@openai/agents-extensions 0.5.4 → 0.7.0

package/dist/ai-sdk/index.mjs

@@ -1,6 +1,12 @@
 import { createGenerationSpan, resetCurrentSpan, setCurrentSpan, Usage, UserError, withGenerationSpan, getLogger, } from '@openai/agents';
-import { isZodObject } from '@openai/agents/utils';
-import { encodeUint8ArrayToBase64 } from '@openai/agents/utils';
+import { getToolSearchProviderCallId, resolveToolSearchCallId, shouldQueuePendingToolSearchCall, takePendingToolSearchCallId, toolQualifiedName, } from '@openai/agents-core/utils';
+import { isZodObject, encodeUint8ArrayToBase64 } from '@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) {
@@ -53,8 +59,13 @@ function parseBase64ImageDataUrl(imageSource) {
  */
 export 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)) {
@@ -83,7 +94,7 @@ export 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') {
@@ -213,10 +224,12 @@ export 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),
                 };
@@ -230,10 +243,11 @@ export 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),
             };
@@ -244,6 +258,93 @@ export 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 = resolveToolSearchCallId(item, () => {
+                    generatedToolSearchCallId += 1;
+                    return `tool_search_${generatedToolSearchCallId}`;
+                });
+                if (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}`;
+                })
+                : 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 UserError('Hosted tool calls are not supported');
         }
@@ -425,6 +526,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 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 = getToolSearchProviderCallId(value);
+    if (explicitCallId) {
+        const pendingIndex = pendingCallIds.indexOf(explicitCallId);
+        if (pendingIndex >= 0) {
+            pendingCallIds.splice(pendingIndex, 1);
+        }
+        return explicitCallId;
+    }
+    return (pendingCallIds.shift() ?? resolveToolSearchCallId(value, generateFallbackId));
+}
+function getToolSearchOutputReplacementKey(item) {
+    const providerCallId = 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
@@ -495,6 +711,12 @@ function convertStructuredOutputsToAiSdkOutput(outputs) {
 function isRecord(value) {
     return typeof value === 'object' && value !== null;
 }
+function getAiSdkToolName(tool) {
+    return toolQualifiedName(tool.name, tool.namespace) ?? tool.name;
+}
+function getSerializedFunctionToolName(tool) {
+    return getAiSdkToolName(tool);
+}
 function getModelIdentifier(model) {
     return `${model.provider}:${model.modelId}`;
 }
@@ -621,6 +843,16 @@ function formatInlineData(data, mediaType) {
     const base64 = typeof data === 'string' ? data : 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.
@@ -630,9 +862,12 @@ function formatInlineData(data, mediaType) {
  */
 export function toolToLanguageV2Tool(model, tool) {
     if (tool.type === 'function') {
+        if (tool.deferLoading) {
+            throw new 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,
         };
@@ -644,10 +879,13 @@ export 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 UserError('The AI SDK adapter requires computer tools to include environment and dimensions metadata.');
+        }
         return {
             type: providerToolType,
             id: `${providerToolPrefix}.${tool.name}`,
@@ -700,7 +938,7 @@ export 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'));
@@ -723,6 +961,25 @@ export 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) {
@@ -775,6 +1032,7 @@ export class AiSdkModel {
                 if (isZodObject(request.outputType)) {
                     throw new UserError('Zod output type is not yet supported');
                 }
+                const requestedToolsByName = buildRequestedToolsByName(request);
                 const responseFormat = getResponseFormat(request.outputType);
                 const aiSdkRequest = {
                     ...(tools.length ? { tools } : {}),
@@ -814,36 +1072,21 @@ export 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,
@@ -981,6 +1224,7 @@ export class AiSdkModel {
                 abortSignal: request.signal,
                 ...(request.modelSettings.providerData ?? {}),
             };
+            const requestedToolsByName = buildRequestedToolsByName(request);
             if (this.#logger.dontLogModelData) {
                 this.#logger.debug('Request received (streamed)');
             }
@@ -1047,14 +1291,16 @@ export 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;
                     }
@@ -1204,7 +1450,7 @@ export class 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'));