@openrouter/sdk 0.9.11 → 0.11.2

package/esm/lib/next-turn-params.d.ts

@@ -4,10 +4,10 @@ import type { NextTurnParamsContext, ParsedToolCall, Tool } from './tool-types.j
  * Build a NextTurnParamsContext from the current request
  * Extracts relevant fields that can be modified by nextTurnParams functions
  *
- * @param request - The current OpenResponsesRequest
+ * @param request - The current ResponsesRequest
  * @returns Context object with current parameter values
  */
-export declare function buildNextTurnParamsContext(request: models.OpenResponsesRequest): NextTurnParamsContext;
+export declare function buildNextTurnParamsContext(request: models.ResponsesRequest): NextTurnParamsContext;
 /**
  * Execute nextTurnParams functions for all called tools
  * Composes functions when multiple tools modify the same parameter
@@ -17,7 +17,7 @@ export declare function buildNextTurnParamsContext(request: models.OpenResponses
  * @param currentRequest - The current request
  * @returns Object with computed parameter values
  */
-export declare function executeNextTurnParamsFunctions(toolCalls: ParsedToolCall<Tool>[], tools: readonly Tool[], currentRequest: models.OpenResponsesRequest): Promise<Partial<NextTurnParamsContext>>;
+export declare function executeNextTurnParamsFunctions(toolCalls: ParsedToolCall<Tool>[], tools: readonly Tool[], currentRequest: models.ResponsesRequest): Promise<Partial<NextTurnParamsContext>>;
 /**
  * Apply computed nextTurnParams to the current request
  * Returns a new request object with updated parameters
@@ -26,5 +26,5 @@ export declare function executeNextTurnParamsFunctions(toolCalls: ParsedToolCall
  * @param computedParams - Computed parameter values from nextTurnParams functions
  * @returns New request with updated parameters
  */
-export declare function applyNextTurnParamsToRequest(request: models.OpenResponsesRequest, computedParams: Partial<NextTurnParamsContext>): models.OpenResponsesRequest;
+export declare function applyNextTurnParamsToRequest(request: models.ResponsesRequest, computedParams: Partial<NextTurnParamsContext>): models.ResponsesRequest;
 //# sourceMappingURL=next-turn-params.d.ts.map

package/esm/lib/next-turn-params.js

@@ -8,7 +8,7 @@ function isRecord(value) {
  * Build a NextTurnParamsContext from the current request
  * Extracts relevant fields that can be modified by nextTurnParams functions
  *
- * @param request - The current OpenResponsesRequest
+ * @param request - The current ResponsesRequest
  * @returns Context object with current parameter values
  */
 export function buildNextTurnParamsContext(request) {

package/esm/lib/sdks.d.ts

@@ -1,5 +1,5 @@
 import { SDKHooks } from "../hooks/hooks.js";
-import type { HookContext } from "../hooks/types.js";
+import { HookContext } from "../hooks/types.js";
 import { ConnectionError, InvalidRequestError, RequestAbortedError, RequestTimeoutError, UnexpectedClientError } from "../models/errors/httpclienterrors.js";
 import { Result } from "../types/fp.js";
 import { SDKOptions } from "./config.js";

package/esm/lib/sdks.js

@@ -13,7 +13,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _ClientSDK_instances, _ClientSDK_httpClient, _ClientSDK_hooks, _ClientSDK_logger, _ClientSDK_registerHook;
+var _ClientSDK_httpClient, _ClientSDK_hooks, _ClientSDK_logger;
 import { SDKHooks } from "../hooks/hooks.js";
 import { ConnectionError, InvalidRequestError, RequestAbortedError, RequestTimeoutError, UnexpectedClientError, } from "../models/errors/httpclienterrors.js";
 import { ERR, OK } from "../types/fp.js";
@@ -33,22 +33,18 @@ const isBrowserLike = webWorkerLike
     || (typeof window === "object" && typeof window.document !== "undefined");
 export class ClientSDK {
     constructor(options = {}) {
-        _ClientSDK_instances.add(this);
         _ClientSDK_httpClient.set(this, void 0);
         _ClientSDK_hooks.set(this, void 0);
         _ClientSDK_logger.set(this, void 0);
-        // Reuse existing SDKHooks if passed (for sub-SDKs)
-        if (options.hooks instanceof SDKHooks) {
-            __classPrivateFieldSet(this, _ClientSDK_hooks, options.hooks, "f");
+        const opt = options;
+        if (typeof opt === "object"
+            && opt != null
+            && "hooks" in opt
+            && opt.hooks instanceof SDKHooks) {
+            __classPrivateFieldSet(this, _ClientSDK_hooks, opt.hooks, "f");
         }
         else {
             __classPrivateFieldSet(this, _ClientSDK_hooks, new SDKHooks(), "f");
-            if (options.hooks) {
-                const hooksArray = Array.isArray(options.hooks) ? options.hooks : [options.hooks];
-                for (const hook of hooksArray) {
-                    __classPrivateFieldGet(this, _ClientSDK_instances, "m", _ClientSDK_registerHook).call(this, hook);
-                }
-            }
         }
         const defaultHttpClient = new HTTPClient();
         options.httpClient = options.httpClient || defaultHttpClient;
@@ -71,12 +67,16 @@ export class ClientSDK {
         if (!base) {
             return ERR(new InvalidRequestError("No base URL provided for operation"));
         }
-        const reqURL = new URL(base);
-        const inputURL = new URL(path, reqURL);
+        const baseURL = new URL(base);
+        let reqURL;
         if (path) {
-            reqURL.pathname += reqURL.pathname.endsWith("/") ? "" : "/";
-            reqURL.pathname += inputURL.pathname.replace(/^\/+/, "");
+            baseURL.pathname = baseURL.pathname.replace(/\/+$/, "") + "/";
+            reqURL = new URL(path, baseURL);
         }
+        else {
+            reqURL = baseURL;
+        }
+        reqURL.hash = "";
         let finalQuery = query || "";
         const secQuery = [];
         for (const [k, v] of Object.entries(security?.queryParams || {})) {
@@ -189,25 +189,9 @@ export class ClientSDK {
         });
     }
 }
-_ClientSDK_httpClient = new WeakMap(), _ClientSDK_hooks = new WeakMap(), _ClientSDK_logger = new WeakMap(), _ClientSDK_instances = new WeakSet(), _ClientSDK_registerHook = function _ClientSDK_registerHook(hook) {
-    if ("sdkInit" in hook) {
-        __classPrivateFieldGet(this, _ClientSDK_hooks, "f").registerSDKInitHook(hook);
-    }
-    if ("beforeCreateRequest" in hook) {
-        __classPrivateFieldGet(this, _ClientSDK_hooks, "f").registerBeforeCreateRequestHook(hook);
-    }
-    if ("beforeRequest" in hook) {
-        __classPrivateFieldGet(this, _ClientSDK_hooks, "f").registerBeforeRequestHook(hook);
-    }
-    if ("afterSuccess" in hook) {
-        __classPrivateFieldGet(this, _ClientSDK_hooks, "f").registerAfterSuccessHook(hook);
-    }
-    if ("afterError" in hook) {
-        __classPrivateFieldGet(this, _ClientSDK_hooks, "f").registerAfterErrorHook(hook);
-    }
-};
-const jsonLikeContentTypeRE = /(application|text)\/.*?\+*json.*/;
-const jsonlLikeContentTypeRE = /(application|text)\/(.*?\+*\bjsonl\b.*|.*?\+*\bx-ndjson\b.*)/;
+_ClientSDK_httpClient = new WeakMap(), _ClientSDK_hooks = new WeakMap(), _ClientSDK_logger = new WeakMap();
+const jsonLikeContentTypeRE = /^(application|text)\/([^+]+\+)*json.*/;
+const jsonlLikeContentTypeRE = /^(application|text)\/([^+]+\+)*(jsonl|x-ndjson)\b.*/;
 async function logRequest(logger, req) {
     if (!logger) {
         return;

package/esm/lib/security.d.ts

@@ -77,7 +77,7 @@ type SecurityInputCustom = {
 };
 export type SecurityInput = SecurityInputBasic | SecurityInputBearer | SecurityInputAPIKey | SecurityInputOAuth2 | SecurityInputOAuth2ClientCredentials | SecurityInputOAuth2PasswordCredentials | SecurityInputOIDC | SecurityInputCustom;
 export declare function resolveSecurity(...options: SecurityInput[][]): SecurityState | null;
-export declare function resolveGlobalSecurity(security: Partial<models.Security> | null | undefined): SecurityState | null;
+export declare function resolveGlobalSecurity(security: Partial<models.Security> | null | undefined, allowedFields?: number[]): SecurityState | null;
 export declare function extractSecurity<T extends string | Record<string, unknown>>(sec: T | (() => Promise<T>) | undefined): Promise<T | undefined>;
 export {};
 //# sourceMappingURL=security.d.ts.map

package/esm/lib/security.js

@@ -96,8 +96,7 @@ export function resolveSecurity(...options) {
                 applyBearer(state, spec);
                 break;
             default:
-                spec;
-                throw SecurityError.unrecognizedType(type);
+                throw SecurityError.unrecognizedType((spec, type));
         }
     });
     return state;
@@ -120,14 +119,25 @@ function applyBearer(state, spec) {
         state.headers[spec.fieldName] = value;
     }
 }
-export function resolveGlobalSecurity(security) {
-    return resolveSecurity([
-        {
-            fieldName: "Authorization",
-            type: "http:bearer",
-            value: security?.apiKey ?? env().OPENROUTER_API_KEY,
-        },
-    ]);
+export function resolveGlobalSecurity(security, allowedFields) {
+    let inputs = [
+        [
+            {
+                fieldName: "Authorization",
+                type: "http:bearer",
+                value: security?.apiKey ?? env().OPENROUTER_API_KEY,
+            },
+        ],
+    ];
+    if (allowedFields) {
+        inputs = allowedFields.map((i) => {
+            if (i < 0 || i >= inputs.length) {
+                throw new RangeError(`invalid allowedFields index ${i}`);
+            }
+            return inputs[i];
+        });
+    }
+    return resolveSecurity(...inputs);
 }
 export async function extractSecurity(sec) {
     if (sec == null) {

package/esm/lib/stream-transformers.d.ts

@@ -1,85 +1,109 @@
 import type * as models from '../models/index.js';
+import type { ClaudeMessage, UnsupportedContent } from '../models/claude-message.js';
 import type { ReusableReadableStream } from './reusable-stream.js';
 import type { ParsedToolCall, Tool } from './tool-types.js';
 /**
  * Extract text deltas from responses stream events
  */
-export declare function extractTextDeltas(stream: ReusableReadableStream<models.OpenResponsesStreamEvent>): AsyncIterableIterator<string>;
+export declare function extractTextDeltas(stream: ReusableReadableStream<models.StreamEvents>): AsyncIterableIterator<string>;
 /**
  * Extract reasoning deltas from responses stream events
  */
-export declare function extractReasoningDeltas(stream: ReusableReadableStream<models.OpenResponsesStreamEvent>): AsyncIterableIterator<string>;
+export declare function extractReasoningDeltas(stream: ReusableReadableStream<models.StreamEvents>): AsyncIterableIterator<string>;
 /**
  * Extract tool call argument deltas from responses stream events
  */
-export declare function extractToolDeltas(stream: ReusableReadableStream<models.OpenResponsesStreamEvent>): AsyncIterableIterator<string>;
+export declare function extractToolDeltas(stream: ReusableReadableStream<models.StreamEvents>): AsyncIterableIterator<string>;
 /**
  * Build incremental message updates from responses stream events
- * Returns ResponsesOutputMessage (assistant/responses format)
+ * Returns OutputMessage (assistant/responses format)
  */
-export declare function buildResponsesMessageStream(stream: ReusableReadableStream<models.OpenResponsesStreamEvent>): AsyncIterableIterator<models.ResponsesOutputMessage>;
+export declare function buildResponsesMessageStream(stream: ReusableReadableStream<models.StreamEvents>): AsyncIterableIterator<models.OutputMessage>;
 /**
  * Output item types that can be streamed from a response.
  * This is the union of all item types that appear in response output,
  * plus function_call_output for tool results.
  */
-export type StreamableOutputItem = models.ResponsesOutputMessage | models.ResponsesOutputItemFunctionCall | models.ResponsesOutputItemReasoning | models.ResponsesWebSearchCallOutput | models.ResponsesOutputItemFileSearchCall | models.ResponsesImageGenerationCall | models.OpenResponsesFunctionCallOutput;
+export type StreamableOutputItem = models.OutputMessage | models.OutputFunctionCallItem | models.OutputReasoningItem | models.OutputWebSearchCallItem | models.OutputFileSearchCallItem | models.OutputImageGenerationCallItem | models.FunctionCallOutputItem;
+/**
+ * Discriminated union for tracking items in progress.
+ * Each variant has only the fields relevant to that item type.
+ */
+export type ItemInProgress = {
+    type: 'message';
+    id: string;
+    textContent: string;
+} | {
+    type: 'function_call';
+    id: string;
+    name: string;
+    callId: string;
+    argumentsAccumulated: string;
+} | {
+    type: 'reasoning';
+    id: string;
+    reasoningContent: string;
+};
+type ItemsStreamHandler = (event: models.StreamEvents, itemsInProgress: Map<string, ItemInProgress>) => StreamableOutputItem | undefined;
+export declare const itemsStreamHandlers: Record<string, ItemsStreamHandler>;
+export declare const streamTerminationEvents: Set<string>;
 /**
  * Build incremental output item updates from responses stream events.
  * Yields all item types cumulatively - same item may be emitted multiple times
  * with the same ID but progressively updated content as streaming progresses.
  */
-export declare function buildItemsStream(stream: ReusableReadableStream<models.OpenResponsesStreamEvent>): AsyncIterableIterator<StreamableOutputItem>;
+export declare function buildItemsStream(stream: ReusableReadableStream<models.StreamEvents>): AsyncIterableIterator<StreamableOutputItem>;
 /**
  * Build incremental message updates from responses stream events
- * Returns AssistantMessage (chat format) instead of ResponsesOutputMessage
+ * Returns ChatAssistantMessage (chat format) instead of OutputMessage
  */
-export declare function buildMessageStream(stream: ReusableReadableStream<models.OpenResponsesStreamEvent>): AsyncIterableIterator<models.AssistantMessage>;
+export declare function buildMessageStream(stream: ReusableReadableStream<models.StreamEvents>): AsyncIterableIterator<models.ChatAssistantMessage>;
 /**
  * Consume stream until completion and return the complete response
  */
-export declare function consumeStreamForCompletion(stream: ReusableReadableStream<models.OpenResponsesStreamEvent>): Promise<models.OpenResponsesNonStreamingResponse>;
+export declare function consumeStreamForCompletion(stream: ReusableReadableStream<models.StreamEvents>): Promise<models.OpenResponsesResult>;
 /**
  * Extract the first message from a completed response (chat format)
  */
-export declare function extractMessageFromResponse(response: models.OpenResponsesNonStreamingResponse): models.AssistantMessage;
+export declare function extractMessageFromResponse(response: models.OpenResponsesResult): models.ChatAssistantMessage;
 /**
  * Extract the first message from a completed response (responses format)
  */
-export declare function extractResponsesMessageFromResponse(response: models.OpenResponsesNonStreamingResponse): models.ResponsesOutputMessage;
+export declare function extractResponsesMessageFromResponse(response: models.OpenResponsesResult): models.OutputMessage;
 /**
  * Extract text from a response, either from outputText or by concatenating message content
  */
-export declare function extractTextFromResponse(response: models.OpenResponsesNonStreamingResponse): string;
+export declare function extractTextFromResponse(response: models.OpenResponsesResult): string;
 /**
  * Extract all tool calls from a completed response
  * Returns parsed tool calls with arguments as objects (not JSON strings)
  */
-export declare function extractToolCallsFromResponse(response: models.OpenResponsesNonStreamingResponse): ParsedToolCall<Tool>[];
+export declare function extractToolCallsFromResponse(response: models.OpenResponsesResult): ParsedToolCall<Tool>[];
 /**
  * Build incremental tool call updates from responses stream events
  * Yields structured tool call objects as they're built from deltas
  */
-export declare function buildToolCallStream(stream: ReusableReadableStream<models.OpenResponsesStreamEvent>): AsyncIterableIterator<ParsedToolCall<Tool>>;
+export declare function buildToolCallStream(stream: ReusableReadableStream<models.StreamEvents>): AsyncIterableIterator<ParsedToolCall<Tool>>;
 /**
  * Check if a response contains any tool calls
  */
-export declare function responseHasToolCalls(response: models.OpenResponsesNonStreamingResponse): boolean;
+export declare function responseHasToolCalls(response: models.OpenResponsesResult): boolean;
 /**
- * Convert OpenResponsesNonStreamingResponse to ClaudeMessage format
+ * Convert OpenResponsesResult to ClaudeMessage format
  * Compatible with the Anthropic SDK BetaMessage type
  */
-export declare function convertToClaudeMessage(response: models.OpenResponsesNonStreamingResponse): models.ClaudeMessage;
+export declare function convertToClaudeMessage(response: models.OpenResponsesResult): ClaudeMessage;
 /**
  * Extract unsupported content by original type
  */
-export declare function extractUnsupportedContent(message: models.ClaudeMessage, originalType: string): models.UnsupportedContent[];
+export declare function extractUnsupportedContent(message: ClaudeMessage, originalType: string): UnsupportedContent[];
 /**
  * Check if message has any unsupported content
  */
-export declare function hasUnsupportedContent(message: models.ClaudeMessage): boolean;
+export declare function hasUnsupportedContent(message: ClaudeMessage): boolean;
 /**
  * Get summary of unsupported content types
  */
-export declare function getUnsupportedContentSummary(message: models.ClaudeMessage): Record<string, number>;
+export declare function getUnsupportedContentSummary(message: ClaudeMessage): Record<string, number>;
+export {};
 //# sourceMappingURL=stream-transformers.d.ts.map

package/esm/lib/stream-transformers.js

@@ -101,12 +101,12 @@ async function* buildMessageStreamCore(stream) {
 }
 /**
  * Build incremental message updates from responses stream events
- * Returns ResponsesOutputMessage (assistant/responses format)
+ * Returns OutputMessage (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 incremental update in OutputMessage format
             yield {
                 id: update.messageId,
                 type: 'message',
@@ -296,14 +296,14 @@ function handleOutputItemDone(event, itemsInProgress) {
     }
     return undefined;
 }
-const itemsStreamHandlers = {
+export const itemsStreamHandlers = {
     'response.output_item.added': handleOutputItemAdded,
     'response.output_text.delta': handleTextDelta,
     'response.function_call_arguments.delta': handleFunctionCallDelta,
     'response.reasoning_text.delta': handleReasoningDelta,
     'response.output_item.done': handleOutputItemDone,
 };
-const streamTerminationEvents = new Set([
+export const streamTerminationEvents = new Set([
     'response.completed',
     'response.failed',
     'response.incomplete',
@@ -335,7 +335,7 @@ export async function* buildItemsStream(stream) {
 }
 /**
  * Build incremental message updates from responses stream events
- * Returns AssistantMessage (chat format) instead of ResponsesOutputMessage
+ * Returns ChatAssistantMessage (chat format) instead of OutputMessage
  */
 export async function* buildMessageStream(stream) {
     for await (const update of buildMessageStreamCore(stream)) {
@@ -376,7 +376,7 @@ export async function consumeStreamForCompletion(stream) {
     throw new Error('Stream ended without completion event');
 }
 /**
- * Convert ResponsesOutputMessage to AssistantMessage (chat format)
+ * Convert OutputMessage to ChatAssistantMessage (chat format)
  */
 function convertToAssistantMessage(outputMessage) {
     // Extract text content
@@ -423,9 +423,9 @@ export function extractTextFromResponse(response) {
         // No message in response (e.g., only function calls)
         return '';
     }
-    // Otherwise, extract from the first message (convert to AssistantMessage which has string content)
+    // Otherwise, extract from the first message (convert to ChatAssistantMessage which has string content)
     const message = extractMessageFromResponse(response);
-    // AssistantMessage.content is string | Array | null | undefined
+    // ChatAssistantMessage.content is string | Array | null | undefined
     if (typeof message.content === 'string') {
         return message.content;
     }
@@ -440,7 +440,8 @@ export function extractToolCallsFromResponse(response) {
     for (const item of response.output) {
         if (isFunctionCallItem(item)) {
             try {
-                const parsedArguments = JSON.parse(item.arguments);
+                const trimmedArgs = item.arguments.trim();
+                const parsedArguments = trimmedArgs ? JSON.parse(trimmedArgs) : {};
                 toolCalls.push({
                     id: item.callId,
                     name: item.name,
@@ -475,7 +476,9 @@ export async function* buildToolCallStream(stream) {
         switch (event.type) {
             case 'response.output_item.added': {
                 if (isOutputItemAddedEvent(event) && event.item && isFunctionCallItem(event.item)) {
-                    toolCallsInProgress.set(event.item.callId, {
+                    // Use item.id if available (matches itemId in delta events), fall back to callId
+                    const itemKey = event.item.id ?? event.item.callId;
+                    toolCallsInProgress.set(itemKey, {
                         id: event.item.callId,
                         name: event.item.name,
                         argumentsAccumulated: '',
@@ -496,9 +499,10 @@ export async function* buildToolCallStream(stream) {
                 if (isFunctionCallArgumentsDoneEvent(event)) {
                     const toolCall = toolCallsInProgress.get(event.itemId);
                     if (toolCall) {
-                        // Parse complete arguments
+                        // Parse complete arguments (empty string → empty object for no-param tools)
                         try {
-                            const parsedArguments = JSON.parse(event.arguments);
+                            const trimmedArgs = event.arguments.trim();
+                            const parsedArguments = trimmedArgs ? JSON.parse(trimmedArgs) : {};
                             yield {
                                 id: toolCall.id,
                                 name: event.name,
@@ -522,10 +526,13 @@ export async function* buildToolCallStream(stream) {
             }
             case 'response.output_item.done': {
                 if (isOutputItemDoneEvent(event) && event.item && isFunctionCallItem(event.item)) {
+                    // Use item.id if available (matches itemId in delta events), fall back to callId
+                    const itemKey = event.item.id ?? event.item.callId;
                     // Yield final tool call if we haven't already
-                    if (toolCallsInProgress.has(event.item.callId)) {
+                    if (toolCallsInProgress.has(itemKey)) {
                         try {
-                            const parsedArguments = JSON.parse(event.item.arguments);
+                            const trimmedArgs = event.item.arguments.trim();
+                            const parsedArguments = trimmedArgs ? JSON.parse(trimmedArgs) : {};
                             yield {
                                 id: event.item.callId,
                                 name: event.item.name,
@@ -539,7 +546,7 @@ export async function* buildToolCallStream(stream) {
                                 arguments: event.item.arguments,
                             };
                         }
-                        toolCallsInProgress.delete(event.item.callId);
+                        toolCallsInProgress.delete(itemKey);
                     }
                 }
                 break;
@@ -606,14 +613,9 @@ function mapAnnotationsToCitations(annotations) {
                 }
                 break;
             }
-            default: {
-                // 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)}`);
-            }
+            default:
+                // Unknown annotation types are skipped for forward compatibility.
+                break;
         }
     }
     return citations.length > 0 ? citations : undefined;
@@ -642,7 +644,7 @@ function mapStopReason(response) {
     return 'end_turn';
 }
 /**
- * Convert OpenResponsesNonStreamingResponse to ClaudeMessage format
+ * Convert OpenResponsesResult to ClaudeMessage format
  * Compatible with the Anthropic SDK BetaMessage type
  */
 export function convertToClaudeMessage(response) {
@@ -698,11 +700,7 @@ export function convertToClaudeMessage(response) {
                             });
                         }
                         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)}`);
+                            // Unknown content types are skipped for forward compatibility.
                         }
                     }
                 }
@@ -712,7 +710,8 @@ export function convertToClaudeMessage(response) {
                 if (isFunctionCallItem(item)) {
                     let parsedInput;
                     try {
-                        parsedInput = JSON.parse(item.arguments);
+                        const trimmedArgs = item.arguments.trim();
+                        parsedInput = trimmedArgs ? JSON.parse(trimmedArgs) : {};
                     }
                     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 ? '...' : ''}`);
@@ -797,14 +796,10 @@ export function convertToClaudeMessage(response) {
                 }
                 break;
             }
-            default: {
-                // 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)}`);
-            }
+            default:
+                // Unknown output types (e.g. new server tools) are skipped during Claude format
+                // conversion — they round-trip natively via the Responses API input union.
+                break;
         }
     }
     return {

package/esm/lib/stream-type-guards.d.ts

@@ -3,21 +3,21 @@ import type * as models from '../models/index.js';
  * Type guards for OpenResponses stream events
  * These enable proper TypeScript narrowing without type casts
  */
-export declare function isOutputTextDeltaEvent(event: models.OpenResponsesStreamEvent): event is models.OpenResponsesStreamEventResponseOutputTextDelta;
-export declare function isReasoningDeltaEvent(event: models.OpenResponsesStreamEvent): event is models.OpenResponsesReasoningDeltaEvent;
-export declare function isFunctionCallArgumentsDeltaEvent(event: models.OpenResponsesStreamEvent): event is models.OpenResponsesStreamEventResponseFunctionCallArgumentsDelta;
-export declare function isOutputItemAddedEvent(event: models.OpenResponsesStreamEvent): event is models.OpenResponsesStreamEventResponseOutputItemAdded;
-export declare function isOutputItemDoneEvent(event: models.OpenResponsesStreamEvent): event is models.OpenResponsesStreamEventResponseOutputItemDone;
-export declare function isResponseCompletedEvent(event: models.OpenResponsesStreamEvent): event is models.OpenResponsesStreamEventResponseCompleted;
-export declare function isResponseFailedEvent(event: models.OpenResponsesStreamEvent): event is models.OpenResponsesStreamEventResponseFailed;
-export declare function isResponseIncompleteEvent(event: models.OpenResponsesStreamEvent): event is models.OpenResponsesStreamEventResponseIncomplete;
-export declare function isFunctionCallArgumentsDoneEvent(event: models.OpenResponsesStreamEvent): event is models.OpenResponsesStreamEventResponseFunctionCallArgumentsDone;
-export declare function isOutputMessage(item: unknown): item is models.ResponsesOutputMessage;
-export declare function isFunctionCallItem(item: unknown): item is models.ResponsesOutputItemFunctionCall;
-export declare function isReasoningOutputItem(item: unknown): item is models.ResponsesOutputItemReasoning;
-export declare function isWebSearchCallOutputItem(item: unknown): item is models.ResponsesWebSearchCallOutput;
-export declare function isFileSearchCallOutputItem(item: unknown): item is models.ResponsesOutputItemFileSearchCall;
-export declare function isImageGenerationCallOutputItem(item: unknown): item is models.ResponsesImageGenerationCall;
+export declare function isOutputTextDeltaEvent(event: models.StreamEvents): event is models.TextDeltaEvent;
+export declare function isReasoningDeltaEvent(event: models.StreamEvents): event is models.ReasoningDeltaEvent;
+export declare function isFunctionCallArgumentsDeltaEvent(event: models.StreamEvents): event is models.FunctionCallArgsDeltaEvent;
+export declare function isOutputItemAddedEvent(event: models.StreamEvents): event is models.StreamEventsResponseOutputItemAdded;
+export declare function isOutputItemDoneEvent(event: models.StreamEvents): event is models.StreamEventsResponseOutputItemDone;
+export declare function isResponseCompletedEvent(event: models.StreamEvents): event is models.StreamEventsResponseCompleted;
+export declare function isResponseFailedEvent(event: models.StreamEvents): event is models.StreamEventsResponseFailed;
+export declare function isResponseIncompleteEvent(event: models.StreamEvents): event is models.StreamEventsResponseIncomplete;
+export declare function isFunctionCallArgumentsDoneEvent(event: models.StreamEvents): event is models.FunctionCallArgsDoneEvent;
+export declare function isOutputMessage(item: unknown): item is models.OutputMessage;
+export declare function isFunctionCallItem(item: unknown): item is models.OutputFunctionCallItem;
+export declare function isReasoningOutputItem(item: unknown): item is models.OutputReasoningItem;
+export declare function isWebSearchCallOutputItem(item: unknown): item is models.OutputWebSearchCallItem;
+export declare function isFileSearchCallOutputItem(item: unknown): item is models.OutputFileSearchCallItem;
+export declare function isImageGenerationCallOutputItem(item: unknown): item is models.OutputImageGenerationCallItem;
 export declare function isOutputTextPart(part: unknown): part is models.ResponseOutputText;
 export declare function isRefusalPart(part: unknown): part is models.OpenAIResponsesRefusalContent;
 export declare function isFileCitationAnnotation(annotation: unknown): annotation is models.FileCitation;

package/esm/lib/stream-type-guards.js

@@ -32,34 +32,19 @@ export function isFunctionCallArgumentsDoneEvent(event) {
 }
 // Output item type guards
 export function isOutputMessage(item) {
-    return (typeof item === 'object' &&
-        item !== null &&
-        'type' in item &&
-        item.type === 'message');
+    return typeof item === 'object' && item !== null && 'type' in item && item.type === 'message';
 }
 export function isFunctionCallItem(item) {
-    return (typeof item === 'object' &&
-        item !== null &&
-        'type' in item &&
-        item.type === 'function_call');
+    return (typeof item === 'object' && item !== null && 'type' in item && item.type === 'function_call');
 }
 export function isReasoningOutputItem(item) {
-    return (typeof item === 'object' &&
-        item !== null &&
-        'type' in item &&
-        item.type === 'reasoning');
+    return typeof item === 'object' && item !== null && 'type' in item && item.type === 'reasoning';
 }
 export function isWebSearchCallOutputItem(item) {
-    return (typeof item === 'object' &&
-        item !== null &&
-        'type' in item &&
-        item.type === 'web_search_call');
+    return (typeof item === 'object' && item !== null && 'type' in item && item.type === 'web_search_call');
 }
 export function isFileSearchCallOutputItem(item) {
-    return (typeof item === 'object' &&
-        item !== null &&
-        'type' in item &&
-        item.type === 'file_search_call');
+    return (typeof item === 'object' && item !== null && 'type' in item && item.type === 'file_search_call');
 }
 export function isImageGenerationCallOutputItem(item) {
     return (typeof item === 'object' &&
@@ -69,16 +54,10 @@ export function isImageGenerationCallOutputItem(item) {
 }
 // Content part type guards
 export function isOutputTextPart(part) {
-    return (typeof part === 'object' &&
-        part !== null &&
-        'type' in part &&
-        part.type === 'output_text');
+    return typeof part === 'object' && part !== null && 'type' in part && part.type === 'output_text';
 }
 export function isRefusalPart(part) {
-    return (typeof part === 'object' &&
-        part !== null &&
-        'type' in part &&
-        part.type === 'refusal');
+    return typeof part === 'object' && part !== null && 'type' in part && part.type === 'refusal';
 }
 // Annotation type guards for Claude conversion
 export function isFileCitationAnnotation(annotation) {
@@ -101,9 +80,6 @@ export function isFilePathAnnotation(annotation) {
 }
 // Helper to check if output has a type property
 export function hasTypeProperty(item) {
-    return (typeof item === 'object' &&
-        item !== null &&
-        'type' in item &&
-        typeof item.type === 'string');
+    return (typeof item === 'object' && item !== null && 'type' in item && typeof item.type === 'string');
 }
 //# sourceMappingURL=stream-type-guards.js.map