assistant.py 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345
  1. """
  2. agent67.core.assistant — lambda 的大脑 🐑 (v2)
  3. v2 升级:
  4. - 使用 lambdagent 内置 21 工具(替代手写 6 工具)
  5. - ToolGateway 安全网关(替代手写 safety.py)
  6. - Hook 系统全局审计
  7. - ContextManager 防状态爆炸
  8. - 保留 macOS 专属工具(browser, app, system, screenshot)
  9. Lambda 表达式:
  10. lambda = Memory(Loop(Brain >> parse_action >> route_execute))
  11. """
  12. from __future__ import annotations
  13. import json
  14. import re
  15. import sys
  16. import os
  17. from pathlib import Path
  18. from typing import Any
  19. # 路径设置
  20. PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent.parent
  21. sys.path.insert(0, str(PROJECT_ROOT))
  22. from lambdagent import Lam, Tool, Loop, Context
  23. from lambdagent.extensions import Memory, Guard
  24. from lambdagent.context_manager import ContextManager
  25. from lambdagent.hooks import HookRegistry
  26. # 内置工具
  27. from lambdagent.builtin_tools.registry import BUILTIN_TOOLS, resolve_tools
  28. from lambdagent.builtin_tools.terminal_ui import TerminalUI
  29. from .claude_lam import ClaudeLam
  30. from .ollama_lam import OllamaLam
  31. from .config import BACKEND_OLLAMA, BACKEND_CLAUDE_CODE, BACKEND_API
  32. from .prompt import SYSTEM_PROMPT
  33. # macOS 专属工具(保留)
  34. from ..tools.browser_controller import control_browser
  35. from ..tools.app_controller import control_app
  36. from ..tools.system_info import query_system
  37. from ..tools.screenshot import take_screenshot
  38. # ════════════════════════════════════════════════════════════
  39. # 工具注册表 (v2: 内置工具 + macOS 工具)
  40. # ════════════════════════════════════════════════════════════
  41. def _build_tool_registry() -> dict:
  42. """合并内置工具 + macOS 专属工具"""
  43. # 内置 21 个工具
  44. tools = dict(BUILTIN_TOOLS)
  45. # macOS 专属(保留原有能力)
  46. tools["browser"] = Tool("browser", control_browser)
  47. tools["app"] = Tool("app", control_app)
  48. tools["system"] = Tool("system", query_system)
  49. tools["screenshot"] = Tool("screenshot", take_screenshot)
  50. # 完成信号
  51. tools["done"] = Tool("done", lambda x: x)
  52. return tools
  53. TOOL_REGISTRY = _build_tool_registry()
  54. # ════════════════════════════════════════════════════════════
  55. # 解析 & 执行引擎 (v2)
  56. # ════════════════════════════════════════════════════════════
  57. def parse_and_execute(llm_output: str, hooks: HookRegistry = None) -> tuple[str, bool]:
  58. """
  59. 解析 LLM 输出,提取工具调用并执行。
  60. v2: 统一 action/tool 格式,支持内置工具 + macOS 工具
  61. """
  62. # 尝试从 ```json ... ``` 代码块提取
  63. matches = re.findall(r'```json\s*\n?(.*?)\n?```', llm_output, re.DOTALL)
  64. if not matches:
  65. matches = re.findall(r'\{[^{}]*(?:"action"|"tool")\s*:.*?\}', llm_output, re.DOTALL)
  66. if not matches:
  67. return llm_output, False
  68. json_str = matches[-1].strip()
  69. try:
  70. data = json.loads(json_str)
  71. except json.JSONDecodeError:
  72. return f"(无法解析 JSON: {json_str[:100]})\n{llm_output}", False
  73. # 统一格式: action/tool 都支持
  74. tool_name = data.get("action", data.get("tool", ""))
  75. # 完成信号
  76. if tool_name in ("done", "terminate"):
  77. answer = data.get("summary", data.get("input", {}).get("answer", "")) if isinstance(data.get("input"), dict) else data.get("summary", "任务完成")
  78. return str(answer) if answer else "任务完成", True
  79. # 路由到工具
  80. tool = TOOL_REGISTRY.get(tool_name)
  81. if not tool:
  82. return f"❌ 未知工具: {tool_name}. 可用: {', '.join(sorted(TOOL_REGISTRY.keys())[:15])}...", False
  83. # 准备输入
  84. tool_input = data.get("input", {})
  85. if not tool_input:
  86. # 兼容旧格式: {"tool": "shell", "command": "ls"} → input = {"command": "ls"}
  87. tool_input = {k: v for k, v in data.items() if k not in ("action", "tool")}
  88. if isinstance(tool_input, dict):
  89. tool_input_str = json.dumps(tool_input, ensure_ascii=False)
  90. else:
  91. tool_input_str = str(tool_input)
  92. # Hook: pre_tool
  93. if hooks:
  94. hooks.fire("pre_tool", term=tool, input=tool_input_str, ctx=None)
  95. # 执行
  96. import time
  97. t0 = time.time()
  98. try:
  99. if hasattr(tool, 'apply'):
  100. result = tool.apply(tool_input_str)
  101. else:
  102. result = tool(tool_input_str)
  103. except Exception as e:
  104. result = f"[ERROR] {e}"
  105. duration_ms = (time.time() - t0) * 1000
  106. # Hook: post_tool
  107. if hooks:
  108. output_wrapper = {"value": result}
  109. hooks.fire("post_tool", term=tool, input=tool_input_str,
  110. output=output_wrapper, duration_ms=duration_ms, ctx=None)
  111. result = output_wrapper["value"]
  112. return str(result), False
  113. # ════════════════════════════════════════════════════════════
  114. # PersonalAssistant v2
  115. # ════════════════════════════════════════════════════════════
  116. class PersonalAssistant:
  117. """
  118. lambda 个人助理 v2 = Memory(ReAct(Brain)) + 21 内置工具 + Hook
  119. 新增能力:
  120. - 21 个内置工具 (文件/代码/Shell/Git/Web/Notebook/Task)
  121. - ToolGateway 安全网关
  122. - Hook 全局审计
  123. - ContextManager 上下文压缩
  124. - TerminalUI 流式显示
  125. """
  126. def __init__(self, model: str = "sonnet", use_api: bool = False,
  127. backend: str = "", verbose: bool = False):
  128. # Brain (LLM)
  129. if backend == BACKEND_OLLAMA:
  130. self.brain = OllamaLam(
  131. "lambda_v2", prompt=SYSTEM_PROMPT,
  132. model=model, temperature=0.3, max_tokens=4096,
  133. )
  134. elif use_api or backend == BACKEND_API:
  135. self.brain = Lam(
  136. "lambda_v2", prompt=SYSTEM_PROMPT,
  137. model=model, temperature=0.3, max_tokens=4096,
  138. )
  139. else:
  140. self.brain = ClaudeLam(
  141. "lambda_v2", prompt=SYSTEM_PROMPT,
  142. model=model, max_tokens=4096,
  143. )
  144. self.ctx = Context()
  145. self.conversation_history: list[dict] = []
  146. self.max_history = 30
  147. # v2 新增
  148. self.hooks = HookRegistry()
  149. self.context_manager = ContextManager(max_tokens=100000, keep_recent=5)
  150. self.ui = TerminalUI(verbose=verbose)
  151. # 注册审计 hook
  152. self._total_tokens = 0
  153. self._total_tool_calls = 0
  154. self.hooks.register("post_tool", self._audit_tool)
  155. def _audit_tool(self, **kwargs):
  156. """全局工具调用审计"""
  157. self._total_tool_calls += 1
  158. def _build_input(self, user_msg: str, observations: list[str] | None = None) -> str:
  159. """构建完整输入(历史 + 消息 + 工具结果)"""
  160. parts = []
  161. # 对话历史
  162. if self.conversation_history:
  163. parts.append("=== 对话历史 ===")
  164. for entry in self.conversation_history[-self.max_history:]:
  165. content = entry["content"]
  166. if len(content) > 300:
  167. content = content[:300] + "..."
  168. parts.append(f"[{entry['role']}] {content}")
  169. parts.append("=== 历史结束 ===\n")
  170. # 工具观察
  171. if observations:
  172. parts.append("=== 工具执行结果 ===")
  173. for obs in observations:
  174. parts.append(obs)
  175. parts.append("=== 结果结束 ===\n")
  176. parts.append("请基于以上工具执行结果,决定下一步行动或给出最终回复。")
  177. else:
  178. parts.append(f"[用户] {user_msg}")
  179. state = "\n".join(parts)
  180. # v2: 上下文压缩
  181. if self.context_manager.should_compact(state):
  182. state = self.context_manager.compact(state)
  183. return state
  184. def chat(self, user_msg: str) -> str:
  185. """
  186. 与 lambda 对话。完整 ReAct 循环 (v2 流式交互)。
  187. """
  188. self.conversation_history.append({"role": "用户", "content": user_msg})
  189. observations = []
  190. max_steps = 15
  191. final_response = ""
  192. import time as _time
  193. for step in range(max_steps):
  194. # 显示当前步骤状态
  195. _step_label = f"[步骤 {step + 1}/{max_steps}]"
  196. # 构建输入
  197. if step == 0:
  198. llm_input = self._build_input(user_msg)
  199. else:
  200. llm_input = self._build_input(user_msg, observations)
  201. # 显示思考状态(如果不是流式模式,显示 spinner)
  202. is_streaming = hasattr(self.brain, 'stream') and self.brain.stream
  203. if not is_streaming:
  204. print(f" ⏳ {_step_label} 思考中...", end="\r", flush=True)
  205. # Brain 思考 (β-规约) — 流式模式下 ClaudeLam 会实时输出
  206. t0 = _time.time()
  207. llm_output = self.brain.apply(llm_input, self.ctx)
  208. think_ms = (_time.time() - t0) * 1000
  209. if not is_streaming:
  210. # 清除 spinner
  211. print(f" ✅ {_step_label} 思考完成 ({think_ms:.0f}ms) ")
  212. # 解析并执行 (v2: 支持内置工具 + hooks)
  213. result, is_done = parse_and_execute(str(llm_output), self.hooks)
  214. if is_done:
  215. text_part = re.sub(r'```json.*?```', '', str(llm_output), flags=re.DOTALL).strip()
  216. final_response = text_part + ("\n" + result if result else "")
  217. print(f" ✅ {_step_label} 任务完成")
  218. break
  219. if result != str(llm_output):
  220. # 工具被执行
  221. text_part = re.sub(r'```json.*?```', '', str(llm_output), flags=re.DOTALL).strip()
  222. json_matches = re.findall(r'\{[^{}]*(?:"action"|"tool")\s*:.*?\}', str(llm_output))
  223. tool_call = json_matches[-1] if json_matches else ""
  224. tool_name = ""
  225. try:
  226. tool_name = json.loads(tool_call).get("action", json.loads(tool_call).get("tool", ""))
  227. except Exception:
  228. pass
  229. # 显示思考内容
  230. if text_part and not is_streaming:
  231. print(f" 💭 {text_part[:200]}")
  232. # 显示工具调用(带进度)
  233. t0_tool = _time.time()
  234. print(f" 🔧 {_step_label} 调用工具: {tool_name or 'unknown'}")
  235. # 工具输入预览
  236. try:
  237. tool_input_data = json.loads(tool_call).get("input", {})
  238. if isinstance(tool_input_data, dict):
  239. input_preview = json.dumps(tool_input_data, ensure_ascii=False)[:120]
  240. else:
  241. input_preview = str(tool_input_data)[:120]
  242. print(f" 输入: {input_preview}")
  243. except Exception:
  244. pass
  245. tool_ms = (_time.time() - t0_tool) * 1000
  246. # 工具结果预览
  247. result_preview = result[:300].replace("\n", "\n ")
  248. print(f" 结果: {result_preview}")
  249. print()
  250. observations.append(f"[工具调用] {tool_call}\n[执行结果] {result}")
  251. else:
  252. # 纯文本回复(流式模式下已经显示过了)
  253. if not is_streaming:
  254. final_response = str(llm_output)
  255. else:
  256. final_response = str(llm_output)
  257. break
  258. else:
  259. final_response = f"(达到最大步数 {max_steps})\n最后的观察:\n" + (
  260. observations[-1] if observations else "无"
  261. )
  262. self.conversation_history.append({
  263. "role": "lambda",
  264. "content": final_response[:500],
  265. })
  266. return final_response
  267. def print_trace(self):
  268. """打印 β-规约追踪 (v2: 使用 TerminalUI)"""
  269. if self.ctx.trace:
  270. self.ui.trace(self.ctx.trace)
  271. else:
  272. print(" (无追踪记录)")
  273. def print_stats(self):
  274. """打印会话统计"""
  275. print(f"\n📊 会话统计:")
  276. print(f" β-规约步数: {len(self.ctx.trace)}")
  277. print(f" 工具调用数: {self._total_tool_calls}")
  278. print(f" 对话轮数: {len(self.conversation_history) // 2}")