@openrouter/sdk 0.3.7 → 0.3.11

package/esm/lib/stream-transformers.js

@@ -1,13 +1,13 @@
+import { isOutputTextDeltaEvent, isReasoningDeltaEvent, isFunctionCallArgumentsDeltaEvent, isOutputItemAddedEvent, isOutputItemDoneEvent, isResponseCompletedEvent, isResponseFailedEvent, isResponseIncompleteEvent, isFunctionCallArgumentsDoneEvent, isOutputMessage, isFunctionCallOutputItem, isReasoningOutputItem, isWebSearchCallOutputItem, isFileSearchCallOutputItem, isImageGenerationCallOutputItem, isOutputTextPart, isRefusalPart, isFileCitationAnnotation, isURLCitationAnnotation, isFilePathAnnotation, } from './stream-type-guards.js';
 /**
  * Extract text deltas from responses stream events
  */
 export async function* extractTextDeltas(stream) {
     const consumer = stream.createConsumer();
     for await (const event of consumer) {
-        if ('type' in event && event.type === 'response.output_text.delta') {
-            const deltaEvent = event;
-            if (deltaEvent.delta) {
-                yield deltaEvent.delta;
+        if (isOutputTextDeltaEvent(event)) {
+            if (event.delta) {
+                yield event.delta;
             }
         }
     }
@@ -18,10 +18,9 @@ export async function* extractTextDeltas(stream) {
 export async function* extractReasoningDeltas(stream) {
     const consumer = stream.createConsumer();
     for await (const event of consumer) {
-        if ('type' in event && event.type === 'response.reasoning_text.delta') {
-            const deltaEvent = event;
-            if (deltaEvent.delta) {
-                yield deltaEvent.delta;
+        if (isReasoningDeltaEvent(event)) {
+            if (event.delta) {
+                yield event.delta;
             }
         }
     }
@@ -32,19 +31,18 @@ export async function* extractReasoningDeltas(stream) {
 export async function* extractToolDeltas(stream) {
     const consumer = stream.createConsumer();
     for await (const event of consumer) {
-        if ('type' in event && event.type === 'response.function_call_arguments.delta') {
-            const deltaEvent = event;
-            if (deltaEvent.delta) {
-                yield deltaEvent.delta;
+        if (isFunctionCallArgumentsDeltaEvent(event)) {
+            if (event.delta) {
+                yield event.delta;
             }
         }
     }
 }
 /**
- * Build incremental message updates from responses stream events
- * Returns ResponsesOutputMessage (assistant/responses format)
+ * Core message stream builder - shared logic for both formats
+ * Accumulates text deltas and yields updates
  */
-export async function* buildResponsesMessageStream(stream) {
+async function* buildMessageStreamCore(stream) {
     const consumer = stream.createConsumer();
     // Track the accumulated text and message info
     let currentText = '';
@@ -56,47 +54,76 @@ export async function* buildResponsesMessageStream(stream) {
         }
         switch (event.type) {
             case 'response.output_item.added': {
-                const itemEvent = event;
-                if (itemEvent.item && 'type' in itemEvent.item && itemEvent.item.type === 'message') {
-                    hasStarted = true;
-                    currentText = '';
-                    const msgItem = itemEvent.item;
-                    currentId = msgItem.id;
+                if (isOutputItemAddedEvent(event)) {
+                    if (event.item && isOutputMessage(event.item)) {
+                        hasStarted = true;
+                        currentText = '';
+                        currentId = event.item.id;
+                    }
                 }
                 break;
             }
             case 'response.output_text.delta': {
-                const deltaEvent = event;
-                if (hasStarted && deltaEvent.delta) {
-                    currentText += deltaEvent.delta;
-                    // Yield updated message in ResponsesOutputMessage format
-                    yield {
-                        id: currentId,
-                        type: 'message',
-                        role: 'assistant',
-                        status: 'in_progress',
-                        content: [
-                            {
-                                type: 'output_text',
-                                text: currentText,
-                                annotations: [],
-                            },
-                        ],
-                    };
+                if (isOutputTextDeltaEvent(event)) {
+                    if (hasStarted && event.delta) {
+                        currentText += event.delta;
+                        yield {
+                            type: 'delta',
+                            text: currentText,
+                            messageId: currentId,
+                        };
+                    }
                 }
                 break;
             }
             case 'response.output_item.done': {
-                const itemDoneEvent = event;
-                if (itemDoneEvent.item &&
-                    'type' in itemDoneEvent.item &&
-                    itemDoneEvent.item.type === 'message') {
-                    // Yield final complete message in ResponsesOutputMessage format
-                    const outputMessage = itemDoneEvent.item;
-                    yield outputMessage;
+                if (isOutputItemDoneEvent(event)) {
+                    if (event.item && isOutputMessage(event.item)) {
+                        yield {
+                            type: 'complete',
+                            completeMessage: event.item,
+                        };
+                    }
                 }
                 break;
             }
+            case 'response.completed':
+            case 'response.failed':
+            case 'response.incomplete':
+                // Stream is complete, stop consuming
+                return;
+            default:
+                // Ignore other event types - this is intentionally not exhaustive
+                // as we only care about specific events for message building
+                break;
+        }
+    }
+}
+/**
+ * Build incremental message updates from responses stream events
+ * Returns ResponsesOutputMessage (assistant/responses format)
+ */
+export async function* buildResponsesMessageStream(stream) {
+    for await (const update of buildMessageStreamCore(stream)) {
+        if (update.type === 'delta' && update.text !== undefined && update.messageId !== undefined) {
+            // Yield incremental update in ResponsesOutputMessage format
+            yield {
+                id: update.messageId,
+                type: 'message',
+                role: 'assistant',
+                status: 'in_progress',
+                content: [
+                    {
+                        type: 'output_text',
+                        text: update.text,
+                        annotations: [],
+                    },
+                ],
+            };
+        }
+        else if (update.type === 'complete' && update.completeMessage) {
+            // Yield final complete message
+            yield update.completeMessage;
         }
     }
 }
@@ -105,46 +132,17 @@ export async function* buildResponsesMessageStream(stream) {
  * Returns AssistantMessage (chat format) instead of ResponsesOutputMessage
  */
 export async function* buildMessageStream(stream) {
-    const consumer = stream.createConsumer();
-    // Track the accumulated text
-    let currentText = '';
-    let hasStarted = false;
-    for await (const event of consumer) {
-        if (!('type' in event)) {
-            continue;
+    for await (const update of buildMessageStreamCore(stream)) {
+        if (update.type === 'delta' && update.text !== undefined) {
+            // Yield incremental update in chat format
+            yield {
+                role: 'assistant',
+                content: update.text,
+            };
         }
-        switch (event.type) {
-            case 'response.output_item.added': {
-                const itemEvent = event;
-                if (itemEvent.item && 'type' in itemEvent.item && itemEvent.item.type === 'message') {
-                    hasStarted = true;
-                    currentText = '';
-                }
-                break;
-            }
-            case 'response.output_text.delta': {
-                const deltaEvent = event;
-                if (hasStarted && deltaEvent.delta) {
-                    currentText += deltaEvent.delta;
-                    // Yield updated message
-                    yield {
-                        role: 'assistant',
-                        content: currentText,
-                    };
-                }
-                break;
-            }
-            case 'response.output_item.done': {
-                const itemDoneEvent = event;
-                if (itemDoneEvent.item &&
-                    'type' in itemDoneEvent.item &&
-                    itemDoneEvent.item.type === 'message') {
-                    // Yield final complete message
-                    const outputMessage = itemDoneEvent.item;
-                    yield convertToAssistantMessage(outputMessage);
-                }
-                break;
-            }
+        else if (update.type === 'complete' && update.completeMessage) {
+            // Yield final complete message converted to chat format
+            yield convertToAssistantMessage(update.completeMessage);
         }
     }
 }
@@ -157,19 +155,16 @@ export async function consumeStreamForCompletion(stream) {
         if (!('type' in event)) {
             continue;
         }
-        if (event.type === 'response.completed') {
-            const completedEvent = event;
-            return completedEvent.response;
+        if (isResponseCompletedEvent(event)) {
+            return event.response;
         }
-        if (event.type === 'response.failed') {
-            const failedEvent = event;
+        if (isResponseFailedEvent(event)) {
             // The failed event contains the full response with error information
-            throw new Error(`Response failed: ${JSON.stringify(failedEvent.response.error)}`);
+            throw new Error(`Response failed: ${JSON.stringify(event.response.error)}`);
         }
-        if (event.type === 'response.incomplete') {
-            const incompleteEvent = event;
+        if (isResponseIncompleteEvent(event)) {
             // Return the incomplete response
-            return incompleteEvent.response;
+            return event.response;
         }
     }
     throw new Error('Stream ended without completion event');
@@ -216,6 +211,12 @@ export function extractTextFromResponse(response) {
     if (response.outputText) {
         return response.outputText;
     }
+    // Check if there's a message in the output
+    const hasMessage = response.output.some((item) => 'type' in item && item.type === 'message');
+    if (!hasMessage) {
+        // No message in response (e.g., only function calls)
+        return '';
+    }
     // Otherwise, extract from the first message (convert to AssistantMessage which has string content)
     const message = extractMessageFromResponse(response);
     // AssistantMessage.content is string | Array | null | undefined
@@ -231,22 +232,22 @@ export function extractTextFromResponse(response) {
 export function extractToolCallsFromResponse(response) {
     const toolCalls = [];
     for (const item of response.output) {
-        if ('type' in item && item.type === 'function_call') {
-            const functionCallItem = item;
+        if (isFunctionCallOutputItem(item)) {
             try {
-                const parsedArguments = JSON.parse(functionCallItem.arguments);
+                const parsedArguments = JSON.parse(item.arguments);
                 toolCalls.push({
-                    id: functionCallItem.callId,
-                    name: functionCallItem.name,
+                    id: item.callId,
+                    name: item.name,
                     arguments: parsedArguments,
                 });
             }
-            catch (_error) {
+            catch (error) {
+                console.warn(`Failed to parse tool call arguments for ${item.name}:`, error instanceof Error ? error.message : String(error), `\nArguments: ${item.arguments.substring(0, 100)}${item.arguments.length > 100 ? '...' : ''}`);
                 // Include the tool call with unparsed arguments
                 toolCalls.push({
-                    id: functionCallItem.callId,
-                    name: functionCallItem.name,
-                    arguments: functionCallItem.arguments, // Keep as string if parsing fails
+                    id: item.callId,
+                    name: item.name,
+                    arguments: item.arguments, // Keep as string if parsing fails
                 });
             }
         }
@@ -267,75 +268,72 @@ export async function* buildToolCallStream(stream) {
         }
         switch (event.type) {
             case 'response.output_item.added': {
-                const itemEvent = event;
-                if (itemEvent.item && 'type' in itemEvent.item && itemEvent.item.type === 'function_call') {
-                    const functionCallItem = itemEvent.item;
-                    toolCallsInProgress.set(functionCallItem.callId, {
-                        id: functionCallItem.callId,
-                        name: functionCallItem.name,
+                if (isOutputItemAddedEvent(event) && event.item && isFunctionCallOutputItem(event.item)) {
+                    toolCallsInProgress.set(event.item.callId, {
+                        id: event.item.callId,
+                        name: event.item.name,
                         argumentsAccumulated: '',
                     });
                 }
                 break;
             }
             case 'response.function_call_arguments.delta': {
-                const deltaEvent = event;
-                const toolCall = toolCallsInProgress.get(deltaEvent.itemId);
-                if (toolCall && deltaEvent.delta) {
-                    toolCall.argumentsAccumulated += deltaEvent.delta;
+                if (isFunctionCallArgumentsDeltaEvent(event)) {
+                    const toolCall = toolCallsInProgress.get(event.itemId);
+                    if (toolCall && event.delta) {
+                        toolCall.argumentsAccumulated += event.delta;
+                    }
                 }
                 break;
             }
             case 'response.function_call_arguments.done': {
-                const doneEvent = event;
-                const toolCall = toolCallsInProgress.get(doneEvent.itemId);
-                if (toolCall) {
-                    // Parse complete arguments
-                    try {
-                        const parsedArguments = JSON.parse(doneEvent.arguments);
-                        yield {
-                            id: toolCall.id,
-                            name: doneEvent.name,
-                            arguments: parsedArguments,
-                        };
-                    }
-                    catch (_error) {
-                        // Yield with unparsed arguments if parsing fails
-                        yield {
-                            id: toolCall.id,
-                            name: doneEvent.name,
-                            arguments: doneEvent.arguments,
-                        };
+                if (isFunctionCallArgumentsDoneEvent(event)) {
+                    const toolCall = toolCallsInProgress.get(event.itemId);
+                    if (toolCall) {
+                        // Parse complete arguments
+                        try {
+                            const parsedArguments = JSON.parse(event.arguments);
+                            yield {
+                                id: toolCall.id,
+                                name: event.name,
+                                arguments: parsedArguments,
+                            };
+                        }
+                        catch (error) {
+                            console.warn(`Failed to parse tool call arguments for ${event.name}:`, error instanceof Error ? error.message : String(error), `\nArguments: ${event.arguments.substring(0, 100)}${event.arguments.length > 100 ? '...' : ''}`);
+                            // Yield with unparsed arguments if parsing fails
+                            yield {
+                                id: toolCall.id,
+                                name: event.name,
+                                arguments: event.arguments,
+                            };
+                        }
+                        // Clean up
+                        toolCallsInProgress.delete(event.itemId);
                     }
-                    // Clean up
-                    toolCallsInProgress.delete(doneEvent.itemId);
                 }
                 break;
             }
             case 'response.output_item.done': {
-                const itemDoneEvent = event;
-                if (itemDoneEvent.item &&
-                    'type' in itemDoneEvent.item &&
-                    itemDoneEvent.item.type === 'function_call') {
-                    const functionCallItem = itemDoneEvent.item;
+                if (isOutputItemDoneEvent(event) && event.item && isFunctionCallOutputItem(event.item)) {
                     // Yield final tool call if we haven't already
-                    if (toolCallsInProgress.has(functionCallItem.callId)) {
+                    if (toolCallsInProgress.has(event.item.callId)) {
                         try {
-                            const parsedArguments = JSON.parse(functionCallItem.arguments);
+                            const parsedArguments = JSON.parse(event.item.arguments);
                             yield {
-                                id: functionCallItem.callId,
-                                name: functionCallItem.name,
+                                id: event.item.callId,
+                                name: event.item.name,
                                 arguments: parsedArguments,
                             };
                         }
                         catch (_error) {
                             yield {
-                                id: functionCallItem.callId,
-                                name: functionCallItem.name,
-                                arguments: functionCallItem.arguments,
+                                id: event.item.callId,
+                                name: event.item.name,
+                                arguments: event.item.arguments,
                             };
                         }
-                        toolCallsInProgress.delete(functionCallItem.callId);
+                        toolCallsInProgress.delete(event.item.callId);
                     }
                 }
                 break;
@@ -363,45 +361,52 @@ function mapAnnotationsToCitations(annotations) {
         }
         switch (annotation.type) {
             case 'file_citation': {
-                const fileCite = annotation;
-                citations.push({
-                    type: 'char_location',
-                    cited_text: '',
-                    document_index: fileCite.index,
-                    document_title: fileCite.filename,
-                    file_id: fileCite.fileId,
-                    start_char_index: 0,
-                    end_char_index: 0,
-                });
+                if (isFileCitationAnnotation(annotation)) {
+                    citations.push({
+                        type: 'char_location',
+                        cited_text: '',
+                        document_index: annotation.index,
+                        document_title: annotation.filename,
+                        file_id: annotation.fileId,
+                        start_char_index: 0,
+                        end_char_index: 0,
+                    });
+                }
                 break;
             }
             case 'url_citation': {
-                const urlCite = annotation;
-                citations.push({
-                    type: 'web_search_result_location',
-                    cited_text: '',
-                    title: urlCite.title,
-                    url: urlCite.url,
-                    encrypted_index: '',
-                });
+                if (isURLCitationAnnotation(annotation)) {
+                    citations.push({
+                        type: 'web_search_result_location',
+                        cited_text: '',
+                        title: annotation.title,
+                        url: annotation.url,
+                        encrypted_index: '',
+                    });
+                }
                 break;
             }
             case 'file_path': {
-                const pathCite = annotation;
-                citations.push({
-                    type: 'char_location',
-                    cited_text: '',
-                    document_index: pathCite.index,
-                    document_title: '',
-                    file_id: pathCite.fileId,
-                    start_char_index: 0,
-                    end_char_index: 0,
-                });
+                if (isFilePathAnnotation(annotation)) {
+                    citations.push({
+                        type: 'char_location',
+                        cited_text: '',
+                        document_index: annotation.index,
+                        document_title: '',
+                        file_id: annotation.fileId,
+                        start_char_index: 0,
+                        end_char_index: 0,
+                    });
+                }
                 break;
             }
             default: {
-                const _exhaustiveCheck = annotation;
-                throw new Error(`Unhandled annotation type: ${_exhaustiveCheck.type}`);
+                // Exhaustiveness check - TypeScript will error if we don't handle all annotation types
+                const exhaustiveCheck = annotation;
+                // Cast to unknown for runtime debugging if type system bypassed
+                // This should never execute - throw with JSON of the unhandled value
+                throw new Error(`Unhandled annotation type. This indicates a new annotation type was added. ` +
+                    `Annotation: ${JSON.stringify(exhaustiveCheck)}`);
             }
         }
     }
@@ -439,116 +444,160 @@ export function convertToClaudeMessage(response) {
     const unsupportedContent = [];
     for (const item of response.output) {
         if (!('type' in item)) {
+            // Handle items without type field
+            // Convert unknown item to a record format for storage
+            const itemData = typeof item === 'object' && item !== null
+                ? item
+                : { value: item };
+            unsupportedContent.push({
+                original_type: 'unknown',
+                data: itemData,
+                reason: 'Output item missing type field',
+            });
             continue;
         }
         switch (item.type) {
             case 'message': {
-                const msgItem = item;
-                for (const part of msgItem.content) {
-                    if (!('type' in part)) {
-                        continue;
-                    }
-                    if (part.type === 'output_text') {
-                        const textPart = part;
-                        const citations = mapAnnotationsToCitations(textPart.annotations);
-                        content.push({
-                            type: 'text',
-                            text: textPart.text,
-                            ...(citations && { citations }),
-                        });
-                    }
-                    else if (part.type === 'refusal') {
-                        const refusalPart = part;
-                        unsupportedContent.push({
-                            original_type: 'refusal',
-                            data: { refusal: refusalPart.refusal },
-                            reason: 'Claude does not have a native refusal content type',
-                        });
+                if (isOutputMessage(item)) {
+                    for (const part of item.content) {
+                        if (!('type' in part)) {
+                            // Convert unknown part to a record format for storage
+                            const partData = typeof part === 'object' && part !== null
+                                ? part
+                                : { value: part };
+                            unsupportedContent.push({
+                                original_type: 'unknown_message_part',
+                                data: partData,
+                                reason: 'Message content part missing type field',
+                            });
+                            continue;
+                        }
+                        if (isOutputTextPart(part)) {
+                            const citations = mapAnnotationsToCitations(part.annotations);
+                            content.push({
+                                type: 'text',
+                                text: part.text,
+                                ...(citations && {
+                                    citations,
+                                }),
+                            });
+                        }
+                        else if (isRefusalPart(part)) {
+                            unsupportedContent.push({
+                                original_type: 'refusal',
+                                data: {
+                                    refusal: part.refusal,
+                                },
+                                reason: 'Claude does not have a native refusal content type',
+                            });
+                        }
+                        else {
+                            // Exhaustiveness check - TypeScript will error if we don't handle all part types
+                            const exhaustiveCheck = part;
+                            // This should never execute - new content type was added
+                            throw new Error(`Unhandled message content type. This indicates a new content type was added. ` +
+                                `Part: ${JSON.stringify(exhaustiveCheck)}`);
+                        }
                     }
                 }
                 break;
             }
             case 'function_call': {
-                const fnCall = item;
-                let parsedInput = {};
-                try {
-                    parsedInput = JSON.parse(fnCall.arguments);
-                }
-                catch {
-                    parsedInput = {};
+                if (isFunctionCallOutputItem(item)) {
+                    let parsedInput;
+                    try {
+                        parsedInput = JSON.parse(item.arguments);
+                    }
+                    catch (error) {
+                        console.warn(`Failed to parse tool call arguments for ${item.name}:`, error instanceof Error ? error.message : String(error), `\nArguments: ${item.arguments.substring(0, 100)}${item.arguments.length > 100 ? '...' : ''}`);
+                        // Preserve raw arguments if JSON parsing fails
+                        parsedInput = {
+                            _raw_arguments: item.arguments,
+                        };
+                    }
+                    content.push({
+                        type: 'tool_use',
+                        id: item.callId,
+                        name: item.name,
+                        input: parsedInput,
+                    });
                 }
-                content.push({
-                    type: 'tool_use',
-                    id: fnCall.callId,
-                    name: fnCall.name,
-                    input: parsedInput,
-                });
                 break;
             }
             case 'reasoning': {
-                const reasoningItem = item;
-                if (reasoningItem.summary && reasoningItem.summary.length > 0) {
-                    for (const summaryItem of reasoningItem.summary) {
-                        if (summaryItem.type === 'summary_text' && summaryItem.text) {
-                            content.push({
-                                type: 'thinking',
-                                thinking: summaryItem.text,
-                                signature: '',
-                            });
+                if (isReasoningOutputItem(item)) {
+                    if (item.summary && item.summary.length > 0) {
+                        for (const summaryItem of item.summary) {
+                            if (summaryItem.type === 'summary_text' && summaryItem.text) {
+                                content.push({
+                                    type: 'thinking',
+                                    thinking: summaryItem.text,
+                                    signature: '',
+                                });
+                            }
                         }
                     }
-                }
-                if (reasoningItem.encryptedContent) {
-                    unsupportedContent.push({
-                        original_type: 'reasoning_encrypted',
-                        data: {
-                            id: reasoningItem.id,
-                            encrypted_content: reasoningItem.encryptedContent,
-                        },
-                        reason: 'Encrypted reasoning content preserved for round-trip',
-                    });
+                    if (item.encryptedContent) {
+                        unsupportedContent.push({
+                            original_type: 'reasoning_encrypted',
+                            data: {
+                                id: item.id,
+                                encrypted_content: item.encryptedContent,
+                            },
+                            reason: 'Encrypted reasoning content preserved for round-trip',
+                        });
+                    }
                 }
                 break;
             }
             case 'web_search_call': {
-                const webSearchItem = item;
-                content.push({
-                    type: 'server_tool_use',
-                    id: webSearchItem.id,
-                    name: 'web_search',
-                    input: { status: webSearchItem.status },
-                });
+                if (isWebSearchCallOutputItem(item)) {
+                    content.push({
+                        type: 'server_tool_use',
+                        id: item.id,
+                        name: 'web_search',
+                        input: {
+                            status: item.status,
+                        },
+                    });
+                }
                 break;
             }
             case 'file_search_call': {
-                const fileSearchItem = item;
-                content.push({
-                    type: 'tool_use',
-                    id: fileSearchItem.id,
-                    name: 'file_search',
-                    input: {
-                        queries: fileSearchItem.queries,
-                        status: fileSearchItem.status,
-                    },
-                });
+                if (isFileSearchCallOutputItem(item)) {
+                    content.push({
+                        type: 'tool_use',
+                        id: item.id,
+                        name: 'file_search',
+                        input: {
+                            queries: item.queries,
+                            status: item.status,
+                        },
+                    });
+                }
                 break;
             }
             case 'image_generation_call': {
-                const imageGenItem = item;
-                unsupportedContent.push({
-                    original_type: 'image_generation_call',
-                    data: {
-                        id: imageGenItem.id,
-                        result: imageGenItem.result,
-                        status: imageGenItem.status,
-                    },
-                    reason: 'Claude does not support image outputs in assistant messages',
-                });
+                if (isImageGenerationCallOutputItem(item)) {
+                    unsupportedContent.push({
+                        original_type: 'image_generation_call',
+                        data: {
+                            id: item.id,
+                            result: item.result,
+                            status: item.status,
+                        },
+                        reason: 'Claude does not support image outputs in assistant messages',
+                    });
+                }
                 break;
             }
             default: {
-                const _exhaustiveCheck = item;
-                throw new Error(`Unhandled output item type: ${_exhaustiveCheck.type}`);
+                // Exhaustiveness check - if a new output type is added, TypeScript will error here
+                const exhaustiveCheck = item;
+                // This line should never execute - it means a new type was added to the union
+                // Throw an error instead of silently continuing to ensure we catch new types
+                throw new Error(`Unhandled output item type. This indicates a new output type was added to the API. ` +
+                    `Item: ${JSON.stringify(exhaustiveCheck)}`);
             }
         }
     }
@@ -566,7 +615,9 @@ export function convertToClaudeMessage(response) {
             cache_creation_input_tokens: response.usage?.inputTokensDetails?.cachedTokens ?? 0,
             cache_read_input_tokens: 0,
         },
-        ...(unsupportedContent.length > 0 && { unsupported_content: unsupportedContent }),
+        ...(unsupportedContent.length > 0 && {
+            unsupported_content: unsupportedContent,
+        }),
     };
 }
 /**
@@ -576,7 +627,7 @@ export function extractUnsupportedContent(message, originalType) {
     if (!message.unsupported_content) {
         return [];
     }
-    return message.unsupported_content.filter(item => item.original_type === originalType);
+    return message.unsupported_content.filter((item) => item.original_type === originalType);
 }
 /**
  * Check if message has any unsupported content