myagent-ai 1.9.9 → 1.10.0

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,
@@ -391,7 +391,7 @@ class MainAgent(BaseAgent):
                 + self.SYSTEM_PROMPT.split("\n", 1)[1]
             )
             system_content = _prompt_with_placeholder.replace(_CONTEXT_PLACEHOLDER, context_xml)
-
+            print(system_content)
             # Step 3: 调用 LLM
             messages = [Message(role="system", content=system_content)]
 
@@ -452,7 +452,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 +473,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:

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/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
 
 

package/core/output_parser.py

@@ -43,6 +43,10 @@ import xml.etree.ElementTree as ET
 from dataclasses import dataclass, field
 from typing import Any, Dict, List
 
+from core.logger import get_logger
+
+logger = get_logger("myagent.output_parser")
+
 # ---------------------------------------------------------------------------
 # Constants
 # ---------------------------------------------------------------------------
@@ -95,6 +99,7 @@ class ParsedOutput:
     ask_user: str = ""
     get_knowledge: str = ""
     finish: bool = False
+    response: str = ""  # 模型对用户的直接回复（友好自然的话语）
     raw_text: str = ""
     parse_success: bool = False
 
@@ -207,21 +212,149 @@ def _parse_tools_element(tools_element: ET.Element | None) -> List[Dict[str, Any
     return tools
 
 
+def _fix_incomplete_xml(xml_content: str) -> str:
+    """修复不完整的 XML，使用正则表达式补齐格式。
+    
+    支持修复的问题类型：
+    1. 自闭合标签误用：<tag /> → <tag></tag>
+    2. 缺少闭合标签：<tag>value → <tag>value</tag>
+    3. 标签大小写混乱：<TAG>value</TAG> → <tag>value</tag>
+    4. 空白字符问题：< tag >value</ tag >
+    5. 嵌套标签未闭合
+    6. 特殊字符转义：& → &amp; (在属性值中)
+    """
+    if not xml_content:
+        return xml_content
+        
+    # 标准标签列表（用于修复缺少闭合标签）
+    STANDARD_TAGS = [
+        "usersays_correct", "task_plan", "toolstocal", "remember", 
+        "recall", "askuser", "get_knowledge", "finish", "response",
+        "tool", "beforecalltext", "toolname", "parms", "timeout", "callback"
+    ]
+    
+    # 1. 修复自闭合标签为普通标签
+    # <tag /> → <tag></tag>
+    # <tag/> → <tag></tag>
+    xml_content = re.sub(r'<(\w+)\s*/\s*>', r'<\1></\1>', xml_content)
+    
+    # 2. 修复空白字符在标签内的问题：< tag > → <tag>
+    # 同时规范化大小写
+    def normalize_tag(match):
+        inner = match.group(1).strip()
+        tag_name = inner.split()[0].lower()
+        rest = ' '.join(inner.split()[1:])  # 保留可能的属性
+        if rest:
+            return f'<{tag_name} {rest}>'
+        return f'<{tag_name}>'
+    xml_content = re.sub(r'<([a-z_][a-z_0-9]*)[^>]*>', normalize_tag, xml_content, flags=re.IGNORECASE)
+    
+    # 3. 修复闭合标签的大小写和空白：</ TAG > → </tag>
+    def normalize_close_tag(match):
+        tag_name = match.group(1).strip().lower()
+        return f'</{tag_name}>'
+    xml_content = re.sub(r'</\s*([a-z_][a-z_0-9]*)\s*>', normalize_close_tag, xml_content, flags=re.IGNORECASE)
+    
+    # 4. 修复缺少闭合标签的问题
+    # 策略：对于标准标签，如果后面跟着另一个标签或 </output>，则添加闭合标签
+    for tag in STANDARD_TAGS:
+        # 修复 <tag>value<下一个标签> 格式（缺少 </tag>）
+        # 例如：<finish>true<task_plan> → <finish>true</finish><task_plan>
+        next_tag_pattern = '|'.join([re.escape(t) for t in STANDARD_TAGS if t != tag])
+        if next_tag_pattern:
+            # 匹配 <tag>...后面跟着其他标签或 </output>
+            pattern = rf'(<{tag}>)([^<]*?)(?=(?:<{next_tag_pattern}|</output>))'
+            replacement = rf'\1\2</{tag}>'
+            xml_content = re.sub(pattern, replacement, xml_content, flags=re.IGNORECASE | re.DOTALL)
+    
+    # 5. 修复 <toolstocal> 和 </toolstocal> 标签
+    xml_content = re.sub(r'<toolstocal\s*>', '<toolstocal>', xml_content, flags=re.IGNORECASE)
+    xml_content = re.sub(r'</toolstocal\s*>', '</toolstocal>', xml_content, flags=re.IGNORECASE)
+    
+    # 6. 修复 askuser 标签（系统提示中用的是 askuser，但有时可能写成 ask_user）
+    xml_content = re.sub(r'<ask_user\s*>', '<askuser>', xml_content, flags=re.IGNORECASE)
+    xml_content = re.sub(r'</ask_user\s*>', '</askuser>', xml_content, flags=re.IGNORECASE)
+    
+    # 7. 修复单独的 <tool> 块中的标签
+    # 匹配 <tool>... 中缺少闭合标签的情况
+    tool_tags = ["beforecalltext", "toolname", "parms", "timeout", "callback"]
+    tool_next_pattern = '|'.join([re.escape(t) for t in tool_tags])
+    
+    for tag in tool_tags:
+        pattern = rf'(<{tag}>)([^<]*?)(?=(?:<{tool_next_pattern}|</tool>|</toolstocal>|</output>))'
+        replacement = rf'\1\2</{tag}>'
+        xml_content = re.sub(pattern, replacement, xml_content, flags=re.IGNORECASE | re.DOTALL)
+    
+    # 8. 处理文本内容中的特殊 XML 字符（简单处理 &）
+    # 只在标签外的内容中处理
+    # 这个比较复杂，简单处理：在文本内容中 & 后没有 ; 的转为 &amp;
+    # 但更安全的做法是只在必要时处理
+    
+    # 9. 确保 <output> 标签周围没有多余空白
+    xml_content = xml_content.strip()
+    
+    return xml_content
+
+
+def _aggressive_clean_xml(xml_content: str) -> str:
+    """激进清理 XML 内容，移除可能导致解析失败的字符。"""
+    # 移除控制字符（除了换行和 tab）
+    xml_content = re.sub(r'[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]', '', xml_content)
+    
+    # 修复 & 字符（确保它是有效的 XML 实体）
+    # 匹配 & 不在有效实体前的情况
+    xml_content = re.sub(r'&(?!amp;|lt;|gt;|quot;|apos;|#\d+;|#x[0-9a-fA-F]+;)', '&amp;', xml_content)
+    
+    # 移除多余的空白（连续多个空白合并为一个）
+    xml_content = re.sub(r'>\s+<', '><', xml_content)
+    xml_content = re.sub(r'\s{2,}', ' ', xml_content)
+    
+    return xml_content
+
+
 def _parse_xml_content(xml_content: str) -> ParsedOutput:
     """Attempt to parse *xml_content* (the inner body of ``<output>``) as XML.
 
     Assumes *xml_content* has already been extracted from the surrounding
     ``<output>`` tags.  If parsing fails a :class:`ParsedOutput` with
     ``parse_success=False`` is returned.
+    
+    解析策略：
+    1. 首先尝试直接解析
+    2. 如果失败，使用正则表达式修复后再解析
+    3. 如果仍然失败，尝试激进清理
     """
     parsed = ParsedOutput(parse_success=False)
 
+    # Strategy 1: 尝试直接解析原始 XML
     try:
-        root = ET.fromstring(f"<output>{xml_content}</output>")
-    except ET.ParseError:
-        return parsed
-
-    parsed.parse_success = True
+        root = ET.fromstring("<output>" + xml_content + "</output>")
+        parsed.parse_success = True
+        logger.debug(f"XML 直接解析成功")
+    except ET.ParseError as e1:
+        logger.debug(f"XML 直接解析失败: {e1}，尝试修复...")
+        
+        # Strategy 2: 修复不完整的 XML 后再解析
+        fixed_xml = _fix_incomplete_xml(xml_content)
+        logger.debug(f"修复后 XML 前200字符: {fixed_xml[:200]}...")
+        
+        try:
+            root = ET.fromstring("<output>" + fixed_xml + "</output>")
+            parsed.parse_success = True
+            logger.debug(f"XML 修复后解析成功")
+        except ET.ParseError as e2:
+            logger.warning(f"XML 修复后仍然解析失败: {e2}，尝试激进清理...")
+            # Strategy 3: 激进清理
+            cleaned = _aggressive_clean_xml(fixed_xml)
+            try:
+                root = ET.fromstring("<output>" + cleaned + "</output>")
+                parsed.parse_success = True
+                logger.debug(f"XML 激进清理后解析成功")
+            except ET.ParseError as e3:
+                logger.warning(f"XML 解析最终失败: {e3}")
+                return parsed
+
+    # 提取各字段
     parsed.usersays_correct = _safe_strip(root.findtext("usersays_correct"))
     parsed.task_plan = _safe_strip(root.findtext("task_plan"))
     parsed.tools_to_call = _parse_tools_element(root.find("toolstocal"))
@@ -230,6 +363,7 @@ def _parse_xml_content(xml_content: str) -> ParsedOutput:
     parsed.ask_user = _safe_strip(root.findtext("askuser"))
     parsed.get_knowledge = _safe_strip(root.findtext("get_knowledge"))
     parsed.finish = _parse_bool(root.findtext("finish"), False)
+    parsed.response = _safe_strip(root.findtext("response"))
 
     return parsed
 
@@ -259,6 +393,7 @@ def _fallback_regex_parse(raw_text: str) -> ParsedOutput:
     parsed.ask_user = _safe_strip(tag_map.get("askuser"))
     parsed.get_knowledge = _safe_strip(tag_map.get("get_knowledge"))
     parsed.finish = _parse_bool(tag_map.get("finish"), False)
+    parsed.response = _safe_strip(tag_map.get("response"))
 
     # For toolstocal we attempt to find individual <tool> blocks.
     tools_raw = tag_map.get("toolstocal", "")
@@ -347,6 +482,7 @@ def parse_output(raw_text: str) -> ParsedOutput:
             parsed.ask_user = _safe_strip(root.findtext("askuser"))
             parsed.get_knowledge = _safe_strip(root.findtext("get_knowledge"))
             parsed.finish = _parse_bool(root.findtext("finish"), False)
+            parsed.response = _safe_strip(root.findtext("response"))
             return parsed
     except ET.ParseError:
         pass

package/main.py

@@ -199,6 +199,7 @@ class MyAgentApp:
             max_tokens=llm_cfg.max_tokens,
             timeout=llm_cfg.timeout,
             max_retries=llm_cfg.max_retries,
+            reasoning=llm_cfg.reasoning,
             anthropic_api_key=llm_cfg.anthropic_api_key,
         )
         self.logger.info(f"LLM: {llm_cfg.provider}/{llm_cfg.model}")
@@ -487,7 +488,7 @@ class MyAgentApp:
 
         print()
         print("=" * 60)
-        print("  🤖 MyAgent - 本地桌面端执行型AI助手")
+        print("  MyAgent - 本地桌面端执行型AI助手")
         print(f"  版本: v{get_version()}")
         print(f"  LLM: {self.config.llm.provider}/{self.config.llm.model}")
         print(f"  技能: {len(self.skill_registry.list_skills())} 个已注册")
@@ -499,14 +500,14 @@ class MyAgentApp:
         while self._running:
             try:
                 # 读取用户输入
-                user_input = input("👤 你: ").strip()
+                user_input = input("> ").strip()
 
                 if not user_input:
                     continue
 
                 # 内置命令
                 if user_input.lower() in ("quit", "exit", "q"):
-                    print("👋 再见!")
+                    print("再见!")
                     break
                 elif user_input.lower() == "help":
                     self._print_help()
@@ -1499,7 +1500,7 @@ def main():
         args.web = args.port
     if args.server and not args.host:
         args.host = "0.0.0.0"
-    web_port = args.web if args.web else args.port if args.tray else None
+    web_port = args.web if args.web else args.port
     web_host = args.host or "127.0.0.1"
     if not web_port:
         # 仅 CLI 模式才用命令行配置向导

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "myagent-ai",
-  "version": "1.9.9",
-  "description": "\u672c\u5730\u684c\u9762\u7aef\u6267\u884c\u578bAI\u52a9\u624b - Open Interpreter \u98ce\u683c | Local Desktop Execution-Oriented AI Assistant",
+  "version": "1.10.0",
+  "description": "本地桌面端执行型AI助手 - Open Interpreter 风格 | Local Desktop Execution-Oriented AI Assistant",
   "main": "main.py",
   "bin": {
     "myagent-ai": "start.js"
@@ -65,4 +65,4 @@
     "departments/",
     "web/"
   ]
-}
+}