JiuContinent/company-ai-platform
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

```

Browse Source 
feat(ai_agent): 完善AI适配器和服务功能

- 添加OpenClaw和Hermes健康检查接口
- 实现OpenClaw工具调用功能
- 重构AI适配器使用常量定义
- 增加AI技能系统支持
- 更新配置文件中的默认模型提供者设置

refactor(scheduler): 使用常量替换硬编码值

- 将硬编码的actor值替换为ActorValue常量
- 将receive_id_type替换为FeishuReceiveIdType枚举

refactor(audit): 统一审计日志常量使用

- 将硬编码的actor、source、risk_level等值替换为对应常量
- 更新审核服务中的状态和操作常量引用

refactor(approvals): 标准化审批模块常量使用

- 将applicant默认值替换为ActorValue.API常量
- 使用ApprovalStatus常量替代硬编码状态值
- 更新审核操作常量引用
```
This commit is contained in:
JiuContinent
2026-07-06 00:02:03 +08:00
parent d82116d637
commit aa81fc5321
36 changed files with 2328 additions and 337 deletions
Download Patch File Download Diff File Expand all files Collapse all files

368
app/modules/ai_agent/adapters.py
View File

@@ -5,6 +5,28 @@ import httpx
from fastapi import HTTPException
from app.core.config import Settings, get_settings
from app.modules.ai_agent.constants import (
AUTHORIZATION_BEARER_TEMPLATE,
CHAT_USER_CONTENT_TEMPLATE,
COMPANY_MANAGEMENT_SYSTEM_INSTRUCTIONS,
DIRECT_LLM_API_KEY_MISSING,
NOOP_PROVIDER_ANSWER,
OPENCLAW_HERMES_PIPELINE,
OPENCLAW_TOOL_COMPLETED_ANSWER,
UNEXPECTED_HERMES_RESPONSE,
AIDefault,
AIChatRole,
AIContextKey,
AIErrorKey,
AIHttpHeader,
AIHttpPath,
AIHttpPayloadKey,
AIMemoryMode,
AIProviderName,
AIRequestKey,
AIResponseKey,
)
from app.modules.ai_agent.skills import AISkillId, get_ai_skill
class AIAdapter(ABC):
@@ -20,67 +42,163 @@ class AIAdapter(ABC):
class NoopAdapter(AIAdapter):
"""Deterministic adapter used when no model provider is configured."""
provider_name = "noop"
provider_name = AIProviderName.NOOP
def ask(self, prompt: str, context: dict[str, Any] | None = None) -> dict[str, Any]:
return {
"answer": (
"AI provider is not configured yet. This is a deterministic placeholder. "
"Set MODEL_PROVIDER to openclaw_hermes, openclaw, hermes, or direct_llm "
"after credentials are ready."
),
"raw": {"prompt": prompt, "context": context or {}},
AIResponseKey.ANSWER: NOOP_PROVIDER_ANSWER,
AIResponseKey.RAW: {
AIRequestKey.PROMPT: prompt,
AIRequestKey.CONTEXT: context or {},
},
}
class OpenClawAdapter(AIAdapter):
"""Adapter for an OpenClaw-compatible agent endpoint."""
"""Adapter for the OpenClaw Gateway control-plane API."""
provider_name = "openclaw"
provider_name = AIProviderName.OPENCLAW
def __init__(self, settings: Settings):
self.settings = settings
def ask(self, prompt: str, context: dict[str, Any] | None = None) -> dict[str, Any]:
url = f"{self.settings.openclaw_base_url.rstrip('/')}/api/v1/agent/ask"
headers = {}
if self.settings.openclaw_api_key:
headers["Authorization"] = f"Bearer {self.settings.openclaw_api_key}"
payload = {"prompt": prompt, "context": context or {}}
with httpx.Client(timeout=60) as client:
response = client.post(url, json=payload, headers=headers)
context = context or {}
tool = context.get(AIContextKey.OPENCLAW_TOOL)
if not tool:
raise HTTPException(
status_code=400,
detail=(
"OpenClaw Gateway is not configured as a chat provider. "
"Provide context.openclaw_tool for /tools/invoke, or use "
"MODEL_PROVIDER=hermes/openclaw_hermes for AI answers."
),
)
result = self.invoke_tool(
tool=str(tool),
action=str(context.get(AIContextKey.OPENCLAW_ACTION) or AIDefault.ACTION_JSON),
args=context.get(AIContextKey.OPENCLAW_ARGS) or {},
session_key=str(
context.get(AIContextKey.OPENCLAW_SESSION_KEY) or AIDefault.SESSION_KEY_MAIN
),
)
return {
AIResponseKey.ANSWER: OPENCLAW_TOOL_COMPLETED_ANSWER,
AIResponseKey.RAW: result,
}
def health(self) -> dict[str, Any]:
"""Check OpenClaw Gateway health endpoints."""
headers = self._headers()
base_url = self._base_url()
with httpx.Client(timeout=5, trust_env=False) as client:
healthz = client.get(f"{base_url}{AIHttpPath.HEALTHZ}", headers=headers)
readyz = client.get(f"{base_url}{AIHttpPath.READYZ}", headers=headers)
return {
AIResponseKey.OK: healthz.status_code < 400 and readyz.status_code < 400,
AIResponseKey.BASE_URL: base_url,
AIResponseKey.HEALTHZ: _response_payload(healthz),
AIResponseKey.READYZ: _response_payload(readyz),
}
def invoke_tool(
self,
tool: str,
action: str = AIDefault.ACTION_JSON,
args: dict[str, Any] | None = None,
session_key: str = AIDefault.SESSION_KEY_MAIN,
) -> dict[str, Any]:
"""Invoke one OpenClaw Gateway tool through `/tools/invoke`."""
payload = {
AIHttpPayloadKey.TOOL: tool,
AIHttpPayloadKey.ACTION: action,
AIHttpPayloadKey.ARGS: args or {},
AIHttpPayloadKey.SESSION_KEY: session_key,
}
url = f"{self._base_url()}{AIHttpPath.TOOLS_INVOKE}"
with httpx.Client(timeout=120, trust_env=False) as client:
response = client.post(url, json=payload, headers=self._headers())
if response.status_code >= 400:
raise HTTPException(status_code=502, detail={"openclaw_error": response.text})
data = response.json()
return {"answer": data.get("answer") or data.get("content") or str(data), "raw": data}
raise HTTPException(status_code=502, detail={AIErrorKey.OPENCLAW: response.text})
return _response_payload(response)
def _base_url(self) -> str:
return (self.settings.openclaw_http_url or self.settings.openclaw_base_url).rstrip("/")
def _headers(self) -> dict[str, str]:
token = self.settings.openclaw_gateway_token or self.settings.openclaw_api_key
if not token:
return {}
return {
AIHttpHeader.AUTHORIZATION: AUTHORIZATION_BEARER_TEMPLATE.format(token=token)
}
class HermesAdapter(AIAdapter):
"""Adapter for a Hermes-compatible memory or agent endpoint."""
"""Adapter for the Hermes OpenAI-compatible agent endpoint."""
provider_name = "hermes"
provider_name = AIProviderName.HERMES
def __init__(self, settings: Settings):
self.settings = settings
def ask(self, prompt: str, context: dict[str, Any] | None = None) -> dict[str, Any]:
url = f"{self.settings.hermes_base_url.rstrip('/')}/api/v1/ask"
url = f"{self.settings.hermes_base_url.rstrip('/')}{AIHttpPath.CHAT_COMPLETIONS}"
headers = {}
if self.settings.hermes_api_key:
headers["Authorization"] = f"Bearer {self.settings.hermes_api_key}"
payload = {"prompt": prompt, "context": context or {}}
with httpx.Client(timeout=60) as client:
headers[AIHttpHeader.AUTHORIZATION] = AUTHORIZATION_BEARER_TEMPLATE.format(
token=self.settings.hermes_api_key
)
if self.settings.hermes_session_id:
headers[AIHttpHeader.HERMES_SESSION_ID] = self.settings.hermes_session_id
payload = {
AIHttpPayloadKey.MODEL: self.settings.hermes_model,
AIHttpPayloadKey.MESSAGES: _chat_messages(prompt, context),
AIHttpPayloadKey.STREAM: False,
}
with httpx.Client(timeout=300, trust_env=False) as client:
response = client.post(url, json=payload, headers=headers)
if response.status_code >= 400:
raise HTTPException(status_code=502, detail={"hermes_error": response.text})
raise HTTPException(status_code=502, detail={AIErrorKey.HERMES: response.text})
data = response.json()
return {"answer": data.get("answer") or data.get("content") or str(data), "raw": data}
try:
answer = data[AIHttpPayloadKey.CHOICES][0][AIHttpPayloadKey.MESSAGE][
AIHttpPayloadKey.CONTENT
]
except (KeyError, IndexError, TypeError) as exc:
raise HTTPException(
status_code=502,
detail={
AIErrorKey.HERMES: UNEXPECTED_HERMES_RESPONSE,
AIResponseKey.RAW: data,
},
) from exc
return {AIResponseKey.ANSWER: answer, AIResponseKey.RAW: data}
def health(self) -> dict[str, Any]:
"""Check Hermes Agent health without triggering a chat completion."""
url = f"{_service_root(self.settings.hermes_base_url, AIHttpPath.V1)}{AIHttpPath.HEALTH}"
headers = {}
if self.settings.hermes_api_key:
headers[AIHttpHeader.AUTHORIZATION] = AUTHORIZATION_BEARER_TEMPLATE.format(
token=self.settings.hermes_api_key
)
with httpx.Client(timeout=5, trust_env=False) as client:
response = client.get(url, headers=headers)
return {
AIResponseKey.OK: response.status_code < 400,
AIResponseKey.BASE_URL: self.settings.hermes_base_url.rstrip("/"),
AIResponseKey.HEALTH: _response_payload(response),
}
class OpenClawHermesAdapter(AIAdapter):
"""Compose Hermes memory with OpenClaw execution."""
"""Compose OpenClaw Gateway context with Hermes Agent answers."""
provider_name = "openclaw_hermes"
provider_name = AIProviderName.OPENCLAW_HERMES
def __init__(self, settings: Settings):
self.openclaw = OpenClawAdapter(settings)
@@ -89,40 +207,80 @@ class OpenClawHermesAdapter(AIAdapter):
def ask(self, prompt: str, context: dict[str, Any] | None = None) -> dict[str, Any]:
base_context = context or {}
recall = self._recall_memory(prompt, base_context)
openclaw_context = {
openclaw = self._openclaw_context(base_context)
hermes_context = {
**base_context,
"agent_pipeline": self.provider_name,
"hermes_memory": recall["answer"],
AIContextKey.AGENT_PIPELINE: self.provider_name,
AIContextKey.HERMES_MEMORY: recall[AIResponseKey.ANSWER],
AIContextKey.OPENCLAW: openclaw,
}
openclaw_result = self.openclaw.ask(prompt, openclaw_context)
remember = self._remember_interaction(prompt, base_context, openclaw_result["answer"])
hermes_result = self.hermes.ask(prompt, hermes_context)
remember = self._remember_interaction(
prompt,
base_context,
hermes_result[AIResponseKey.ANSWER],
)
return {
"answer": openclaw_result["answer"],
"raw": {
"pipeline": "hermes_recall -> openclaw_answer -> hermes_remember",
"hermes_recall": recall,
"openclaw": openclaw_result.get("raw", {}),
"hermes_remember": remember,
AIResponseKey.ANSWER: hermes_result[AIResponseKey.ANSWER],
AIResponseKey.RAW: {
AIResponseKey.PIPELINE: OPENCLAW_HERMES_PIPELINE,
AIResponseKey.HERMES_RECALL: recall,
AIResponseKey.OPENCLAW: openclaw,
AIResponseKey.HERMES_ANSWER: hermes_result.get(AIResponseKey.RAW, {}),
AIResponseKey.HERMES_REMEMBER: remember,
},
}
def _openclaw_context(self, context: dict[str, Any]) -> dict[str, Any]:
result: dict[str, Any] = {AIResponseKey.TOOL_INVOKED: False}
try:
result[AIResponseKey.HEALTH] = self.openclaw.health()
except Exception as exc:
result[AIResponseKey.HEALTH] = {
AIResponseKey.OK: False,
AIResponseKey.ERROR: _error_detail(exc),
}
tool = context.get(AIContextKey.OPENCLAW_TOOL)
if not tool:
return result
try:
result[AIResponseKey.TOOL_INVOKED] = True
result[AIResponseKey.TOOL] = self.openclaw.invoke_tool(
tool=str(tool),
action=str(context.get(AIContextKey.OPENCLAW_ACTION) or AIDefault.ACTION_JSON),
args=context.get(AIContextKey.OPENCLAW_ARGS) or {},
session_key=str(
context.get(AIContextKey.OPENCLAW_SESSION_KEY)
or AIDefault.SESSION_KEY_MAIN
),
)
except Exception as exc:
result[AIResponseKey.TOOL_ERROR] = _error_detail(exc)
return result
def _recall_memory(self, prompt: str, context: dict[str, Any]) -> dict[str, Any]:
recall_prompt = (
"Retrieve concise long-term memory, preferences, prior decisions, and relevant "
"business context for this request. Return only information useful to answer it."
)
recall_skill = get_ai_skill(AISkillId.HERMES_MEMORY_RECALL)
try:
result = self.hermes.ask(
recall_prompt,
recall_skill.render(),
{
"mode": "memory_recall",
"user_prompt": prompt,
"request_context": context,
AIContextKey.MODE: AIMemoryMode.RECALL,
AIContextKey.USER_PROMPT: prompt,
AIContextKey.REQUEST_CONTEXT: context,
},
)
except Exception as exc: # Hermes memory should not block OpenClaw execution.
return {"answer": "", "raw": {}, "error": _error_detail(exc)}
return {"answer": result["answer"], "raw": result.get("raw", {})}
return {
AIResponseKey.ANSWER: "",
AIResponseKey.RAW: {},
AIResponseKey.ERROR: _error_detail(exc),
}
return {
AIResponseKey.ANSWER: result[AIResponseKey.ANSWER],
AIResponseKey.RAW: result.get(AIResponseKey.RAW, {}),
}
def _remember_interaction(
self,
@@ -130,56 +288,60 @@ class OpenClawHermesAdapter(AIAdapter):
context: dict[str, Any],
answer: str,
) -> dict[str, Any]:
remember_prompt = (
"Store durable lessons from this interaction for future company management "
"assistance. Ignore transient details and do not store secrets."
)
remember_skill = get_ai_skill(AISkillId.HERMES_MEMORY_WRITE)
try:
result = self.hermes.ask(
remember_prompt,
remember_skill.render(),
{
"mode": "memory_write",
"user_prompt": prompt,
"request_context": context,
"assistant_answer": answer,
AIContextKey.MODE: AIMemoryMode.WRITE,
AIContextKey.USER_PROMPT: prompt,
AIContextKey.REQUEST_CONTEXT: context,
AIContextKey.ASSISTANT_ANSWER: answer,
},
)
except Exception as exc:
return {"ok": False, "raw": {}, "error": _error_detail(exc)}
return {"ok": True, "raw": result.get("raw", {}), "answer": result["answer"]}
return {
AIResponseKey.OK: False,
AIResponseKey.RAW: {},
AIResponseKey.ERROR: _error_detail(exc),
}
return {
AIResponseKey.OK: True,
AIResponseKey.RAW: result.get(AIResponseKey.RAW, {}),
AIResponseKey.ANSWER: result[AIResponseKey.ANSWER],
}
class DirectLLMAdapter(AIAdapter):
"""Adapter for OpenAI-compatible chat completions APIs."""
provider_name = "direct_llm"
provider_name = AIProviderName.DIRECT_LLM
def __init__(self, settings: Settings):
self.settings = settings
def ask(self, prompt: str, context: dict[str, Any] | None = None) -> dict[str, Any]:
if not self.settings.direct_llm_api_key:
raise HTTPException(status_code=503, detail="DIRECT_LLM_API_KEY is not configured")
url = f"{self.settings.direct_llm_base_url.rstrip('/')}/chat/completions"
headers = {"Authorization": f"Bearer {self.settings.direct_llm_api_key}"}
messages = [
{
"role": "system",
"content": (
"You are a company management AI. Be concise, cite data from context, "
"and never approve payments, performance changes, or trades automatically."
),
},
{"role": "user", "content": f"Context:\n{context or {}}\n\nTask:\n{prompt}"},
]
payload = {"model": self.settings.direct_llm_model, "messages": messages}
with httpx.Client(timeout=60) as client:
raise HTTPException(status_code=503, detail=DIRECT_LLM_API_KEY_MISSING)
url = f"{self.settings.direct_llm_base_url.rstrip('/')}{AIHttpPath.CHAT_COMPLETIONS}"
headers = {
AIHttpHeader.AUTHORIZATION: AUTHORIZATION_BEARER_TEMPLATE.format(
token=self.settings.direct_llm_api_key
)
}
payload = {
AIHttpPayloadKey.MODEL: self.settings.direct_llm_model,
AIHttpPayloadKey.MESSAGES: _chat_messages(prompt, context),
}
with httpx.Client(timeout=60, trust_env=False) as client:
response = client.post(url, json=payload, headers=headers)
if response.status_code >= 400:
raise HTTPException(status_code=502, detail={"llm_error": response.text})
raise HTTPException(status_code=502, detail={AIErrorKey.DIRECT_LLM: response.text})
data = response.json()
answer = data["choices"][0]["message"]["content"]
return {"answer": answer, "raw": data}
answer = data[AIHttpPayloadKey.CHOICES][0][AIHttpPayloadKey.MESSAGE][
AIHttpPayloadKey.CONTENT
]
return {AIResponseKey.ANSWER: answer, AIResponseKey.RAW: data}
def get_adapter() -> AIAdapter:
@@ -187,13 +349,17 @@ def get_adapter() -> AIAdapter:
settings = get_settings()
provider = settings.model_provider.lower()
if provider == "openclaw":
if provider == AIProviderName.OPENCLAW:
return OpenClawAdapter(settings)
if provider == "hermes":
if provider == AIProviderName.HERMES:
return HermesAdapter(settings)
if provider in {"openclaw_hermes", "openclaw-hermes", "hybrid"}:
if provider in {
AIProviderName.OPENCLAW_HERMES,
AIProviderName.OPENCLAW_HERMES_DASH,
AIProviderName.HYBRID,
}:
return OpenClawHermesAdapter(settings)
if provider == "direct_llm":
if provider == AIProviderName.DIRECT_LLM:
return DirectLLMAdapter(settings)
return NoopAdapter()
@@ -201,4 +367,36 @@ def get_adapter() -> AIAdapter:
def _error_detail(exc: Exception) -> Any:
if isinstance(exc, HTTPException):
return exc.detail
return {"type": type(exc).__name__, "message": str(exc)}
return {AIResponseKey.TYPE: type(exc).__name__, AIResponseKey.MESSAGE: str(exc)}
def _response_payload(response: httpx.Response) -> dict[str, Any]:
try:
data = response.json()
except ValueError:
data = {AIResponseKey.TEXT: response.text}
return {AIResponseKey.STATUS_CODE: response.status_code, AIResponseKey.DATA: data}
def _chat_messages(prompt: str, context: dict[str, Any] | None = None) -> list[dict[str, str]]:
return [
{
AIHttpPayloadKey.ROLE: AIChatRole.SYSTEM,
AIHttpPayloadKey.CONTENT: COMPANY_MANAGEMENT_SYSTEM_INSTRUCTIONS,
},
{
AIHttpPayloadKey.ROLE: AIChatRole.USER,
AIHttpPayloadKey.CONTENT: CHAT_USER_CONTENT_TEMPLATE.format(
context=context or {},
task=prompt,
),
},
]
def _service_root(base_url: str, suffix: str) -> str:
root = base_url.rstrip("/")
normalized_suffix = suffix.rstrip("/")
if root.endswith(normalized_suffix):
root = root[: -len(normalized_suffix)]
return root.rstrip("/")