foliko 1.1.6 → 1.1.7

package/plugins/memory-plugin.js

@@ -70,6 +70,8 @@ function parseFrontmatter(content) {
       currentKey = 'metadata'
       frontmatter.metadata = {}
     } else if (key === 'tags') {
+      // 去除首尾空白和方括号
+      value = value.trim().replace(/^\[|\]$/g, '')
       frontmatter[key] = value
         .split(',')
         .map(t => t.trim().replace(/^["']|["']$/g, ''))
@@ -558,6 +560,10 @@ class MemoryPlugin extends Plugin {
     this._store = null
     this._memoryAgent = null // 用于记忆提取的子 agent
     this._isExtracting = false // 防止递归调用的标志
+    this._extractInterval = config.extractInterval || 10 * 60 * 1000 // 默认 5 分钟
+    this._extractTimer = null // 定时提取定时器
+    this._pendingConversations = [] // 待处理的对话队列
+    this._pendingErrors = [] // 待处理的错误队列
   }
 
   install(framework) {
@@ -811,93 +817,91 @@ class MemoryPlugin extends Plugin {
    * 设置自动记忆提取
    */
   _setupAutoExtract(framework) {
-    // 监听 agent 消息完成事件，在对话轮次结束时提取记忆
-    framework.on('agent:message', async ({ userMessage, assistantResponse }) => {
+    // 收集对话到待处理队列，定时提取
+    framework.on('agent:message', ({ 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)
+      // 添加到待处理队列
+      this._pendingConversations.push({
+        userMessage,
+        assistantResponse,
+        timestamp: Date.now()
+      })
+
+      // 限制队列大小，避免内存溢出
+      if (this._pendingConversations.length > 50) {
+        this._pendingConversations.shift()
       }
     })
 
-    // 监听所有工具调用错误（包括 ext_call, MCP, 原生工具等）
+    // 启动定时提取器
+    this._startPeriodicExtraction()
+
+    // 监听所有工具调用错误 - 收集到队列，定时处理
     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)
+      // 添加到待处理队列
+      this._pendingErrors.push({
+        name: data.name || data.tool || 'unknown-tool',
+        args: data.args || {},
+        error: data.error || data.message || String(data),
+        source: data.source || 'tool',
+        timestamp: Date.now()
+      })
+
+      // 限制队列大小
+      if (this._pendingErrors.length > 50) {
+        this._pendingErrors.shift()
       }
     })
 
     // 监听 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)
+      // 添加到待处理队列
+      this._pendingErrors.push({
+        name: data.name || data.tool || 'unknown-tool',
+        args: data.args || {},
+        error: data.error || data.message || String(data),
+        source: data.source || 'tool',
+        timestamp: Date.now()
+      })
+
+      // 限制队列大小
+      if (this._pendingErrors.length > 50) {
+        this._pendingErrors.shift()
       }
     })
 
-    // 监听工具重试事件（重试可能意味着配置或参数问题）
+    // 监听工具重试事件
     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)
+      // 添加到待处理队列
+      this._pendingErrors.push({
+        name: data.name || 'unknown-tool',
+        args: data.args || {},
+        error: `Retry attempt ${data.attempt} failed: ${data.error || data.message || 'unknown'}`,
+        source: 'tool-retry',
+        timestamp: Date.now()
+      })
+
+      // 限制队列大小
+      if (this._pendingErrors.length > 50) {
+        this._pendingErrors.shift()
       }
     })
 
     // 监听 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 错误通常不需要提取记忆，避免循环
+      log.debug('Received agent error event, skipping memory extraction')
     })
 
     // 监听 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)
-        }
-      }
+      // status 错误已经在 tool:error 中处理，这里跳过避免重复
+      log.debug('Received status event, skipping memory extraction')
     })
 
     // 监听会话上下文错误
@@ -918,12 +922,113 @@ class MemoryPlugin extends Plugin {
     })
   }
 
+  /**
+   * 启动定时记忆提取
+   */
+  _startPeriodicExtraction() {
+    // 如果间隔为 0，则禁用定时提取
+    if (this._extractInterval <= 0) {
+      log.info('Periodic memory extraction disabled')
+      return
+    }
+
+    // 清除已有的定时器
+    if (this._extractTimer) {
+      clearInterval(this._extractTimer)
+    }
+
+    log.info(`Starting periodic memory extraction (interval: ${this._extractInterval / 1000}s)`)
+
+    this._extractTimer = setInterval(async () => {
+      await this._processPendingConversations()
+    }, this._extractInterval)
+  }
+
+  /**
+   * 处理待处理的对话队列和错误队列
+   */
+  async _processPendingConversations() {
+    if (this._isExtracting) {
+      log.debug('Skipping periodic extraction - already in progress')
+      return
+    }
+
+    // 如果两个队列都为空，直接返回
+    if (this._pendingConversations.length === 0 && this._pendingErrors.length === 0) {
+      return
+    }
+
+    // 防止递归调用
+    this._isExtracting = true
+
+    try {
+      // 批量处理对话
+      if (this._pendingConversations.length > 0) {
+        const conversations = this._pendingConversations.splice(0, 10) // 每次最多处理 10 条
+        log.debug(`Processing ${conversations.length} pending conversations`)
+
+        for (const { userMessage, assistantResponse } of conversations) {
+          try {
+            await this._extractMemoryFromConversation(userMessage, assistantResponse)
+          } catch (err) {
+            log.warn('Failed to extract memory from conversation:', err.message)
+          }
+        }
+      }
+
+      // 批量处理错误
+      if (this._pendingErrors.length > 0) {
+        const errors = this._pendingErrors.splice(0, 10) // 每次最多处理 10 条
+        log.debug(`Processing ${errors.length} pending errors`)
+
+        for (const errorData of errors) {
+          try {
+            await this._extractErrorLesson(errorData)
+          } catch (err) {
+            log.warn('Failed to extract error lesson:', err.message)
+          }
+        }
+      }
+    } finally {
+      this._isExtracting = false
+    }
+  }
+
   /**
    * 从错误中提取经验教训并保存
    */
   async _extractErrorLesson(errorData) {
     const { name, args, error, source } = errorData
 
+    // 将 error 转为字符串
+    const errorStr = typeof error === 'string' ? error : String(error)
+
+    // 检查是否需要跳过 AI 提取（AI 服务过载或返回非 JSON 时避免加重负担）
+    const shouldSkipAI = errorStr && (
+      errorStr.includes('负载较高') ||
+      errorStr.includes('retry') ||
+      errorStr.includes('timeout') ||
+      errorStr.includes('Failed after') ||
+      errorStr.includes('Invalid JSON response')
+    )
+
+    if (shouldSkipAI) {
+      // AI 服务过载时，直接保存基本信息，不调用 AI
+      try {
+        this._store.add({
+          name: `【避免指南】${name} 调用失败`,
+          type: MEMORY_TYPES.FEEDBACK,
+          project: null,
+          tags: ['error', 'avoid', name],
+          body: `【下次这样做】调用 ${name} 时遇到错误: ${error}。来源: ${source}`
+        })
+        log.debug('[Memory] Saved error lesson without AI extraction')
+      } catch (saveErr) {
+        // 忽略保存失败
+      }
+      return
+    }
+
     // 构建提取提示 - 强调"如何下次避免"
     const extractPrompt = `你是一个经验总结专家。请分析以下错误，总结如何在未来避免类似错误。
 
@@ -961,7 +1066,9 @@ class MemoryPlugin extends Plugin {
         }
       }
     } catch (err) {
-      log.warn('[Memory] Error lesson extraction failed:', err.message)
+      // 忽略所有提取错误，包括 AI 服务过载错误
+      // 这些错误不应该影响主对话流程
+      log.debug('[Memory] Error lesson extraction skipped:', err.message)
     }
   }
 
@@ -1123,25 +1230,25 @@ ${prompt}`
         return null
       }
 
-      const parts = ['【记忆上下文】']
+      const parts = ['## 【记忆上下文】']
 
       // 错误避免指南（优先显示，放在最前面）
       if (feedbackMemories.length > 0) {
-        parts.push('【错误避免指南 - 必须遵守】')
+        parts.push('### 【错误避免指南 - 必须遵守】')
         for (const m of feedbackMemories) {
           parts.push(`- ${m.body}`)
         }
       }
 
       if (userMemories.length > 0) {
-        parts.push('【用户偏好】')
+        parts.push('### 【用户偏好】')
         for (const m of userMemories) {
           parts.push(`- ${m.name}: ${m.body.substring(0, 150)}${m.body.length > 150 ? '...' : ''}`)
         }
       }
 
       if (projectMemories.length > 0) {
-        parts.push('【项目上下文】')
+        parts.push('### 【项目上下文】')
         for (const m of projectMemories) {
           const projectTag = m.project ? `[${m.project}] ` : ''
           parts.push(`- ${projectTag}${m.name}: ${m.body.substring(0, 100)}${m.body.length > 100 ? '...' : ''}`)
@@ -1176,6 +1283,11 @@ ${prompt}`
   }
 
   uninstall(framework) {
+    // 清除定时器
+    if (this._extractTimer) {
+      clearInterval(this._extractTimer)
+      this._extractTimer = null
+    }
     this._store = null
     this._framework = null
   }

package/plugins/python-plugin-loader.js

@@ -9,6 +9,7 @@ const { Plugin } = require('../src/core/plugin-base')
 const { logger } = require('../src/utils/logger')
 const log = logger.child('PythonPluginLoader')
 const { z } = require('zod')
+const { zodSchemaToMarkdown } = require('@chnak/zod-to-markdown')
 
 // 将 JSON Schema 转换为 Zod Schema
 function jsonSchemaToZod(jsonSchema) {
@@ -101,21 +102,25 @@ class PythonPluginLoader extends Plugin {
       return ''
     }
 
-    let desc = '【Python 插件】\n'
-    desc += 'Python 插件通过 ext_call 调用：\n\n'
+    let desc = '## 【Python 插件】\n'
+    desc += 'Python 插件工具已注册为 `插件名_工具名` 格式，通过 ext_call 调用：\n\n'
 
     for (const [name, plugin] of this._pythonPlugins) {
-      desc += `插件: ${plugin.info.name} - ${plugin.info.description || ''}\n`
+      desc += `### ${plugin.info.name}\n`
+      desc += `${plugin.info.description || ''}\n\n`
       if (plugin.info.tools && Array.isArray(plugin.info.tools)) {
         for (const tool of plugin.info.tools) {
-          const paramsStr = Object.keys(tool.params || {}).join(', ') || '无参数'
-          desc += `  - ${tool.name}(${paramsStr}): ${tool.description || '无描述'}\n`
+          const fullName = `${name}_${tool.name}`
+          const paramsStr = this._formatParams(tool.params || {})
+          desc += `- **${fullName}**(${paramsStr}): ${tool.description || '无描述'}\n`
         }
       }
       desc += '\n'
     }
 
-    desc += '调用格式: ext_call({ plugin: "插件名", tool: "工具名", args: {...} })\n'
+    desc += '**调用格式:**\n'
+    desc += '```\next_call({ plugin: "python", tool: "插件名_工具名", args: {...} })\n'
+    desc += '```\n'
     return desc.trim()
   }
 
@@ -202,14 +207,18 @@ class PythonPluginLoader extends Plugin {
 
   /**
    * 注册 Python 插件的工具
+   * 工具名格式：插件名_工具名（如 stock_get_price）
    */
   _registerPythonTool(pluginName, tool) {
     if (!tool.name) return
 
+    // 格式：pluginname_toolname
+    const fullToolName = `${pluginName}_${tool.name}`
+
     try {
       this.registerTool({
-        name: tool.name,
-        description: tool.description || '',
+        name: fullToolName,
+        description: `[${pluginName}] ${tool.description || ''}`,
         pluginName: pluginName,
         inputSchema: this._parseToolParams(tool.params || {}),
         execute: async (args) => {
@@ -217,7 +226,7 @@ class PythonPluginLoader extends Plugin {
         }
       })
     } catch (err) {
-      log.error(` Failed to register tool ${tool.name}:`, err.message)
+      log.error(` Failed to register tool ${fullToolName}:`, err.message)
     }
   }
 
@@ -253,6 +262,67 @@ class PythonPluginLoader extends Plugin {
     return jsonSchemaToZod(jsonSchema)
   }
 
+  /**
+   * 格式化参数描述（使用 zodSchemaToMarkdown）
+   */
+  _formatParams(params) {
+    if (!params || Object.keys(params).length === 0) {
+      return '无参数'
+    }
+
+    try {
+      // 构建 JSON Schema 格式
+      const properties = {}
+      const required = []
+
+      for (const [key, value] of Object.entries(params)) {
+        let type = 'string'
+        if (typeof value === 'boolean') type = 'boolean'
+        else if (typeof value === 'number') type = 'number'
+        else if (Array.isArray(value)) type = 'array'
+        else if (typeof value === 'object' && value !== null) type = 'object'
+
+        properties[key] = {
+          type,
+          description: ''
+        }
+        required.push(key)
+      }
+
+      const jsonSchema = {
+        type: 'object',
+        properties,
+        required
+      }
+
+      // 转换为 Zod Schema
+      const zodSchema = jsonSchemaToZod(jsonSchema)
+
+      // 使用 zodSchemaToMarkdown 生成表格
+      const table = zodSchemaToMarkdown(zodSchema)
+
+      // 提取表格中的参数行，格式化为 "param: type" 形式
+      const lines = table.split('\n')
+      const paramLines = []
+
+      for (const line of lines) {
+        if (line.startsWith('| ') && !line.includes('字段') && !line.includes('---')) {
+          const parts = line.split('|').map(s => s.trim())
+          if (parts.length >= 3 && parts[1]) {
+            const paramName = parts[1]
+            const type = parts[2]
+            paramLines.push(`${paramName}: ${type}`)
+          }
+        }
+      }
+
+      return paramLines.join(', ') || '无参数'
+    } catch (err) {
+      // fallback 到简单的参数名列表
+      return Object.keys(params).join(', ') || '无参数'
+    }
+  }
+
   /**
    * 加载单个 Python 插件的元信息
    * 支持 PLUGIN 和 TOOLS 格式

package/plugins/scheduler-plugin.js

@@ -55,7 +55,8 @@ class TaskStore {
         sessionId: t.sessionId,
         llm: t.llm,
         persistDelay: t.persistDelay,  // 相对时间的延迟毫秒数
-        persistNextRun: t.persistNextRun  // 下次执行时间
+        persistNextRun: t.persistNextRun,  // 下次执行时间
+        notify: t.notify  // 是否发送通知
       }))
       fs.writeFileSync(this._getTasksPath(), JSON.stringify(serializable, null, 2))
     } catch (err) {
@@ -180,7 +181,8 @@ class SchedulerPlugin extends Plugin {
         repeat: z.boolean().optional().describe('是否重复执行 (默认 false)'),
         cronExpression: z.string().optional().describe('Cron 表达式 (当 repeat 为 true 时使用)'),
         sessionId: z.string().optional().describe('会话 ID（提醒将发送到该会话，不填则使用默认会话）'),
-        llm: z.boolean().optional().describe('是否需要 LLM 处理（自动检测，可手动覆盖）')
+        llm: z.boolean().optional().describe('是否需要 LLM 处理（自动检测，可手动覆盖）'),
+        notify: z.boolean().optional().describe('任务完成后是否发送通知（默认 true）。设为 false 时，任务将在后台静默执行，不发送任何通知')
       }),
       execute: async (args) => {
         try {
@@ -254,7 +256,8 @@ class SchedulerPlugin extends Plugin {
               timer: null,
               cronTask: null,
               sessionId: targetSessionId || null,
-              llm: llmMode
+              llm: llmMode,
+              notify: args.notify !== false  // 默认发送通知
             }
 
             // 使用 node-cron 调度
@@ -276,7 +279,8 @@ class SchedulerPlugin extends Plugin {
               runCount: 0,
               timer: null,
               sessionId: targetSessionId || null,
-              llm: llmMode
+              llm: llmMode,
+              notify: args.notify !== false
             }
             task.timer = setTimeout(async () => {
               await this._executeTask(task)
@@ -301,7 +305,8 @@ class SchedulerPlugin extends Plugin {
               timer: null,
               sessionId: targetSessionId || null,
               llm: llmMode,
-              persistDelay: delayMs  // 保存延迟毫秒数用于持久化
+              persistDelay: delayMs,  // 保存延迟毫秒数用于持久化
+              notify: args.notify !== false
             }
             task.timer = setTimeout(async () => {
               await this._executeTask(task)
@@ -330,7 +335,8 @@ class SchedulerPlugin extends Plugin {
             cronExpression: task.cronExpression,
             message: repeat ? '定时任务已创建 (重复执行)' : '提醒已设置',
             sessionId: sessionId || 'default',
-            llm: llmMode
+            llm: llmMode,
+            notify: task.notify
           }
         } catch (err) {
           return { success: false, error: err.message }
@@ -354,6 +360,7 @@ class SchedulerPlugin extends Plugin {
           lastRun: t.lastRun,
           cronExpression: t.cronExpression,
           llm: t.llm,
+          notify: t.notify,
           sessionId: t.sessionId
         }))
 
@@ -578,29 +585,56 @@ class SchedulerPlugin extends Plugin {
         //   console.log(`\n🔔 [定时提醒] ${responseText}\n`)
         // }
 
-        // 发送统一的通知事件
-        this._framework.emit('notification', {
-          title: task.name,
-          message: responseText || task.message,
-          source: 'scheduler',
-          level: 'info',
-          sessionId: task.sessionId,
-          timestamp: new Date()
+        // 根据 notify 参数决定是否发送通知
+        if (task.notify !== false) {
+          // 发送统一的通知事件
+          this._framework.emit('notification', {
+            title: task.name,
+            message: responseText || task.message,
+            source: 'scheduler',
+            level: 'info',
+            sessionId: task.sessionId,
+            timestamp: new Date()
+          })
+          // 发送 scheduler:reminder 事件
+          this._framework.emit('scheduler:reminder', {
+            taskId: task.id,
+            message: task.message,
+            time: task.runAt || task.nextRun
+          })
+        }
+
+        // 发送任务完成事件
+        this._framework.emit('scheduler:task_completed', {
+          taskId: task.id,
+          result: responseText || task.message
         })
       } else {
         // 直接显示模式：只显示提醒，不发 LLM
-        //console.log(`\n🔔 [定时提醒] ${task.message}\n`)
+        // 根据 notify 参数决定是否发送通知
+        if (task.notify !== false) {
+          // 发送统一的通知事件
+          this._framework.emit('notification', {
+            title: task.name,
+            message: task.message,
+            source: 'scheduler',
+            level: 'info',
+            sessionId: task.sessionId,
+            timestamp: new Date()
+          })
+          // 发送 scheduler:reminder 事件
+          this._framework.emit('scheduler:reminder', {
+            taskId: task.id,
+            message: task.message,
+            time: task.runAt || task.nextRun
+          })
+        }
 
-        // 发送统一的通知事件
-        this._framework.emit('notification', {
-          title: task.name,
-          message: task.message,
-          source: 'scheduler',
-          level: 'info',
-          sessionId: task.sessionId,
-          timestamp: new Date()
+        // 发送任务完成事件
+        this._framework.emit('scheduler:task_completed', {
+          taskId: task.id,
+          result: task.message
         })
-
         this._taskStats.completed++
       }
 
@@ -624,6 +658,12 @@ class SchedulerPlugin extends Plugin {
         timestamp: new Date()
       })
 
+      // 发送任务失败事件
+      this._framework.emit('scheduler:task_failed', {
+        taskId: task.id,
+        error: err.message
+      })
+
       // 一次性任务失败后也清理
       if (task.type === 'once' && !task.cronTask) {
         this._cleanupTask(task.id)

package/plugins/think-plugin.js

@@ -131,9 +131,14 @@ class ThinkPlugin extends Plugin {
         this._thoughts = this._thoughts.slice(-100)
       }
 
-      // 触发思考完成事件
+      // 触发思考完成事件（使用文档规定的字段结构）
       if (this._framework) {
-        this._framework.emit('think:thought_completed', thought)
+        this._framework.emit('think:thought_completed', {
+          mode: thought.mode,
+          topic: thought.topic,
+          thought: thought.result,
+          depth: thought.depth
+        })
       }
 
       return {