@jaypie/llm 1.2.16 → 1.2.18

package/dist/cjs/operate/adapters/OpenAiAdapter.d.ts

@@ -26,6 +26,12 @@ export declare class OpenAiAdapter extends BaseProviderAdapter {
     responseToHistoryItems(response: unknown): LlmHistory;
     classifyError(error: unknown): ClassifiedError;
     isComplete(response: unknown): boolean;
+    /**
+     * Sanitize history items for the OpenAI Responses API.
+     * Strips fields not accepted by specific item types (e.g., `name` on
+     * function_call_output items) to prevent 400 "Unknown parameter" errors.
+     */
+    private sanitizeInputItems;
     private hasToolCalls;
     private extractContent;
 }

package/dist/cjs/types/LlmStreamChunk.interface.d.ts

@@ -16,6 +16,8 @@ export interface LlmStreamChunkToolCall {
         id: string;
         name: string;
         arguments: string;
+        /** Provider-specific metadata preserved through tool-call roundtrip */
+        metadata?: Record<string, unknown>;
     };
 }
 export interface LlmStreamChunkToolResult {

package/dist/esm/index.js

@@ -1679,6 +1679,11 @@ class GeminiAdapter extends BaseProviderAdapter {
                             name: functionCall.name || "",
                             arguments: functionCall.args || {},
                         };
+                        // Preserve thoughtSignature for Gemini 3 models
+                        // Required to maintain tool call context between turns
+                        const metadata = part.thoughtSignature
+                            ? { thoughtSignature: part.thoughtSignature }
+                            : undefined;
                         // Emit the function call immediately
                         yield {
                             type: LlmStreamChunkType.ToolCall,
@@ -1686,6 +1691,7 @@ class GeminiAdapter extends BaseProviderAdapter {
                                 id: currentFunctionCall.id,
                                 name: currentFunctionCall.name,
                                 arguments: JSON.stringify(currentFunctionCall.arguments),
+                                metadata,
                             },
                         };
                         currentFunctionCall = null;
@@ -2221,7 +2227,7 @@ class OpenAiAdapter extends BaseProviderAdapter {
         const model = request.model || this.defaultModel;
         const openaiRequest = {
             model,
-            input: request.messages,
+            input: this.sanitizeInputItems(request.messages),
         };
         if (request.user) {
             openaiRequest.user = request.user;
@@ -2372,6 +2378,9 @@ class OpenAiAdapter extends BaseProviderAdapter {
                             id: currentFunctionCall.callId,
                             name: currentFunctionCall.name,
                             arguments: currentFunctionCall.arguments,
+                            // Preserve the item ID (fc_...) separately from call_id (call_...)
+                            // OpenAI Responses API requires both with correct prefixes
+                            metadata: { itemId: currentFunctionCall.id },
                         },
                     };
                     currentFunctionCall = null;
@@ -2566,6 +2575,31 @@ class OpenAiAdapter extends BaseProviderAdapter {
     //
     // Private Helpers
     //
+    /**
+     * Sanitize history items for the OpenAI Responses API.
+     * Strips fields not accepted by specific item types (e.g., `name` on
+     * function_call_output items) to prevent 400 "Unknown parameter" errors.
+     */
+    sanitizeInputItems(messages) {
+        return messages.map((item) => {
+            const typedItem = item;
+            // function_call_output only accepts: type, call_id, output, id, status
+            if (typedItem.type === LlmMessageType.FunctionCallOutput) {
+                const sanitized = {
+                    type: typedItem.type,
+                    call_id: typedItem.call_id,
+                    output: typedItem.output,
+                };
+                if (typedItem.id)
+                    sanitized.id = typedItem.id;
+                if (typedItem.status)
+                    sanitized.status = typedItem.status;
+                return sanitized;
+            }
+            // All other items pass through as-is
+            return item;
+        });
+    }
     hasToolCalls(response) {
         if (!response.output || !Array.isArray(response.output)) {
             return false;
@@ -4791,13 +4825,22 @@ class StreamLoop {
         if (collectedToolCalls.length > 0 && state.toolkit && state.maxTurns > 1) {
             // Add tool calls to history
             for (const toolCall of collectedToolCalls) {
-                state.currentInput.push({
+                // Extract provider-specific metadata from the stream chunk
+                const metadata = toolCall.raw?.metadata;
+                const historyItem = {
                     type: LlmMessageType.FunctionCall,
                     name: toolCall.name,
                     arguments: toolCall.arguments,
                     call_id: toolCall.callId,
-                    id: toolCall.callId,
-                });
+                    // Use provider item ID if available (e.g., OpenAI fc_... prefix),
+                    // otherwise fall back to callId
+                    id: metadata?.itemId || toolCall.callId,
+                };
+                // Preserve provider-specific fields (e.g., Gemini thoughtSignature)
+                if (metadata?.thoughtSignature) {
+                    historyItem.thoughtSignature = metadata.thoughtSignature;
+                }
+                state.currentInput.push(historyItem);
             }
             return { shouldContinue: true, toolCalls: collectedToolCalls };
         }