foliko 2.0.21 → 2.0.23

package/src/agent/tool-loop.js

@@ -0,0 +1,648 @@
+'use strict';
+
+/**
+ * ToolLoop — 自实现的工具调用循环
+ * 替代 AI SDK 的 ToolLoopAgent，完全本地可控
+ *
+ * 职责：
+ * - 管理 messages → LLM → tool_call → execute → tool_result → LLM 循环
+ * - 支持流式和非流式
+ * - 支持 prepareStep 回调（压缩、sanitize）
+ * - 支持中断信号
+ */
+
+const { EventEmitter } = require('../common/events');
+const { logger } = require('../common/logger');
+const log = logger.child('ToolLoop');
+
+class ToolLoop extends EventEmitter {
+  constructor(config = {}) {
+    super();
+    this.tools = config.tools || {};          // { name => { execute, description } }
+    this.maxSteps = config.maxSteps || 100000;
+    this.prepareStep = config.prepareStep || (async () => {});
+    this.abortSignal = config.abortSignal || null;
+    this._repairFn = config.repairToolCall || null;
+    this._thinkingMode = config.thinkingMode === true;
+  }
+
+  _checkAbort() {
+    if (this.abortSignal?.aborted) throw new Error('AbortError');
+  }
+
+  /**
+   * 提取 DeepSeek thinking 配置，清理 AI SDK 残留字段
+   */
+  _prepareApiOptions(options) {
+    const apiOptions = { ...options };
+    if (apiOptions.deepseek?.thinking) {
+      apiOptions.thinking = apiOptions.deepseek.thinking;
+    }
+    delete apiOptions.deepseek;
+    delete apiOptions.providerOptions;
+    return apiOptions;
+  }
+
+  /**
+   * 执行工具调用循环
+   * @param {Array} toolCalls - 工具调用列表
+   * @param {Array} messages - 消息数组（会被修改）
+   * @param {Object} opts - { yieldEvents: boolean }
+   */
+  async *_executeToolCalls(toolCalls, messages, { yieldEvents = false } = {}) {
+    for (const tc of toolCalls) {
+      this._checkAbort();
+      const toolName = tc.function.name;
+      const tool = this.tools[toolName];
+      if (!tool) {
+        const errMsg = '工具不存在: ' + toolName;
+        this._addToolResult(messages, tc.id, toolName, null, errMsg);
+        if (yieldEvents) yield { type: 'error', error: errMsg };
+        continue;
+      }
+
+      let args;
+      try {
+        args = JSON.parse(tc.function.arguments);
+      } catch (parseErr) {
+        try {
+          args = this._repairArgs(toolName, tc.function.arguments, parseErr);
+        } catch {
+          const errMsg = '参数解析失败: ' + parseErr.message;
+          this._addToolResult(messages, tc.id, toolName, null, errMsg);
+          if (yieldEvents) yield { type: 'error', error: errMsg };
+          continue;
+        }
+      }
+
+      if (yieldEvents) yield { type: 'tool-call', toolName, input: args };
+      this.emit('tool-call', { name: toolName, args });
+      try {
+        const result = await tool.execute(args);
+        this.emit('tool-result', { name: toolName, args, result });
+        this._addToolResult(messages, tc.id, toolName, result);
+        if (yieldEvents) yield { type: 'tool-result', toolName, result };
+      } catch (err) {
+        this.emit('tool-error', { name: toolName, args, error: err.message });
+        this._addToolResult(messages, tc.id, toolName, null, err.message);
+        if (yieldEvents) yield { type: 'error', error: err.message };
+      }
+    }
+  }
+
+  /**
+   * 处理流式响应块
+   * @returns {Object} { finishReason, hasContent, hasReasoning, hasToolCalls, error }
+   */
+  _processStreamingChunk(chunk, toolCallAccum, state) {
+    const result = { finishReason: null, hasContent: false, hasReasoning: false, hasToolCalls: false, error: null };
+
+    if (chunk.usage) {
+      state.totalUsage = {
+        promptTokens: chunk.usage.prompt_tokens || 0,
+        completionTokens: chunk.usage.completion_tokens || 0,
+      };
+    }
+
+    const delta = chunk.choices?.[0]?.delta;
+    const choice = chunk.choices?.[0];
+
+    if (choice?.finish_reason) {
+      result.finishReason = choice.finish_reason;
+    }
+
+    if (chunk.error) {
+      result.error = chunk.error.message || '流式错误';
+      return result;
+    }
+
+    if (!delta) return result;
+
+    // Reasoning content
+    if (delta.reasoning_content || delta.reasoning) {
+      result.hasReasoning = true;
+      const text = delta.reasoning_content || delta.reasoning || '';
+      state.fullReasoning += text;
+    }
+
+    // Text delta
+    if (delta.content) {
+      result.hasContent = true;
+      state.fullText += delta.content;
+    }
+
+    // Tool calls delta
+    if (delta.tool_calls) {
+      result.hasToolCalls = true;
+      for (const tc of delta.tool_calls) {
+        const idx = tc.index;
+        if (!toolCallAccum[idx]) {
+          toolCallAccum[idx] = {
+            id: tc.id || '',
+            type: 'function',
+            function: { name: '', arguments: '' },
+          };
+        }
+        if (tc.id) toolCallAccum[idx].id = tc.id;
+        if (tc.function?.name) toolCallAccum[idx].function.name += tc.function.name;
+        if (tc.function?.arguments) toolCallAccum[idx].function.arguments += tc.function.arguments;
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * 修复工具参数 JSON
+   * 当 LLM 返回的 JSON 无法解析时尝试修复
+   */
+  _repairArgs(toolName, argsStr, error) {
+    if (this._repairFn) {
+      const repaired = this._repairFn({ toolCall: { toolName, input: argsStr }, error });
+      if (repaired && repaired.input) {
+        return typeof repaired.input === 'string' ? JSON.parse(repaired.input) : repaired.input;
+      }
+    }
+    // 基础修复
+    const trimmed = (argsStr || '').trim();
+    if (trimmed === '') return {};
+    if (!trimmed.startsWith('{')) {
+      try { return JSON.parse('{' + trimmed + '}'); } catch { /* ignore */ }
+    }
+    if (trimmed.endsWith('}') || !trimmed.includes('}')) {
+      try { return JSON.parse(trimmed + '}'); } catch { /* ignore */ }
+    }
+    throw error;
+  }
+
+  /**
+   * 构建 OpenAI API 格式的 messages 数组
+   * 从内部格式（AI SDK ModelMessage）转换
+   */
+  _buildApiMessages(messages, systemPrompt) {
+    const api = [];
+    if (systemPrompt) api.push({ role: 'system', content: systemPrompt });
+
+    for (const msg of messages) {
+      if (msg.role === 'system') {
+        api.push({ role: 'system', content: typeof msg.content === 'string' ? msg.content : '' });
+      } else if (msg.role === 'user') {
+        if (typeof msg.content === 'string') {
+          api.push({ role: 'user', content: msg.content });
+        } else if (Array.isArray(msg.content)) {
+          const text = msg.content.filter(p => p && p.type === 'text').map(p => p.text).join('');
+          api.push({ role: 'user', content: text || '' });
+        }
+      } else if (msg.role === 'assistant') {
+        // ★ 检测是否有 reasoning 内容（thinking mode 必须携带）
+        const hasReasoningInContent = Array.isArray(msg.content) && msg.content.some(p => p && p.type === 'reasoning');
+        const hasReasoningTopLevel = msg.reasoning_content || msg.reasoning;
+
+        if (typeof msg.content === 'string') {
+          if (msg.tool_calls && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0) {
+            // thinking mode 下，无 reasoning 则自动补 placeholder
+            const reasonVal = hasReasoningTopLevel || (this._thinkingMode ? '...' : '');
+            api.push({ role: 'assistant', content: msg.content || null, tool_calls: msg.tool_calls, ...(reasonVal ? { reasoning_content: reasonVal } : {}) });
+          } else {
+            api.push({ role: 'assistant', content: msg.content });
+          }
+        } else if (Array.isArray(msg.content)) {
+          let text = '';
+          const toolCalls = [];
+          for (const part of msg.content) {
+            if (!part) continue;
+            if (part.type === 'text') text += part.text;
+            else if (part.type === 'tool-call' || part.type === 'tool-use') {
+              toolCalls.push({
+                id: part.toolCallId,
+                type: 'function',
+                function: {
+                  name: part.toolName,
+                  arguments: typeof part.input === 'string' ? part.input : JSON.stringify(part.input ?? {}),
+                },
+              });
+            }
+          }
+
+          if (toolCalls.length > 0) {
+            const reasonVal = hasReasoningTopLevel || (this._thinkingMode ? '...' : '');
+            api.push({ role: 'assistant', content: text || null, tool_calls: toolCalls, ...(reasonVal ? { reasoning_content: reasonVal } : {}) });
+          } else {
+            api.push({ role: 'assistant', content: text });
+          }
+        } else {
+          api.push({ role: 'assistant', content: String(msg.content ?? '') });
+        }
+      } else if (msg.role === 'tool') {
+        if (Array.isArray(msg.content)) {
+          for (const part of msg.content) {
+            if (!part || (part.type !== 'tool-result' && part.type !== 'tool_result')) continue;
+            const output = part.output;
+            let content;
+            if (output?.type === 'text') content = output.value;
+            else if (output?.type === 'json') content = JSON.stringify(output.value);
+            else content = typeof output === 'string' ? output : JSON.stringify(output);
+            api.push({ role: 'tool', tool_call_id: part.toolCallId, content });
+          }
+        } else if (msg.tool_call_id && typeof msg.content === 'string') {
+          // 已经是 OpenAI 格式（streaming 完成后的消息）
+          api.push(msg);
+        }
+      }
+    }
+    return api;
+  }
+
+  /**
+   * 构建 OpenAI API 格式的 tools 数组
+   * 从内部的 tools map 转换
+   */
+  _buildApiTools(tools) {
+    if (!tools || Object.keys(tools).length === 0) return undefined;
+    return Object.values(tools).map(t => {
+      const paramSchema = t.parameters || t.inputSchema;
+      // ★ 确保 schema 是纯 JSON Schema 对象（不是 zod 实例）
+      //   OpenAI API 要求 tools 的 parameters 必须是 {type: 'object', ...}
+      //   zod 实例的 JSON 序列化物没有 type: 'object'，API 会抛 400
+      const jsonSchema = this._toJsonSchema(paramSchema);
+      return {
+        type: 'function',
+        function: {
+          name: t.name,
+          description: t.description || '',
+          parameters: jsonSchema,
+        },
+      };
+    });
+  }
+
+  /**
+   * 将 zod schema 或任意 schema 转为纯 JSON Schema 对象
+   * 递归处理所有嵌套类型（ZodArray → {type:'array', items} 等）
+   * 确保 OpenAI API 能正确识别参数结构
+   */
+  _toJsonSchema(schema) {
+    if (!schema) return { type: 'object', properties: {} };
+    if (schema.properties) return schema; // 已经是 JSON Schema
+    if (typeof schema.safeParse !== 'function') return { type: 'object', properties: {} };
+    return this._zodToJson(schema);
+  }
+
+  /**
+   * 递归转换 zod 实例为 JSON Schema
+   */
+  _zodToJson(zod) {
+    if (!zod || !zod._def) return {};
+    const def = zod._def;
+    const tn = def.typeName || '';
+
+    // 先解包包装类型
+    if (tn === 'ZodOptional') {
+      const inner = this._zodToJson(def.innerType);
+      return inner;
+    }
+    if (tn === 'ZodDefault') {
+      const inner = this._zodToJson(def.innerType);
+      if (def.defaultValue !== undefined) inner.default = def.defaultValue;
+      return inner;
+    }
+    if (tn === 'ZodNullable') {
+      const inner = this._zodToJson(def.innerType);
+      inner.type = [inner.type, 'null'];
+      return inner;
+    }
+    if (tn === 'ZodBranded') return this._zodToJson(def.type);
+    if (tn === 'ZodEffects') return this._zodToJson(def.schema || def.innerType);
+    if (tn === 'ZodReadonly') return this._zodToJson(def.innerType);
+
+    // 基本类型
+    if (tn === 'ZodString') {
+      const r = { type: 'string' };
+      if (def.description) r.description = def.description;
+      return r;
+    }
+    if (tn === 'ZodNumber' || tn === 'ZodInt' || tn === 'ZodBigInt') {
+      const r = { type: 'number' };
+      if (def.description) r.description = def.description;
+      return r;
+    }
+    if (tn === 'ZodBoolean') {
+      const r = { type: 'boolean' };
+      if (def.description) r.description = def.description;
+      return r;
+    }
+    if (tn === 'ZodNull') return { type: 'null' };
+    if (tn === 'ZodAny' || tn === 'ZodUnknown') return {};
+
+    // 枚举
+    if (tn === 'ZodEnum' || tn === 'ZodNativeEnum') {
+      return { type: 'string', enum: def.values || Object.values(def.values || {}), description: def.description };
+    }
+
+    // 数组
+    if (tn === 'ZodArray') {
+      const r = { type: 'array', items: this._zodToJson(def.type) };
+      if (def.description) r.description = def.description;
+      if (def.minLength) r.minItems = def.minLength.value;
+      if (def.maxLength) r.maxItems = def.maxLength.value;
+      return r;
+    }
+
+    // 对象
+    if (tn === 'ZodObject') {
+      const shape = typeof def.shape === 'function' ? def.shape() : def.shape;
+      if (!shape) return { type: 'object' };
+      const properties = {};
+      const required = [];
+      for (const [key, field] of Object.entries(shape)) {
+        properties[key] = this._zodToJson(field);
+        // 判断必填：没有 isOptional 方法 或 isOptional() 返回 false
+        if (typeof field.isOptional !== 'function' || !field.isOptional()) {
+          required.push(key);
+        }
+      }
+      return { type: 'object', properties, required: required.length > 0 ? required : undefined, description: def.description };
+    }
+
+    // 联合
+    if (tn === 'ZodUnion') {
+      const options = def.options?.map(o => this._zodToJson(o)) || [];
+      return { anyOf: options, description: def.description };
+    }
+    if (tn === 'ZodDiscriminatedUnion') {
+      const options = Object.values(def.optionsMap || {}).map(o => this._zodToJson(o));
+      return { anyOf: options, description: def.description };
+    }
+
+    // 记录
+    if (tn === 'ZodRecord') {
+      return { type: 'object', additionalProperties: this._zodToJson(def.valueType), description: def.description };
+    }
+
+    // 元组
+    if (tn === 'ZodTuple') {
+      const items = (def.items || []).map(item => this._zodToJson(item));
+      return { type: 'array', items, description: def.description };
+    }
+
+    // 函数（OpenAI 不支持函数参数 schema，返回空对象）
+    if (tn === 'ZodFunction') {
+      return {};
+    }
+
+    // Map
+    if (tn === 'ZodMap') {
+      return { type: 'object', additionalProperties: this._zodToJson(def.valueType), description: def.description };
+    }
+
+    // Literal
+    if (tn === 'ZodLiteral') {
+      const val = def.value;
+      if (typeof val === 'string') return { type: 'string', const: val };
+      if (typeof val === 'number') return { type: 'number', const: val };
+      if (typeof val === 'boolean') return { type: 'boolean', const: val };
+      return {};
+    }
+
+    // 兜底
+    return { description: def.description };
+  }
+
+  /**
+   * 以内部格式添加 tool result 到 messages
+   * 使用 { type: 'tool-result' } part 格式（兼容 sanitizeForLLM / validateAll）
+   */
+  _addToolResult(messages, toolCallId, toolName, content, error) {
+    const output = error
+      ? { type: 'text', value: JSON.stringify({ error }) }
+      : { type: 'text', value: typeof content === 'string' ? content : JSON.stringify(content) };
+    messages.push({
+      role: 'tool',
+      content: [{ type: 'tool-result', toolCallId, toolName, output }],
+    });
+  }
+
+  /**
+   * 非流式生成
+   * @returns {{ text, response: { messages }, steps, usage, reasoningText }}
+   */
+  async generate({ messages, systemPrompt, model, client, ...options }) {
+    this._checkAbort();
+    let step = 0;
+    let fullText = '';
+    let fullReasoning = '';
+    let totalUsage = null;
+
+    while (step < this.maxSteps) {
+      this._checkAbort();
+
+      // 1. 准备步骤（压缩、sanitize）
+      if (this.prepareStep) {
+        await this.prepareStep({ stepNumber: step, messages });
+      }
+
+      // 2. 构建 API 请求
+      const apiMessages = this._buildApiMessages(messages, systemPrompt);
+      const apiTools = this._buildApiTools(this.tools);
+      const apiOptions = this._prepareApiOptions(options);
+
+      let response;
+      try {
+        response = await client.chat.completions.create({
+          model,
+          messages: apiMessages,
+          tools: apiTools,
+          ...apiOptions,
+          stream: false,
+        });
+      } catch (apiErr) {
+        log.error(`[ToolLoop] API call failed: ${apiErr.message}`);
+        const recent = apiMessages.slice(-3).map(m => ({
+          role: m.role, hasTc: !!(m.tool_calls?.length), hasReason: !!m.reasoning_content,
+        }));
+        log.error(`[ToolLoop] last msgs: ${JSON.stringify(recent)}`);
+        throw apiErr;
+      }
+
+      // 3. 解析响应
+      const choice = response.choices?.[0];
+      if (!choice) throw new Error('API 响应没有 choices');
+      const message = choice.message;
+
+      // 跟踪用量
+      if (response.usage) {
+        totalUsage = {
+          promptTokens: response.usage.prompt_tokens || 0,
+          completionTokens: response.usage.completion_tokens || 0,
+        };
+      }
+
+      // 收集 reasoning
+      const reasoningContent = message.reasoning_content || message.reasoning || '';
+      if (reasoningContent) fullReasoning += reasoningContent;
+
+      // 4. 处理工具调用
+      if (choice.finish_reason === 'tool_calls' && message.tool_calls && message.tool_calls.length > 0) {
+        // 插入 assistant 消息（保留原格式，后面的 _processMessage 会存盘）
+        const assistantMsg = {
+          role: 'assistant',
+          content: message.content || '',
+        };
+        if (message.tool_calls.length > 0) {
+          assistantMsg.tool_calls = message.tool_calls;
+        }
+        // ★ 保存 reasoning_content（下次 API 调用时需要传回）
+        if (reasoningContent) {
+          assistantMsg.reasoning_content = reasoningContent;
+        }
+        messages.push(assistantMsg);
+
+        // 执行工具
+        for await (const _ of this._executeToolCalls(message.tool_calls, messages)) {
+          // 非流式模式，不 yield 事件
+        }
+        step++;
+      } else {
+        // 没有工具调用 → 完成
+        fullText = message.content || '';
+        break;
+      }
+    }
+
+    return {
+      text: fullText,
+      response: { messages },
+      steps: step,
+      usage: totalUsage,
+      reasoningText: fullReasoning || undefined,
+    };
+  }
+
+  /**
+   * 流式生成
+   * yield { type: 'text-delta'|'thinking'|'tool-call'|'tool-result'|'usage'|'error', ... }
+   * 最终通过 result.response.messages 拿完整消息列表
+   */
+  async *stream({ messages, systemPrompt, model, client, ...options }) {
+    this._checkAbort();
+    let step = 0;
+    let fullText = '';
+    let fullReasoning = '';
+    let totalUsage = null;
+
+    while (step < this.maxSteps) {
+      this._checkAbort();
+
+      // 1. 准备步骤
+      if (this.prepareStep) {
+        await this.prepareStep({ stepNumber: step, messages });
+      }
+
+      // 2. 构建请求
+      const apiMessages = this._buildApiMessages(messages, systemPrompt);
+      const apiTools = this._buildApiTools(this.tools);
+      const apiOptions = this._prepareApiOptions(options);
+
+      let stream;
+      try {
+        stream = await client.chat.completions.create({
+          model,
+          messages: apiMessages,
+          tools: apiTools,
+          ...apiOptions,
+          stream: true,
+          stream_options: { include_usage: true },
+        });
+      } catch (apiErr) {
+        log.error(`[ToolLoop] stream call failed: ${apiErr.message}`);
+        log.error(`[ToolLoop] model=${model} msgs=${apiMessages.length}`);
+        const recent = apiMessages.slice(-3).map(m => ({
+          role: m.role, hasTc: !!(m.tool_calls?.length), hasReason: !!m.reasoning_content,
+        }));
+        log.error(`[ToolLoop] last msgs: ${JSON.stringify(recent)}`);
+        throw apiErr;
+      }
+
+      // 3. 处理流式响应（累计 tool_calls delta）
+      const toolCallAccum = {};
+      let finishReason = null;
+      const state = { fullText: '', fullReasoning: '', totalUsage: null };
+
+      for await (const chunk of stream) {
+        this._checkAbort();
+
+        const result = this._processStreamingChunk(chunk, toolCallAccum, state);
+
+        if (result.error) {
+          yield { type: 'error', error: result.error };
+          continue;
+        }
+
+        // 追踪 finish_reason
+        if (result.finishReason) {
+          finishReason = result.finishReason;
+        }
+
+        // Reasoning content
+        if (result.hasReasoning) {
+          yield { type: 'thinking', text: state.fullReasoning.slice(fullReasoning.length) };
+        }
+
+        // Text delta
+        if (result.hasContent) {
+          const textStart = fullText.length;
+          fullText += state.fullText.slice(textStart);
+          yield { type: 'text-delta', text: state.fullText.slice(textStart) };
+        }
+
+        // Tool calls delta
+        if (result.hasToolCalls) {
+          // toolCallAccum 已通过 _processStreamingChunk 更新，无需额外操作
+        }
+      }
+
+      // 同步状态
+      totalUsage = state.totalUsage;
+      fullReasoning = state.fullReasoning;
+
+      const toolCalls = Object.values(toolCallAccum).filter(tc => tc.id);
+
+      if (finishReason === 'tool_calls' && toolCalls.length > 0) {
+        // 插入 assistant 消息（含 tool_calls）
+        const assistantMsg = { role: 'assistant', content: fullText || '', tool_calls: toolCalls };
+        // ★ 保存 reasoning_content（下次 API 调用时需要传回）
+        if (fullReasoning) assistantMsg.reasoning_content = fullReasoning;
+        messages.push(assistantMsg);
+        fullText = '';
+        fullReasoning = '';  // ★ 重置，下轮单独收集
+
+        // 执行工具
+        for await (const event of this._executeToolCalls(toolCalls, messages, { yieldEvents: true })) {
+          yield event;
+        }
+        step++;
+      } else {
+        // 无工具调用 → 完成（与 generate() 保持一致：确保 fullText 有值）
+        fullText = state.fullText || fullText;
+        break;
+      }
+    }
+
+    // 输出用量
+    yield {
+      type: 'usage',
+      inputTokens: totalUsage?.promptTokens || 0,
+      outputTokens: totalUsage?.completionTokens || 0,
+    };
+
+    return {
+      text: fullText,
+      response: { messages },
+      steps: step,
+      usage: totalUsage,
+      reasoningText: fullReasoning || undefined,
+    };
+  }
+}
+
+module.exports = { ToolLoop };