@fleetagent/pi-ai 0.1.8 → 0.2.0

package/dist/providers/openai-responses-shared.js

@@ -3,9 +3,6 @@ import { shortHash } from "../utils/hash.js";
 import { parseStreamingJson } from "../utils/json-parse.js";
 import { sanitizeSurrogates } from "../utils/sanitize-unicode.js";
 import { transformMessages } from "./transform-messages.js";
-// =============================================================================
-// Utilities
-// =============================================================================
 function encodeTextSignatureV1(id, phase) {
     const payload = { v: 1, id };
     if (phase)
@@ -34,169 +31,162 @@ function parseTextSignature(signature) {
 // =============================================================================
 // Message conversion
 // =============================================================================
-export function convertResponsesMessages(model, context, allowedToolCallProviders, options) {
-    const messages = [];
-    const normalizeIdPart = (part) => {
-        const sanitized = part.replace(/[^a-zA-Z0-9_-]/g, "_");
-        const normalized = sanitized.length > 64 ? sanitized.slice(0, 64) : sanitized;
-        return normalized.replace(/_+$/, "");
+function normalizeResponsesIdPart(part) {
+    const sanitized = part.replace(/[^a-zA-Z0-9_-]/g, "_");
+    const normalized = sanitized.length > 64 ? sanitized.slice(0, 64) : sanitized;
+    return normalized.replace(/_+$/, "");
+}
+function buildForeignResponsesItemId(itemId) {
+    const normalized = `fc_${shortHash(itemId)}`;
+    return normalized.length > 64 ? normalized.slice(0, 64) : normalized;
+}
+function normalizeResponsesToolCallId(id, model, source, allowedToolCallProviders) {
+    if (!allowedToolCallProviders.has(model.provider))
+        return normalizeResponsesIdPart(id);
+    if (!id.includes("|"))
+        return normalizeResponsesIdPart(id);
+    const [callId, itemId] = id.split("|");
+    const normalizedCallId = normalizeResponsesIdPart(callId);
+    const isForeignToolCall = source.provider !== model.provider || source.api !== model.api;
+    let normalizedItemId = isForeignToolCall ? buildForeignResponsesItemId(itemId) : normalizeResponsesIdPart(itemId);
+    // OpenAI Responses API requires item IDs to start with "fc".
+    if (!normalizedItemId.startsWith("fc_"))
+        normalizedItemId = normalizeResponsesIdPart(`fc_${normalizedItemId}`);
+    return `${normalizedCallId}|${normalizedItemId}`;
+}
+function convertResponsesUserMessage(message) {
+    if (typeof message.content === "string") {
+        return [
+            {
+                role: "user",
+                content: [{ type: "input_text", text: sanitizeSurrogates(message.content) }],
+            },
+        ];
+    }
+    const content = message.content.map((item) => {
+        if (item.type === "text") {
+            return {
+                type: "input_text",
+                text: sanitizeSurrogates(item.text),
+            };
+        }
+        return {
+            type: "input_image",
+            detail: "auto",
+            image_url: `data:${item.mimeType};base64,${item.data}`,
+        };
+    });
+    return content.length === 0 ? [] : [{ role: "user", content }];
+}
+function resolveResponsesMessageId(textBlock, messageIndex, textBlockIndex) {
+    const parsedSignature = parseTextSignature(textBlock.textSignature);
+    const fallbackId = textBlockIndex === 0 ? `msg_pi_${messageIndex}` : `msg_pi_${messageIndex}_${textBlockIndex}`;
+    if (!parsedSignature?.id)
+        return { id: fallbackId };
+    return {
+        ...parsedSignature,
+        id: parsedSignature.id.length > 64 ? `msg_${shortHash(parsedSignature.id)}` : parsedSignature.id,
     };
-    const buildForeignResponsesItemId = (itemId) => {
-        const normalized = `fc_${shortHash(itemId)}`;
-        return normalized.length > 64 ? normalized.slice(0, 64) : normalized;
+}
+function convertResponsesTextBlock(block, messageIndex, textBlockIndex) {
+    const signature = resolveResponsesMessageId(block, messageIndex, textBlockIndex);
+    return {
+        type: "message",
+        role: "assistant",
+        content: [{ type: "output_text", text: sanitizeSurrogates(block.text), annotations: [] }],
+        status: "completed",
+        id: signature.id,
+        phase: signature.phase,
     };
-    const normalizeToolCallId = (id, _targetModel, source) => {
-        if (!allowedToolCallProviders.has(model.provider))
-            return normalizeIdPart(id);
-        if (!id.includes("|"))
-            return normalizeIdPart(id);
-        const [callId, itemId] = id.split("|");
-        const normalizedCallId = normalizeIdPart(callId);
-        const isForeignToolCall = source.provider !== model.provider || source.api !== model.api;
-        let normalizedItemId = isForeignToolCall ? buildForeignResponsesItemId(itemId) : normalizeIdPart(itemId);
-        // OpenAI Responses API requires item id to start with "fc"
-        if (!normalizedItemId.startsWith("fc_")) {
-            normalizedItemId = normalizeIdPart(`fc_${normalizedItemId}`);
-        }
-        return `${normalizedCallId}|${normalizedItemId}`;
+}
+function convertResponsesToolCall(block, isDifferentModel) {
+    const [callId, rawItemId] = block.id.split("|");
+    const itemId = isDifferentModel && rawItemId?.startsWith("fc_") ? undefined : rawItemId;
+    return {
+        type: "function_call",
+        id: itemId,
+        call_id: callId,
+        name: block.name,
+        arguments: JSON.stringify(block.arguments),
     };
+}
+function convertResponsesAssistantMessage(message, model, messageIndex) {
+    const output = [];
+    const isDifferentModel = message.model !== model.id && message.provider === model.provider && message.api === model.api;
+    let textBlockIndex = 0;
+    for (const block of message.content) {
+        if (block.type === "thinking") {
+            if (block.thinkingSignature)
+                output.push(JSON.parse(block.thinkingSignature));
+            continue;
+        }
+        if (block.type === "text") {
+            output.push(convertResponsesTextBlock(block, messageIndex, textBlockIndex));
+            textBlockIndex++;
+            continue;
+        }
+        if (block.type === "toolCall")
+            output.push(convertResponsesToolCall(block, isDifferentModel));
+    }
+    return output;
+}
+function buildResponsesToolOutput(message, supportsImages) {
+    const textResult = message.content
+        .filter((content) => content.type === "text")
+        .map((content) => content.text)
+        .join("\n");
+    const hasImages = message.content.some((content) => content.type === "image");
+    const hasText = textResult.length > 0;
+    if (!hasImages || !supportsImages) {
+        return sanitizeSurrogates(hasText ? textResult : hasImages ? "(see attached image)" : "(no tool output)");
+    }
+    const contentParts = [];
+    if (hasText)
+        contentParts.push({ type: "input_text", text: sanitizeSurrogates(textResult) });
+    for (const block of message.content) {
+        if (block.type !== "image")
+            continue;
+        contentParts.push({
+            type: "input_image",
+            detail: "auto",
+            image_url: `data:${block.mimeType};base64,${block.data}`,
+        });
+    }
+    return contentParts;
+}
+function convertResponsesToolResult(message, model) {
+    const [callId] = message.toolCallId.split("|");
+    return [
+        {
+            type: "function_call_output",
+            call_id: callId,
+            output: buildResponsesToolOutput(message, model.input.includes("image")),
+        },
+    ];
+}
+export function convertResponsesMessages(model, context, allowedToolCallProviders, options) {
+    const messages = [];
+    const normalizeToolCallId = (id, _targetModel, source) => normalizeResponsesToolCallId(id, model, source, allowedToolCallProviders);
     const transformedMessages = transformMessages(context.messages, model, normalizeToolCallId);
-    const includeSystemPrompt = options?.includeSystemPrompt ?? true;
-    if (includeSystemPrompt && context.systemPrompt) {
-        const role = model.reasoning ? "developer" : "system";
+    if ((options?.includeSystemPrompt ?? true) && context.systemPrompt) {
         messages.push({
-            role,
+            role: model.reasoning ? "developer" : "system",
             content: sanitizeSurrogates(context.systemPrompt),
         });
     }
-    let msgIndex = 0;
-    for (const msg of transformedMessages) {
-        if (msg.role === "user") {
-            if (typeof msg.content === "string") {
-                messages.push({
-                    role: "user",
-                    content: [{ type: "input_text", text: sanitizeSurrogates(msg.content) }],
-                });
-            }
-            else {
-                const content = msg.content.map((item) => {
-                    if (item.type === "text") {
-                        return {
-                            type: "input_text",
-                            text: sanitizeSurrogates(item.text),
-                        };
-                    }
-                    return {
-                        type: "input_image",
-                        detail: "auto",
-                        image_url: `data:${item.mimeType};base64,${item.data}`,
-                    };
-                });
-                if (content.length === 0)
-                    continue;
-                messages.push({
-                    role: "user",
-                    content,
-                });
-            }
-        }
-        else if (msg.role === "assistant") {
-            const output = [];
-            const assistantMsg = msg;
-            const isDifferentModel = assistantMsg.model !== model.id &&
-                assistantMsg.provider === model.provider &&
-                assistantMsg.api === model.api;
-            let textBlockIndex = 0;
-            for (const block of msg.content) {
-                if (block.type === "thinking") {
-                    if (block.thinkingSignature) {
-                        const reasoningItem = JSON.parse(block.thinkingSignature);
-                        output.push(reasoningItem);
-                    }
-                }
-                else if (block.type === "text") {
-                    const textBlock = block;
-                    const parsedSignature = parseTextSignature(textBlock.textSignature);
-                    const fallbackMessageId = textBlockIndex === 0 ? `msg_pi_${msgIndex}` : `msg_pi_${msgIndex}_${textBlockIndex}`;
-                    textBlockIndex++;
-                    // OpenAI requires id to be max 64 characters
-                    let msgId = parsedSignature?.id;
-                    if (!msgId) {
-                        msgId = fallbackMessageId;
-                    }
-                    else if (msgId.length > 64) {
-                        msgId = `msg_${shortHash(msgId)}`;
-                    }
-                    output.push({
-                        type: "message",
-                        role: "assistant",
-                        content: [{ type: "output_text", text: sanitizeSurrogates(textBlock.text), annotations: [] }],
-                        status: "completed",
-                        id: msgId,
-                        phase: parsedSignature?.phase,
-                    });
-                }
-                else if (block.type === "toolCall") {
-                    const toolCall = block;
-                    const [callId, itemIdRaw] = toolCall.id.split("|");
-                    let itemId = itemIdRaw;
-                    // For different-model messages, set id to undefined to avoid pairing validation.
-                    // OpenAI tracks which fc_xxx IDs were paired with rs_xxx reasoning items.
-                    // By omitting the id, we avoid triggering that validation (like cross-provider does).
-                    if (isDifferentModel && itemId?.startsWith("fc_")) {
-                        itemId = undefined;
-                    }
-                    output.push({
-                        type: "function_call",
-                        id: itemId,
-                        call_id: callId,
-                        name: toolCall.name,
-                        arguments: JSON.stringify(toolCall.arguments),
-                    });
-                }
-            }
-            if (output.length === 0)
-                continue;
-            messages.push(...output);
-        }
-        else if (msg.role === "toolResult") {
-            const textResult = msg.content
-                .filter((c) => c.type === "text")
-                .map((c) => c.text)
-                .join("\n");
-            const hasImages = msg.content.some((c) => c.type === "image");
-            const hasText = textResult.length > 0;
-            const [callId] = msg.toolCallId.split("|");
-            let output;
-            if (hasImages && model.input.includes("image")) {
-                const contentParts = [];
-                if (hasText) {
-                    contentParts.push({
-                        type: "input_text",
-                        text: sanitizeSurrogates(textResult),
-                    });
-                }
-                for (const block of msg.content) {
-                    if (block.type === "image") {
-                        contentParts.push({
-                            type: "input_image",
-                            detail: "auto",
-                            image_url: `data:${block.mimeType};base64,${block.data}`,
-                        });
-                    }
-                }
-                output = contentParts;
-            }
-            else {
-                output = sanitizeSurrogates(hasText ? textResult : "(see attached image)");
-            }
-            messages.push({
-                type: "function_call_output",
-                call_id: callId,
-                output,
-            });
-        }
-        msgIndex++;
+    let messageIndex = 0;
+    for (const message of transformedMessages) {
+        let converted;
+        if (message.role === "user")
+            converted = convertResponsesUserMessage(message);
+        else if (message.role === "assistant")
+            converted = convertResponsesAssistantMessage(message, model, messageIndex);
+        else
+            converted = convertResponsesToolResult(message, model);
+        if (converted.length === 0)
+            continue;
+        messages.push(...converted);
+        messageIndex++;
     }
     return messages;
 }
@@ -213,34 +203,50 @@ export function convertResponsesTools(tools, options) {
         strict,
     }));
 }
-export async function processResponsesStream(openaiStream, output, stream, model, options) {
-    const outputSlots = new Map();
-    const getSlot = (outputIndex, type) => {
-        const slot = outputSlots.get(outputIndex);
-        return slot?.type === type ? slot : undefined;
-    };
-    const createSlot = (outputIndex, item) => {
-        if (item.type === "reasoning") {
+function applyResponsesMessagePhaseStopReason(output, item) {
+    if (item.type === "message" && item.phase === "final_answer")
+        output.stopReason = "stop";
+}
+function getResponsesThinkingSlot(state, outputIndex) {
+    const slot = state.outputSlots.get(outputIndex);
+    return slot?.type === "thinking" ? slot : undefined;
+}
+function getResponsesTextSlot(state, outputIndex) {
+    const slot = state.outputSlots.get(outputIndex);
+    return slot?.type === "text" ? slot : undefined;
+}
+function getResponsesToolCallSlot(state, outputIndex) {
+    const slot = state.outputSlots.get(outputIndex);
+    return slot?.type === "toolCall" ? slot : undefined;
+}
+function createResponsesOutputSlot(state, outputIndex, item) {
+    switch (item.type) {
+        case "reasoning": {
             const block = { type: "thinking", thinking: "" };
-            output.content.push(block);
+            state.output.content.push(block);
             const slot = {
                 type: "thinking",
                 block,
-                contentIndex: output.content.length - 1,
+                contentIndex: state.output.content.length - 1,
             };
-            outputSlots.set(outputIndex, slot);
-            stream.push({ type: "thinking_start", contentIndex: slot.contentIndex, partial: output });
+            state.outputSlots.set(outputIndex, slot);
+            state.stream.push({ type: "thinking_start", contentIndex: slot.contentIndex, partial: state.output });
             return slot;
         }
-        if (item.type === "message") {
+        case "message": {
+            applyResponsesMessagePhaseStopReason(state.output, item);
             const block = { type: "text", text: "" };
-            output.content.push(block);
-            const slot = { type: "text", block, contentIndex: output.content.length - 1 };
-            outputSlots.set(outputIndex, slot);
-            stream.push({ type: "text_start", contentIndex: slot.contentIndex, partial: output });
+            state.output.content.push(block);
+            const slot = {
+                type: "text",
+                block,
+                contentIndex: state.output.content.length - 1,
+            };
+            state.outputSlots.set(outputIndex, slot);
+            state.stream.push({ type: "text_start", contentIndex: slot.contentIndex, partial: state.output });
             return slot;
         }
-        if (item.type === "function_call") {
+        case "function_call": {
             const block = {
                 type: "toolCall",
                 id: `${item.call_id}|${item.id}`,
@@ -248,203 +254,227 @@ export async function processResponsesStream(openaiStream, output, stream, model
                 arguments: {},
                 partialJson: item.arguments || "",
             };
-            output.content.push(block);
+            state.output.content.push(block);
             const slot = {
                 type: "toolCall",
                 block,
-                contentIndex: output.content.length - 1,
+                contentIndex: state.output.content.length - 1,
             };
-            outputSlots.set(outputIndex, slot);
-            stream.push({ type: "toolcall_start", contentIndex: slot.contentIndex, partial: output });
+            state.outputSlots.set(outputIndex, slot);
+            state.stream.push({ type: "toolcall_start", contentIndex: slot.contentIndex, partial: state.output });
             return slot;
         }
-        return undefined;
-    };
-    const getOrCreateSlot = (outputIndex, item) => {
-        return outputSlots.get(outputIndex) ?? createSlot(outputIndex, item);
-    };
-    for await (const event of openaiStream) {
-        if (event.type === "response.created") {
-            output.responseId = event.response.id;
-        }
-        else if (event.type === "response.output_item.added") {
-            createSlot(event.output_index, event.item);
-        }
-        else if (event.type === "response.reasoning_summary_text.delta") {
-            const slot = getSlot(event.output_index, "thinking");
-            if (!slot)
-                continue;
-            slot.block.thinking += event.delta;
-            stream.push({
-                type: "thinking_delta",
-                contentIndex: slot.contentIndex,
-                delta: event.delta,
-                partial: output,
-            });
-        }
-        else if (event.type === "response.reasoning_summary_part.done") {
-            const slot = getSlot(event.output_index, "thinking");
-            if (!slot)
-                continue;
-            slot.block.thinking += "\n\n";
-            stream.push({
-                type: "thinking_delta",
-                contentIndex: slot.contentIndex,
-                delta: "\n\n",
-                partial: output,
-            });
-        }
-        else if (event.type === "response.reasoning_text.delta") {
-            const slot = getSlot(event.output_index, "thinking");
-            if (!slot)
-                continue;
-            slot.block.thinking += event.delta;
-            stream.push({
-                type: "thinking_delta",
-                contentIndex: slot.contentIndex,
-                delta: event.delta,
-                partial: output,
-            });
-        }
-        else if (event.type === "response.output_text.delta") {
-            const slot = getSlot(event.output_index, "text");
-            if (!slot)
-                continue;
-            slot.block.text += event.delta;
-            stream.push({
-                type: "text_delta",
+        default:
+            return undefined;
+    }
+}
+function getOrCreateResponsesOutputSlot(state, outputIndex, item) {
+    return state.outputSlots.get(outputIndex) ?? createResponsesOutputSlot(state, outputIndex, item);
+}
+function backfillResponsesReasoningSignatures(state, responseOutput) {
+    for (const item of responseOutput) {
+        if (item.type !== "reasoning" || !item.encrypted_content)
+            continue;
+        const block = state.reasoningBlocksById.get(item.id);
+        if (!block?.thinkingSignature)
+            continue;
+        const storedItem = JSON.parse(block.thinkingSignature);
+        if (storedItem.encrypted_content)
+            continue;
+        block.thinkingSignature = JSON.stringify({ ...storedItem, encrypted_content: item.encrypted_content });
+    }
+}
+function finalizeResponsesResponse(state, response) {
+    state.sawTerminalResponseEvent = true;
+    backfillResponsesReasoningSignatures(state, response.output ?? []);
+    if (response.id)
+        state.output.responseId = response.id;
+    if (response.usage) {
+        const inputDetails = response.usage.input_tokens_details;
+        const cachedTokens = inputDetails?.cached_tokens || 0;
+        const cacheWriteTokens = inputDetails?.cache_write_tokens || 0;
+        state.output.usage = {
+            input: Math.max(0, (response.usage.input_tokens || 0) - cachedTokens - cacheWriteTokens),
+            output: response.usage.output_tokens || 0,
+            cacheRead: cachedTokens,
+            cacheWrite: cacheWriteTokens,
+            reasoning: response.usage.output_tokens_details?.reasoning_tokens || 0,
+            totalTokens: response.usage.total_tokens || 0,
+            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+        };
+    }
+    calculateCost(state.model, state.output.usage);
+    if (state.options?.applyServiceTierPricing) {
+        const serviceTier = state.options.resolveServiceTier
+            ? state.options.resolveServiceTier(response.service_tier, state.options.serviceTier)
+            : (response.service_tier ?? state.options.serviceTier);
+        state.options.applyServiceTierPricing(state.output.usage, serviceTier);
+    }
+    state.output.rawStopReason = response.status;
+    state.output.stopReason = mapStopReason(response.status);
+    if (state.output.content.some((block) => block.type === "toolCall") && state.output.stopReason === "stop") {
+        state.output.stopReason = "toolUse";
+    }
+}
+function appendResponsesThinkingDelta(state, outputIndex, delta) {
+    const slot = getResponsesThinkingSlot(state, outputIndex);
+    if (!slot)
+        return;
+    slot.block.thinking += delta;
+    state.stream.push({
+        type: "thinking_delta",
+        contentIndex: slot.contentIndex,
+        delta,
+        partial: state.output,
+    });
+}
+function appendResponsesTextDelta(state, outputIndex, delta) {
+    const slot = getResponsesTextSlot(state, outputIndex);
+    if (!slot)
+        return;
+    slot.block.text += delta;
+    state.stream.push({ type: "text_delta", contentIndex: slot.contentIndex, delta, partial: state.output });
+}
+function appendResponsesToolCallDelta(state, outputIndex, delta) {
+    const slot = getResponsesToolCallSlot(state, outputIndex);
+    if (!slot)
+        return;
+    slot.block.partialJson += delta;
+    slot.block.arguments = parseStreamingJson(slot.block.partialJson);
+    state.stream.push({ type: "toolcall_delta", contentIndex: slot.contentIndex, delta, partial: state.output });
+}
+function completeResponsesToolCallArguments(state, outputIndex, argumentsJson) {
+    const slot = getResponsesToolCallSlot(state, outputIndex);
+    if (!slot)
+        return;
+    const previousPartialJson = slot.block.partialJson;
+    slot.block.partialJson = argumentsJson;
+    slot.block.arguments = parseStreamingJson(slot.block.partialJson);
+    if (!argumentsJson.startsWith(previousPartialJson))
+        return;
+    const delta = argumentsJson.slice(previousPartialJson.length);
+    if (delta.length > 0) {
+        state.stream.push({ type: "toolcall_delta", contentIndex: slot.contentIndex, delta, partial: state.output });
+    }
+}
+function finalizeResponsesOutputItem(state, outputIndex, item) {
+    applyResponsesMessagePhaseStopReason(state.output, item);
+    const slot = getOrCreateResponsesOutputSlot(state, outputIndex, item);
+    switch (item.type) {
+        case "reasoning":
+            if (slot?.type !== "thinking")
+                return;
+            slot.block.thinking =
+                item.summary?.map((summary) => summary.text).join("\n\n") ||
+                    item.content?.map((content) => content.text).join("\n\n") ||
+                    slot.block.thinking;
+            slot.block.thinkingSignature = JSON.stringify(item);
+            state.reasoningBlocksById.set(item.id, slot.block);
+            state.stream.push({
+                type: "thinking_end",
                 contentIndex: slot.contentIndex,
-                delta: event.delta,
-                partial: output,
+                content: slot.block.thinking,
+                partial: state.output,
             });
-        }
-        else if (event.type === "response.refusal.delta") {
-            const slot = getSlot(event.output_index, "text");
-            if (!slot)
-                continue;
-            slot.block.text += event.delta;
-            stream.push({
-                type: "text_delta",
+            state.outputSlots.delete(outputIndex);
+            return;
+        case "message":
+            if (slot?.type !== "text")
+                return;
+            slot.block.text =
+                item.content
+                    ?.map((content) => (content.type === "output_text" ? content.text : content.refusal))
+                    .join("") || "";
+            slot.block.textSignature = encodeTextSignatureV1(item.id, item.phase ?? undefined);
+            state.stream.push({
+                type: "text_end",
                 contentIndex: slot.contentIndex,
-                delta: event.delta,
-                partial: output,
+                content: slot.block.text,
+                partial: state.output,
             });
-        }
-        else if (event.type === "response.function_call_arguments.delta") {
-            const slot = getSlot(event.output_index, "toolCall");
-            if (!slot)
-                continue;
-            slot.block.partialJson += event.delta;
-            slot.block.arguments = parseStreamingJson(slot.block.partialJson);
-            stream.push({
-                type: "toolcall_delta",
+            state.outputSlots.delete(outputIndex);
+            return;
+        case "function_call":
+            if (slot?.type !== "toolCall")
+                return;
+            slot.block.arguments = parseStreamingJson(item.arguments || slot.block.partialJson || "{}");
+            delete slot.block.partialJson;
+            state.stream.push({
+                type: "toolcall_end",
                 contentIndex: slot.contentIndex,
-                delta: event.delta,
-                partial: output,
+                toolCall: slot.block,
+                partial: state.output,
             });
-        }
-        else if (event.type === "response.function_call_arguments.done") {
-            const slot = getSlot(event.output_index, "toolCall");
-            if (!slot)
-                continue;
-            const previousPartialJson = slot.block.partialJson;
-            slot.block.partialJson = event.arguments;
-            slot.block.arguments = parseStreamingJson(slot.block.partialJson);
-            if (event.arguments.startsWith(previousPartialJson)) {
-                const delta = event.arguments.slice(previousPartialJson.length);
-                if (delta.length > 0) {
-                    stream.push({
-                        type: "toolcall_delta",
-                        contentIndex: slot.contentIndex,
-                        delta,
-                        partial: output,
-                    });
-                }
-            }
-        }
-        else if (event.type === "response.output_item.done") {
-            const item = event.item;
-            const slot = getOrCreateSlot(event.output_index, item);
-            if (item.type === "reasoning" && slot?.type === "thinking") {
-                const summaryText = item.summary?.map((summary) => summary.text).join("\n\n") || "";
-                const contentText = item.content?.map((content) => content.text).join("\n\n") || "";
-                slot.block.thinking = summaryText || contentText || slot.block.thinking;
-                slot.block.thinkingSignature = JSON.stringify(item);
-                stream.push({
-                    type: "thinking_end",
-                    contentIndex: slot.contentIndex,
-                    content: slot.block.thinking,
-                    partial: output,
-                });
-                outputSlots.delete(event.output_index);
-            }
-            else if (item.type === "message" && slot?.type === "text") {
-                slot.block.text =
-                    item.content
-                        ?.map((content) => (content.type === "output_text" ? content.text : content.refusal))
-                        .join("") || "";
-                slot.block.textSignature = encodeTextSignatureV1(item.id, item.phase ?? undefined);
-                stream.push({
-                    type: "text_end",
-                    contentIndex: slot.contentIndex,
-                    content: slot.block.text,
-                    partial: output,
-                });
-                outputSlots.delete(event.output_index);
-            }
-            else if (item.type === "function_call" && slot?.type === "toolCall") {
-                slot.block.arguments = parseStreamingJson(item.arguments || slot.block.partialJson || "{}");
-                delete slot.block.partialJson;
-                stream.push({
-                    type: "toolcall_end",
-                    contentIndex: slot.contentIndex,
-                    toolCall: slot.block,
-                    partial: output,
-                });
-                outputSlots.delete(event.output_index);
-            }
-        }
-        else if (event.type === "response.completed") {
-            const response = event.response;
-            if (response?.id) {
-                output.responseId = response.id;
-            }
-            if (response?.usage) {
-                const cachedTokens = response.usage.input_tokens_details?.cached_tokens || 0;
-                output.usage = {
-                    input: (response.usage.input_tokens || 0) - cachedTokens,
-                    output: response.usage.output_tokens || 0,
-                    cacheRead: cachedTokens,
-                    cacheWrite: 0,
-                    totalTokens: response.usage.total_tokens || 0,
-                    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-                };
-            }
-            calculateCost(model, output.usage);
-            if (options?.applyServiceTierPricing) {
-                const serviceTier = options.resolveServiceTier
-                    ? options.resolveServiceTier(response?.service_tier, options.serviceTier)
-                    : (response?.service_tier ?? options.serviceTier);
-                options.applyServiceTierPricing(output.usage, serviceTier);
-            }
-            output.stopReason = mapStopReason(response?.status);
-            if (output.content.some((block) => block.type === "toolCall") && output.stopReason === "stop") {
-                output.stopReason = "toolUse";
-            }
-        }
-        else if (event.type === "error") {
+            state.outputSlots.delete(outputIndex);
+            return;
+        default:
+            return;
+    }
+}
+function failResponsesStream(state, response) {
+    state.sawTerminalResponseEvent = true;
+    state.output.rawStopReason = response?.status;
+    const error = response?.error;
+    const details = response?.incomplete_details;
+    const message = error
+        ? `${error.code || "unknown"}: ${error.message || "no message"}`
+        : details?.reason
+            ? `incomplete: ${details.reason}`
+            : "Unknown error (no error details in response)";
+    throw new Error(message);
+}
+function processResponsesStreamEvent(state, event) {
+    switch (event.type) {
+        case "response.created":
+            state.output.responseId = event.response.id;
+            break;
+        case "response.output_item.added":
+            createResponsesOutputSlot(state, event.output_index, event.item);
+            break;
+        case "response.reasoning_summary_text.delta":
+        case "response.reasoning_text.delta":
+            appendResponsesThinkingDelta(state, event.output_index, event.delta);
+            break;
+        case "response.reasoning_summary_part.done":
+            appendResponsesThinkingDelta(state, event.output_index, "\n\n");
+            break;
+        case "response.output_text.delta":
+        case "response.refusal.delta":
+            appendResponsesTextDelta(state, event.output_index, event.delta);
+            break;
+        case "response.function_call_arguments.delta":
+            appendResponsesToolCallDelta(state, event.output_index, event.delta);
+            break;
+        case "response.function_call_arguments.done":
+            completeResponsesToolCallArguments(state, event.output_index, event.arguments);
+            break;
+        case "response.output_item.done":
+            finalizeResponsesOutputItem(state, event.output_index, event.item);
+            break;
+        case "response.completed":
+        case "response.incomplete":
+            finalizeResponsesResponse(state, event.response);
+            break;
+        case "error":
             throw new Error(`Error Code ${event.code}: ${event.message}` || "Unknown error");
-        }
-        else if (event.type === "response.failed") {
-            const error = event.response?.error;
-            const details = event.response?.incomplete_details;
-            const message = error
-                ? `${error.code || "unknown"}: ${error.message || "no message"}`
-                : details?.reason
-                    ? `incomplete: ${details.reason}`
-                    : "Unknown error (no error details in response)";
-            throw new Error(message);
-        }
+        case "response.failed":
+            failResponsesStream(state, event.response);
+    }
+}
+export async function processResponsesStream(openaiStream, output, stream, model, options) {
+    const state = {
+        output,
+        stream,
+        model,
+        options,
+        sawTerminalResponseEvent: false,
+        outputSlots: new Map(),
+        reasoningBlocksById: new Map(),
+    };
+    for await (const event of openaiStream)
+        processResponsesStreamEvent(state, event);
+    if (!state.sawTerminalResponseEvent) {
+        throw new Error("OpenAI Responses stream ended before a terminal response event");
     }
 }
 function mapStopReason(status) {