@zhivex-ai/openai 0.7.2 → 0.8.0

package/dist/index.js

@@ -1,6 +1,11 @@
 import { toJSONSchema, z } from "zod";
 import { CallbackRealtimeSession, ConfigurationError, ProviderHTTPError, openWebSocketConnection, hostedTool, providerDataPart, UnsupportedFeatureError, createProviderAdapter, encodeAudioFrame, encodeMediaFrame, isCallableToolDefinition, isHostedToolDefinition, normalizeFinishReason, streamSSE, toToolSet, toolResultPayload, withRetry, withTimeoutSignal } from "@zhivex-ai/core";
 const openAIResponsesToolMetadataKey = "openai.responses_tool_type";
+const openAIResponsesFunctionConfigMetadataKey = "openai.responses_function_config";
+const openAIResponsesFunctionConfig = (tool) => {
+    const config = tool.metadata?.[openAIResponsesFunctionConfigMetadataKey];
+    return config && typeof config === "object" && !Array.isArray(config) ? config : undefined;
+};
 const openAILocalResponsesToolType = (tool) => {
     const type = tool.metadata?.[openAIResponsesToolMetadataKey];
     return typeof type === "string" ? type : undefined;
@@ -53,30 +58,51 @@ const capabilities = {
     }
 };
 const normalizeModelId = (modelId) => modelId.trim().toLowerCase();
-const supportsOpenAIToolSearch = (modelId) => {
-    const normalized = normalizeModelId(modelId);
-    return /^gpt-5\.4(?:$|-20|-pro)/.test(normalized);
-};
-const supportsOpenAIComputerUse = (modelId) => {
-    const normalized = normalizeModelId(modelId);
-    return /^(?:gpt-5\.5|gpt-5\.4)(?:$|-20|-pro|-mini)/.test(normalized);
-};
-const supportsOpenAIHostedHarnessTools = (modelId) => /^gpt-5\.4(?:$|-)/.test(normalizeModelId(modelId));
+const isOpenAIGpt56Model = (modelId) => /^gpt-5\.6(?:$|-(?:sol|terra|luna)(?:-|$)|-\d{4}-\d{2}-\d{2})/.test(normalizeModelId(modelId));
+const isOpenAIGpt55BaseModel = (modelId) => /^gpt-5\.5(?:$|-\d{4}-\d{2}-\d{2})/.test(normalizeModelId(modelId));
+const isOpenAIGpt55ProModel = (modelId) => /^gpt-5\.5-pro(?:$|-\d{4}-\d{2}-\d{2})/.test(normalizeModelId(modelId));
+const isOpenAIGpt54BaseModel = (modelId) => /^gpt-5\.4(?:$|-\d{4}-\d{2}-\d{2})/.test(normalizeModelId(modelId));
+const isOpenAIGpt54MiniModel = (modelId) => /^gpt-5\.4-mini(?:$|-\d{4}-\d{2}-\d{2})/.test(normalizeModelId(modelId));
+const isOpenAIGpt54NanoModel = (modelId) => /^gpt-5\.4-nano(?:$|-\d{4}-\d{2}-\d{2})/.test(normalizeModelId(modelId));
+const isOpenAIGpt54ProModel = (modelId) => /^gpt-5\.4-pro(?:$|-\d{4}-\d{2}-\d{2})/.test(normalizeModelId(modelId));
+const supportsOpenAIToolSearch = (modelId) => isOpenAIGpt56Model(modelId) || isOpenAIGpt55BaseModel(modelId) || isOpenAIGpt54BaseModel(modelId) || isOpenAIGpt54MiniModel(modelId);
+const supportsOpenAIComputerUse = (modelId) => isOpenAIGpt56Model(modelId) || isOpenAIGpt55BaseModel(modelId) || isOpenAIGpt54BaseModel(modelId) || isOpenAIGpt54MiniModel(modelId);
+const supportsOpenAIShell = (modelId) => isOpenAIGpt56Model(modelId) ||
+    isOpenAIGpt55BaseModel(modelId) ||
+    isOpenAIGpt55ProModel(modelId) ||
+    isOpenAIGpt54BaseModel(modelId) ||
+    isOpenAIGpt54MiniModel(modelId) ||
+    isOpenAIGpt54NanoModel(modelId) ||
+    isOpenAIGpt54ProModel(modelId);
+const supportsOpenAIApplyPatchAndSkills = (modelId) => isOpenAIGpt56Model(modelId) ||
+    isOpenAIGpt55BaseModel(modelId) ||
+    isOpenAIGpt54BaseModel(modelId) ||
+    isOpenAIGpt54MiniModel(modelId) ||
+    isOpenAIGpt54NanoModel(modelId);
 const supportsOpenAIChatAudio = (modelId) => {
     const normalized = normalizeModelId(modelId);
     return /^(?:gpt-audio(?:-|$)|gpt-4o(?:-mini)?-audio-preview(?:-|$))/.test(normalized);
 };
 const modelCapabilities = (modelId) => ({
     ...capabilities,
+    explicitPromptCaching: isOpenAIGpt56Model(modelId),
+    files: isOpenAIGpt56Model(modelId),
+    reasoningEfforts: isOpenAIGpt56Model(modelId)
+        ? ["none", "low", "medium", "high", "xhigh", "max"]
+        : undefined,
+    reasoningModes: isOpenAIGpt56Model(modelId) ? ["standard", "pro"] : undefined,
+    reasoningContexts: isOpenAIGpt56Model(modelId) ? ["auto", "current_turn", "all_turns"] : undefined,
     audioInput: supportsOpenAIChatAudio(modelId),
     audioOutput: supportsOpenAIChatAudio(modelId),
     agentCapabilities: {
         ...capabilities.agentCapabilities,
         computerUse: supportsOpenAIComputerUse(modelId),
-        shell: supportsOpenAIHostedHarnessTools(modelId),
-        applyPatch: supportsOpenAIHostedHarnessTools(modelId),
-        skills: supportsOpenAIHostedHarnessTools(modelId),
-        toolSearch: supportsOpenAIToolSearch(modelId)
+        shell: supportsOpenAIShell(modelId),
+        applyPatch: supportsOpenAIApplyPatchAndSkills(modelId),
+        skills: supportsOpenAIApplyPatchAndSkills(modelId),
+        toolSearch: supportsOpenAIToolSearch(modelId),
+        programmaticToolCalling: isOpenAIGpt56Model(modelId),
+        multiAgent: isOpenAIGpt56Model(modelId)
     }
 });
 const transcriptionCapabilities = {
@@ -152,6 +178,44 @@ const jsonHeaders = (apiKey) => ({
     "content-type": "application/json",
     authorization: `Bearer ${apiKey}`
 });
+const resolveOpenAILanguageRequestOptions = (providerOptions, apiKey) => {
+    const bodyOptions = { ...(providerOptions ?? {}) };
+    const apiMode = bodyOptions.apiMode ?? "auto";
+    const customHeaders = { ...(bodyOptions.headers ?? {}) };
+    const betaValues = new Set(bodyOptions.betas ?? []);
+    const multiAgentEnabled = bodyOptions.multi_agent?.enabled === true;
+    if (multiAgentEnabled) {
+        betaValues.add("responses_multi_agent=v1");
+    }
+    const existingBetaHeaderKey = Object.keys(customHeaders).find((key) => key.toLowerCase() === "openai-beta");
+    if (existingBetaHeaderKey) {
+        for (const value of customHeaders[existingBetaHeaderKey]?.split(",") ?? []) {
+            if (value.trim()) {
+                betaValues.add(value.trim());
+            }
+        }
+        delete customHeaders[existingBetaHeaderKey];
+    }
+    delete bodyOptions.apiMode;
+    delete bodyOptions.headers;
+    delete bodyOptions.betas;
+    return {
+        apiMode,
+        bodyOptions,
+        multiAgentEnabled,
+        headers: {
+            ...jsonHeaders(apiKey),
+            ...customHeaders,
+            ...(betaValues.size ? { "OpenAI-Beta": [...betaValues].join(",") } : {})
+        }
+    };
+};
+const openAIResponsesBodyOptions = (options, modelId) => options.store === false && isOpenAIGpt56Model(modelId)
+    ? {
+        ...options,
+        include: [...new Set([...(options.include ?? []), "reasoning.encrypted_content"])]
+    }
+    : options;
 const getRequestOptions = (input) => withTimeoutSignal(input);
 const toUint8Array = (data) => {
     if (data instanceof Uint8Array) {
@@ -200,32 +264,84 @@ const parseJson = async (response) => {
     }
     return response.json();
 };
+const isOpenAIPromptCacheBreakpointPart = (part) => part.type === "provider-data" &&
+    part.provider === "openai" &&
+    part.data !== null &&
+    typeof part.data === "object" &&
+    part.data.type === "prompt_cache_breakpoint";
+const promptCacheBreakpointForContentPart = (part) => {
+    const metadata = part
+        .providerMetadata;
+    const openAIMetadata = metadata?.openai && typeof metadata.openai === "object" && !Array.isArray(metadata.openai)
+        ? metadata.openai
+        : metadata;
+    const breakpoint = openAIMetadata?.prompt_cache_breakpoint;
+    return breakpoint && typeof breakpoint === "object" && !Array.isArray(breakpoint)
+        ? { prompt_cache_breakpoint: { mode: "explicit" } }
+        : {};
+};
+const imageDetailForPart = (part) => {
+    const metadata = part.providerMetadata;
+    const detail = metadata?.openaiDetail ??
+        (metadata?.openai && typeof metadata.openai === "object" && !Array.isArray(metadata.openai)
+            ? metadata.openai.detail
+            : undefined);
+    return detail === "auto" || detail === "low" || detail === "high" || detail === "original" ? detail : undefined;
+};
+const markLastContentBlockForPromptCaching = (content) => {
+    const last = content.at(-1);
+    if (!last) {
+        throw new ConfigurationError("OpenAI prompt cache breakpoints must follow a cacheable content part.");
+    }
+    last.prompt_cache_breakpoint = { mode: "explicit" };
+};
 const mapContentParts = (message) => {
-    const textParts = message.parts.filter((part) => part.type === "text");
-    const imageParts = message.parts.filter((part) => part.type === "image");
-    const audioParts = message.parts.filter((part) => part.type === "audio");
-    if (!imageParts.length && !audioParts.length) {
-        return textParts.map((part) => part.text).join("");
+    const hasRichContent = message.parts.some((part) => part.type === "image" ||
+        part.type === "audio" ||
+        part.type === "file" ||
+        Object.keys(promptCacheBreakpointForContentPart(part)).length > 0 ||
+        isOpenAIPromptCacheBreakpointPart(part));
+    if (!hasRichContent) {
+        return message.parts
+            .filter((part) => part.type === "text")
+            .map((part) => part.text)
+            .join("");
+    }
+    const content = [];
+    for (const part of message.parts) {
+        if (part.type === "text") {
+            content.push({ type: "text", text: part.text, ...promptCacheBreakpointForContentPart(part) });
+        }
+        else if (part.type === "image") {
+            const detail = imageDetailForPart(part);
+            content.push({
+                type: "image_url",
+                image_url: { url: part.image, ...(detail ? { detail } : {}) },
+                ...promptCacheBreakpointForContentPart(part)
+            });
+        }
+        else if (part.type === "file") {
+            content.push({
+                type: "file",
+                file: { file_id: part.data },
+                ...promptCacheBreakpointForContentPart(part)
+            });
+        }
+        else if (part.type === "audio") {
+            content.push({
+                type: "input_audio",
+                input_audio: {
+                    data: toBase64(part.data),
+                    format: inferOpenAIAudioFormat(part.mediaType, part.format)
+                },
+                ...promptCacheBreakpointForContentPart(part)
+            });
+        }
+        else if (isOpenAIPromptCacheBreakpointPart(part)) {
+            markLastContentBlockForPromptCaching(content);
+        }
     }
-    return [
-        ...textParts.map((part) => ({
-            type: "text",
-            text: part.text
-        })),
-        ...imageParts.map((part) => ({
-            type: "image_url",
-            image_url: {
-                url: part.image
-            }
-        })),
-        ...audioParts.map((part) => ({
-            type: "input_audio",
-            input_audio: {
-                data: toBase64(part.data),
-                format: inferOpenAIAudioFormat(part.mediaType, part.format)
-            }
-        }))
-    ];
+    return content;
 };
 const mapMessages = (messages) => messages.map((message) => {
     if (message.role === "tool") {
@@ -258,6 +374,13 @@ const mapMessages = (messages) => messages.map((message) => {
     return payload;
 });
 const hasResponsesOnlyTools = (tools) => Object.values(tools ?? {}).some((tool) => isHostedToolDefinition(tool) || (isCallableToolDefinition(tool) && openAILocalResponsesToolType(tool)));
+const hasProgrammaticToolCalling = (tools) => Object.values(tools ?? {}).some((tool) => isHostedToolDefinition(tool)
+    ? tool.type === "programmatic_tool_calling"
+    : openAILocalResponsesToolType(tool) === "programmatic_tool_calling");
+const localResponsesTools = (tools) => new Map(Object.values(tools ?? {})
+    .filter(isCallableToolDefinition)
+    .map((tool) => [openAILocalResponsesToolType(tool), tool.name])
+    .filter((entry) => Boolean(entry[0])));
 const assertResponsesToolsSupported = (modelId, tools) => {
     const currentCapabilities = modelCapabilities(modelId).agentCapabilities;
     for (const definition of Object.values(tools ?? {})) {
@@ -268,9 +391,26 @@ const assertResponsesToolsSupported = (modelId, tools) => {
         if (type === "computer_use_preview" && !currentCapabilities?.computerUse) {
             throw new UnsupportedFeatureError(`Provider "openai" model "${modelId}" does not support the Responses computer_use tool.`);
         }
-        if ((type === "shell" || type === "apply_patch") && !supportsOpenAIHostedHarnessTools(modelId)) {
+        if (type === "computer" && !currentCapabilities?.computerUse) {
+            throw new UnsupportedFeatureError(`Provider "openai" model "${modelId}" does not support the Responses computer tool.`);
+        }
+        if (type === "shell" && !supportsOpenAIShell(modelId)) {
             throw new UnsupportedFeatureError(`Provider "openai" model "${modelId}" does not support the Responses ${type} tool.`);
         }
+        if (type === "apply_patch" && !supportsOpenAIApplyPatchAndSkills(modelId)) {
+            throw new UnsupportedFeatureError(`Provider "openai" model "${modelId}" does not support the Responses ${type} tool.`);
+        }
+        if (type === "skill" && !currentCapabilities?.skills) {
+            throw new UnsupportedFeatureError(`Provider "openai" model "${modelId}" does not support the Responses skills tool.`);
+        }
+        if (type === "programmatic_tool_calling" && !isOpenAIGpt56Model(modelId)) {
+            throw new UnsupportedFeatureError(`Provider "openai" model "${modelId}" does not support Programmatic Tool Calling.`);
+        }
+    }
+};
+const assertOpenAIResponsesOptionsSupported = (modelId, options) => {
+    if (options.multi_agent?.enabled && !isOpenAIGpt56Model(modelId)) {
+        throw new UnsupportedFeatureError(`Provider "openai" model "${modelId}" does not support Multi-agent.`);
     }
 };
 const normalizeWebSearchConfig = (config = {}) => ({
@@ -313,7 +453,8 @@ const mapResponsesTools = (input) => input
                 type: "function",
                 name: tool.name,
                 description: tool.description,
-                parameters: toJSONSchema(tool.schema)
+                parameters: toJSONSchema(tool.schema),
+                ...openAIResponsesFunctionConfig(tool)
             };
         }
         if (tool.provider && tool.provider !== "openai") {
@@ -339,6 +480,15 @@ const mapToolChoice = (toolChoice) => {
         }
     };
 };
+const mapResponsesToolChoice = (toolChoice) => {
+    if (!toolChoice || typeof toolChoice === "string") {
+        return toolChoice;
+    }
+    return {
+        type: "function",
+        name: toolChoice.toolName
+    };
+};
 const mapRealtimeProviderOptions = (providerOptions) => {
     if (!providerOptions) {
         return {};
@@ -592,18 +742,45 @@ const mapResponsesStructuredOutput = (input) => {
         }
     };
 };
-const mapReasoning = (input) => {
+const getOpenAIReasoning = (input) => {
     if (!input.reasoning) {
-        return {};
+        return undefined;
     }
     if (input.reasoning.budgetTokens !== undefined) {
         throw new UnsupportedFeatureError('Provider "openai" does not support "reasoning.budgetTokens".');
     }
+    return input.reasoning;
+};
+const mapChatReasoning = (input) => {
+    const reasoning = getOpenAIReasoning(input);
+    if (!reasoning) {
+        return {};
+    }
+    if (reasoning.mode !== undefined || reasoning.context !== undefined) {
+        throw new UnsupportedFeatureError('Provider "openai" only supports "reasoning.mode" and "reasoning.context" through the Responses API.');
+    }
     return {
-        reasoning_effort: input.reasoning.effort,
+        ...(reasoning.effort !== undefined ? { reasoning_effort: reasoning.effort } : {}),
         max_completion_tokens: input.maxTokens
     };
 };
+const mapResponsesReasoning = (input, providerReasoning) => {
+    const reasoning = getOpenAIReasoning(input);
+    if (!reasoning) {
+        return {};
+    }
+    return {
+        reasoning: {
+            ...(providerReasoning && typeof providerReasoning === "object" && !Array.isArray(providerReasoning)
+                ? providerReasoning
+                : {}),
+            ...(reasoning.effort !== undefined ? { effort: reasoning.effort } : {}),
+            ...(reasoning.mode !== undefined ? { mode: reasoning.mode } : {}),
+            ...(reasoning.context !== undefined ? { context: reasoning.context } : {}),
+            ...(reasoning.includeThoughts ? { summary: "auto" } : {})
+        }
+    };
+};
 const getProviderResponseId = (messages) => {
     for (let index = messages.length - 1; index >= 0; index -= 1) {
         const message = messages[index];
@@ -627,20 +804,52 @@ const getProviderResponseId = (messages) => {
 const serializeToolOutput = (message) => message.parts
     .filter((part) => part.type === "tool-result")
     .map((part) => {
-    if (part.toolResult.toolName === "shell") {
+    const responsesToolType = part.toolResult.providerMetadata?.responsesToolType;
+    if (part.toolResult.toolName === "shell" || responsesToolType === "shell") {
+        const rawOutput = part.toolResult.output;
+        const rawOutputs = Array.isArray(rawOutput)
+            ? rawOutput
+            : rawOutput && typeof rawOutput === "object" && Array.isArray(rawOutput.output)
+                ? rawOutput.output
+                : rawOutput
+                    ? [rawOutput]
+                    : [];
+        const firstRawOutput = rawOutputs[0] && typeof rawOutputs[0] === "object"
+            ? rawOutputs[0]
+            : undefined;
+        const output = rawOutputs.map((entry) => {
+            const result = entry && typeof entry === "object" ? entry : {};
+            const outcome = result.outcome && typeof result.outcome === "object"
+                ? result.outcome
+                : { type: "exit", exit_code: 0 };
+            return {
+                stdout: typeof result.stdout === "string" ? result.stdout : "",
+                stderr: typeof result.stderr === "string" ? result.stderr : "",
+                outcome: {
+                    type: outcome.type ?? "exit",
+                    exit_code: outcome.exit_code ?? outcome.exitCode
+                }
+            };
+        });
         return {
             type: "shell_call_output",
             call_id: part.toolResult.toolCallId,
+            max_output_length: rawOutput && typeof rawOutput === "object"
+                ? (rawOutput.max_output_length ??
+                    rawOutput.maxOutputLength ??
+                    firstRawOutput?.max_output_length ??
+                    firstRawOutput?.maxOutputLength)
+                : undefined,
             output: part.toolResult.isError
-                ? {
-                    stdout: "",
-                    stderr: part.toolResult.error?.message ?? "Shell execution failed.",
-                    outcome: { type: "exit", exitCode: 1 }
-                }
-                : part.toolResult.output
+                ? [{
+                        stdout: "",
+                        stderr: part.toolResult.error?.message ?? "Shell execution failed.",
+                        outcome: { type: "exit", exit_code: 1 }
+                    }]
+                : output
         };
     }
-    if (part.toolResult.toolName === "apply_patch") {
+    if (part.toolResult.toolName === "apply_patch" || responsesToolType === "apply_patch") {
         const output = part.toolResult.output;
         const outputRecord = output && typeof output === "object" && !Array.isArray(output)
             ? output
@@ -652,10 +861,23 @@ const serializeToolOutput = (message) => message.parts
             output: part.toolResult.isError ? part.toolResult.error?.message : outputRecord?.output
         };
     }
+    if (part.toolResult.toolName === "computer" || responsesToolType === "computer") {
+        if (part.toolResult.isError) {
+            throw new Error(`OpenAI computer action execution failed: ${part.toolResult.error?.message ?? "unknown error"}`);
+        }
+        return {
+            type: "computer_call_output",
+            call_id: part.toolResult.toolCallId,
+            output: part.toolResult.output
+        };
+    }
     return {
         type: "function_call_output",
         call_id: part.toolResult.toolCallId,
-        output: JSON.stringify(part.toolResult.isError ? part.toolResult.error : part.toolResult.output ?? null)
+        output: JSON.stringify(part.toolResult.isError ? part.toolResult.error : part.toolResult.output ?? null),
+        ...(part.toolResult.providerMetadata?.caller !== undefined
+            ? { caller: part.toolResult.providerMetadata.caller }
+            : {})
     };
 });
 const serializeProviderDataInput = (message) => message.parts
@@ -663,15 +885,27 @@ const serializeProviderDataInput = (message) => message.parts
     part.provider === "openai" &&
     part.data !== null &&
     typeof part.data === "object" &&
-    part.data.type === "mcp_approval_response")
+    typeof part.data.type === "string" &&
+    !["prompt_cache_breakpoint", "responses_output"].includes(part.data.type))
     .map((part) => part.data);
+const serializedResponsesOutput = (message) => message.parts.flatMap((part) => {
+    if (part.type !== "provider-data" ||
+        part.provider !== "openai" ||
+        !part.data ||
+        typeof part.data !== "object" ||
+        part.data.type !== "responses_output" ||
+        !Array.isArray(part.data.items)) {
+        return [];
+    }
+    return part.data.items;
+});
 const parseResponsesProviderData = (item) => {
     if (!item || typeof item !== "object") {
         return undefined;
     }
     const typedItem = item;
     if (typeof typedItem.type !== "string" ||
-        ["message", "function_call", "shell_call", "apply_patch_call"].includes(typedItem.type)) {
+        ["message", "function_call"].includes(typedItem.type)) {
         return undefined;
     }
     return item;
@@ -679,7 +913,13 @@ const parseResponsesProviderData = (item) => {
 const parseShellCallInput = (item) => {
     const action = item.action && typeof item.action === "object" ? item.action : undefined;
     return {
-        command: typeof action?.command === "string" ? action.command : typeof item.command === "string" ? item.command : undefined,
+        command: typeof action?.command === "string"
+            ? action.command
+            : Array.isArray(action?.commands) && typeof action.commands[0] === "string"
+                ? action.commands[0]
+                : typeof item.command === "string"
+                    ? item.command
+                    : undefined,
         action: action,
         maxOutputLength: typeof action?.max_output_length === "number"
             ? action.max_output_length
@@ -753,26 +993,52 @@ const toResponsesInput = (messages) => {
             input.push(...serializeToolOutput(message));
             continue;
         }
+        const rawResponsesOutput = serializedResponsesOutput(message);
+        if (message.role === "assistant" && rawResponsesOutput.length) {
+            input.push(...rawResponsesOutput);
+            continue;
+        }
         input.push(...serializeProviderDataInput(message));
         const content = [];
+        const assistantOutputItems = [];
         for (const part of message.parts) {
             switch (part.type) {
                 case "text":
-                    content.push({ type: "input_text", text: part.text });
+                    content.push({ type: "input_text", text: part.text, ...promptCacheBreakpointForContentPart(part) });
                     break;
                 case "image":
-                    content.push({ type: "input_image", image_url: part.image });
+                    const detail = imageDetailForPart(part);
+                    content.push({
+                        type: "input_image",
+                        image_url: part.image,
+                        ...(detail ? { detail } : {}),
+                        ...promptCacheBreakpointForContentPart(part)
+                    });
+                    break;
+                case "file":
+                    content.push({
+                        type: "input_file",
+                        file_id: part.data,
+                        ...promptCacheBreakpointForContentPart(part)
+                    });
                     break;
                 case "tool-call":
                     if (message.role === "assistant") {
-                        content.push({
+                        const caller = part.toolCall.providerMetadata?.caller;
+                        assistantOutputItems.push({
                             type: "function_call",
                             call_id: part.toolCall.id,
                             name: part.toolCall.name,
-                            arguments: JSON.stringify(part.toolCall.input)
+                            arguments: JSON.stringify(part.toolCall.input),
+                            ...(caller !== undefined ? { caller } : {})
                         });
                     }
                     break;
+                case "provider-data":
+                    if (isOpenAIPromptCacheBreakpointPart(part)) {
+                        markLastContentBlockForPromptCaching(content);
+                    }
+                    break;
             }
         }
         if (content.length) {
@@ -781,49 +1047,76 @@ const toResponsesInput = (messages) => {
                 content
             });
         }
+        input.push(...assistantOutputItems);
     }
     return input;
 };
-const parseResponsesAssistantMessage = (json) => {
+const parseResponsesAssistantMessage = (json, multiAgentEnabled = false, localTools = new Map()) => {
     const parts = [];
     for (const [index, item] of (json.output ?? []).entries()) {
         if (item?.type === "message") {
+            if (multiAgentEnabled && (item.agent?.agent_name !== "/root" || item.phase !== "final_answer")) {
+                continue;
+            }
             for (const content of item.content ?? []) {
                 if (typeof content?.text === "string" && content.text) {
                     parts.push({ type: "text", text: content.text });
                 }
+                else if (typeof content?.refusal === "string" && content.refusal) {
+                    parts.push({ type: "text", text: content.refusal });
+                }
             }
             continue;
         }
         if (item?.type === "function_call") {
+            const callId = item.call_id ?? item.id ?? `${item.name}-${index}`;
             parts.push({
                 type: "tool-call",
                 toolCall: {
-                    id: item.call_id ?? item.id ?? `${item.name}-${index}`,
+                    id: callId,
                     name: item.name,
-                    input: JSON.parse(item.arguments ?? "{}")
+                    input: JSON.parse(item.arguments ?? "{}"),
+                    ...(item.caller && typeof item.caller === "object"
+                        ? { providerMetadata: { caller: item.caller } }
+                        : {})
                 }
             });
             continue;
         }
-        if (item?.type === "shell_call") {
+        if (item?.type === "shell_call" && localTools.has("shell")) {
             parts.push({
                 type: "tool-call",
                 toolCall: {
                     id: item.call_id ?? item.id ?? `shell-${index}`,
-                    name: "shell",
-                    input: parseShellCallInput(item)
+                    name: localTools.get("shell"),
+                    input: parseShellCallInput(item),
+                    providerMetadata: { responsesToolType: "shell" }
                 }
             });
             continue;
         }
-        if (item?.type === "apply_patch_call") {
+        if (item?.type === "apply_patch_call" && localTools.has("apply_patch")) {
             parts.push({
                 type: "tool-call",
                 toolCall: {
                     id: item.call_id ?? item.id ?? `apply_patch-${index}`,
-                    name: "apply_patch",
-                    input: parseApplyPatchCallInput(item)
+                    name: localTools.get("apply_patch"),
+                    input: parseApplyPatchCallInput(item),
+                    providerMetadata: { responsesToolType: "apply_patch" }
+                }
+            });
+            continue;
+        }
+        if (item?.type === "computer_call" && localTools.has("computer")) {
+            parts.push({
+                type: "tool-call",
+                toolCall: {
+                    id: item.call_id ?? item.id ?? `computer-${index}`,
+                    name: localTools.get("computer"),
+                    input: {
+                        actions: Array.isArray(item.actions) ? item.actions : []
+                    },
+                    providerMetadata: { responsesToolType: "computer" }
                 }
             });
             continue;
@@ -833,7 +1126,13 @@ const parseResponsesAssistantMessage = (json) => {
             parts.push(providerDataPart("openai", providerData));
         }
     }
-    if (!parts.some((part) => part.type === "text") && typeof json.output_text === "string" && json.output_text) {
+    if (Array.isArray(json.output) && json.output.length) {
+        parts.push(providerDataPart("openai", {
+            type: "responses_output",
+            items: json.output
+        }));
+    }
+    if (!multiAgentEnabled && !parts.some((part) => part.type === "text") && typeof json.output_text === "string" && json.output_text) {
         parts.push({ type: "text", text: json.output_text });
     }
     if (typeof json.id === "string") {
@@ -850,10 +1149,13 @@ const parseResponsesAssistantMessage = (json) => {
         parts
     };
 };
-const normalizeResponsesFinishReason = (status, hasToolCalls) => {
+const normalizeResponsesFinishReason = (status, hasToolCalls, hasRefusal = false) => {
     if (hasToolCalls) {
         return "tool-calls";
     }
+    if (hasRefusal) {
+        return "refusal";
+    }
     if (status === "completed") {
         return "stop";
     }
@@ -862,9 +1164,46 @@ const normalizeResponsesFinishReason = (status, hasToolCalls) => {
     }
     return normalizeFinishReason(status);
 };
-const streamResponses = async function* (response) {
+const mapResponsesUsage = (usage) => usage
+    ? {
+        inputTokens: usage.input_tokens,
+        cachedInputTokens: usage.input_tokens_details?.cached_tokens,
+        cacheWriteTokens: usage.input_tokens_details?.cache_write_tokens,
+        outputTokens: usage.output_tokens,
+        reasoningTokens: usage.output_tokens_details?.reasoning_tokens,
+        totalTokens: usage.total_tokens
+    }
+    : undefined;
+const mapChatUsage = (usage) => usage
+    ? {
+        inputTokens: usage.prompt_tokens,
+        cachedInputTokens: usage.prompt_tokens_details?.cached_tokens,
+        cacheWriteTokens: usage.prompt_tokens_details?.cache_write_tokens,
+        outputTokens: usage.completion_tokens,
+        reasoningTokens: usage.completion_tokens_details?.reasoning_tokens,
+        totalTokens: usage.total_tokens
+    }
+    : undefined;
+const addTokenUsage = (left, right) => {
+    if (!left)
+        return right;
+    if (!right)
+        return left;
+    const sum = (a, b) => a === undefined && b === undefined ? undefined : (a ?? 0) + (b ?? 0);
+    return {
+        inputTokens: sum(left.inputTokens, right.inputTokens),
+        cachedInputTokens: sum(left.cachedInputTokens, right.cachedInputTokens),
+        cacheWriteTokens: sum(left.cacheWriteTokens, right.cacheWriteTokens),
+        outputTokens: sum(left.outputTokens, right.outputTokens),
+        reasoningTokens: sum(left.reasoningTokens, right.reasoningTokens),
+        totalTokens: sum(left.totalTokens, right.totalTokens)
+    };
+};
+const streamResponses = async function* (response, multiAgentEnabled = false, localTools = new Map()) {
     const toolBuffers = new Map();
+    const outputAgents = new Map();
     let sawToolCalls = false;
+    let sawRefusal = false;
     const emitToolCall = (key) => {
         const toolCall = toolBuffers.get(key);
         if (!toolCall || toolCall.emitted || !toolCall.name) {
@@ -877,7 +1216,8 @@ const streamResponses = async function* (response) {
             toolCall: {
                 id: toolCall.callId,
                 name: toolCall.name,
-                input: JSON.parse(toolCall.args || "{}")
+                input: JSON.parse(toolCall.args || "{}"),
+                ...(toolCall.caller !== undefined ? { providerMetadata: { caller: toolCall.caller } } : {})
             }
         };
     };
@@ -887,12 +1227,32 @@ const streamResponses = async function* (response) {
         }
         const json = JSON.parse(event.data);
         const type = json.type;
-        if (type === "response.output_text.delta" && typeof json.delta === "string") {
+        if (type === "error") {
+            throw new ProviderHTTPError(`OpenAI Responses stream failed: ${json.error?.message ?? json.message ?? "unknown error"}`, 500, { responseBody: JSON.stringify(json) });
+        }
+        if (type === "response.output_text.delta" &&
+            typeof json.delta === "string" &&
+            (!multiAgentEnabled ||
+                (outputAgents.get(json.output_index)?.agentName ?? "/root") === "/root")) {
+            yield { type: "text-delta", textDelta: json.delta };
+            continue;
+        }
+        if (type === "response.refusal.delta" &&
+            typeof json.delta === "string" &&
+            (!multiAgentEnabled ||
+                (outputAgents.get(json.output_index)?.agentName ?? "/root") === "/root")) {
+            sawRefusal = true;
             yield { type: "text-delta", textDelta: json.delta };
             continue;
         }
         if (type === "response.output_item.added" || type === "response.output_item.done") {
             const item = json.item;
+            let handledLocalToolCall = false;
+            if (typeof json.output_index === "number" && item?.type === "message") {
+                outputAgents.set(json.output_index, {
+                    agentName: item.agent?.agent_name
+                });
+            }
             if (item?.type === "function_call") {
                 const key = item.id ?? json.item_id ?? `${json.output_index ?? toolBuffers.size}`;
                 const existing = toolBuffers.get(key) ?? {
@@ -903,6 +1263,9 @@ const streamResponses = async function* (response) {
                 };
                 existing.callId = item.call_id ?? existing.callId;
                 existing.name ||= item.name ?? "";
+                if (item.caller && typeof item.caller === "object") {
+                    existing.caller = item.caller;
+                }
                 if (typeof item.arguments === "string") {
                     existing.args = item.arguments;
                 }
@@ -914,36 +1277,65 @@ const streamResponses = async function* (response) {
                     }
                 }
             }
-            if (item?.type === "shell_call" && type === "response.output_item.done") {
+            if (item?.type === "shell_call" && type === "response.output_item.done" && localTools.has("shell")) {
                 yield {
                     type: "tool-call",
                     toolCall: {
                         id: item.call_id ?? item.id ?? `${json.output_index ?? "shell"}`,
-                        name: "shell",
-                        input: parseShellCallInput(item)
+                        name: localTools.get("shell"),
+                        input: parseShellCallInput(item),
+                        providerMetadata: { responsesToolType: "shell" }
                     }
                 };
                 sawToolCalls = true;
+                handledLocalToolCall = true;
             }
-            if (item?.type === "apply_patch_call" && type === "response.output_item.done") {
+            if (item?.type === "apply_patch_call" && type === "response.output_item.done" && localTools.has("apply_patch")) {
                 yield {
                     type: "tool-call",
                     toolCall: {
                         id: item.call_id ?? item.id ?? `${json.output_index ?? "apply_patch"}`,
-                        name: "apply_patch",
-                        input: parseApplyPatchCallInput(item)
+                        name: localTools.get("apply_patch"),
+                        input: parseApplyPatchCallInput(item),
+                        providerMetadata: { responsesToolType: "apply_patch" }
                     }
                 };
                 sawToolCalls = true;
+                handledLocalToolCall = true;
+            }
+            if (item?.type === "computer_call" && type === "response.output_item.done" && localTools.has("computer")) {
+                yield {
+                    type: "tool-call",
+                    toolCall: {
+                        id: item.call_id ?? item.id ?? `${json.output_index ?? "computer"}`,
+                        name: localTools.get("computer"),
+                        input: {
+                            actions: Array.isArray(item.actions) ? item.actions : []
+                        },
+                        providerMetadata: { responsesToolType: "computer" }
+                    }
+                };
+                sawToolCalls = true;
+                handledLocalToolCall = true;
             }
             const providerData = parseResponsesProviderData(item);
-            if (providerData && type === "response.output_item.done") {
+            if (providerData && type === "response.output_item.done" && !handledLocalToolCall) {
                 yield {
                     type: "provider-data",
                     provider: "openai",
                     data: providerData
                 };
             }
+            if (item && type === "response.output_item.done") {
+                yield {
+                    type: "provider-data",
+                    provider: "openai",
+                    data: {
+                        type: "responses_output",
+                        items: [item]
+                    }
+                };
+            }
             continue;
         }
         if (type === "response.function_call_arguments.delta") {
@@ -978,21 +1370,47 @@ const streamResponses = async function* (response) {
         }
         if (type === "response.completed" || type === "response.failed" || type === "response.incomplete") {
             const responseData = json.response ?? {};
+            if (typeof responseData.id === "string") {
+                yield {
+                    type: "provider-data",
+                    provider: "openai",
+                    data: { responseId: responseData.id }
+                };
+            }
             yield {
                 type: "finish",
-                finishReason: normalizeResponsesFinishReason(responseData.status, sawToolCalls),
+                finishReason: normalizeResponsesFinishReason(responseData.status, sawToolCalls, sawRefusal),
                 providerFinishReason: responseData.status,
-                usage: responseData.usage
-                    ? {
-                        inputTokens: responseData.usage.input_tokens,
-                        outputTokens: responseData.usage.output_tokens,
-                        totalTokens: responseData.usage.total_tokens
-                    }
-                    : undefined
+                usage: mapResponsesUsage(responseData.usage)
             };
         }
     }
 };
+const streamGenerateResult = async function* (result) {
+    for (const message of result.messages ?? (result.message ? [result.message] : [])) {
+        for (const part of message.parts) {
+            if (part.type === "text" && part.text) {
+                yield { type: "text-delta", textDelta: part.text };
+            }
+            else if (part.type === "tool-call") {
+                yield { type: "tool-call", toolCall: part.toolCall };
+            }
+            else if (part.type === "provider-data") {
+                yield {
+                    type: "provider-data",
+                    provider: part.provider,
+                    data: part.data
+                };
+            }
+        }
+    }
+    yield {
+        type: "finish",
+        finishReason: result.finishReason,
+        providerFinishReason: result.providerFinishReason,
+        usage: result.usage
+    };
+};
 const extractSources = (value) => {
     const sources = [];
     const visit = (node) => {
@@ -1033,69 +1451,117 @@ class OpenAILanguageModel {
         this.fetcher = fetcher;
         this.capabilities = modelCapabilities(modelId);
     }
-    usesResponsesAPI(input) {
-        return hasResponsesOnlyTools(input.tools);
+    usesResponsesAPI(input, options) {
+        const requiresResponses = hasResponsesOnlyTools(input.tools) || options.multiAgentEnabled;
+        if (options.apiMode === "chat") {
+            if (requiresResponses) {
+                throw new UnsupportedFeatureError('Provider "openai" cannot use apiMode "chat" with Responses-only tools or Multi-agent.');
+            }
+            return false;
+        }
+        return options.apiMode === "responses" || requiresResponses || isOpenAIGpt56Model(this.modelId);
     }
-    async generateViaResponses(input, signal) {
+    async generateViaResponses(input, signal, options) {
+        const responseBodyOptions = openAIResponsesBodyOptions(options.bodyOptions, this.modelId);
         assertResponsesToolsSupported(this.modelId, input.tools);
-        const previousResponse = getProviderResponseId(input.messages);
+        assertOpenAIResponsesOptionsSupported(this.modelId, responseBodyOptions);
+        const previousResponse = responseBodyOptions.store === false ? undefined : getProviderResponseId(input.messages);
         const messages = previousResponse && previousResponse.index < input.messages.length - 1
             ? input.messages.slice(previousResponse.index + 1)
             : input.messages;
-        const response = await withRetry(() => this.fetcher(`${this.baseURL}/responses`, {
-            method: "POST",
-            headers: jsonHeaders(this.apiKey),
-            signal,
-            body: JSON.stringify({
-                ...input.providerOptions,
-                model: this.modelId,
-                ...(previousResponse ? { previous_response_id: previousResponse.responseId } : {}),
-                ...(messages.length ? { input: toResponsesInput(messages) } : {}),
-                tools: mapResponsesTools(input.tools),
-                tool_choice: mapToolChoice(input.toolChoice),
-                text: mapResponsesStructuredOutput(input),
-                temperature: input.temperature,
-                max_output_tokens: input.maxTokens,
-                ...mapReasoning(input)
-            })
-        }), input);
-        const json = await parseJson(response);
-        const assistantMessage = parseResponsesAssistantMessage(json);
-        const hasToolCalls = assistantMessage.parts.some((part) => part.type === "tool-call");
-        return {
-            messages: [assistantMessage],
-            text: extractMessageText(assistantMessage),
-            audio: extractAudioOutputs(assistantMessage),
-            finishReason: normalizeResponsesFinishReason(json.status, hasToolCalls),
-            providerFinishReason: json.status,
-            usage: {
-                inputTokens: json.usage?.input_tokens,
-                outputTokens: json.usage?.output_tokens,
-                totalTokens: json.usage?.total_tokens
-            },
-            rawResponse: json
-        };
+        let nextPreviousResponseId = previousResponse?.responseId;
+        let nextInput = messages.length ? toResponsesInput(messages) : [];
+        let accumulatedUsage;
+        let statelessInternalOutputs = [];
+        for (let continuation = 0; continuation < 8; continuation += 1) {
+            const response = await withRetry(() => this.fetcher(`${this.baseURL}/responses`, {
+                method: "POST",
+                headers: options.headers,
+                signal,
+                body: JSON.stringify({
+                    ...responseBodyOptions,
+                    model: this.modelId,
+                    ...(nextPreviousResponseId ? { previous_response_id: nextPreviousResponseId } : {}),
+                    ...(nextInput.length ? { input: nextInput } : {}),
+                    tools: mapResponsesTools(input.tools),
+                    ...(input.toolChoice ? { tool_choice: mapResponsesToolChoice(input.toolChoice) } : {}),
+                    text: mapResponsesStructuredOutput(input),
+                    temperature: input.temperature,
+                    max_output_tokens: input.maxTokens,
+                    ...mapResponsesReasoning(input, responseBodyOptions.reasoning)
+                })
+            }), input);
+            const json = await parseJson(response);
+            accumulatedUsage = addTokenUsage(accumulatedUsage, mapResponsesUsage(json.usage));
+            const assistantMessage = parseResponsesAssistantMessage(json, options.multiAgentEnabled, localResponsesTools(input.tools));
+            const currentOutput = Array.isArray(json.output)
+                ? json.output
+                : [];
+            const completeStatelessOutput = [...statelessInternalOutputs, ...currentOutput];
+            if (responseBodyOptions.store === false && completeStatelessOutput.length) {
+                assistantMessage.parts = assistantMessage.parts.filter((part) => part.type !== "provider-data" ||
+                    part.provider !== "openai" ||
+                    !part.data ||
+                    typeof part.data !== "object" ||
+                    part.data.type !== "responses_output");
+                assistantMessage.parts.push(providerDataPart("openai", {
+                    type: "responses_output",
+                    items: completeStatelessOutput
+                }));
+            }
+            const hasToolCalls = assistantMessage.parts.some((part) => part.type === "tool-call");
+            const hasRefusal = (json.output ?? []).some((item) => item?.type === "message" &&
+                (item.content ?? []).some((content) => content?.type === "refusal"));
+            const hasFinalMessage = (json.output ?? []).some((item) => item?.type === "message" &&
+                (!options.multiAgentEnabled || (item.agent?.agent_name === "/root" && item.phase === "final_answer")));
+            const shouldContinueProgram = hasProgrammaticToolCalling(input.tools) &&
+                json.status === "completed" &&
+                !hasToolCalls &&
+                !hasFinalMessage &&
+                (json.output ?? []).some((item) => item?.type === "program" || item?.type === "program_output");
+            if (!shouldContinueProgram) {
+                return {
+                    messages: [assistantMessage],
+                    text: extractMessageText(assistantMessage),
+                    audio: extractAudioOutputs(assistantMessage),
+                    finishReason: normalizeResponsesFinishReason(json.status, hasToolCalls, hasRefusal),
+                    providerFinishReason: json.status,
+                    usage: accumulatedUsage,
+                    rawResponse: json
+                };
+            }
+            if (responseBodyOptions.store === false) {
+                statelessInternalOutputs = completeStatelessOutput;
+                nextInput = [...nextInput, ...currentOutput];
+            }
+            else {
+                nextPreviousResponseId = json.id;
+                nextInput = [];
+            }
+        }
+        throw new ProviderHTTPError("OpenAI Programmatic Tool Calling exceeded 8 internal continuations.", 500);
     }
     async generate(input) {
         const { signal, cleanup } = getRequestOptions(input);
+        const options = resolveOpenAILanguageRequestOptions(input.providerOptions, this.apiKey);
         try {
-            if (this.usesResponsesAPI(input)) {
-                return await this.generateViaResponses(input, signal);
+            if (this.usesResponsesAPI(input, options)) {
+                return await this.generateViaResponses(input, signal, options);
             }
             const response = await withRetry(() => this.fetcher(`${this.baseURL}/chat/completions`, {
                 method: "POST",
-                headers: jsonHeaders(this.apiKey),
+                headers: options.headers,
                 signal,
                 body: JSON.stringify({
-                    ...input.providerOptions,
+                    ...options.bodyOptions,
                     model: this.modelId,
                     messages: mapMessages(input.messages),
                     tools: mapTools(input.tools),
-                    tool_choice: mapToolChoice(input.toolChoice),
+                    ...(input.toolChoice ? { tool_choice: mapToolChoice(input.toolChoice) } : {}),
                     response_format: mapStructuredOutput(input),
                     temperature: input.temperature,
                     ...(input.reasoning ? {} : { max_tokens: input.maxTokens }),
-                    ...mapReasoning(input),
+                    ...mapChatReasoning(input),
                     stream: false
                 })
             }), input);
@@ -1109,11 +1575,7 @@ class OpenAILanguageModel {
                 audio: extractAudioOutputs(assistantMessage),
                 finishReason: normalizeFinishReason(choice?.finish_reason),
                 providerFinishReason: choice?.finish_reason,
-                usage: {
-                    inputTokens: json.usage?.prompt_tokens,
-                    outputTokens: json.usage?.completion_tokens,
-                    totalTokens: json.usage?.total_tokens
-                },
+                usage: mapChatUsage(json.usage),
                 rawResponse: json
             };
         }
@@ -1122,29 +1584,48 @@ class OpenAILanguageModel {
         }
     }
     async stream(input) {
-        if (this.usesResponsesAPI(input)) {
+        const options = resolveOpenAILanguageRequestOptions(input.providerOptions, this.apiKey);
+        if (this.usesResponsesAPI(input, options)) {
+            const responseBodyOptions = openAIResponsesBodyOptions(options.bodyOptions, this.modelId);
             assertResponsesToolsSupported(this.modelId, input.tools);
+            assertOpenAIResponsesOptionsSupported(this.modelId, responseBodyOptions);
             const { signal, cleanup } = getRequestOptions(input);
+            if (hasProgrammaticToolCalling(input.tools)) {
+                const result = await this.generateViaResponses(input, signal, options);
+                return (async function* () {
+                    try {
+                        yield* streamGenerateResult(result);
+                    }
+                    finally {
+                        cleanup();
+                    }
+                })();
+            }
+            const previousResponse = responseBodyOptions.store === false ? undefined : getProviderResponseId(input.messages);
+            const messages = previousResponse && previousResponse.index < input.messages.length - 1
+                ? input.messages.slice(previousResponse.index + 1)
+                : input.messages;
             const response = await withRetry(() => this.fetcher(`${this.baseURL}/responses`, {
                 method: "POST",
-                headers: jsonHeaders(this.apiKey),
+                headers: options.headers,
                 signal,
                 body: JSON.stringify({
-                    ...input.providerOptions,
+                    ...responseBodyOptions,
                     model: this.modelId,
-                    input: toResponsesInput(input.messages),
+                    ...(previousResponse ? { previous_response_id: previousResponse.responseId } : {}),
+                    ...(messages.length ? { input: toResponsesInput(messages) } : {}),
                     tools: mapResponsesTools(input.tools),
-                    tool_choice: mapToolChoice(input.toolChoice),
+                    ...(input.toolChoice ? { tool_choice: mapResponsesToolChoice(input.toolChoice) } : {}),
                     text: mapResponsesStructuredOutput(input),
                     temperature: input.temperature,
                     max_output_tokens: input.maxTokens,
-                    ...mapReasoning(input),
+                    ...mapResponsesReasoning(input, responseBodyOptions.reasoning),
                     stream: true
                 })
             }), input);
             return (async function* () {
                 try {
-                    yield* streamResponses(response);
+                    yield* streamResponses(response, options.multiAgentEnabled, localResponsesTools(input.tools));
                 }
                 finally {
                     cleanup();
@@ -1154,18 +1635,18 @@ class OpenAILanguageModel {
         const { signal, cleanup } = getRequestOptions(input);
         const response = await withRetry(() => this.fetcher(`${this.baseURL}/chat/completions`, {
             method: "POST",
-            headers: jsonHeaders(this.apiKey),
+            headers: options.headers,
             signal,
             body: JSON.stringify({
-                ...input.providerOptions,
+                ...options.bodyOptions,
                 model: this.modelId,
                 messages: mapMessages(input.messages),
                 tools: mapTools(input.tools),
-                tool_choice: mapToolChoice(input.toolChoice),
+                ...(input.toolChoice ? { tool_choice: mapToolChoice(input.toolChoice) } : {}),
                 response_format: mapStructuredOutput(input),
                 temperature: input.temperature,
                 ...(input.reasoning ? {} : { max_tokens: input.maxTokens }),
-                ...mapReasoning(input),
+                ...mapChatReasoning(input),
                 stream: true,
                 stream_options: { include_usage: true }
             })
@@ -1208,13 +1689,7 @@ class OpenAILanguageModel {
                             type: "finish",
                             finishReason: normalizeFinishReason(choice.finish_reason),
                             providerFinishReason: choice.finish_reason,
-                            usage: json.usage
-                                ? {
-                                    inputTokens: json.usage.prompt_tokens,
-                                    outputTokens: json.usage.completion_tokens,
-                                    totalTokens: json.usage.total_tokens
-                                }
-                                : undefined
+                            usage: mapChatUsage(json.usage)
                         };
                     }
                 }
@@ -1375,29 +1850,28 @@ class OpenAIGroundedLanguageModel {
     }
     async generate(input) {
         const { signal, cleanup } = withTimeoutSignal(input);
+        const options = resolveOpenAILanguageRequestOptions(input.providerOptions, this.apiKey);
+        const responseBodyOptions = openAIResponsesBodyOptions(options.bodyOptions, this.modelId);
         try {
             const response = await withRetry(() => this.fetcher(`${this.baseURL}/responses`, {
                 method: "POST",
-                headers: jsonHeaders(this.apiKey),
+                headers: options.headers,
                 signal,
                 body: JSON.stringify({
-                    ...input.providerOptions,
+                    ...responseBodyOptions,
                     model: this.modelId,
                     input: toResponsesInput(input.messages),
                     tools: [{ type: "web_search_preview" }],
                     temperature: input.temperature,
-                    max_output_tokens: input.maxTokens
+                    max_output_tokens: input.maxTokens,
+                    ...mapResponsesReasoning(input, responseBodyOptions.reasoning)
                 })
             }), input);
             const json = await parseJson(response);
             return {
                 text: json.output_text ?? "",
                 sources: extractSources(json),
-                usage: {
-                    inputTokens: json.usage?.input_tokens,
-                    outputTokens: json.usage?.output_tokens,
-                    totalTokens: json.usage?.total_tokens
-                },
+                usage: mapResponsesUsage(json.usage),
                 finishReason: normalizeFinishReason(json.status),
                 providerFinishReason: json.status,
                 rawResponse: json
@@ -1644,6 +2118,22 @@ export const openAIToolSearchTool = (config = {}) => hostedTool({
     toolClass: "tool-search",
     config: config
 });
+export const openAIProgrammaticToolCallingTool = () => hostedTool({
+    name: "programmatic_tool_calling",
+    provider: "openai",
+    type: "programmatic_tool_calling",
+    toolClass: "code-execution"
+});
+export const openAIProgrammaticTool = (definition, options = {}) => ({
+    ...definition,
+    metadata: {
+        ...definition.metadata,
+        [openAIResponsesFunctionConfigMetadataKey]: {
+            allowed_callers: options.allowedCallers ?? ["programmatic"],
+            ...(options.outputSchema ? { output_schema: toJSONSchema(options.outputSchema) } : {})
+        }
+    }
+});
 export const openAIRemoteMcpTool = (config) => hostedTool({
     name: config.server_label ?? "mcp",
     provider: "openai",
@@ -1656,6 +2146,10 @@ export const openAIMcpApprovalResponse = (response) => providerDataPart("openai"
     type: "mcp_approval_response",
     ...response
 });
+export const openAIPromptCacheBreakpoint = () => providerDataPart("openai", {
+    type: "prompt_cache_breakpoint",
+    mode: "explicit"
+});
 export const openAIComputerUseTool = (config) => hostedTool({
     name: "computer",
     provider: "openai",
@@ -1663,63 +2157,106 @@ export const openAIComputerUseTool = (config) => hostedTool({
     toolClass: "computer-use",
     config: config
 });
+export const openAIComputerTool = (config) => ({
+    name: config.name ?? "computer",
+    description: "Execute batched actions requested by the OpenAI Responses computer tool and return a screenshot.",
+    requiresApproval: config.requiresApproval ?? true,
+    metadata: {
+        [openAIResponsesToolMetadataKey]: "computer",
+        "openai.responses_tool_config": {}
+    },
+    schema: z.object({
+        actions: z.array(z.record(z.string(), z.unknown()))
+    }),
+    execute: async (input) => {
+        const output = await config.execute(input);
+        return {
+            ...output,
+            detail: "original"
+        };
+    }
+});
 const runOpenAIShellCommand = async (input, config) => {
     if (config.execute) {
-        return config.execute(input);
+        const result = await config.execute(input);
+        return Array.isArray(result) ? result : [result];
     }
-    const command = input.command ?? input.action?.command;
-    if (!command) {
+    const commands = input.action?.commands?.length
+        ? input.action.commands
+        : [input.command ?? input.action?.command].filter((command) => Boolean(command));
+    if (!commands.length) {
         throw new Error("OpenAI shell tool did not provide a command.");
     }
     const { exec } = await import("node:child_process");
     const { promisify } = await import("node:util");
     const execAsync = promisify(exec);
-    const maxBuffer = Math.max(1024, config.maxOutputLength ?? input.maxOutputLength ?? input.max_output_length ?? input.action?.maxOutputLength ?? input.action?.max_output_length ?? 20000);
+    const maxBuffer = Math.max(1024, config.maxOutputLength ??
+        input.maxOutputLength ??
+        input.max_output_length ??
+        input.action?.maxOutputLength ??
+        input.action?.max_output_length ??
+        20000);
     const cwd = config.rootDir
         ? await assertOpenAIToolPathInsideRoot(config.rootDir, config.cwd ?? ".", "shell cwd")
         : config.cwd;
-    try {
-        const result = await execAsync(command, {
-            cwd,
-            timeout: config.timeoutMs,
-            maxBuffer
-        });
-        return {
-            stdout: result.stdout,
-            stderr: result.stderr,
-            outcome: {
-                type: "exit",
-                exitCode: 0
-            },
-            maxOutputLength: maxBuffer
-        };
-    }
-    catch (error) {
-        const err = error;
-        return {
-            stdout: err.stdout ?? "",
-            stderr: err.stderr ?? err.message ?? "",
-            outcome: {
-                type: err.killed || err.signal === "SIGTERM" ? "timeout" : "exit",
-                exitCode: typeof err.code === "number" ? err.code : 1
-            },
-            maxOutputLength: maxBuffer
-        };
+    const output = [];
+    for (const command of commands) {
+        try {
+            const result = await execAsync(command, {
+                cwd,
+                timeout: config.timeoutMs ?? input.action?.timeout_ms,
+                maxBuffer
+            });
+            output.push({
+                stdout: result.stdout,
+                stderr: result.stderr,
+                outcome: { type: "exit", exit_code: 0 },
+                maxOutputLength: maxBuffer
+            });
+        }
+        catch (error) {
+            const err = error;
+            output.push({
+                stdout: err.stdout ?? "",
+                stderr: err.stderr ?? err.message ?? "",
+                outcome: {
+                    type: err.killed || err.signal === "SIGTERM" ? "timeout" : "exit",
+                    exit_code: typeof err.code === "number" ? err.code : 1
+                },
+                maxOutputLength: maxBuffer
+            });
+        }
     }
+    return output;
 };
+export const openAIHostedShellTool = (config) => hostedTool({
+    name: "shell",
+    provider: "openai",
+    type: "shell",
+    toolClass: "shell",
+    config: {
+        environment: config.environment,
+        ...(config.allowedCallers ? { allowed_callers: config.allowedCallers } : {})
+    }
+});
 export const openAIShellTool = (config = {}) => ({
     name: config.name ?? "shell",
     description: "Run a shell command requested by the OpenAI Responses shell tool.",
     requiresApproval: true,
     metadata: {
         [openAIResponsesToolMetadataKey]: "shell",
-        "openai.responses_tool_config": {}
+        "openai.responses_tool_config": {
+            environment: config.environment ?? { type: "local" },
+            ...(config.allowedCallers ? { allowed_callers: config.allowedCallers } : {})
+        }
     },
     schema: z.object({
         command: z.string().optional(),
         action: z
             .object({
             command: z.string().optional(),
+            commands: z.array(z.string()).optional(),
+            timeout_ms: z.number().optional(),
             max_output_length: z.number().optional(),
             maxOutputLength: z.number().optional()
         })
@@ -1742,7 +2279,9 @@ export const openAIApplyPatchTool = (config) => ({
     requiresApproval: true,
     metadata: {
         [openAIResponsesToolMetadataKey]: "apply_patch",
-        "openai.responses_tool_config": {}
+        "openai.responses_tool_config": {
+            ...(config.allowedCallers ? { allowed_callers: config.allowedCallers } : {})
+        }
     },
     schema: z.object({
         operation: z