@openai/agents-extensions 0.3.6 → 0.3.8

package/dist/aiSdk.mjs

@@ -1,6 +1,26 @@
 import { createGenerationSpan, resetCurrentSpan, setCurrentSpan, Usage, UserError, withGenerationSpan, getLogger, } from '@openai/agents';
 import { isZodObject } from '@openai/agents/utils';
 import { encodeUint8ArrayToBase64 } from '@openai/agents/utils';
+function getSpecVersion(model) {
+    const spec = model?.specificationVersion;
+    if (!spec) {
+        // Default to v2 for backward compatibility with older AI SDK model wrappers.
+        return 'v2';
+    }
+    if (spec === 'v2') {
+        return 'v2';
+    }
+    if (typeof spec === 'string' && spec.toLowerCase().startsWith('v3')) {
+        return 'v3';
+    }
+    return 'unknown';
+}
+function ensureSupportedModel(model) {
+    const spec = getSpecVersion(model);
+    if (spec === 'unknown') {
+        throw new UserError(`Unsupported AI SDK specificationVersion: ${String(model?.specificationVersion)}. Only v2 and v3 are supported.`);
+    }
+}
 /**
  * @internal
  * Converts a list of model items to a list of language model V2 messages.
@@ -9,23 +29,52 @@ import { encodeUint8ArrayToBase64 } from '@openai/agents/utils';
  * @param items - The items to convert.
  * @returns The list of language model V2 messages.
  */
-export function itemsToLanguageV2Messages(model, items) {
+export function itemsToLanguageV2Messages(model, items, modelSettings) {
     const messages = [];
     let currentAssistantMessage;
+    let pendingReasonerReasoning;
+    const flushPendingReasonerReasoningToMessages = () => {
+        if (!(shouldIncludeReasoningContent(model, modelSettings) &&
+            pendingReasonerReasoning)) {
+            return;
+        }
+        const reasoningPart = {
+            type: 'reasoning',
+            text: pendingReasonerReasoning.text,
+            providerOptions: pendingReasonerReasoning.providerOptions,
+        };
+        if (currentAssistantMessage &&
+            Array.isArray(currentAssistantMessage.content) &&
+            currentAssistantMessage.role === 'assistant') {
+            currentAssistantMessage.content.unshift(reasoningPart);
+            currentAssistantMessage.providerOptions = {
+                ...pendingReasonerReasoning.providerOptions,
+                ...currentAssistantMessage.providerOptions,
+            };
+        }
+        else {
+            messages.push({
+                role: 'assistant',
+                content: [reasoningPart],
+                providerOptions: pendingReasonerReasoning.providerOptions,
+            });
+        }
+        pendingReasonerReasoning = undefined;
+    };
     for (const item of items) {
         if (item.type === 'message' || typeof item.type === 'undefined') {
             const { role, content, providerData } = item;
             if (role === 'system') {
+                flushPendingReasonerReasoningToMessages();
                 messages.push({
                     role: 'system',
                     content: content,
-                    providerOptions: {
-                        ...(providerData ?? {}),
-                    },
+                    providerOptions: toProviderOptions(providerData, model),
                 });
                 continue;
             }
             if (role === 'user') {
+                flushPendingReasonerReasoningToMessages();
                 messages.push({
                     role,
                     content: typeof content === 'string'
@@ -36,9 +85,7 @@ export function itemsToLanguageV2Messages(model, items) {
                                 return {
                                     type: 'text',
                                     text: c.text,
-                                    providerOptions: {
-                                        ...(contentProviderData ?? {}),
-                                    },
+                                    providerOptions: toProviderOptions(contentProviderData, model),
                                 };
                             }
                             if (c.type === 'input_image') {
@@ -55,9 +102,7 @@ export function itemsToLanguageV2Messages(model, items) {
                                     type: 'file',
                                     data: url,
                                     mediaType: 'image/*',
-                                    providerOptions: {
-                                        ...(contentProviderData ?? {}),
-                                    },
+                                    providerOptions: toProviderOptions(contentProviderData, model),
                                 };
                             }
                             if (c.type === 'input_file') {
@@ -65,9 +110,7 @@ export function itemsToLanguageV2Messages(model, items) {
                             }
                             throw new UserError(`Unknown content type: ${c.type}`);
                         }),
-                    providerOptions: {
-                        ...(providerData ?? {}),
-                    },
+                    providerOptions: toProviderOptions(providerData, model),
                 });
                 continue;
             }
@@ -76,23 +119,39 @@ export function itemsToLanguageV2Messages(model, items) {
                     messages.push(currentAssistantMessage);
                     currentAssistantMessage = undefined;
                 }
+                const assistantProviderOptions = toProviderOptions(providerData, model);
+                const assistantContent = content
+                    .filter((c) => c.type === 'output_text')
+                    .map((c) => {
+                    const { providerData: contentProviderData } = c;
+                    return {
+                        type: 'text',
+                        text: c.text,
+                        providerOptions: toProviderOptions(contentProviderData, model),
+                    };
+                });
+                if (shouldIncludeReasoningContent(model, modelSettings) &&
+                    pendingReasonerReasoning) {
+                    assistantContent.unshift({
+                        type: 'reasoning',
+                        text: pendingReasonerReasoning.text,
+                        providerOptions: pendingReasonerReasoning.providerOptions,
+                    });
+                    messages.push({
+                        role,
+                        content: assistantContent,
+                        providerOptions: {
+                            ...pendingReasonerReasoning.providerOptions,
+                            ...assistantProviderOptions,
+                        },
+                    });
+                    pendingReasonerReasoning = undefined;
+                    continue;
+                }
                 messages.push({
                     role,
-                    content: content
-                        .filter((c) => c.type === 'output_text')
-                        .map((c) => {
-                        const { providerData: contentProviderData } = c;
-                        return {
-                            type: 'text',
-                            text: c.text,
-                            providerOptions: {
-                                ...(contentProviderData ?? {}),
-                            },
-                        };
-                    }),
-                    providerOptions: {
-                        ...(providerData ?? {}),
-                    },
+                    content: assistantContent,
+                    providerOptions: assistantProviderOptions,
                 });
                 continue;
             }
@@ -104,27 +163,38 @@ export function itemsToLanguageV2Messages(model, items) {
                 currentAssistantMessage = {
                     role: 'assistant',
                     content: [],
-                    providerOptions: {
-                        ...(item.providerData ?? {}),
-                    },
+                    providerOptions: toProviderOptions(item.providerData, model),
                 };
             }
             if (Array.isArray(currentAssistantMessage.content) &&
                 currentAssistantMessage.role === 'assistant') {
+                // Reasoner models (e.g., DeepSeek Reasoner) require reasoning_content on tool-call messages.
+                if (shouldIncludeReasoningContent(model, modelSettings) &&
+                    pendingReasonerReasoning) {
+                    currentAssistantMessage.content.push({
+                        type: 'reasoning',
+                        text: pendingReasonerReasoning.text,
+                        providerOptions: pendingReasonerReasoning.providerOptions,
+                    });
+                    currentAssistantMessage.providerOptions = {
+                        ...pendingReasonerReasoning.providerOptions,
+                        ...currentAssistantMessage.providerOptions,
+                    };
+                    pendingReasonerReasoning = undefined;
+                }
                 const content = {
                     type: 'tool-call',
                     toolCallId: item.callId,
                     toolName: item.name,
                     input: parseArguments(item.arguments),
-                    providerOptions: {
-                        ...(item.providerData ?? {}),
-                    },
+                    providerOptions: toProviderOptions(item.providerData, model),
                 };
                 currentAssistantMessage.content.push(content);
             }
             continue;
         }
         else if (item.type === 'function_call_result') {
+            flushPendingReasonerReasoningToMessages();
             if (currentAssistantMessage) {
                 messages.push(currentAssistantMessage);
                 currentAssistantMessage = undefined;
@@ -134,16 +204,12 @@ export function itemsToLanguageV2Messages(model, items) {
                 toolCallId: item.callId,
                 toolName: item.name,
                 output: convertToAiSdkOutput(item.output),
-                providerOptions: {
-                    ...(item.providerData ?? {}),
-                },
+                providerOptions: toProviderOptions(item.providerData, model),
             };
             messages.push({
                 role: 'tool',
                 content: [toolResult],
-                providerOptions: {
-                    ...(item.providerData ?? {}),
-                },
+                providerOptions: toProviderOptions(item.providerData, model),
             });
             continue;
         }
@@ -171,22 +237,29 @@ export function itemsToLanguageV2Messages(model, items) {
         if (item.type === 'reasoning' &&
             item.content.length > 0 &&
             typeof item.content[0].text === 'string') {
+            // Only forward provider data when it targets this model so signatures stay scoped correctly.
+            if (shouldIncludeReasoningContent(model, modelSettings)) {
+                pendingReasonerReasoning = {
+                    text: item.content[0].text,
+                    providerOptions: toProviderOptions(item.providerData, model),
+                };
+                continue;
+            }
             messages.push({
                 role: 'assistant',
                 content: [
                     {
                         type: 'reasoning',
                         text: item.content[0].text,
-                        providerOptions: { ...(item.providerData ?? {}) },
+                        providerOptions: toProviderOptions(item.providerData, model),
                     },
                 ],
-                providerOptions: {
-                    ...(item.providerData ?? {}),
-                },
+                providerOptions: toProviderOptions(item.providerData, model),
             });
             continue;
         }
         if (item.type === 'unknown') {
+            flushPendingReasonerReasoningToMessages();
             messages.push({ ...(item.providerData ?? {}) });
             continue;
         }
@@ -196,6 +269,7 @@ export function itemsToLanguageV2Messages(model, items) {
         const itemType = item;
         throw new UserError(`Unknown item type: ${itemType}`);
     }
+    flushPendingReasonerReasoningToMessages();
     if (currentAssistantMessage) {
         messages.push(currentAssistantMessage);
     }
@@ -381,6 +455,122 @@ function convertStructuredOutputsToAiSdkOutput(outputs) {
 function isRecord(value) {
     return typeof value === 'object' && value !== null;
 }
+function getModelIdentifier(model) {
+    return `${model.provider}:${model.modelId}`;
+}
+function isProviderDataForModel(providerData, model) {
+    const providerDataModel = providerData.model;
+    if (typeof providerDataModel !== 'string') {
+        return true;
+    }
+    const target = getModelIdentifier(model).toLowerCase();
+    const pdLower = providerDataModel.toLowerCase();
+    return (pdLower === target ||
+        pdLower === model.modelId.toLowerCase() ||
+        pdLower === model.provider.toLowerCase());
+}
+function isGeminiModel(model) {
+    const target = getModelIdentifier(model).toLowerCase();
+    return (target.includes('gemini') || model.modelId.toLowerCase().includes('gemini'));
+}
+function isDeepSeekModel(model) {
+    const target = getModelIdentifier(model).toLowerCase();
+    return (target.includes('deepseek') ||
+        model.modelId.toLowerCase().includes('deepseek') ||
+        model.provider.toLowerCase().includes('deepseek'));
+}
+function shouldIncludeReasoningContent(model, modelSettings) {
+    const target = getModelIdentifier(model).toLowerCase();
+    const modelIdLower = model.modelId.toLowerCase();
+    // DeepSeek models require reasoning_content to be sent alongside tool calls when
+    // either the dedicated reasoner model is used or thinking mode is explicitly enabled.
+    const isDeepSeekReasoner = target.includes('deepseek-reasoner') ||
+        modelIdLower.includes('deepseek-reasoner');
+    if (isDeepSeekReasoner) {
+        return true;
+    }
+    if (!isDeepSeekModel(model)) {
+        return false;
+    }
+    return hasEnabledDeepSeekThinking(modelSettings?.providerData);
+}
+function hasEnabledDeepSeekThinking(providerData) {
+    if (!isRecord(providerData)) {
+        return false;
+    }
+    const thinkingOption = [
+        providerData.thinking,
+        providerData.deepseek?.thinking,
+        providerData.providerOptions?.thinking,
+        providerData.providerOptions?.deepseek?.thinking,
+    ].find((value) => value !== undefined);
+    return isThinkingEnabled(thinkingOption);
+}
+function isThinkingEnabled(option) {
+    if (option === undefined || option === null) {
+        return false;
+    }
+    if (option === true) {
+        return true;
+    }
+    if (typeof option === 'string') {
+        return option.toLowerCase() === 'enabled';
+    }
+    if (isRecord(option)) {
+        const type = option.type ?? option.mode ?? option.status;
+        if (typeof type === 'string') {
+            return type.toLowerCase() === 'enabled';
+        }
+    }
+    return false;
+}
+function toProviderOptions(providerData, model) {
+    if (!isRecord(providerData)) {
+        return {};
+    }
+    if (!isProviderDataForModel(providerData, model)) {
+        return {};
+    }
+    const options = { ...providerData };
+    delete options.model;
+    delete options.responseId;
+    delete options.response_id;
+    if (isGeminiModel(model)) {
+        const googleFields = isRecord(options.google) ? { ...options.google } : {};
+        const thoughtSignature = googleFields.thoughtSignature ??
+            googleFields.thought_signature ??
+            options.thoughtSignature ??
+            options.thought_signature;
+        if (thoughtSignature) {
+            googleFields.thoughtSignature = thoughtSignature;
+        }
+        if (Object.keys(googleFields).length > 0) {
+            options.google = googleFields;
+        }
+        delete options.thoughtSignature;
+        delete options.thought_signature;
+    }
+    return options;
+}
+function buildBaseProviderData(model, responseId) {
+    const base = { model: getModelIdentifier(model) };
+    if (responseId) {
+        base.responseId = responseId;
+    }
+    return base;
+}
+function mergeProviderData(base, ...sources) {
+    const merged = {};
+    if (isRecord(base)) {
+        Object.assign(merged, base);
+    }
+    for (const src of sources) {
+        if (isRecord(src)) {
+            Object.assign(merged, src);
+        }
+    }
+    return Object.keys(merged).length > 0 ? merged : undefined;
+}
 function getImageInlineMediaType(source) {
     if (typeof source.mediaType === 'string' && source.mediaType.length > 0) {
         return source.mediaType;
@@ -476,6 +666,7 @@ export class AiSdkModel {
     #model;
     #logger = getLogger('openai-agents:extensions:ai-sdk');
     constructor(model) {
+        ensureSupportedModel(model);
         this.#model = model;
     }
     async getResponse(request) {
@@ -493,7 +684,7 @@ export class AiSdkModel {
                             content: [{ type: 'text', text: request.input }],
                         },
                     ]
-                    : itemsToLanguageV2Messages(this.#model, request.input);
+                    : itemsToLanguageV2Messages(this.#model, request.input, request.modelSettings);
                 if (request.systemInstructions) {
                     input = [
                         {
@@ -534,8 +725,10 @@ export class AiSdkModel {
                     this.#logger.debug('Request:', JSON.stringify(aiSdkRequest, null, 2));
                 }
                 const result = await this.#model.doGenerate(aiSdkRequest);
+                const baseProviderData = buildBaseProviderData(this.#model, result.response?.id);
                 const output = [];
                 const resultContent = result.content ?? [];
+                // Emit reasoning before tool calls so Anthropic thinking signatures propagate into the next turn.
                 // Extract and add reasoning items FIRST (required by Anthropic: thinking blocks must precede tool_use blocks)
                 const reasoningParts = resultContent.filter((c) => c && c.type === 'reasoning');
                 for (const reasoningPart of reasoningParts) {
@@ -545,7 +738,7 @@ export class AiSdkModel {
                         content: [{ type: 'input_text', text: reasoningText }],
                         rawContent: [{ type: 'reasoning_text', text: reasoningText }],
                         // Preserve provider-specific metadata (including signature for Anthropic extended thinking)
-                        providerData: reasoningPart.providerMetadata ?? undefined,
+                        providerData: mergeProviderData(baseProviderData, reasoningPart.providerMetadata),
                     });
                 }
                 const toolCalls = resultContent.filter((c) => c && c.type === 'tool-call');
@@ -577,8 +770,8 @@ export class AiSdkModel {
                         name: toolCall.toolName,
                         arguments: toolCallArguments,
                         status: 'completed',
-                        providerData: toolCall.providerMetadata ??
-                            (hasToolCalls ? result.providerMetadata : undefined),
+                        providerData: mergeProviderData(baseProviderData, toolCall.providerMetadata ??
+                            (hasToolCalls ? result.providerMetadata : undefined)),
                     });
                 }
                 // Some of other platforms may return both tool calls and text.
@@ -593,7 +786,7 @@ export class AiSdkModel {
                             content: [{ type: 'output_text', text: textItem.text }],
                             role: 'assistant',
                             status: 'completed',
-                            providerData: result.providerMetadata,
+                            providerData: mergeProviderData(baseProviderData, result.providerMetadata),
                         });
                     }
                 }
@@ -603,18 +796,10 @@ export class AiSdkModel {
                 const response = {
                     responseId: result.response?.id ?? 'FAKE_ID',
                     usage: new Usage({
-                        inputTokens: Number.isNaN(result.usage?.inputTokens)
-                            ? 0
-                            : (result.usage?.inputTokens ?? 0),
-                        outputTokens: Number.isNaN(result.usage?.outputTokens)
-                            ? 0
-                            : (result.usage?.outputTokens ?? 0),
-                        totalTokens: (Number.isNaN(result.usage?.inputTokens)
-                            ? 0
-                            : (result.usage?.inputTokens ?? 0)) +
-                            (Number.isNaN(result.usage?.outputTokens)
-                                ? 0
-                                : (result.usage?.outputTokens ?? 0)) || 0,
+                        inputTokens: extractTokenCount(result.usage, 'inputTokens'),
+                        outputTokens: extractTokenCount(result.usage, 'outputTokens'),
+                        totalTokens: extractTokenCount(result.usage, 'inputTokens') +
+                            extractTokenCount(result.usage, 'outputTokens') || 0,
                     }),
                     output,
                     providerData: result,
@@ -702,7 +887,7 @@ export class AiSdkModel {
                         content: [{ type: 'text', text: request.input }],
                     },
                 ]
-                : itemsToLanguageV2Messages(this.#model, request.input);
+                : itemsToLanguageV2Messages(this.#model, request.input, request.modelSettings);
             if (request.systemInstructions) {
                 input = [
                     {
@@ -722,6 +907,7 @@ export class AiSdkModel {
             const responseFormat = getResponseFormat(request.outputType);
             const aiSdkRequest = {
                 tools,
+                toolChoice: toolChoiceToLanguageV2Format(request.modelSettings.toolChoice),
                 prompt: input,
                 temperature: request.modelSettings.temperature,
                 topP: request.modelSettings.topP,
@@ -739,13 +925,15 @@ export class AiSdkModel {
                 this.#logger.debug('Request (streamed):', JSON.stringify(aiSdkRequest, null, 2));
             }
             const { stream } = await this.#model.doStream(aiSdkRequest);
+            const baseProviderData = buildBaseProviderData(this.#model);
             let started = false;
             let responseId;
             let usagePromptTokens = 0;
             let usageCompletionTokens = 0;
             const functionCalls = {};
             let textOutput;
-            // State for tracking reasoning blocks (for Anthropic extended thinking)
+            // State for tracking reasoning blocks (for Anthropic extended thinking):
+            // Track reasoning deltas so we can preserve Anthropic signatures even when text is redacted.
             const reasoningBlocks = {};
             for await (const part of stream) {
                 if (!started) {
@@ -801,9 +989,7 @@ export class AiSdkModel {
                                 name: part.toolName,
                                 arguments: part.input ?? '',
                                 status: 'completed',
-                                ...(part.providerMetadata
-                                    ? { providerData: part.providerMetadata }
-                                    : {}),
+                                providerData: mergeProviderData(baseProviderData, part.providerMetadata),
                             };
                         }
                         break;
@@ -815,12 +1001,8 @@ export class AiSdkModel {
                         break;
                     }
                     case 'finish': {
-                        usagePromptTokens = Number.isNaN(part.usage?.inputTokens)
-                            ? 0
-                            : (part.usage?.inputTokens ?? 0);
-                        usageCompletionTokens = Number.isNaN(part.usage?.outputTokens)
-                            ? 0
-                            : (part.usage?.outputTokens ?? 0);
+                        usagePromptTokens = extractTokenCount(part.usage, 'inputTokens');
+                        usageCompletionTokens = extractTokenCount(part.usage, 'outputTokens');
                         break;
                     }
                     case 'error': {
@@ -841,7 +1023,7 @@ export class AiSdkModel {
                         content: [{ type: 'input_text', text: reasoningBlock.text }],
                         rawContent: [{ type: 'reasoning_text', text: reasoningBlock.text }],
                         // Preserve provider-specific metadata (including signature for Anthropic extended thinking)
-                        providerData: reasoningBlock.providerMetadata ?? undefined,
+                        providerData: mergeProviderData(baseProviderData, reasoningBlock.providerMetadata, responseId ? { responseId } : undefined),
                     });
                 }
             }
@@ -851,10 +1033,14 @@ export class AiSdkModel {
                     role: 'assistant',
                     content: [textOutput],
                     status: 'completed',
+                    providerData: mergeProviderData(baseProviderData, responseId ? { responseId } : undefined),
                 });
             }
             for (const fc of Object.values(functionCalls)) {
-                outputs.push(fc);
+                outputs.push({
+                    ...fc,
+                    providerData: mergeProviderData(baseProviderData, fc.providerData, responseId ? { responseId } : undefined),
+                });
             }
             const finalEvent = {
                 type: 'response_done',
@@ -960,6 +1146,19 @@ export class AiSdkModel {
 export function aisdk(model) {
     return new AiSdkModel(model);
 }
+function extractTokenCount(usage, key) {
+    const val = usage?.[key];
+    if (typeof val === 'number') {
+        return Number.isNaN(val) ? 0 : val;
+    }
+    // Handle Google AI SDK object format ({ total: number, ... })
+    if (typeof val === 'object' &&
+        val !== null &&
+        typeof val.total === 'number') {
+        return val.total;
+    }
+    return 0;
+}
 export function parseArguments(args) {
     if (!args) {
         return {};