myagent-ai 1.13.1 → 1.13.3

package/core/context_builder.py

@@ -42,6 +42,27 @@ if TYPE_CHECKING:
 logger = get_logger("myagent.context_builder")
 
 
+# ── 知识库 RAG 索引缓存（模块级，避免每次 LLM 调用重建） ──
+_rag_cache: dict = {}  # {abs_kb_dir: {"rag": KnowledgeRAG, "mtime": str}}
+
+
+def _compute_dir_mtime(dir_path: str) -> str:
+    """计算目录下所有支持文件的修改时间摘要（用于脏检测）"""
+    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):
+                ext = os.path.splitext(f)[1].lower()
+                if ext in _KB_EXTS:
+                    mtimes.append(f"{f}:{os.path.getmtime(fp)}")
+    except OSError:
+        pass
+    return "|".join(sorted(mtimes))
+
+
 # 默认知识库目录名（相对于 data_dir）
 _DEFAULT_KB_RELATIVE_PATH = "knowledge"
 
@@ -143,6 +164,9 @@ class ContextBuilder:
         context_body = "\n".join(sections)
         context_xml = f"<context>\n{context_body}\n</context>"
 
+        # ── Token 预算检查与自动裁剪 ──
+        context_xml = self._enforce_token_budget(context_xml)
+
         logger.debug(
             f"上下文已构建 (session={session_id}, 对话条数={len(conversation_history)}, "
             f"context长度={len(context_xml)})"
@@ -336,7 +360,10 @@ class ContextBuilder:
         return "<knowledge>\n(未找到相关知识)\n</knowledge>"
 
     def _search_knowledge_dir(self, kb_dir: str, query: str, top_k: int = 5) -> str:
-        """在指定知识库目录中执行 RAG 搜索并格式化结果"""
+        """在指定知识库目录中执行 RAG 搜索并格式化结果
+
+        使用模块级缓存 + 文件修改时间脏检测，避免每次 LLM 调用都重建索引。
+        """
         import os as _os
 
         if not query.strip():
@@ -348,8 +375,30 @@ class ContextBuilder:
         try:
             from knowledge.rag import KnowledgeRAG
 
-            rag = KnowledgeRAG(kb_dir=kb_dir)
-            rag.build_index()
+            # ── 缓存键: 目录绝对路径 ──
+            abs_kb = _os.path.abspath(kb_dir)
+            cache = _rag_cache.get(abs_kb)
+            need_rebuild = True
+
+            if cache is not None:
+                # 脏检测: 比较上次记录的文件修改时间摘要
+                current_mtime = _compute_dir_mtime(abs_kb)
+                if current_mtime == cache["mtime"]:
+                    need_rebuild = False
+                else:
+                    logger.debug(f"知识库目录变更检测到 ({abs_kb})，重建索引")
+
+            if need_rebuild:
+                rag = KnowledgeRAG(kb_dir=kb_dir)
+                rag.build_index()
+                _rag_cache[abs_kb] = {
+                    "rag": rag,
+                    "mtime": _compute_dir_mtime(abs_kb),
+                }
+                rebuild_tag = "重新" if cache else ""
+                logger.debug(f"知识库索引已{rebuild_tag}构建: {rag.total_chunks} 块 ({abs_kb})")
+            else:
+                rag = cache["rag"]
 
             if rag.total_chunks == 0:
                 return ""
@@ -648,6 +697,87 @@ class ContextBuilder:
         lines.append("</tools>")
         return "\n".join(lines)
 
+    # =========================================================================
+    # Token 预算管理
+    # =========================================================================
+
+    def _enforce_token_budget(self, context_xml: str, budget_ratio: float = 0.75) -> str:
+        """
+        Token 预算检查与自动裁剪。
+
+        估算 context_xml 的 token 数，如果超过 budget_ratio * context_window，
+        按优先级裁剪（先裁剪 <knowledge>、<recall_memory>、<automemory>，
+        再裁剪 <resentdialog> 历史部分）。
+
+        Args:
+            context_xml: 完整的 <context> XML 字符串
+            budget_ratio: 上下文窗口使用比例上限（默认 75%，为系统提示和输出预留空间）
+
+        Returns:
+            裁剪后的 context_xml
+        """
+        if not context_xml:
+            return context_xml
+
+        # 粗略估算 token: 中文约 1.3 token/字，英文约 0.35 token/字
+        def _est_tok(text: str) -> int:
+            if not text:
+                return 0
+            cn = sum(1 for c in text if '\u4e00' <= c <= '\u9fff')
+            other = len(text) - cn
+            return int(cn * 1.3 + other * 0.35)
+
+        # 默认 128K context window
+        window = 128000
+
+        budget = int(window * budget_ratio)
+        estimated = _est_tok(context_xml)
+
+        if estimated <= budget:
+            return context_xml
+
+        logger.warning(
+            f"上下文 token 估算 ({estimated}) 超出预算 ({budget} = {budget_ratio}*{window}), "
+            f"启动自动裁剪 (原始长度={len(context_xml)} 字符)"
+        )
+
+        import re
+
+        def _remove_section(xml: str, tag: str) -> str:
+            pattern = rf'<{tag}>[\s\S]*?</{tag}>'
+            replacement = f'<{tag}>\n(因 token 预算不足已裁剪)\n</{tag}>'
+            return re.sub(pattern, replacement, xml, count=1, flags=re.DOTALL)
+
+        # 按优先级从低到高裁剪
+        for tag in ['knowledge', 'recall_memory', 'automemory']:
+            if estimated <= budget:
+                break
+            if f'<{tag}>' in context_xml:
+                context_xml = _remove_section(context_xml, tag)
+                estimated = _est_tok(context_xml)
+                logger.debug(f"裁剪 <{tag}> 后 token 估算: {estimated}")
+
+        # 如果还超预算，截断 <resentdialog> 内容
+        if estimated > budget:
+            pattern = r'<resentdialog>\n([\s\S]*?)\n</resentdialog>'
+            match = re.search(pattern, context_xml)
+            if match:
+                dialog_text = match.group(1)
+                target_chars = int(budget / 1.3)
+                if len(dialog_text) > target_chars:
+                    truncated = dialog_text[-target_chars:]
+                    truncated = "(... 历史已因 token 预算不足裁剪 ...)\n" + truncated
+                    context_xml = (
+                        context_xml[:match.start(1)] + truncated + context_xml[match.end(1):]
+                    )
+                    estimated = _est_tok(context_xml)
+                    logger.debug(f"截断对话历史后 token 估算: {estimated}")
+
+        if estimated > budget:
+            logger.warning(f"上下文裁剪后仍超出预算 (token={estimated}/{budget})")
+
+        return context_xml
+
 
 # =============================================================================
 # 工具函数

package/package.json

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

package/web/api_server.py

@@ -155,6 +155,9 @@ class ApiServer:
         self._msg_queues: Dict[str, List[Dict]] = {}
         # 任务列表内存存储（exec 模式，替代 task.md）
         self._task_list_store: dict[str, list] = {}  # session_id -> [{text, status}]  (per-session, not per-agent)
+        # 模型链并发锁：防止并发请求互相覆盖 self.core.llm 配置
+        import asyncio
+        self._model_chain_lock = asyncio.Lock()
         self._setup_routes()
         self._runner: Optional[web.AppRunner] = None
 
@@ -1031,23 +1034,25 @@ class ApiServer:
         base_instruction = (
             "你当前处于【执行模式】(Execution Mode)。\n\n"
             "## 核心规则\n"
-            "1. **任务列表（强制）**：每次回复【必须】包含一个 ```tasklist``` 代码块，内含 JSON 数组格式的任务进度。\n"
+            "1. **任务列表（按复杂度决定）**：\n"
+            "   - 如果用户的需求是简单任务（预计操作步骤不超过5步，如：单次查询、简单计算、问答题、格式转换、文件读取等），【不要】使用 ```tasklist```，直接用纯文本回复并执行即可。\n"
+            "   - 只有当任务较复杂（预计需要超过5步操作，如：多文件修改、需要调研+实现+测试、涉及多个模块联动等），才使用 ```tasklist``` 代码块来跟踪进度。\n"
             "   - 格式：```tasklist\\n[{\"text\": \"步骤描述\", \"status\": \"pending\"}]\\n```\n"
             "   - status 可选值：pending(待执行)、running(进行中)、done(已完成)、blocked(受阻)\n"
-            "   - 首次收到任务时，拆分为多个步骤，全部标记为 pending\n"
+            "   - 首次收到复杂任务时，拆分为多个步骤，全部标记为 pending\n"
             "   - 每次执行完一个步骤后，更新对应步骤状态为 done，下一个为 running\n"
             "2. **单步执行（强制）**：每次回复【只能执行一个操作】（一个工具调用、一个代码块或一个技能调用）。\n"
             "   - 执行完一个操作后停下来，等待结果反馈后再决定下一步\n"
             "   - 不要一次性执行多个操作\n"
-            "3. **回复格式**：先写纯文本分析/总结 → 再写 ```tasklist``` 更新进度 → 最后写 ```action``` 执行操作（如有）\n"
-            "4. **任务完成**：当所有步骤都标记为 done 时，用 ```action``` 输出 {\"type\": \"final_answer\", \"content\": \"...\"} 结束任务。\n"
+            "3. **回复格式**：先写纯文本分析/总结 → 如有任务列表则用 ```tasklist``` 更新进度 → 最后用 ```action``` 执行操作（如有）\n"
+            "4. **任务完成**：当使用任务列表且所有步骤都标记为 done 时，用 ```action``` 输出 {\"type\": \"final_answer\", \"content\": \"...\"} 结束任务。简单任务直接回复即可。\n"
         )
 
         # 从内存读取当前任务列表（按 session 隔离）
         store_key = session_id or agent_path
         tasks = self._task_list_store.get(store_key, [])
         if not tasks:
-            return base_instruction + "\n## 当前状态\n暂无任务计划。请先分析用户需求，拆分为具体步骤，然后用 ```tasklist``` 输出计划。"
+            return base_instruction + "\n## 当前状态\n暂无任务计划。如果是简单任务（不超过5步），直接执行即可，无需创建任务列表。如果是复杂任务（超过5步），请先分析用户需求，拆分为具体步骤，然后用 ```tasklist``` 输出计划。"
 
         pending = [f"  - ⏳ {t['text']}" for t in tasks if t.get("status") in ("pending", "running", "blocked")]
         done = [f"  - ✅ {t['text']}" for t in tasks if t.get("status") == "done"]
@@ -3054,10 +3059,22 @@ class ApiServer:
     async def _try_model_chain(self, model_chain: list[dict], message: str, session_id: str,
                                  agent_path: str = None, agent_system_prompt: str = None,
                                  chat_mode: str = "") -> str:
-        """依次尝试模型链中的模型，直到成功或全部失败"""
+        """依次尝试模型链中的模型，直到成功或全部失败
+        
+        使用 asyncio.Lock 保护共享的 self.core.llm，防止并发请求互相干扰。
+        """
         if not model_chain:
             return await self.core.process_message(message, session_id)
 
+        async with self._model_chain_lock:
+            return await self._try_model_chain_inner(model_chain, message, session_id,
+                agent_path=agent_path, agent_system_prompt=agent_system_prompt,
+                chat_mode=chat_mode)
+
+    async def _try_model_chain_inner(self, model_chain: list[dict], message: str, session_id: str,
+                                      agent_path: str = None, agent_system_prompt: str = None,
+                                      chat_mode: str = "") -> str:
+        """_try_model_chain 的实际执行体（已在 _model_chain_lock 保护下）"""
         llm = self.core.llm
         last_error = ""
         used_model_name = ""
@@ -3152,12 +3169,26 @@ class ApiServer:
     async def _try_model_chain_stream(self, model_chain, message, session_id,
                                        agent_path=None, agent_system_prompt=None,
                                        chat_mode="", stream_response=None):
-        """流式版本的模型链调用，逐token输出到SSE"""
+        """流式版本的模型链调用，逐token输出到SSE
+        
+        使用 asyncio.Lock 保护共享的 self.core.llm，防止并发请求互相干扰。
+        """
         if not model_chain:
             result = await self.core.process_message(message, session_id)
             await stream_response.write(("data: " + json.dumps({"type": "text", "content": result}) + "\n\n").encode())
             return result
 
+        async with self._model_chain_lock:
+            return await self._try_model_chain_stream_inner(
+                model_chain, message, session_id,
+                agent_path=agent_path, agent_system_prompt=agent_system_prompt,
+                chat_mode=chat_mode, stream_response=stream_response,
+            )
+
+    async def _try_model_chain_stream_inner(self, model_chain, message, session_id,
+                                             agent_path=None, agent_system_prompt=None,
+                                             chat_mode="", stream_response=None):
+        """_try_model_chain_stream 的实际执行体（已在 _model_chain_lock 保护下）"""
         llm = self.core.llm
         full_text = ""
 

package/web/ui/chat/chat.css

@@ -455,7 +455,7 @@ input,textarea,select{font:inherit}
 
 /* ── Message Content Smooth Render ── */
 .message-content{
-  min-width:0;
+  flex:1;min-width:0;
 }
 .stream-text-node{
   display:inline;

package/web/ui/chat/chat_main.js

@@ -345,15 +345,10 @@ function initChat() {
     document.getElementById('sendBtn').disabled = !this.value.trim();
     saveDraft();
   });
-  // Load task plan if in exec mode (collapsed by default)
+  // Load task plan if in exec mode (panel stays hidden until tasks exist)
   if (state.chatMode === 'exec') {
-    document.getElementById('taskPanel').classList.remove('hidden');
-    // Ensure task body starts collapsed
-    var taskBody = document.getElementById('taskBody');
-    var taskToggle = document.getElementById('taskToggle');
-    if (taskBody) taskBody.classList.remove('expanded');
-    if (taskToggle) taskToggle.classList.remove('expanded');
-    state.taskPanelExpanded = false;
+    // Don't show task panel by default - it will appear when the LLM creates a task list
+    // document.getElementById('taskPanel').classList.remove('hidden');
     loadTaskPlan();
   }
 
@@ -536,7 +531,10 @@ function setMode(mode) {
   } else {
     chatBtn.className = 'mode-btn';
     execBtn.className = 'mode-btn active-exec';
-    taskPanel.classList.remove('hidden');
+    // Only show task panel if tasks already exist (don't show empty panel)
+    if (state.taskItems.length > 0) {
+      taskPanel.classList.remove('hidden');
+    }
     // Default collapsed when switching to exec mode
     var tb = document.getElementById('taskBody');
     var tt = document.getElementById('taskToggle');
@@ -642,7 +640,7 @@ async function loadTaskPlan() {
     var data = await api(url);
     state.taskItems = data.tasks || [];
     renderTaskList();
-    // Auto-show task panel header if tasks exist (don't auto-expand body)
+    // Show/hide task panel based on whether tasks exist
     const panel = document.getElementById('taskPanel');
     if (panel && state.taskItems.length > 0) {
       panel.classList.remove('hidden');
@@ -651,6 +649,9 @@ async function loadTaskPlan() {
         triggerTaskAutoFade();
       }
       // Don't auto-expand the body - user can click to expand manually
+    } else if (panel) {
+      // Hide panel when no tasks exist
+      panel.classList.add('hidden');
     }
   } catch (e) {
     state.taskItems = [];

package/web/ui/chat/flow_engine.js

@@ -393,6 +393,8 @@ function updateStreamingMessage(msgIdx) {
           const newText = msg.reasoning.substring(prevLen);
           thoughtContent.insertAdjacentHTML('beforeend', renderMarkdown(newText));
           reasoningDetails._lastReasoningLen = msg.reasoning.length;
+          // 自动滚动推理框内部内容到底部（不滚动整个页面）
+          thoughtContent.scrollTop = thoughtContent.scrollHeight;
         }
       } else if (thoughtContent && !msg.streaming) {
         // Final render once streaming stops
@@ -443,6 +445,8 @@ function updateStreamingMessage(msgIdx) {
           const newText = msg.thought.substring(prevLen);
           thoughtContent.insertAdjacentHTML('beforeend', renderMarkdown(newText));
           thoughtBlock._lastThoughtLen = msg.thought.length;
+          // 自动滚动思考框内部内容到底部
+          thoughtContent.scrollTop = thoughtContent.scrollHeight;
         }
       } else if (thoughtContent && !msg.streaming) {
         thoughtContent.innerHTML = renderMarkdown(msg.thought);
@@ -499,6 +503,8 @@ function updateStreamingMessage(msgIdx) {
             const newText = msg._v2Reasoning.substring(prevLen);
             thoughtContent.insertAdjacentHTML('beforeend', renderMarkdown(newText));
             v2ReasoningBlock._lastV2Len = msg._v2Reasoning.length;
+            // 自动滚动 V2 推理框内部内容到底部
+            thoughtContent.scrollTop = thoughtContent.scrollHeight;
           }
         } else if (thoughtContent && !msg.streaming) {
           thoughtContent.innerHTML = renderMarkdown(msg._v2Reasoning);
@@ -1203,6 +1209,16 @@ async function sendMessage() {
     sessionId = `${state.activeAgent}_web_${ts}`;
     state.activeSessionId = sessionId;
     document.getElementById('headerTitle').textContent = formatSessionName(sessionId);
+    // ── 立即在左侧边栏添加新会话条目（不等后端返回） ──
+    state.sessions.unshift({
+      id: sessionId,
+      name: formatSessionName(sessionId),
+      messages: 0,
+      last: new Date().toISOString(),
+      preview: '',
+    });
+    state.agentSessions[state.activeAgent] = [...state.sessions];
+    renderSessions();
     // ── 更新 URL 参数，携带会话 ID（刷新页面可恢复） ──
     try {
       const url = new URL(window.location.href);