@zhivex-ai/openai 0.9.6 → 0.10.0

package/dist/index.js

@@ -1,10 +1,13 @@
 import { toJSONSchema, z } from "zod";
 import { createOpenAIImageGenerationModel, normalizeOpenAIImageGenerationCall, normalizeOpenAIImageGenerationPartialImage } from "./image-generation.js";
-import { CallbackRealtimeSession, ConfigurationError, ProviderHTTPError, ProviderResponseTooLargeError, assertTrustedEndpoint, decodeBase64WithLimit, readBodyWithLimit, readErrorBodyWithLimit, readJsonWithLimit, resolveAudioResponseLimits, openWebSocketConnection, hostedTool, providerDataPart, UnsupportedFeatureError, createProviderAdapter, encodeAudioFrame, encodeMediaFrame, isCallableToolDefinition, isHostedToolDefinition, normalizeFinishReason, streamSSE, toToolSet, toolResultPayload, withRetry, withTimeoutSignal } from "@zhivex-ai/core";
+import { capabilities, groundedCapabilities, inferOpenAIRealtimeMode, isOpenAIGpt56Model, modelCapabilities, openAIRealtimeSupportsImageInput, realtimeCapabilities, speechCapabilities, supportsOpenAIApplyPatchAndSkills, supportsOpenAIShell, transcriptionCapabilities, } from "./capabilities.js";
+import { CallbackRealtimeSession, ConfigurationError, ProviderHTTPError, ProviderResponseTooLargeError, ProviderToolCallError, assertTrustedEndpoint, decodeBase64WithLimit, readBodyWithLimit, readErrorBodyWithLimit, readJsonWithLimit, resolveAudioResponseLimits, openWebSocketConnection, hostedTool, providerDataPart, UnsupportedFeatureError, createProviderAdapter, encodeAudioFrame, encodeMediaFrame, isCallableToolDefinition, isHostedToolDefinition, normalizeFinishReason, streamSSE, toToolSet, toolResultPayload, withRetry, withTimeoutSignal } from "@zhivex-ai/core";
 const MIB = 1024 * 1024;
 const DEFAULT_HOSTED_IMAGE_EVENT_BYTES = 32 * MIB;
 const DEFAULT_HOSTED_IMAGE_TOTAL_BYTES = 128 * MIB;
+const DEFAULT_TOOL_CALL_ARGUMENT_CHARS = MIB;
 const HOSTED_IMAGE_EVENT_JSON_OVERHEAD_CHARS = MIB;
+export const OPENAI_RESPONSES_TOOL_CALL_ERROR_CODE = "OPENAI_RESPONSES_TOOL_CALL_INVALID";
 const normalizeOpenAIResponseLimit = (value, fallback, name) => {
     const resolved = value ?? fallback;
     if (!Number.isSafeInteger(resolved) || resolved <= 0) {
@@ -15,7 +18,16 @@ const normalizeOpenAIResponseLimit = (value, fallback, name) => {
 const resolveOpenAIResponseLimits = (limits = {}) => ({
     ...resolveAudioResponseLimits(limits),
     hostedImageEventBytes: normalizeOpenAIResponseLimit(limits.hostedImageEventBytes, DEFAULT_HOSTED_IMAGE_EVENT_BYTES, "hostedImageEventBytes"),
-    hostedImageTotalBytes: normalizeOpenAIResponseLimit(limits.hostedImageTotalBytes, DEFAULT_HOSTED_IMAGE_TOTAL_BYTES, "hostedImageTotalBytes")
+    hostedImageTotalBytes: normalizeOpenAIResponseLimit(limits.hostedImageTotalBytes, DEFAULT_HOSTED_IMAGE_TOTAL_BYTES, "hostedImageTotalBytes"),
+    toolCallArgumentChars: normalizeOpenAIResponseLimit(limits.toolCallArgumentChars, DEFAULT_TOOL_CALL_ARGUMENT_CHARS, "toolCallArgumentChars")
+});
+const openAIResponsesToolCallError = (reason, effectsPossible = false) => new ProviderToolCallError({
+    provider: "openai",
+    transport: "responses",
+    diagnosticCode: OPENAI_RESPONSES_TOOL_CALL_ERROR_CODE,
+    reason,
+    retryable: !effectsPossible,
+    effectsPossible
 });
 const openAIResponsesToolMetadataKey = "openai.responses_tool_type";
 const openAIResponsesFunctionConfigMetadataKey = "openai.responses_function_config";
@@ -45,174 +57,6 @@ const assertOpenAIToolPathInsideRoot = async (rootDir, targetPath, label) => {
     return target;
 };
 export const openAIRealtimeMcpMetadataKey = "openai.realtime_mcp";
-const capabilities = {
-    streaming: true,
-    tools: true,
-    structuredOutput: true,
-    jsonMode: true,
-    toolChoice: true,
-    parallelToolCalls: true,
-    vision: true,
-    files: false,
-    audioInput: false,
-    audioOutput: false,
-    embeddings: true,
-    reasoning: true,
-    webSearch: true,
-    agentCapabilities: {
-        supportTier: "tier-a",
-        toolChoiceNone: true,
-        approvalRequests: true,
-        hostedWebSearch: true,
-        hostedFileSearch: true,
-        remoteMcp: true,
-        computerUse: true,
-        codeExecution: true,
-        shell: true,
-        applyPatch: true,
-        toolSearch: true,
-        skills: true,
-        toolsets: false
-    }
-};
-const normalizeModelId = (modelId) => modelId.trim().toLowerCase();
-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: supportsOpenAIShell(modelId),
-        applyPatch: supportsOpenAIApplyPatchAndSkills(modelId),
-        skills: supportsOpenAIApplyPatchAndSkills(modelId),
-        toolSearch: supportsOpenAIToolSearch(modelId),
-        programmaticToolCalling: isOpenAIGpt56Model(modelId),
-        multiAgent: isOpenAIGpt56Model(modelId)
-    }
-});
-const transcriptionCapabilities = {
-    ...capabilities,
-    streaming: false,
-    tools: false,
-    structuredOutput: false,
-    jsonMode: false,
-    toolChoice: false,
-    parallelToolCalls: false,
-    vision: false,
-    audioInput: true,
-    audioOutput: false,
-    embeddings: false,
-    reasoning: false,
-    webSearch: false,
-    agentCapabilities: {
-        supportTier: "tier-c",
-        toolChoiceNone: false,
-        approvalRequests: false,
-        hostedWebSearch: false,
-        hostedFileSearch: false,
-        remoteMcp: false,
-        computerUse: false,
-        codeExecution: false,
-        toolsets: false
-    }
-};
-const speechCapabilities = {
-    ...transcriptionCapabilities,
-    audioInput: false,
-    audioOutput: true
-};
-const groundedCapabilities = {
-    ...capabilities,
-    webSearch: true
-};
-const isOpenAIRealtimeTranslationModel = (modelId) => /^gpt-realtime-translate(?:[-@]|$)/.test(modelId);
-const isOpenAIRealtimeTranscriptionModel = (modelId) => /^gpt-realtime-whisper(?:[-@]|$)/.test(modelId);
-const inferOpenAIRealtimeMode = (modelId, mode) => {
-    if (mode) {
-        return mode;
-    }
-    if (isOpenAIRealtimeTranslationModel(modelId)) {
-        return "translation";
-    }
-    if (isOpenAIRealtimeTranscriptionModel(modelId)) {
-        return "transcription";
-    }
-    return "conversation";
-};
-const isOpenAIRealtimeReasoningModel = (modelId) => /^gpt-realtime-2(?:\.1(?:-mini)?)?(?:-\d{4}-\d{2}-\d{2}|@.*)?$/.test(modelId);
-const openAIRealtimeSupportsImageInput = (modelId) => /^(?:gpt-realtime|gpt-realtime-mini|gpt-realtime-1\.5|gpt-realtime-2(?:\.1(?:-mini)?)?)(?:-\d{4}-\d{2}-\d{2}|@.*)?$/.test(modelId);
-const realtimeCapabilities = (modelId) => ({
-    ...capabilities,
-    streaming: false,
-    structuredOutput: false,
-    jsonMode: false,
-    embeddings: false,
-    audioInput: true,
-    audioOutput: !isOpenAIRealtimeTranscriptionModel(modelId),
-    tools: !isOpenAIRealtimeTranslationModel(modelId) && !isOpenAIRealtimeTranscriptionModel(modelId),
-    toolChoice: !isOpenAIRealtimeTranslationModel(modelId) && !isOpenAIRealtimeTranscriptionModel(modelId),
-    parallelToolCalls: !isOpenAIRealtimeTranslationModel(modelId) && !isOpenAIRealtimeTranscriptionModel(modelId),
-    vision: openAIRealtimeSupportsImageInput(modelId),
-    reasoning: isOpenAIRealtimeReasoningModel(modelId),
-    webSearch: false,
-    agentCapabilities: {
-        ...capabilities.agentCapabilities,
-        supportTier: isOpenAIRealtimeTranslationModel(modelId) || isOpenAIRealtimeTranscriptionModel(modelId) ? "tier-c" : "tier-a",
-        toolChoiceNone: !isOpenAIRealtimeTranslationModel(modelId) && !isOpenAIRealtimeTranscriptionModel(modelId),
-        approvalRequests: !isOpenAIRealtimeTranslationModel(modelId) && !isOpenAIRealtimeTranscriptionModel(modelId),
-        hostedWebSearch: false,
-        hostedFileSearch: false,
-        remoteMcp: !isOpenAIRealtimeTranslationModel(modelId) && !isOpenAIRealtimeTranscriptionModel(modelId),
-        computerUse: false,
-        codeExecution: false,
-        shell: false,
-        applyPatch: false,
-        toolSearch: false,
-        skills: false,
-        toolsets: false
-    },
-    realtime: {
-        sessions: true,
-        audioInput: true,
-        audioOutput: !isOpenAIRealtimeTranscriptionModel(modelId),
-        imageInput: openAIRealtimeSupportsImageInput(modelId),
-        tools: !isOpenAIRealtimeTranslationModel(modelId) && !isOpenAIRealtimeTranscriptionModel(modelId),
-        browserTokens: true
-    }
-});
 const jsonHeaders = (apiKey) => ({
     "content-type": "application/json",
     authorization: `Bearer ${apiKey}`
@@ -1220,6 +1064,23 @@ const parseAssistantMessage = (message) => ({
         })) ?? [])
     ]
 });
+const parseOpenAIResponsesToolArguments = (rawArguments, maxChars, effectsPossible = false) => {
+    if (typeof rawArguments !== "string") {
+        throw openAIResponsesToolCallError("incomplete_arguments", effectsPossible);
+    }
+    if (rawArguments.trim().length === 0) {
+        throw openAIResponsesToolCallError("empty_arguments", effectsPossible);
+    }
+    if (rawArguments.length > maxChars) {
+        throw openAIResponsesToolCallError("arguments_too_large", effectsPossible);
+    }
+    try {
+        return JSON.parse(rawArguments);
+    }
+    catch {
+        throw openAIResponsesToolCallError("invalid_json", effectsPossible);
+    }
+};
 const extractAudioOutputs = (message) => message.parts
     .filter((part) => part.type === "audio")
     .map((part) => ({
@@ -1301,9 +1162,29 @@ const toResponsesInput = (messages) => {
     }
     return input;
 };
-const parseResponsesAssistantMessage = (json, multiAgentEnabled = false, localTools = new Map()) => {
+const parseResponsesAssistantMessage = (json, multiAgentEnabled = false, localTools = new Map(), toolCallArgumentChars = DEFAULT_TOOL_CALL_ARGUMENT_CHARS) => {
     const parts = [];
-    for (const [index, item] of (json.output ?? []).entries()) {
+    const output = Array.isArray(json.output) ? json.output : [];
+    const responseStatus = typeof json.status === "string" ? json.status : undefined;
+    const isExecutableToolOutput = (item) => item?.type === "function_call" ||
+        (item?.type === "shell_call" && localTools.has("shell")) ||
+        (item?.type === "apply_patch_call" && localTools.has("apply_patch")) ||
+        (item?.type === "computer_call" && localTools.has("computer"));
+    const hasExecutableToolOutput = output.some(isExecutableToolOutput);
+    if (hasExecutableToolOutput && responseStatus !== "completed") {
+        throw openAIResponsesToolCallError(responseStatus === "failed"
+            ? "response_failed"
+            : responseStatus === "incomplete"
+                ? "response_incomplete"
+                : "inconsistent_metadata");
+    }
+    const nonCompletedToolOutput = output.find((item) => isExecutableToolOutput(item) &&
+        typeof item.status === "string" &&
+        item.status !== "completed");
+    if (nonCompletedToolOutput) {
+        throw openAIResponsesToolCallError(nonCompletedToolOutput.status === "failed" ? "response_failed" : "incomplete_arguments");
+    }
+    for (const [index, item] of output.entries()) {
         if (item?.type === "message") {
             if (multiAgentEnabled && (item.agent?.agent_name !== "/root" || item.phase !== "final_answer")) {
                 continue;
@@ -1319,13 +1200,21 @@ const parseResponsesAssistantMessage = (json, multiAgentEnabled = false, localTo
             continue;
         }
         if (item?.type === "function_call") {
-            const callId = item.call_id ?? item.id ?? `${item.name}-${index}`;
+            if (typeof item.call_id !== "string" ||
+                item.call_id.length === 0 ||
+                typeof item.name !== "string" ||
+                item.name.length === 0) {
+                throw openAIResponsesToolCallError("inconsistent_metadata");
+            }
+            if (item.status === "incomplete" || item.status === "failed") {
+                throw openAIResponsesToolCallError(item.status === "failed" ? "response_failed" : "incomplete_arguments");
+            }
             parts.push({
                 type: "tool-call",
                 toolCall: {
-                    id: callId,
+                    id: item.call_id,
                     name: item.name,
-                    input: JSON.parse(item.arguments ?? "{}"),
+                    input: parseOpenAIResponsesToolArguments(item.arguments, toolCallArgumentChars),
                     ...(item.caller && typeof item.caller === "object"
                         ? { providerMetadata: { caller: item.caller } }
                         : {})
@@ -1404,6 +1293,9 @@ const extractResponsesImageOutputs = (response, outputFormat = "png") => (Array.
     return normalized?.image ? [normalized.image] : [];
 });
 const normalizeResponsesFinishReason = (status, hasToolCalls, hasRefusal = false) => {
+    if (status === "failed") {
+        return "error";
+    }
     if (hasToolCalls) {
         return "tool-calls";
     }
@@ -1413,9 +1305,6 @@ const normalizeResponsesFinishReason = (status, hasToolCalls, hasRefusal = false
     if (status === "completed") {
         return "stop";
     }
-    if (status === "failed") {
-        return "error";
-    }
     return normalizeFinishReason(status);
 };
 const mapResponsesUsage = (usage) => usage
@@ -1453,14 +1342,19 @@ const addTokenUsage = (left, right) => {
         totalTokens: sum(left.totalTokens, right.totalTokens)
     };
 };
-const streamResponses = async function* (response, multiAgentEnabled = false, localTools = new Map(), imageGeneration) {
+const streamResponses = async function* (response, multiAgentEnabled = false, localTools = new Map(), imageGeneration, toolCallArgumentChars = DEFAULT_TOOL_CALL_ARGUMENT_CHARS) {
     const toolBuffers = new Map();
+    const toolBuffersByOutputIndex = new Map();
+    const pendingExecutableEvents = [];
+    const pendingExecutableProviderEvents = [];
     const outputAgents = new Map();
     const hostedImageEventMaxBytes = imageGeneration?.eventMaxBytes ?? DEFAULT_HOSTED_IMAGE_EVENT_BYTES;
     const hostedImageTotalMaxBytes = imageGeneration?.totalMaxBytes ?? DEFAULT_HOSTED_IMAGE_TOTAL_BYTES;
     let hostedImageBytes = 0;
     let sawToolCalls = false;
     let sawRefusal = false;
+    let sawTerminalResponse = false;
+    let nextToolOrder = 0;
     const recordHostedImageBytes = (image) => {
         const receivedBytes = hostedImageBytes + (image.data?.byteLength ?? 0);
         if (receivedBytes > hostedImageTotalMaxBytes) {
@@ -1473,32 +1367,155 @@ const streamResponses = async function* (response, multiAgentEnabled = false, lo
         }
         hostedImageBytes = receivedBytes;
     };
-    const emitToolCall = (key) => {
-        const toolCall = toolBuffers.get(key);
-        if (!toolCall || toolCall.emitted || !toolCall.name) {
-            return undefined;
+    const toolBufferKey = (itemId, outputIndex) => {
+        if (typeof itemId === "string" && itemId.length > 0) {
+            return `item:${itemId}`;
         }
-        toolCall.emitted = true;
-        sawToolCalls = true;
-        return {
-            type: "tool-call",
-            toolCall: {
-                id: toolCall.callId,
-                name: toolCall.name,
-                input: JSON.parse(toolCall.args || "{}"),
-                ...(toolCall.caller !== undefined ? { providerMetadata: { caller: toolCall.caller } } : {})
+        if (typeof outputIndex === "number" && Number.isSafeInteger(outputIndex) && outputIndex >= 0) {
+            return `output:${outputIndex}`;
+        }
+        throw openAIResponsesToolCallError("inconsistent_metadata", sawToolCalls);
+    };
+    const getToolBuffer = (key, itemId, outputIndex) => {
+        const canonicalItemId = typeof itemId === "string" && itemId.length > 0 ? itemId : undefined;
+        const canonicalOutputIndex = typeof outputIndex === "number" && Number.isSafeInteger(outputIndex) && outputIndex >= 0
+            ? outputIndex
+            : undefined;
+        const bindItemId = (toolCall) => {
+            if (canonicalItemId !== undefined &&
+                toolCall.itemId !== undefined &&
+                toolCall.itemId !== canonicalItemId) {
+                throw openAIResponsesToolCallError("inconsistent_metadata", sawToolCalls);
+            }
+            if (canonicalItemId !== undefined) {
+                toolCall.itemId = canonicalItemId;
             }
         };
+        const bindOutputIndex = (toolCall) => {
+            if (canonicalOutputIndex === undefined) {
+                return;
+            }
+            if (toolCall.outputIndex !== undefined && toolCall.outputIndex !== canonicalOutputIndex) {
+                throw openAIResponsesToolCallError("inconsistent_metadata", sawToolCalls);
+            }
+            const indexed = toolBuffersByOutputIndex.get(canonicalOutputIndex);
+            if (indexed && indexed !== toolCall) {
+                throw openAIResponsesToolCallError("inconsistent_metadata", sawToolCalls);
+            }
+            toolCall.outputIndex = canonicalOutputIndex;
+            toolBuffersByOutputIndex.set(canonicalOutputIndex, toolCall);
+        };
+        const existing = toolBuffers.get(key);
+        if (existing) {
+            bindItemId(existing);
+            bindOutputIndex(existing);
+            return existing;
+        }
+        if (canonicalOutputIndex !== undefined) {
+            const indexed = toolBuffersByOutputIndex.get(canonicalOutputIndex);
+            if (indexed) {
+                bindItemId(indexed);
+                toolBuffers.set(key, indexed);
+                return indexed;
+            }
+        }
+        const created = {
+            ...(canonicalItemId !== undefined ? { itemId: canonicalItemId } : {}),
+            deltaArguments: "",
+            argumentsDone: false,
+            outputItemDone: false,
+            emitted: false,
+            order: nextToolOrder++,
+            ...(canonicalOutputIndex !== undefined ? { outputIndex: canonicalOutputIndex } : {})
+        };
+        toolBuffers.set(key, created);
+        if (created.outputIndex !== undefined) {
+            toolBuffersByOutputIndex.set(created.outputIndex, created);
+        }
+        return created;
+    };
+    const mergeToolString = (toolCall, field, value) => {
+        if (typeof value !== "string" || value.length === 0) {
+            return;
+        }
+        if (toolCall[field] !== undefined && toolCall[field] !== value) {
+            throw openAIResponsesToolCallError("inconsistent_metadata", sawToolCalls);
+        }
+        toolCall[field] = value;
+    };
+    const ensureArgumentLimit = (argumentsValue) => {
+        if (argumentsValue.length > toolCallArgumentChars) {
+            throw openAIResponsesToolCallError("arguments_too_large", sawToolCalls);
+        }
+    };
+    const setFinalArguments = (toolCall, argumentsValue) => {
+        if (typeof argumentsValue !== "string") {
+            return;
+        }
+        ensureArgumentLimit(argumentsValue);
+        if (toolCall.finalArguments !== undefined && toolCall.finalArguments !== argumentsValue) {
+            throw openAIResponsesToolCallError("inconsistent_metadata", sawToolCalls);
+        }
+        if (toolCall.deltaArguments.length > 0 && toolCall.deltaArguments !== argumentsValue) {
+            throw openAIResponsesToolCallError("inconsistent_metadata", sawToolCalls);
+        }
+        toolCall.finalArguments = argumentsValue;
+    };
+    const materializeToolCalls = () => {
+        const pending = [...new Set(toolBuffers.values())]
+            .filter((toolCall) => !toolCall.emitted)
+            .sort((left, right) => (left.outputIndex ?? Number.MAX_SAFE_INTEGER) - (right.outputIndex ?? Number.MAX_SAFE_INTEGER) ||
+            left.order - right.order);
+        const events = pending.map((toolCall) => {
+            if (!toolCall.callId ||
+                !toolCall.name ||
+                (!toolCall.argumentsDone && !toolCall.outputItemDone)) {
+                throw openAIResponsesToolCallError("incomplete_arguments", sawToolCalls);
+            }
+            if (toolCall.itemStatus === "failed" || toolCall.itemStatus === "incomplete") {
+                throw openAIResponsesToolCallError(toolCall.itemStatus === "failed" ? "response_failed" : "incomplete_arguments", sawToolCalls);
+            }
+            const rawArguments = toolCall.finalArguments ?? toolCall.deltaArguments;
+            const input = parseOpenAIResponsesToolArguments(rawArguments, toolCallArgumentChars, sawToolCalls);
+            return {
+                type: "tool-call",
+                toolCall: {
+                    id: toolCall.callId,
+                    name: toolCall.name,
+                    input,
+                    ...(toolCall.caller !== undefined ? { providerMetadata: { caller: toolCall.caller } } : {})
+                }
+            };
+        });
+        for (const toolCall of pending) {
+            toolCall.emitted = true;
+        }
+        if (events.length > 0) {
+            sawToolCalls = true;
+        }
+        return events;
     };
     const maxHostedImageEventChars = Math.min(Number.MAX_SAFE_INTEGER, 4 * Math.ceil(hostedImageEventMaxBytes / 3) + HOSTED_IMAGE_EVENT_JSON_OVERHEAD_CHARS);
     for await (const event of streamSSE(response, imageGeneration
         ? { maxEventChars: maxHostedImageEventChars, maxBufferChars: maxHostedImageEventChars }
         : undefined)) {
         if (event.data === "[DONE]") {
-            return;
+            break;
+        }
+        let json;
+        try {
+            json = JSON.parse(event.data);
+        }
+        catch (error) {
+            if (toolBuffers.size > 0 || sawToolCalls) {
+                throw openAIResponsesToolCallError("stream_truncated", sawToolCalls);
+            }
+            throw error;
         }
-        const json = JSON.parse(event.data);
         const type = json.type;
+        if (sawTerminalResponse) {
+            continue;
+        }
         if (type === "response.image_generation_call.partial_image") {
             const normalized = normalizeOpenAIImageGenerationPartialImage(json, imageGeneration?.outputFormat ?? "png", hostedImageEventMaxBytes);
             if (normalized) {
@@ -1516,6 +1533,9 @@ const streamResponses = async function* (response, multiAgentEnabled = false, lo
             continue;
         }
         if (type === "error") {
+            if (toolBuffers.size > 0 || pendingExecutableEvents.length > 0 || sawToolCalls) {
+                throw openAIResponsesToolCallError("response_failed", sawToolCalls);
+            }
             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" &&
@@ -1536,6 +1556,16 @@ const streamResponses = async function* (response, multiAgentEnabled = false, lo
         if (type === "response.output_item.added" || type === "response.output_item.done") {
             const item = json.item;
             let handledLocalToolCall = false;
+            const isLocalExecutableItem = item?.type === "function_call" ||
+                (item?.type === "shell_call" && localTools.has("shell")) ||
+                (item?.type === "apply_patch_call" && localTools.has("apply_patch")) ||
+                (item?.type === "computer_call" && localTools.has("computer"));
+            if (type === "response.output_item.done" &&
+                isLocalExecutableItem &&
+                typeof item.status === "string" &&
+                item.status !== "completed") {
+                throw openAIResponsesToolCallError(item.status === "failed" ? "response_failed" : "incomplete_arguments", sawToolCalls);
+            }
             if (item?.type === "image_generation_call" && type === "response.output_item.done") {
                 const normalized = normalizeOpenAIImageGenerationCall(item, imageGeneration?.outputFormat ?? "png", hostedImageEventMaxBytes);
                 if (normalized?.image) {
@@ -1556,31 +1586,26 @@ const streamResponses = async function* (response, multiAgentEnabled = false, lo
                 });
             }
             if (item?.type === "function_call") {
-                const key = item.id ?? json.item_id ?? `${json.output_index ?? toolBuffers.size}`;
-                const existing = toolBuffers.get(key) ?? {
-                    callId: item.call_id ?? key,
-                    name: item.name ?? "",
-                    args: "",
-                    emitted: false
-                };
-                existing.callId = item.call_id ?? existing.callId;
-                existing.name ||= item.name ?? "";
+                const itemId = item.id ?? json.item_id;
+                const key = toolBufferKey(itemId, json.output_index);
+                const existing = getToolBuffer(key, itemId, json.output_index);
+                mergeToolString(existing, "callId", item.call_id);
+                mergeToolString(existing, "name", item.name);
                 if (item.caller && typeof item.caller === "object") {
                     existing.caller = item.caller;
                 }
-                if (typeof item.arguments === "string") {
-                    existing.args = item.arguments;
-                }
-                toolBuffers.set(key, existing);
                 if (type === "response.output_item.done") {
-                    const emitted = emitToolCall(key);
-                    if (emitted) {
-                        yield emitted;
-                    }
+                    existing.outputItemDone = true;
+                    existing.itemStatus = typeof item.status === "string" ? item.status : existing.itemStatus;
+                    setFinalArguments(existing, item.arguments);
+                }
+                else if (typeof item.arguments === "string" && item.arguments.length > 0) {
+                    ensureArgumentLimit(item.arguments);
+                    existing.deltaArguments = item.arguments;
                 }
             }
             if (item?.type === "shell_call" && type === "response.output_item.done" && localTools.has("shell")) {
-                yield {
+                pendingExecutableEvents.push({
                     type: "tool-call",
                     toolCall: {
                         id: item.call_id ?? item.id ?? `${json.output_index ?? "shell"}`,
@@ -1588,12 +1613,11 @@ const streamResponses = async function* (response, multiAgentEnabled = false, lo
                         input: parseShellCallInput(item),
                         providerMetadata: { responsesToolType: "shell" }
                     }
-                };
-                sawToolCalls = true;
+                });
                 handledLocalToolCall = true;
             }
             if (item?.type === "apply_patch_call" && type === "response.output_item.done" && localTools.has("apply_patch")) {
-                yield {
+                pendingExecutableEvents.push({
                     type: "tool-call",
                     toolCall: {
                         id: item.call_id ?? item.id ?? `${json.output_index ?? "apply_patch"}`,
@@ -1601,12 +1625,11 @@ const streamResponses = async function* (response, multiAgentEnabled = false, lo
                         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 {
+                pendingExecutableEvents.push({
                     type: "tool-call",
                     toolCall: {
                         id: item.call_id ?? item.id ?? `${json.output_index ?? "computer"}`,
@@ -1616,8 +1639,7 @@ const streamResponses = async function* (response, multiAgentEnabled = false, lo
                         },
                         providerMetadata: { responsesToolType: "computer" }
                     }
-                };
-                sawToolCalls = true;
+                });
                 handledLocalToolCall = true;
             }
             const providerData = parseResponsesProviderData(item);
@@ -1629,7 +1651,7 @@ const streamResponses = async function* (response, multiAgentEnabled = false, lo
                 };
             }
             if (item && type === "response.output_item.done") {
-                yield {
+                const outputEvent = {
                     type: "provider-data",
                     provider: "openai",
                     data: {
@@ -1637,41 +1659,60 @@ const streamResponses = async function* (response, multiAgentEnabled = false, lo
                         items: [item]
                     }
                 };
+                if (item.type === "function_call" || handledLocalToolCall) {
+                    pendingExecutableProviderEvents.push(outputEvent);
+                }
+                else {
+                    yield outputEvent;
+                }
             }
             continue;
         }
         if (type === "response.function_call_arguments.delta") {
-            const key = json.item_id ?? `${json.output_index ?? toolBuffers.size}`;
-            const existing = toolBuffers.get(key) ?? {
-                callId: key,
-                name: "",
-                args: "",
-                emitted: false
-            };
-            existing.args += typeof json.delta === "string" ? json.delta : "";
-            toolBuffers.set(key, existing);
+            const key = toolBufferKey(json.item_id, json.output_index);
+            const existing = getToolBuffer(key, json.item_id, json.output_index);
+            mergeToolString(existing, "callId", json.call_id);
+            mergeToolString(existing, "name", json.name);
+            if (typeof json.delta === "string") {
+                const nextArguments = existing.deltaArguments + json.delta;
+                ensureArgumentLimit(nextArguments);
+                existing.deltaArguments = nextArguments;
+            }
             continue;
         }
         if (type === "response.function_call_arguments.done") {
-            const key = json.item_id ?? `${json.output_index ?? toolBuffers.size}`;
-            const existing = toolBuffers.get(key) ?? {
-                callId: key,
-                name: "",
-                args: "",
-                emitted: false
-            };
-            if (typeof json.arguments === "string") {
-                existing.args = json.arguments;
-            }
-            toolBuffers.set(key, existing);
-            const emitted = emitToolCall(key);
-            if (emitted) {
-                yield emitted;
-            }
+            const key = toolBufferKey(json.item_id, json.output_index);
+            const existing = getToolBuffer(key, json.item_id, json.output_index);
+            mergeToolString(existing, "callId", json.call_id);
+            mergeToolString(existing, "name", json.name);
+            existing.argumentsDone = true;
+            setFinalArguments(existing, json.arguments);
             continue;
         }
         if (type === "response.completed" || type === "response.failed" || type === "response.incomplete") {
             const responseData = json.response ?? {};
+            const responseStatus = typeof responseData.status === "string"
+                ? responseData.status
+                : type.slice("response.".length);
+            sawTerminalResponse = true;
+            if (responseStatus === "completed") {
+                for (const toolCallEvent of materializeToolCalls()) {
+                    yield toolCallEvent;
+                }
+                if (pendingExecutableEvents.length > 0) {
+                    sawToolCalls = true;
+                    for (const toolCallEvent of pendingExecutableEvents) {
+                        yield toolCallEvent;
+                    }
+                }
+                for (const providerEvent of pendingExecutableProviderEvents) {
+                    yield providerEvent;
+                }
+            }
+            else if ((responseStatus === "failed" || responseStatus === "incomplete") &&
+                (toolBuffers.size > 0 || pendingExecutableEvents.length > 0 || sawToolCalls)) {
+                throw openAIResponsesToolCallError(responseStatus === "failed" ? "response_failed" : "response_incomplete", sawToolCalls);
+            }
             if (typeof responseData.id === "string") {
                 yield {
                     type: "provider-data",
@@ -1681,12 +1722,17 @@ const streamResponses = async function* (response, multiAgentEnabled = false, lo
             }
             yield {
                 type: "finish",
-                finishReason: normalizeResponsesFinishReason(responseData.status, sawToolCalls, sawRefusal),
-                providerFinishReason: responseData.status,
+                finishReason: normalizeResponsesFinishReason(responseStatus, sawToolCalls, sawRefusal),
+                providerFinishReason: responseStatus,
                 usage: mapResponsesUsage(responseData.usage)
             };
+            continue;
         }
     }
+    if (!sawTerminalResponse &&
+        (toolBuffers.size > 0 || pendingExecutableEvents.length > 0 || sawToolCalls)) {
+        throw openAIResponsesToolCallError("stream_truncated", sawToolCalls);
+    }
 };
 const streamGenerateResult = async function* (result) {
     for (const message of result.messages ?? (result.message ? [result.message] : [])) {
@@ -1805,7 +1851,7 @@ class OpenAILanguageModel {
             }), input);
             const json = await parseJson(response);
             accumulatedUsage = addTokenUsage(accumulatedUsage, mapResponsesUsage(json.usage));
-            const assistantMessage = parseResponsesAssistantMessage(json, options.multiAgentEnabled, localResponsesTools(input.tools));
+            const assistantMessage = parseResponsesAssistantMessage(json, options.multiAgentEnabled, localResponsesTools(input.tools), this.responseLimits.toolCallArgumentChars);
             const currentOutput = Array.isArray(json.output)
                 ? json.output
                 : [];
@@ -1937,9 +1983,10 @@ class OpenAILanguageModel {
                 })
             }), input);
             const imageGeneration = responsesImageGenerationConfig(input.tools, this.responseLimits);
+            const toolCallArgumentChars = this.responseLimits.toolCallArgumentChars;
             return (async function* () {
                 try {
-                    yield* streamResponses(response, options.multiAgentEnabled, localResponsesTools(input.tools), imageGeneration);
+                    yield* streamResponses(response, options.multiAgentEnabled, localResponsesTools(input.tools), imageGeneration, toolCallArgumentChars);
                 }
                 finally {
                     cleanup();