myagent-ai 1.47.17 → 1.47.18

package/agents/main_agent.py

@@ -1222,8 +1222,200 @@ class MainAgent(BaseAgent):
                 continue
 
             else:
-                # 没有工具调用 → 纯文本回复 → 结束循环
-                reply_text = (response.content or "").strip()
+                # 没有原生工具调用 → 检查是否为旧格式 <output> XML（某些模型不支持 tool_calling）
+                raw_content = (response.content or "").strip()
+
+                # [v1.47.16] 兼容旧格式：当 LLM 输出 <output> XML 时，用 output_parser 解析
+                if raw_content.startswith("<output") or ("<output>" in raw_content and "<toolstocal>" in raw_content):
+                    logger.info(f"[{task_id}] 检测到旧格式 <output> XML 输出，启用 output_parser 解析")
+                    parsed = parse_output(raw_content)
+
+                    if parsed.parse_success:
+                        # 1) 处理 mainsubject → 更新会话标题
+                        if parsed.mainsubject and self.dispatcher:
+                            try:
+                                await self.dispatcher.dispatch(
+                                    tool_name="update_conversation_title",
+                                    params={"title": parsed.mainsubject, "session_id": context.session_id},
+                                    timeout=10,
+                                )
+                            except Exception:
+                                pass
+
+                        # 2) 处理 remember → 保存记忆
+                        if parsed.remember and self.dispatcher:
+                            try:
+                                await self.dispatcher.dispatch(
+                                    tool_name="save_memory",
+                                    params={
+                                        "content": parsed.remember,
+                                        "type": parsed.remember_type or "session",
+                                        "session_id": context.session_id,
+                                    },
+                                    timeout=10,
+                                )
+                            except Exception:
+                                pass
+
+                        # 3) 处理 task_plan
+                        if parsed.task_plan and self.dispatcher:
+                            try:
+                                await self.dispatcher.dispatch(
+                                    tool_name="task_plan",
+                                    params={"action": "create", "plan": parsed.task_plan},
+                                    timeout=10,
+                                )
+                                current_task_plan = parsed.task_plan
+                                await self._emit_v2_event(
+                                    "v2_task_plan",
+                                    {"plan": truncate_str(current_task_plan, 2000)},
+                                    stream_callback,
+                                )
+                            except Exception:
+                                pass
+
+                        # 4) 处理 tools_to_call → 执行工具
+                        if parsed.tools_to_call:
+                            logger.info(f"[{task_id}] 从 <output> XML 提取到 {len(parsed.tools_to_call)} 个工具调用")
+
+                            # 添加 assistant 消息到消息列表
+                            messages.append(Message(
+                                role="assistant",
+                                content=raw_content,
+                            ))
+
+                            # 保存 LLM 原始输出
+                            if self.memory:
+                                self.memory.add_session(agent_id=_effective_agent_id,
+                                    session_id=context.session_id,
+                                    role="assistant",
+                                    content=raw_content,
+                                    key="llm_output",
+                                    importance=0.3,
+                                )
+
+                            for tool_desc in parsed.tools_to_call:
+                                _tc_name = tool_desc.get("toolname", "")
+                                _tc_parms = tool_desc.get("parms", "{}")
+                                _tc_timeout = int(tool_desc.get("timeout", 120))
+
+                                if not _tc_name:
+                                    continue
+
+                                # 注入 session_id
+                                if _tc_name in ("save_memory", "recall_memory", "update_conversation_title"):
+                                    if isinstance(_tc_parms, str):
+                                        try:
+                                            _tc_parms_dict = json.loads(_tc_parms)
+                                        except (json.JSONDecodeError, TypeError):
+                                            _tc_parms_dict = {"raw_input": _tc_parms}
+                                    else:
+                                        _tc_parms_dict = _tc_parms
+                                    _tc_parms_dict.setdefault("session_id", context.session_id)
+                                    _tc_parms = json.dumps(_tc_parms_dict, ensure_ascii=False)
+
+                                # 发送工具开始事件
+                                await self._emit_v2_event(
+                                    "v2_tool_start",
+                                    {"tool": {"toolname": _tc_name, "parms": truncate_str(str(_tc_parms), 500)}},
+                                    stream_callback,
+                                )
+
+                                self._add_exec_event("tool_call", {
+                                    "title": f"调用工具: {_tc_name}",
+                                    "tool_name": _tc_name,
+                                    "arguments": str(_tc_parms),
+                                })
+
+                                # 执行工具
+                                tool_result = await self._execute_v2_tool(
+                                    _tc_name, str(_tc_parms), _tc_timeout,
+                                    context, task_id,
+                                    stream_callback=stream_callback,
+                                    sent_files=_sent_files,
+                                    agent_path=agent_path,
+                                )
+
+                                # 提取输出
+                                if tool_result is None:
+                                    tool_result = {"success": False, "error": "工具返回了空结果"}
+                                _output_text = (
+                                    tool_result.get("output", "")
+                                    or tool_result.get("message", "")
+                                    or tool_result.get("stdout", "")
+                                    or tool_result.get("error", "")
+                                )
+                                if not _output_text and tool_result.get("data"):
+                                    try:
+                                        _output_text = json.dumps(tool_result["data"], ensure_ascii=False, default=str)[:30000]
+                                    except Exception:
+                                        _output_text = str(tool_result["data"])[:30000]
+
+                                # 发送工具结果事件
+                                await self._emit_v2_event(
+                                    "v2_tool_result",
+                                    {"tool": {"toolname": _tc_name}, "result": {
+                                        "success": tool_result.get("success", False),
+                                        "output": truncate_str(_output_text, 30000),
+                                        "error": truncate_str(tool_result.get("error", ""), 30000),
+                                    }},
+                                    stream_callback,
+                                )
+
+                                self._add_exec_event("tool_result", {
+                                    "title": f"工具结果: {_tc_name}",
+                                    "tool_name": _tc_name,
+                                    "success": tool_result.get("success", False),
+                                    "summary": truncate_str(_output_text, 30000),
+                                })
+
+                                # 添加 tool result 消息
+                                messages.append(Message(
+                                    role="user",
+                                    content=f"[工具结果: {_tc_name}] {truncate_str(_output_text, 5000)}",
+                                ))
+
+                            # 工具执行完毕 → 继续循环让 LLM 处理结果
+                            continue
+
+                        # 5) 没有工具但有 reply → 提取纯文本回复
+                        if parsed.reply:
+                            reply_text = parsed.reply.strip()
+                        else:
+                            # 兜底：去除所有 XML 标签
+                            import re as _re_xml
+                            reply_text = _re_xml.sub(r'<[^>]+>', '', raw_content).strip()
+
+                        if not reply_text:
+                            reply_text = "处理完毕。"
+
+                        context.working_memory["final_response"] = reply_text
+                        await self._emit_v2_event("v2_reasoning", {"content": truncate_str(reply_text, 3000)}, stream_callback)
+
+                        # 保存回复到会话记忆
+                        if self.memory:
+                            self.memory.add_session(agent_id=_effective_agent_id,
+                                session_id=context.session_id,
+                                role="assistant",
+                                content=reply_text,
+                                key="reply",
+                                importance=0.5,
+                            )
+
+                        # 保存 LLM 原始输出
+                        if self.memory:
+                            self.memory.add_session(agent_id=_effective_agent_id,
+                                session_id=context.session_id,
+                                role="assistant",
+                                content=raw_content,
+                                key="llm_output",
+                                importance=0.3,
+                            )
+
+                        break
+
+                # 纯文本回复（非 XML 格式）
+                reply_text = raw_content
                 logger.info(f"[{task_id}] 无工具调用，任务完成 (reply长度={len(reply_text)})")
 
                 if not reply_text:

package/package.json

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

package/web/api_server.py

@@ -7901,10 +7901,11 @@ window.addEventListener('beforeunload', function() {{
             # 4. 检测到裸 JSON（整个回复以 { 开头）：进入 action 模式，提取 thought
             # 5. 代码块结束后回到文本模式，继续流式推送
             _stream_state = {
-                "mode": "text",         # "text" | "action_block" | "tasklist_block" | "bare_json"
+                "mode": "text",         # "text" | "action_block" | "tasklist_block" | "bare_json" | "output_xml"
                 "processed_pos": 0,     # 已处理到的位置（用于去重 streaming）
                 "thought_sent": 0,      # 已推送的 thought 长度
                 "action_block_depth": 0, # ``` 嵌套深度
+                "reply_sent": 0,        # [v1.47.16] output_xml 模式下已推送的 reply 长度
             }
 
             # 需要回退(hold back)的最大字符数，用于检测 ```action 或 ```tasklist 标记
@@ -7913,12 +7914,30 @@ window.addEventListener('beforeunload', function() {{
             _MAX_HOLD = 12
 
             async def _text_delta_callback(full_text_so_far: str, delta_text: str):
-                """智能流式过滤器：文本正常推送，JSON action 块拦截"""
+                """智能流式过滤器：文本正常推送，JSON action 块拦截，<output> XML 拦截"""
                 st = _stream_state
                 remaining = full_text_so_far[st["processed_pos"]:]
 
                 while remaining:
                     if st["mode"] == "text":
+                        # ── [v1.47.16] 检测 <output> XML 标签 → 进入 output_xml 模式 ──
+                        output_marker = remaining.find("<output")
+                        if output_marker >= 0:
+                            # 推送 <output> 之前的文本
+                            text_before = remaining[:output_marker]
+                            if text_before.strip():
+                                await _write_sse({"type": "text_delta", "content": text_before})
+                                _all_streamed_text_parts.append(text_before)
+                            # 跳过 <output...> 开始标签
+                            tag_end = remaining.find(">", output_marker)
+                            if tag_end >= 0:
+                                st["processed_pos"] += tag_end + 1
+                            else:
+                                st["processed_pos"] += len(remaining)
+                            st["mode"] = "output_xml"
+                            remaining = full_text_so_far[st["processed_pos"]:]
+                            continue
+
                         # ── 文本模式：寻找 ```action 或 ```tasklist 标记 ──
                         action_marker = remaining.find("```action")
                         tasklist_marker = remaining.find("```tasklist")
@@ -8037,6 +8056,60 @@ window.addEventListener('beforeunload', function() {{
                         remaining = ""
                         break
 
+                    elif st["mode"] == "output_xml":
+                        # ── [v1.47.16] <output> XML 模式：提取 <reply> 内容流式推送，其余全部拦截 ──
+                        # 策略：在 output_xml 模式下，只在检测到 <reply> 内容时推送，其他标签内容全部跳过
+                        import re as _re_xml_stream
+
+                        # 检查 </output> 闭合标签 → 退出 output_xml 模式
+                        close_output = remaining.find("</output>")
+                        if close_output >= 0:
+                            # 在闭合标签前，检查是否有未推送的 <reply> 内容
+                            before_close = full_text_so_far[st["processed_pos"]:st["processed_pos"] + close_output]
+                            # 尝试提取 <reply> 内容
+                            reply_m = _re_xml_stream.search(r'<reply[^>]*>([\s\S]*?)</reply>', before_close)
+                            if reply_m and reply_m.group(1).strip():
+                                reply_content = reply_m.group(1).strip()
+                                new_part = reply_content[st["reply_sent"]:]
+                                if new_part:
+                                    await _write_sse({"type": "text_delta", "content": new_part})
+                                    _all_streamed_text_parts.append(new_part)
+                                st["reply_sent"] = len(reply_content)
+                            # 跳过到 </output> 之后
+                            st["processed_pos"] += close_output + len("</output>")
+                            st["mode"] = "text"
+                            remaining = full_text_so_far[st["processed_pos"]:]
+                            continue
+
+                        # 尚未闭合：尝试提取已闭合的 <reply>...</reply> 内容并流式推送
+                        all_so_far = full_text_so_far[st["processed_pos"]:]
+                        reply_m = _re_xml_stream.search(r'<reply[^>]*>([\s\S]*?)</reply>', all_so_far)
+                        if reply_m and reply_m.group(1).strip():
+                            reply_content = reply_m.group(1).strip()
+                            new_part = reply_content[st["reply_sent"]:]
+                            if new_part:
+                                await _write_sse({"type": "text_delta", "content": new_part})
+                                _all_streamed_text_parts.append(new_part)
+                            st["reply_sent"] = len(reply_content)
+
+                        # 尝试提取未闭合的 <reply> 内容（流式输出中标签可能尚未关闭）
+                        elif not reply_m:
+                            reply_open_m = _re_xml_stream.search(r'<reply[^>]*>([\s\S]+)$', all_so_far)
+                            if reply_open_m and reply_open_m.group(1).strip():
+                                partial_reply = reply_open_m.group(1)
+                                # 去除尾部可能的不完整标签
+                                partial_reply = _re_xml_stream.sub(r'<[^>]*$', '', partial_reply).strip()
+                                if partial_reply and len(partial_reply) > st["reply_sent"]:
+                                    new_part = partial_reply[st["reply_sent"]:]
+                                    if new_part:
+                                        await _write_sse({"type": "text_delta", "content": new_part})
+                                        _all_streamed_text_parts.append(new_part)
+                                    st["reply_sent"] = len(partial_reply)
+
+                        # 等待更多 token
+                        remaining = ""
+                        break
+
             # Stream 结束后的 flush：推送所有 hold 住的文本
             async def _flush_remaining_text(full_text: str):
                 """流结束后，推送所有剩余的文本（处理 hold back 的部分）"""
@@ -8050,6 +8123,25 @@ window.addEventListener('beforeunload', function() {{
                         await _write_sse({"type": "text_delta", "content": remaining})
                     _all_streamed_text_parts.append(remaining)
                     st["processed_pos"] = len(full_text)
+                elif st["mode"] == "output_xml":
+                    # [v1.47.16] output_xml 模式下 flush：尝试提取 <reply> 内容
+                    import re as _re_xml_flush
+                    reply_m = _re_xml_flush.search(r'<reply[^>]*>([\s\S]*?)(?:</reply>|$)', remaining)
+                    if reply_m and reply_m.group(1).strip():
+                        reply_content = reply_m.group(1).strip()
+                        new_part = reply_content[st["reply_sent"]:]
+                        if new_part:
+                            await _write_sse({"type": "text_delta", "content": new_part})
+                            _all_streamed_text_parts.append(new_part)
+                        st["reply_sent"] = len(reply_content)
+                    # 检查 </output> 之后是否还有文本
+                    close_pos = remaining.find("</output>")
+                    if close_pos >= 0:
+                        after_output = remaining[close_pos + len("</output>"):].strip()
+                        if after_output and st["mode"] == "output_xml":
+                            # 不推送（output_xml 模式结束后可能有残余标签文本）
+                            pass
+                    st["processed_pos"] = len(full_text)
 
             # Call LLM with streaming — tokens are filtered through _text_delta_callback
             # Call LLM with streaming + frequency_penalty to reduce repetition

package/web/ui/chat/chat_main.js

@@ -2999,12 +2999,12 @@ async function selectSession(id) {
       return m && (m.role === 'user' || m.role === 'assistant' || m.role === 'tool');
     }).map(function(m) {
       var content = (m.content != null) ? String(m.content) : '';
-      // Strip XML tags from assistant messages that are raw LLM output (key is empty or llm_output)
-      // 只有无 key 的旧格式 assistant 消息且内容以 < 开头时才需要剥离 XML
-      // 有 key 的消息（reasoning/reply/tool_call）已经是解析后的纯内容，无需处理
+      // [v1.47.16] 剥离 XML 标签：无 key 的旧格式 + key=reply 但仍含 XML 标签的消息
       var mkey = (m.key || '').toLowerCase();
-      if (m.role === 'assistant' && !mkey && content && content.trim().startsWith('<')) {
-        content = (typeof _stripXmlTags === 'function') ? _stripXmlTags(content) : content;
+      if (m.role === 'assistant' && content && content.trim().startsWith('<')) {
+        if (!mkey || mkey === 'reply') {
+          content = (typeof _stripXmlTags === 'function') ? _stripXmlTags(content) : content;
+        }
       }
       var mapped = {
         role: m.role || 'assistant',
@@ -3110,8 +3110,10 @@ async function loadMoreMessages() {
     }).map(function(m) {
       var content = (m.content != null) ? String(m.content) : '';
       var mkey = (m.key || '').toLowerCase();
-      if (m.role === 'assistant' && mkey !== 'tool_call' && mkey !== 'reasoning' && content && content.trim().startsWith('<')) {
-        content = (typeof _stripXmlTags === 'function') ? _stripXmlTags(content) : content;
+      if (m.role === 'assistant' && content && content.trim().startsWith('<')) {
+        if (!mkey || mkey === 'reply' || (mkey !== 'tool_call' && mkey !== 'reasoning')) {
+          content = (typeof _stripXmlTags === 'function') ? _stripXmlTags(content) : content;
+        }
       }
       var mapped = {
         role: m.role || 'assistant',

package/web/ui/chat/flow_engine.js

@@ -398,10 +398,12 @@ async function pollChatHistory() {
     }).map(function(m) {
       var content = (m.content != null) ? String(m.content) : '';
       var mkey = (m.key || '').toLowerCase();
-      // 只有无 key 的旧格式 assistant 消息且内容以 < 开头时才需要剥离 XML
-      // 有 key 的消息（reasoning/reply/tool_call）已经是解析后的纯内容，无需处理
-      if (m.role === 'assistant' && !mkey && content && content.trim().startsWith('<')) {
-        content = (typeof _stripXmlTags === 'function') ? _stripXmlTags(content) : content;
+      // [v1.47.16] 剥离 XML 标签：无 key 的旧格式 + key=reply 但仍含 XML 标签的消息
+      // 有 key 的消息（reasoning/reply/tool_call）一般已是纯内容，但部分模型仍会输出 XML
+      if (m.role === 'assistant' && content && content.trim().startsWith('<')) {
+        if (!mkey || mkey === 'reply') {
+          content = (typeof _stripXmlTags === 'function') ? _stripXmlTags(content) : content;
+        }
       }
       var mapped = {
         role: m.role || 'assistant',
@@ -473,9 +475,11 @@ async function forceRefreshHistory() {
     }).map(function(m) {
       var content = (m.content != null) ? String(m.content) : '';
       var mkey = (m.key || '').toLowerCase();
-      // 只有无 key 的旧格式 assistant 消息且内容以 < 开头时才需要剥离 XML
-      if (m.role === 'assistant' && !mkey && content && content.trim().startsWith('<')) {
-        content = (typeof _stripXmlTags === 'function') ? _stripXmlTags(content) : content;
+      // [v1.47.16] 剥离 XML 标签：无 key 的旧格式 + key=reply 但仍含 XML 标签的消息
+      if (m.role === 'assistant' && content && content.trim().startsWith('<')) {
+        if (!mkey || mkey === 'reply') {
+          content = (typeof _stripXmlTags === 'function') ? _stripXmlTags(content) : content;
+        }
       }
       var mapped = {
         role: m.role || 'assistant',