@openai/agents-extensions 0.5.4 → 0.7.0

package/dist/ai-sdk/index.d.ts

@@ -1,5 +1,5 @@
 import type { LanguageModelV2 as LanguageModelV2Base, LanguageModelV2CallOptions, LanguageModelV2FunctionTool, LanguageModelV2ToolChoice } from '@ai-sdk/provider';
-import { Model, ModelRequest, ResponseStreamEvent, Usage, ModelSettingsToolChoice } from '@openai/agents';
+import { Model, ModelRetryAdvice, ModelRetryAdviceRequest, ModelRequest, ResponseStreamEvent, Usage, ModelSettingsToolChoice } from '@openai/agents';
 type LanguageModelV3Compatible = {
     specificationVersion: string;
     provider: string;
@@ -63,7 +63,7 @@ export type AiSdkModelOptions = {
  * If tracing is enabled, the model will send generation spans to your traces processor.
  *
  * ```ts
- * import { aisdk } from '@openai/agents-extensions';
+ * import { aisdk } from '@openai/agents-extensions/ai-sdk';
  * import { openai } from '@ai-sdk/openai';
  *
  * const model = aisdk(openai('gpt-4o'));
@@ -80,6 +80,7 @@ export type AiSdkModelOptions = {
 export declare class AiSdkModel implements Model {
     #private;
     constructor(model: LanguageModelCompatible, options?: AiSdkModelOptions);
+    getRetryAdvice(args: ModelRetryAdviceRequest): ModelRetryAdvice | undefined;
     getResponse(request: ModelRequest): Promise<{
         readonly responseId: any;
         readonly usage: Usage;
@@ -98,7 +99,7 @@ export declare class AiSdkModel implements Model {
  * If tracing is enabled, the model will send generation spans to your traces processor.
  *
  * ```ts
- * import { aisdk } from '@openai/agents-extensions';
+ * import { aisdk } from '@openai/agents-extensions/ai-sdk';
  * import { openai } from '@ai-sdk/openai';
  *
  * const model = aisdk(openai('gpt-4o'));

package/dist/ai-sdk/index.js

@@ -8,8 +8,14 @@ exports.aisdk = aisdk;
 exports.parseArguments = parseArguments;
 exports.toolChoiceToLanguageV2Format = toolChoiceToLanguageV2Format;
 const agents_1 = require("@openai/agents");
-const utils_1 = require("@openai/agents/utils");
+const utils_1 = require("@openai/agents-core/utils");
 const utils_2 = require("@openai/agents/utils");
+function hasComputerDisplayMetadata(tool) {
+    return (typeof tool.environment === 'string' &&
+        Array.isArray(tool.dimensions) &&
+        tool.dimensions.length === 2 &&
+        tool.dimensions.every((value) => typeof value === 'number'));
+}
 function getSpecVersion(model) {
     const spec = model?.specificationVersion;
     if (!spec) {
@@ -62,8 +68,13 @@ function parseBase64ImageDataUrl(imageSource) {
  */
 function itemsToLanguageV2Messages(model, items, modelSettings) {
     const messages = [];
+    const toolCallNamesById = new Map();
+    const pendingToolSearchCallIds = [];
+    const pendingServerToolSearchCallIds = [];
+    let generatedToolSearchCallId = 0;
     let currentAssistantMessage;
     let pendingReasonerReasoning;
+    const collapsedItems = collapseReplacedToolSearchOutputs(items);
     const flushPendingReasonerReasoningToMessages = () => {
         if (!(shouldIncludeReasoningContent(model, modelSettings) &&
             pendingReasonerReasoning)) {
@@ -92,7 +103,7 @@ function itemsToLanguageV2Messages(model, items, modelSettings) {
         }
         pendingReasonerReasoning = undefined;
     };
-    for (const item of items) {
+    for (const item of collapsedItems) {
         if (item.type === 'message' || typeof item.type === 'undefined') {
             const { role, content, providerData } = item;
             if (role === 'system') {
@@ -222,10 +233,12 @@ function itemsToLanguageV2Messages(model, items, modelSettings) {
                     };
                     pendingReasonerReasoning = undefined;
                 }
+                const toolName = getAiSdkToolName(item);
+                toolCallNamesById.set(item.callId, toolName);
                 const content = {
                     type: 'tool-call',
                     toolCallId: item.callId,
-                    toolName: item.name,
+                    toolName,
                     input: parseArguments(item.arguments),
                     providerOptions: toProviderOptions(item.providerData, model),
                 };
@@ -239,10 +252,11 @@ function itemsToLanguageV2Messages(model, items, modelSettings) {
                 messages.push(currentAssistantMessage);
                 currentAssistantMessage = undefined;
             }
+            const toolName = toolCallNamesById.get(item.callId) ?? getAiSdkToolName(item);
             const toolResult = {
                 type: 'tool-result',
                 toolCallId: item.callId,
-                toolName: item.name,
+                toolName,
                 output: convertToAiSdkOutput(item.output),
                 providerOptions: toProviderOptions(item.providerData, model),
             };
@@ -253,6 +267,93 @@ function itemsToLanguageV2Messages(model, items, modelSettings) {
             });
             continue;
         }
+        else if (item.type === 'tool_search_call') {
+            if (!currentAssistantMessage) {
+                currentAssistantMessage = {
+                    role: 'assistant',
+                    content: [],
+                    providerOptions: toProviderOptions(item.providerData, model),
+                };
+            }
+            if (Array.isArray(currentAssistantMessage.content) &&
+                currentAssistantMessage.role === 'assistant') {
+                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 toolCallId = (0, utils_1.resolveToolSearchCallId)(item, () => {
+                    generatedToolSearchCallId += 1;
+                    return `tool_search_${generatedToolSearchCallId}`;
+                });
+                if ((0, utils_1.shouldQueuePendingToolSearchCall)(item)) {
+                    pendingToolSearchCallIds.push(toolCallId);
+                }
+                else {
+                    pendingServerToolSearchCallIds.push(toolCallId);
+                }
+                toolCallNamesById.set(toolCallId, 'tool_search');
+                const content = {
+                    type: 'tool-call',
+                    toolCallId,
+                    toolName: 'tool_search',
+                    input: item.arguments,
+                    providerOptions: toProviderOptions(item.providerData, model),
+                };
+                currentAssistantMessage.content.push(content);
+            }
+            continue;
+        }
+        else if (item.type === 'tool_search_output') {
+            flushPendingReasonerReasoningToMessages();
+            if (currentAssistantMessage) {
+                messages.push(currentAssistantMessage);
+                currentAssistantMessage = undefined;
+            }
+            const rawToolSearchExecution = item.execution ??
+                item.providerData?.execution;
+            const toolSearchExecution = rawToolSearchExecution === 'client' ||
+                rawToolSearchExecution === 'server'
+                ? rawToolSearchExecution
+                : undefined;
+            const toolCallId = toolSearchExecution === 'server'
+                ? takeQueuedToolSearchResultCallId(item, pendingServerToolSearchCallIds, () => {
+                    generatedToolSearchCallId += 1;
+                    return `tool_search_${generatedToolSearchCallId}`;
+                })
+                : (0, utils_1.takePendingToolSearchCallId)(item, pendingToolSearchCallIds, () => {
+                    generatedToolSearchCallId += 1;
+                    return `tool_search_${generatedToolSearchCallId}`;
+                });
+            const toolName = toolCallNamesById.get(toolCallId) ?? 'tool_search';
+            const toolResult = {
+                type: 'tool-result',
+                toolCallId,
+                toolName,
+                output: {
+                    type: 'json',
+                    value: {
+                        ...(typeof item.status === 'string' ? { status: item.status } : {}),
+                        tools: item.tools,
+                    },
+                },
+                providerOptions: toProviderOptions(item.providerData, model),
+            };
+            messages.push({
+                role: 'tool',
+                content: [toolResult],
+                providerOptions: toProviderOptions(item.providerData, model),
+            });
+            continue;
+        }
         if (item.type === 'hosted_tool_call') {
             throw new agents_1.UserError('Hosted tool calls are not supported');
         }
@@ -434,6 +535,121 @@ function expectsObjectArguments(tool) {
     }
     return false;
 }
+function buildRequestedToolsByName(request) {
+    const toolsByName = new Map();
+    const addRequestedTool = (name, tool) => {
+        const existing = toolsByName.get(name);
+        if (name === 'tool_search' &&
+            existing &&
+            isHostedToolSearchTool(existing) !== isHostedToolSearchTool(tool)) {
+            throw new agents_1.UserError('AiSdkModel cannot disambiguate a hosted tool_search helper from a custom tool or handoff that is also named "tool_search". Rename the custom tool or use a different adapter.');
+        }
+        toolsByName.set(name, tool);
+    };
+    for (const tool of request.tools) {
+        addRequestedTool(tool.type === 'function'
+            ? getSerializedFunctionToolName(tool)
+            : tool.name, tool);
+    }
+    for (const handoff of request.handoffs) {
+        addRequestedTool(handoff.toolName, handoff);
+    }
+    return toolsByName;
+}
+function isHostedToolSearchTool(tool) {
+    return (!!tool &&
+        !('toolName' in tool) &&
+        tool.type === 'hosted_tool' &&
+        tool.providerData?.type === 'tool_search');
+}
+function normalizeToolSearchArguments(value) {
+    if (typeof value !== 'string') {
+        return value ?? {};
+    }
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        return {};
+    }
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function takeQueuedToolSearchResultCallId(value, pendingCallIds, generateFallbackId) {
+    const explicitCallId = (0, utils_1.getToolSearchProviderCallId)(value);
+    if (explicitCallId) {
+        const pendingIndex = pendingCallIds.indexOf(explicitCallId);
+        if (pendingIndex >= 0) {
+            pendingCallIds.splice(pendingIndex, 1);
+        }
+        return explicitCallId;
+    }
+    return (pendingCallIds.shift() ?? (0, utils_1.resolveToolSearchCallId)(value, generateFallbackId));
+}
+function getToolSearchOutputReplacementKey(item) {
+    const providerCallId = (0, utils_1.getToolSearchProviderCallId)(item);
+    if (providerCallId) {
+        return `call:${providerCallId}`;
+    }
+    if (typeof item.id === 'string' && item.id.length > 0) {
+        return `item:${item.id}`;
+    }
+    return undefined;
+}
+function collapseReplacedToolSearchOutputs(items) {
+    const latestIndexByReplacementKey = new Map();
+    items.forEach((item, index) => {
+        if (item.type !== 'tool_search_output') {
+            return;
+        }
+        const replacementKey = getToolSearchOutputReplacementKey(item);
+        if (replacementKey) {
+            latestIndexByReplacementKey.set(replacementKey, index);
+        }
+    });
+    return items.filter((item, index) => {
+        if (item.type !== 'tool_search_output') {
+            return true;
+        }
+        const replacementKey = getToolSearchOutputReplacementKey(item);
+        if (!replacementKey) {
+            return true;
+        }
+        return latestIndexByReplacementKey.get(replacementKey) === index;
+    });
+}
+function createProtocolToolCallItem(args) {
+    const { requestedTool, toolCallId, toolName, input, providerData } = args;
+    if (isHostedToolSearchTool(requestedTool)) {
+        return {
+            type: 'tool_search_call',
+            id: toolCallId,
+            arguments: normalizeToolSearchArguments(input),
+            status: 'completed',
+            providerData,
+        };
+    }
+    let toolCallArguments;
+    if (typeof input === 'string') {
+        toolCallArguments =
+            input === '' && expectsObjectArguments(requestedTool)
+                ? JSON.stringify({})
+                : input;
+    }
+    else {
+        toolCallArguments = JSON.stringify(input ?? {});
+    }
+    return {
+        type: 'function_call',
+        callId: toolCallId,
+        name: toolName,
+        arguments: toolCallArguments,
+        status: 'completed',
+        providerData,
+    };
+}
 /**
  * Maps the protocol-level structured outputs into the Language Model V2 result primitives.
  * The AI SDK expects either plain text or content parts (text + media), so we merge multiple
@@ -504,6 +720,12 @@ function convertStructuredOutputsToAiSdkOutput(outputs) {
 function isRecord(value) {
     return typeof value === 'object' && value !== null;
 }
+function getAiSdkToolName(tool) {
+    return (0, utils_1.toolQualifiedName)(tool.name, tool.namespace) ?? tool.name;
+}
+function getSerializedFunctionToolName(tool) {
+    return getAiSdkToolName(tool);
+}
 function getModelIdentifier(model) {
     return `${model.provider}:${model.modelId}`;
 }
@@ -630,6 +852,16 @@ function formatInlineData(data, mediaType) {
     const base64 = typeof data === 'string' ? data : (0, utils_2.encodeUint8ArrayToBase64)(data);
     return mediaType ? `data:${mediaType};base64,${base64}` : base64;
 }
+function getHostedToolArgs(providerData) {
+    if (!isRecord(providerData)) {
+        return {};
+    }
+    if (isRecord(providerData.args)) {
+        return providerData.args;
+    }
+    const { type: _type, name: _name, args: _args, ...rest } = providerData;
+    return rest;
+}
 /**
  * @internal
  * Converts a tool to a language model V2 tool.
@@ -639,9 +871,12 @@ function formatInlineData(data, mediaType) {
  */
 function toolToLanguageV2Tool(model, tool) {
     if (tool.type === 'function') {
+        if (tool.deferLoading) {
+            throw new agents_1.UserError('The AI SDK adapter does not support deferred Responses function tools (`toolNamespace()` or `deferLoading: true`). Use a Responses API model directly.');
+        }
         return {
             type: 'function',
-            name: tool.name,
+            name: getSerializedFunctionToolName(tool),
             description: tool.description,
             inputSchema: tool.parameters,
         };
@@ -653,10 +888,13 @@ function toolToLanguageV2Tool(model, tool) {
             type: providerToolType,
             id: `${providerToolPrefix}.${tool.name}`,
             name: tool.name,
-            args: tool.providerData?.args ?? {},
+            args: getHostedToolArgs(tool.providerData),
         };
     }
     if (tool.type === 'computer') {
+        if (!hasComputerDisplayMetadata(tool)) {
+            throw new agents_1.UserError('The AI SDK adapter requires computer tools to include environment and dimensions metadata.');
+        }
         return {
             type: providerToolType,
             id: `${providerToolPrefix}.${tool.name}`,
@@ -709,7 +947,7 @@ function getResponseFormat(outputType) {
  * If tracing is enabled, the model will send generation spans to your traces processor.
  *
  * ```ts
- * import { aisdk } from '@openai/agents-extensions';
+ * import { aisdk } from '@openai/agents-extensions/ai-sdk';
  * import { openai } from '@ai-sdk/openai';
  *
  * const model = aisdk(openai('gpt-4o'));
@@ -732,6 +970,25 @@ class AiSdkModel {
         this.#model = model;
         this.#options = options;
     }
+    getRetryAdvice(args) {
+        const error = args.error;
+        const isRetryable = typeof error?.isRetryable === 'boolean'
+            ? error.isRetryable
+            : undefined;
+        if (isRetryable === false) {
+            return {
+                suggested: false,
+                reason: error instanceof Error ? error.message : undefined,
+            };
+        }
+        if (isRetryable === true) {
+            return {
+                suggested: true,
+                reason: error instanceof Error ? error.message : undefined,
+            };
+        }
+        return undefined;
+    }
     async #transformOutputText(text, request, stream) {
         const transform = this.#options.transformOutputText;
         if (!transform) {
@@ -781,9 +1038,10 @@ class AiSdkModel {
                 if (span && request.tracing === true) {
                     span.spanData.input = input;
                 }
-                if ((0, utils_1.isZodObject)(request.outputType)) {
+                if ((0, utils_2.isZodObject)(request.outputType)) {
                     throw new agents_1.UserError('Zod output type is not yet supported');
                 }
+                const requestedToolsByName = buildRequestedToolsByName(request);
                 const responseFormat = getResponseFormat(request.outputType);
                 const aiSdkRequest = {
                     ...(tools.length ? { tools } : {}),
@@ -823,36 +1081,21 @@ class AiSdkModel {
                 }
                 const toolCalls = resultContent.filter((c) => c && c.type === 'tool-call');
                 const hasToolCalls = toolCalls.length > 0;
-                const toolsNameToToolMap = new Map(request.tools.map((tool) => [tool.name, tool]));
-                for (const handoff of request.handoffs) {
-                    toolsNameToToolMap.set(handoff.toolName, handoff);
-                }
                 for (const toolCall of toolCalls) {
                     const requestedTool = typeof toolCall.toolName === 'string'
-                        ? toolsNameToToolMap.get(toolCall.toolName)
+                        ? requestedToolsByName.get(toolCall.toolName)
                         : undefined;
                     if (!requestedTool && toolCall.toolName) {
                         this.#logger.warn(`Received tool call for unknown tool '${toolCall.toolName}'.`);
                     }
-                    let toolCallArguments;
-                    if (typeof toolCall.input === 'string') {
-                        toolCallArguments =
-                            toolCall.input === '' && expectsObjectArguments(requestedTool)
-                                ? JSON.stringify({})
-                                : toolCall.input;
-                    }
-                    else {
-                        toolCallArguments = JSON.stringify(toolCall.input ?? {});
-                    }
-                    output.push({
-                        type: 'function_call',
-                        callId: toolCall.toolCallId,
-                        name: toolCall.toolName,
-                        arguments: toolCallArguments,
-                        status: 'completed',
+                    output.push(createProtocolToolCallItem({
+                        requestedTool,
+                        toolCallId: toolCall.toolCallId,
+                        toolName: toolCall.toolName,
+                        input: toolCall.input,
                         providerData: mergeProviderData(baseProviderData, toolCall.providerMetadata ??
                             (hasToolCalls ? result.providerMetadata : undefined)),
-                    });
+                    }));
                 }
                 // Some of other platforms may return both tool calls and text.
                 // Putting a text message here will let the agent loop to complete,
@@ -990,6 +1233,7 @@ class AiSdkModel {
                 abortSignal: request.signal,
                 ...(request.modelSettings.providerData ?? {}),
             };
+            const requestedToolsByName = buildRequestedToolsByName(request);
             if (this.#logger.dontLogModelData) {
                 this.#logger.debug('Request received (streamed)');
             }
@@ -1056,14 +1300,16 @@ class AiSdkModel {
                     case 'tool-call': {
                         const toolCallId = part.toolCallId;
                         if (toolCallId) {
-                            functionCalls[toolCallId] = {
-                                type: 'function_call',
-                                callId: toolCallId,
-                                name: part.toolName,
-                                arguments: part.input ?? '',
-                                status: 'completed',
+                            const requestedTool = typeof part.toolName === 'string'
+                                ? requestedToolsByName.get(part.toolName)
+                                : undefined;
+                            functionCalls[toolCallId] = createProtocolToolCallItem({
+                                requestedTool,
+                                toolCallId,
+                                toolName: part.toolName,
+                                input: part.input,
                                 providerData: mergeProviderData(baseProviderData, part.providerMetadata),
-                            };
+                            });
                         }
                         break;
                     }
@@ -1214,7 +1460,7 @@ exports.AiSdkModel = AiSdkModel;
  * If tracing is enabled, the model will send generation spans to your traces processor.
  *
  * ```ts
- * import { aisdk } from '@openai/agents-extensions';
+ * import { aisdk } from '@openai/agents-extensions/ai-sdk';
  * import { openai } from '@ai-sdk/openai';
  *
  * const model = aisdk(openai('gpt-4o'));