@faapi/agent 5.4.0 → 6.1.0

package/dist/index.js

@@ -30,10 +30,12 @@ function createOpenAIProvider(config) {
     const modelConfig = modelName ? config.models[modelName] : void 0;
     const body = {
       model: modelName,
-      messages: request.messages.map(toOpenAIMessage)
+      // 规范形即 OpenAI 形状：messages 恒等透传（剥离框架扩展字段 reasoning_content，
+      // 推理内容是解析产物不回传——DeepSeek 多轮回传直接 400，OpenAI 等拒绝未知字段）
+      messages: stripReasoningFromMessages(request.messages)
     };
     if (request.tools && request.tools.length > 0) {
-      body.tools = request.tools.map(toOpenAITool);
+      body.tools = request.tools;
     }
     const mergedConfig = {};
     for (const key of Object.keys(config)) {
@@ -182,13 +184,13 @@ function createOpenAIProvider(config) {
       });
     }
     const content = msg.content ?? "";
-    const toolCalls = parseToolCalls(msg.tool_calls, bodyText, response.status);
+    const toolCalls = normalizeToolCalls(msg.tool_calls, bodyText, response.status);
+    const message = { role: "assistant", content };
+    if (toolCalls) message.tool_calls = toolCalls;
+    const reasoning = extractReasoning(msg);
+    if (reasoning) message.reasoning_content = reasoning;
     return {
-      message: {
-        role: "assistant",
-        content,
-        toolCalls
-      },
+      message,
       stopReason: mapStopReason(choice.finish_reason ?? void 0),
       usage: mapUsage(json.usage)
     };
@@ -243,6 +245,10 @@ function createOpenAIProvider(config) {
           }
           const delta = chunk.choices?.[0]?.delta;
           if (delta) {
+            const reasoning = extractReasoning(delta);
+            if (reasoning) {
+              yield { deltaReasoning: reasoning };
+            }
             if (typeof delta.content === "string" && delta.content.length > 0) {
               yield { deltaContent: delta.content };
             }
@@ -271,40 +277,33 @@ function createOpenAIProvider(config) {
   }
   return { complete, stream };
 }
-function toOpenAIMessage(msg) {
-  const out = {
-    role: msg.role,
-    content: msg.content
-  };
-  if (msg.toolCallId !== void 0) out.tool_call_id = msg.toolCallId;
-  if (msg.toolCalls !== void 0 && msg.toolCalls.length > 0) {
-    out.tool_calls = msg.toolCalls.map((tc) => ({
-      id: tc.id,
-      type: "function",
-      function: { name: tc.name, arguments: JSON.stringify(tc.arguments) }
-    }));
+function extractReasoning(source) {
+  if (typeof source.reasoning_content === "string" && source.reasoning_content.length > 0) {
+    return source.reasoning_content;
   }
-  return out;
+  if (typeof source.reasoning === "string" && source.reasoning.length > 0) {
+    return source.reasoning;
+  }
+  return void 0;
 }
-function toOpenAITool(tool) {
-  return {
-    type: "function",
-    function: {
-      name: tool.name,
-      description: tool.description,
-      parameters: tool.input
-    }
-  };
+function stripReasoningFromMessages(messages) {
+  if (!messages.some((m) => m.reasoning_content !== void 0)) {
+    return messages;
+  }
+  return messages.map((m) => {
+    if (m.reasoning_content === void 0) return m;
+    const { reasoning_content: _stripped, ...rest } = m;
+    return rest;
+  });
 }
-function parseToolCalls(toolCalls, bodyText, status) {
+function normalizeToolCalls(toolCalls, bodyText, status) {
   if (!toolCalls || toolCalls.length === 0) return void 0;
   const result = [];
   for (let i = 0; i < toolCalls.length; i++) {
     const tc = toolCalls[i];
     const argsStr = tc?.function?.arguments ?? "{}";
-    let args;
     try {
-      args = JSON.parse(argsStr);
+      JSON.parse(argsStr);
     } catch {
       const excerpt = argsStr.slice(0, 500);
       throw new LLMProviderError(`Invalid tool arguments JSON: ${excerpt}`, {
@@ -314,8 +313,8 @@ function parseToolCalls(toolCalls, bodyText, status) {
     }
     result.push({
       id: tc?.id ?? `call_${i}`,
-      name: tc?.function?.name ?? "",
-      arguments: args
+      type: "function",
+      function: { name: tc?.function?.name ?? "", arguments: argsStr }
     });
   }
   return result;
@@ -337,9 +336,9 @@ function mapStopReason(fr) {
 function mapUsage(u) {
   if (!u) return void 0;
   return {
-    promptTokens: u.prompt_tokens ?? 0,
-    completionTokens: u.completion_tokens ?? 0,
-    totalTokens: u.total_tokens ?? 0
+    prompt_tokens: u.prompt_tokens ?? 0,
+    completion_tokens: u.completion_tokens ?? 0,
+    total_tokens: u.total_tokens ?? 0
   };
 }
 function extractSSEData(event) {
@@ -394,19 +393,19 @@ function finalizeStreamChunk(accumulators, finishReason, usage) {
     for (const idx of indices) {
       const acc = accumulators.get(idx);
       if (!acc.id || !acc.name) continue;
-      let args;
+      const argsStr = acc.argsString || "{}";
       try {
-        args = acc.argsString ? JSON.parse(acc.argsString) : {};
+        JSON.parse(argsStr);
       } catch {
-        const excerpt = acc.argsString.slice(0, 500);
+        const excerpt = argsStr.slice(0, 500);
         throw new LLMProviderError(`Invalid tool arguments JSON: ${excerpt}`, {
           body: excerpt
         });
       }
       toolCalls.push({
         id: acc.id,
-        name: acc.name,
-        arguments: args
+        type: "function",
+        function: { name: acc.name, arguments: argsStr }
       });
     }
   }
@@ -464,12 +463,17 @@ function stringifyError(err) {
   if (err instanceof Error) return err.message;
   return String(err);
 }
+function stripReasoning(message) {
+  if (message.reasoning_content === void 0) return message;
+  const { reasoning_content: _stripped, ...rest } = message;
+  return rest;
+}
 function accumulateUsage(a, b) {
   if (!a) return { ...b };
   return {
-    promptTokens: a.promptTokens + b.promptTokens,
-    completionTokens: a.completionTokens + b.completionTokens,
-    totalTokens: a.totalTokens + b.totalTokens
+    prompt_tokens: a.prompt_tokens + b.prompt_tokens,
+    completion_tokens: a.completion_tokens + b.completion_tokens,
+    total_tokens: a.total_tokens + b.total_tokens
   };
 }
 function buildInitialMessages(input, systemPrompt) {
@@ -480,9 +484,14 @@ function buildInitialMessages(input, systemPrompt) {
   messages.push({ role: "user", content: input });
   return messages;
 }
+function parseToolCallArguments(toolCall) {
+  const raw = toolCall.function.arguments;
+  if (!raw) return {};
+  return JSON.parse(raw);
+}
 function initLoopMessages(input, config) {
   if (config.messages?.length) {
-    const messages = [...config.messages];
+    const messages = config.messages.map(stripReasoning);
     if (config.systemPrompt && !messages.some((m) => m.role === "system")) {
       messages.unshift({ role: "system", content: config.systemPrompt });
     }
@@ -498,11 +507,11 @@ function estimateTokens(chars) {
 }
 function estimateMessageTokens(message) {
   let chars = message.content.length;
-  if (message.toolCalls) {
-    chars += JSON.stringify(message.toolCalls).length;
+  if (message.tool_calls) {
+    chars += JSON.stringify(message.tool_calls).length;
   }
-  if (message.toolCallId) {
-    chars += message.toolCallId.length;
+  if (message.tool_call_id) {
+    chars += message.tool_call_id.length;
   }
   return estimateTokens(chars);
 }
@@ -555,6 +564,7 @@ async function reactLoop(input, config) {
   const maxTurns = config.maxTurns ?? DEFAULT_MAX_TURNS;
   const extras = buildRequestExtras(config);
   let totalUsage;
+  let finalReasoning;
   let turns = 0;
   const traceStartedAt = enableTracing ? nowMs() : 0;
   const traceEvents = enableTracing ? [] : void 0;
@@ -591,15 +601,18 @@ async function reactLoop(input, config) {
         durationMs: llmEndedAt - llmStartedAt,
         model: config.model ?? "",
         inputMessages: inputSnapshot,
+        // 原始 assistant 消息（含 reasoning_content）——trace 保留完整 LLM 返回，
+        // 与历史剥离策略互补（见 trace.md「llm_call.response 与 thinking」）
         response: response.message,
         stopReason: response.stopReason,
         usage: response.usage
       });
     }
-    messages.push(response.message);
-    if (response.stopReason !== "tool_calls" || !response.message.toolCalls) {
+    finalReasoning = response.message.reasoning_content;
+    messages.push(stripReasoning(response.message));
+    if (response.stopReason !== "tool_calls" || !response.message.tool_calls) {
       const traceEndedAt = enableTracing ? nowMs() : 0;
-      return {
+      const result = {
         content: response.message.content,
         messages,
         turns,
@@ -616,16 +629,23 @@ async function reactLoop(input, config) {
           events: traceEvents
         } : void 0
       };
+      if (finalReasoning !== void 0) {
+        result.reasoning = finalReasoning;
+      }
+      return result;
     }
     const settled = await Promise.all(
-      response.message.toolCalls.map(async (toolCall) => {
+      response.message.tool_calls.map(async (toolCall) => {
         const toolStartedAt = enableTracing ? nowMs() : 0;
+        const toolName = toolCall.function.name;
+        let args = {};
         let resultStr;
         let rawResult;
         let toolErr;
         let hasError = false;
         try {
-          rawResult = await config.executeTool(toolCall.name, toolCall.arguments);
+          args = parseToolCallArguments(toolCall);
+          rawResult = await config.executeTool(toolName, args);
           if (isTracingToolResult(rawResult)) {
             resultStr = stringifyResult(rawResult.result);
           } else {
@@ -640,6 +660,8 @@ async function reactLoop(input, config) {
         const toolEndedAt = enableTracing ? nowMs() : 0;
         return {
           toolCall,
+          toolName,
+          args,
           toolStartedAt,
           toolEndedAt,
           resultStr,
@@ -651,6 +673,8 @@ async function reactLoop(input, config) {
     );
     for (const {
       toolCall,
+      toolName,
+      args,
       toolStartedAt,
       toolEndedAt,
       resultStr,
@@ -666,8 +690,8 @@ async function reactLoop(input, config) {
             startedAt: toolStartedAt,
             durationMs: toolEndedAt - toolStartedAt,
             toolCallId: toolCall.id,
-            agentName: extractSubAgentName(toolCall.name),
-            input: JSON.stringify(toolCall.arguments),
+            agentName: extractSubAgentName(toolName),
+            input: JSON.stringify(args),
             trace: rawResult.trace,
             result: resultStr
           });
@@ -678,8 +702,8 @@ async function reactLoop(input, config) {
             startedAt: toolStartedAt,
             durationMs: toolEndedAt - toolStartedAt,
             toolCallId: toolCall.id,
-            name: toolCall.name,
-            arguments: toolCall.arguments,
+            name: toolName,
+            arguments: args,
             result: resultStr,
             error: hasError ? stringifyError(toolErr) : void 0
           });
@@ -688,7 +712,7 @@ async function reactLoop(input, config) {
       messages.push({
         role: "tool",
         content: resultStr,
-        toolCallId: toolCall.id
+        tool_call_id: toolCall.id
       });
     }
   }
@@ -714,6 +738,7 @@ async function* reactLoopStream(input, config) {
     const outgoing = config.maxHistoryTokens ? trimHistory(messages, config.maxHistoryTokens) : messages;
     const inputSnapshot = enableTracing ? [...outgoing] : void 0;
     let turnContent = "";
+    let turnReasoning = "";
     let toolCalls;
     let finishReason;
     let turnUsage;
@@ -723,6 +748,10 @@ async function* reactLoopStream(input, config) {
         ...extras,
         signal: config.signal
       })) {
+        if (typeof chunk.deltaReasoning === "string" && chunk.deltaReasoning.length > 0) {
+          turnReasoning += chunk.deltaReasoning;
+          yield { deltaReasoning: chunk.deltaReasoning };
+        }
         if (typeof chunk.deltaContent === "string" && chunk.deltaContent.length > 0) {
           turnContent += chunk.deltaContent;
           yield { deltaContent: chunk.deltaContent };
@@ -749,11 +778,12 @@ async function* reactLoopStream(input, config) {
       content: turnContent
     };
     if (toolCalls) {
-      assistantMessage.toolCalls = toolCalls;
+      assistantMessage.tool_calls = toolCalls;
     }
     messages.push(assistantMessage);
     if (enableTracing) {
       const llmEndedAt = nowMs();
+      const tracedResponse = turnReasoning ? { ...assistantMessage, reasoning_content: turnReasoning } : assistantMessage;
       yield {
         traceEvent: {
           type: "llm_call",
@@ -762,32 +792,37 @@ async function* reactLoopStream(input, config) {
           durationMs: llmEndedAt - llmStartedAt,
           model: config.model ?? "",
           inputMessages: inputSnapshot,
-          response: assistantMessage,
+          response: tracedResponse,
           stopReason: finishReason ?? "other",
           usage: turnUsage
         }
       };
     }
     if (finishReason !== "tool_calls" || !toolCalls) {
-      yield {
-        done: {
-          content: turnContent,
-          turns,
-          stopReason: finishReason ?? "other",
-          usage: totalUsage
-        }
+      const donePayload = {
+        content: turnContent,
+        turns,
+        stopReason: finishReason ?? "other",
+        usage: totalUsage
       };
+      if (turnReasoning) {
+        donePayload.reasoning = turnReasoning;
+      }
+      yield { done: donePayload };
       return;
     }
     for (const toolCall of toolCalls) {
-      yield { toolCall: { name: toolCall.name, arguments: toolCall.arguments } };
+      const toolName = toolCall.function.name;
       const toolStartedAt = enableTracing ? nowMs() : 0;
+      let args = {};
       let resultStr;
       let rawResult;
       let toolErr;
       let hasError = false;
       try {
-        rawResult = await config.executeTool(toolCall.name, toolCall.arguments);
+        args = parseToolCallArguments(toolCall);
+        yield { toolCall: { name: toolName, arguments: args } };
+        rawResult = await config.executeTool(toolName, args);
         if (isTracingToolResult(rawResult)) {
           resultStr = stringifyResult(rawResult.result);
         } else {
@@ -799,7 +834,7 @@ async function* reactLoopStream(input, config) {
         resultStr = stringifyError(err);
         rawResult = void 0;
       }
-      yield { toolResult: { name: toolCall.name, result: resultStr } };
+      yield { toolResult: { name: toolName, result: resultStr } };
       if (enableTracing) {
         const toolEndedAt = nowMs();
         if (isTracingToolResult(rawResult)) {
@@ -810,8 +845,8 @@ async function* reactLoopStream(input, config) {
               startedAt: toolStartedAt,
               durationMs: toolEndedAt - toolStartedAt,
               toolCallId: toolCall.id,
-              agentName: extractSubAgentName(toolCall.name),
-              input: JSON.stringify(toolCall.arguments),
+              agentName: extractSubAgentName(toolName),
+              input: JSON.stringify(args),
               trace: rawResult.trace,
               result: resultStr
             }
@@ -824,8 +859,8 @@ async function* reactLoopStream(input, config) {
               startedAt: toolStartedAt,
               durationMs: toolEndedAt - toolStartedAt,
               toolCallId: toolCall.id,
-              name: toolCall.name,
-              arguments: toolCall.arguments,
+              name: toolName,
+              arguments: args,
               result: resultStr,
               error: hasError ? stringifyError(toolErr) : void 0
             }
@@ -835,7 +870,7 @@ async function* reactLoopStream(input, config) {
       messages.push({
         role: "tool",
         content: resultStr,
-        toolCallId: toolCall.id
+        tool_call_id: toolCall.id
       });
     }
   }
@@ -871,10 +906,10 @@ function validateResumeHistory(messages) {
         `Invalid resume history at messages[${index}]: unknown role "${String(message.role)}"`
       );
     }
-    if (message.role === "assistant" && message.toolCalls?.length) {
-      const missing = new Set(message.toolCalls.map((call) => call.id));
+    if (message.role === "assistant" && message.tool_calls?.length) {
+      const missing = new Set(message.tool_calls.map((call) => call.id));
       for (let j = index + 1; j < messages.length && messages[j].role === "tool"; j++) {
-        missing.delete(messages[j].toolCallId ?? "");
+        missing.delete(messages[j].tool_call_id ?? "");
       }
       if (missing.size > 0) {
         throw new AgentError(
@@ -1166,17 +1201,17 @@ var Agent = class _Agent {
     );
   }
   /**
-   * 组装 LLM 可见 tool 列表
+   * 组装 LLM 可见 tool 列表（OpenAI chat completions 规范形）
    *
-   * 合并两个来源（按 `name` 去重，先入者保留）：
+   * 合并两个来源（按 `function.name` 去重，先入者保留）：
    * 1. **resolveAgentTools** —— agent 显式声明的 `tools` 引用
    * 2. **sub-agent** —— `resolveSubAgents` 每个包装为 `agent.<name>`
    *
-   * 每个常规 tool 的 `input`：
+   * 每个常规 tool 的 `function.parameters`：
    * - `resolveToolSchema` 提供 → 用其 `jsonSchema`
    * - 未提供 / tool 无 `inputTypeName` → 自由 schema `{ type: 'object' }`
    *
-   * sub-agent 的 `input` 始终为 `{ type: 'object' }`（agent 参数开放）。
+   * sub-agent 的 `function.parameters` 始终为 `{ type: 'object' }`（agent 参数开放）。
    */
   async buildToolDefinitions(agentName) {
     const definitions = /* @__PURE__ */ new Map();
@@ -1184,18 +1219,24 @@ var Agent = class _Agent {
       if (definitions.has(tool.name)) continue;
       const schemaRes = await this.getToolSchema(tool);
       definitions.set(tool.name, {
-        name: tool.name,
-        description: tool.description,
-        input: schemaRes?.jsonSchema ?? { type: "object" }
+        type: "function",
+        function: {
+          name: tool.name,
+          description: tool.description,
+          parameters: schemaRes?.jsonSchema ?? { type: "object" }
+        }
       });
     }
     for (const subAgent of this.deps.resolveSubAgents(agentName)) {
       const name = `agent.${subAgent.name}`;
       if (definitions.has(name)) continue;
       definitions.set(name, {
-        name,
-        description: subAgent.description,
-        input: { type: "object" }
+        type: "function",
+        function: {
+          name,
+          description: subAgent.description,
+          parameters: { type: "object" }
+        }
       });
     }
     const defs = Array.from(definitions.values());