foliko 1.0.64 → 1.0.65

package/cli/src/commands/chat.js

@@ -93,7 +93,10 @@ async function chatCommand(args) {
       provider: options.provider,
       model: options.model,
       baseURL: options.baseURL,
-      apiKey: options.apiKey
+      apiKey: options.apiKey,
+      providerOptions:{
+        maxOutputTokens: 8192,
+      }
     }
   })
 

package/package.json

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

package/plugins/ai-plugin.js

@@ -20,7 +20,8 @@ class AIPlugin extends Plugin {
       model: config.model || 'deepseek-chat',
       apiKey: config.apiKey,
       baseURL: config.baseURL,
-      maxSteps: config.maxSteps || 20
+      maxSteps: config.maxSteps || 20,
+      maxOutputTokens:config.maxOutputTokens||8192
     }
 
     this._aiClient = null

package/plugins/ambient-agent-plugin.js

@@ -428,7 +428,7 @@ class ExplorerLoop {
     }
 
     this._tickCount++
-    this._lastActionTime = Date.now()
+    
 
     try {
       await this._processGoals()
@@ -436,7 +436,7 @@ class ExplorerLoop {
       console.error('[Ambient] Tick错误:', err.message)
       this._addActivity('error', { message: err.message })
     }
-
+    this._lastActionTime = Date.now()
     // 调度下一次tick
     this._scheduleNext()
   }

package/plugins/email.js

@@ -201,6 +201,126 @@ class EmailPlugin extends Plugin {
         return this._handleEmailWatch(args)
       }
     })
+
+    // 自动回复邮件
+    this._framework.registerTool({
+      name: 'email_auto_reply',
+      description: '自动分析邮件内容并发送回复（无需用户确认）',
+      inputSchema: z.object({
+        to: z.string().describe('收件人邮箱地址'),
+        subject: z.string().describe('原始邮件主题'),
+        body: z.string().describe('原始邮件内容'),
+        from: z.string().optional().describe('发件人邮箱地址（可选）'),
+        prompt: z.string().optional().describe('自定义提示词，用于指导AI生成回复内容')
+      }),
+      execute: async (args) => {
+        return this._handleAutoReply(args)
+      }
+    })
+  }
+
+  /**
+   * 处理自动回复
+   */
+  async _handleAutoReply(args) {
+    let { to, subject, body, from, _event, prompt } = args
+
+    // 如果没有直接参数，尝试从 _event 提取
+    if (!to && !subject && !body && _event) {
+      const email = _event.data?.email || _event.email || {}
+      from = email.from?.text || email.from || ''
+      to = email.to?.text || email.to || ''
+      subject = email.subject || ''
+      body = email.text || email.body || ''
+    }
+
+    // 检查必要参数
+    if (!from && !to) {
+      return { success: false, error: '缺少收件人地址' }
+    }
+    if (!body) {
+      return { success: false, error: '缺少邮件内容' }
+    }
+
+    try {
+      // 获取活跃的 Agent
+      const agent = this._getActiveAgent()
+      if (!agent) {
+        return { success: false, error: 'No active agent found' }
+      }
+
+      // 构建提示让 LLM 生成回复
+      const finalPrompt = prompt || `你是一封邮件自动回复助手。请根据以下邮件内容，生成一封专业的回复邮件。
+
+【原始邮件】
+发件人: ${from || to}
+主题: ${subject}
+内容:
+${body}
+
+【要求】
+1. 回复内容要针对邮件中的问题或内容进行回复
+2. 语言要专业、礼貌、简洁
+3. 只输出邮件正文内容，不要额外解释
+4. 回复语言应与原邮件一致（如果原邮件是中文，则用中文回复）`
+
+      // 等待 Agent 生成回复（带超时保护）
+      const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => reject(new Error('AI回复生成超时（30秒）')), 30000)
+      })
+
+      const replyPromise = agent.pushMessage(finalPrompt, { maxSteps: 3 })
+      const replyResult = await Promise.race([replyPromise, timeoutPromise])
+
+      // 提取回复内容
+      let replyContent = ''
+      if (typeof replyResult === 'string') {
+        replyContent = replyResult.trim()
+      } else if (replyResult && replyResult.content) {
+        replyContent = replyResult.content.trim()
+      } else if (replyResult && replyResult.message) {
+        replyContent = replyResult.message.trim()
+      } else {
+        replyContent = JSON.stringify(replyResult).trim()
+      }
+
+      // 去掉思考过程标签
+      replyContent = replyContent.replace(/<think>[\s\S]*?<\/think>/g, '').trim()
+
+      if (!replyContent || replyContent.length < 5) {
+        return { success: false, error: 'AI未能生成有效的回复内容' }
+      }
+
+      // 发送回复邮件
+      const sendResult = await this._sendEmail({
+        to: from || to,
+        subject: `Re: ${subject}`,
+        body: replyContent
+      })
+
+      if (sendResult.success) {
+        return {
+          success: true,
+          message: `自动回复已发送至 ${from || to}`,
+          replyContent
+        }
+      } else {
+        return { success: false, error: sendResult.error || '发送失败' }
+      }
+    } catch (err) {
+      return { success: false, error: err.message }
+    }
+  }
+
+  /**
+   * 获取活跃的 Agent
+   */
+  _getActiveAgent() {
+    if (this._framework._mainAgent) {
+      return this._framework._mainAgent
+    }
+    const agents = this._framework._agents || []
+    return agents.length > 0 ? agents[agents.length - 1] : null
   }
 
   /**
@@ -209,10 +329,10 @@ class EmailPlugin extends Plugin {
   async _handleEmailWatch(args) {
     args={
       ...args,
-      host: config.host || process.env.IMAP_HOST,
-      port: config.port || parseInt(process.env.IMAP_PORT) || 993,
-      user: config.user || process.env.IMAP_USER,
-      password: config.password || process.env.IMAP_PASS
+      host: process.env.IMAP_HOST,
+      port: parseInt(process.env.IMAP_PORT) || 993,
+      user: process.env.IMAP_USER,
+      password: process.env.IMAP_PASS
     }
     
     const { action, interval, host, port, user, password, box } = args
@@ -407,7 +527,7 @@ class EmailPlugin extends Plugin {
                       // 发送事件通知
                       this._emitEmailReceived(email)
 
-                      //console.log(`[Email] New email received: ${email.subject}`)
+                      console.log(`[Email] New email received: ${email.subject}`)
                       cleanup()
                       resolve({ success: true, newEmails: newEmails.length, email })
                     } else {

package/plugins/file-system-plugin.js

@@ -401,10 +401,10 @@ class FileSystemPlugin extends Plugin {
       inputSchema: z.object({
         title: z.string().describe('通知标题'),
         message: z.string().describe('通知内容'),
-        source: z.string().optional().describe('通知来源标识，默认 file-system')
+        source: z.string().optional().describe('通知来源标识，默认 系统消息')
       }),
       execute: async (args, framework) => {
-        const { title, message, source = 'file-system' } = args
+        const { title, message, source = '系统消息' } = args
         try {
           // 获取当前执行上下文中的 sessionId，只发送到当前会话
           const ctx = framework.getExecutionContext()

package/skills/workflow-guide/SKILL.md

@@ -1,14 +1,14 @@
 ---
 name: workflow-guide
 description: 工作流与多步任务指南。当用户说"创建工作流"、"多步任务"、"自动化流程"时立即调用。
-allowed-tools: Read, Write, Edit, Glob, Grep, Bash, execute_workflow, reloadWorkflows
+allowed-tools: execute_workflow,reloadWorkflows
 ---
 
 # 工作流（Workflow）开发指南
 
 ## 概述
 
-工作流引擎用于处理多步骤任务，通过 `execute_workflow` 工具执行。工作流由多个步骤组成，支持脚本、条件分支、循环、延时等类型。
+工作流引擎用于处理多步骤任务，通过 `execute_workflow` 工具执行。工作流由多个步骤组成，支持脚本、条件分支、循环、延时、工具调用等类型。
 
 ## 工作流存放位置
 
@@ -46,7 +46,7 @@ allowed-tools: Read, Write, Edit, Glob, Grep, Bash, execute_workflow, reloadWork
 {
   "tool": "execute_workflow",
   "args": {
-    "workflow": "<工作流 JSON 字符串>",
+    "workflow": "my-workflow",  // 工作流名称（自动从 .agent/workflows/ 加载）
     "input": { "变量名": "值" }
   }
 }
@@ -62,26 +62,83 @@ allowed-tools: Read, Write, Edit, Glob, Grep, Bash, execute_workflow, reloadWork
 }
 ```
 
+## 重要注意事项
+
+1. **script 必须用 return 返回值**：`script` 是函数体，不是表达式
+2. **JSON 中不能使用多行字符串**：所有 script 内容写成单行，用分号分隔
+3. **JSON 中不能有注释**：注释会导致 JSON 解析失败
+
 ## 工作流步骤类型
 
 ### 1. script - 脚本步骤
 
-执行 JavaScript 脚本：
+执行 JavaScript 脚本，**必须用 return 返回值**：
 
 ```json
 {
   "type": "script",
   "name": "步骤名称",
   "outputVariable": "result",
-  "script": "context.variables.x = 10; return context.variables.x;"
+  "script": "var x=10; context.variables.count=x+1; return context.variables.count;"
 }
 ```
 
-- `outputVariable`: 可选，将返回值存入上下文变量
+**正确写法**：
+```json
+{ "script": "return context.variables.value + 1;" }
+```
+
+**错误写法**（缺少 return）：
+```json
+{ "script": "context.variables.value + 1;" }
+```
+
+- `outputVariable`: 可选，将返回值存入 `context.variables`
 - `context.variables`: 所有步骤共享的变量对象
-- `context.stepResults`: 上一步的输出结果
+- `context.lastResult`: 上一步的输出结果
 
-### 2. loop - 循环步骤
+### 2. tool - 工具调用步骤
+
+在工作流中调用框架注册的工具：
+
+```json
+{
+  "type": "tool",
+  "name": "发送通知",
+  "tool": "notification_send",
+  "args": {
+    "title": "标题",
+    "message": "内容"
+  },
+  "outputVariable": "result"
+}
+```
+
+**参数说明**：
+
+| 字段 | 类型 | 必填 | 说明 |
+|------|------|------|------|
+| `tool` | string | 是 | 工具名称 |
+| `args` | object | 否 | 工具参数 |
+| `outputVariable` | string | 否 | 结果保存到的变量名 |
+
+**args 中支持变量引用**：
+
+使用 `{{variableName}}` 语法引用 context.variables 中的变量：
+
+```json
+{
+  "type": "tool",
+  "name": "发送通知",
+  "tool": "notification_send",
+  "args": {
+    "title": "IP 信息",
+    "message": "当前公网IP: {{currentIp}}"
+  }
+}
+```
+
+### 3. loop - 循环步骤
 
 重复执行一组步骤：
 
@@ -100,7 +157,7 @@ allowed-tools: Read, Write, Edit, Glob, Grep, Bash, execute_workflow, reloadWork
 - `maxIterations`: 最大迭代次数
 - `loopVariable`: 循环计数器变量名（从 0 开始）
 
-### 3. condition - 条件分支
+### 4. condition - 条件分支
 
 根据条件选择执行分支：
 
@@ -123,7 +180,7 @@ allowed-tools: Read, Write, Edit, Glob, Grep, Bash, execute_workflow, reloadWork
 }
 ```
 
-### 4. delay - 延时步骤
+### 5. delay - 延时步骤
 
 等待指定毫秒数：
 
@@ -135,85 +192,63 @@ allowed-tools: Read, Write, Edit, Glob, Grep, Bash, execute_workflow, reloadWork
 }
 ```
 
-### 5. parallel - 并行步骤（可选）
+### 6. sequential - 顺序步骤
 
-并行执行多个步骤：
+将多个步骤组合为顺序执行（可嵌套使用）：
 
 ```json
 {
-  "type": "parallel",
-  "name": "并行执行",
-  "steps": [...]
+  "type": "sequential",
+  "name": "顺序执行",
+  "steps": [
+    { "type": "script", "name": "步骤1", "script": "return 1;" },
+    { "type": "script", "name": "步骤2", "script": "return 2;" }
+  ]
 }
 ```
 
+## sessionId 传递
+
+工作流执行时会自动获取当前 sessionId，所有 tool 调用都会使用该 sessionId，确保通知发送到当前会话。
+
 ## 完整示例
 
-### 示例：用户问候与天气查询工作流
+### 示例：获取IP并发送通知
 
 ```json
 {
-  "name": "greet-and-query-weather",
-  "description": "问候用户并查询天气",
+  "name": "get-ip-notify",
+  "description": "获取本机IP并发送通知",
   "steps": [
     {
-      "type": "script",
-      "name": "获取用户名",
-      "outputVariable": "username",
-      "script": "context.variables.username = context.input.username || '用户'; return context.variables.username;"
+      "type": "tool",
+      "name": "获取IP信息",
+      "tool": "fetch",
+      "args": {
+        "url": "https://api.ipify.org?format=json",
+        "proxy": true
+      },
+      "outputVariable": "ipResult"
     },
     {
       "type": "script",
-      "name": "生成问候语",
-      "outputVariable": "greeting",
-      "script": "return '你好，' + context.variables.username + '！';"
+      "name": "提取IP",
+      "outputVariable": "currentIp",
+      "script": "var r=context.variables.ipResult; return (r&&r.success&&r.body)?(typeof r.body==='object'?r.body.ip:r.body.trim()):'获取失败';"
     },
     {
-      "type": "condition",
-      "name": "检查是否查询天气",
-      "branches": [
-        {
-          "name": "需要查询天气",
-          "condition": "context.input.queryWeather === true",
-          "steps": [
-            {
-              "type": "script",
-              "name": "模拟天气查询",
-              "outputVariable": "weather",
-              "script": "return '今天天气晴，温度 25°C';"
-            }
-          ]
-        },
-        {
-          "name": "不需要查询天气",
-          "condition": "true",
-          "steps": [
-            {
-              "type": "script",
-              "name": "跳过天气",
-              "outputVariable": "weather",
-              "script": "return '好的，有需要随时叫我！';"
-            }
-          ]
-        }
-      ]
+      "type": "tool",
+      "name": "发送通知",
+      "tool": "notification_send",
+      "args": {
+        "title": "IP 信息",
+        "message": "当前公网IP: {{currentIp}}"
+      }
     }
   ]
 }
 ```
 
-调用：
-
-```json
-{
-  "tool": "execute_workflow",
-  "args": {
-    "workflow": "<上面 JSON 转字符串>",
-    "input": { "username": "张三", "queryWeather": true }
-  }
-}
-```
-
 ### 示例：循环处理任务列表
 
 ```json
@@ -225,7 +260,7 @@ allowed-tools: Read, Write, Edit, Glob, Grep, Bash, execute_workflow, reloadWork
       "type": "script",
       "name": "初始化列表",
       "outputVariable": "items",
-      "script": "context.variables.items = ['任务A', '任务B', '任务C']; return context.variables.items;"
+      "script": "context.variables.items=['任务A','任务B','任务C']; return context.variables.items;"
     },
     {
       "type": "loop",
@@ -237,7 +272,7 @@ allowed-tools: Read, Write, Edit, Glob, Grep, Bash, execute_workflow, reloadWork
           "type": "script",
           "name": "处理任务",
           "outputVariable": "processed",
-          "script": "const item = context.variables.items[context.variables.i]; context.variables.processed = (context.variables.processed || []); context.variables.processed.push(item + '_完成'); return item;"
+          "script": "var item=context.variables.items[context.variables.i]; context.variables.processed=(context.variables.processed||[]); context.variables.processed.push(item+'_完成'); return item;"
         }
       ]
     }
@@ -247,12 +282,13 @@ allowed-tools: Read, Write, Edit, Glob, Grep, Bash, execute_workflow, reloadWork
 
 ## 注意事项
 
-1. **context.variables** 在所有步骤间共享，可存储中间结果
-2. **context.input** 是工作流的输入参数
-3. **context.stepResults** 包含前面各步骤的输出
-4. 脚本中使用 `return` 值会传递给下一步
-5. 循环变量 `i` 从 0 开始计数
-6. 条件分支的 `condition` 是 JavaScript 表达式字符串
+1. **script 必须 return**：`script` 是函数体，必须用 return 返回值
+2. **JSON 中 script 单行写**：用分号分隔多个语句，不要换行
+3. **JSON 中不能有注释**：注释会导致 JSON 解析失败
+4. **context.variables** 在所有步骤间共享，可存储中间结果
+5. **context.input** 是工作流的输入参数
+6. 循环变量 `i` 从 0 开始计数
+7. 条件分支的 `condition` 是 JavaScript 表达式字符串
 
 ## 最佳实践
 
@@ -261,3 +297,33 @@ allowed-tools: Read, Write, Edit, Glob, Grep, Bash, execute_workflow, reloadWork
 3. 循环前确保有合理的 `maxIterations` 限制
 4. 条件分支要有兜底的 `condition: "true"` 分支
 5. 复杂的业务逻辑优先使用脚本步骤
+6. **script 必须 return**：`script` 是函数体，必须用 return 返回值
+7. **JSON 中 script 单行写**：用分号分隔多个语句，不要换行
+
+**错误示例**：
+```json
+// ❌ 错误 - script 没有 return
+{ "type": "script", "script": "context.variables.count + 1;" }
+
+// ❌ 错误 - JSON 多行字符串
+{
+  "script": "
+    const a = 10;
+    return a + 1;
+  "
+}
+
+// ❌ 错误 - JSON 中有注释
+{
+  "script": "return 1; // 这是注释"
+}
+```
+
+**正确示例**：
+```json
+// ✅ 正确
+{ "type": "script", "outputVariable": "count", "script": "return (context.variables.count||0) + 1;" }
+
+// ✅ 正确 - 复杂逻辑拆成多步
+{ "type": "script", "script": "context.variables.a=10; context.variables.b=20; return context.variables.a+context.variables.b;" }
+```

package/src/capabilities/workflow-engine.js

@@ -20,6 +20,7 @@ const StepType = {
   SEQUENTIAL: 'sequential',
   LOOP: 'loop',
   DELAY: 'delay',
+  TOOL: 'tool',
   INPUT: 'input',
   OUTPUT: 'output'
 }
@@ -244,6 +245,112 @@ class DelayStep extends WorkflowStep {
   }
 }
 
+/**
+ * 工具步骤
+ */
+class ToolStep extends WorkflowStep {
+  constructor(config) {
+    super({ ...config, type: StepType.TOOL })
+    this.tool = config.tool
+    this.args = config.args || {}
+    this.outputVariable = config.outputVariable || null
+  }
+
+  async execute(context, engine) {
+    if (!this.tool) {
+      throw new Error('Tool step requires a tool name')
+    }
+
+    console.log(`[Workflow] Executing tool: ${this.tool}`)
+
+    // 解析工具参数，支持变量引用
+    const resolvedArgs = this._resolveArgs(this.args, context)
+
+    // 获取当前 sessionId（从上下文变量或执行上下文）
+    let sessionId = context.variables._sessionId
+    if (!sessionId && engine.framework.getExecutionContext) {
+      const ctx = engine.framework.getExecutionContext()
+      sessionId = ctx?.sessionId
+    }
+
+    // 使用 sessionId 上下文执行工具
+    let result
+    if (sessionId && engine.framework.runWithContext) {
+      result = await engine.framework.runWithContext(
+        { sessionId },
+        async () => await engine.framework.executeTool(this.tool, resolvedArgs)
+      )
+    } else {
+      result = await engine.framework.executeTool(this.tool, resolvedArgs)
+    }
+
+    // 保存结果到变量
+    if (this.outputVariable) {
+      context.variables[this.outputVariable] = result
+    }
+    context.lastResult = result
+
+    // 检查工具执行结果
+    if (result && result.error) {
+      console.warn(`[Workflow] Tool ${this.tool} returned error: ${result.error}`)
+    }
+
+    return result
+  }
+
+  /**
+   * 解析参数中的变量引用
+   * 支持 {{variableName}} 语法
+   */
+  _resolveArgs(args, context) {
+    const resolved = {}
+    for (const [key, value] of Object.entries(args)) {
+      resolved[key] = this._resolveValue(value, context)
+    }
+    return resolved
+  }
+
+  _resolveValue(value, context) {
+    if (typeof value === 'string') {
+      // 替换 {{variable}} 或 {{variables.name}} 语法
+      return value.replace(/\{\{(\w+(?:\.\w+)*)\}\}/g, (match, path) => {
+        // 支持 variables.xxx 或直接 xxx 格式
+        if (path.startsWith('variables.')) {
+          return this._getNestedValue(context, path) ?? match
+        } else if (path.startsWith('context.')) {
+          return this._getNestedValue(context, path) ?? match
+        } else {
+          // 尝试从 context.variables 获取
+          const val = this._getNestedValue(context.variables, path)
+          if (val !== undefined) return val
+          // 尝试从 context 直接获取
+          return this._getNestedValue(context, path) ?? match
+        }
+      })
+    } else if (Array.isArray(value)) {
+      return value.map(v => this._resolveValue(v, context))
+    } else if (typeof value === 'object' && value !== null) {
+      const resolved = {}
+      for (const [k, v] of Object.entries(value)) {
+        resolved[k] = this._resolveValue(v, context)
+      }
+      return resolved
+    }
+    return value
+  }
+
+  _getNestedValue(obj, path) {
+    if (!obj) return undefined
+    const parts = path.split('.')
+    let current = obj
+    for (const part of parts) {
+      if (current === null || current === undefined) return undefined
+      current = current[part]
+    }
+    return current
+  }
+}
+
 /**
  * 工作流引擎
  */
@@ -316,6 +423,7 @@ class WorkflowPlugin extends Plugin {
     this._engine.registerStepType(StepType.SEQUENTIAL, SequentialStep)
     this._engine.registerStepType(StepType.LOOP, LoopStep)
     this._engine.registerStepType(StepType.DELAY, DelayStep)
+    this._engine.registerStepType(StepType.TOOL, ToolStep)
 
     // 注册工作流执行工具
     framework.registerTool({
@@ -325,8 +433,14 @@ class WorkflowPlugin extends Plugin {
         workflow: z.string().describe('工作流定义（JSON 或 JavaScript 代码）'),
         input: z.object({}).optional().describe('工作流输入参数')
       }),
-      execute: async (args) => {
-        return await this.executeWorkflow(args.workflow, args.input || {})
+      execute: async (args, framework) => {
+        // 获取当前 sessionId
+        let sessionId = null
+        const ctx = framework.getExecutionContext()
+        if (ctx?.sessionId) {
+          sessionId = ctx.sessionId
+        }
+        return await this.executeWorkflow(args.workflow, args.input || {}, sessionId)
       }
     })
 
@@ -455,18 +569,24 @@ class WorkflowPlugin extends Plugin {
   /**
    * 执行工作流
    */
-  async executeWorkflow(workflowDef, input = {}) {
+  async executeWorkflow(workflowDef, input = {}, sessionId = null) {
     try {
       let workflow
 
       if (typeof workflowDef === 'string') {
-        // 尝试解析 JSON 或执行代码
-        try {
-          workflow = JSON.parse(workflowDef)
-        } catch {
-          // eslint-disable-next-line no-new-func
-          const fn = new Function('engine', 'return (' + workflowDef + ')')
-          workflow = fn(this._engine)
+        // 尝试作为工作流名称加载（先检查是否已加载的工作流）
+        const workflowName = workflowDef.trim()
+        if (this._workflows.has(workflowName)) {
+          workflow = this._workflows.get(workflowName)
+        } else {
+          // 尝试解析 JSON 或执行代码
+          try {
+            workflow = JSON.parse(workflowDef)
+          } catch {
+            // eslint-disable-next-line no-new-func
+            const fn = new Function('engine', 'return (' + workflowDef + ')')
+            workflow = fn(this._engine)
+          }
         }
       } else {
         workflow = workflowDef
@@ -474,6 +594,11 @@ class WorkflowPlugin extends Plugin {
 
       const context = this._engine.createContext(input, {})
 
+      // 将 sessionId 存储到上下文变量，供工具步骤使用
+      if (sessionId) {
+        context.variables._sessionId = sessionId
+      }
+
       // 执行工作流步骤
       if (workflow.steps && Array.isArray(workflow.steps)) {
         const results = []
@@ -513,5 +638,6 @@ module.exports = {
   ConditionStep,
   SequentialStep,
   LoopStep,
-  DelayStep
+  DelayStep,
+  ToolStep
 }

package/src/core/agent.js

@@ -29,7 +29,7 @@ class Agent extends EventEmitter {
     this.baseURL = config.baseURL
     this.provider = config.provider || 'deepseek'
     this.providerOptions = config.providerOptions || {}
-
+    this.providerOptions.maxOutputTokens=8192
     // 原始 system prompt
     this._originalPrompt = config.systemPrompt || '你是一个智能助手。当用户提出问题或任务时，你会主动分析需求，选择合适的工具来获取信息或执行操作。你善于将复杂任务拆解为多个步骤，通过工具协作完成。'
 

package/src/core/framework.js

@@ -215,7 +215,7 @@ class Framework extends EventEmitter {
       name: `session_${sessionId}`,
       ...config
     }
-
+    
     // 如果没有提供 AI 相关参数，从 AI 插件获取
     if (!agentConfig.apiKey) {
       const aiPlugin = this.pluginManager.get('ai')
@@ -223,10 +223,10 @@ class Framework extends EventEmitter {
         agentConfig.apiKey = aiPlugin.config.apiKey
         agentConfig.provider = agentConfig.provider || aiPlugin.config.provider
         agentConfig.model = agentConfig.model || aiPlugin.config.model
-        agentConfig.baseURL = agentConfig.baseURL || aiPlugin.config.baseURL
+        agentConfig.baseURL = agentConfig.baseURL || aiPlugin.config.baseURL,
+        agentConfig.providerOptions||aiPlugin.config.providerOptions||{}
       }
     }
-
     const agent = new Agent(this, agentConfig)
     this._agents.push(agent)