myagent-ai 1.13.1 → 1.13.2

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.2",
   "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
 
@@ -3054,10 +3057,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 +3167,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/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);