foliko 1.1.20 → 1.1.21

package/nul

@@ -0,0 +1,3 @@
+dir: cannot access '/s': No such file or directory
+dir: cannot access '/b': No such file or directory
+dir: cannot access '*.png': No such file or directory

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "foliko",
-  "version": "1.1.20",
+  "version": "1.1.21",
   "description": "简约的插件化 Agent 框架",
   "main": "src/index.js",
   "type": "commonjs",

package/plugins/ambient-agent/ExplorerLoop.js

@@ -4,7 +4,6 @@
 
 const { Plugin } = require('../../src/core/plugin-base')
 const { logger } = require('../../src/utils/logger')
-const { Agent } = require('../../src/core/agent')
 const { StepExecutor } = require('../../src/capabilities/workflow-engine')
 const { SystemPrompts, ThinkModePrompts, FreeThinkPrompts } = require('./constants')
 
@@ -37,13 +36,19 @@ class ExplorerLoop {
     const aiPlugin = this._framework.pluginManager?.get('ai')
     const llmConfig = aiPlugin ? aiPlugin.getConfig() : {}
 
-    this._ambientAgent = new Agent(this._framework, {
+    // 使用 Subagent 代替 Agent，轻量化处理后台任务
+    this._ambientAgent = this._framework.createSubAgent({
       name: 'ambient-worker',
+      role: '后台任务执行助手',
+      description: '执行需要 AI 能力的后台任务',
       systemPrompt: SystemPrompts.ambientWorker,
-      model: llmConfig.model,
-      provider: llmConfig.provider,
-      apiKey: llmConfig.apiKey,
-      baseURL: llmConfig.baseURL
+      isAll:true,
+      llmConfig: {
+        model: llmConfig.model,
+        provider: llmConfig.provider,
+        apiKey: llmConfig.apiKey,
+        baseURL: llmConfig.baseURL
+      }
     })
 
     // 注册到主 agent（如果主 agent 已存在）
@@ -451,10 +456,22 @@ class ExplorerLoop {
     if (typeof value === 'string') {
       // 处理 ${actionId.output} 和 ${actionId.output.field} 格式
       const result = value.replace(/\$\{([^}]+)\}/g, (match, path) => {
+        // 特殊处理：${result.xxx} 引用上一步结果中的字段
+        if (path.startsWith('result.')) {
+          const fieldPath = path.replace(/^result\./, '')
+          const lastResult = stepOutputs._lastResult
+          if (lastResult) {
+            const val = this._getNestedValue(lastResult, fieldPath)
+            if (val !== undefined) return val
+          }
+          return match
+        }
+        
         if (path === 'output' || path === 'result') {
-          // {{result}} 引用上一步结果
+          // ${result} 引用上一步结果
           return stepOutputs._lastResult ?? match
         }
+        
         if (path.startsWith('event.')) {
           // ${event.xxx} 引用事件数据
           let eventPath = path.replace(/^event\./, '')
@@ -478,10 +495,12 @@ class ExplorerLoop {
           }
           return match
         }
+        
         if (path === 'event') {
           // ${event} 引用整个事件数据对象
           return eventData ?? match
         }
+        
         if (path.includes('.')) {
           // ${actionId.output.field} 格式
           const [actionId, ...fieldParts] = path.split('.')
@@ -526,6 +545,66 @@ class ExplorerLoop {
     return current
   }
 
+  /**
+   * 判断 LLM 回复是否应该发送通知
+   * 识别模式：
+   * - 包含 "【通知】" 或 "[通知]" 开头的回复
+   * - JSON 中包含 notification_send 调用
+   * - 包含 "已发送通知"、"发送通知" 等关键词
+   */
+  _shouldSendNotification(resultText) {
+    if (!resultText) return false
+    
+    // 检查通知标记
+    const notifyPatterns = [
+      /【通知】/,
+      /\[通知\]/,
+      /notification_send/,
+      /已发送通知/,
+      /发送通知成功/,
+      /通知已发送/,
+      /【提醒】/,
+      /\[提醒\]/,
+      /⚠️|🚨|🔔|📢/  // 常见通知 emoji
+    ]
+    
+    return notifyPatterns.some(pattern => pattern.test(resultText))
+  }
+
+  /**
+   * 从 LLM 回复中提取通知内容
+   */
+  _extractNotification(resultText) {
+    if (!resultText) return null
+    
+    // 尝试提取 【通知】... 内容
+    const zhMatch = resultText.match(/【通知】([\s\S]*?)(?:```|$)/)
+    if (zhMatch) {
+      const content = zhMatch[1].trim()
+      // 尝试分离标题和内容
+      const lines = content.split('\n').filter(l => l.trim())
+      if (lines.length >= 2) {
+        return { title: lines[0], message: lines.slice(1).join('\n') }
+      } else if (lines.length === 1) {
+        return { title: '通知提醒', message: lines[0] }
+      }
+    }
+    
+    // 尝试提取 [通知]... 内容
+    const enMatch = resultText.match(/\[通知\]([\s\S]*?)(?:```|$)/)
+    if (enMatch) {
+      const content = enMatch[1].trim()
+      const lines = content.split('\n').filter(l => l.trim())
+      if (lines.length >= 1) {
+        return { title: lines[0], message: lines.slice(1).join('\n') || lines[0] }
+      }
+    }
+    
+    // 默认：从结果中提取前100字符作为消息
+    const shortContent = resultText.substring(0, 200).replace(/```[\s\S]*?```/g, '').trim()
+    return { title: 'Ambient Agent 通知', message: shortContent }
+  }
+
   /**
    * 按顺序执行所有 actions
    * @param {Array} actions - action 数组
@@ -607,9 +686,36 @@ class ExplorerLoop {
         content = `${content}\n\n[事件上下文: ${JSON.stringify(context.variables._event)}]`
       }
 
+      // 添加通知能力提示
+      const notifyPrompt = `\n\n## 通知能力\n如果你需要发送通知，可以使用 notification_send 工具：\n- plugin: "notification"\n- tool: "notification_send"  \n- args: { "title": "通知标题", "message": "通知内容" }\n\n**重要**：当判断结果满足条件时，你应该调用 notification_send 发送通知。不满足条件时，静默结束即可。`
+
       try {
-        const result = await this._ambientAgent.pushMessage(content)
-        return { success: true, result }
+        const result = await this._ambientAgent.chat(content + notifyPrompt, { maxRetries: 2 })
+
+        // Subagent 返回 { success, message, steps, error }
+        if (!result.success) {
+          return { success: false, error: result.error }
+        }
+
+        const resultText = result.message || ''
+
+        // 如果 result 中包含通知相关的内容，自动发送通知
+        if (this._shouldSendNotification(resultText)) {
+          const notification = this._extractNotification(resultText)
+          if (notification) {
+            // 通过事件系统发送通知
+            this._framework.emit('notification', {
+              title: notification.title || 'Ambient Agent 通知',
+              message: notification.message,
+              source: 'ambient',
+              level: 'info',
+              timestamp: new Date()
+            })
+            return { success: true, result: resultText, notified: true, notification }
+          }
+        }
+
+        return { success: true, result: resultText }
       } catch (err) {
         return { success: false, error: err.message }
       }
@@ -701,8 +807,12 @@ ${extensionsInfo}
 请直接返回 JSON 代码块。`
 
       try {
-        const response = await this._ambientAgent.pushMessage(prompt)
-        const responseText = typeof response === 'string' ? response : JSON.stringify(response)
+        const result = await this._ambientAgent.chat(prompt, { maxRetries: 2 })
+        if (!result.success) {
+          log.warn(`[ExplorerLoop] Subagent 调用失败: ${result.error}`)
+          return { success: false, error: result.error }
+        }
+        const responseText = result.message || ''
 
         // 尝试解析 LLM 返回的 JSON
         let toolChoice = null

package/plugins/ambient-agent/GoalManager.js

@@ -183,7 +183,7 @@ class GoalManager {
       e.event === event.type && (now - new Date(e.timestamp).getTime()) < 2000
     )
     if (recentSameEvent) {
-      log.info(`跳过重复事件: ${event.type} (2秒内不重复添加)`)
+      //log.info(`跳过重复事件: ${event.type} (2秒内不重复添加)`)
       return
     }
 

package/plugins/extension-executor-plugin.js

@@ -136,7 +136,7 @@ class ExtensionExecutorPlugin extends Plugin {
       }),
       execute: async (args) => {
         const { plugin, tool, args: toolArgs = {} } = args;
-        log.info(` ext_call: plugin=${plugin}, tool=${tool}, args=${JSON.stringify(toolArgs)}`);
+        log.info(`[Extension] ext_call: plugin=${plugin}, tool=${tool}`);
 
         // MCP 服务器工具（已注册为 server_toolname 格式，如 github_search）
         if (plugin === 'mcp' && this._mcpExecutor) {

package/plugins/weixin-plugin.js

@@ -463,8 +463,11 @@ class WeixinPlugin extends Plugin {
           [用户发送了${type_dict[msg.type]}消息]\n
           文件列表：\n
           ${JSON.stringify(files,null,2)} \n
-        
-          *重要：* 不要试图读取文件内容！
+
+          **重要提醒：**
+          - 禁止读取任何文件内容！
+          - 禁止调用任何读取工具！
+          - 只告知用户文件保存路径
         `
         , msg)
         break

package/src/core/agent-chat.js

@@ -606,6 +606,8 @@ class AgentChatHandler extends EventEmitter {
    */
   async _prepareSession(message, sessionId) {
     const messageStore = this._getSessionMessageStore(sessionId);
+    // 先加载 session 文件中的历史消息
+    this._chatSession.loadHistory(sessionId);
     const messages = messageStore.messages;
 
     // 刷新系统提示词
@@ -621,11 +623,17 @@ class AgentChatHandler extends EventEmitter {
     const totalTokens = messagesTokens + toolsTokens + systemPromptTokens;
     const limit = this._maxContextTokens * 0.5;
 
+    console.log(
+      `[_prepareSession] BEFORE: messages=${messages.length}, tokens=${totalTokens}/${limit}`
+    );
+
     if (totalTokens > limit) {
+      console.log(`[_prepareSession] Compressing context...`);
       logger.info(
         `Context large (${totalTokens}/${this._maxContextTokens} tokens), compressing...`
       );
       await this._compressContext(sessionId, messages, messageStore);
+      console.log(`[_prepareSession] AFTER compress: messages=${messages.length}`);
     }
 
     // 最终 token 检查
@@ -743,26 +751,31 @@ class AgentChatHandler extends EventEmitter {
       try {
         const tokenCount = this._countMessagesTokens(inputMessages);
         const tokenLimit = this._maxContextTokens * 0.75;
-        logger.debug(`prepareStep: messages=${inputMessages.length}, tokens=${tokenCount}`);
 
+        // 超过限制时，保留三分之一的消息
         if (tokenCount > tokenLimit) {
-          logger.info(
-            `Context compress triggered: messages=${inputMessages.length}, tokens=${tokenCount}/${tokenLimit}`
+          const keepCount = Math.max(10, Math.floor(inputMessages.length / 3));
+          console.log(
+            `[PrepareStep] Trimming: ${inputMessages.length} msgs -> ${keepCount}, tokens=${tokenCount}`
           );
-          const pairedMessages = await this._compressContextForPrepare(inputMessages);
-          if (pairedMessages.length !== inputMessages.length) {
-            logger.info(`Compressed ${inputMessages.length} -> ${pairedMessages.length} messages`);
-            inputMessages.length = 0;
-            inputMessages.push(...pairedMessages);
-          }
+          const trimmed = inputMessages.slice(-keepCount);
+          inputMessages.length = 0;
+          inputMessages.push(...trimmed);
         }
 
+        // 验证 tool-call 和 tool-result 配对
         const validated = this._validateMessagesPairing(inputMessages);
         if (validated.length !== inputMessages.length) {
+          console.log(
+            `[PrepareStep] After pairing validation: ${inputMessages.length} -> ${validated.length}`
+          );
           inputMessages.length = 0;
           inputMessages.push(...validated);
         }
+
+        // 验证 tool-call 格式
         this._validateToolCalls(inputMessages);
+
         return { messages: inputMessages };
       } catch (err) {
         logger.error('prepareStep error:', err.message, err.stack);

package/src/core/chat-session.js

@@ -212,9 +212,14 @@ class ChatSession extends EventEmitter {
       return messageStore.messages;
     }
 
-    // 从 SessionContext 加载
+    // 确保 SessionContext 已初始化（会从文件加载或创建新的）
     if (this.agent?.framework) {
-      const sessionCtx = this.agent.framework._sessionContexts?.get(sessionId);
+      // 先尝试获取已存在的 SessionContext
+      let sessionCtx = this.agent.framework._sessionContexts?.get(sessionId);
+      // 如果不存在，调用 getOrCreateSessionContext 来加载或创建
+      if (!sessionCtx) {
+        sessionCtx = this.agent.framework.getOrCreateSessionContext(sessionId);
+      }
       if (sessionCtx) {
         const messages = sessionCtx.getMessages();
         if (messages && messages.length > 0) {

package/src/core/context-compressor.js

@@ -15,7 +15,7 @@ const MODEL_CONTEXT_LIMITS = {
   'deepseek-chat': 128000,
   'deepseek-coder': 128000,
   'deepseek-reasoner': 128000,
-  'MiniMax-M2.7': 110000,
+  'MiniMax-M2.7': 128000,
   'gpt-4': 100000,
   'gpt-4o': 100000,
   'gpt-4o-mini': 100000,
@@ -136,14 +136,14 @@ class ContextCompressor {
     const messagesToSummarize = otherMessages.slice(0, -this._keepRecentMessages);
 
     const compressedCount = messagesToSummarize.length;
+
     let summaryContent = '';
 
     // 使用 AI 生成摘要
     if (this._enableSmartCompress && this.agent?._chatHandler?._aiClient) {
       try {
         const summaryText = await this._summarizeMessages(messagesToSummarize);
-        summaryContent = `[早期对话摘要]: ${summaryText}`;
-        logger.info(`AI summary generated (${summaryText.length} chars)`);
+        summaryContent = `[早期对话摘要]: ${summaryText || '（无内容）'}`;
       } catch (err) {
         logger.warn('AI summary failed, using simple compression:', err.message);
         summaryContent = `[上下文已压缩: 省略了 ${compressedCount} 条早期消息。保留了最近 ${this._keepRecentMessages} 条对话记录。]`;
@@ -409,23 +409,36 @@ class ContextCompressor {
    * @private
    */
   async _summarizeMessages(messages) {
-    if (!this.agent?._chatHandler?._aiClient) {
+    const chatHandler = this.agent?._chatHandler;
+    if (!chatHandler?._aiClient) {
       throw new Error('AI client not available');
     }
 
     const { generateText } = await import('ai');
 
-    const prompt = `请简要总结以下对话的主要内容，用 100 字以内描述：
-
-${messages.map((m) => `${m.role}: ${typeof m.content === 'string' ? m.content : JSON.stringify(m.content)}`).join('\n')}
-
-摘要：`;
+    // 使用 AI SDK 消息格式
+    const chatMessages = [
+      {
+        role: 'user',
+        content:
+          '请简要总结以下对话的主要内容，用1000字以内描述：\n' +
+          messages
+            .map((m) => {
+              const content =
+                typeof m.content === 'string' ? m.content : JSON.stringify(m.content || '');
+              return `${m.role}: ${content}`;
+            })
+            .join('\n'),
+      },
+    ];
 
     try {
+      // _aiClient 已经是 model 对象，直接使用
+      const model = chatHandler._aiClient;
       const result = await generateText({
-        model: this.agent._chatHandler._aiClient,
-        prompt: prompt,
-        maxTokens: 200,
+        model: model,
+        messages: chatMessages,
+        maxTokens: 1000,
       });
       return result.text || '';
     } catch (err) {
@@ -458,6 +471,10 @@ ${messages.map((m) => `${m.role}: ${typeof m.content === 'string' ? m.content :
 
     let total = 4; // 角色开销
 
+    if (!msg.content) {
+      return total;
+    }
+
     if (typeof msg.content === 'string') {
       total += Math.ceil(Buffer.byteLength(msg.content, 'utf8') / 4);
     } else if (Array.isArray(msg.content)) {
@@ -470,7 +487,11 @@ ${messages.map((m) => `${m.role}: ${typeof m.content === 'string' ? m.content :
           }
         } else if (block.type === 'tool-result' || block.type === 'tool_result') {
           const content =
-            typeof block.content === 'string' ? block.content : JSON.stringify(block.content);
+            block.content == null
+              ? ''
+              : typeof block.content === 'string'
+                ? block.content
+                : JSON.stringify(block.content);
           total += Math.ceil(Buffer.byteLength(content, 'utf8') / 4);
         }
       }

package/src/core/subagent.js

@@ -50,7 +50,7 @@ class Subagent extends EventEmitter {
     };
     // 如果提供了 systemPrompt 则使用，否则标记为需要动态构建
     this._customSystemPrompt = config.systemPrompt || null;
-    this.parentTools = config?.parentTools || [];
+    this.parentTools = config?.parentTools;
     // 工具管理
     this._tools = new Map();
     this._registerTools(config.tools || []);
@@ -121,20 +121,31 @@ class Subagent extends EventEmitter {
     const tools = {};
     // 从父Agent继承工具
     const all_tools = this.framework.getTools();
-    this.parentTools = this.parentTools.map((key) => {
-      return this.bindTools[key.toLocaleLowerCase()] || key;
-    });
-    for (const toolName of this.parentTools) {
-      const toolDef = all_tools.find((t) => t.name === toolName);
-      if (toolDef) {
-        tools[toolDef.name] = toolDef;
+    let parentTools = [];
+    if (Array.isArray(this.parentTools)) {
+      parentTools = this.parentTools.map((key) => {
+        return this.bindTools[key.toLocaleLowerCase()] || key;
+      });
+      for (const toolName of parentTools) {
+        const toolDef = all_tools.find((t) => t.name === toolName);
+        if (toolDef) {
+          tools[toolDef.name] = toolDef;
+        }
+      }
+      const defaulTools = all_tools.filter((a) => this.defaulTools.includes(a.name));
+
+      defaulTools.map((tool) => {
+        tools[tool.name] = tool;
+      });
+    } else {
+      for (const toolName of all_tools) {
+        const toolDef = all_tools.find((t) => t.name === toolName);
+        if (toolDef) {
+          tools[toolDef.name] = toolDef;
+        }
       }
     }
-    const defaulTools = all_tools.filter((a) => this.defaulTools.includes(a.name));
 
-    defaulTools.map((tool) => {
-      tools[tool.name] = tool;
-    });
     return { ...tools, ...this._tools };
   }
 

package/src/utils/chat-queue.js

@@ -119,7 +119,12 @@ class ChatQueueManager extends EventEmitter {
 
         // 检查是否有错误（通过返回的 result.error）
         if (result.error) {
-          console.log('[ChatQueue] executeWithRetry: attempt', attempt, 'got error:', result.error.message);
+          console.log(
+            '[ChatQueue] executeWithRetry: attempt',
+            attempt,
+            'got error:',
+            result.error.message
+          );
           lastError = result.error;
           if (attempt < this.retryAttempts && this.isRetryableError(lastError)) {
             await this.sleep(this.retryDelay * Math.pow(2, attempt - 1));
@@ -132,7 +137,12 @@ class ChatQueueManager extends EventEmitter {
 
         return result;
       } catch (error) {
-        console.log('[ChatQueue] executeWithRetry: attempt', attempt, 'threw error:', error.message);
+        console.log(
+          '[ChatQueue] executeWithRetry: attempt',
+          attempt,
+          'threw error:',
+          error.message
+        );
         lastError = error;
         if (attempt < this.retryAttempts && this.isRetryableError(error)) {
           await this.sleep(this.retryDelay * Math.pow(2, attempt - 1));
@@ -186,7 +196,10 @@ class ChatQueueManager extends EventEmitter {
         ? 'AI 服务暂时不可用，请稍后重试'
         : (err.message || err.toString()).split('\n')[0];
 
-      console.log('[ChatQueue] executeStream caught error, converting to friendly:', friendlyMessage);
+      console.log(
+        '[ChatQueue] executeStream caught error, converting to friendly:',
+        friendlyMessage
+      );
       chunks.push({ type: 'error', error: friendlyMessage });
       this.emit('stream:chunk', {
         requestId: item.id,

package/system.md

@@ -5,6 +5,85 @@
 【元数据】
 - WORK_DIR: D:\code\vb-agent
 
+## 【Ambient Agent 监控任务指南】
+
+当用户请求创建条件监控任务（如"价格高于X时通知我"、"收到某邮件时自动回复"）时，使用以下模式：
+
+### 标准条件监控配置
+
+```javascript
+{
+  "title": "监控任务标题",
+  "description": "监控条件描述（包含阈值等信息）",
+  "conditions": { "events": ["scheduler:reminder"] },
+  "persistent": true,
+  "actions": [
+    {
+      "id": "get_data",
+      "type": "tool",
+      "plugin": "gate-trading",  // 或 email, web 等
+      "name": "gate_get_market_info",
+      "args": { "currency_pair": "BTC_USDT", "info_type": "tickers" }
+    },
+    {
+      "id": "judge",
+      "type": "message",
+      "content": "你是一个条件判断助手。\n\n上一步获取到了数据：${result.last}\n\n判断规则：\n- 如果数据满足条件，调用 notification_send 发送通知\n- 如果不满足条件，静默结束（不要发送任何通知）\n\n你的任务是分析数据，判断是否需要通知用户。"
+    }
+  ]
+}
+```
+
+### 关键要点
+
+1. **actions 必须包含两个步骤**：
+   - 第一步：用 `type: "tool"` 获取数据
+   - 第二步：用 `type: "message"` 让 LLM 判断是否发送通知
+
+2. **message content 中的判断提示词**：
+   - 明确告诉 LLM 阈值是多少
+   - 说明满足条件时应该做什么
+   - 说明不满足条件时应该静默
+
+3. **使用 ${result.xxx} 引用上一步结果**：
+   - `${result.last}` - 获取价格数据
+   - `${result.from}` - 获取发件人
+   - `${result.subject}` - 获取邮件主题
+
+### 示例：比特币价格监控
+
+```javascript
+{
+  "title": "比特币价格监控 (BTC > $73000)",
+  "description": "每2分钟检查BTC价格，高于73000美元时通知",
+  "conditions": { "events": ["scheduler:reminder"] },
+  "persistent": true,
+  "actions": [
+    {
+      "type": "tool",
+      "plugin": "gate-trading",
+      "name": "gate_get_market_info",
+      "args": { "currency_pair": "BTC_USDT", "info_type": "tickers" }
+    },
+    {
+      "type": "message",
+      "content": "你是条件判断助手。\n\n上一步获取到 BTC 价格数据：${result.last} USDT\n\n监控条件：价格 > 73000 USDT\n\n判断规则：\n- 如果 ${result.last} > 73000，调用 notification_send 发送通知\n- 通知内容：当前 BTC 价格 ${result.last} USDT，已超过 $73000 阈值\n- 如果价格 <= 73000，静默结束，不要发送任何通知"
+    }
+  ]
+}
+```
+
+### 常见监控场景配置
+
+| 场景 | 工具 | 判断逻辑 |
+|------|------|----------|
+| 价格监控 | gate_get_market_info | 价格 > 阈值 |
+| 邮件监控 | email_read | 主题/发件人匹配 |
+| 余额监控 | gate_get_account_balance | 余额变化 |
+| 网页监控 | web_request | 内容包含某字符串 |
+
+---
+
 ## 【记忆上下文】
 ### 【用户偏好】
 - 用户海报风格偏好: ## 用户海报设计风格偏好