@openai/agents-openai 0.5.4 → 0.7.0

package/dist/openaiResponsesModel.mjs

@@ -1,13 +1,114 @@
 import { RequestUsage, Usage, withResponseSpan, createResponseSpan, setCurrentSpan, resetCurrentSpan, UserError, } from '@openai/agents-core';
 import OpenAI from 'openai';
 import logger from "./logger.mjs";
+import { getOpenAIRetryAdvice } from "./retryAdvice.mjs";
 import { z } from 'zod';
 import { HEADERS } from "./defaults.mjs";
 import { ResponsesWebSocketConnection, ResponsesWebSocketInternalError, isWebSocketNotOpenError, shouldWrapNoEventWebSocketError, throwIfAborted, webSocketFrameToText, withAbortSignal, withTimeout, } from "./responsesWebSocketConnection.mjs";
 import { applyHeadersToAccumulator, createHeaderAccumulator, ensureResponsesWebSocketPath, headerAccumulatorToRecord, headerAccumulatorToSDKHeaders, mergeQueryParamsIntoURL, splitResponsesTransportOverrides, } from "./responsesTransportUtils.mjs";
 import { CodeInterpreterStatus, FileSearchStatus, ImageGenerationStatus, WebSearchStatus, } from "./tools.mjs";
-import { camelOrSnakeToSnakeCase } from "./utils/providerData.mjs";
-import { encodeUint8ArrayToBase64 } from '@openai/agents-core/utils';
+import { camelOrSnakeToSnakeCase, getSnakeCasedProviderDataWithoutReservedKeys, } from "./utils/providerData.mjs";
+import { encodeUint8ArrayToBase64, getToolSearchExecution, getToolSearchProviderCallId, } from '@openai/agents-core/utils';
+/**
+ * Tool search outputs are replayed through agents-core protocol items, which use camelCase
+ * field names, while the Responses API wire shape uses snake_case. Keep this codec even with
+ * first-class upstream types because the local protocol still normalizes these payloads.
+ */
+function toOpenAIToolSearchOutputToolPayload(tool, _withinNamespace = false) {
+    if (!tool || typeof tool !== 'object' || Array.isArray(tool)) {
+        return tool;
+    }
+    if (tool.type === 'tool_reference' && typeof tool.functionName === 'string') {
+        return {
+            type: 'tool_reference',
+            function_name: tool.functionName,
+            ...(typeof tool.namespace === 'string'
+                ? { namespace: tool.namespace }
+                : {}),
+        };
+    }
+    if (tool.type === 'namespace' && Array.isArray(tool.tools)) {
+        return {
+            ...tool,
+            tools: tool.tools.map((entry) => toOpenAIToolSearchOutputToolPayload(entry, true)),
+        };
+    }
+    if (tool.type === 'function') {
+        const { deferLoading, ...rest } = tool;
+        return {
+            ...rest,
+            ...(typeof deferLoading === 'boolean'
+                ? { defer_loading: deferLoading }
+                : {}),
+        };
+    }
+    return tool;
+}
+function fromOpenAIToolSearchOutputToolPayload(tool, _withinNamespace = false) {
+    if (!tool || typeof tool !== 'object' || Array.isArray(tool)) {
+        return tool;
+    }
+    if (tool.type === 'tool_reference' &&
+        typeof tool.function_name === 'string') {
+        return {
+            type: 'tool_reference',
+            functionName: tool.function_name,
+            ...(typeof tool.namespace === 'string'
+                ? { namespace: tool.namespace }
+                : {}),
+        };
+    }
+    if (tool.type === 'namespace' && Array.isArray(tool.tools)) {
+        return {
+            ...tool,
+            tools: tool.tools.map((entry) => fromOpenAIToolSearchOutputToolPayload(entry, true)),
+        };
+    }
+    if (tool.type === 'function') {
+        const { defer_loading, ...rest } = tool;
+        return {
+            ...rest,
+            ...(typeof defer_loading === 'boolean'
+                ? { deferLoading: defer_loading }
+                : {}),
+        };
+    }
+    return tool;
+}
+function isNeverSentWebSocketError(error) {
+    if (isWebSocketNotOpenError(error)) {
+        return true;
+    }
+    const errorCause = error instanceof Error
+        ? error.cause
+        : undefined;
+    if (error instanceof ResponsesWebSocketInternalError &&
+        error.code === 'connection_closed_before_opening') {
+        return true;
+    }
+    if (errorCause instanceof ResponsesWebSocketInternalError &&
+        errorCause.code === 'connection_closed_before_opening') {
+        return true;
+    }
+    return false;
+}
+function isAmbiguousWebSocketReplayError(error) {
+    if (error instanceof ResponsesWebSocketInternalError &&
+        error.code === 'connection_closed_before_terminal_response_event') {
+        return true;
+    }
+    const errorCause = error instanceof Error
+        ? error.cause
+        : undefined;
+    return (errorCause instanceof ResponsesWebSocketInternalError &&
+        errorCause.code === 'connection_closed_before_terminal_response_event');
+}
+function hasSerializedComputerDisplayMetadata(tool) {
+    return (typeof tool.environment === 'string' &&
+        Array.isArray(tool.dimensions) &&
+        tool.dimensions.length === 2 &&
+        tool.dimensions.every((value) => typeof value === 'number'));
+}
 const HostedToolChoice = z.enum([
     'file_search',
     'web_search',
@@ -16,12 +117,16 @@ const HostedToolChoice = z.enum([
     'image_generation',
     'mcp',
     // Specialized local tools
-    'computer_use_preview',
     'shell',
     'apply_patch',
 ]);
 const DefaultToolChoice = z.enum(['auto', 'required', 'none']);
-function getToolChoice(toolChoice) {
+const BuiltinComputerToolChoice = z.enum([
+    'computer',
+    'computer_use',
+    'computer_use_preview',
+]);
+function getToolChoice(toolChoice, options) {
     if (typeof toolChoice === 'undefined') {
         return undefined;
     }
@@ -29,12 +134,202 @@ function getToolChoice(toolChoice) {
     if (resultDefaultCheck.success) {
         return resultDefaultCheck.data;
     }
+    const builtinComputerToolChoice = BuiltinComputerToolChoice.safeParse(toolChoice);
+    if (builtinComputerToolChoice.success) {
+        if (hasBuiltinComputerTool(options?.tools) ||
+            options?.allowPromptSuppliedComputerTool === true) {
+            return getBuiltinComputerToolChoice(builtinComputerToolChoice.data, {
+                model: options?.model,
+            });
+        }
+        if (builtinComputerToolChoice.data === 'computer_use_preview') {
+            return { type: 'computer_use_preview' };
+        }
+        return { type: 'function', name: builtinComputerToolChoice.data };
+    }
     const result = HostedToolChoice.safeParse(toolChoice);
     if (result.success) {
         return { type: result.data };
     }
     return { type: 'function', name: toolChoice };
 }
+function normalizeToolSearchStatus(status) {
+    return status === 'in_progress' ||
+        status === 'completed' ||
+        status === 'incomplete'
+        ? status
+        : null;
+}
+function hasBuiltinComputerTool(tools) {
+    return (tools ?? []).some((tool) => tool.type === 'computer' ||
+        tool.type === 'computer_use' ||
+        tool.type === 'computer_use_preview');
+}
+function isPreviewComputerModel(model) {
+    return typeof model === 'string' && model.startsWith('computer-use-preview');
+}
+function shouldUsePreviewComputerTool(options) {
+    if (isPreviewComputerModel(options?.model)) {
+        return true;
+    }
+    if (typeof options?.model === 'string') {
+        return false;
+    }
+    if (options?.toolChoice === 'computer' ||
+        options?.toolChoice === 'computer_use') {
+        return false;
+    }
+    return true;
+}
+function getBuiltinComputerToolChoice(toolChoice, options) {
+    if (shouldUsePreviewComputerTool({
+        model: options?.model,
+        toolChoice,
+    })) {
+        return { type: 'computer_use_preview' };
+    }
+    if (toolChoice === 'computer_use') {
+        return { type: 'computer_use' };
+    }
+    return { type: 'computer' };
+}
+function isBuiltinComputerToolType(type) {
+    return (type === 'computer' ||
+        type === 'computer_use' ||
+        type === 'computer_use_preview');
+}
+function isCompatibleBuiltinComputerToolChoice(toolChoiceType, toolType) {
+    if (!isBuiltinComputerToolType(toolChoiceType)) {
+        return false;
+    }
+    if (toolChoiceType === 'computer_use_preview') {
+        return toolType === 'computer_use_preview';
+    }
+    return toolType === 'computer';
+}
+function isToolChoiceAvailable(toolChoice, tools) {
+    if (toolChoice === 'auto' || toolChoice === 'none') {
+        return true;
+    }
+    if (toolChoice === 'required') {
+        return tools.length > 0;
+    }
+    if (toolChoice.type === 'function') {
+        return hasFunctionToolChoiceName(toolChoice.name, tools);
+    }
+    return tools.some((tool) => isCompatibleBuiltinComputerToolChoice(toolChoice.type, tool.type)
+        ? true
+        : tool.type === toolChoice.type);
+}
+function hasFunctionToolChoiceName(toolChoiceName, tools, namespacePrefix) {
+    return (findFunctionToolChoice(toolChoiceName, tools, namespacePrefix) !== undefined);
+}
+function findFunctionToolChoice(toolChoiceName, tools, namespacePrefix) {
+    for (const tool of tools) {
+        if (isNamedFunctionTool(tool)) {
+            const qualifiedName = namespacePrefix
+                ? `${namespacePrefix}.${tool.name}`
+                : tool.name;
+            if (toolChoiceName === qualifiedName) {
+                return tool;
+            }
+            continue;
+        }
+        if (isNamespaceTool(tool)) {
+            const nestedNamespace = namespacePrefix
+                ? `${namespacePrefix}.${tool.name}`
+                : tool.name;
+            const matchedTool = findFunctionToolChoice(toolChoiceName, tool.tools, nestedNamespace);
+            if (matchedTool) {
+                return matchedTool;
+            }
+        }
+    }
+    return undefined;
+}
+function collectAvailableToolChoiceNames(tools, namespacePrefix) {
+    const availableToolChoices = [];
+    for (const tool of tools) {
+        if (isNamedFunctionTool(tool)) {
+            availableToolChoices.push(namespacePrefix ? `${namespacePrefix}.${tool.name}` : tool.name);
+            continue;
+        }
+        if (isNamespaceTool(tool)) {
+            const nestedNamespace = namespacePrefix
+                ? `${namespacePrefix}.${tool.name}`
+                : tool.name;
+            availableToolChoices.push(...collectAvailableToolChoiceNames(tool.tools, nestedNamespace));
+            continue;
+        }
+        availableToolChoices.push(tool.type);
+    }
+    return availableToolChoices;
+}
+function isNamedFunctionTool(tool) {
+    return (tool.type === 'function' &&
+        typeof tool.name === 'string');
+}
+function isNamespaceTool(tool) {
+    const candidate = tool;
+    return (tool.type === 'namespace' &&
+        typeof candidate.name === 'string' &&
+        Array.isArray(candidate.tools));
+}
+function getExtraBodyToolsForToolChoiceValidation(extraBody) {
+    if (!extraBody || !Array.isArray(extraBody.tools)) {
+        return [];
+    }
+    return extraBody.tools;
+}
+function assertSupportedToolChoice(toolChoice, tools, options) {
+    const allowPromptSuppliedTools = options?.allowPromptSuppliedTools === true;
+    if (!toolChoice ||
+        toolChoice === 'auto' ||
+        toolChoice === 'required' ||
+        toolChoice === 'none' ||
+        toolChoice.type !== 'function') {
+        return;
+    }
+    const matchedFunctionTool = findFunctionToolChoice(toolChoice.name, tools);
+    if (!matchedFunctionTool &&
+        allowPromptSuppliedTools &&
+        toolChoice.name !== 'tool_search') {
+        return;
+    }
+    if (matchedFunctionTool
+        ?.defer_loading === true) {
+        throw new UserError(`modelSettings.toolChoice="${toolChoice.name}" cannot force a deferred function tool in Responses. Use "auto" so tool_search can load it.`);
+    }
+    if (toolChoice.name === 'tool_search' &&
+        !hasFunctionToolChoiceName(toolChoice.name, tools)) {
+        throw new UserError('modelSettings.toolChoice="tool_search" is only supported for a custom function named "tool_search". Responses does not support forcing the built-in tool_search tool. Use "auto" instead.');
+    }
+}
+function getCompatibleToolChoice(toolChoice, tools, options) {
+    const allowPromptSuppliedTools = options?.allowPromptSuppliedTools === true;
+    if (typeof toolChoice === 'undefined') {
+        return undefined;
+    }
+    if (isToolChoiceAvailable(toolChoice, tools) || allowPromptSuppliedTools) {
+        return toolChoice;
+    }
+    const availableToolChoices = [
+        ...new Set(collectAvailableToolChoiceNames(tools)),
+    ];
+    const availableToolChoicesMessage = availableToolChoices.length > 0
+        ? ` Available tools: ${availableToolChoices.join(', ')}.`
+        : ' No tools are available in the outgoing Responses request.';
+    if (toolChoice === 'required') {
+        throw new UserError(`modelSettings.toolChoice="required" requires at least one available tool in the outgoing Responses request.${availableToolChoicesMessage}`);
+    }
+    if (toolChoice === 'auto' || toolChoice === 'none') {
+        throw new Error(`Unexpected unavailable tool choice: ${JSON.stringify(toolChoice)}`);
+    }
+    if (toolChoice.type === 'function') {
+        throw new UserError(`modelSettings.toolChoice="${toolChoice.name}" does not match any available tool in the outgoing Responses request.${availableToolChoicesMessage}`);
+    }
+    throw new UserError(`modelSettings.toolChoice="${toolChoice.type}" is unavailable in the outgoing Responses request.${availableToolChoicesMessage}`);
+}
 function getResponseFormat(outputType, otherProperties) {
     if (outputType === 'text') {
         return otherProperties;
@@ -88,12 +383,13 @@ function convertLegacyToolOutputContent(output) {
         const legacyImageUrl = output.imageUrl;
         const legacyFileId = output.fileId;
         const dataValue = output.data;
+        const topLevelInlineMediaType = getImageInlineMediaType(output);
         if (typeof output.image === 'string' && output.image.length > 0) {
             structured.image = output.image;
         }
         else if (isRecord(output.image)) {
             const imageObj = output.image;
-            const inlineMediaType = getImageInlineMediaType(imageObj);
+            const inlineMediaType = getImageInlineMediaType(imageObj) ?? topLevelInlineMediaType;
             if (typeof imageObj.url === 'string' && imageObj.url.length > 0) {
                 structured.image = imageObj.url;
             }
@@ -133,7 +429,7 @@ function convertLegacyToolOutputContent(output) {
                 base64Data = encodeUint8ArrayToBase64(dataValue);
             }
             if (base64Data) {
-                structured.image = base64Data;
+                structured.image = formatInlineData(base64Data, topLevelInlineMediaType);
             }
         }
         if (output.providerData) {
@@ -378,9 +674,16 @@ function getImageInlineMediaType(source) {
     if (typeof source.mediaType === 'string' && source.mediaType.length > 0) {
         return source.mediaType;
     }
+    if (typeof source.mimeType === 'string' &&
+        source.mimeType.length > 0) {
+        return source.mimeType;
+    }
     return undefined;
 }
 function formatInlineData(data, mediaType) {
+    if (typeof data === 'string' && data.startsWith('data:')) {
+        return data;
+    }
     const base64 = typeof data === 'string' ? data : encodeUint8ArrayToBase64(data);
     return mediaType ? `data:${mediaType};base64,${base64}` : base64;
 }
@@ -497,11 +800,70 @@ function toOpenAIShellEnvironment(environment) {
     }
     throw new UserError(`Unsupported shell environment type: ${String(environment.type)}`);
 }
-function getTools(tools, handoffs) {
+function getTools(tools, handoffs, options) {
     const openaiTools = [];
     const include = [];
+    const namespaceStateByName = new Map();
+    let hasDeferredSearchableTool = false;
+    let hasToolSearch = false;
+    const usePreviewComputerTool = shouldUsePreviewComputerTool({
+        model: options?.model,
+        toolChoice: options?.toolChoice,
+    });
     for (const tool of tools) {
-        const { tool: openaiTool, include: openaiIncludes } = converTool(tool);
+        if (tool.type === 'function') {
+            const isDeferredFunction = tool.deferLoading === true;
+            hasDeferredSearchableTool ||= isDeferredFunction;
+            const namespaceName = typeof tool.namespace === 'string' ? tool.namespace.trim() : '';
+            if (namespaceName.length > 0) {
+                const namespaceDescription = typeof tool.namespaceDescription === 'string'
+                    ? tool.namespaceDescription.trim()
+                    : '';
+                if (namespaceDescription.length === 0) {
+                    throw new UserError(`All tools in namespace "${namespaceName}" must provide a non-empty description.`);
+                }
+                let namespaceState = namespaceStateByName.get(namespaceName);
+                if (!namespaceState) {
+                    namespaceState = {
+                        index: openaiTools.length,
+                        description: namespaceDescription,
+                        functionNames: new Set(),
+                        tools: [],
+                    };
+                    namespaceStateByName.set(namespaceName, namespaceState);
+                    openaiTools.push({});
+                }
+                else if (namespaceState.description !== namespaceDescription) {
+                    throw new UserError(`All tools in namespace "${namespaceName}" must share the same description.`);
+                }
+                const { tool: openaiTool, include: openaiIncludes } = converTool(tool, {
+                    usePreviewComputerTool,
+                });
+                if (namespaceState.functionNames.has(tool.name)) {
+                    throw new UserError(`Namespace "${namespaceName}" cannot contain duplicate function tool name "${tool.name}".`);
+                }
+                namespaceState.functionNames.add(tool.name);
+                namespaceState.tools.push(openaiTool);
+                if (openaiIncludes && openaiIncludes.length > 0) {
+                    for (const item of openaiIncludes) {
+                        include.push(item);
+                    }
+                }
+                continue;
+            }
+        }
+        if (tool.type === 'hosted_tool' &&
+            tool.providerData?.type === 'tool_search') {
+            hasToolSearch = true;
+        }
+        if (tool.type === 'hosted_tool' &&
+            tool.providerData?.type === 'mcp' &&
+            tool.providerData.defer_loading === true) {
+            hasDeferredSearchableTool = true;
+        }
+        const { tool: openaiTool, include: openaiIncludes } = converTool(tool, {
+            usePreviewComputerTool,
+        });
         openaiTools.push(openaiTool);
         if (openaiIncludes && openaiIncludes.length > 0) {
             for (const item of openaiIncludes) {
@@ -509,31 +871,57 @@ function getTools(tools, handoffs) {
             }
         }
     }
+    if (hasDeferredSearchableTool && !hasToolSearch) {
+        throw new UserError('Deferred function tools and hosted MCP tools with deferLoading: true require toolSearchTool() in the same request.');
+    }
+    for (const [namespaceName, namespaceState,] of namespaceStateByName.entries()) {
+        openaiTools[namespaceState.index] = {
+            type: 'namespace',
+            name: namespaceName,
+            description: namespaceState.description,
+            tools: namespaceState.tools,
+        };
+    }
     return {
         tools: [...openaiTools, ...handoffs.map(getHandoffTool)],
         include,
     };
 }
-function converTool(tool) {
+function converTool(tool, options) {
     if (tool.type === 'function') {
+        const openaiTool = {
+            type: 'function',
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters,
+            strict: tool.strict,
+        };
+        if (tool.deferLoading) {
+            openaiTool.defer_loading = true;
+        }
         return {
-            tool: {
-                type: 'function',
-                name: tool.name,
-                description: tool.description,
-                parameters: tool.parameters,
-                strict: tool.strict,
-            },
+            tool: openaiTool,
             include: undefined,
         };
     }
     else if (tool.type === 'computer') {
+        if (options?.usePreviewComputerTool) {
+            if (!hasSerializedComputerDisplayMetadata(tool)) {
+                throw new UserError('Preview computer tools require environment and dimensions. Provide them on your Computer implementation or target a GA computer model such as gpt-5.4.');
+            }
+            return {
+                tool: {
+                    type: 'computer_use_preview',
+                    environment: tool.environment,
+                    display_width: tool.dimensions[0],
+                    display_height: tool.dimensions[1],
+                },
+                include: undefined,
+            };
+        }
         return {
             tool: {
-                type: 'computer_use_preview',
-                environment: tool.environment,
-                display_width: tool.dimensions[0],
-                display_height: tool.dimensions[1],
+                type: 'computer',
             },
             include: undefined,
         };
@@ -604,6 +992,17 @@ function converTool(tool) {
                 include: undefined,
             };
         }
+        else if (tool.providerData?.type === 'tool_search') {
+            return {
+                tool: {
+                    type: 'tool_search',
+                    execution: tool.providerData.execution,
+                    description: tool.providerData.description,
+                    parameters: tool.providerData.parameters,
+                },
+                include: undefined,
+            };
+        }
         else if (tool.providerData?.type === 'image_generation') {
             return {
                 tool: {
@@ -623,17 +1022,22 @@ function converTool(tool) {
             };
         }
         else if (tool.providerData?.type === 'mcp') {
+            const openaiTool = {
+                type: 'mcp',
+                server_label: tool.providerData.server_label,
+                server_url: tool.providerData.server_url,
+                connector_id: tool.providerData.connector_id,
+                authorization: tool.providerData.authorization,
+                allowed_tools: tool.providerData.allowed_tools,
+                headers: tool.providerData.headers,
+                require_approval: convertMCPRequireApproval(tool.providerData.require_approval),
+                server_description: tool.providerData.server_description,
+            };
+            if (tool.providerData.defer_loading === true) {
+                openaiTool.defer_loading = true;
+            }
             return {
-                tool: {
-                    type: 'mcp',
-                    server_label: tool.providerData.server_label,
-                    server_url: tool.providerData.server_url,
-                    connector_id: tool.providerData.connector_id,
-                    authorization: tool.providerData.authorization,
-                    allowed_tools: tool.providerData.allowed_tools,
-                    headers: tool.providerData.headers,
-                    require_approval: convertMCPRequireApproval(tool.providerData.require_approval),
-                },
+                tool: openaiTool,
                 include: undefined,
             };
         }
@@ -672,7 +1076,10 @@ function getInputMessageContent(entry) {
         return {
             type: 'input_text',
             text: entry.text,
-            ...camelOrSnakeToSnakeCase(entry.providerData),
+            ...getSnakeCasedProviderDataWithoutReservedKeys(entry.providerData, [
+                'type',
+                'text',
+            ]),
         };
     }
     else if (entry.type === 'input_image') {
@@ -694,7 +1101,12 @@ function getInputMessageContent(entry) {
         }
         return {
             ...imageEntry,
-            ...camelOrSnakeToSnakeCase(entry.providerData),
+            ...getSnakeCasedProviderDataWithoutReservedKeys(entry.providerData, [
+                'type',
+                'detail',
+                'image_url',
+                'file_id',
+            ]),
         };
     }
     else if (entry.type === 'input_file') {
@@ -739,25 +1151,54 @@ function getInputMessageContent(entry) {
         }
         return {
             ...fileEntry,
-            ...camelOrSnakeToSnakeCase(entry.providerData),
+            ...getSnakeCasedProviderDataWithoutReservedKeys(entry.providerData, [
+                'type',
+                'file_data',
+                'file_url',
+                'file_id',
+                'filename',
+            ]),
         };
     }
     throw new UserError(`Unsupported input content type: ${JSON.stringify(entry)}`);
 }
+function getProviderDataField(providerData, keys) {
+    if (!providerData ||
+        typeof providerData !== 'object' ||
+        Array.isArray(providerData)) {
+        return undefined;
+    }
+    const record = providerData;
+    for (const key of keys) {
+        if (typeof record[key] !== 'undefined') {
+            return record[key];
+        }
+    }
+    return undefined;
+}
 function getOutputMessageContent(entry) {
     if (entry.type === 'output_text') {
+        const annotations = getProviderDataField(entry.providerData, ['annotations']);
+        const normalizedAnnotations = Array.isArray(annotations) ? annotations : [];
         return {
             type: 'output_text',
             text: entry.text,
-            annotations: [],
-            ...camelOrSnakeToSnakeCase(entry.providerData),
+            annotations: normalizedAnnotations,
+            ...getSnakeCasedProviderDataWithoutReservedKeys(entry.providerData, [
+                'type',
+                'text',
+                'annotations',
+            ]),
         };
     }
     if (entry.type === 'refusal') {
         return {
             type: 'refusal',
             refusal: entry.refusal,
-            ...camelOrSnakeToSnakeCase(entry.providerData),
+            ...getSnakeCasedProviderDataWithoutReservedKeys(entry.providerData, [
+                'type',
+                'refusal',
+            ]),
         };
     }
     throw new UserError(`Unsupported output content type: ${JSON.stringify(entry)}`);
@@ -768,7 +1209,11 @@ function getMessageItem(item) {
             id: item.id,
             role: 'system',
             content: item.content,
-            ...camelOrSnakeToSnakeCase(item.providerData),
+            ...getSnakeCasedProviderDataWithoutReservedKeys(item.providerData, [
+                'id',
+                'role',
+                'content',
+            ]),
         };
     }
     if (item.role === 'user') {
@@ -777,14 +1222,22 @@ function getMessageItem(item) {
                 id: item.id,
                 role: 'user',
                 content: item.content,
-                ...camelOrSnakeToSnakeCase(item.providerData),
+                ...getSnakeCasedProviderDataWithoutReservedKeys(item.providerData, [
+                    'id',
+                    'role',
+                    'content',
+                ]),
             };
         }
         return {
             id: item.id,
             role: 'user',
             content: item.content.map(getInputMessageContent),
-            ...camelOrSnakeToSnakeCase(item.providerData),
+            ...getSnakeCasedProviderDataWithoutReservedKeys(item.providerData, [
+                'id',
+                'role',
+                'content',
+            ]),
         };
     }
     if (item.role === 'assistant') {
@@ -794,7 +1247,13 @@ function getMessageItem(item) {
             role: 'assistant',
             content: item.content.map(getOutputMessageContent),
             status: item.status,
-            ...camelOrSnakeToSnakeCase(item.providerData),
+            ...getSnakeCasedProviderDataWithoutReservedKeys(item.providerData, [
+                'type',
+                'id',
+                'role',
+                'content',
+                'status',
+            ]),
         };
         return assistantMessage;
     }
@@ -841,6 +1300,52 @@ function getInputItems(input) {
         if (isMessageItem(item)) {
             return getMessageItem(item);
         }
+        if (item.type === 'tool_search_call') {
+            const status = normalizeToolSearchStatus(item.status);
+            const callId = getToolSearchProviderCallId(item);
+            const execution = getToolSearchExecution(item);
+            const toolSearchCall = {
+                type: 'tool_search_call',
+                id: item.id,
+                ...(status !== null ? { status } : {}),
+                arguments: item.arguments,
+                ...(callId ? { call_id: callId } : {}),
+                ...(execution ? { execution } : {}),
+                ...getSnakeCasedProviderDataWithoutReservedKeys(item.providerData, [
+                    'type',
+                    'id',
+                    'status',
+                    'arguments',
+                    'call_id',
+                    'callId',
+                    'execution',
+                ]),
+            };
+            return toolSearchCall;
+        }
+        if (item.type === 'tool_search_output') {
+            const status = normalizeToolSearchStatus(item.status);
+            const callId = getToolSearchProviderCallId(item);
+            const execution = getToolSearchExecution(item);
+            const toolSearchOutput = {
+                type: 'tool_search_output',
+                id: item.id,
+                ...(status !== null ? { status } : {}),
+                tools: item.tools.map((tool) => toOpenAIToolSearchOutputToolPayload(tool)),
+                ...(callId ? { call_id: callId } : {}),
+                ...(execution ? { execution } : {}),
+                ...getSnakeCasedProviderDataWithoutReservedKeys(item.providerData, [
+                    'type',
+                    'id',
+                    'status',
+                    'tools',
+                    'call_id',
+                    'callId',
+                    'execution',
+                ]),
+            };
+            return toolSearchOutput;
+        }
         if (item.type === 'function_call') {
             const entry = {
                 id: item.id,
@@ -849,7 +1354,18 @@ function getInputItems(input) {
                 call_id: item.callId,
                 arguments: item.arguments,
                 status: item.status,
-                ...camelOrSnakeToSnakeCase(item.providerData),
+                ...(typeof item.namespace === 'string'
+                    ? { namespace: item.namespace }
+                    : {}),
+                ...getSnakeCasedProviderDataWithoutReservedKeys(item.providerData, [
+                    'id',
+                    'type',
+                    'name',
+                    'call_id',
+                    'arguments',
+                    'status',
+                    'namespace',
+                ]),
             };
             return entry;
         }
@@ -861,45 +1377,98 @@ function getInputItems(input) {
                 call_id: item.callId,
                 output: normalizedOutput,
                 status: item.status,
-                ...camelOrSnakeToSnakeCase(item.providerData),
+                ...getSnakeCasedProviderDataWithoutReservedKeys(item.providerData, [
+                    'type',
+                    'id',
+                    'call_id',
+                    'output',
+                    'status',
+                    'namespace',
+                ]),
             };
             return entry;
         }
         if (item.type === 'reasoning') {
+            const encryptedContent = getProviderDataField(item.providerData, [
+                'encryptedContent',
+                'encrypted_content',
+            ]);
             const entry = {
                 id: item.id,
                 type: 'reasoning',
                 summary: item.content.map((content) => ({
                     type: 'summary_text',
                     text: content.text,
-                    ...camelOrSnakeToSnakeCase(content.providerData),
+                    ...getSnakeCasedProviderDataWithoutReservedKeys(content.providerData, ['type', 'text']),
                 })),
-                encrypted_content: item.providerData?.encryptedContent,
-                ...camelOrSnakeToSnakeCase(item.providerData),
+                ...(typeof encryptedContent === 'string'
+                    ? { encrypted_content: encryptedContent }
+                    : {}),
+                ...getSnakeCasedProviderDataWithoutReservedKeys(item.providerData, [
+                    'id',
+                    'type',
+                    'summary',
+                    'encrypted_content',
+                ]),
             };
             return entry;
         }
         if (item.type === 'computer_call') {
+            const pendingSafetyChecks = getProviderDataField(item.providerData, ['pendingSafetyChecks', 'pending_safety_checks']);
+            const normalizedPendingSafetyChecks = Array.isArray(pendingSafetyChecks) ? pendingSafetyChecks : [];
+            const batchedActions = Array.isArray(item.actions)
+                ? (item
+                    .actions ?? [])
+                : [];
+            const actionPayload = batchedActions.length > 0
+                ? {
+                    action: item.action ?? batchedActions[0],
+                    actions: batchedActions,
+                }
+                : item.action
+                    ? { action: item.action }
+                    : {};
             const entry = {
                 type: 'computer_call',
                 call_id: item.callId,
                 id: item.id,
-                action: item.action,
                 status: item.status,
-                pending_safety_checks: [],
-                ...camelOrSnakeToSnakeCase(item.providerData),
+                pending_safety_checks: normalizedPendingSafetyChecks,
+                ...actionPayload,
+                ...getSnakeCasedProviderDataWithoutReservedKeys(item.providerData, [
+                    'type',
+                    'call_id',
+                    'id',
+                    'action',
+                    'actions',
+                    'status',
+                    'pending_safety_checks',
+                ]),
             };
             return entry;
         }
         if (item.type === 'computer_call_result') {
+            const acknowledgedSafetyChecks = getProviderDataField(item.providerData, [
+                'acknowledgedSafetyChecks',
+                'acknowledged_safety_checks',
+            ]);
             const entry = {
                 type: 'computer_call_output',
                 id: item.id,
                 call_id: item.callId,
                 output: buildResponseOutput(item),
                 status: item.providerData?.status,
-                acknowledged_safety_checks: item.providerData?.acknowledgedSafetyChecks,
-                ...camelOrSnakeToSnakeCase(item.providerData),
+                acknowledged_safety_checks: Array.isArray(acknowledgedSafetyChecks)
+                    ? acknowledgedSafetyChecks
+                    : [],
+                ...getSnakeCasedProviderDataWithoutReservedKeys(item.providerData, [
+                    'type',
+                    'id',
+                    'call_id',
+                    'output',
+                    'status',
+                    'acknowledged_safety_checks',
+                ]),
             };
             return entry;
         }
@@ -1152,6 +1721,30 @@ function convertToOutputItem(items) {
                 providerData,
             };
         }
+        else if (item.type === 'tool_search_call') {
+            const { id, type: _type, status, arguments: args, ...providerData } = item;
+            const output = {
+                type: 'tool_search_call',
+                id,
+                status,
+                arguments: args,
+                providerData,
+            };
+            return output;
+        }
+        else if (item.type === 'tool_search_output') {
+            const { id, type: _type, status, tools, ...providerData } = item;
+            const output = {
+                type: 'tool_search_output',
+                id,
+                status,
+                tools: Array.isArray(tools)
+                    ? tools.map((tool) => fromOpenAIToolSearchOutputToolPayload(tool))
+                    : [],
+                providerData,
+            };
+            return output;
+        }
         else if (item.type === 'file_search_call' ||
             item.type === 'web_search_call' ||
             item.type === 'image_generation_call' ||
@@ -1174,12 +1767,14 @@ function convertToOutputItem(items) {
             return output;
         }
         else if (item.type === 'function_call') {
-            const { call_id, name, status, arguments: args, ...providerData } = item;
+            const functionCall = item;
+            const { call_id, name, namespace, status, arguments: args, ...providerData } = functionCall;
             const output = {
                 type: 'function_call',
-                id: item.id,
+                id: functionCall.id,
                 callId: call_id,
                 name,
+                ...(typeof namespace === 'string' ? { namespace } : {}),
                 status,
                 arguments: args,
                 providerData,
@@ -1187,12 +1782,13 @@ function convertToOutputItem(items) {
             return output;
         }
         else if (item.type === 'function_call_output') {
-            const { call_id, status, output: rawOutput, name: toolName, function_name: functionName, ...providerData } = item;
+            const { call_id, status, output: rawOutput, name: toolName, function_name: functionName, namespace, ...providerData } = item;
             const output = {
                 type: 'function_call_result',
                 id: item.id,
                 callId: call_id,
                 name: toolName ?? functionName ?? call_id,
+                ...(typeof namespace === 'string' ? { namespace } : {}),
                 status: status ?? 'completed',
                 output: convertFunctionCallOutputToProtocol(rawOutput),
                 providerData,
@@ -1200,13 +1796,18 @@ function convertToOutputItem(items) {
             return output;
         }
         else if (item.type === 'computer_call') {
-            const { call_id, status, action, ...providerData } = item;
+            const { call_id, status, action, actions, ...providerData } = item;
+            const normalizedActions = Array.isArray(actions) && actions.length > 0 ? actions : undefined;
+            if (!normalizedActions && !action) {
+                throw new UserError(`Unsupported computer call item without an action or actions: ${JSON.stringify(item)}`);
+            }
             const output = {
                 type: 'computer_call',
                 id: item.id,
                 callId: call_id,
                 status,
-                action,
+                action: action ?? normalizedActions?.[0],
+                ...(normalizedActions ? { actions: normalizedActions } : {}),
                 providerData,
             };
             return output;
@@ -1451,15 +2052,22 @@ export class OpenAIResponsesModel {
         this._client = client;
         this._model = model;
     }
+    getRetryAdvice(args) {
+        return getOpenAIRetryAdvice(args);
+    }
     async _fetchResponse(request, stream) {
         const builtRequest = this._buildResponsesCreateRequest(request, stream);
-        const responsePromise = this._client.responses.create(builtRequest.requestData, {
+        const requestOptions = {
             headers: builtRequest.sdkRequestHeaders,
             signal: builtRequest.signal,
             ...(builtRequest.transportExtraQuery
                 ? { query: builtRequest.transportExtraQuery }
                 : {}),
-        });
+        };
+        if (request._internal?.runnerManagedRetry === true) {
+            requestOptions.maxRetries = 0;
+        }
+        const responsePromise = this._client.responses.create(builtRequest.requestData, requestOptions);
         let response;
         if (stream) {
             const withResponse = responsePromise
@@ -1486,9 +2094,30 @@ export class OpenAIResponsesModel {
     }
     _buildResponsesCreateRequest(request, stream) {
         const input = getInputItems(request.input);
-        const { tools, include } = getTools(request.tools, request.handoffs);
-        const toolChoice = getToolChoice(request.modelSettings.toolChoice);
+        const prompt = getPrompt(request.prompt);
+        // When a prompt template already declares a model, skip sending the agent's default model.
+        // If the caller explicitly requests an override, include the resolved model name in the request.
+        const shouldSendModel = !request.prompt || request.overridePromptModel === true;
+        const effectiveRequestModel = shouldSendModel ? this._model : undefined;
         const { providerData: providerDataWithoutTransport, overrides: transportOverrides, } = splitResponsesTransportOverrides(request.modelSettings.providerData);
+        const { tools, include } = getTools(request.tools, request.handoffs, {
+            model: effectiveRequestModel,
+            toolChoice: request.modelSettings.toolChoice,
+        });
+        const toolChoiceValidationTools = [
+            ...tools,
+            ...getExtraBodyToolsForToolChoiceValidation(transportOverrides.extraBody),
+        ];
+        const allowPromptSuppliedTools = Boolean(request.prompt) &&
+            !(request.toolsExplicitlyProvided === true && tools.length === 0);
+        const toolChoice = getToolChoice(request.modelSettings.toolChoice, {
+            tools: toolChoiceValidationTools,
+            model: effectiveRequestModel,
+            allowPromptSuppliedComputerTool: allowPromptSuppliedTools,
+        });
+        assertSupportedToolChoice(toolChoice, toolChoiceValidationTools, {
+            allowPromptSuppliedTools,
+        });
         const { text, ...restOfProviderData } = providerDataWithoutTransport;
         if (request.modelSettings.reasoning) {
             // Merge top-level reasoning settings with provider data.
@@ -1503,25 +2132,19 @@ export class OpenAIResponsesModel {
             mergedText = { ...request.modelSettings.text, ...text };
         }
         const responseFormat = getResponseFormat(request.outputType, mergedText);
-        const prompt = getPrompt(request.prompt);
         let parallelToolCalls = undefined;
         if (typeof request.modelSettings.parallelToolCalls === 'boolean') {
-            if (request.modelSettings.parallelToolCalls && tools.length === 0) {
-                throw new Error('Parallel tool calls are not supported without tools');
-            }
             parallelToolCalls = request.modelSettings.parallelToolCalls;
         }
-        // When a prompt template already declares a model, skip sending the agent's default model.
-        // If the caller explicitly requests an override, include the resolved model name in the request.
-        const shouldSendModel = !request.prompt || request.overridePromptModel === true;
         const shouldSendTools = tools.length > 0 ||
             request.toolsExplicitlyProvided === true ||
             !request.prompt;
-        const shouldOmitToolChoice = Boolean(request.prompt) &&
-            !shouldSendTools &&
-            typeof toolChoice === 'object';
+        const compatibleToolChoice = getCompatibleToolChoice(toolChoice, toolChoiceValidationTools, {
+            allowPromptSuppliedTools,
+        });
+        const shouldOmitToolChoice = typeof compatibleToolChoice === 'undefined';
         let requestData = {
-            ...(shouldSendModel ? { model: this._model } : {}),
+            ...(effectiveRequestModel ? { model: effectiveRequestModel } : {}),
             instructions: normalizeInstructions(request.systemInstructions),
             input,
             include,
@@ -1538,7 +2161,7 @@ export class OpenAIResponsesModel {
             truncation: request.modelSettings.truncation,
             max_output_tokens: request.modelSettings.maxTokens,
             ...(!shouldOmitToolChoice
-                ? { tool_choice: toolChoice }
+                ? { tool_choice: compatibleToolChoice }
                 : {}),
             parallel_tool_calls: parallelToolCalls,
             stream,
@@ -1729,6 +2352,23 @@ export class OpenAIResponsesWSModel extends OpenAIResponsesModel {
         this.#websocketBaseURL = options.websocketBaseURL;
         this.#reuseConnection = options.reuseConnection ?? true;
     }
+    getRetryAdvice(args) {
+        if (isNeverSentWebSocketError(args.error)) {
+            return {
+                suggested: true,
+                replaySafety: 'safe',
+                reason: args.error instanceof Error ? args.error.message : undefined,
+            };
+        }
+        if (isAmbiguousWebSocketReplayError(args.error)) {
+            return {
+                suggested: false,
+                replaySafety: 'unsafe',
+                reason: args.error instanceof Error ? args.error.message : undefined,
+            };
+        }
+        return super.getRetryAdvice(args);
+    }
     async _fetchResponse(request, stream) {
         // The websocket transport always uses streamed Responses events, then callers either
         // consume the stream directly or collapse it into the final terminal response.
@@ -1737,12 +2377,22 @@ export class OpenAIResponsesWSModel extends OpenAIResponsesModel {
             return this.#iterWebSocketResponseEvents(builtRequest);
         }
         let finalResponse;
-        for await (const event of this.#iterWebSocketResponseEvents(builtRequest)) {
-            const eventType = event.type;
-            if (isTerminalResponsesStreamEventType(eventType)) {
-                finalResponse = event
-                    .response;
+        let receivedAnyEvent = false;
+        try {
+            for await (const event of this.#iterWebSocketResponseEvents(builtRequest)) {
+                receivedAnyEvent = true;
+                const eventType = event.type;
+                if (isTerminalResponsesStreamEventType(eventType)) {
+                    finalResponse = event
+                        .response;
+                }
+            }
+        }
+        catch (error) {
+            if (receivedAnyEvent && error instanceof Error) {
+                error.unsafeToReplay = true;
             }
+            throw error;
         }
         if (!finalResponse) {
             throw new Error('Responses websocket stream ended without a terminal response event.');