agt-agent 0.1.0__py3-none-any.whl

agt_agent-0.1.0.dist-info/METADATA

@@ -0,0 +1,159 @@
+Metadata-Version: 2.4
+Name: agt-agent
+Version: 0.1.0
+Summary: AI Agent 框架——多模型 ReAct 引擎 + MCP 集成 + Coze 工作流 + WebUI + 可视化编辑器
+Author-email: 马建强 <vgp7758@github.com>
+License: MIT
+Project-URL: Homepage, https://github.com/vgp7758/Agt
+Project-URL: Repository, https://github.com/vgp7758/Agt
+Project-URL: Issues, https://github.com/vgp7758/Agt/issues
+Keywords: ai,agent,llm,mcp,workflow,coze
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openai>=1.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: ddgs>=9.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: requests>=2.28.0
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: jedi>=0.19
+Requires-Dist: fastapi>=0.100
+Requires-Dist: uvicorn[standard]>=0.20
+Requires-Dist: websockets>=12.0
+Requires-Dist: python-docx>=0.8
+Requires-Dist: openpyxl>=3.0
+Requires-Dist: PyPDF2>=3.0
+Requires-Dist: pymupdf>=1.23
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21; extra == "dev"
+Dynamic: license-file
+
+# Agt — AI Agent 框架
+
+> 多模型 ReAct 引擎 + MCP 工具 + Coze 工作流 + WebUI + 可视化编辑器。不依赖 LangChain / LlamaIndex / AutoGen，每个模块手写。
+
+```bash
+pip install agt-agent
+agt          # CLI 对话
+agt-web      # WebUI → http://localhost:8000
+```
+
+---
+
+## 功能
+
+| 模块 | 说明 |
+|---|---|
+| **ReAct 引擎** | 思考 → 工具调用 → 观察 → 循环，最大步数 + Token 预算 + Ctrl+C 中断 |
+| **多模型** | DeepSeek / Qwen / GLM / MiniMax / StepFun / 任意 OpenAI 兼容，热切换 + 回退链 |
+| **MCP** | Model Context Protocol 客户端，自动发现工具 |
+| **工作流** | Coze 原生画布 JSON 执行器，13 类节点，每轮扫描注册为 Agent 工具 |
+| **可视化编辑器** | SVG 画布 + 节点拖拽 + 流程线/变量线(彩色) + 属性面板，零依赖 |
+| **多 Agent** | SubAgent 并行调度，工具继承，防递归 |
+| **WebUI** | FastAPI + WebSocket，多客户端广播，断线续连 |
+| **会话** | 分层上下文（全局摘要 + 最近窗口融合）+ 存档/恢复 |
+| **自主模式** | 定时/目标驱动，消息队列 |
+| **Wiki** | `.agent/wiki/` 知识库 CRUD + 子 Agent 自动维护 |
+| **技能** | `.agent/skills/` YAML 渐进式披露 |
+| **Agentic RAG** | 工作流设 `auto:true`，消息自动预取注入 |
+| **批处理** | 任意节点对数组逐元素执行，输出 all/filtered/nth |
+
+---
+
+## 快速开始
+
+### 1. 安装
+
+```bash
+pip install agt-agent
+```
+
+### 2. 配置模型
+
+启动后点 ⚙ 设置 → 添加模型（base_url / api_token / model id），保存到 `~/.agt/models.json`。
+
+或手动：复制 `models.example.py` → `models.py`，填 token。
+
+### 3. 启动
+
+```bash
+agt          # CLI
+agt-web      # WebUI（浏览器打开 http://localhost:8000）
+```
+
+---
+
+## 工作流
+
+1. 打开 `http://localhost:8000/editor`（或 WebUI 点 ✏ 编辑器）
+2. 左侧调色板拖放节点 → 连线 → 右侧面板编辑属性 → Ctrl+S 保存
+3. 文件存入 `.agent/workflows/<名>.json`
+4. Agent 每轮自动扫描 → 注册为 `wf_<名>` 工具，模型可调用
+
+**自动工作流（Agentic RAG）**：编辑器勾选 ✅ 自动 + 填写参数名，保存后 `meta` 写入 `{"auto":true,"auto_param":"query"}`。之后每次发消息，Agent 先跑该工作流取上下文再处理。
+
+### 节点类型（13 类）
+
+开始/结束 · LLM · 代码 · 选择器(分支) · 循环 · 批处理 · 意图识别 · JSON 解析/构造 · 文本处理 · HTTP 请求 · 子工作流 · 插件 · 变量聚合/赋值
+
+---
+
+## 项目结构
+
+```
+├── pyproject.toml       # pip install 配置（entry: agt, agt-web）
+├── src/                 # 源代码
+│   ├── chat.py          # CLI
+│   ├── web.py           # WebUI + API
+│   ├── agent.py         # ReAct 引擎
+│   ├── workflow.py      # Coze 工作流执行器
+│   ├── tools.py         # Tool/Toolbox
+│   ├── real_tools.py    # 内置工具（Python/文件读写/grep/搜索/shell）
+│   ├── llm_client.py    # 多模型客户端
+│   ├── session.py       # 分层上下文会话
+│   ├── mcp_client.py    # MCP 协议
+│   ├── multiagent.py    # 多 Agent
+│   └── ...
+├── static/              # WebUI 前端
+│   ├── index.html       # 聊天界面
+│   └── workflow_editor.html  # 工作流编辑器
+├── .agent/              # 工作区（workflows/rules/skills/wiki）
+└── examples/            # step0-7 教程
+```
+
+---
+
+## 开发
+
+```bash
+git clone https://github.com/vgp7758/Agt.git
+cd Agt
+pip install -e .
+```
+
+运行测试：`python examples/step*.py`
+
+---
+
+## 卸载
+
+```bash
+pip uninstall agt-agent
+rm -rf ~/.agt
+```
+
+## License
+
+MIT

agt_agent-0.1.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+agt_agent-0.1.0.dist-info/licenses/LICENSE,sha256=-KJMHdqC1ZDgedOTvF8O2Y4zDWD2uAJa_3LA9pFUn_w,1076
+src/__init__.py,sha256=fva579HQAQGoek4upG_431R0TH5ZGWda5cE24gJouR0,247
+src/agent.py,sha256=bIZuQh538dGDkn0alWt5sv5QKefcTz7FxT2sFWubnBM,19797
+src/agent_config.py,sha256=0DOOoB8ZNtz1aQIXrizXKbTL1LbwRsoK1DtrpPIcAyM,4358
+src/chat.py,sha256=-E3Ruklf60V5YpeNQFPq0tLxVhEVYVSaZ_HQKTK6Qac,7107
+src/commands.py,sha256=kX9ZkMK5hsv_Q3NZyCsMyHgxxHoPZznzm3-AXodsefQ,15722
+src/config.py,sha256=QIm0TocbVGgvoQTo3gfiZ2mvt-FTsnM4K9_Iz_vHjPk,3778
+src/llm_client.py,sha256=77KY4dsYHOoVbN6wHzf9LjIpzuHpMYk4S6sEmnDL6VE,9542
+src/lsp_server.py,sha256=kUZz-Elw7755u4C5ATl8_AhRTk5QeZnTmo2vbntwiws,3773
+src/mcp_client.py,sha256=Wj0uZJbhS7xWabwZoG9fVg1-SXYt3wNJnluDI-DsKSw,7428
+src/multiagent.py,sha256=qiP3iXnDriMvcWgFF9yD9KuSkYcRQ3La-zlMiUnMf2U,5103
+src/plan_tools.py,sha256=tETRKs1dthYvjybNRCXkK_DQH9UZiRz3Osb4-hpuDqE,2254
+src/prompts.py,sha256=SRg6XISTKJX0sN9X6NEdmgBiZFmez2VCSM2GnutrYLo,2812
+src/real_tools.py,sha256=GkW09B46fgnJDtiJE4CcaAj6WQt6LioAtLOrTRGdNMI,22355
+src/session.py,sha256=3rOo1gMzCxxsINHfAIzeCgkGLlsaZPXJjJ5RBZ0Qahw,13705
+src/snapshots.py,sha256=mDs75RxmOH1cNYg_ZKSxEyDoHQ-5m1bbYwbz4OS-lq0,3677
+src/tools.py,sha256=-wK7taMICTMwg3T-oal4n_btYD2vcJ7lpfDusNYzElU,5428
+src/web.py,sha256=fQvZkS_REWCcYwGisedQwBxhL1vGV97QYgh5SKQJvuM,19555
+src/wiki.py,sha256=rpKLkynAg1NAEUtS4Do8A7rhmNjaJhiPCnNJ8Be6U_I,7341
+src/workflow.py,sha256=DAh99-_c3MXIOapL2ZSb9Z9DUnZ9SHT6KSt90063NR0,56270
+agt_agent-0.1.0.dist-info/METADATA,sha256=3rOUZtPdQgcYKUlhTUkgp6kpIqCQUmIoBNKzvabImdk,5491
+agt_agent-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+agt_agent-0.1.0.dist-info/entry_points.txt,sha256=ZFQEL-Mqr5l2a6ZCumuHTQKRnuQl-sUi2OdqUrEygoY,61
+agt_agent-0.1.0.dist-info/top_level.txt,sha256=74rtVfumQlgAPzR5_2CgYN24MB0XARCg0t-gzk6gTrM,4
+agt_agent-0.1.0.dist-info/RECORD,,

agt_agent-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

agt_agent-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+agt = src.chat:main
+agt-web = src.web:main

agt_agent-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 马建强 (vgp7758)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

agt_agent-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+src

src/__init__.py

@@ -0,0 +1,6 @@
+"""Agt Agent 框架——src 包。确保包内绝对导入(import config 等)能找到同级模块。"""
+__version__ = "0.1.0"
+import sys, os
+_pkg = os.path.dirname(os.path.abspath(__file__))
+if _pkg not in sys.path:
+    sys.path.insert(0, _pkg)

src/agent.py

@@ -0,0 +1,375 @@
+"""agent.py —— 自主 Agent（事件化输出，CLI 与 Web 各取所需）。
+
+输出抽象成结构化事件流：`_emit(event)`。若设了 `on_event`（如 Web 后端）则回调它；
+同时若 `verbose=True` 则 `_print_event` 复刻原控制台格式。故 `chat.py`（不设 on_event、
+verbose=True）输出与之前完全一致；`web.py` 设 on_event 把事件推给浏览器。
+
+能力：ReAct 主循环、长程自主、单步并行工具、软 token 预算、Ctrl+C 优雅打断、
+多模型热切换、多 Agent（self.sub_agents）、定时纯自主模式。
+"""
+from __future__ import annotations
+
+import config
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from datetime import datetime
+from typing import Callable, Optional, List
+
+from llm_client import LLMClient
+from session import Session, Step, ToolCall
+from tools import Toolbox
+
+GRAY, RESET = "\033[90m", "\033[0m"
+
+
+class Agent:
+    def __init__(
+        self,
+        system: str,
+        tools: Toolbox,
+        *,
+        enable_thinking: bool = True,
+        max_steps: int = 50,
+        token_budget: int = 80000,
+        temperature: float = 0.7,
+        verbose: bool = True,
+        recent_window_turns: int = 4,
+        max_steps_per_turn: int = 80,
+        model_name: Optional[str] = None,
+        on_event: Optional[Callable[[dict], None]] = None,
+        snapshot_manager=None,
+    ):
+        self.base_system = system
+        self.tools = tools
+        self.max_steps = max_steps
+        self.token_budget = token_budget
+        self.verbose = verbose
+        self.on_event = on_event
+        self.snapshot_manager = snapshot_manager
+        self.model_name = model_name or config.DEFAULT_MODEL
+
+        self.llm = LLMClient(model_name=self.model_name,
+                             temperature=temperature, enable_thinking=enable_thinking)
+        self.session = Session(system, llm=self.llm, recent_window_turns=recent_window_turns,
+                               max_steps_per_turn=max_steps_per_turn)
+        self.cumulative_tokens = 0
+        self.sub_agents: dict = {}  # 多 Agent 协作：name -> SubAgent
+        self.plan: list = []        # 计划清单（create_plan/update_plan 维护）
+        # 纯自主模式状态
+        self.autonomous_mode: bool = False
+        self.autonomous_end_time: Optional[datetime] = None
+        self.autonomous_prompt: str = "当前为纯自主模式，请继续按照要求完成更多工作"
+        self.pending_messages: List[str] = []  # 用户插入的消息队列
+        self.goal_check_script: str = ""       # 目标达成验证脚本(Python，输出 PASS=达成)
+
+    # ========== 事件输出 ==========
+    def _print_only_emit(self, event: dict):
+        """CLI 模式的流式回调：tool_stream/tool_progress 直接打印。"""
+        t = event.get("type")
+        if t == "tool_stream":
+            print(f"{GRAY}{event.get('text', '')}{RESET}", end="", flush=True)
+        elif t == "tool_progress":
+            print(f"{GRAY}⏳ {event['name']} 已运行 {event['elapsed']}s，{event.get('lines', 0)} 行输出{RESET}")
+
+    def _emit(self, event: dict):
+        """发一个事件：回调 on_event（Web）；verbose 时打印（CLI）。"""
+        if self.on_event:
+            try:
+                self.on_event(event)
+            except Exception:
+                pass
+        if self.verbose:
+            self._print_event(event)
+
+    def _print_event(self, e: dict):
+        """复刻原控制台输出格式（保证 CLI 行为不变）。"""
+        t = e.get("type")
+        if t == "user":
+            print(f"\n🧑 用户：{e['text']}")
+        elif t == "step":
+            print(f"\n{GRAY}━━━ 第 {e['n']} 步 (累计 {e['tokens']} token) ━━━{RESET}")
+        elif t == "warn":
+            print(f"{GRAY}{e['text']}{RESET}")
+        elif t == "budget_hit":
+            print(f"\n⚠️ token 预算 ({self.token_budget}) 已用尽，强制收尾。")
+        elif t == "thinking":
+            print(f"{GRAY}[思考] {e['text']}{RESET}")
+        elif t == "parallel":
+            print(f"{GRAY}⚡ 并行执行 {e['count']} 个工具调用{RESET}")
+        elif t == "tool_call":
+            print(f"🔧 调用 {e['name']}({e['arguments']})")
+        elif t == "tool_result":
+            prefix = f"   → [{e['name']}]" if e.get("parallel") else "   →"
+            print(f"{prefix} {e['result']}")
+        elif t == "answer":
+            print(f"\n🤖 最终回答：{e['text'].strip()}")
+            print(f"{GRAY}[本次累计 token: {e.get('tokens', self.cumulative_tokens)}]{RESET}")
+        elif t == "wrap_up":
+            print(f"\n⚠️ 达到最大步数 {self.max_steps}，强制收尾。")
+        elif t == "wrap_answer":
+            print(f"\n🤖 收尾回答：{e['text'].strip()}")
+        elif t == "interrupted":
+            print("\n\n⏹ 已中断（已完成的轮次保留在会话中，可用 /save 保存）。")
+        elif t == "autonomous_status":
+            if e.get("active"):
+                print(f"\n🔁 纯自主模式已开启，持续到 {e['end_time']}")
+            else:
+                print("\n🔁 纯自主模式已关闭")
+        elif t == "autonomous_continue":
+            print(f"\n{GRAY}🔁 自主继续：{e['text']}{RESET}")
+        elif t == "autonomous_next":
+            print(f"{GRAY}🔁 准备自主继续：{e['text']}{RESET}")
+        elif t == "tool_stream":
+            # CLI 模式：流式输出直接 print，不加换行（全靠子进程自己控制）
+            pass  # _print_only_emit 已在流式回调中处理
+        elif t == "tool_progress":
+            print(f"{GRAY}⏳ {e['name']} 运行中 {e['elapsed']}s，{e.get('lines',0)} 行输出{RESET}")
+        elif t == "auto_wf":
+            print(f"{GRAY}🔍 自动工作流[{e['name']}]: {e['text'][:120]}{RESET}")
+        elif t == "message_queued":
+            print(f"{GRAY}📨 消息已入队（队列大小：{e['queue_size']}）{RESET}")
+
+    @staticmethod
+    def _truncate(s, n=500):
+        s = str(s)
+        return s if len(s) <= n else s[:n] + f"...(+{len(s) - n}字)"
+
+    def _run_tools_parallel(self, calls: list) -> list:
+        """并行执行一组工具调用，按原顺序返回结果。"""
+        results = [None] * len(calls)
+        with ThreadPoolExecutor(max_workers=len(calls)) as ex:
+            fut_to_idx = {ex.submit(self.tools.call, tc["name"], tc["arguments"]): i
+                          for i, tc in enumerate(calls)}
+            for fut in as_completed(fut_to_idx):
+                i = fut_to_idx[fut]
+                try:
+                    results[i] = fut.result()
+                except Exception as e:
+                    results[i] = f"[执行出错] {type(e).__name__}: {e}"
+        return results
+
+    def switch_model(self, name: str):
+        """热切换模型。Session 共用 self.llm，故摘要调用也跟着切。"""
+        self.llm.switch_model(name)
+        self.model_name = name
+
+    def set_autonomous_mode(self, end_time: datetime, prompt: str = None):
+        """设置纯自主模式：到 end_time 之前，任务完成后自动继续。
+        prompt: 自动继续时使用的提示词（默认使用预设提示）。"""
+        self.autonomous_mode = True
+        self.autonomous_end_time = end_time
+        if prompt:
+            self.autonomous_prompt = prompt
+        self._emit({"type": "autonomous_status", "active": True, "end_time": end_time.isoformat(),
+                    "prompt": self.autonomous_prompt})
+
+    def exit_autonomous_mode(self):
+        """退出纯自主模式。"""
+        self.autonomous_mode = False
+        self.autonomous_end_time = None
+        self._emit({"type": "autonomous_status", "active": False})
+
+    def is_autonomous_active(self) -> bool:
+        """检查纯自主模式是否仍有效（未超时且未被手动关闭）。"""
+        if not self.autonomous_mode:
+            return False
+        if self.autonomous_end_time and datetime.now() > self.autonomous_end_time:
+            self.exit_autonomous_mode()
+            return False
+        return True
+
+    def queue_user_message(self, text: str):
+        """在自主模式下，将用户消息加入队列（等当前任务完成后注入）。"""
+        if self.autonomous_mode:
+            self.pending_messages.append(text)
+            self._emit({"type": "message_queued", "text": text, "queue_size": len(self.pending_messages)})
+            return True
+        return False
+
+    def get_next_message(self) -> Optional[str]:
+        """获取下一条要处理的消息（优先队列中的用户消息，否则用自主提示）。"""
+        if self.pending_messages:
+            return self.pending_messages.pop(0)
+        if self.is_autonomous_active():
+            return self.autonomous_prompt
+        return None
+
+    def run_goal_check(self) -> str:
+        """运行目标验证脚本（独立子进程），返回输出。'PASS' 表示目标达成。"""
+        if not self.goal_check_script:
+            return ""
+        import subprocess, sys, tempfile, os
+        with tempfile.NamedTemporaryFile("w", suffix=".py", delete=False, encoding="utf-8") as f:
+            f.write(self.goal_check_script)
+            tmp = f.name
+        try:
+            proc = subprocess.run([sys.executable, tmp], capture_output=True,
+                                  text=True, timeout=30, cwd=os.getcwd())
+            return (proc.stdout or "").strip()
+        except subprocess.TimeoutExpired:
+            return "[目标检查超时]"
+        finally:
+            try:
+                os.unlink(tmp)
+            except OSError:
+                pass
+
+    # ========== ReAct 主循环 ==========
+    def run(self, user_message: str, images: Optional[list] = None, _autonomous_continue: bool = False) -> str:
+        """
+        :param user_message: 用户消息（自主继续时为自动生成的提示）
+        :param images: 图片列表
+        :param _autonomous_continue: 内部标记，表示这是自主继续的一轮（用于事件区分）
+        """
+        # 用循环替代递归：自主继续时走下一轮迭代而不是 self.run() 递归
+        msg, auto_flag, imgs = user_message, _autonomous_continue, images
+        while True:
+            self._stop_flag = False
+            self.session.start_turn(msg, imgs)
+            # 自动工作流（agentic RAG）：auto:true 的工作流用当前消息作为输入预执行
+            auto_ctx = ""
+            try:
+                from real_tools import WORKSPACE as _ws2
+                from workflow import get_auto_workflows, execute as _wf_execute
+                for aw in get_auto_workflows(_ws2):
+                    try:
+                        result = _wf_execute(aw["canvas"], {aw["auto_param"]: msg},
+                                             tools=self.tools, llm=self.llm, workspace=_ws2)
+                        auto_ctx += f"\n\n[自动工作流「{aw['name']}」的预取结果]（参数 {aw['auto_param']}={msg[:80]}）：\n{result}"
+                        self._emit({"type": "auto_wf", "name": aw["name"], "text": str(result)[:300]})
+                    except Exception as e2:
+                        auto_ctx += f"\n\n[自动工作流「{aw['name']}」执行失败：{e2}]"
+            except Exception:
+                pass  # 自动工作流不影响主循环
+            if auto_ctx and not auto_flag:
+                msg = auto_ctx.strip() + "\n\n---\n用户消息：" + msg
+            if not auto_flag:
+                self._emit({"type": "user", "text": msg, "image_count": len(imgs or [])})
+            else:
+                self._emit({"type": "autonomous_continue", "text": msg})
+            if self.snapshot_manager is not None:
+                try:
+                    sha = self.snapshot_manager.snapshot()
+                    self.session._current.snapshot_sha = sha
+                    self._emit({"type": "checkpoint", "sha": sha})
+                except Exception as e:
+                    self._emit({"type": "warn", "text": f"快照失败：{type(e).__name__}: {e}"})
+            # 每轮扫描 .agent/workflows/，把工作流刷新成工具（新增/改动的工作流即时生效）
+            try:
+                from real_tools import WORKSPACE as _ws
+                from workflow import refresh_workflow_tools
+                refresh_workflow_tools(self.tools, _ws, self)
+            except Exception:
+                pass  # 工作流刷新绝不影响主循环
+            tool_schemas = self.tools.schemas()
+            continue_loop = False
+            try:
+                    for step_num in range(1, self.max_steps + 1):
+                        if self._stop_flag:
+                            self._emit({"type": "interrupted"})
+                            self.session.abort_current_turn("（被用户停止）")
+                            return ""
+                        if self.cumulative_tokens >= self.token_budget:
+                            self._emit({"type": "budget_hit"})
+                            return self._wrap_up()
+
+                        self._emit({"type": "step", "n": step_num, "tokens": self.cumulative_tokens,
+                                    "model": self.llm.model_name})
+                        resp = self.llm.chat(self.session.messages_for_llm(), tools=tool_schemas)
+                        if resp.usage:
+                            self.cumulative_tokens += resp.usage.get("total_tokens", 0)
+
+                        if self.cumulative_tokens >= self.token_budget * 0.8:
+                            self._emit({"type": "warn", "text": "⚠️ 预算已用 80%+，即将触顶收尾"})
+
+                        if resp.reasoning:
+                            snippet = resp.reasoning[:200].replace("\n", " ")
+                            if len(resp.reasoning) > 200:
+                                snippet += "..."
+                            self._emit({"type": "thinking", "text": snippet})
+
+                        # 不再调用工具 → 最终答案
+                        if not resp.tool_calls:
+                            self.session.finish_turn(resp.content, resp.reasoning)
+                            self._emit({"type": "answer", "text": resp.content,
+                                        "tokens": self.cumulative_tokens})
+                            # 目标检查：跑验证脚本，PASS 则结束自主模式
+                            if self.goal_check_script:
+                                result = self.run_goal_check()
+                                if result and result.startswith("PASS"):
+                                    self._emit({"type": "system", "text": f"🎯 目标达成：{result}"})
+                                    self.exit_autonomous_mode()
+                            # 纯自主模式：完成后检查是否继续
+                            if self.is_autonomous_active():
+                                next_msg = self.get_next_message()
+                                if next_msg:
+                                    self._emit({"type": "autonomous_next", "text": next_msg})
+                                    msg, auto_flag, imgs, continue_loop = next_msg, True, None, True
+                                    break
+                            return resp.content
+
+                        # 执行工具
+                        calls = resp.tool_calls
+                        step = Step(reasoning=resp.reasoning)
+                        # 设置流式回调（run_python/run_shell 通过它推 tool_stream/tool_progress）
+                        import real_tools as _rt
+                        _rt._tool_emit = self.on_event if self.on_event else (self._print_only_emit if self.verbose else None)
+                        if len(calls) == 1:
+                            tc = calls[0]
+                            self._emit({"type": "tool_call", "name": tc["name"], "arguments": tc["arguments"]})
+                            result = self.tools.call(tc["name"], tc["arguments"])
+                            self._emit({"type": "tool_result", "name": tc["name"],
+                                        "result": self._truncate(result), "parallel": False})
+                            step.tool_calls.append(ToolCall(id=tc.get("id", ""), name=tc["name"],
+                                                             arguments=tc["arguments"], result=result))
+                        else:
+                            self._emit({"type": "parallel", "count": len(calls)})
+                            for tc in calls:
+                                self._emit({"type": "tool_call", "name": tc["name"], "arguments": tc["arguments"]})
+                            results = self._run_tools_parallel(calls)
+                            for tc, result in zip(calls, results):
+                                self._emit({"type": "tool_result", "name": tc["name"],
+                                            "result": self._truncate(result), "parallel": True})
+                                step.tool_calls.append(ToolCall(id=tc.get("id", ""), name=tc["name"],
+                                                                 arguments=tc["arguments"], result=result))
+                        _rt._tool_emit = None  # 清理
+                        self.session.add_step(step)
+                        # 自主模式下：工具执行完后检查是否有用户插入消息，附加到结果里让 Agent 立刻看到
+                        if self.autonomous_mode and self.pending_messages:
+                            inject = "；".join(self.pending_messages)
+                            self.pending_messages.clear()
+                            self._emit({"type": "message_injected", "text": inject})
+                            # 在下一步发给 LLM 的上下文里，通过 system 消息注入用户提示
+                            self.session._current._user_hint = inject
+
+                    if continue_loop:
+                        continue
+                    self._emit({"type": "wrap_up"})
+                    if self.is_autonomous_active():
+                        next_msg = self.get_next_message()
+                        if next_msg:
+                            self._emit({"type": "autonomous_next", "text": next_msg})
+                            msg, auto_flag, imgs, continue_loop = next_msg, True, None, True
+                            continue
+                    return self._wrap_up()
+
+            except KeyboardInterrupt:
+                self._emit({"type": "interrupted"})
+                self.session.abort_current_turn("（被用户中断）")
+                return ""
+
+    def _wrap_up(self) -> str:
+        """预算/步数到顶时，做一次无工具的总结性收尾。"""
+        msgs = self.session.messages_for_llm() + [{
+            "role": "system",
+            "content": "token 预算或步数已达上限。请基于目前已有的工具结果，直接给出最终总结性回答，不要再调用工具。"
+        }]
+        try:
+            resp = self.llm.chat(msgs)
+            answer = resp.content
+            if resp.usage:
+                self.cumulative_tokens += resp.usage.get("total_tokens", 0)
+        except Exception as e:
+            answer = f"（收尾调用失败：{e}）"
+        self.session.finish_turn(answer)
+        self._emit({"type": "wrap_answer", "text": answer})
+        return answer