@openai/agents-extensions 0.3.7 → 0.3.8

package/dist/aiSdk.d.ts

@@ -1,5 +1,18 @@
 import type { LanguageModelV2, LanguageModelV2ToolChoice } from '@ai-sdk/provider';
 import { Model, ModelRequest, ResponseStreamEvent, Usage, ModelSettingsToolChoice } from '@openai/agents';
+type LanguageModelV3Compatible = {
+    specificationVersion: string;
+    provider: string;
+    modelId: string;
+    supportedUrls: any;
+    doGenerate: (options: any) => PromiseLike<any> | any;
+    doStream: (options: any) => PromiseLike<{
+        stream: AsyncIterable<any>;
+    }> | {
+        stream: AsyncIterable<any>;
+    } | any;
+};
+type LanguageModelCompatible = LanguageModelV2 | LanguageModelV3Compatible;
 /**
  * Wraps a model from the AI SDK that adheres to the LanguageModelV2 spec to be used used as a model
  * in the OpenAI Agents SDK to use other models.
@@ -26,25 +39,12 @@ import { Model, ModelRequest, ResponseStreamEvent, Usage, ModelSettingsToolChoic
  */
 export declare class AiSdkModel implements Model {
     #private;
-    constructor(model: LanguageModelV2);
+    constructor(model: LanguageModelCompatible);
     getResponse(request: ModelRequest): Promise<{
         readonly responseId: any;
         readonly usage: Usage;
         readonly output: import("@openai/agents").AgentOutputItem[];
-        readonly providerData: {
-            content: Array<import("@ai-sdk/provider").LanguageModelV2Content>;
-            finishReason: import("@ai-sdk/provider").LanguageModelV2FinishReason;
-            usage: import("@ai-sdk/provider").LanguageModelV2Usage;
-            providerMetadata?: import("@ai-sdk/provider").SharedV2ProviderMetadata;
-            request?: {
-                body?: unknown;
-            };
-            response?: import("@ai-sdk/provider").LanguageModelV2ResponseMetadata & {
-                headers?: import("@ai-sdk/provider").SharedV2Headers;
-                body?: unknown;
-            };
-            warnings: Array<import("@ai-sdk/provider").LanguageModelV2CallWarning>;
-        };
+        readonly providerData: any;
     }>;
     getStreamedResponse(request: ModelRequest): AsyncIterable<ResponseStreamEvent>;
 }
@@ -72,6 +72,7 @@ export declare class AiSdkModel implements Model {
  * @param model - The Vercel AI SDK model to wrap.
  * @returns The wrapped model.
  */
-export declare function aisdk(model: LanguageModelV2): AiSdkModel;
+export declare function aisdk(model: LanguageModelCompatible): AiSdkModel;
 export declare function parseArguments(args: string | undefined | null): any;
 export declare function toolChoiceToLanguageV2Format(toolChoice: ModelSettingsToolChoice | undefined): LanguageModelV2ToolChoice | undefined;
+export {};

package/dist/aiSdk.js

@@ -10,6 +10,26 @@ exports.toolChoiceToLanguageV2Format = toolChoiceToLanguageV2Format;
 const agents_1 = require("@openai/agents");
 const utils_1 = require("@openai/agents/utils");
 const utils_2 = require("@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 agents_1.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.
@@ -18,23 +38,52 @@ const utils_2 = require("@openai/agents/utils");
  * @param items - The items to convert.
  * @returns The list of language model V2 messages.
  */
-function itemsToLanguageV2Messages(model, items) {
+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'
@@ -45,9 +94,7 @@ function itemsToLanguageV2Messages(model, items) {
                                 return {
                                     type: 'text',
                                     text: c.text,
-                                    providerOptions: {
-                                        ...(contentProviderData ?? {}),
-                                    },
+                                    providerOptions: toProviderOptions(contentProviderData, model),
                                 };
                             }
                             if (c.type === 'input_image') {
@@ -64,9 +111,7 @@ function itemsToLanguageV2Messages(model, items) {
                                     type: 'file',
                                     data: url,
                                     mediaType: 'image/*',
-                                    providerOptions: {
-                                        ...(contentProviderData ?? {}),
-                                    },
+                                    providerOptions: toProviderOptions(contentProviderData, model),
                                 };
                             }
                             if (c.type === 'input_file') {
@@ -74,9 +119,7 @@ function itemsToLanguageV2Messages(model, items) {
                             }
                             throw new agents_1.UserError(`Unknown content type: ${c.type}`);
                         }),
-                    providerOptions: {
-                        ...(providerData ?? {}),
-                    },
+                    providerOptions: toProviderOptions(providerData, model),
                 });
                 continue;
             }
@@ -85,23 +128,39 @@ 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;
             }
@@ -113,27 +172,38 @@ 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;
@@ -143,16 +213,12 @@ 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;
         }
@@ -180,22 +246,29 @@ 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;
         }
@@ -205,6 +278,7 @@ function itemsToLanguageV2Messages(model, items) {
         const itemType = item;
         throw new agents_1.UserError(`Unknown item type: ${itemType}`);
     }
+    flushPendingReasonerReasoningToMessages();
     if (currentAssistantMessage) {
         messages.push(currentAssistantMessage);
     }
@@ -390,6 +464,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;
@@ -485,6 +675,7 @@ class AiSdkModel {
     #model;
     #logger = (0, agents_1.getLogger)('openai-agents:extensions:ai-sdk');
     constructor(model) {
+        ensureSupportedModel(model);
         this.#model = model;
     }
     async getResponse(request) {
@@ -502,7 +693,7 @@ class AiSdkModel {
                             content: [{ type: 'text', text: request.input }],
                         },
                     ]
-                    : itemsToLanguageV2Messages(this.#model, request.input);
+                    : itemsToLanguageV2Messages(this.#model, request.input, request.modelSettings);
                 if (request.systemInstructions) {
                     input = [
                         {
@@ -543,8 +734,10 @@ 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) {
@@ -554,7 +747,7 @@ 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');
@@ -586,8 +779,8 @@ 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.
@@ -602,7 +795,7 @@ class AiSdkModel {
                             content: [{ type: 'output_text', text: textItem.text }],
                             role: 'assistant',
                             status: 'completed',
-                            providerData: result.providerMetadata,
+                            providerData: mergeProviderData(baseProviderData, result.providerMetadata),
                         });
                     }
                 }
@@ -612,18 +805,10 @@ class AiSdkModel {
                 const response = {
                     responseId: result.response?.id ?? 'FAKE_ID',
                     usage: new agents_1.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,
@@ -711,7 +896,7 @@ class AiSdkModel {
                         content: [{ type: 'text', text: request.input }],
                     },
                 ]
-                : itemsToLanguageV2Messages(this.#model, request.input);
+                : itemsToLanguageV2Messages(this.#model, request.input, request.modelSettings);
             if (request.systemInstructions) {
                 input = [
                     {
@@ -731,6 +916,7 @@ 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,
@@ -748,13 +934,15 @@ 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) {
@@ -810,9 +998,7 @@ class AiSdkModel {
                                 name: part.toolName,
                                 arguments: part.input ?? '',
                                 status: 'completed',
-                                ...(part.providerMetadata
-                                    ? { providerData: part.providerMetadata }
-                                    : {}),
+                                providerData: mergeProviderData(baseProviderData, part.providerMetadata),
                             };
                         }
                         break;
@@ -824,12 +1010,8 @@ 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': {
@@ -850,7 +1032,7 @@ 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),
                     });
                 }
             }
@@ -860,10 +1042,14 @@ 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',
@@ -970,6 +1156,19 @@ exports.AiSdkModel = AiSdkModel;
 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;
+}
 function parseArguments(args) {
     if (!args) {
         return {};