engine.py 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295
  1. # app/services/agent/engine.py
  2. import json
  3. import uuid
  4. import asyncio
  5. from typing import AsyncGenerator, Dict, Any, List, Optional
  6. from sqlalchemy.ext.asyncio import AsyncSession
  7. from redis.asyncio import Redis
  8. from app.core.logger import logger
  9. from app.models.user import VasUser
  10. from app.schemas.agent import (
  11. AgentChatRequest,
  12. AgentChatResponse,
  13. AgentToolCallStep,
  14. )
  15. from app.services.llm_service import LlmService
  16. from app.services.agent.memory import AgentMemory
  17. from app.services.agent.tools.registry import tool_registry
  18. # 自动加载内置业务工具
  19. import app.services.agent.tools.builtin # noqa: F401
  20. SYSTEM_PROMPT = """你是一个专业的智能业务助理,具备自主调用系统后端工具(Tools)的能力。
  21. 你可以根据用户的自然语言需求,自主规划并按顺序调用相关工具来完成查询、数据检索或操作任务。
  22. 【行为规范与准则】:
  23. 1. 遇到需要查询、修改、统计具体业务数据时,必须调用对应的工具获取真实结果,禁止凭空捏造数据或订单状态。
  24. 2. 若用户需要执行操作(如取消订单),请先确认订单状态及所需参数,必要时先查询详情再执行操作。
  25. 3. 如果工具返回错误或未查到结果,请友好告知用户原因或提出可能的解决建议。
  26. 4. 工具调用完成后,请用清晰、结构化、自然的语言向用户总结执行结果。
  27. 5. 回答始终保持礼貌、高效与专业。"""
  28. class AgentEngine:
  29. """Agent 核心编排引擎,支持 ReAct 循环与 SSE 流式输出"""
  30. @classmethod
  31. def _format_sse(cls, event: str, data: Dict[str, Any]) -> str:
  32. return f"event: {event}\ndata: {json.dumps(data, ensure_ascii=False)}\n\n"
  33. @classmethod
  34. async def run_sync(
  35. cls,
  36. request: AgentChatRequest,
  37. current_user: VasUser,
  38. db: AsyncSession,
  39. redis_client: Optional[Redis] = None,
  40. ) -> AgentChatResponse:
  41. """同步执行 Agent 对话并返回完整结果"""
  42. session_id = request.session_id or f"sess_{uuid.uuid4().hex[:12]}"
  43. history = await AgentMemory.get_history(session_id, max_messages=10)
  44. tools_schema = tool_registry.get_openai_tools_schema()
  45. context = {
  46. "db": db,
  47. "current_user": current_user,
  48. "redis_client": redis_client,
  49. }
  50. # 组装本轮执行的消息列表
  51. messages: List[Dict[str, Any]] = [
  52. {"role": "system", "content": SYSTEM_PROMPT},
  53. ]
  54. # 追加历史对话
  55. messages.extend(history)
  56. # 追加当前用户输入
  57. user_msg = {"role": "user", "content": request.message}
  58. messages.append(user_msg)
  59. # 用于持久化到 Redis 的增量消息
  60. new_history_messages: List[Dict[str, Any]] = [user_msg]
  61. steps_record: List[AgentToolCallStep] = []
  62. step = 0
  63. final_answer = ""
  64. while step < request.max_steps:
  65. step += 1
  66. logger.info(f"[AgentEngine] Step {step}/{request.max_steps} calling LLM (session={session_id})...")
  67. llm_reply = await LlmService.chat_completion_with_tools_async(
  68. messages=messages,
  69. tools=tools_schema if tools_schema else None,
  70. model=request.model,
  71. )
  72. tool_calls = llm_reply.get("tool_calls")
  73. content = llm_reply.get("content") or ""
  74. if not tool_calls:
  75. # LLM 没有触发工具调用,直接作为最终答案返回
  76. final_answer = content
  77. assistant_msg = {"role": "assistant", "content": final_answer}
  78. new_history_messages.append(assistant_msg)
  79. break
  80. # 处理工具调用
  81. assistant_call_msg = {
  82. "role": "assistant",
  83. "content": content,
  84. "tool_calls": tool_calls,
  85. }
  86. messages.append(assistant_call_msg)
  87. new_history_messages.append(assistant_call_msg)
  88. for call in tool_calls:
  89. fn_info = call.get("function", {})
  90. tool_name = fn_info.get("name", "")
  91. raw_args = fn_info.get("arguments", "{}")
  92. call_id = call.get("id", f"call_{uuid.uuid4().hex[:8]}")
  93. try:
  94. args = json.loads(raw_args) if isinstance(raw_args, str) else raw_args
  95. except Exception:
  96. args = {}
  97. logger.info(f"[AgentEngine] Invoking tool: {tool_name} with args: {args}")
  98. tool_result = await tool_registry.execute(tool_name, args, context=context)
  99. is_error = isinstance(tool_result, dict) and "error" in tool_result
  100. steps_record.append(
  101. AgentToolCallStep(
  102. tool=tool_name,
  103. arguments=args,
  104. result=tool_result,
  105. is_error=is_error,
  106. )
  107. )
  108. tool_reply_msg = {
  109. "role": "tool",
  110. "tool_call_id": call_id,
  111. "name": tool_name,
  112. "content": json.dumps(tool_result, ensure_ascii=False),
  113. }
  114. messages.append(tool_reply_msg)
  115. new_history_messages.append(tool_reply_msg)
  116. if not final_answer and step >= request.max_steps:
  117. # 达到最大步数未停止,强制做一次总结
  118. summary_reply = await LlmService.chat_completion_with_tools_async(
  119. messages=messages + [{"role": "user", "content": "请根据以上所有工具执行结果,做最终汇总回答。"}],
  120. tools=None,
  121. model=request.model,
  122. )
  123. final_answer = summary_reply.get("content", "已完成操作处理。")
  124. new_history_messages.append({"role": "assistant", "content": final_answer})
  125. # 持久化更新历史记录到 Redis
  126. await AgentMemory.append_messages(session_id, new_history_messages)
  127. return AgentChatResponse(
  128. session_id=session_id,
  129. answer=final_answer,
  130. steps=steps_record,
  131. steps_count=len(steps_record),
  132. )
  133. @classmethod
  134. async def run_stream(
  135. cls,
  136. request: AgentChatRequest,
  137. current_user: VasUser,
  138. db: AsyncSession,
  139. redis_client: Optional[Redis] = None,
  140. ) -> AsyncGenerator[str, None]:
  141. """以 SSE 格式流式生成 Agent 运行状态、工具调用过程与最终回答"""
  142. session_id = request.session_id or f"sess_{uuid.uuid4().hex[:12]}"
  143. try:
  144. yield cls._format_sse("think", {"status": "started", "session_id": session_id})
  145. history = await AgentMemory.get_history(session_id, max_messages=10)
  146. tools_schema = tool_registry.get_openai_tools_schema()
  147. context = {
  148. "db": db,
  149. "current_user": current_user,
  150. "redis_client": redis_client,
  151. }
  152. messages: List[Dict[str, Any]] = [
  153. {"role": "system", "content": SYSTEM_PROMPT},
  154. ]
  155. messages.extend(history)
  156. user_msg = {"role": "user", "content": request.message}
  157. messages.append(user_msg)
  158. new_history_messages: List[Dict[str, Any]] = [user_msg]
  159. steps_record: List[AgentToolCallStep] = []
  160. step = 0
  161. final_answer = ""
  162. while step < request.max_steps:
  163. step += 1
  164. yield cls._format_sse("think", {"status": "planning", "step": step})
  165. llm_reply = await LlmService.chat_completion_with_tools_async(
  166. messages=messages,
  167. tools=tools_schema if tools_schema else None,
  168. model=request.model,
  169. )
  170. tool_calls = llm_reply.get("tool_calls")
  171. content = llm_reply.get("content") or ""
  172. reasoning = llm_reply.get("reasoning_content") or ""
  173. if reasoning:
  174. yield cls._format_sse("think", {"status": "reasoning", "reasoning": reasoning, "step": step})
  175. if not tool_calls:
  176. final_answer = content
  177. # 推送最终回复文本
  178. yield cls._format_sse("message", {"delta": final_answer, "full": final_answer})
  179. new_history_messages.append({"role": "assistant", "content": final_answer})
  180. break
  181. # 记录 assistant 的 tool_calls
  182. assistant_call_msg = {
  183. "role": "assistant",
  184. "content": content,
  185. "tool_calls": tool_calls,
  186. }
  187. messages.append(assistant_call_msg)
  188. new_history_messages.append(assistant_call_msg)
  189. for call in tool_calls:
  190. fn_info = call.get("function", {})
  191. tool_name = fn_info.get("name", "")
  192. raw_args = fn_info.get("arguments", "{}")
  193. call_id = call.get("id", f"call_{uuid.uuid4().hex[:8]}")
  194. try:
  195. args = json.loads(raw_args) if isinstance(raw_args, str) else raw_args
  196. except Exception:
  197. args = {}
  198. # 推送 tool_start 事件
  199. yield cls._format_sse("tool_start", {
  200. "tool": tool_name,
  201. "arguments": args,
  202. "call_id": call_id,
  203. })
  204. tool_result = await tool_registry.execute(tool_name, args, context=context)
  205. is_error = isinstance(tool_result, dict) and "error" in tool_result
  206. step_obj = AgentToolCallStep(
  207. tool=tool_name,
  208. arguments=args,
  209. result=tool_result,
  210. is_error=is_error,
  211. )
  212. steps_record.append(step_obj)
  213. # 推送 tool_end 事件
  214. yield cls._format_sse("tool_end", {
  215. "tool": tool_name,
  216. "result": tool_result,
  217. "is_error": is_error,
  218. "call_id": call_id,
  219. })
  220. tool_reply_msg = {
  221. "role": "tool",
  222. "tool_call_id": call_id,
  223. "name": tool_name,
  224. "content": json.dumps(tool_result, ensure_ascii=False),
  225. }
  226. messages.append(tool_reply_msg)
  227. new_history_messages.append(tool_reply_msg)
  228. if not final_answer and step >= request.max_steps:
  229. summary_reply = await LlmService.chat_completion_with_tools_async(
  230. messages=messages + [{"role": "user", "content": "请根据以上所有工具执行结果,做最终汇总回答。"}],
  231. tools=None,
  232. model=request.model,
  233. )
  234. final_answer = summary_reply.get("content", "已完成操作处理。")
  235. yield cls._format_sse("message", {"delta": final_answer, "full": final_answer})
  236. new_history_messages.append({"role": "assistant", "content": final_answer})
  237. # 更新记忆
  238. await AgentMemory.append_messages(session_id, new_history_messages)
  239. # 发送 finish 完成事件
  240. yield cls._format_sse("finish", {
  241. "session_id": session_id,
  242. "answer": final_answer,
  243. "steps_count": len(steps_record),
  244. })
  245. except Exception as e:
  246. logger.error(f"[AgentEngine.stream] error: {e}", exc_info=True)
  247. yield cls._format_sse("error", {"error": str(e)})