@openrouter/sdk 0.3.7 → 0.3.11

package/esm/lib/anthropic-compat.js

@@ -1,12 +1,12 @@
-import { OpenResponsesEasyInputMessageRoleUser, OpenResponsesEasyInputMessageRoleAssistant, } from "../models/openresponseseasyinputmessage.js";
-import { OpenResponsesInputMessageItemRoleUser, OpenResponsesInputMessageItemRoleSystem, } from "../models/openresponsesinputmessageitem.js";
-import { OpenResponsesFunctionCallOutputType } from "../models/openresponsesfunctioncalloutput.js";
-import { convertToClaudeMessage } from "./stream-transformers.js";
+import { OpenResponsesEasyInputMessageRoleAssistant, OpenResponsesEasyInputMessageRoleUser, } from '../models/openresponseseasyinputmessage.js';
+import { OpenResponsesFunctionCallOutputType } from '../models/openresponsesfunctioncalloutput.js';
+import { OpenResponsesInputMessageItemRoleUser, OpenResponsesInputMessageItemRoleDeveloper } from '../models/openresponsesinputmessageitem.js';
+import { convertToClaudeMessage } from './stream-transformers.js';
 /**
  * Maps Claude role strings to OpenResponses role types
  */
 function mapClaudeRole(role) {
-    if (role === "user") {
+    if (role === 'user') {
         return OpenResponsesEasyInputMessageRoleUser.User;
     }
     return OpenResponsesEasyInputMessageRoleAssistant.Assistant;
@@ -36,6 +36,10 @@ function createFunctionCallOutput(callId, output) {
  * 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';
@@ -55,124 +59,139 @@ export function fromClaudeMessages(messages) {
     const result = [];
     for (const msg of messages) {
         const { role, content } = msg;
-        if (typeof content === "string") {
+        if (typeof content === 'string') {
             result.push(createEasyInputMessage(role, content));
             continue;
         }
-        const contentItems = [];
-        let hasStructuredContent = false;
+        // Separate content blocks into categories for clearer processing
+        const textBlocks = [];
+        const imageBlocks = [];
+        const toolUseBlocks = [];
+        const toolResultBlocks = [];
         for (const block of content) {
             switch (block.type) {
-                case 'text': {
-                    const textBlock = block;
-                    contentItems.push({
-                        type: 'input_text',
-                        text: textBlock.text,
-                    });
-                    // Note: cache_control is lost in conversion (OpenRouter doesn't support it)
+                case 'text':
+                    textBlocks.push(block);
+                    break;
+                case 'image':
+                    imageBlocks.push(block);
+                    break;
+                case 'tool_use':
+                    toolUseBlocks.push(block);
                     break;
+                case 'tool_result':
+                    toolResultBlocks.push(block);
+                    break;
+                default: {
+                    // Exhaustiveness check - TypeScript will error if we don't handle all block types
+                    const exhaustiveCheck = block;
+                    throw new Error(`Unhandled content block type: ${JSON.stringify(exhaustiveCheck)}`);
                 }
-                case 'image': {
-                    const imageBlock = block;
-                    hasStructuredContent = true;
-                    // Convert Claude image source to OpenRouter format
-                    if (imageBlock.source.type === 'url') {
-                        contentItems.push({
-                            type: 'input_image',
-                            detail: 'auto',
-                            imageUrl: imageBlock.source.url,
-                        });
+            }
+        }
+        // Process tool use blocks first (they go directly to result)
+        for (const toolUseBlock of toolUseBlocks) {
+            result.push({
+                type: 'function_call',
+                callId: toolUseBlock.id,
+                name: toolUseBlock.name,
+                arguments: JSON.stringify(toolUseBlock.input),
+                id: toolUseBlock.id,
+                status: 'completed',
+            });
+        }
+        // Process tool result blocks
+        for (const toolResultBlock of toolResultBlocks) {
+            let toolOutput = '';
+            if (typeof toolResultBlock.content === 'string') {
+                toolOutput = toolResultBlock.content;
+            }
+            else {
+                // Extract text and handle images separately
+                const textParts = [];
+                const imageParts = [];
+                for (const part of toolResultBlock.content) {
+                    if (part.type === 'text') {
+                        textParts.push(part.text);
                     }
-                    else if (imageBlock.source.type === 'base64') {
-                        // Base64 images: OpenRouter expects a URL, so we use data URI
-                        const dataUri = `data:${imageBlock.source.media_type};base64,${imageBlock.source.data}`;
-                        contentItems.push({
-                            type: 'input_image',
-                            detail: 'auto',
-                            imageUrl: dataUri,
-                        });
+                    else if (part.type === 'image') {
+                        imageParts.push(part);
                     }
-                    break;
-                }
-                case 'tool_use': {
-                    const toolUseBlock = block;
-                    // Map to OpenResponsesFunctionToolCall
-                    result.push({
-                        type: 'function_call',
-                        callId: toolUseBlock.id,
-                        name: toolUseBlock.name,
-                        arguments: JSON.stringify(toolUseBlock.input),
-                        id: toolUseBlock.id,
-                        status: 'completed', // Tool use in conversation history is already completed
-                    });
-                    break;
                 }
-                case 'tool_result': {
-                    const toolResultBlock = block;
-                    let toolOutput = '';
-                    if (typeof toolResultBlock.content === 'string') {
-                        toolOutput = toolResultBlock.content;
+                toolOutput = textParts.join('');
+                // Map images to image_generation_call items
+                imageParts.forEach((imagePart, i) => {
+                    let imageUrl;
+                    if (imagePart.source.type === 'url') {
+                        imageUrl = imagePart.source.url;
                     }
-                    else {
-                        // Extract text and handle images separately
-                        const textParts = [];
-                        const imageParts = [];
-                        for (const part of toolResultBlock.content) {
-                            if (part.type === 'text') {
-                                textParts.push(part.text);
-                            }
-                            else if (part.type === 'image') {
-                                imageParts.push(part);
-                            }
-                        }
-                        toolOutput = textParts.join('');
-                        // Map images to image_generation_call items
-                        for (const imagePart of imageParts) {
-                            const imageUrl = imagePart.source.type === 'url'
-                                ? imagePart.source.url
-                                : `data:${imagePart.source.media_type};base64,${imagePart.source.data}`;
-                            result.push({
-                                type: 'image_generation_call',
-                                id: `${toolResultBlock.tool_use_id}-image-${imageParts.indexOf(imagePart)}`,
-                                result: imageUrl,
-                                status: 'completed',
-                            });
-                        }
+                    else if (imagePart.source.type === 'base64') {
+                        imageUrl = `data:${imagePart.source.media_type};base64,${imagePart.source.data}`;
                     }
-                    // Add the function call output for the text portion
-                    if (toolOutput || typeof toolResultBlock.content === 'string') {
-                        result.push(createFunctionCallOutput(toolResultBlock.tool_use_id, toolOutput));
+                    else {
+                        const exhaustiveCheck = imagePart.source;
+                        throw new Error(`Unhandled image source type: ${exhaustiveCheck}`);
                     }
-                    break;
+                    result.push({
+                        type: 'image_generation_call',
+                        id: `${toolResultBlock.tool_use_id}-image-${i}`,
+                        result: imageUrl,
+                        status: 'completed',
+                    });
+                });
+            }
+            // Add the function call output for the text portion (if any)
+            if (toolOutput.length > 0) {
+                result.push(createFunctionCallOutput(toolResultBlock.tool_use_id, toolOutput));
+            }
+        }
+        // Process text and image blocks (these become message content)
+        if (textBlocks.length > 0 || imageBlocks.length > 0) {
+            const contentItems = [];
+            // Add text blocks
+            for (const textBlock of textBlocks) {
+                contentItems.push({
+                    type: 'input_text',
+                    text: textBlock.text,
+                });
+            }
+            // Add image blocks
+            for (const imageBlock of imageBlocks) {
+                let imageUrl;
+                if (imageBlock.source.type === 'url') {
+                    imageUrl = imageBlock.source.url;
                 }
-                default: {
-                    const _exhaustiveCheck = block;
-                    throw new Error(`Unhandled content block type: ${_exhaustiveCheck.type}`);
+                else if (imageBlock.source.type === 'base64') {
+                    imageUrl = `data:${imageBlock.source.media_type};base64,${imageBlock.source.data}`;
                 }
+                else {
+                    const exhaustiveCheck = imageBlock.source;
+                    throw new Error(`Unhandled image source type: ${exhaustiveCheck}`);
+                }
+                contentItems.push({
+                    type: 'input_image',
+                    detail: 'auto',
+                    imageUrl,
+                });
             }
-        }
-        // Use structured format if we have images, otherwise use simple format
-        if (contentItems.length > 0) {
-            if (hasStructuredContent) {
-                // Use OpenResponsesInputMessageItem for messages with images
-                const messageRole = role === 'user'
-                    ? OpenResponsesInputMessageItemRoleUser.User
-                    : role === 'assistant'
-                        ? OpenResponsesInputMessageItemRoleSystem.System // Assistant messages treated as system in this context
-                        : OpenResponsesInputMessageItemRoleSystem.System;
+            // Determine output format based on content
+            if (imageBlocks.length > 0) {
+                // Use structured format for messages with images
                 result.push({
                     type: 'message',
-                    role: messageRole,
+                    role: role === 'user'
+                        ? OpenResponsesInputMessageItemRoleUser.User
+                        : OpenResponsesInputMessageItemRoleDeveloper.Developer,
                     content: contentItems,
                 });
             }
             else {
-                // Use simple format for text-only messages
+                // Use simple string format for text-only messages
                 const textContent = contentItems
                     .filter((item) => item.type === 'input_text')
-                    .map(item => item.text)
+                    .map((item) => item.text)
                     .join('');
-                if (textContent) {
+                if (textContent.length > 0) {
                     result.push(createEasyInputMessage(role, textContent));
                 }
             }

package/esm/lib/async-params.d.ts

@@ -0,0 +1,53 @@
+import type * as models from '../models/index.js';
+import type { StopWhen, Tool, TurnContext } from './tool-types.js';
+/**
+ * A field can be either a value of type T or a function that computes T
+ */
+export type FieldOrAsyncFunction<T> = T | ((context: TurnContext) => T | Promise<T>);
+/**
+ * Input type for callModel function
+ * Each field can independently be a static value or a function that computes the value
+ * Generic over TTools to enable proper type inference for stopWhen conditions
+ */
+export type CallModelInput<TTools extends readonly Tool[] = readonly Tool[]> = {
+    [K in keyof Omit<models.OpenResponsesRequest, 'stream' | 'tools'>]?: FieldOrAsyncFunction<models.OpenResponsesRequest[K]>;
+} & {
+    tools?: TTools;
+    stopWhen?: StopWhen<TTools>;
+};
+/**
+ * Resolved CallModelInput (all functions evaluated to values)
+ * This is the type after all async functions have been resolved to their values
+ */
+export type ResolvedCallModelInput = Omit<models.OpenResponsesRequest, 'stream' | 'tools'> & {
+    tools?: never;
+};
+/**
+ * Resolve all async functions in CallModelInput to their values
+ *
+ * @param input - Input with possible functions
+ * @param context - Turn context for function execution
+ * @returns Resolved input with all values (no functions)
+ *
+ * @example
+ * ```typescript
+ * const resolved = await resolveAsyncFunctions(
+ *   {
+ *     model: 'gpt-4',
+ *     temperature: (ctx) => ctx.numberOfTurns * 0.1,
+ *     input: 'Hello',
+ *   },
+ *   { numberOfTurns: 2, messageHistory: [] }
+ * );
+ * // resolved.temperature === 0.2
+ * ```
+ */
+export declare function resolveAsyncFunctions(input: CallModelInput, context: TurnContext): Promise<ResolvedCallModelInput>;
+/**
+ * Check if input has any async functions that need resolution
+ *
+ * @param input - Input to check
+ * @returns True if any field is a function
+ */
+export declare function hasAsyncFunctions(input: unknown): boolean;
+//# sourceMappingURL=async-params.d.ts.map

package/esm/lib/async-params.js

@@ -0,0 +1,76 @@
+/**
+ * Type guard to check if a value is a parameter function
+ * Parameter functions take TurnContext and return a value or promise
+ */
+function isParameterFunction(value) {
+    return typeof value === 'function';
+}
+/**
+ * Build a resolved request object from entries
+ * This validates the structure matches the expected ResolvedCallModelInput shape
+ */
+function buildResolvedRequest(entries) {
+    const obj = Object.fromEntries(entries);
+    return obj;
+}
+/**
+ * Resolve all async functions in CallModelInput to their values
+ *
+ * @param input - Input with possible functions
+ * @param context - Turn context for function execution
+ * @returns Resolved input with all values (no functions)
+ *
+ * @example
+ * ```typescript
+ * const resolved = await resolveAsyncFunctions(
+ *   {
+ *     model: 'gpt-4',
+ *     temperature: (ctx) => ctx.numberOfTurns * 0.1,
+ *     input: 'Hello',
+ *   },
+ *   { numberOfTurns: 2, messageHistory: [] }
+ * );
+ * // resolved.temperature === 0.2
+ * ```
+ */
+export async function resolveAsyncFunctions(input, context) {
+    // Build array of resolved entries
+    const resolvedEntries = [];
+    // Iterate over all keys in the input
+    for (const [key, value] of Object.entries(input)) {
+        // Skip stopWhen - it's handled separately in ModelResult
+        // Note: tools are already in API format at this point (converted in callModel()), so we include them
+        if (key === 'stopWhen') {
+            continue;
+        }
+        if (isParameterFunction(value)) {
+            try {
+                // Execute the function with context and store the result
+                const result = await Promise.resolve(value(context));
+                resolvedEntries.push([key, result]);
+            }
+            catch (error) {
+                // Wrap errors with context about which field failed
+                throw new Error(`Failed to resolve async function for field "${key}": ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        else {
+            // Not a function, use as-is
+            resolvedEntries.push([key, value]);
+        }
+    }
+    return buildResolvedRequest(resolvedEntries);
+}
+/**
+ * Check if input has any async functions that need resolution
+ *
+ * @param input - Input to check
+ * @returns True if any field is a function
+ */
+export function hasAsyncFunctions(input) {
+    if (!input || typeof input !== 'object') {
+        return false;
+    }
+    return Object.values(input).some((value) => typeof value === 'function');
+}
+//# sourceMappingURL=async-params.js.map

package/esm/lib/chat-compat.js

@@ -26,6 +26,10 @@ function mapChatRole(role) {
             return OpenResponsesEasyInputMessageRoleAssistant.Assistant;
         case "developer":
             return OpenResponsesEasyInputMessageRoleDeveloper.Developer;
+        default: {
+            const exhaustiveCheck = role;
+            throw new Error(`Unhandled role type: ${exhaustiveCheck}`);
+        }
     }
 }
 /**

package/esm/lib/claude-constants.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Claude-specific content block types
+ * Used for detecting Claude message format
+ */
+export declare const ClaudeContentBlockType: {
+    readonly Text: "text";
+    readonly Image: "image";
+    readonly ToolUse: "tool_use";
+    readonly ToolResult: "tool_result";
+};
+export type ClaudeContentBlockType = (typeof ClaudeContentBlockType)[keyof typeof ClaudeContentBlockType];
+/**
+ * Message roles that are NOT supported in Claude format
+ * Used for distinguishing Claude vs OpenAI format
+ */
+export declare const NonClaudeMessageRole: {
+    readonly System: "system";
+    readonly Developer: "developer";
+    readonly Tool: "tool";
+};
+export type NonClaudeMessageRole = (typeof NonClaudeMessageRole)[keyof typeof NonClaudeMessageRole];
+//# sourceMappingURL=claude-constants.d.ts.map

package/esm/lib/claude-constants.js

@@ -0,0 +1,20 @@
+/**
+ * Claude-specific content block types
+ * Used for detecting Claude message format
+ */
+export const ClaudeContentBlockType = {
+    Text: "text",
+    Image: "image",
+    ToolUse: "tool_use",
+    ToolResult: "tool_result",
+};
+/**
+ * Message roles that are NOT supported in Claude format
+ * Used for distinguishing Claude vs OpenAI format
+ */
+export const NonClaudeMessageRole = {
+    System: "system",
+    Developer: "developer",
+    Tool: "tool",
+};
+//# sourceMappingURL=claude-constants.js.map

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

@@ -0,0 +1,10 @@
+import type * as models from "../models/index.js";
+/**
+ * Check if input is in Claude message format
+ * Uses structural analysis to detect Claude-specific patterns
+ *
+ * @param input - Input to check
+ * @returns True if input appears to be Claude format
+ */
+export declare function isClaudeStyleMessages(input: unknown): input is models.ClaudeMessageParam[];
+//# sourceMappingURL=claude-type-guards.d.ts.map

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

@@ -0,0 +1,70 @@
+import { ClaudeContentBlockType, NonClaudeMessageRole, } from "./claude-constants.js";
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isNonClaudeRole(role) {
+    return (role === NonClaudeMessageRole.System ||
+        role === NonClaudeMessageRole.Developer ||
+        role === NonClaudeMessageRole.Tool);
+}
+function isClaudeToolResultBlock(block) {
+    if (!isRecord(block))
+        return false;
+    return block["type"] === ClaudeContentBlockType.ToolResult;
+}
+function isClaudeImageBlockWithSource(block) {
+    if (!isRecord(block))
+        return false;
+    return (block["type"] === ClaudeContentBlockType.Image &&
+        "source" in block &&
+        isRecord(block["source"]));
+}
+function isClaudeToolUseBlockWithId(block) {
+    if (!isRecord(block))
+        return false;
+    return (block["type"] === ClaudeContentBlockType.ToolUse &&
+        "id" in block &&
+        typeof block["id"] === "string");
+}
+function hasClaudeSpecificBlocks(content) {
+    for (const block of content) {
+        if (isClaudeToolResultBlock(block))
+            return true;
+        if (isClaudeImageBlockWithSource(block))
+            return true;
+        if (isClaudeToolUseBlockWithId(block))
+            return true;
+    }
+    return false;
+}
+/**
+ * Check if input is in Claude message format
+ * Uses structural analysis to detect Claude-specific patterns
+ *
+ * @param input - Input to check
+ * @returns True if input appears to be Claude format
+ */
+export function isClaudeStyleMessages(input) {
+    if (!Array.isArray(input) || input.length === 0) {
+        return false;
+    }
+    for (const msg of input) {
+        if (!isRecord(msg))
+            continue;
+        if (!("role" in msg))
+            continue;
+        if ("type" in msg)
+            continue; // Claude messages don't have top-level "type"
+        // If we find a non-Claude role, it's not Claude format
+        if (isNonClaudeRole(msg["role"])) {
+            return false;
+        }
+        // If we find Claude-specific content blocks, it's Claude format
+        const content = msg["content"];
+        if (Array.isArray(content) && hasClaudeSpecificBlocks(content)) {
+            return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=claude-type-guards.js.map

package/esm/lib/config.d.ts

@@ -1,3 +1,4 @@
+import { SDKHooks } from "../hooks/hooks.js";
 import { HTTPClient } from "./http.js";
 import { Logger } from "./logger.js";
 import { RetryConfig } from "./retries.js";
@@ -40,13 +41,14 @@ export type SDKOptions = {
     retryConfig?: RetryConfig;
     timeoutMs?: number;
     debugLogger?: Logger;
+    hooks?: SDKHooks;
 };
 export declare function serverURLFromOptions(options: SDKOptions): URL | null;
 export declare const SDK_METADATA: {
     readonly language: "typescript";
     readonly openapiDocVersion: "1.0.0";
-    readonly sdkVersion: "0.3.7";
+    readonly sdkVersion: "0.3.11";
     readonly genVersion: "2.788.4";
-    readonly userAgent: "speakeasy-sdk/typescript 0.3.7 2.788.4 1.0.0 @openrouter/sdk";
+    readonly userAgent: "speakeasy-sdk/typescript 0.3.11 2.788.4 1.0.0 @openrouter/sdk";
 };
 //# sourceMappingURL=config.d.ts.map

package/esm/lib/config.js

@@ -26,8 +26,8 @@ export function serverURLFromOptions(options) {
 export const SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.0.0",
-    sdkVersion: "0.3.7",
+    sdkVersion: "0.3.11",
     genVersion: "2.788.4",
-    userAgent: "speakeasy-sdk/typescript 0.3.7 2.788.4 1.0.0 @openrouter/sdk",
+    userAgent: "speakeasy-sdk/typescript 0.3.11 2.788.4 1.0.0 @openrouter/sdk",
 };
 //# sourceMappingURL=config.js.map

package/esm/lib/model-result.d.ts

@@ -1,13 +1,14 @@
-import type { OpenRouterCore } from "../core.js";
-import type * as models from "../models/index.js";
-import type { RequestOptions } from "./sdks.js";
-import type { ChatStreamEvent, EnhancedResponseStreamEvent, Tool, MaxToolRounds, ParsedToolCall, ToolStreamEvent } from "./tool-types.js";
-export interface GetResponseOptions {
-    request: models.OpenResponsesRequest;
+import type { OpenRouterCore } from '../core.js';
+import type * as models from '../models/index.js';
+import type { CallModelInput } from './async-params.js';
+import type { RequestOptions } from './sdks.js';
+import type { ResponseStreamEvent, InferToolEventsUnion, ParsedToolCall, StopWhen, Tool, ToolStreamEvent } from './tool-types.js';
+export interface GetResponseOptions<TTools extends readonly Tool[]> {
+    request: CallModelInput<TTools>;
     client: OpenRouterCore;
     options?: RequestOptions;
-    tools?: Tool[];
-    maxToolRounds?: MaxToolRounds;
+    tools?: TTools;
+    stopWhen?: StopWhen<TTools>;
 }
 /**
  * A wrapper around a streaming response that provides multiple consumption patterns.
@@ -25,8 +26,10 @@ export interface GetResponseOptions {
  *
  * All consumption patterns can be used concurrently thanks to the underlying
  * ReusableReadableStream implementation.
+ *
+ * @template TTools - The tools array type to enable typed tool calls and results
  */
-export declare class ModelResult {
+export declare class ModelResult<TTools extends readonly Tool[]> {
     private reusableStream;
     private streamPromise;
     private textPromise;
@@ -36,7 +39,8 @@ export declare class ModelResult {
     private finalResponse;
     private preliminaryResults;
     private allToolExecutionRounds;
-    constructor(options: GetResponseOptions);
+    private resolvedRequest;
+    constructor(options: GetResponseOptions<TTools>);
     /**
      * Type guard to check if a value is a non-streaming response
      */
@@ -71,7 +75,7 @@ export declare class ModelResult {
      * Multiple consumers can iterate over this stream concurrently.
      * Includes preliminary tool result events after tool execution.
      */
-    getFullResponsesStream(): AsyncIterableIterator<EnhancedResponseStreamEvent>;
+    getFullResponsesStream(): AsyncIterableIterator<ResponseStreamEvent<InferToolEventsUnion<TTools>>>;
     /**
      * Stream only text deltas as they arrive.
      * This filters the full event stream to only yield text content.
@@ -95,30 +99,19 @@ export declare class ModelResult {
      * - Tool call argument deltas as { type: "delta", content: string }
      * - Preliminary results as { type: "preliminary_result", toolCallId, result }
      */
-    getToolStream(): AsyncIterableIterator<ToolStreamEvent>;
-    /**
-     * Stream events in chat format (compatibility layer).
-     * Note: This transforms responses API events into a chat-like format.
-     * Includes preliminary tool result events after tool execution.
-     *
-     * @remarks
-     * This is a compatibility method that attempts to transform the responses API
-     * stream into a format similar to the chat API. Due to differences in the APIs,
-     * this may not be a perfect mapping.
-     */
-    getFullChatStream(): AsyncIterableIterator<ChatStreamEvent>;
+    getToolStream(): AsyncIterableIterator<ToolStreamEvent<InferToolEventsUnion<TTools>>>;
     /**
      * Get all tool calls from the completed response (before auto-execution).
      * Note: If tools have execute functions, they will be automatically executed
      * and this will return the tool calls from the initial response.
      * Returns structured tool calls with parsed arguments.
      */
-    getToolCalls(): Promise<ParsedToolCall[]>;
+    getToolCalls(): Promise<ParsedToolCall<TTools[number]>[]>;
     /**
      * Stream structured tool call objects as they're completed.
      * Each iteration yields a complete tool call with parsed arguments.
      */
-    getToolCallsStream(): AsyncIterableIterator<ParsedToolCall>;
+    getToolCallsStream(): AsyncIterableIterator<ParsedToolCall<TTools[number]>>;
     /**
      * Cancel the underlying stream and all consumers
      */