myagent-ai 1.9.3 → 1.9.5

package/agents/main_agent.py

@@ -188,7 +188,7 @@ status 取值：
 
 <tool><beforecalltext>连接词，介绍调用什么工具，达到什么目的。示例:接下来，要调用命令行工具，获得ip地址。</beforecalltext><toolname>工具名</toolname><parms>参数</parms><timeout>预估超时时限</timeout><callback>true/false</callback></tool>
 </toolstocal>
-<remember>根据"context,提取需要存入记忆库的内容，这里要搜简上记忆库</remember>
+<remember>仅从最新用户输入（userprint 或 usersays_correct）中提炼值得长期记忆的信息（如用户偏好、重要结论、错误经验等）。不要从历史对话中重复提炼旧记忆。如果本轮用户输入没有新信息需要记忆，则为空。</remember>
 <recall>下一轮执行需要调取的记忆，这里要设计接上记忆库</recall>
 <get_knowledge>下一轮执行时需要从知识库搜索获得的知识，填写检索关键词或描述。如context中已包含充足的<knowledge>内容，则为空。如需更多专业知识支撑，则填写相关搜索词。</get_knowledge>
 <askuser>需要询问用户的内容，如无，则为空</askuser>
@@ -203,7 +203,7 @@ status 取值：
 4. <toolstocal>: 列出所有需要执行的工具调用，每个工具包含完整的参数说明
 5. <timeout>: 预估超时秒数（简单操作10-30s，文件操作30-60s，网络请求60-120s，数据处理120-300s）
 6. <callback>: 如果该工具的执行结果对后续决策有影响，设为 true；否则设为 false
-7. <remember>: 提取本轮对话中值得长期记忆的关键信息（用户偏好、重要结论、错误经验等）
+7. <remember>: 仅从最新用户输入（userprint 或 usersays_correct）中提炼值得长期记忆的关键信息，不要重复提炼历史对话中已有的记忆。如果本轮没有新信息需要记忆，则为空
 8. <recall>: 描述下一轮执行时需要从记忆库中检索的内容关键词
 9. <get_knowledge>: 如果当前 <knowledge> 内容不足以完成任务，填写需要从知识库搜索的关键词；否则为空
 10. <askuser>: 当信息不足需要用户补充时，在此填写要问的问题
@@ -1347,39 +1347,43 @@ status 取值：
             if parsed.usersays_correct:
                 context.working_memory["usersays_correct"] = parsed.usersays_correct
 
-            # Step 6: 处理 remember — 存入长期记忆
-            if parsed.remember and self.memory_agent:
+            # Step 6: 处理 remember — 查重后存入长期记忆
+            if parsed.remember:
                 try:
-                    mem_ctx = AgentContext(
-                        task_id=task_id,
-                        session_id=context.session_id,
-                        metadata={
-                            "memory_action": "save",
-                            "content": parsed.remember,
-                        },
-                    )
-                    await self.memory_agent.process(mem_ctx)
-                    await self._emit_v2_event(
-                        "v2_memory_saved",
-                        {"content": truncate_str(parsed.remember, 200)},
-                        stream_callback,
-                    )
-                except Exception as e:
-                    logger.warning(f"[{task_id}] 存入记忆失败: {e}")
-            elif parsed.remember and self.memory:
-                try:
-                    self.memory.add_long_term(
-                        session_id=context.session_id,
-                        key="conversation_insight",
-                        content=parsed.remember,
-                        summary=truncate_str(parsed.remember, 200),
-                        importance=0.7,
-                    )
-                    await self._emit_v2_event(
-                        "v2_memory_saved",
-                        {"content": truncate_str(parsed.remember, 200)},
-                        stream_callback,
-                    )
+                    # 查重：跳过与已有记忆高度重复的内容
+                    is_dup = False
+                    if self.memory:
+                        is_dup = self.memory.is_duplicate_memory(
+                            content=parsed.remember,
+                            session_id=context.session_id,
+                            key="conversation_insight",
+                        )
+                    if is_dup:
+                        logger.debug(f"[{task_id}] 记忆查重: 跳过重复内容")
+                    else:
+                        if self.memory_agent:
+                            mem_ctx = AgentContext(
+                                task_id=task_id,
+                                session_id=context.session_id,
+                                metadata={
+                                    "memory_action": "save",
+                                    "content": parsed.remember,
+                                },
+                            )
+                            await self.memory_agent.process(mem_ctx)
+                        elif self.memory:
+                            self.memory.add_long_term(
+                                session_id=context.session_id,
+                                key="conversation_insight",
+                                content=parsed.remember,
+                                summary=truncate_str(parsed.remember, 200),
+                                importance=0.7,
+                            )
+                        await self._emit_v2_event(
+                            "v2_memory_saved",
+                            {"content": truncate_str(parsed.remember, 200)},
+                            stream_callback,
+                        )
                 except Exception as e:
                     logger.warning(f"[{task_id}] 存入记忆失败: {e}")
 

package/core/output_parser.py

@@ -20,7 +20,7 @@ Expected XML schema produced by the LLM::
                 <callback>true/false</callback>
             </tool>
         </toolstocal>
-        <remember>需要存入记忆库的内容</remember>
+        <remember>仅从最新用户输入中提炼的记忆，无新信息则为空</remember>
         <recall>下一轮需要调取的记忆</recall>
         <askuser>需要询问用户的内容</askuser>
         <get_knowledge>下一轮需要搜索获得的知识</get_knowledge>

package/memory/manager.py

@@ -479,6 +479,71 @@ class MemoryManager:
     # 长期记忆 (持久知识)
     # ==========================================================================
 
+    def is_duplicate_memory(
+        self,
+        content: str,
+        session_id: str = "",
+        key: str = "",
+        similarity_threshold: float = 0.85,
+    ) -> bool:
+        """
+        检查是否已存在高度相似的记忆（查重）。
+
+        使用 TF-IDF 余弦相似度判断新内容是否与已有记忆高度重复。
+        相似度超过阈值则视为重复。
+
+        Args:
+            content: 待检查的新记忆内容
+            session_id: 会话 ID（为空则跨会话查重）
+            key: 记忆分类键（为空则不限制分类）
+            similarity_threshold: 相似度阈值，超过此值视为重复（默认 0.85）
+
+        Returns:
+            True 表示存在重复记忆，False 表示可以存储
+        """
+        if not content or not content.strip():
+            return True  # 空内容视为重复
+
+        conn = self._get_conn()
+        conditions = ["category = 'long_term'"]
+        params: list = []
+
+        if session_id:
+            conditions.append("session_id = ?")
+            params.append(session_id)
+        if key:
+            conditions.append("key = ?")
+            params.append(key)
+
+        # 过滤过期
+        conditions.append("(expires_at = '' OR expires_at > ?)")
+        params.append(timestamp())
+
+        where = " AND ".join(conditions)
+        # 取最近的记忆候选进行比对
+        sql = f"SELECT id, content, summary FROM memories WHERE {where} ORDER BY created_at DESC LIMIT 50"
+        rows = conn.execute(sql, params).fetchall()
+
+        if not rows:
+            return False
+
+        # 使用 TF-IDF 计算新内容与每条已有记忆的相似度
+        documents = [(row["id"], row["content"]) for row in rows]
+        scores = self._compute_tfidf(content, documents)
+
+        if not scores:
+            return False
+
+        max_score = max(scores.values())
+        if max_score >= similarity_threshold:
+            logger.debug(
+                f"记忆查重: 发现重复内容 (相似度={max_score:.2f}, "
+                f"阈值={similarity_threshold}, 匹配ID={max(scores, key=scores.get)})"
+            )
+            return True
+
+        return False
+
     def add_long_term(
         self,
         session_id: str = "global",

package/package.json

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

package/web/api_server.py

@@ -3064,7 +3064,13 @@ class ApiServer:
             # 返回最终响应
             final_response = v2_context.working_memory.get("final_response", "")
             if not final_response and _v2_reasoning_parts:
-                final_response = "\n".join(_v2_reasoning_parts)
+                # Smart join: only add separator when parts don't already end with newline
+                joined_parts = []
+                for i, part in enumerate(_v2_reasoning_parts):
+                    if i > 0 and joined_parts and not joined_parts[-1].endswith('\n') and not part.startswith('\n'):
+                        joined_parts.append('\n')
+                    joined_parts.append(part)
+                final_response = ''.join(joined_parts)
             return final_response
 
         # ── V1 路由: 标准 JSON action 格式 ──

package/web/ui/chat/flow_engine.js

@@ -814,6 +814,54 @@ function showToolResultModal(msgIndex, eventId) {
   document.body.appendChild(overlay);
 }
 
+// ══════════════════════════════════════════════════════
+// ── V2 Helpers ──
+// ══════════════════════════════════════════════════════
+
+/**
+ * Strip XML tags from text for real-time streaming preview in V2 mode.
+ * Shows plain text between tags so the user sees progress during LLM streaming.
+ */
+function _stripXmlTags(xml) {
+  if (!xml) return '';
+  // Remove all XML tags, collapse excessive whitespace
+  return xml
+    .replace(/<[^>]+>/g, ' ')     // Replace tags with space
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&amp;/g, '&')
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/&#x27;/g, "'")
+    .replace(/\s{3,}/g, ' ')      // Collapse 3+ whitespace to single space
+    .trim();
+}
+
+// ══════════════════════════════════════════════════════
+// ── V2 Content Assembler (V2 内容组装) ──
+// ══════════════════════════════════════════════════════
+
+function _assembleV2Content(msg, msgParts) {
+  // Priority 1: V2 reasoning text (user-facing response from v2_reasoning events)
+  if (msg._v2Reasoning && msg._v2Reasoning.trim()) {
+    return msg._v2Reasoning.trim();
+  }
+  // Priority 2: V2 ask user text
+  if (msg._askUser && msg._askUser.trim()) {
+    return msg._askUser.trim();
+  }
+  // Priority 3: V1 text parts (backward compat — non-V2 mode)
+  var textParts = msgParts.filter(function(p) { return p.type === 'text'; });
+  if (textParts.length > 0) {
+    return textParts.map(function(p) { return p.content; }).join('\n\n');
+  }
+  // Priority 4: raw content from message (server-stored response)
+  if (msg.content && msg.content.trim() && msg.content !== '(无回复)') {
+    return msg.content.trim();
+  }
+  return '(无回复)';
+}
+
 // ══════════════════════════════════════════════════════
 // ── Send Message (核心 SSE 流式消息发送) ──
 // ══════════════════════════════════════════════════════
@@ -904,10 +952,17 @@ async function sendMessage() {
     let msgIdx = state.messages.length;
     let sessionIdReceived = sessionId;
     let fullThought = '';
+    let _isV2Mode = false;   // Track whether V2 structured output events are received
+    let _v2RawXml = '';      // In V2 mode, accumulate raw XML from text_delta separately
+    let _v2ReasoningText = ''; // Accumulated V2 reasoning text for content
 
     function flushCurrentText() {
       if (currentText.trim()) {
-        msgParts.push({type: 'text', content: currentText});
+        // In V2 mode, text_delta contains raw XML — do NOT add to msgParts as user-facing text
+        if (!_isV2Mode) {
+          msgParts.push({type: 'text', content: currentText});
+        }
+        // Always accumulate for backward compat content field
       }
       currentText = '';
     }
@@ -950,12 +1005,17 @@ async function sendMessage() {
           } else if (evt.type === 'text_delta') {
             // Incremental streaming token
             currentText += evt.content;
-            // Build backward-compat content from all parts + streaming text
-            const allText = msgParts.filter(p => p.type === 'text').map(p => p.content).join('\n\n')
-              + (currentText.trim() ? '\n\n' + currentText : '');
+            if (_isV2Mode) {
+              // In V2 mode, text_delta contains raw XML — store separately
+              _v2RawXml = currentText;
+              // Show V2 reasoning text as streaming content (if available)
+              // If no reasoning yet, show a stripped version of raw text so user sees real-time progress
+              state.messages[msgIdx]._streamingText = _v2ReasoningText || _stripXmlTags(currentText);
+            } else {
+              // V1 mode: text_delta IS the user-facing content
+              state.messages[msgIdx]._streamingText = currentText;
+            }
             state.messages[msgIdx].parts = [...msgParts];
-            state.messages[msgIdx]._streamingText = currentText;
-            state.messages[msgIdx].content = allText;
             throttledStreamUpdate(msgIdx);
             // ── 分段流式 TTS：推送增量文本 ──
             if (ttsManager.enabled && !ttsManager._streamActive) {
@@ -982,7 +1042,7 @@ async function sendMessage() {
             if (state.messages[msgIdx]) {
               state.messages[msgIdx].streaming = false;
               state.messages[msgIdx].parts = [...msgParts];
-              state.messages[msgIdx].content = msgParts.filter(p => p.type === 'text').map(p => p.content).join('\n\n') || '(无回复)';
+              state.messages[msgIdx].content = _assembleV2Content(state.messages[msgIdx], msgParts);
               state.messages[msgIdx]._streamingText = '';
               if (allExecEvents.length > 0) state.messages[msgIdx].exec_events = [...allExecEvents];
             }
@@ -1000,7 +1060,7 @@ async function sendMessage() {
             flushCurrentText();
             state.messages[msgIdx].parts = [...msgParts];
             state.messages[msgIdx]._streamingText = '';
-            state.messages[msgIdx].content = msgParts.filter(p => p.type === 'text').map(p => p.content).join('\n\n') || '';
+            state.messages[msgIdx].content = _assembleV2Content(state.messages[msgIdx], msgParts);
             throttledStreamUpdate(msgIdx);
             // 停止当前轮次的 TTS 播放，防止旧迭代语音与新迭代语音互相打断
             if (ttsManager.enabled && ttsManager._streamActive) {
@@ -1041,7 +1101,10 @@ async function sendMessage() {
                 }
               }
             }
-          // V2 Structured Output Events
+          // V2 Structured Output Events — mark V2 mode
+          } else if (evt.type === 'v2_context') {
+            // V2 context event — confirms we're in V2 mode
+            _isV2Mode = true;
           } else if (evt.type === 'v2_output_parsed') {
             // LLM output was parsed into structured format
             // evt.data contains: {usersays_correct, task_plan, tools_to_call, remember, recall, ask_user, finish}
@@ -1120,11 +1183,23 @@ async function sendMessage() {
             state.messages[msgIdx]._memorySaved = (state.messages[msgIdx]._memorySaved || '') +
               (evt.content ? evt.content.substring(0, 100) : '');
           } else if (evt.type === 'v2_reasoning') {
-            // V2 reasoning text from model (similar to thought_delta)
+            // V2 reasoning text from model — this IS the user-facing content in V2 mode
             if (!state.messages[msgIdx]._v2Reasoning) {
               state.messages[msgIdx]._v2Reasoning = '';
             }
+            // Smart separator: only add newline if previous reasoning doesn't already end with one
+            var prev = state.messages[msgIdx]._v2Reasoning;
+            if (prev.length > 0 && evt.content && !prev.endsWith('\n') && !evt.content.startsWith('\n')) {
+              state.messages[msgIdx]._v2Reasoning += '\n';
+            }
             state.messages[msgIdx]._v2Reasoning += evt.content;
+            _v2ReasoningText = state.messages[msgIdx]._v2Reasoning;
+            // In V2 mode, update streaming text to show reasoning content
+            if (_isV2Mode) {
+              state.messages[msgIdx]._streamingText = _v2ReasoningText;
+              // Also update content for real-time display
+              state.messages[msgIdx].content = _v2ReasoningText;
+            }
             throttledStreamUpdate(msgIdx);
           } else if (evt.type === 'done') {
             flushCurrentText();
@@ -1135,7 +1210,8 @@ async function sendMessage() {
             state.messages[msgIdx].parts = [...msgParts];
             state.messages[msgIdx]._streamingText = '';
             state.messages[msgIdx].exec_events = [...allExecEvents];
-            state.messages[msgIdx].content = msgParts.filter(p => p.type === 'text').map(p => p.content).join('\n\n') || '(无回复)';
+            // Assemble final content: prefer V2 reasoning/ask text over raw XML
+            state.messages[msgIdx].content = _assembleV2Content(state.messages[msgIdx], msgParts);
           } else if (evt.type === 'reasoning_delta') {
             // 模型推理过程增量文本（OpenAI o1/o3/DeepSeek-R1 等推理模型）
             if (!state.messages[msgIdx].reasoning) state.messages[msgIdx].reasoning = '';
@@ -1164,7 +1240,8 @@ async function sendMessage() {
       state.messages[msgIdx].parts = [...msgParts];
       state.messages[msgIdx]._streamingText = '';
       state.messages[msgIdx].exec_events = allExecEvents;
-      state.messages[msgIdx].content = msgParts.filter(p => p.type === 'text').map(p => p.content).join('\n\n') || '(无回复)';
+      // Assemble final content: prefer V2 reasoning/ask text over raw XML
+      state.messages[msgIdx].content = _assembleV2Content(state.messages[msgIdx], msgParts);
     }
     
     // Task list 已通过 SSE task_list_update 事件实时推送，无需再轮询