@openrouter/sdk 0.3.7 → 0.3.10

package/.zed/settings.json

@@ -0,0 +1,10 @@
+{
+  "tab_size": 2,
+  "project_name": "@openrouter/sdk",
+  "formatter": {
+    "language_server": {
+      "name": "eslint"
+    }
+  },
+  "language_servers": ["!biome", "..."]
+}

package/_speakeasy/.github/action-inputs-config.json

@@ -0,0 +1,53 @@
+[
+  {
+    "name": "mode",
+    "validation_regex": "/^(direct|pr)$/.source",
+    "validation_message": "Must be `direct` or `pr`"
+  },
+  {
+    "name": "speakeasy_version",
+    "validation_regex": "/^[\\w.\\-]+$/.source",
+    "validation_message": "Letters, numbers, or .-_ only"
+  },
+  {
+    "name": "openapi_doc_location",
+    "validation_regex": "/^((https?):\\/\\/([\\w\\-]+\\.)+\\w+(\\/.*)?|[\\w.\\-\\/]+)$/i.source",
+    "validation_message": "Must be a valid server URL or file path containing letters, numbers, or .-_/ only"
+  },
+  {
+    "name": "openapi_doc_auth_header",
+    "validation_regex": "/^[A-Za-z\\-]+$/.source",
+    "validation_message": "Letters or - only"
+  },
+  {
+    "name": "create_release"
+  },
+  {
+    "name": "publish_python",
+    "language": "python"
+  },
+  {
+    "name": "publish_typescript",
+    "language": "typescript"
+  },
+  {
+    "name": "publish_java",
+    "language": "java"
+  },
+  {
+    "name": "publish_php",
+    "language": "php"
+  },
+  {
+    "name": "publish_ruby",
+    "language": "ruby"
+  },
+  {
+    "name": "publish_csharp",
+    "language": "csharp"
+  },
+  {
+    "name": "publish_terraform",
+    "language": "terraform"
+  }
+]

package/_speakeasy/.github/action-security-config.json

@@ -0,0 +1,88 @@
+[
+  {
+    "name": "pypi_token",
+    "secret_name": "PYPI_TOKEN",
+    "validation_regex": "/^[\\w.\\-]+$/.source",
+    "validation_message": "Letters, numbers, or .-_ only",
+    "language": "python"
+  },
+  {
+    "name": "npm_token",
+    "secret_name": "NPM_TOKEN",
+    "validation_regex": "/^[\\w.\\-]+$/.source",
+    "validation_message": "Letters, numbers, or .-_ only",
+    "language": "typescript"
+  },
+  {
+    "name": "packagist_username",
+    "validation_regex": "/^[\\w.\\-]+$/.source",
+    "validation_message": "Letters, numbers, or .-_ only",
+    "language": "php"
+  },
+  {
+    "name": "packagist_token",
+    "validation_regex": "/^[\\w.\\-]+$/.source",
+    "validation_message": "Letters, numbers, or .-_ only",
+    "language": "php"
+  },
+  {
+    "name": "openapi_doc_auth_token",
+    "secret_name": "SPEC_TOKEN",
+    "validation_regex": "/^[\\w.\\-]+$/.source",
+    "validation_message": "Letters, numbers, or .-_ only"
+  },
+  {
+    "name": "speakeasy_api_key",
+    "secret_name": "SPEAKEASY_API_KEY",
+    "validation_regex": "/^[\\w.\\-]+$/.source",
+    "validation_message": "Letters, numbers, or .-_ only"
+  },
+  {
+    "name": "ossrh_username",
+    "secret_name": "MAVEN_USERNAME",
+    "validation_regex": "/^[\\w.\\-]+$/.source",
+    "validation_message": "Letters, numbers, or .-_ only",
+    "language": "java"
+  },
+  {
+    "name": "ossrh_password",
+    "secret_name": "MAVEN_PASSWORD",
+    "language": "java"
+  },
+  {
+    "name": "java_gpg_secret_key",
+    "validation_regex": "/^[\\w.\\-\\t \\r\\n]+$/.source",
+    "validation_message": "Letters, numbers, tabs, spaces, newlines, or .-_ only",
+    "language": "java"
+  },
+  {
+    "name": "java_gpg_passphrase",
+    "language": "java"
+  },
+  {
+    "name": "terraform_gpg_secret_key",
+    "secret_name": "TERRAFORM_GPG_SECRET_KEY",
+    "validation_regex": "/^[\\w.\\-\\t \\r\\n]+$/.source",
+    "validation_message": "Letters, numbers, tabs, spaces, newlines, or .-_ only",
+    "language": "terraform"
+  },
+  {
+    "name": "terraform_gpg_passphrase",
+    "secret_name": "TERRAFORM_GPG_PASSPHRASE",
+    "language": "terraform"
+  },
+  {
+    "name": "rubygems_auth_token",
+    "secret_name": "RUBYGEMS_AUTH_TOKEN",
+    "language": "ruby"
+  },
+  {
+    "name": "nuget_api_key",
+    "secret_name": "NUGET_API_KEY",
+    "language": "csharp"
+  },
+  {
+    "name": "slack_webhook_url",
+    "secret_name": "SLACK_WEBHOOK_URL"
+  }
+]

package/esm/funcs/call-model.d.ts

@@ -1,8 +1,9 @@
-import type { OpenRouterCore } from "../core.js";
-import type { RequestOptions } from "../lib/sdks.js";
-import type { Tool, MaxToolRounds } from "../lib/tool-types.js";
-import type * as models from "../models/index.js";
-import { ModelResult } from "../lib/model-result.js";
+import type { OpenRouterCore } from '../core.js';
+import type { CallModelInput } from '../lib/async-params.js';
+import type { RequestOptions } from '../lib/sdks.js';
+import type { Tool } from '../lib/tool-types.js';
+import { ModelResult } from '../lib/model-result.js';
+export type { CallModelInput } from '../lib/async-params.js';
 /**
  * Get a response with multiple consumption patterns
  *
@@ -25,9 +26,93 @@ import { ModelResult } from "../lib/model-result.js";
  * For message format conversion, use the helper functions:
  * - `fromChatMessages()` / `toChatMessage()` for OpenAI chat format
  * - `fromClaudeMessages()` / `toClaudeMessage()` for Anthropic Claude format
+ *
+ * **Async Function Support:**
+ *
+ * Any field in CallModelInput can be a function that computes the value dynamically
+ * based on the conversation context. You can mix static values and functions in the
+ * same request. Functions are resolved before EVERY turn, allowing parameters to
+ * adapt as the conversation progresses.
+ *
+ * @example
+ * ```typescript
+ * // Mix static and dynamic values
+ * const result = callModel(client, {
+ *   model: 'gpt-4',  // static
+ *   temperature: (ctx) => Math.min(ctx.numberOfTurns * 0.2, 1.0),  // dynamic
+ *   input: [{ type: 'text', text: 'Hello' }],  // static
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Switch models based on conversation length
+ * const result = callModel(client, {
+ *   model: (ctx) => ctx.numberOfTurns > 3 ? 'gpt-4' : 'gpt-3.5-turbo',
+ *   input: [{ type: 'text', text: 'Complex question' }],
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Use async functions to fetch dynamic values
+ * const result = callModel(client, {
+ *   model: 'gpt-4',
+ *   instructions: async (ctx) => {
+ *     const userPrefs = await fetchUserPreferences();
+ *     return `You are a helpful assistant. User preferences: ${userPrefs}`;
+ *   },
+ *   input: [{ type: 'text', text: 'Help me' }],
+ * });
+ * ```
+ *
+ * Async functions receive `TurnContext` with:
+ * - `numberOfTurns`: Current turn number (0-indexed, 0 = initial request)
+ * - `messageHistory`: Current conversation messages
+ * - `model`: Current model selection (if set)
+ * - `models`: Current models array (if set)
+ *
+ * **Execution Order:**
+ * Functions are resolved at the START of each turn in this order:
+ * 1. Async functions (parallel resolution)
+ * 2. Tool execution (if tools called by model)
+ * 3. nextTurnParams functions (if defined on tools)
+ * 4. API request with resolved values
+ *
+ * **Stop Conditions:**
+ *
+ * Control when tool execution stops using the `stopWhen` parameter:
+ *
+ * @example
+ * ```typescript
+ * // Stop after 3 steps
+ * stopWhen: stepCountIs(3)
+ *
+ * // Stop when a specific tool is called
+ * stopWhen: hasToolCall('finalizeResults')
+ *
+ * // Multiple conditions (OR logic - stops if ANY is true)
+ * stopWhen: [
+ *   stepCountIs(10),        // Safety: max 10 steps
+ *   maxCost(0.50),          // Budget: max $0.50
+ *   hasToolCall('finalize') // Logic: stop when finalize called
+ * ]
+ *
+ * // Custom condition with full step history
+ * stopWhen: ({ steps }) => {
+ *   const totalCalls = steps.reduce((sum, s) => sum + s.toolCalls.length, 0);
+ *   return totalCalls >= 20; // Stop after 20 total tool calls
+ * }
+ * ```
+ *
+ * Available helper functions:
+ * - `stepCountIs(n)` - Stop after n steps
+ * - `hasToolCall(name)` - Stop when tool is called
+ * - `maxTokensUsed(n)` - Stop when token usage exceeds n
+ * - `maxCost(n)` - Stop when cost exceeds n dollars
+ * - `finishReasonIs(reason)` - Stop on specific finish reason
+ *
+ * Default: `stepCountIs(5)` if not specified
  */
-export declare function callModel(client: OpenRouterCore, request: Omit<models.OpenResponsesRequest, "stream" | "tools"> & {
-    tools?: Tool[];
-    maxToolRounds?: MaxToolRounds;
-}, options?: RequestOptions): ModelResult;
+export declare function callModel<TTools extends readonly Tool[]>(client: OpenRouterCore, request: CallModelInput<TTools>, options?: RequestOptions): ModelResult<TTools>;
 //# sourceMappingURL=call-model.d.ts.map

package/esm/funcs/call-model.js

@@ -1,103 +1,5 @@
-import { ModelResult } from "../lib/model-result.js";
-import { convertToolsToAPIFormat } from "../lib/tool-executor.js";
-/**
- * Checks if a message looks like a Claude-style message
- */
-function isClaudeStyleMessage(msg) {
-    if (!msg || typeof msg !== 'object')
-        return false;
-    // Check if it has a role field that's user or assistant
-    const role = msg.role;
-    if (role !== 'user' && role !== 'assistant')
-        return false;
-    // Check if content is an array with Claude-style content blocks
-    if (Array.isArray(msg.content)) {
-        return msg.content.some((block) => block &&
-            typeof block === 'object' &&
-            block.type &&
-            // Claude content block types (not OpenRouter types)
-            (block.type === 'text' || block.type === 'image' || block.type === 'tool_use' || block.type === 'tool_result'));
-    }
-    return false;
-}
-/**
- * Converts Claude-style content blocks to OpenRouter format
- */
-function convertClaudeContentBlock(block) {
-    if (!block || typeof block !== 'object' || !('type' in block)) {
-        return null;
-    }
-    switch (block.type) {
-        case 'text': {
-            const textBlock = block;
-            return {
-                type: 'input_text',
-                text: textBlock.text,
-            };
-        }
-        case 'image': {
-            const imageBlock = block;
-            if (imageBlock.source.type === 'url') {
-                return {
-                    type: 'input_image',
-                    detail: 'auto',
-                    imageUrl: imageBlock.source.url,
-                };
-            }
-            else if (imageBlock.source.type === 'base64') {
-                const dataUri = `data:${imageBlock.source.media_type};base64,${imageBlock.source.data}`;
-                return {
-                    type: 'input_image',
-                    detail: 'auto',
-                    imageUrl: dataUri,
-                };
-            }
-            return null;
-        }
-        case 'tool_use':
-        case 'tool_result':
-            // tool_use and tool_result are not handled here as they map to different input types
-            return null;
-        default:
-            return null;
-    }
-}
-/**
- * Converts a Claude-style message to OpenRouter EasyInputMessage format
- */
-function convertClaudeMessage(msg) {
-    const { role, content } = msg;
-    if (typeof content === 'string') {
-        return {
-            role: role === 'user' ? 'user' : 'assistant',
-            content,
-        };
-    }
-    // Convert array of content blocks
-    const convertedBlocks = [];
-    for (const block of content) {
-        const converted = convertClaudeContentBlock(block);
-        if (converted) {
-            convertedBlocks.push(converted);
-        }
-    }
-    // If all blocks were text, concatenate them into a string
-    const allText = convertedBlocks.every(b => b.type === 'input_text');
-    if (allText) {
-        const text = convertedBlocks
-            .map(b => b.text)
-            .join('');
-        return {
-            role: role === 'user' ? 'user' : 'assistant',
-            content: text,
-        };
-    }
-    // Otherwise, return as array
-    return {
-        role: role === 'user' ? 'user' : 'assistant',
-        content: convertedBlocks,
-    };
-}
+import { ModelResult } from '../lib/model-result.js';
+import { convertToolsToAPIFormat } from '../lib/tool-executor.js';
 /**
  * Get a response with multiple consumption patterns
  *
@@ -120,36 +22,116 @@ function convertClaudeMessage(msg) {
  * For message format conversion, use the helper functions:
  * - `fromChatMessages()` / `toChatMessage()` for OpenAI chat format
  * - `fromClaudeMessages()` / `toClaudeMessage()` for Anthropic Claude format
+ *
+ * **Async Function Support:**
+ *
+ * Any field in CallModelInput can be a function that computes the value dynamically
+ * based on the conversation context. You can mix static values and functions in the
+ * same request. Functions are resolved before EVERY turn, allowing parameters to
+ * adapt as the conversation progresses.
+ *
+ * @example
+ * ```typescript
+ * // Mix static and dynamic values
+ * const result = callModel(client, {
+ *   model: 'gpt-4',  // static
+ *   temperature: (ctx) => Math.min(ctx.numberOfTurns * 0.2, 1.0),  // dynamic
+ *   input: [{ type: 'text', text: 'Hello' }],  // static
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Switch models based on conversation length
+ * const result = callModel(client, {
+ *   model: (ctx) => ctx.numberOfTurns > 3 ? 'gpt-4' : 'gpt-3.5-turbo',
+ *   input: [{ type: 'text', text: 'Complex question' }],
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Use async functions to fetch dynamic values
+ * const result = callModel(client, {
+ *   model: 'gpt-4',
+ *   instructions: async (ctx) => {
+ *     const userPrefs = await fetchUserPreferences();
+ *     return `You are a helpful assistant. User preferences: ${userPrefs}`;
+ *   },
+ *   input: [{ type: 'text', text: 'Help me' }],
+ * });
+ * ```
+ *
+ * Async functions receive `TurnContext` with:
+ * - `numberOfTurns`: Current turn number (0-indexed, 0 = initial request)
+ * - `messageHistory`: Current conversation messages
+ * - `model`: Current model selection (if set)
+ * - `models`: Current models array (if set)
+ *
+ * **Execution Order:**
+ * Functions are resolved at the START of each turn in this order:
+ * 1. Async functions (parallel resolution)
+ * 2. Tool execution (if tools called by model)
+ * 3. nextTurnParams functions (if defined on tools)
+ * 4. API request with resolved values
+ *
+ * **Stop Conditions:**
+ *
+ * Control when tool execution stops using the `stopWhen` parameter:
+ *
+ * @example
+ * ```typescript
+ * // Stop after 3 steps
+ * stopWhen: stepCountIs(3)
+ *
+ * // Stop when a specific tool is called
+ * stopWhen: hasToolCall('finalizeResults')
+ *
+ * // Multiple conditions (OR logic - stops if ANY is true)
+ * stopWhen: [
+ *   stepCountIs(10),        // Safety: max 10 steps
+ *   maxCost(0.50),          // Budget: max $0.50
+ *   hasToolCall('finalize') // Logic: stop when finalize called
+ * ]
+ *
+ * // Custom condition with full step history
+ * stopWhen: ({ steps }) => {
+ *   const totalCalls = steps.reduce((sum, s) => sum + s.toolCalls.length, 0);
+ *   return totalCalls >= 20; // Stop after 20 total tool calls
+ * }
+ * ```
+ *
+ * Available helper functions:
+ * - `stepCountIs(n)` - Stop after n steps
+ * - `hasToolCall(name)` - Stop when tool is called
+ * - `maxTokensUsed(n)` - Stop when token usage exceeds n
+ * - `maxCost(n)` - Stop when cost exceeds n dollars
+ * - `finishReasonIs(reason)` - Stop on specific finish reason
+ *
+ * Default: `stepCountIs(5)` if not specified
  */
 export function callModel(client, request, options) {
-    const { tools, maxToolRounds, ...apiRequest } = request;
-    // Auto-convert Claude-style messages if detected
-    let processedInput = apiRequest.input;
-    if (Array.isArray(apiRequest.input)) {
-        const hasClaudeMessages = apiRequest.input.some(isClaudeStyleMessage);
-        if (hasClaudeMessages) {
-            processedInput = apiRequest.input.map((msg) => {
-                if (isClaudeStyleMessage(msg)) {
-                    return convertClaudeMessage(msg);
-                }
-                return msg;
-            });
-        }
-    }
-    // Convert tools to API format and extract enhanced tools if present
+    const { tools, stopWhen, ...apiRequest } = request;
+    // Convert tools to API format - no cast needed now that convertToolsToAPIFormat accepts readonly
     const apiTools = tools ? convertToolsToAPIFormat(tools) : undefined;
-    // Build the request with converted tools and input
+    // Build the request with converted tools
+    // Note: async functions are resolved later in ModelResult.executeToolsIfNeeded()
+    // The request can have async fields (functions) or sync fields, and the tools are converted to API format
     const finalRequest = {
         ...apiRequest,
-        ...(processedInput !== undefined && { input: processedInput }),
-        ...(apiTools !== undefined && { tools: apiTools }),
     };
+    if (apiTools !== undefined) {
+        finalRequest['tools'] = apiTools;
+    }
     return new ModelResult({
         client,
         request: finalRequest,
         options: options ?? {},
-        tools: tools ?? [],
-        ...(maxToolRounds !== undefined && { maxToolRounds }),
+        // Preserve the exact TTools type instead of widening to Tool[]
+        tools: tools,
+        ...(stopWhen !== undefined && {
+            stopWhen,
+        }),
     });
 }
 //# sourceMappingURL=call-model.js.map

package/esm/index.d.ts

@@ -1,9 +1,21 @@
-export * from "./lib/config.js";
-export * as files from "./lib/files.js";
-export { HTTPClient } from "./lib/http.js";
-export type { Fetcher, HTTPClientOptions } from "./lib/http.js";
-export * from "./sdk/sdk.js";
-export { fromClaudeMessages, toClaudeMessage } from "./lib/anthropic-compat.js";
-export { fromChatMessages, toChatMessage } from "./lib/chat-compat.js";
-export { extractUnsupportedContent, hasUnsupportedContent, getUnsupportedContentSummary } from "./lib/stream-transformers.js";
+export type { CallModelInput, FieldOrAsyncFunction, ResolvedCallModelInput, } from './lib/async-params.js';
+export type { Fetcher, HTTPClientOptions } from './lib/http.js';
+export type { ChatStreamEvent, ResponseStreamEvent as EnhancedResponseStreamEvent, InferToolEvent, InferToolEventsUnion, InferToolInput, InferToolOutput, ManualTool, NextTurnParamsContext, NextTurnParamsFunctions, ParsedToolCall, StepResult, StopCondition, StopWhen, Tool, ToolExecutionResult, ToolExecutionResultUnion, ToolPreliminaryResultEvent, ToolStreamEvent, ToolWithExecute, ToolWithGenerator, TurnContext, TypedToolCall, TypedToolCallUnion, Warning, } from './lib/tool-types.js';
+export type { BuildTurnContextOptions } from './lib/turn-context.js';
+export type { ClaudeBase64ImageSource, ClaudeCacheControl, ClaudeCitationCharLocation, ClaudeCitationContentBlockLocation, ClaudeCitationPageLocation, ClaudeCitationSearchResultLocation, ClaudeCitationWebSearchResultLocation, ClaudeContentBlock, ClaudeContentBlockParam, ClaudeImageBlockParam, ClaudeMessage, ClaudeMessageParam, ClaudeRedactedThinkingBlock, ClaudeServerToolUseBlock, ClaudeStopReason, ClaudeTextBlock, ClaudeTextBlockParam, ClaudeTextCitation, ClaudeThinkingBlock, ClaudeToolResultBlockParam, ClaudeToolUseBlock, ClaudeToolUseBlockParam, ClaudeURLImageSource, ClaudeUsage, } from './models/claude-message.js';
+export { fromClaudeMessages, toClaudeMessage } from './lib/anthropic-compat.js';
+export { hasAsyncFunctions, resolveAsyncFunctions, } from './lib/async-params.js';
+export { fromChatMessages, toChatMessage } from './lib/chat-compat.js';
+export { ClaudeContentBlockType, NonClaudeMessageRole } from './lib/claude-constants.js';
+export { isClaudeStyleMessages } from './lib/claude-type-guards.js';
+export * from './lib/config.js';
+export * as files from './lib/files.js';
+export { HTTPClient } from './lib/http.js';
+export { applyNextTurnParamsToRequest, buildNextTurnParamsContext, executeNextTurnParamsFunctions, } from './lib/next-turn-params.js';
+export { finishReasonIs, hasToolCall, isStopConditionMet, maxCost, maxTokensUsed, stepCountIs, } from './lib/stop-conditions.js';
+export { extractUnsupportedContent, getUnsupportedContentSummary, hasUnsupportedContent, } from './lib/stream-transformers.js';
+export { tool } from './lib/tool.js';
+export { hasExecuteFunction, isGeneratorTool, isRegularExecuteTool, isToolPreliminaryResultEvent, ToolType, } from './lib/tool-types.js';
+export { buildTurnContext, normalizeInputToArray } from './lib/turn-context.js';
+export * from './sdk/sdk.js';
 //# sourceMappingURL=index.d.ts.map

package/esm/index.js

@@ -1,12 +1,25 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
-export * from "./lib/config.js";
-export * as files from "./lib/files.js";
-export { HTTPClient } from "./lib/http.js";
-export * from "./sdk/sdk.js";
 // Message format compatibility helpers
-export { fromClaudeMessages, toClaudeMessage } from "./lib/anthropic-compat.js";
-export { fromChatMessages, toChatMessage } from "./lib/chat-compat.js";
-export { extractUnsupportedContent, hasUnsupportedContent, getUnsupportedContentSummary } from "./lib/stream-transformers.js";
+export { fromClaudeMessages, toClaudeMessage } from './lib/anthropic-compat.js';
+export { hasAsyncFunctions, resolveAsyncFunctions, } from './lib/async-params.js';
+export { fromChatMessages, toChatMessage } from './lib/chat-compat.js';
+// Claude constants and type guards
+export { ClaudeContentBlockType, NonClaudeMessageRole } from './lib/claude-constants.js';
+export { isClaudeStyleMessages } from './lib/claude-type-guards.js';
+export * from './lib/config.js';
+export * as files from './lib/files.js';
+export { HTTPClient } from './lib/http.js';
+// Next turn params helpers
+export { applyNextTurnParamsToRequest, buildNextTurnParamsContext, executeNextTurnParamsFunctions, } from './lib/next-turn-params.js';
+// Stop condition helpers
+export { finishReasonIs, hasToolCall, isStopConditionMet, maxCost, maxTokensUsed, stepCountIs, } from './lib/stop-conditions.js';
+export { extractUnsupportedContent, getUnsupportedContentSummary, hasUnsupportedContent, } from './lib/stream-transformers.js';
+// Tool creation helpers
+export { tool } from './lib/tool.js';
+export { hasExecuteFunction, isGeneratorTool, isRegularExecuteTool, isToolPreliminaryResultEvent, ToolType, } from './lib/tool-types.js';
+// Turn context helpers
+export { buildTurnContext, normalizeInputToArray } from './lib/turn-context.js';
+export * from './sdk/sdk.js';
 //# sourceMappingURL=index.js.map

package/esm/lib/anthropic-compat.d.ts

@@ -1,11 +1,15 @@
-import type * as models from "../models/index.js";
-import { convertToClaudeMessage } from "./stream-transformers.js";
+import type * as models from '../models/index.js';
+import { convertToClaudeMessage } from './stream-transformers.js';
 /**
  * Convert Anthropic Claude-style messages to OpenResponses input format.
  *
  * This function transforms ClaudeMessageParam[] (Anthropic SDK format) to
  * OpenResponsesInput format that can be passed directly to callModel().
  *
+ * Note: Some Claude features are lost in conversion as OpenRouter doesn't support them:
+ * - cache_control on content blocks
+ * - is_error flag on tool_result blocks
+ *
  * @example
  * ```typescript
  * import { fromClaudeMessages } from '@openrouter/sdk';