myagent-ai 1.15.2 → 1.15.9

package/agents/base.py

@@ -367,6 +367,7 @@ 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

@@ -57,6 +57,7 @@ class MainAgent(BaseAgent):
 <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>
 
@@ -77,7 +78,8 @@ class MainAgent(BaseAgent):
 14. <finish>: 当任务已完成或需要等待用户回应时为 true；否则为 false 继续执行
 15. <finish_reason>: **finish=true 时必须填写**，详细说明结束原因（任务完成/等待用户/信息不足/无法处理等）
 16. <next_step>: **finish=false 时必须填写**，描述下一步计划做什么，要求简洁明确（1-2句话）
-17. 使用中文输出所有内容
+17. <mainsubject>: 为当前对话生成6字以内的简短标题，概括对话主题。仅在对话刚开始的前几轮需要输出，已有标题后留空
+18. 使用中文输出所有内容
 
 ## 上下文中的记忆系统说明
 - <automemory>: 系统自动根据你通过 <remember> 保存的记忆和当前用户输入，搜索出的 top10 相关记忆。这些是你过去主动记住的内容（包含时间信息），可供参考。
@@ -109,14 +111,19 @@ class MainAgent(BaseAgent):
         # 活跃会话上下文追踪（用于消息注入）
         self.active_contexts: Dict[str, AgentContext] = {}
 
-    def init_context_builder(self, memory_manager=None, skill_registry=None, knowledge_base_dir=None):
+    def init_context_builder(self, memory_manager=None, skill_registry=None, knowledge_base_dir=None, context_window=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("Context Builder 已初始化" + (f" (知识库: {knowledge_base_dir})" if knowledge_base_dir else ""))
+        logger.info(f"Context Builder 已初始化 (context_window={context_window})" + (f" (知识库: {knowledge_base_dir})" if knowledge_base_dir else ""))
 
     def _add_exec_event(self, event_type: str, data: Dict):
         """记录一个执行事件（供前端展示）"""
@@ -288,14 +295,24 @@ class MainAgent(BaseAgent):
         Returns:
             True 表示成功存储了新知识，False 表示跳过（重复）或失败
         """
-        if not self.context_builder or not self.context_builder.knowledge_base_dir:
+        if not self.context_builder:
             logger.debug(f"[{task_id}] 知识库未配置，跳过 knowledge 存储")
             return False
 
         from datetime import datetime
         from pathlib import Path
 
-        kb_dir = Path(self.context_builder.knowledge_base_dir)
+        # 优先写入 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
+
         auto_kb_dir = kb_dir / "auto_knowledge"
         auto_kb_dir.mkdir(parents=True, exist_ok=True)
 
@@ -366,7 +383,7 @@ class MainAgent(BaseAgent):
                 f.write(f"\n## {now_str}\n")
                 f.write(content.strip() + "\n")
             logger.info(
-                f"[{task_id}] 知识已存入知识库: {kb_file.name} "
+                f"[{task_id}] 知识已存入知识库: {kb_file} "
                 f"({len(content)} 字符, {len(content.strip().split(chr(10)))} 条)"
             )
             return True
@@ -468,6 +485,12 @@ class MainAgent(BaseAgent):
             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(
@@ -493,6 +516,7 @@ 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:
@@ -538,7 +562,7 @@ class MainAgent(BaseAgent):
                 + self.SYSTEM_PROMPT.split("\n", 1)[1]
             )
             system_content = _prompt_with_placeholder.replace(_CONTEXT_PLACEHOLDER, context_xml)
-            # Step 3: 调用 LLM
+            # Step 3: 构建 LLM 消息（必须包含 role=user，否则 OpenAI 兼容 API 返回 400）
             messages = [Message(role="system", content=system_content)]
 
             if all_tool_outputs:
@@ -547,6 +571,11 @@ 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(
@@ -561,6 +590,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
@@ -575,6 +610,15 @@ 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)
@@ -661,6 +705,7 @@ 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},
@@ -746,6 +791,21 @@ 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
@@ -795,7 +855,9 @@ class MainAgent(BaseAgent):
                     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)
+                # [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)
                 if self.memory:
                     self.memory.add_session(
                         session_id=context.session_id,
@@ -824,6 +886,7 @@ 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},
@@ -1069,7 +1132,9 @@ class MainAgent(BaseAgent):
                     if current_task_plan:
                         final_text += f"\n\n任务计划:\n{current_task_plan}"
                 context.working_memory["final_response"] = final_text
-                await self._emit_v2_event("v2_reasoning", {"content": truncate_str(final_text, 3000)}, stream_callback)
+                # [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)
                 if self.memory:
                     self.memory.add_session(
                         session_id=context.session_id,
@@ -1096,7 +1161,9 @@ class MainAgent(BaseAgent):
                     if current_task_plan:
                         final_text += f"\n\n任务计划:\n{current_task_plan}"
                 context.working_memory["final_response"] = final_text
-                await self._emit_v2_event("v2_reasoning", {"content": truncate_str(final_text, 3000)}, stream_callback)
+                # [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)
                 if self.memory:
                     self.memory.add_session(
                         session_id=context.session_id,

package/core/context_builder.py

@@ -47,17 +47,23 @@ _rag_cache: dict = {}  # {abs_kb_dir: {"rag": KnowledgeRAG, "mtime": str}}
 
 
 def _compute_dir_mtime(dir_path: str) -> str:
-    """计算目录下所有支持文件的修改时间摘要（用于脏检测）"""
+    """计算目录下所有支持文件的修改时间摘要（用于脏检测）
+
+    [v1.15.7] 修复: 使用 os.walk 递归扫描子目录（如 auto_knowledge/），
+    之前仅扫描顶层目录，导致子目录新增文件无法被脏检测发现，
+    造成 RAG 缓存使用过期索引。
+    """
     import os
     _KB_EXTS = {".md", ".txt", ".json", ".csv", ".py", ".js", ".html"}
     mtimes = []
     try:
-        for f in sorted(os.listdir(dir_path)):
-            fp = os.path.join(dir_path, f)
-            if os.path.isfile(fp):
+        for root, dirs, files in os.walk(dir_path):
+            for f in sorted(files):
                 ext = os.path.splitext(f)[1].lower()
                 if ext in _KB_EXTS:
-                    mtimes.append(f"{f}:{os.path.getmtime(fp)}")
+                    fp = os.path.join(root, f)
+                    rel = os.path.relpath(fp, dir_path)
+                    mtimes.append(f"{rel}:{os.path.getmtime(fp)}")
     except OSError:
         pass
     return "|".join(sorted(mtimes))
@@ -92,11 +98,13 @@ class ContextBuilder:
         skill_registry: Optional["SkillRegistry"] = None,
         knowledge_base_dir: Optional[str] = None,
         max_dialog_chars: int = 20000,
+        context_window: int = 128000,
     ) -> None:
         self.memory_manager = memory_manager
         self.skill_registry = skill_registry
         self.knowledge_base_dir = knowledge_base_dir
         self.max_dialog_chars = max_dialog_chars
+        self.context_window = context_window
         # Agent 专属知识库目录（由调用方动态设置，优先于组织知识库）
         self.agent_knowledge_dir: Optional[str] = None
 
@@ -155,7 +163,9 @@ class ContextBuilder:
             self._build_whomi(agent_name, agent_description, agent_override_prompt),
             self._build_memory(query, session_id, recall),
             self._build_knowledge(kb_query),
-            self._build_recent_dialog(conversation_history, self.max_dialog_chars, session_id),
+            # [v1.15.6] 注释掉聊天历史注入 — 仅保留用户最新消息 + 工具回调，
+            # 其他上下文由系统记忆（automemory/recall_memory）自行处理
+            # self._build_recent_dialog(conversation_history, self.max_dialog_chars, session_id),
             self._build_user_input(user_typed_text, user_voice_text),
             self._build_task_plan(task_plan),
             self._build_tools(self.skill_registry),
@@ -332,9 +342,9 @@ class ContextBuilder:
         """
         构建 <knowledge> 段落 —— 知识库 RAG 检索结果。
 
-        搜索优先级:
-        1. Agent 专属知识库 (agent_knowledge_dir) —— 如果有且非空
-        2. 组织知识库 (knowledge_base_dir) —— 兜底
+        [v1.15.7] 用户隔离: 当 agent_knowledge_dir 已设置时，仅搜索当前
+        Agent 专属知识库，不再回退到组织知识库（避免搜索到其他用户的文件）。
+        仅在 agent_knowledge_dir 未设置时才搜索组织知识库（兼容无专属知识库的 Agent）。
 
         Args:
             query: 搜索查询文本（通常为 <get_knowledge> 内容或用户消息）
@@ -342,22 +352,22 @@ class ContextBuilder:
         Returns:
             <knowledge> XML 段落字符串
         """
-        # 优先搜索 Agent 专属知识库
+        # Agent 专属知识库已设置 → 仅搜索当前用户/Agent 的知识
         if self.agent_knowledge_dir:
             agent_result = self._search_knowledge_dir(self.agent_knowledge_dir, query, top_k=5)
             if agent_result:
                 return agent_result
+            # [v1.15.7] 不再回退到组织知识库，避免搜索到其他用户的文件
+            return "<knowledge>\n(未找到相关知识)\n</knowledge>"
 
-        # 回退到组织知识库
+        # 未设置 Agent 专属知识库 → 搜索组织知识库（兼容模式）
         if self.knowledge_base_dir:
             org_result = self._search_knowledge_dir(self.knowledge_base_dir, query, top_k=5)
             if org_result:
                 return org_result
+            return "<knowledge>\n(未找到相关知识)\n</knowledge>"
 
-        # 都没有配置或都为空
-        if not self.knowledge_base_dir and not self.agent_knowledge_dir:
-            return "<knowledge>\n(知识库未配置)\n</knowledge>"
-        return "<knowledge>\n(未找到相关知识)\n</knowledge>"
+        return "<knowledge>\n(知识库未配置)\n</knowledge>"
 
     def _search_knowledge_dir(self, kb_dir: str, query: str, top_k: int = 5) -> str:
         """在指定知识库目录中执行 RAG 搜索并格式化结果
@@ -734,8 +744,8 @@ class ContextBuilder:
             other = len(text) - cn
             return int(cn * 1.3 + other * 0.35)
 
-        # 默认 128K context window
-        window = 128000
+        # 使用配置的 context_window（由 init_context_builder 注入）
+        window = self.context_window
 
         budget = int(window * budget_ratio)
         estimated = _est_tok(context_xml)

package/core/deps_checker.py

@@ -75,6 +75,10 @@ DEPENDENCIES: List[DepInfo] = [
     # ── 语音合成 ──
     DepInfo("edge_tts", "edge-tts", "6.1.0", "tts", "all"),
 
+    # ── 语音识别 (STT) ──
+    DepInfo("faster_whisper", "faster-whisper", "1.0.0", "stt", "all",
+            note="本地语音识别引擎 (首次使用自动下载模型)"),
+
     # ── 浏览器自动化 (ChromeDev MCP) ──
     # Playwright 已移除，浏览器自动化统一使用 ChromeDevTools Protocol (MCP)
     # 需要 Node.js >= 20.19，参见 skills/chromedev_mcp.py
@@ -369,6 +373,7 @@ def ensure_skill_deps(skill_category: str) -> bool:
         "gui": {"gui"},
         "search": {"search"},
         "tts": {"tts"},
+        "stt": {"stt"},
         "tray": {"tray"},
     }
 

package/core/llm.py

@@ -89,6 +89,7 @@ class LLMResponse:
     raw_response: Any = None
     success: bool = True
     error: str = ""
+    reasoning: str = ""  # 推理模型的思考过程 (DeepSeek-R1, o1, o3, QwQ 等)
 
 
 # ==============================================================================
@@ -118,6 +119,7 @@ class LLMClient:
         max_retries: int = 3,
         reasoning: bool = False,
         reasoning_effort: str = "medium",
+        context_window: int = 128000,
         **kwargs,
     ):
         self.provider = provider
@@ -130,6 +132,7 @@ class LLMClient:
         self.max_retries = max_retries
         self.reasoning = reasoning
         self.reasoning_effort = reasoning_effort  # low | medium | high
+        self.context_window = context_window
         self.extra = kwargs
         self._client = None
 
@@ -973,6 +976,7 @@ def get_llm_client() -> LLMClient:
             timeout=cfg.timeout,
             max_retries=cfg.max_retries,
             anthropic_api_key=cfg.anthropic_api_key,
+            context_window=cfg.context_window,
         )
     return _global_llm_client
 

package/core/output_parser.py

@@ -77,6 +77,7 @@ KNOWN_TOP_LEVEL_TAGS = [
     "finish_reason",
     "next_step",
     "response",
+    "mainsubject",  # [v1.15.8] 会话标题自动命名
 ]
 
 # Inner tags inside each <tool>.
@@ -147,6 +148,7 @@ class ParsedOutput:
     finish_reason: str = ""
     next_step: str = ""
     response: str = ""
+    mainsubject: str = ""  # [v1.15.8] 会话标题自动命名（6字以内）
     raw_text: str = ""
     parse_success: bool = False
     needs_correction: bool = False
@@ -444,6 +446,10 @@ def _custom_parse(raw_text: str) -> ParsedOutput:
     raw_val = _extract_tag_content(body, "next_step")
     parsed.next_step = _safe_strip(raw_val)
 
+    # mainsubject [v1.15.8] 会话标题自动命名
+    raw_val = _extract_tag_content(body, "mainsubject")
+    parsed.mainsubject = _safe_strip(raw_val)
+
     # ── Step 3: Parse <remember> (may contain <type> and <content>) ──
     remember_raw = _extract_tag_content(body, "remember")
     if remember_raw.strip():

package/departments/manager.py

@@ -310,6 +310,10 @@ class DepartmentManager:
             **meta,
         }
 
+        # 确保 agent_count 字段存在（meta 中不一定有，需要动态计算）
+        if "agent_count" not in result:
+            result["agent_count"] = len(meta.get("agents", []))
+
         # 列出子部门
         sub_depts = self.list_sub_depts(path)
         result["children"] = sub_depts

package/main.py

@@ -178,6 +178,7 @@ class MyAgentApp:
             max_retries=llm_cfg.max_retries,
             reasoning=llm_cfg.reasoning,
             anthropic_api_key=llm_cfg.anthropic_api_key,
+            context_window=llm_cfg.context_window,
         )
         self.logger.info(f"LLM: {llm_cfg.provider}/{llm_cfg.model}")
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myagent-ai",
-  "version": "1.15.2",
+  "version": "1.15.9",
   "description": "本地桌面端执行型AI助手 - Open Interpreter 风格 | Local Desktop Execution-Oriented AI Assistant",
   "main": "main.py",
   "bin": {

package/start.js

@@ -293,6 +293,7 @@ const CORE_PACKAGES = [
   "pystray>=0.19.5",
   "Pillow>=10.0.0",
   "edge-tts>=6.1.0",
+  "faster-whisper>=1.0.0",
   "anthropic>=0.18.0",
 ];