foliko 1.1.4 → 1.1.6

package/plugins/memory-plugin.js

@@ -10,7 +10,7 @@ const { z } = require('zod')
 const fs = require('fs')
 const path = require('path')
 const { EventEmitter } = require('events')
-
+const {cleanResponse} =require('../src/utils')
 /**
  * 记忆类型常量
  */
@@ -147,44 +147,60 @@ function _extractJSON(text) {
 
   // 去掉首尾空白
   text = text.trim()
-  if (!text.startsWith('{')) return null
 
-  // 查找配对的括号位置
-  let braceCount = 0
-  let inString = false
-  let escaped = false
+  // 方法1：如果直接以 { 开头，尝试直接解析
+  if (text.startsWith('{')) {
+    // 查找配对的括号位置
+    let braceCount = 0
+    let inString = false
+    let escaped = false
 
-  for (let i = 0; i < text.length; i++) {
-    const char = text[i]
+    for (let i = 0; i < text.length; i++) {
+      const char = text[i]
 
-    if (escaped) {
-      escaped = false
-      continue
-    }
+      if (escaped) {
+        escaped = false
+        continue
+      }
 
-    if (char === '\\' && inString) {
-      escaped = true
-      continue
-    }
+      if (char === '\\' && inString) {
+        escaped = true
+        continue
+      }
 
-    if (char === '"') {
-      inString = !inString
-      continue
-    }
+      if (char === '"') {
+        inString = !inString
+        continue
+      }
 
-    if (!inString) {
-      if (char === '{') {
-        braceCount++
-      } else if (char === '}') {
-        braceCount--
-        if (braceCount === 0) {
-          // 找到完整的 JSON 对象
-          return text.substring(0, i + 1)
+      if (!inString) {
+        if (char === '{') {
+          braceCount++
+        } else if (char === '}') {
+          braceCount--
+          if (braceCount === 0) {
+            return text.substring(0, i + 1)
+          }
         }
       }
     }
   }
 
+  // 方法2：从 thinking 文本中查找 JSON（处理 AI 输出 thinking 的情况）
+  // 查找最后一个 { 到最后一个 } 之间的内容
+  const firstBrace = text.indexOf('{')
+  const lastBrace = text.lastIndexOf('}')
+
+  if (firstBrace !== -1 && lastBrace !== -1 && lastBrace > firstBrace) {
+    const potential = text.substring(firstBrace, lastBrace + 1)
+    try {
+      JSON.parse(potential) // 验证是否是有效 JSON
+      return potential
+    } catch (e) {
+      // 不是有效 JSON，继续尝试其他方法
+    }
+  }
+
   return null
 }
 
@@ -541,6 +557,7 @@ class MemoryPlugin extends Plugin {
     this._framework = null
     this._store = null
     this._memoryAgent = null // 用于记忆提取的子 agent
+    this._isExtracting = false // 防止递归调用的标志
   }
 
   install(framework) {
@@ -552,6 +569,15 @@ class MemoryPlugin extends Plugin {
     // 初始化存储
     this._store = new MemoryStore(this.config.memoryDir)
 
+    // 创建复用的记忆提取子 Agent
+    this._memoryAgent = framework.createSubAgent({
+      name: 'memory-extractor',
+      role: '记忆提取专家',
+      description: '专门负责从对话和错误中提取记忆的子 Agent',
+      tools: {}, // 不需要额外工具，隔离主 Agent 工具
+      parentTools: [] // 不继承任何工具，纯粹做提取
+    })
+
     // 注册工具
     this._registerTools(framework)
 
@@ -787,12 +813,156 @@ class MemoryPlugin extends Plugin {
   _setupAutoExtract(framework) {
     // 监听 agent 消息完成事件，在对话轮次结束时提取记忆
     framework.on('agent:message', async ({ userMessage, assistantResponse }) => {
+      // 防止递归调用：如果正在提取中，跳过此次事件
+      if (this._isExtracting) {
+        log.debug('Skipping agent:message event during memory extraction')
+        return
+      }
+
       try {
         await this._extractMemoryFromConversation(userMessage, assistantResponse)
       } catch (err) {
         log.warn('Auto memory extraction failed:', err.message)
       }
     })
+
+    // 监听所有工具调用错误（包括 ext_call, MCP, 原生工具等）
+    framework.on('tool:error', async (data) => {
+      try {
+        await this._extractErrorLesson({
+          name: data.name || data.tool || 'unknown-tool',
+          args: data.args || {},
+          error: data.error || data.message || String(data),
+          source: data.source || 'tool'
+        })
+      } catch (err) {
+        log.warn('Auto tool error lesson extraction failed:', err.message)
+      }
+    })
+
+    // 监听 tool-call 别名（AI SDK 6.x 格式）
+    framework.on('tool-error', async (data) => {
+      try {
+        await this._extractErrorLesson({
+          name: data.name || data.tool || 'unknown-tool',
+          args: data.args || {},
+          error: data.error || data.message || String(data),
+          source: data.source || 'tool'
+        })
+      } catch (err) {
+        log.warn('Auto tool-error lesson extraction failed:', err.message)
+      }
+    })
+
+    // 监听工具重试事件（重试可能意味着配置或参数问题）
+    framework.on('tool:retry', async (data) => {
+      try {
+        const { name, args, error, attempt } = data
+        await this._extractErrorLesson({
+          name: name || 'unknown-tool',
+          args: args || {},
+          error: `Retry attempt ${attempt} failed: ${error || data.message || 'unknown'}`,
+          source: 'tool-retry'
+        })
+      } catch (err) {
+        log.warn('Auto tool retry lesson extraction failed:', err.message)
+      }
+    })
+
+    // 监听 agent 对话过程中的错误
+    framework.on('error', async (data) => {
+      try {
+        const errorObj = typeof data === 'object' ? data : { error: String(data) }
+        await this._extractErrorLesson({
+          name: errorObj.context || 'agent-error',
+          args: errorObj.data || {},
+          error: errorObj.error || errorObj.message || String(data),
+          source: 'agent'
+        })
+      } catch (err) {
+        log.warn('Auto agent error lesson extraction failed:', err.message)
+      }
+    })
+
+    // 监听 agent status 错误
+    framework.on('status', async (data) => {
+      if (data.status === 'error' && data.error) {
+        try {
+          await this._extractErrorLesson({
+            name: 'agent-status-error',
+            args: {},
+            error: data.error,
+            source: 'agent-status'
+          })
+        } catch (err) {
+          log.warn('Auto status error lesson extraction failed:', err.message)
+        }
+      }
+    })
+
+    // 监听会话上下文错误
+    framework.on('session:context-destroyed', async (data) => {
+      // 上下文销毁通常是正常的，但如果有错误信息则记录
+      if (data && data.error) {
+        try {
+          await this._extractErrorLesson({
+            name: 'session-context-error',
+            args: { sessionId: data.sessionId },
+            error: data.error,
+            source: 'session'
+          })
+        } catch (err) {
+          log.warn('Auto session error lesson extraction failed:', err.message)
+        }
+      }
+    })
+  }
+
+  /**
+   * 从错误中提取经验教训并保存
+   */
+  async _extractErrorLesson(errorData) {
+    const { name, args, error, source } = errorData
+
+    // 构建提取提示 - 强调"如何下次避免"
+    const extractPrompt = `你是一个经验总结专家。请分析以下错误，总结如何在未来避免类似错误。
+
+错误信息：
+- 工具名称: ${name}
+- 调用参数: ${JSON.stringify(args)}
+- 错误原因: ${error}
+- 来源: ${source || 'unknown'}
+
+请按以下格式返回（仅返回 JSON，不要有其他内容）：
+{
+  "extract": true/false,
+  "name": "【避免指南】具体说明避免什么（如：避免不传 plugin 参数调用 ext_call）",
+  "tags": ["error", "avoid", "${name}"],
+  "content": "以【下次这样做】为开头，说明正确的做法。例如：\n【下次这样做】调用 ext_call 时必须传入 plugin、tool、args 三个参数。错误原因：缺少 plugin 参数导致扩展插件无法定位。"
+}
+
+如果错误是无关紧要的（如用户主动取消、超时重试等），返回：
+{"extract": false}`
+
+    try {
+      const result = await this._runMemoryExtractionAgent(extractPrompt)
+
+      if (result && result.extract === true) {
+        try {
+          const saved = this._store.add({
+            name: result.name,
+            type: result.type || MEMORY_TYPES.FEEDBACK,
+            project: null,
+            tags: result.tags || ['error', 'avoid'],
+            body: result.content
+          })
+        } catch (saveErr) {
+          log.warn('[Memory] Failed to save error lesson:', saveErr.message)
+        }
+      }
+    } catch (err) {
+      log.warn('[Memory] Error lesson extraction failed:', err.message)
+    }
   }
 
   /**
@@ -851,35 +1021,24 @@ ${typeof assistantResponse === 'string' ? assistantResponse : JSON.stringify(ass
    * 使用独立的轻量子 agent 处理记忆提取，不占用主 agent 资源
    */
   async _runMemoryExtractionAgent(prompt) {
-    try {
-      // 获取 ai 插件获取模型配置
-      const aiPlugin = this._framework.pluginManager.get('ai')
-      if (!aiPlugin) {
-        log.warn('Memory extraction: AI plugin not found')
-        return null
-      }
+    if (!this._memoryAgent) {
+      log.warn('Memory extraction: memory sub-agent not found')
+      return null
+    }
 
-      const aiClient = aiPlugin.getAIClient()
-      if (!aiClient) {
-        log.warn('Memory extraction: AI client not found')
-        return null
-      }
+    // 设置提取标志，防止递归调用
+    this._isExtracting = true
 
-      // 直接使用 generateText，设置 maxSteps: 1 避免多轮对话消耗过多 context
-      const { generateText } = require('ai')
+    try {
+      const fullPrompt = `你是一个记忆提取专家。直接返回 JSON 格式的答案，不要输出任何思考过程、解释或其他内容。格式：{"extract":true/false,"name":"...","tags":[...],"content":"..."}
 
-      const { text } = await generateText({
-        model: aiClient,
-        system: '你是一个记忆提取专家，直接返回 JSON，不要有其他内容。',
-        prompt,
-        maxTokens: 500,
-        temperature: 0.3,
-        maxSteps: 1
-      })
+${prompt}`
+
+      const result = await this._memoryAgent.chat(fullPrompt, { maxSteps: 1 })
 
       // 解析 JSON 响应
-      if (text) {
-        const cleanedText = text.trim()
+      if (result?.message) {
+        const cleanedText = cleanResponse(result.message.trim())
 
         // 移除 markdown 代码块包裹
         let jsonText = cleanedText
@@ -891,14 +1050,14 @@ ${typeof assistantResponse === 'string' ? assistantResponse : JSON.stringify(ass
         const jsonStr = _extractJSON(jsonText)
         if (jsonStr) {
           try {
-            const result = JSON.parse(jsonStr)
-            return result
+            const parsed = JSON.parse(jsonStr)
+            return parsed
           } catch (parseErr) {
             // JSON 解析失败，尝试清理不可见字符后重试
             const cleaned = jsonStr.replace(/[\u0000-\u001F\u007F-\u009F\u200B-\u200F\u2028\u2029]/g, '')
             try {
-              const result = JSON.parse(cleaned)
-              return result
+              const parsed = JSON.parse(cleaned)
+              return parsed
             } catch (e) {
               log.warn('Failed to parse extracted JSON:', jsonStr.substring(0, 200))
             }
@@ -907,6 +1066,9 @@ ${typeof assistantResponse === 'string' ? assistantResponse : JSON.stringify(ass
       }
     } catch (err) {
       log.warn('Memory extraction agent failed:', err.message)
+    } finally {
+      // 必须清除提取标志
+      this._isExtracting = false
     }
 
     return null
@@ -955,13 +1117,22 @@ ${typeof assistantResponse === 'string' ? assistantResponse : JSON.stringify(ass
     try {
       const userMemories = this._store.listByType(MEMORY_TYPES.USER, 10)
       const projectMemories = this._store.listByType(MEMORY_TYPES.PROJECT, 5)
+      const feedbackMemories = this._store.search('', { type: MEMORY_TYPES.FEEDBACK, tags: ['avoid'], limit: 10 })
 
-      if (userMemories.length === 0 && projectMemories.length === 0) {
+      if (userMemories.length === 0 && projectMemories.length === 0 && feedbackMemories.length === 0) {
         return null
       }
 
       const parts = ['【记忆上下文】']
 
+      // 错误避免指南（优先显示，放在最前面）
+      if (feedbackMemories.length > 0) {
+        parts.push('【错误避免指南 - 必须遵守】')
+        for (const m of feedbackMemories) {
+          parts.push(`- ${m.body}`)
+        }
+      }
+
       if (userMemories.length > 0) {
         parts.push('【用户偏好】')
         for (const m of userMemories) {