myagent-ai 1.28.1 → 1.28.2

package/agents/main_agent.py

@@ -802,7 +802,7 @@ class MainAgent(BaseAgent):
             # Step 1: 构建 Context XML
             # 获取 MemoryAgent 预加载的用户偏好/错误模式（如果有）
             _memory_ctx_prompt = context.working_memory.get("memory_context_prompt", "")
-            context_xml = self.context_builder.build_context(
+            context_xml, context_static_xml, context_dynamic_xml = self.context_builder.build_context(
                 agent_name=agent_name,
                 agent_description=agent_description,
                 session_id=context.session_id,
@@ -823,18 +823,26 @@ class MainAgent(BaseAgent):
                 stream_callback,
             )
 
-            # Step 2: 构建系统消息 — 将 context XML 插入 SYSTEM_PROMPT 的 "上下文" 占位处
+            # Step 2: 构建系统消息 — 拆分为静态（可缓存）和动态两部分
+            # 静态部分：SYSTEM_PROMPT 主体 + 工具列表 + 技能指令 + Agent 信息 + 运行环境
+            # 动态部分：datetime + 记忆 + 知识库 + 对话历史 + 用户输入 + 任务计划
             _CONTEXT_PLACEHOLDER = "__CONTEXT_PLACEHOLDER__"
-            _prompt_with_placeholder = (
-                "你是一个智能AI助手，请深入分析以下上下文内容。\n\n"
-                + _CONTEXT_PLACEHOLDER + "\n\n"
-                + self.SYSTEM_PROMPT.split("\n", 1)[1]
-            )
-            system_content = _prompt_with_placeholder.replace(_CONTEXT_PLACEHOLDER, context_xml)
-            system_content = system_content + "\n最后，再检查输出格式，确保满足以下要求:" + self.xml_prompt
+            _prompt_header = "你是一个智能AI助手，请深入分析以下上下文内容。\n\n"
+            _prompt_tail = self.SYSTEM_PROMPT.split("\n", 1)[1] + "\n最后，再检查输出格式，确保满足以下要求:" + self.xml_prompt
+
+            # 构建 system 内容：[静态缓存头] + [动态区] + [静态尾]
+            # 这样同一个 session 的多轮对话中，静态部分可被 API 提供商缓存
+            static_head = _prompt_header + context_static_xml + "\n\n" + _prompt_tail
+            dynamic_mid = context_dynamic_xml
+
+            # 使用 content_parts 构建 Message（llm.py 会根据 provider 格式化）
+            content_parts = [
+                {"type": "text", "text": static_head, "cache_control": True},    # 可缓存
+                {"type": "text", "text": dynamic_mid},                           # 动态，不缓存
+            ]
             
             # Step 3: 构建 LLM 消息（必须包含 role=user，否则 OpenAI 兼容 API 返回 400）
-            messages = [Message(role="system", content=system_content)]
+            messages = [Message(role="system", content=content_parts)]
 
             if all_tool_outputs:
                 messages.append(Message(

package/core/context_builder.py

@@ -162,32 +162,43 @@ class ContextBuilder:
         # 优先使用 get_knowledge（LLM 指定的检索关键词），否则使用用户消息
         kb_query = get_knowledge.strip() if get_knowledge else query
 
-        sections: List[str] = [
-            self._build_datetime(),
+        # ── [v1.28.1] 按缓存特性分两组：静态段落（可缓存） vs 动态段落（每次变化） ──
+        # 静态段落：同 session 内基本不变，适合 prompt caching
+        static_sections: List[str] = [
             self._build_whomi(agent_name, agent_description, agent_override_prompt, agent_path=agent_path),
+            self._build_tools(self.skill_registry),
+            self._build_skill_prompts(self.skill_registry),
+            self._build_runtime_env(),
+        ]
+        # 动态段落：每轮 LLM 调用都可能不同
+        dynamic_sections: List[str] = [
+            self._build_datetime(),
             self._build_memory(query, session_id, recall, memory_context_prompt),
             self._build_knowledge(kb_query),
             # 轻量近期对话兜底：最近 3 轮对话摘要，补充 automemory 搜索的盲区
             self._build_recent_summary(session_id),
             self._build_user_input(user_typed_text, user_voice_text),
             self._build_task_plan(task_plan),
-            self._build_tools(self.skill_registry),
-            self._build_skill_prompts(self.skill_registry),
-            self._build_runtime_env(),
             self._build_exec_warnings(),
         ]
 
-        context_body = "\n".join(sections)
+        # 合并为完整 context XML（保持向后兼容）
+        all_sections = static_sections + dynamic_sections
+        context_body = "\n".join(all_sections)
         context_xml = f"<context>\n{context_body}\n</context>"
 
         # ── Token 预算检查与自动裁剪 ──
         context_xml = self._enforce_token_budget(context_xml)
 
+        # 构建静态/动态 XML 片段（供 prompt caching 使用）
+        static_xml = "<context>\n" + "\n".join(static_sections)
+        dynamic_xml = "\n".join(dynamic_sections) + "\n</context>"
+
         logger.debug(
             f"上下文已构建 (session={session_id}, 对话条数={len(conversation_history)}, "
-            f"context长度={len(context_xml)})"
+            f"context长度={len(context_xml)}, static={len(static_xml)}, dynamic={len(dynamic_xml)})"
         )
-        return context_xml
+        return context_xml, static_xml, dynamic_xml
 
     # =========================================================================
     # 各段落构建方法

package/core/llm.py

@@ -49,7 +49,25 @@ class Message:
     metadata: Dict[str, Any] = field(default_factory=dict)
 
     def to_dict(self) -> dict:
-        result = {"role": self.role, "content": self.content}
+        # [v1.28.1] 处理带 cache_control 的 content parts
+        # content_parts: [{"type": "text", "text": "...", "cache_control": True}, ...]
+        # - OpenAI/兼容: 直接作为 content 数组发送（前缀相同会自动缓存）
+        # - Anthropic: 在 _chat_anthropic/_stream_anthropic 中提取并添加 cache_control
+        if isinstance(self.content, list) and self.content and isinstance(self.content[0], dict):
+            # 多模态 / content-parts 格式
+            cleaned = []
+            for item in self.content:
+                part = {"type": item.get("type", "text"), "text": item.get("text", "")}
+                # 保留 image_url 类型的完整结构
+                if item.get("type") == "image_url":
+                    part["image_url"] = item["image_url"]
+                # 保留 cache_control 标记（供 Anthropic 路径使用）
+                if item.get("cache_control"):
+                    part["cache_control"] = item["cache_control"]
+                cleaned.append(part)
+            result = {"role": self.role, "content": cleaned}
+        else:
+            result = {"role": self.role, "content": self.content}
         if self.name:
             result["name"] = self.name
         if self.tool_call_id:
@@ -238,6 +256,22 @@ class LLMClient:
     # 所有使用 OpenAI 兼容接口的提供商
     _OPENAI_COMPATIBLE_PROVIDERS = ("openai", "custom", "modelscope", "deepseek", "moonshot", "qwen", "dashscope")
 
+    @staticmethod
+    def _strip_cache_control(messages: list) -> list:
+        """[v1.28.1] 从消息列表中移除 cache_control 标记（OpenAI 不识别此字段）"""
+        cleaned = []
+        for msg in messages:
+            m = dict(msg)
+            content = m.get("content")
+            if isinstance(content, list):
+                new_content = []
+                for part in content:
+                    p = {k: v for k, v in part.items() if k != "cache_control"}
+                    new_content.append(p)
+                m["content"] = new_content
+            cleaned.append(m)
+        return cleaned
+
     @staticmethod
     def _convert_to_anthropic_content(content):
         """将 OpenAI Vision 格式的 content 转换为 Anthropic 格式
@@ -323,15 +357,19 @@ class LLMClient:
         logger.info(f"AsyncOpenAI 客户端已初始化 (model={self.model})")
 
     def _init_anthropic(self):
-        """初始化 Anthropic 客户端"""
+        """初始化 Anthropic 客户端（启用 prompt caching）"""
         try:
             import anthropic
             key = self.extra.get("anthropic_api_key") or self.api_key
             if not key:
                 raise ValueError("Anthropic API Key 未设置")
-            self._client = anthropic.Anthropic(api_key=key)
+            # [v1.28.1] 启用 prompt-caching beta 功能
+            self._client = anthropic.Anthropic(
+                api_key=key,
+                default_headers={"anthropic-beta": "prompt-caching-2024-07-31"},
+            )
             self.model = self.model or "claude-3-sonnet-20240229"
-            logger.info(f"Anthropic 客户端已初始化 (model={self.model})")
+            logger.info(f"Anthropic 客户端已初始化 (model={self.model}, prompt-caching=on)")
         except ImportError:
             raise ImportError("请安装 anthropic: pip install anthropic")
 
@@ -514,7 +552,10 @@ class LLMClient:
     # ------------------------------------------------------------------
 
     async def _chat_openai(self, kwargs: dict) -> LLMResponse:
-        """OpenAI / 兼容接口调用 (异步)"""
+        """OpenAI / 兼容接口调用（异步）— 自动前缀缓存无需额外参数"""
+        # [v1.28.1] 清理 cache_control 标记（OpenAI 不识别此字段，依赖自动前缀缓存）
+        _cleaned_msgs = self._strip_cache_control(kwargs.get("messages", []))
+        kwargs = {**kwargs, "messages": _cleaned_msgs}
         try:
             response = await self._client.chat.completions.create(**kwargs)
         except Exception as api_err:
@@ -590,11 +631,11 @@ class LLMClient:
         )
 
     async def _chat_anthropic(self, messages: List[Message], kwargs: dict) -> LLMResponse:
-        """Anthropic Claude 接口调用"""
+        """Anthropic Claude 接口调用（支持 prompt caching）"""
         loop = asyncio.get_running_loop()
 
         # 转换消息格式
-        system_msg = ""
+        system_msg = None
         anth_messages = []
         for m in messages:
             if m.role == "system":
@@ -610,7 +651,19 @@ class LLMClient:
             "max_tokens": self.max_tokens,
         }
         if system_msg:
-            create_kwargs["system"] = system_msg
+            # [v1.28.1] 支持 content block 格式（带 cache_control）
+            # system_msg 可以是 str 或 list[dict]
+            if isinstance(system_msg, list):
+                # content-parts 格式：转换为 Anthropic cache_control 格式
+                anth_system = []
+                for part in system_msg:
+                    block = {"type": "text", "text": part.get("text", "")}
+                    if part.get("cache_control"):
+                        block["cache_control"] = {"type": "ephemeral"}
+                    anth_system.append(block)
+                create_kwargs["system"] = anth_system
+            else:
+                create_kwargs["system"] = system_msg
 
         response = await loop.run_in_executor(
             None, lambda: self._client.messages.create(**create_kwargs)
@@ -628,12 +681,22 @@ class LLMClient:
         if not content.strip() and _reasoning.strip():
             content = _reasoning
 
+        # [v1.28.1] 记录缓存使用情况
+        _usage = {
+            "input_tokens": getattr(response.usage, "input_tokens", 0) or 0,
+            "output_tokens": getattr(response.usage, "output_tokens", 0) or 0,
+        }
+        if hasattr(response.usage, "cache_creation_input_tokens"):
+            _cc = response.usage.cache_creation_input_tokens or 0
+            _cr = response.usage.cache_read_input_tokens or 0
+            if _cc or _cr:
+                _usage["cache_creation"] = _cc
+                _usage["cache_read"] = _cr
+                logger.info(f"[Anthropic Prompt Cache] 创建={_cc} 读取={_cr} tokens")
+
         return LLMResponse(
             content=content,
-            usage={
-                "input_tokens": response.usage.input_tokens,
-                "output_tokens": response.usage.output_tokens,
-            },
+            usage=_usage,
             model=response.model,
             finish_reason=response.stop_reason or "",
             reasoning=_reasoning,
@@ -730,12 +793,15 @@ class LLMClient:
             raise
 
     async def _stream_openai(self, kwargs: dict) -> AsyncGenerator[str, None]:
-        """OpenAI / 兼容接口 (含 Zhipu) 流式调用
+        """OpenAI / 兼容接口 (含 Zhipu) 流式调用 — 自动前缀缓存
 
         支持两种客户端:
         - AsyncOpenAI: 使用 async for 直接异步迭代
         - 同步 OpenAI: 在 executor 中同步迭代
         """
+        # [v1.28.1] 清理 cache_control 标记
+        _cleaned_msgs = self._strip_cache_control(kwargs.get("messages", []))
+        kwargs = {**kwargs, "messages": _cleaned_msgs}
         # 判断客户端类型，选择合适的流式迭代方式
         is_async = hasattr(self._client, '__aenter__')
 
@@ -764,11 +830,11 @@ class LLMClient:
     async def _stream_anthropic(
         self, messages: List[Message], kwargs: dict
     ) -> AsyncGenerator[str, None]:
-        """Anthropic Claude 流式调用"""
+        """Anthropic Claude 流式调用（支持 prompt caching）"""
         loop = asyncio.get_running_loop()
 
         # 转换消息格式
-        system_msg = ""
+        system_msg = None
         anth_messages = []
         for m in messages:
             if m.role == "system":
@@ -785,7 +851,17 @@ class LLMClient:
             "stream": True,
         }
         if system_msg:
-            create_kwargs["system"] = system_msg
+            # [v1.28.1] 支持 content block 格式（带 cache_control）
+            if isinstance(system_msg, list):
+                anth_system = []
+                for part in system_msg:
+                    block = {"type": "text", "text": part.get("text", "")}
+                    if part.get("cache_control"):
+                        block["cache_control"] = {"type": "ephemeral"}
+                    anth_system.append(block)
+                create_kwargs["system"] = anth_system
+            else:
+                create_kwargs["system"] = system_msg
 
         def _create_stream():
             return self._client.messages.create(**create_kwargs)
@@ -806,6 +882,13 @@ class LLMClient:
             if event.type == "content_block_delta":
                 if hasattr(event.delta, "text"):
                     yield event.delta.text
+            # [v1.28.1] 记录流式缓存的 usage
+            elif event.type == "message_delta":
+                if hasattr(event, "usage"):
+                    _cr = getattr(event.usage, "cache_read_input_tokens", 0) or 0
+                    _cc = getattr(event.usage, "cache_creation_input_tokens", 0) or 0
+                    if _cc or _cr:
+                        logger.info(f"[Anthropic Cache/stream] 创建={_cc} 读取={_cr} tokens")
 
     async def _stream_ollama(self, kwargs: dict) -> AsyncGenerator[str, None]:
         """Ollama 流式调用"""

package/package.json

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