myagent-ai 1.15.30 → 1.15.32

package/agents/base.py

@@ -367,7 +367,6 @@ class BaseAgent(ABC):
                 tool_calls=final_tool_calls,
                 finish_reason=finish_reason,
                 model=request_kwargs.get("model", self.llm.model),
-                reasoning=full_reasoning,
             )
         except Exception as e:
             logger.error(f"LLM 流式调用失败: {e}")

package/agents/main_agent.py

@@ -6,7 +6,6 @@ agents/main_agent.py - 主 Agent
 from __future__ import annotations
 
 import asyncio
-import re
 from typing import Any, Callable, Dict, List, Optional
 
 from core.logger import get_logger
@@ -43,48 +42,41 @@ class MainAgent(BaseAgent):
 严格以XML格式化输出以下内容:
 <output>
 <response>直接回复用户的内容。这是一段友好、自然的话语，用于向用户说明你正在做什么，或者回应用户的问题/问候。要求简洁、有礼貌、符合对话场景。如果用户只是问候，简单回应即可；如果用户有具体任务，要说明你的计划。</response>
-<usersays_correct>根据用户输入的"usersays"内容（语音转写文本），结合对话语境优化为更准确的用户意图表达（修正识别错误、补充标点、口语转书面语）。如果"usersays"为空，这里输出为空。</usersays_correct>
-<task_plan>任务计划（仅复杂任务使用）：如"context"包含非空"task_plan"，则更新它。否则，先评估任务复杂度——如果预计操作步骤不超过3步（如：单次查询、简单问答、格式转换、单文件修改、简单计算等简单任务），则<task_plan>输出为空，不要创建任务列表；只有当任务较复杂（预计超过3步操作，如：多文件修改、需要调研+实现+测试、涉及多个模块联动等），才以Markdown列表格式制定新任务列表。格式：每项用 "- [ ] 任务描述" 或 "- [x] 已完成任务"，含完成状态标记。</task_plan>
+<usersays_correct>根据用户输入的"usersays"内容，结合上下文优化为新的用户输入，如果"usersays"为空，这里输出为空。</usersays_correct>
+<task_plan>如"context"包含非空"task_plan",则更新它，变为当前输出。否则，根据"context", 以MD 的格式，制定新任务列表。</task_plan>
 
 <toolstocal>
 <tool><beforecalltext>连接词，介绍调用什么工具，达到什么目的。</beforecalltext><toolname>工具名</toolname><parms>JSON格式的参数对象，例如: {"query": "搜索关键词", "num": 5}</parms><timeout>预估超时时限(秒)</timeout><callback>true/false,要求解析器在该工具执行完后是否要回调llm大模型，将所有工具输出结果+新构造的"context"输入给llm</callback></tool>
 </toolstocal>
 <remember><type>global或session</type><content>仅从最新用户输入（userprint 或 usersays_correct）中提炼值得记忆的信息（如用户偏好、重要结论、错误经验等）。type=global表示跨会话全局记忆，type=session表示仅当前会话可用的记忆。如果本轮没有新信息需要记忆，则<content>为空、<type>不填。</content></remember>
-<recall>下一轮需要主动召回的记忆描述。填写需要从记忆库中检索的关键字或描述。如果不填写则为空。如果需要更多记忆支持当前任务，填写相关关键词（可包含时间参考，如"2025年1月的项目"），系统将在下一轮搜索top5相关记忆并通过<recall_memory>注入上下文。你也可以直接调用recall_memory工具即时搜索。</recall>
+<recall>下一轮执行需要调取的记忆，这里要设计接上记忆库</recall>
 <knowledge>从本轮对话或工具执行结果中提炼值得长期保存到知识库的专业知识、事实、经验法则、技术要点等。这些知识将被持久化存储，未来可通过 <get_knowledge> 检索复用。如果本轮没有需要保存的知识，则为空。格式要求：简洁明确，每条知识一行，用换行分隔。</knowledge>
 <get_knowledge>下一轮执行时需要从知识库搜索获得的知识，填写检索关键词或描述。如context中已包含充足的<knowledge>内容，则为空。如需更多专业知识支撑，则填写相关搜索词。</get_knowledge>
 <askuser>需要询问用户的内容，如无，则为空</askuser>
 <finish>true/false，是否结束循环调用llm。如"askuser"为非空，则"finish"输出true。否则，根据"context"判断任务是否已完成，是否结束llm回调</finish>
 <finish_reason>当 finish=true 时必填，详细说明为什么现在结束任务（如：任务已完成/需要用户补充信息/信息不足无法继续等）。finish=false 时为空。</finish_reason>
 <next_step>当 finish=false 时必填，描述下一步计划做什么（简洁明了，1-2句话）。finish=true 时为空。</next_step>
-<mainsubject>为当前对话生成一个简短的标题（6个字以内），概括对话主题。仅在对话刚开始（前几轮）时需要输出，已有标题的对话此标签留空即可。要求简洁精炼，例如"Python安装"、"请假流程"、"翻译助手"等。</mainsubject>
 
 </output>
 
 ## 核心规则
 1. 你必须且只能输出 <output> XML 结构，不要输出任何其他文本
 2. <response>: 必须输出一段直接回复用户的话语（这是用户实际看到的回复），要求简洁友好、自然流畅。不要只输出任务计划而不说话！
-3. <usersays_correct>: 如果 context 中 usersays 非空（说明用户通过语音输入），则根据对话语境将语音转写文本优化为更准确的用户意图表达，修正识别错误、补充标点、口语转书面语。如果 usersays 为空，这里输出为空。
-4. <task_plan>: 仅用于复杂任务（预计超过3步操作）。简单任务（≤3步）输出为空。复杂任务使用 Markdown 列表格式，每项包含任务描述和完成状态标记 [x]/[ ]
+3. <usersays_correct>: 如果 context 中 usersays 非空，则根据对话语境优化为更准确的用户意图表达
+4. <task_plan>: 使用 Markdown 列表格式，每项包含任务描述和完成状态标记 [x]/[ ]
 5. <toolstocal>: 列出所有需要执行的工具调用，每个工具包含完整的参数说明
 6. <parms>: **必须使用严格合法的JSON格式**，例如 {"query": "关键词", "num": 10}，不要使用其他格式
 7. <timeout>: 预估超时秒数（简单操作10-30s，文件操作30-60s，网络请求60-120s，数据处理120-300s）
 8. <callback>: 如果该工具的执行结果对后续决策有影响，设为 true；否则设为 false
 9. <remember>: 包含 <type> 和 <content> 子标签。type 填 "global"（跨会话全局记忆）或 "session"（仅当前会话）。content 填从最新用户输入中提炼的值得记忆的关键信息。如果本轮无需记忆，content 为空且不填 type。注意：用户个人偏好、重要结论、通用经验用 global；当前任务的临时上下文、过程信息用 session
-10. <recall>: 填写下一轮需要从记忆库中主动召回的内容描述和关键字（可包含时间参考）。系统将根据这些信息搜索top5相关记忆，在下一轮通过 <recall_memory> 标签注入上下文。如果当前 <automemory> 中的记忆已足够完成任务，<recall> 为空；如果需要更多历史记忆支撑，则填写。你也可以直接使用 recall_memory 工具在当前轮即时搜索
+10. <recall>: 描述下一轮执行时需要从记忆库中检索的内容关键词
 11. <knowledge>: 从本轮对话或工具执行结果中提炼值得长期保存的专业知识、事实、经验法则、技术要点等。这些知识会被持久化到知识库文件，未来可通过 get_knowledge 检索复用。如果没有需要保存的知识，则为空。格式：简洁明确，每条知识一行
 12. <get_knowledge>: 如果当前 <knowledge> 内容不足以完成任务，填写需要从知识库搜索的关键词；否则为空
 13. <askuser>: 当信息不足需要用户补充时，在此填写要问的问题
 14. <finish>: 当任务已完成或需要等待用户回应时为 true；否则为 false 继续执行
 15. <finish_reason>: **finish=true 时必须填写**，详细说明结束原因（任务完成/等待用户/信息不足/无法处理等）
 16. <next_step>: **finish=false 时必须填写**，描述下一步计划做什么，要求简洁明确（1-2句话）
-17. <mainsubject>: 为当前对话生成6字以内的简短标题，概括对话主题。仅在对话刚开始的前几轮需要输出，已有标题后留空
-18. 使用中文输出所有内容
-
-## 上下文中的记忆系统说明
-- <automemory>: 系统自动根据你通过 <remember> 保存的记忆和当前用户输入，搜索出的 top10 相关记忆。这些是你过去主动记住的内容（包含时间信息），可供参考。
-- <recall_memory>: 你在上一轮通过 <recall> 指定的记忆搜索结果。系统根据你提供的关键字和时间点搜索了 top5 相关记忆。
-- 两种记忆互补：automemory 是自动匹配的，recall_memory 是你主动指定搜索的。如果 automemory 不足，使用 <recall> 请求更多。
+17. 使用中文输出所有内容
 
 ## 工具选择指南
 - **搜索信息**: 用 `web_search`（返回标题+URL+摘要），不要用 browser_open
@@ -93,7 +85,6 @@ class MainAgent(BaseAgent):
 - **执行代码**: 用 `code` 工具（language: python/javascript/shell）
 - **执行命令**: 用 `command` 或 `command_run` 工具
 - **文件操作**: 用 `file_read` / `file_write` / `file_list` 等文件工具
-- **主动召回记忆**: 用 `recall_memory` 工具（参数: keyword=关键字, time_point=可选时间点如"2025-01", limit=数量默认5），根据关键字和时间搜索历史记忆
 """
 
     def __init__(self, tool_agent=None, memory_agent=None, **kwargs):
@@ -111,19 +102,14 @@ class MainAgent(BaseAgent):
         # 活跃会话上下文追踪（用于消息注入）
         self.active_contexts: Dict[str, AgentContext] = {}
 
-    def init_context_builder(self, memory_manager=None, skill_registry=None, knowledge_base_dir=None, context_window=None):
+    def init_context_builder(self, memory_manager=None, skill_registry=None, knowledge_base_dir=None):
         """初始化 Context Builder（在系统启动后调用，注入依赖）"""
-        if context_window is None and self.llm:
-            context_window = getattr(self.llm, 'context_window', 128000)
-        if context_window is None:
-            context_window = 128000
         self.context_builder = ContextBuilder(
             memory_manager=memory_manager,
             skill_registry=skill_registry,
             knowledge_base_dir=knowledge_base_dir,
-            context_window=context_window,
         )
-        logger.info(f"Context Builder 已初始化 (context_window={context_window})" + (f" (知识库: {knowledge_base_dir})" if knowledge_base_dir else ""))
+        logger.info("Context Builder 已初始化" + (f" (知识库: {knowledge_base_dir})" if knowledge_base_dir else ""))
 
     def _add_exec_event(self, event_type: str, data: Dict):
         """记录一个执行事件（供前端展示）"""
@@ -295,24 +281,14 @@ class MainAgent(BaseAgent):
         Returns:
             True 表示成功存储了新知识，False 表示跳过（重复）或失败
         """
-        if not self.context_builder:
+        if not self.context_builder or not self.context_builder.knowledge_base_dir:
             logger.debug(f"[{task_id}] 知识库未配置，跳过 knowledge 存储")
             return False
 
         from datetime import datetime
         from pathlib import Path
 
-        # 优先写入 Agent 专属知识库，其次回退到组织知识库
-        kb_dir = None
-        if self.context_builder.agent_knowledge_dir:
-            kb_dir = Path(self.context_builder.agent_knowledge_dir)
-        elif self.context_builder.knowledge_base_dir:
-            kb_dir = Path(self.context_builder.knowledge_base_dir)
-
-        if not kb_dir:
-            logger.debug(f"[{task_id}] 知识库目录未配置，跳过 knowledge 存储")
-            return False
-
+        kb_dir = Path(self.context_builder.knowledge_base_dir)
         auto_kb_dir = kb_dir / "auto_knowledge"
         auto_kb_dir.mkdir(parents=True, exist_ok=True)
 
@@ -383,7 +359,7 @@ class MainAgent(BaseAgent):
                 f.write(f"\n## {now_str}\n")
                 f.write(content.strip() + "\n")
             logger.info(
-                f"[{task_id}] 知识已存入知识库: {kb_file} "
+                f"[{task_id}] 知识已存入知识库: {kb_file.name} "
                 f"({len(content)} 字符, {len(content.strip().split(chr(10)))} 条)"
             )
             return True
@@ -460,8 +436,6 @@ class MainAgent(BaseAgent):
         get_knowledge_content = ""
         # 追踪流式推送的 reasoning 文本（用于构建有意义的最终回复）
         _v2_reasoning_collected: List[str] = []
-        # XML 解析失败时的 LLM 修正重试计数
-        _xml_correction_retries: int = 0
 
         conversation_history = list(context.conversation_history or [])
 
@@ -474,23 +448,13 @@ class MainAgent(BaseAgent):
                 )
                 if db_history:
                     conversation_history = [
-                        Message(
-                            role=entry.role,
-                            content=entry.content,
-                            metadata={"time": (entry.created_at[:19] if entry.created_at else "")}
-                        )
+                        Message(role=entry.role, content=entry.content)
                         for entry in db_history
                     ]
                     logger.info(f"[{task_id}] 从 DB 加载了 {len(conversation_history)} 条历史对话")
             except Exception as e:
                 logger.warning(f"[{task_id}] 加载历史对话失败: {e}")
 
-        # [v1.15.8] 计算历史用户消息数（用于判断是否需要自动命名会话）
-        _history_user_msg_count = sum(
-            1 for m in conversation_history if getattr(m, 'role', '') == 'user'
-            and getattr(m, 'metadata', {}).get('key', '') not in ('llm_output', 'conversation_insight')
-        )
-
         # 保存用户消息到会话记忆
         if self.memory:
             self.memory.add_session(
@@ -516,7 +480,6 @@ class MainAgent(BaseAgent):
         while self._iteration_count < max_iter:
             self._iteration_count += 1
             logger.info(f"[{task_id}] V2 迭代 {self._iteration_count}/{max_iter}")
-            _emitted_reasoning_this_iter = False  # [v1.15.8] 本轮是否已发送过 v2_reasoning 事件（防 TTS 重复）
 
             # ── 检查配置热加载广播 ──
             if self.config_broadcaster:
@@ -541,7 +504,7 @@ class MainAgent(BaseAgent):
                 session_id=context.session_id,
                 conversation_history=conversation_history,
                 user_typed_text=context.user_message,
-                user_voice_text=context.metadata.get("user_voice_text", ""),
+                user_voice_text="",
                 task_plan=current_task_plan,
                 agent_override_prompt=agent_override_prompt,
                 get_knowledge=get_knowledge_content,
@@ -562,7 +525,7 @@ class MainAgent(BaseAgent):
                 + self.SYSTEM_PROMPT.split("\n", 1)[1]
             )
             system_content = _prompt_with_placeholder.replace(_CONTEXT_PLACEHOLDER, context_xml)
-            # Step 3: 构建 LLM 消息（必须包含 role=user，否则 OpenAI 兼容 API 返回 400）
+            # Step 3: 调用 LLM
             messages = [Message(role="system", content=system_content)]
 
             if all_tool_outputs:
@@ -571,11 +534,6 @@ class MainAgent(BaseAgent):
                     content=f"[上一轮工具执行结果汇总]\n{truncate_str(all_tool_outputs, 30000)}"
                 ))
                 all_tool_outputs = ""
-            else:
-                messages.append(Message(
-                    role="user",
-                    content=context.user_message or "请处理上述上下文。"
-                ))
 
             if stream_response and self.llm:
                 response = await self._call_llm_stream(
@@ -590,18 +548,12 @@ class MainAgent(BaseAgent):
                 error_msg = f"LLM 调用失败: {response.error}"
                 context.working_memory["final_response"] = error_msg
                 await self._emit_v2_event("v2_reasoning", {"content": error_msg}, stream_callback)
-                if self.memory:
-                    self.memory.add_session(
-                        session_id=context.session_id,
-                        role="assistant",
-                        content=error_msg,
-                    )
                 break
 
             llm_raw = response.content
             logger.debug(f"[{task_id}] LLM 输出 (前500字): {llm_raw[:500]}")
 
-            # 保存 LLM 原始输出到会话记忆（用于回溯和审计，key=llm_output 不出现在对话历史中）
+            # 保存 LLM 原始输出到会话记忆（用于回溯和审计）
             if self.memory:
                 self.memory.add_session(
                     session_id=context.session_id,
@@ -610,15 +562,6 @@ class MainAgent(BaseAgent):
                     key="llm_output",
                     importance=0.3,
                 )
-                # 保存推理模型的思考过程（key=reasoning 供前端刷新后展示）
-                if response.reasoning and response.reasoning.strip():
-                    self.memory.add_session(
-                        session_id=context.session_id,
-                        role="assistant",
-                        content=response.reasoning.strip(),
-                        key="reasoning",
-                        importance=0.2,
-                    )
 
             # Step 4: 解析结构化输出
             parsed = parse_output(llm_raw)
@@ -634,61 +577,43 @@ class MainAgent(BaseAgent):
                     "finish": parsed.finish,
                     "finish_reason": truncate_str(parsed.finish_reason, 200),
                     "next_step": truncate_str(parsed.next_step, 200),
-                    "response": truncate_str(parsed.response, 500),
                     "parse_success": parsed.parse_success,
-                    "needs_correction": parsed.needs_correction,
                 }},
                 stream_callback,
             )
 
-            # Step 4.5: 解析失败处理 — 回退给 LLM 修正或提取周边文本
             if not parsed.parse_success:
-                if parsed.needs_correction and _xml_correction_retries < 1:
-                    # XML 完全无法解析，让 LLM 重新格式化输出
-                    _xml_correction_retries += 1
-                    logger.warning(
-                        f"[{task_id}] XML 解析完全失败，回退给 LLM 修正 "
-                        f"(重试 {_xml_correction_retries}/1)"
-                    )
-                    correction_prompt = (
-                        "你上一次的输出格式有误，XML解析器无法识别。"
-                        "请严格按照 <output>...</output> 格式重新输出你的回答。"
-                        "注意：不要在 <output> 标签前后输出任何其他文字。\n\n"
-                        f"你上一次的原始输出如下：\n{llm_raw}"
-                    )
-                    conversation_history.append(
-                        Message(role="assistant", content=llm_raw)
-                    )
-                    conversation_history.append(
-                        Message(role="user", content=correction_prompt)
-                    )
-                    await self._emit_v2_event(
-                        "v2_reasoning",
-                        {"content": "⚠️ 模型输出格式异常，正在自动修正..."},
-                        stream_callback,
-                    )
-                    continue  # 重新进入循环，让 LLM 重新生成
+                logger.warning(f"[{task_id}] XML 解析失败 (parse_success=False)")
+                # 即使解析失败，如果 regex fallback 提取到了工具调用，仍然执行
+                if parsed.tools_to_call:
+                    logger.info(f"[{task_id}] 但提取到 {len(parsed.tools_to_call)} 个工具调用，继续执行")
                 else:
-                    # 已重试过或不需要修正，提取周边文本作为备选
-                    logger.warning(f"[{task_id}] XML 解析失败，提取周边文本作为备选")
+                    logger.warning(f"[{task_id}] 无工具调用可执行，尝试提取周边文本")
                     before, after = extract_surrounding_text(llm_raw)
                     if before.strip() or after.strip():
                         final_text = (before + "\n" + after).strip()
+                        context.working_memory["final_response"] = final_text
+                        await self._emit_v2_event("v2_reasoning", {"content": final_text}, stream_callback)
+                        if self.memory:
+                            self.memory.add_session(
+                                session_id=context.session_id,
+                                role="assistant",
+                                content=final_text,
+                            )
+                        break
                     else:
-                        # 清除残余 XML 标签后作为纯文本
-                        final_text = re.sub(r"<[^>]+>", "", llm_raw).strip()
-                        final_text = final_text if final_text else "处理完毕。"
-                    context.working_memory["final_response"] = final_text
-                    await self._emit_v2_event(
-                        "v2_reasoning", {"content": final_text}, stream_callback
-                    )
-                    if self.memory:
-                        self.memory.add_session(
-                            session_id=context.session_id,
-                            role="assistant",
-                            content=final_text,
-                        )
-                    break
+                        # XML 解析失败且无法提取文本，发送原始输出作为备选
+                        logger.warning(f"[{task_id}] 无法提取文本，发送原始 LLM 输出")
+                        final_text = llm_raw.strip() if llm_raw.strip() else "处理完毕。"
+                        context.working_memory["final_response"] = final_text
+                        await self._emit_v2_event("v2_reasoning", {"content": final_text}, stream_callback)
+                        if self.memory:
+                            self.memory.add_session(
+                                session_id=context.session_id,
+                                role="assistant",
+                                content=final_text,
+                            )
+                        break
 
             warnings = validate_output(parsed)
             for w in warnings:
@@ -705,7 +630,6 @@ class MainAgent(BaseAgent):
                     logger.debug(f"[{task_id}] 模型回复用户: {response_text[:100]}")
                     context.working_memory["model_response"] = response_text
                     _v2_reasoning_collected.append(response_text)
-                    _emitted_reasoning_this_iter = True
                     await self._emit_v2_event(
                         "v2_reasoning",
                         {"content": response_text},
@@ -791,21 +715,6 @@ class MainAgent(BaseAgent):
                 except Exception as e:
                     logger.warning(f"[{task_id}] 存入知识库失败: {e}")
 
-            # Step 6.6: [v1.15.8] 处理 mainsubject — 自动命名会话标题
-            if parsed.mainsubject and _history_user_msg_count < 4:
-                try:
-                    subject = parsed.mainsubject.strip()[:20]  # 安全截断
-                    if self.memory:
-                        self.memory.rename_session(context.session_id, subject)
-                        logger.info(f"[{task_id}] 会话自动命名: {subject}")
-                    await self._emit_v2_event(
-                        "v2_session_rename",
-                        {"session_id": context.session_id, "name": subject},
-                        stream_callback,
-                    )
-                except Exception as e:
-                    logger.warning(f"[{task_id}] 会话自动命名失败: {e}")
-
             # Step 7: 处理 recall — 记录下一轮需要检索的记忆内容
             if parsed.recall:
                 recall_content = parsed.recall
@@ -848,22 +757,31 @@ class MainAgent(BaseAgent):
 
             # Step 10: 执行工具调用（无论 finish 值如何，先执行工具）
             if not parsed.tools_to_call:
-                # 无工具调用: 优先使用已收集的 reasoning 文本（包含 parsed.response），避免丢失第一轮输出
-                if _v2_reasoning_collected:
-                    final_text = "\n".join(_v2_reasoning_collected)
-                else:
+                # 无工具调用: 直接根据 finish 判断是否结束
+                if parsed.finish:
+                    logger.info(f"[{task_id}] finish=true 且无工具调用，结束循环")
                     before, after = extract_surrounding_text(llm_raw)
                     final_text = (before + "\n" + after).strip() if (before.strip() or after.strip()) else "任务已完成。"
-                context.working_memory["final_response"] = final_text
-                # [v1.15.8] 跳过已发送的 reasoning 文本，避免 TTS 重复播报
-                if not _emitted_reasoning_this_iter:
+                    context.working_memory["final_response"] = final_text
                     await self._emit_v2_event("v2_reasoning", {"content": truncate_str(final_text, 3000)}, stream_callback)
-                if self.memory:
-                    self.memory.add_session(
-                        session_id=context.session_id,
-                        role="assistant",
-                        content=final_text,
-                    )
+                    if self.memory:
+                        self.memory.add_session(
+                            session_id=context.session_id,
+                            role="assistant",
+                            content=final_text,
+                        )
+                else:
+                    logger.info(f"[{task_id}] 无工具调用且 finish=false，结束")
+                    before, after = extract_surrounding_text(llm_raw)
+                    final_text = (before + "\n" + after).strip() if (before.strip() or after.strip()) else "处理完毕。"
+                    context.working_memory["final_response"] = final_text
+                    await self._emit_v2_event("v2_reasoning", {"content": truncate_str(final_text, 3000)}, stream_callback)
+                    if self.memory:
+                        self.memory.add_session(
+                            session_id=context.session_id,
+                            role="assistant",
+                            content=final_text,
+                        )
                 break
 
             # Step 11: 有工具调用 — 先执行所有工具，再根据 finish 决定回调
@@ -886,7 +804,6 @@ class MainAgent(BaseAgent):
                 # 发送 beforecalltext 作为显示文本
                 if before_call:
                     _v2_reasoning_collected.append(before_call)
-                    _emitted_reasoning_this_iter = True
                     await self._emit_v2_event(
                         "v2_reasoning",
                         {"content": before_call},
@@ -898,7 +815,6 @@ class MainAgent(BaseAgent):
                     "v2_tool_start",
                     {"tool": {
                         "toolname": tool_name,
-                        "beforecalltext": before_call,
                         "parms": truncate_str(parms, 500),
                         "timeout": timeout,
                         "callback": should_callback,
@@ -1070,8 +986,15 @@ class MainAgent(BaseAgent):
                 # 数据密集型工具允许更长的输出
                 _HEAVY_TOOLS = ("web_search", "web_read", "url_read", "file_list",
                                 "file_search", "browser_open", "process_list")
+                # OpenClaw prompt-only 技能也允许较长输出（SKILL.md 指令）
+                _is_openclaw = (
+                    isinstance(tool_result.get("data"), dict)
+                    and tool_result.get("data", {}).get("skill_type") == "openclaw"
+                )
                 if tool_name in _HEAVY_TOOLS:
                     _max_output = 6000
+                elif _is_openclaw:
+                    _max_output = 8000
                 else:
                     _max_output = 3000
                 tool_outputs_parts.append(
@@ -1092,12 +1015,10 @@ class MainAgent(BaseAgent):
 
                 # 保存工具调用到会话记忆
                 if self.memory:
-                    # 构建工具调用记录，包含 beforecalltext 作为标题
-                    tool_call_title = before_call if before_call else f"调用工具: {tool_name}"
                     self.memory.add_session(
                         session_id=context.session_id,
                         role="assistant",
-                        content=f"{tool_call_title}\n调用工具: {tool_name}\n参数: {truncate_str(parms, 1000)}",
+                        content=f"调用工具: {tool_name}\n参数: {truncate_str(parms, 1000)}",
                         key="tool_call",
                         importance=0.4,
                     )
@@ -1132,9 +1053,7 @@ class MainAgent(BaseAgent):
                     if current_task_plan:
                         final_text += f"\n\n任务计划:\n{current_task_plan}"
                 context.working_memory["final_response"] = final_text
-                # [v1.15.8] 跳过已发送的 reasoning 文本，避免 TTS 重复播报
-                if not _emitted_reasoning_this_iter:
-                    await self._emit_v2_event("v2_reasoning", {"content": truncate_str(final_text, 3000)}, stream_callback)
+                await self._emit_v2_event("v2_reasoning", {"content": truncate_str(final_text, 3000)}, stream_callback)
                 if self.memory:
                     self.memory.add_session(
                         session_id=context.session_id,
@@ -1161,9 +1080,7 @@ class MainAgent(BaseAgent):
                     if current_task_plan:
                         final_text += f"\n\n任务计划:\n{current_task_plan}"
                 context.working_memory["final_response"] = final_text
-                # [v1.15.8] 跳过已发送的 reasoning 文本，避免 TTS 重复播报
-                if not _emitted_reasoning_this_iter:
-                    await self._emit_v2_event("v2_reasoning", {"content": truncate_str(final_text, 3000)}, stream_callback)
+                await self._emit_v2_event("v2_reasoning", {"content": truncate_str(final_text, 3000)}, stream_callback)
                 if self.memory:
                     self.memory.add_session(
                         session_id=context.session_id,
@@ -1256,34 +1173,6 @@ class MainAgent(BaseAgent):
                 else:
                     result["error"] = "执行引擎未初始化"
 
-            elif tool_name == "recall_memory":
-                # === 主动召回记忆工具 ===
-                # 根据 memory_agent.recall_memory() 搜索历史记忆
-                try:
-                    if self.memory_agent:
-                        recall_results = await self.memory_agent.recall_memory(
-                            keyword=params.get("keyword", ""),
-                            time_point=params.get("time_point", ""),
-                            session_id=params.get("session_id", ""),
-                            limit=params.get("limit", 5),
-                        )
-                        if recall_results:
-                            output_lines = [f"找到 {len(recall_results)} 条相关记忆:"]
-                            for i, mem in enumerate(recall_results, 1):
-                                output_lines.append(
-                                    f"{i}. [{mem.get('created_at', '')}] "
-                                    f"[{mem.get('category', '')}] "
-                                    f"{mem.get('content', '')}"
-                                )
-                            result = {"success": True, "output": "\n".join(output_lines), "data": recall_results}
-                        else:
-                            result = {"success": True, "output": "未找到相关记忆", "data": []}
-                    else:
-                        result = {"success": False, "error": "记忆系统未初始化"}
-                except Exception as re_err:
-                    result = {"success": False, "error": f"记忆召回失败: {re_err}"}
-                    logger.warning(f"[{task_id}] recall_memory 工具异常: {re_err}")
-
             elif self.skills:
                 exec_result = await self.skills.execute(tool_name, **params)
                 result = exec_result.to_dict()

package/agents/memory_agent.py

@@ -306,14 +306,14 @@ class MemoryAgent(BaseAgent):
 
         context.working_memory["relevant_memories"] = {
             "global": [
-                {"content": e.content, "key": e.key, "summary": e.summary}
+                {"content": e.content[:500], "key": e.key, "summary": e.summary}
                 for e in global_memories
             ],
             "error_patterns": [
-                {"content": e.content} for e in errors
+                {"content": e.content[:300]} for e in errors
             ],
             "preferences": [
-                {"content": e.content} for e in prefs[-5:]
+                {"content": e.content[:200]} for e in prefs[-5:]
             ],
         }
 
@@ -325,99 +325,11 @@ class MemoryAgent(BaseAgent):
 
         if errors:
             context_parts.append("\n## 历史错误(避免重复)")
-            context_parts.extend(f"- {e.content}" for e in errors)
+            context_parts.extend(f"- {e.content[:200]}" for e in errors)
 
         if global_memories:
             context_parts.append("\n## 相关经验")
-            context_parts.extend(f"- {e.summary or e.content}" for e in global_memories)
+            context_parts.extend(f"- {e.summary or e.content[:200]}" for e in global_memories)
 
         if context_parts:
             context.working_memory["memory_context_prompt"] = "\n".join(context_parts)
-
-    async def recall_memory(
-        self,
-        keyword: str = "",
-        time_point: str = "",
-        session_id: str = "",
-        limit: int = 5,
-    ) -> list:
-        """
-        主动召回记忆 —— 根据关键字和时间点搜索历史记忆。
-
-        这是供大模型通过 <recall> 标签调用的工具方法。
-        搜索范围包括全局记忆和会话记忆。
-
-        Args:
-            keyword: 搜索关键字（必填，用于模糊匹配和语义搜索）
-            time_point: 时间参考点（可选），格式如 "2025-01" 或 "2025-01-15"
-                        系统会将其转换为 start_time 进行时间范围过滤
-            session_id: 会话 ID（可选，为空则跨会话搜索）
-            limit: 返回数量（默认 5）
-
-        Returns:
-            匹配的记忆列表，每项包含 content, created_at, key, category
-        """
-        if not self.memory:
-            return []
-
-        # 解析 time_point 为 start_time
-        start_time = ""
-        if time_point:
-            # 支持多种格式: "2025-01", "2025-01-15", "2025年1月"
-            import re as _re
-            # 尝试 "YYYY年MM月" 格式
-            m = _re.match(r"(\d{4})年(\d{1,2})月", time_point)
-            if m:
-                start_time = f"{m.group(1)}-{int(m.group(2)):02d}-01 00:00:00"
-            else:
-                # 尝试 "YYYY-MM" 或 "YYYY-MM-DD"
-                m = _re.match(r"(\d{4})-(\d{1,2})(?:-(\d{1,2}))?", time_point)
-                if m:
-                    year = m.group(1)
-                    month = int(m.group(2))
-                    day = m.group(3)
-                    if day:
-                        start_time = f"{year}-{month:02d}-{int(day):02d} 00:00:00"
-                    else:
-                        start_time = f"{year}-{month:02d}-01 00:00:00"
-
-        # 使用 search_by_time_range 进行精确搜索
-        if start_time or keyword:
-            results = self.memory.search_by_time_range(
-                session_id=session_id,
-                start_time=start_time,
-                keyword=keyword,
-                limit=limit,
-            )
-            if results:
-                return [
-                    {
-                        "content": e.content,
-                        "created_at": e.created_at,
-                        "key": e.key,
-                        "category": e.category,
-                        "summary": e.summary,
-                    }
-                    for e in results
-                ]
-
-        # 回退到普通搜索
-        if keyword:
-            results = self.memory.search(
-                query=keyword,
-                session_id=session_id,
-                limit=limit,
-                mode="hybrid",
-            )
-            return [
-                {
-                    "content": e.content,
-                    "created_at": e.created_at,
-                    "key": e.key,
-                    "category": e.category,
-                    "summary": e.summary,
-                }
-                for e in results
-            ]
-
-        return []

package/config.py

@@ -45,7 +45,7 @@ class LLMConfig:
 class MemoryConfig:
     """记忆系统配置"""
     db_path: str = ""                  # SQLite 数据库路径，默认 ~/.myagent/memory.db
-    max_session: int = 500             # 会话记忆最大对话轮数（[v1.15.13] 从 50 提升到 500，避免过早删除历史）
+    max_session: int = 50              # 会话记忆最大对话轮数
     max_working: int = 100             # 任务进度最大条数
     auto_summarize: bool = True        # 自动总结开关
     summarize_threshold: int = 20      # 触发总结的对话轮数
@@ -100,7 +100,6 @@ class ModelEntry:
     input_modes: List[str] = field(default_factory=lambda: ["text"])  # 支持的输入模式: text, image, video, audio
     reasoning: bool = True       # 是否支持推理（如 o1 系列）
     enabled: bool = True
-    is_global_fallback: bool = True  # 是否作为全局兜底模型（保障系统运行的最终兜底模型）
 
 
 @dataclass