myagent-ai 1.9.9 → 1.10.1

package/agents/base.py

@@ -142,6 +142,12 @@ class BaseAgent(ABC):
         if tools:
             request_kwargs["tools"] = tools
             request_kwargs["tool_choice"] = "auto"
+        # ── 推理模式 (Reasoning) ──
+        if self.llm.reasoning:
+            if self.llm.provider in self.llm._OPENAI_COMPATIBLE_PROVIDERS or self.llm.provider == "zhipu":
+                request_kwargs["reasoning_effort"] = self.llm.reasoning_effort
+                if self.llm.max_tokens < 8192:
+                    request_kwargs["max_tokens"] = 8192
         request_kwargs.update(kwargs)
 
         full_text = ""
@@ -351,9 +357,13 @@ class BaseAgent(ABC):
                     "arguments": args,
                 })
 
+            # 对于推理模型（如 o1/DeepSeek-R1），如果 content 为空但有 reasoning 内容，
+            # 使用 reasoning 内容作为最终回复
+            final_content = full_text if full_text.strip() else (full_reasoning if full_reasoning.strip() else full_text)
+
             return LLMResponse(
                 success=True,
-                content=full_text,
+                content=final_content,
                 tool_calls=final_tool_calls,
                 finish_reason=finish_reason,
                 model=request_kwargs.get("model", self.llm.model),

package/agents/main_agent.py

@@ -39,8 +39,9 @@ class MainAgent(BaseAgent):
     # =========================================================================
     SYSTEM_PROMPT = """你是一个强内容分析格式转化引擎，要深入分析以下上下文内容：
 
-严格格式化输出以下内容:
+严格以XML格式化输出以下内容:
 <output>
+<response>直接回复用户的内容。这是一段友好、自然的话语，用于向用户说明你正在做什么，或者回应用户的问题/问候。要求简洁、有礼貌、符合对话场景。如果用户只是问候，简单回应即可；如果用户有具体任务，要说明你的计划。</response>
 <usersays_correct>根据用户输入的"usersays"内容，结合上下文优化为新的用户输入，如果"usersays"为空，这里输出为空。</usersays_correct>
 <task_plan>如"context"包含非空"task_plan",则更新它，变为当前输出。否则，根据"context", 以MD 的格式，制定新任务列表。</task_plan>
 
@@ -59,18 +60,19 @@ class MainAgent(BaseAgent):
 
 ## 核心规则
 1. 你必须且只能输出 <output> XML 结构，不要输出任何其他文本
-2. <usersays_correct>: 如果 context 中 usersays 非空，则根据对话语境优化为更准确的用户意图表达
-3. <task_plan>: 使用 Markdown 列表格式，每项包含任务描述和完成状态标记 [x]/[ ]
-4. <toolstocal>: 列出所有需要执行的工具调用，每个工具包含完整的参数说明
-5. <timeout>: 预估超时秒数（简单操作10-30s，文件操作30-60s，网络请求60-120s，数据处理120-300s）
-6. <callback>: 如果该工具的执行结果对后续决策有影响，设为 true；否则设为 false
-7. <remember>: 仅从最新用户输入（userprint 或 usersays_correct）中提炼值得长期记忆的关键信息，不要重复提炼历史对话中已有的记忆。如果本轮没有新信息需要记忆，则为空
-8. <recall>: 描述下一轮执行时需要从记忆库中检索的内容关键词
-9. <get_knowledge>: 如果当前 <knowledge> 内容不足以完成任务，填写需要从知识库搜索的关键词；否则为空
-10. <askuser>: 当信息不足需要用户补充时，在此填写要问的问题
-11. <finish>: 当任务已完成或需要等待用户回应时为 true；否则为 false 继续执行
-12. 使用中文输出所有内容
-13. 优先使用技能系统（skill）而非直接写代码执行
+2. <response>: 必须输出一段直接回复用户的话语（这是用户实际看到的回复），要求简洁友好、自然流畅。不要只输出任务计划而不说话！
+3. <usersays_correct>: 如果 context 中 usersays 非空，则根据对话语境优化为更准确的用户意图表达
+4. <task_plan>: 使用 Markdown 列表格式，每项包含任务描述和完成状态标记 [x]/[ ]
+5. <toolstocal>: 列出所有需要执行的工具调用，每个工具包含完整的参数说明
+6. <timeout>: 预估超时秒数（简单操作10-30s，文件操作30-60s，网络请求60-120s，数据处理120-300s）
+7. <callback>: 如果该工具的执行结果对后续决策有影响，设为 true；否则设为 false
+8. <remember>: 仅从最新用户输入（userprint 或 usersays_correct）中提炼值得长期记忆的关键信息，不要重复提炼历史对话中已有的记忆。如果本轮没有新信息需要记忆，则为空
+9. <recall>: 描述下一轮执行时需要从记忆库中检索的内容关键词
+10. <get_knowledge>: 如果当前 <knowledge> 内容不足以完成任务，填写需要从知识库搜索的关键词；否则为空
+11. <askuser>: 当信息不足需要用户补充时，在此填写要问的问题
+12. <finish>: 当任务已完成或需要等待用户回应时为 true；否则为 false 继续执行
+13. 使用中文输出所有内容
+14. 优先使用技能系统（skill）而非直接写代码执行
 """
 
     def __init__(self, tool_agent=None, memory_agent=None, **kwargs):
@@ -173,8 +175,6 @@ class MainAgent(BaseAgent):
                     stream_callback(event)
             except Exception as e:
                 logger.debug(f"V2 SSE 事件发送失败 ({event_type}): {e}")
-        else:
-            logger.debug(f"[v2-event] {event_type}: {data}")
 
     async def _merge_duplicate_memory(
         self,
@@ -323,12 +323,29 @@ class MainAgent(BaseAgent):
 
         conversation_history = list(context.conversation_history or [])
 
+        # 从 DB 加载历史对话（如果 conversation_history 为空且 memory 可用）
+        if self.memory and not conversation_history:
+            try:
+                db_history = self.memory.get_conversation(
+                    session_id=context.session_id,
+                    limit=100,
+                )
+                if db_history:
+                    conversation_history = [
+                        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}")
+
         # 保存用户消息到短期记忆
         if self.memory:
             self.memory.add_short_term(
                 session_id=context.session_id,
                 role="user",
                 content=context.user_message,
+                key="user_input",
             )
 
         # 加载相关记忆 (recall from previous round or initial load)
@@ -391,7 +408,6 @@ class MainAgent(BaseAgent):
                 + self.SYSTEM_PROMPT.split("\n", 1)[1]
             )
             system_content = _prompt_with_placeholder.replace(_CONTEXT_PLACEHOLDER, context_xml)
-
             # Step 3: 调用 LLM
             messages = [Message(role="system", content=system_content)]
 
@@ -420,6 +436,16 @@ class MainAgent(BaseAgent):
             llm_raw = response.content
             logger.debug(f"[{task_id}] LLM 输出 (前500字): {llm_raw[:500]}")
 
+            # 保存 LLM 原始输出到短期记忆（用于回溯和审计）
+            if self.memory:
+                self.memory.add_short_term(
+                    session_id=context.session_id,
+                    role="assistant",
+                    content=llm_raw,
+                    key="llm_output",
+                    importance=0.3,
+                )
+
             # Step 4: 解析结构化输出
             parsed = parse_output(llm_raw)
 
@@ -452,7 +478,17 @@ class MainAgent(BaseAgent):
                         )
                     break
                 else:
-                    context.working_memory["final_response"] = llm_raw
+                    # 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_short_term(
+                            session_id=context.session_id,
+                            role="assistant",
+                            content=final_text,
+                        )
                     break
 
             warnings = validate_output(parsed)
@@ -463,6 +499,18 @@ class MainAgent(BaseAgent):
             if parsed.usersays_correct:
                 context.working_memory["usersays_correct"] = parsed.usersays_correct
 
+            # Step 5.5: 处理 response — 直接回复用户的内容
+            if parsed.response:
+                response_text = parsed.response.strip()
+                if response_text:
+                    logger.debug(f"[{task_id}] 模型回复用户: {response_text[:100]}")
+                    context.working_memory["model_response"] = response_text
+                    await self._emit_v2_event(
+                        "v2_reasoning",
+                        {"content": response_text},
+                        stream_callback,
+                    )
+
             # Step 6: 处理 remember — 查重+LLM合并后存入长期记忆
             if parsed.remember:
                 try:
@@ -645,11 +693,30 @@ class MainAgent(BaseAgent):
                 )
 
                 # 发送工具结果事件
+                # 提取实际输出：SkillResult 有 output/message/data，ExecResult 有 stdout/stderr
+                def _extract_tool_output(tr):
+                    """从工具结果中提取实际输出文本"""
+                    out = tr.get("output", "")
+                    if out:
+                        return out
+                    out = tr.get("message", "")
+                    if out:
+                        return out
+                    out = tr.get("stdout", "")
+                    if out:
+                        return out
+                    data = tr.get("data")
+                    if data is not None:
+                        return str(data) if not isinstance(data, str) else data
+                    return tr.get("error", "")
+
+                tool_output_text = _extract_tool_output(tool_result)
+
                 await self._emit_v2_event(
                     "v2_tool_result",
                     {"tool": {"toolname": tool_name}, "result": {
                         "success": tool_result.get("success", False),
-                        "output": truncate_str(tool_result.get("output", ""), 3000),
+                        "output": truncate_str(tool_output_text, 3000),
                         "error": truncate_str(tool_result.get("error", ""), 1000),
                         "timed_out": tool_result.get("timed_out", False),
                     }},
@@ -660,7 +727,7 @@ class MainAgent(BaseAgent):
                     "title": f"工具结果: {tool_name}",
                     "tool_name": tool_name,
                     "success": tool_result.get("success", False),
-                    "summary": truncate_str(str(tool_result.get("output", tool_result.get("error", ""))), 500),
+                    "summary": truncate_str(tool_output_text, 500),
                     "result": tool_result,
                 })
 
@@ -671,7 +738,7 @@ class MainAgent(BaseAgent):
                 elif should_callback:
                     need_callback = True
 
-                output_str = tool_result.get("output", "") or tool_result.get("error", "")
+                output_str = tool_output_text
                 tool_outputs_parts.append(
                     f"### {before_call}\n"
                     f"**工具**: {tool_name}\n"
@@ -688,6 +755,23 @@ class MainAgent(BaseAgent):
                     content=f"[工具 {tool_name} 执行完成] {'成功' if tool_result.get('success') else '失败'}",
                 ))
 
+                # 保存工具调用到短期记忆
+                if self.memory:
+                    self.memory.add_short_term(
+                        session_id=context.session_id,
+                        role="assistant",
+                        content=f"调用工具: {tool_name}\n参数: {truncate_str(parms, 1000)}",
+                        key="tool_call",
+                        importance=0.4,
+                    )
+                    self.memory.add_short_term(
+                        session_id=context.session_id,
+                        role="tool",
+                        content=f"[{tool_name}] {'成功' if tool_result.get('success') else '失败'}\n{truncate_str(output_str, 5000)}",
+                        key="tool_result",
+                        importance=0.4,
+                    )
+
             all_tool_outputs = "\n".join(tool_outputs_parts)
 
             # Step 12: 工具执行完毕后，根据 finish 标志决定是否回调 LLM

package/config.py

@@ -23,11 +23,15 @@ from typing import Optional, Dict, Any, List
 class LLMConfig:
     """LLM 大模型配置"""
     provider: str = "openai"           # openai | anthropic | ollama | custom
+    api_type: str = "openai-completions"  # API 类型
     api_key: str = ""
     base_url: str = "https://api.openai.com/v1"
     model: str = "gpt-4"
     temperature: float = 0.1
     max_tokens: int = 4096
+    context_window: int = 128000         # 上下文窗口大小
+    input_modes: List[str] = field(default_factory=lambda: ["text"])  # 支持的输入模式
+    reasoning: bool = False              # 是否支持推理
     timeout: int = 120                 # 请求超时(秒)
     max_retries: int = 3               # 最大重试次数
     # Anthropic 专用
@@ -86,11 +90,15 @@ class ModelEntry:
     id: str = ""                 # 唯一标识符，如 "gpt-4o", "claude-3.5-sonnet"
     name: str = ""               # 显示名称
     provider: str = ""            # openai | anthropic | ollama | zhipu | custom
+    api_type: str = "openai-completions"  # API 类型：openai-completions | openai-chat | anthropic | ollama | custom
     model: str = ""               # API 调用使用的实际模型字符串
     base_url: str = ""            # 自定义 Base URL（空=使用 provider 默认值）
     api_key: str = ""             # 专用 API Key（空=使用全局默认值）
     max_tokens: int = 4096
     temperature: float = 0.1
+    context_window: int = 128000  # 上下文窗口大小（token）
+    input_modes: List[str] = field(default_factory=lambda: ["text"])  # 支持的输入模式: text, image, video, audio
+    reasoning: bool = True       # 是否支持推理（如 o1 系列）
     enabled: bool = True
 
 

package/core/context_builder.py

@@ -118,10 +118,11 @@ class ContextBuilder:
         kb_query = get_knowledge.strip() if get_knowledge else query
 
         sections: List[str] = [
+            self._build_datetime(),
             self._build_whomi(agent_name, agent_description, agent_override_prompt),
             self._build_memory(query, session_id),
             self._build_knowledge(kb_query),
-            self._build_recent_dialog(conversation_history, self.max_dialog_chars),
+            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),
@@ -140,6 +141,24 @@ class ContextBuilder:
     # 各段落构建方法
     # =========================================================================
 
+    def _build_datetime(self) -> str:
+        """
+        构建 <datetime> 段落 —— 当前日期时间（精确到秒）。
+        让 LLM 知道当前时间，以便给出与时间相关的回答。
+        """
+        from datetime import datetime
+        now = datetime.now()
+        weekdays = ["星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日"]
+        date_str = now.strftime("%Y年%m月%d日")
+        time_str = now.strftime("%H:%M:%S")
+        weekday = weekdays[now.weekday()]
+        return (
+            f"<datetime>\n"
+            f"当前时间: {date_str} {weekday} {time_str}\n"
+            f"时间戳: {now.timestamp()}\n"
+            f"</datetime>"
+        )
+
     def _build_whomi(
         self,
         agent_name: str,
@@ -275,16 +294,18 @@ class ContextBuilder:
         self,
         conversation_history: List["Message"],
         max_chars: int,
+        session_id: str = "",
     ) -> str:
         """
         构建 <resentdialog> 段落 —— 近期对话历史。
 
-        将对话格式化为带角色标签的文本，并截断到指定最大字符数。
-        保留 agent (assistant) 和 user 的消息，使用中文标签。
+        将对话格式化为带角色标签的文本。当历史过长时，将较早的消息
+        压缩为摘要，保留近期消息完整呈现，总字符数不超过 max_chars。
 
         Args:
             conversation_history: 对话历史消息列表
             max_chars: 最大字符数限制
+            session_id: 会话 ID（用于 MemoryManager 摘要）
 
         Returns:
             <resentdialog> XML 段落字符串
@@ -300,32 +321,126 @@ class ContextBuilder:
             "tool": "工具",
         }
 
-        # 格式化每条消息
-        formatted_lines: List[str] = []
+        # 过滤空消息并格式化
+        filtered_msgs: List[tuple] = []
         for msg in conversation_history:
             role = getattr(msg, "role", "user")
             content = getattr(msg, "content", "")
             if not content.strip():
                 continue
-
             label = role_labels.get(role, role)
-            formatted_lines.append(f"[{label}] {_xml_escape(content.strip())}")
+            filtered_msgs.append((label, content.strip()))
+
+        if not filtered_msgs:
+            return "<resentdialog>\n(无对话历史)\n</resentdialog>"
+
+        # 当消息超过阈值时，将旧消息压缩为摘要
+        SUMMARY_THRESHOLD = 30  # 超过30条时启用摘要
+        RECENT_KEEP = 15        # 保留最近15条完整消息
+        SUMMARY_BUDGET = 3000   # 摘要最大字符数
+
+        prefix_text = ""
+        recent_msgs = filtered_msgs
+
+        if len(filtered_msgs) > SUMMARY_THRESHOLD:
+            old_msgs = filtered_msgs[:-RECENT_KEEP]
+            recent_msgs = filtered_msgs[-RECENT_KEEP:]
+            prefix_text = self._build_dialog_summary(old_msgs, SUMMARY_BUDGET)
+
+        # 格式化近期消息
+        formatted_lines: List[str] = []
+        if prefix_text:
+            formatted_lines.append(prefix_text)
+            formatted_lines.append("")  # 空行分隔
+
+        for label, content in recent_msgs:
+            formatted_lines.append(f"[{label}] {_xml_escape(content)}")
 
         dialog_text = "\n".join(formatted_lines)
 
-        # 截断到最大字符数
+        # Token 预算裁剪：超预算时从最早的消息开始移除
         if len(dialog_text) > max_chars:
-            # 从尾部截断，避免丢失最新的对话
-            dialog_text = dialog_text[-max_chars:]
-            # 从截断点找到最近的换行符以保持完整性
-            newline_pos = dialog_text.find("\n")
-            if newline_pos > 0 and newline_pos < 500:
-                dialog_text = dialog_text[newline_pos + 1:]
-            # 添加截断标记
-            dialog_text = "(... 前面的对话已被截断 ...)\n" + dialog_text
+            # 保留摘要前缀，裁剪近期消息部分
+            if prefix_text:
+                # 先尝试只裁剪近期消息
+                recent_budget = max_chars - len(prefix_text) - 100
+                if recent_budget < 500:
+                    # 摘要本身太长，整体裁剪
+                    dialog_text = dialog_text[-max_chars:]
+                else:
+                    recent_part = "\n".join(formatted_lines[len(formatted_lines) - len(recent_msgs):])
+                    if len(recent_part) > recent_budget:
+                        recent_part = self._trim_messages_from_start(recent_part, recent_budget)
+                    dialog_text = prefix_text + "\n\n" + recent_part
+            else:
+                dialog_text = self._trim_messages_from_start(dialog_text, max_chars)
+            dialog_text = "(... 前面的对话已被裁剪 ...)\n" + dialog_text
 
         return f"<resentdialog>\n{dialog_text}\n</resentdialog>"
 
+    def _build_dialog_summary(self, old_msgs: List[tuple], max_chars: int) -> str:
+        """
+        将旧消息列表压缩为摘要文本。
+
+        策略: 提取每条消息的第一行作为要点，保留关键信息的同时大幅压缩篇幅。
+        如果有 MemoryManager，也可以调用 LLM 生成摘要（未来扩展）。
+
+        Args:
+            old_msgs: (label, content) 元组列表
+            max_chars: 摘要最大字符数
+
+        Returns:
+            摘要文本字符串
+        """
+        if not old_msgs:
+            return ""
+
+        summary_parts: List[str] = ["[历史对话摘要]"]
+        for label, content in old_msgs:
+            # 提取第一行或前100字符作为要点
+            first_line = content.split("\n")[0].strip()
+            if len(first_line) > 100:
+                first_line = first_line[:100] + "..."
+            summary_parts.append(f"- [{label}] {first_line}")
+
+        summary_text = "\n".join(summary_parts)
+
+        # 摘要本身也要限制长度
+        if len(summary_text) > max_chars:
+            summary_text = summary_text[:max_chars] + "\n... (更多历史已省略)"
+
+        return summary_text
+
+    def _trim_messages_from_start(self, text: str, max_chars: int) -> str:
+        """
+        从文本开头裁剪消息，保留尾部（最新消息优先）。
+
+        按行（即按消息）为单位裁剪，避免在消息中间截断。
+
+        Args:
+            text: 格式化后的对话文本
+            max_chars: 最大保留字符数
+
+        Returns:
+            裁剪后的文本
+        """
+        if len(text) <= max_chars:
+            return text
+
+        lines = text.split("\n")
+        result_lines: List[str] = []
+        total = 0
+
+        # 从后往前添加行，保留最新的消息
+        for line in reversed(lines):
+            if total + len(line) + 1 > max_chars:
+                break
+            result_lines.append(line)
+            total += len(line) + 1
+
+        result_lines.reverse()
+        return "\n".join(result_lines)
+
     def _build_user_input(
         self,
         user_typed_text: str,

package/core/logger.py

@@ -148,6 +148,12 @@ def setup_logger(
     # 控制台输出
     if console:
         ch = logging.StreamHandler(sys.stdout)
+        # Windows 兼容 UTF-8
+        if sys.platform == "win32":
+            try:
+                sys.stdout.reconfigure(encoding="utf-8")
+            except Exception:
+                pass
         ch.setFormatter(ColorFormatter(fmt, datefmt=datefmt))
         ch.setLevel(logging.DEBUG)  # 控制台始终显示所有级别
         logger.addHandler(ch)
@@ -216,7 +222,16 @@ def get_logger(name: str = "myagent") -> logging.Logger:
     """获取已存在的 Logger，如果不存在则创建默认的"""
     logger = logging.getLogger(name)
     if not logger.handlers:
-        return setup_logger(name)
+        # 子 logger 继承父 logger 的 handlers（如文件 handler）
+        parent_logger = logging.getLogger()
+        if parent_logger.handlers:
+            for handler in parent_logger.handlers:
+                logger.addHandler(handler)
+            logger.setLevel(parent_logger.level)
+            logger.propagate = parent_logger.propagate
+        else:
+            # 没有父 logger，创建默认配置
+            return setup_logger(name)
     return logger