aisubs 0.3.5 → 0.3.7

package/dist/compatibility.js

@@ -29,13 +29,22 @@ function requiredModel(raw) {
         throw new CompatibilityError("A non-empty model is required");
     return model;
 }
+function cacheControl(value) {
+    if (!isRecord(value) || value.cache_control == null)
+        return {};
+    const control = record(value.cache_control, "cache_control must be an object");
+    if (control.type !== "ephemeral" ||
+        (control.ttl != null && control.ttl !== "5m" && control.ttl !== "1h"))
+        throw new CompatibilityError("Unsupported cache_control type or TTL", "unsupported_feature");
+    return { cache_control: { type: "ephemeral", ...(control.ttl ? { ttl: control.ttl } : {}) } };
+}
 function text(value) {
     if (typeof value === "string")
         return { type: "text", text: value };
     if (!isRecord(value))
         return null;
-    const content = stringValue(value.text);
-    return content == null ? null : { type: "text", text: content };
+    const content = typeof value.text === "string" ? value.text : undefined;
+    return content == null ? null : { type: "text", text: content, ...cacheControl(value) };
 }
 function imageUrl(value) {
     if (typeof value === "string")
@@ -61,14 +70,14 @@ function openAiParts(value) {
             const url = imageUrl(part.image_url) ?? stringValue(part.image_url) ?? stringValue(part.file_id);
             if (!url)
                 throw new CompatibilityError("Image content requires image_url or file_id");
-            return { type: "image", url, detail: stringValue(part.detail) };
+            return { type: "image", url, detail: stringValue(part.detail), ...cacheControl(part) };
         }
         if (type === "input_audio") {
             const audio = record(part.input_audio, "input_audio requires audio data");
             const data = stringValue(audio.data);
             if (!data)
                 throw new CompatibilityError("input_audio requires audio data");
-            return { type: "audio", data, format: stringValue(audio.format) };
+            return { type: "audio", data, format: stringValue(audio.format), ...cacheControl(part) };
         }
         if (type === "file" || type === "input_file") {
             return {
@@ -76,6 +85,7 @@ function openAiParts(value) {
                 fileId: stringValue(part.file_id),
                 data: stringValue(part.file_data),
                 filename: stringValue(part.filename),
+                ...cacheControl(part),
             };
         }
         if (type === "refusal")
@@ -116,6 +126,7 @@ function chatTools(value) {
             description: stringValue(fn.description),
             parameters: fn.parameters,
             strict: typeof fn.strict === "boolean" ? fn.strict : undefined,
+            ...cacheControl(tool),
         };
     });
 }
@@ -134,6 +145,7 @@ function parseChat(body) {
             content: openAiParts(message.content),
             toolCallId: stringValue(message.tool_call_id),
             toolCalls: chatToolCalls(message.tool_calls),
+            ...cacheControl(message),
         };
     });
     return {
@@ -151,6 +163,7 @@ function parseChat(body) {
         metadata: raw.metadata,
         user: stringValue(raw.user),
         promptCacheKey: stringValue(raw.prompt_cache_key),
+        cacheControl: cacheControl(raw).cache_control,
     };
 }
 function responseTools(value) {
@@ -174,6 +187,9 @@ function responseTools(value) {
 }
 function parseResponses(body) {
     const raw = json(body);
+    if (raw.previous_response_id != null || raw.background === true) {
+        throw new CompatibilityError("Stored or background Responses require native Responses support", "unsupported_feature");
+    }
     const messages = [];
     if (typeof raw.instructions === "string") {
         messages.push({ role: "developer", content: [{ type: "text", text: raw.instructions }] });
@@ -218,13 +234,16 @@ function parseResponses(body) {
             else if (value.type === "item_reference") {
                 throw new CompatibilityError("item_reference requires native Responses support", "unsupported_feature");
             }
-            else {
+            else if (value.type == null || value.type === "message") {
                 const role = stringValue(value.role) ?? "user";
                 if (!["system", "developer", "user", "assistant"].includes(role)) {
                     throw new CompatibilityError(`Unsupported Responses role: ${role}`);
                 }
                 messages.push({ role: role, content: openAiParts(value.content) });
             }
+            else {
+                throw new CompatibilityError(`Unsupported Responses input item: ${String(value.type)}`, "unsupported_feature");
+            }
         }
     }
     else if (input != null)
@@ -236,7 +255,9 @@ function parseResponses(body) {
         stream: raw.stream === true,
         messages,
         tools: responseTools(raw.tools),
-        toolChoice: raw.tool_choice,
+        toolChoice: isRecord(raw.tool_choice) && raw.tool_choice.type === "function"
+            ? { type: "function", function: { name: raw.tool_choice.name } }
+            : raw.tool_choice,
         maxTokens: numberValue(raw.max_output_tokens),
         temperature: numberValue(raw.temperature),
         topP: numberValue(raw.top_p),
@@ -257,15 +278,16 @@ function anthropicParts(value) {
     for (const item of value) {
         const part = record(item, "Anthropic content blocks must be objects");
         if (part.type === "text")
-            content.push({ type: "text", text: stringValue(part.text) ?? "" });
+            content.push({ type: "text", text: stringValue(part.text) ?? "", ...cacheControl(part) });
         else if (part.type === "image") {
             const source = record(part.source, "Anthropic image requires source");
             if (source.type === "url")
-                content.push({ type: "image", url: stringValue(source.url) ?? "" });
+                content.push({ type: "image", url: stringValue(source.url) ?? "", ...cacheControl(part) });
             else
                 content.push({
                     type: "image",
                     url: `data:${stringValue(source.media_type) ?? "image/png"};base64,${stringValue(source.data) ?? ""}`,
+                    ...cacheControl(part),
                 });
         }
         else if (part.type === "tool_use") {
@@ -273,6 +295,7 @@ function anthropicParts(value) {
                 id: stringValue(part.id) ?? `call_${crypto.randomUUID()}`,
                 name: stringValue(part.name) ?? "function",
                 arguments: JSON.stringify(part.input ?? {}),
+                ...cacheControl(part),
             });
         }
         else if (part.type !== "thinking" && part.type !== "redacted_thinking") {
@@ -301,6 +324,7 @@ function parseAnthropic(body) {
                         role: "tool",
                         toolCallId: stringValue(part.tool_use_id),
                         content: anthropicParts(part.content).content,
+                        ...cacheControl(part),
                     });
                 }
                 else
@@ -319,7 +343,12 @@ function parseAnthropic(body) {
             const name = stringValue(tool.name);
             if (!name)
                 throw new CompatibilityError("Tool requires a name");
-            return { name, description: stringValue(tool.description), parameters: tool.input_schema };
+            return {
+                name,
+                description: stringValue(tool.description),
+                parameters: tool.input_schema,
+                ...cacheControl(tool),
+            };
         })
         : undefined;
     return {
@@ -327,17 +356,25 @@ function parseAnthropic(body) {
         stream: raw.stream === true,
         messages,
         tools,
-        toolChoice: raw.tool_choice,
+        toolChoice: isRecord(raw.tool_choice)
+            ? raw.tool_choice.type === "tool"
+                ? { type: "function", function: { name: raw.tool_choice.name } }
+                : raw.tool_choice.type === "any"
+                    ? "required"
+                    : raw.tool_choice.type
+            : raw.tool_choice,
         maxTokens: numberValue(raw.max_tokens),
         temperature: numberValue(raw.temperature),
         topP: numberValue(raw.top_p),
         stop: raw.stop_sequences,
         metadata: raw.metadata,
+        cacheControl: cacheControl(raw).cache_control,
     };
 }
 function parseGoogle(body, model, stream = false) {
     const raw = json(body);
     const messages = [];
+    const pendingCalls = [];
     if (isRecord(raw.systemInstruction)) {
         const parts = Array.isArray(raw.systemInstruction.parts) ? raw.systemInstruction.parts : [];
         messages.push({
@@ -370,16 +407,23 @@ function parseGoogle(body, model, stream = false) {
                 content.push({ type: "image", url: stringValue(part.fileData.fileUri) ?? "" });
             }
             else if (isRecord(part.functionCall)) {
-                toolCalls.push({
-                    id: `call_${crypto.randomUUID()}`,
+                const call = {
+                    id: stringValue(part.functionCall.id) ?? `call_${crypto.randomUUID()}`,
                     name: stringValue(part.functionCall.name) ?? "function",
                     arguments: JSON.stringify(part.functionCall.args ?? {}),
-                });
+                };
+                toolCalls.push(call);
+                pendingCalls.push(call);
             }
             else if (isRecord(part.functionResponse)) {
+                const result = part.functionResponse;
+                const callIndex = pendingCalls.findIndex((call) => typeof result.id === "string" ? call.id === result.id : call.name === result.name);
+                const call = callIndex < 0 ? undefined : pendingCalls.splice(callIndex, 1)[0];
+                if (!call)
+                    throw new CompatibilityError("Function response has no matching function call");
                 messages.push({
                     role: "tool",
-                    toolCallId: stringValue(part.functionResponse.name),
+                    toolCallId: call.id,
                     content: [{ type: "text", text: JSON.stringify(part.functionResponse.response ?? {}) }],
                 });
             }
@@ -420,15 +464,16 @@ function dataUri(url) {
     return match?.[1] && match[2] ? { mediaType: match[1], data: match[2] } : null;
 }
 function chatContent(parts) {
-    if (parts.every((part) => part.type === "text"))
+    if (parts.every((part) => part.type === "text" && !part.cache_control))
         return parts.map((part) => (part.type === "text" ? part.text : "")).join("");
     return parts.map((part) => {
         if (part.type === "text")
-            return { type: "text", text: part.text };
+            return { type: "text", text: part.text, ...cacheControl(part) };
         if (part.type === "image")
             return {
                 type: "image_url",
                 image_url: { url: part.url, ...(part.detail ? { detail: part.detail } : {}) },
+                ...cacheControl(part),
             };
         if (part.type === "audio")
             return {
@@ -447,6 +492,7 @@ function toChat(request) {
     const messages = request.messages.map((message) => ({
         role: message.role,
         content: chatContent(message.content),
+        ...cacheControl(message),
         ...(message.toolCallId ? { tool_call_id: message.toolCallId } : {}),
         ...(message.toolCalls
             ? {
@@ -463,7 +509,13 @@ function toChat(request) {
         messages,
         stream: false,
         ...(request.tools
-            ? { tools: request.tools.map((tool) => ({ type: "function", function: tool })) }
+            ? {
+                tools: request.tools.map(({ cache_control, ...tool }) => ({
+                    type: "function",
+                    function: tool,
+                    ...(cache_control ? { cache_control } : {}),
+                })),
+            }
             : {}),
         ...(request.toolChoice != null ? { tool_choice: request.toolChoice } : {}),
         ...(request.maxTokens != null ? { max_completion_tokens: request.maxTokens } : {}),
@@ -550,7 +602,12 @@ function toResponses(request) {
         stream: false,
         store: false,
         ...(request.tools
-            ? { tools: request.tools.map((tool) => ({ type: "function", ...tool })) }
+            ? {
+                tools: request.tools.map(({ cache_control: _cacheControl, ...tool }) => ({
+                    type: "function",
+                    ...tool,
+                })),
+            }
             : {}),
         ...(toolChoice != null ? { tool_choice: toolChoice } : {}),
         ...(request.maxTokens != null ? { max_output_tokens: request.maxTokens } : {}),
@@ -566,12 +623,16 @@ function toResponses(request) {
 function anthropicContent(message) {
     const parts = message.content.map((part) => {
         if (part.type === "text")
-            return { type: "text", text: part.text };
+            return { type: "text", text: part.text, ...cacheControl(part) };
         if (part.type === "image") {
             const data = dataUri(part.url);
             return data
-                ? { type: "image", source: { type: "base64", media_type: data.mediaType, data: data.data } }
-                : { type: "image", source: { type: "url", url: part.url } };
+                ? {
+                    type: "image",
+                    source: { type: "base64", media_type: data.mediaType, data: data.data },
+                    ...cacheControl(part),
+                }
+                : { type: "image", source: { type: "url", url: part.url }, ...cacheControl(part) };
         }
         if (part.type === "file")
             return {
@@ -580,6 +641,7 @@ function anthropicContent(message) {
                     ? { type: "file", file_id: part.fileId }
                     : { type: "base64", media_type: "application/octet-stream", data: part.data ?? "" },
                 ...(part.filename ? { title: part.filename } : {}),
+                ...cacheControl(part),
             };
         throw new CompatibilityError("Anthropic Messages does not support OpenAI input_audio", "unsupported_feature");
     });
@@ -589,7 +651,10 @@ function anthropicContent(message) {
             id: call.id,
             name: call.name,
             input: JSON.parse(call.arguments || "{}"),
+            ...cacheControl(call),
         });
+    if (message.role !== "tool" && message.cache_control && parts.length)
+        Object.assign(parts[parts.length - 1], cacheControl(message));
     return parts;
 }
 function toAnthropic(request) {
@@ -606,6 +671,7 @@ function toAnthropic(request) {
                     type: "tool_result",
                     tool_use_id: message.toolCallId,
                     content: anthropicContent(message),
+                    ...cacheControl(message),
                 },
             ],
         }
@@ -621,12 +687,14 @@ function toAnthropic(request) {
         max_tokens: request.maxTokens ?? 4096,
         stream: false,
         ...(system.length ? { system } : {}),
+        ...(request.cacheControl ? { cache_control: request.cacheControl } : {}),
         ...(request.tools
             ? {
                 tools: request.tools.map((tool) => ({
                     name: tool.name,
                     description: tool.description,
                     input_schema: tool.parameters ?? { type: "object", properties: {} },
+                    ...cacheControl(tool),
                 })),
             }
             : {}),
@@ -657,6 +725,7 @@ function googlePart(part) {
         : { inlineData: { mimeType: "application/octet-stream", data: part.data ?? "" } };
 }
 function toGoogle(request) {
+    const callNames = new Map(request.messages.flatMap((message) => (message.toolCalls ?? []).map((call) => [call.id, call.name])));
     const system = request.messages
         .filter((message) => message.role === "system" || message.role === "developer")
         .flatMap((message) => message.content.map(googlePart));
@@ -666,15 +735,19 @@ function toGoogle(request) {
         const parts = message.role === "tool" ? [] : message.content.map(googlePart);
         for (const call of message.toolCalls ?? [])
             parts.push({ functionCall: { name: call.name, args: JSON.parse(call.arguments || "{}") } });
-        if (message.role === "tool")
+        if (message.role === "tool") {
+            const name = message.toolCallId ? callNames.get(message.toolCallId) : undefined;
+            if (!name)
+                throw new CompatibilityError("Tool result has no matching function call");
             parts.push({
                 functionResponse: {
-                    name: message.toolCallId ?? "function",
+                    name,
                     response: {
                         result: message.content.map((part) => (part.type === "text" ? part.text : part)),
                     },
                 },
             });
+        }
         return { role: message.role === "assistant" ? "model" : "user", parts };
     });
     const schema = isRecord(request.responseFormat) && isRecord(request.responseFormat.json_schema)
@@ -740,10 +813,17 @@ function parseChatResult(raw, model) {
         finishReason: finish === "length" || finish === "tool_calls" || finish === "content_filter"
             ? finish
             : "stop",
-        usage: usage(numberValue(details?.prompt_tokens), numberValue(details?.completion_tokens), numberValue(promptDetails?.cached_tokens), numberValue(completionDetails?.reasoning_tokens), numberValue(promptDetails?.cache_write_tokens)),
+        usage: usage(numberValue(details?.prompt_tokens), numberValue(details?.completion_tokens), numberValue(details?.cached_tokens) ??
+            numberValue(details?.prompt_cache_hit_tokens) ??
+            numberValue(promptDetails?.cached_tokens), numberValue(completionDetails?.reasoning_tokens), numberValue(promptDetails?.cache_write_tokens) ??
+            numberValue(promptDetails?.cache_creation_input_tokens)),
     };
 }
 function parseResponsesResult(raw, model) {
+    if (raw.status === "failed" || raw.error != null) {
+        const error = isRecord(raw.error) ? stringValue(raw.error.message) : undefined;
+        throw new CompatibilityError(error ?? "Provider response failed", "provider_error", 502);
+    }
     const content = [];
     const toolCalls = [];
     let refusal;
@@ -783,13 +863,7 @@ function parseResponsesResult(raw, model) {
         content,
         toolCalls,
         refusal,
-        finishReason: toolCalls.length
-            ? "tool_calls"
-            : raw.status === "incomplete"
-                ? "length"
-                : raw.status === "failed"
-                    ? "error"
-                    : "stop",
+        finishReason: raw.status === "incomplete" ? "length" : toolCalls.length ? "tool_calls" : "stop",
         usage: usage(numberValue(details?.input_tokens), numberValue(details?.output_tokens), numberValue(inputDetails?.cached_tokens), numberValue(outputDetails?.reasoning_tokens), numberValue(inputDetails?.cache_write_tokens)),
     };
 }
@@ -1085,11 +1159,7 @@ function responsesToChatStream(upstream, model) {
     const toolIndexes = new Map();
     const emit = (controller, delta, finishReason = null, rawUsage) => {
         const usage = rawUsage
-            ? {
-                prompt_tokens: rawUsage.input_tokens,
-                completion_tokens: rawUsage.output_tokens,
-                total_tokens: rawUsage.total_tokens,
-            }
+            ? resultToChat(parseResponsesResult({ usage: rawUsage }, model)).usage
             : undefined;
         controller.enqueue(encoder.encode(`data: ${JSON.stringify({
             id: `chatcmpl_${stringValue(response.id) ?? crypto.randomUUID()}`,
@@ -1114,120 +1184,108 @@ function responsesToChatStream(upstream, model) {
         start(controller);
         finished = true;
         const incomplete = response.status === "incomplete";
-        emit(controller, {}, hasToolCalls ? "tool_calls" : incomplete ? "length" : "stop", isRecord(response.usage) ? response.usage : undefined);
+        emit(controller, {}, incomplete ? "length" : hasToolCalls ? "tool_calls" : "stop", isRecord(response.usage) ? response.usage : undefined);
         controller.enqueue(encoder.encode("data: [DONE]\n\n"));
     };
-    let upstreamReader;
-    const body = new ReadableStream({
-        async start(controller) {
-            const reader = upstream.body.getReader();
-            upstreamReader = reader;
-            const decoder = new TextDecoder();
-            let buffer = "";
-            const handle = (raw) => {
-                const data = raw
-                    .split(/\r?\n/)
-                    .filter((line) => line.startsWith("data:"))
-                    .map((line) => line.slice(5).trim())
-                    .join("\n");
-                if (!data || data === "[DONE]")
-                    return;
-                const event = JSON.parse(data);
-                if (!isRecord(event))
-                    return;
-                const completed = isRecord(event.response) ? event.response : undefined;
-                if (event.type === "response.created" && completed)
-                    response = completed;
-                if (event.type === "response.output_text.delta") {
-                    start(controller);
-                    emit(controller, { content: stringValue(event.delta) ?? "" });
-                }
-                if (event.type === "response.refusal.delta") {
-                    start(controller);
-                    emit(controller, { refusal: stringValue(event.delta) ?? "" });
-                }
-                const outputIndex = numberValue(event.output_index) ?? toolIndexes.size;
-                if (event.type === "response.output_item.added" &&
-                    isRecord(event.item) &&
-                    event.item.type === "function_call") {
-                    start(controller);
-                    hasToolCalls = true;
-                    const index = toolIndexes.size;
-                    toolIndexes.set(outputIndex, index);
-                    emit(controller, {
-                        tool_calls: [
-                            {
-                                index,
-                                id: stringValue(event.item.call_id) ??
-                                    stringValue(event.item.id) ??
-                                    `call_${crypto.randomUUID()}`,
-                                type: "function",
-                                function: {
-                                    name: stringValue(event.item.name) ?? "function",
-                                    arguments: stringValue(event.item.arguments) ?? "",
-                                },
-                            },
-                        ],
-                    });
-                }
-                if (event.type === "response.function_call_arguments.delta") {
-                    start(controller);
-                    hasToolCalls = true;
-                    emit(controller, {
-                        tool_calls: [
-                            {
-                                index: toolIndexes.get(outputIndex) ?? 0,
-                                function: { arguments: stringValue(event.delta) ?? "" },
-                            },
-                        ],
-                    });
-                }
-                if (event.type === "response.completed" || event.type === "response.incomplete") {
-                    finish(controller, completed);
-                }
-                if (event.type === "response.failed" || event.type === "error") {
-                    const detail = isRecord(event.error)
-                        ? stringValue(event.error.message)
-                        : "Provider stream failed";
-                    controller.enqueue(encoder.encode(`data: ${JSON.stringify({
-                        error: {
-                            message: detail ?? "Provider stream failed",
-                            type: "provider_error",
-                            code: "provider_error",
-                        },
-                    })}\n\n`));
-                    finished = true;
-                }
-            };
-            try {
-                for (;;) {
-                    const { done, value } = await reader.read();
-                    buffer += decoder.decode(value, { stream: !done });
-                    for (let end = buffer.search(/\r?\n\r?\n/); end !== -1; end = buffer.search(/\r?\n\r?\n/)) {
-                        const raw = buffer.slice(0, end);
-                        buffer = buffer.slice(end).replace(/^\r?\n\r?\n/, "");
-                        handle(raw);
-                    }
-                    if (done)
-                        break;
-                }
-                if (buffer)
-                    handle(buffer);
-                finish(controller);
-                controller.close();
-            }
-            catch (error) {
-                controller.error(error);
-            }
-            finally {
-                reader.releaseLock();
-                upstreamReader = undefined;
-            }
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const body = upstream.body.pipeThrough(new TransformStream({
+        transform(chunk, controller) {
+            buffer += decoder.decode(chunk, { stream: true });
+            consume(controller);
         },
-        cancel(reason) {
-            return upstreamReader?.cancel(reason);
+        flush(controller) {
+            buffer += decoder.decode();
+            consume(controller);
+            if (buffer)
+                handle(buffer, controller);
+            if (!finished)
+                throw new Error("Provider stream ended before a terminal response event");
         },
-    });
+    }));
+    const handle = (raw, controller) => {
+        if (finished)
+            return;
+        const data = raw
+            .split(/\r?\n/)
+            .filter((line) => line.startsWith("data:"))
+            .map((line) => line.slice(5).trim())
+            .join("\n");
+        if (!data || data === "[DONE]")
+            return;
+        const event = JSON.parse(data);
+        if (!isRecord(event))
+            return;
+        const completed = isRecord(event.response) ? event.response : undefined;
+        if (event.type === "response.created" && completed)
+            response = completed;
+        if (event.type === "response.output_text.delta") {
+            start(controller);
+            emit(controller, { content: stringValue(event.delta) ?? "" });
+        }
+        if (event.type === "response.refusal.delta") {
+            start(controller);
+            emit(controller, { refusal: stringValue(event.delta) ?? "" });
+        }
+        const outputIndex = numberValue(event.output_index) ?? toolIndexes.size;
+        if (event.type === "response.output_item.added" &&
+            isRecord(event.item) &&
+            event.item.type === "function_call") {
+            start(controller);
+            hasToolCalls = true;
+            const index = toolIndexes.size;
+            toolIndexes.set(outputIndex, index);
+            emit(controller, {
+                tool_calls: [
+                    {
+                        index,
+                        id: stringValue(event.item.call_id) ??
+                            stringValue(event.item.id) ??
+                            `call_${crypto.randomUUID()}`,
+                        type: "function",
+                        function: {
+                            name: stringValue(event.item.name) ?? "function",
+                            arguments: stringValue(event.item.arguments) ?? "",
+                        },
+                    },
+                ],
+            });
+        }
+        if (event.type === "response.function_call_arguments.delta") {
+            start(controller);
+            hasToolCalls = true;
+            emit(controller, {
+                tool_calls: [
+                    {
+                        index: toolIndexes.get(outputIndex) ?? 0,
+                        function: { arguments: stringValue(event.delta) ?? "" },
+                    },
+                ],
+            });
+        }
+        if (event.type === "response.completed" || event.type === "response.incomplete") {
+            finish(controller, completed);
+        }
+        if (event.type === "response.failed" || event.type === "error") {
+            const failure = event.error ?? completed?.error;
+            const detail = isRecord(failure) ? stringValue(failure.message) : stringValue(event.message);
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify({
+                error: {
+                    message: detail ?? "Provider stream failed",
+                    type: "provider_error",
+                    code: "provider_error",
+                },
+            })}\n\n`));
+            finished = true;
+        }
+    };
+    function consume(controller) {
+        for (let end = buffer.search(/\r?\n\r?\n/); end !== -1; end = buffer.search(/\r?\n\r?\n/)) {
+            const raw = buffer.slice(0, end);
+            buffer = buffer.slice(end).replace(/^\r?\n\r?\n/, "");
+            handle(raw, controller);
+        }
+    }
     return new Response(body, {
         headers: {
             "content-type": "text/event-stream; charset=utf-8",
@@ -1367,7 +1425,7 @@ async function upstreamResult(response, protocol, model) {
     const body = await response.text();
     let raw;
     if (protocol === "responses" && /(^|\n)data:/.test(body)) {
-        let completed = {};
+        let completed;
         let outputText = "";
         const calls = new Map();
         for (const frame of body.split(/\r?\n\r?\n/)) {
@@ -1400,11 +1458,22 @@ async function upstreamResult(response, protocol, model) {
                 if (call)
                     call.arguments += stringValue(event.delta) ?? "";
             }
-            if (event.type === "response.completed" && isRecord(event.response))
-                completed = event.response;
-            if ((event.type === "response.failed" || event.type === "error") && isRecord(event.response))
-                completed = event.response;
+            if ((event.type === "response.completed" || event.type === "response.incomplete") &&
+                isRecord(event.response))
+                completed = {
+                    ...event.response,
+                    status: event.type === "response.incomplete" ? "incomplete" : event.response.status,
+                };
+            if (event.type === "response.failed" || event.type === "error") {
+                const failure = event.error ?? (isRecord(event.response) ? event.response.error : undefined);
+                const message = isRecord(failure)
+                    ? stringValue(failure.message)
+                    : stringValue(event.message);
+                throw new CompatibilityError(message ?? "Provider stream failed", "provider_error", 502);
+            }
         }
+        if (!completed)
+            throw new CompatibilityError("Provider stream ended before a terminal response event", "provider_error", 502);
         const output = Array.isArray(completed.output) ? [...completed.output] : [];
         if (outputText && !output.some((item) => isRecord(item) && item.type === "message")) {
             output.push({