@openrouter/sdk 0.3.15 → 0.3.16

package/esm/index.d.ts

@@ -1,6 +1,6 @@
 export type { CallModelInput, CallModelInputWithState, FieldOrAsyncFunction, ResolvedCallModelInput, } from './lib/async-params.js';
 export type { Fetcher, HTTPClientOptions } from './lib/http.js';
-export type { ChatStreamEvent, ConversationState, ConversationStatus, ResponseStreamEvent as EnhancedResponseStreamEvent, HasApprovalTools, InferToolEvent, InferToolEventsUnion, InferToolInput, InferToolOutput, ManualTool, NextTurnParamsContext, NextTurnParamsFunctions, ParsedToolCall, PartialResponse, StateAccessor, StepResult, StopCondition, StopWhen, Tool, ToolApprovalCheck, ToolExecutionResult, ToolExecutionResultUnion, ToolHasApproval, ToolPreliminaryResultEvent, ToolStreamEvent, ToolWithExecute, ToolWithGenerator, TurnContext, TypedToolCall, TypedToolCallUnion, UnsentToolResult, Warning, } from './lib/tool-types.js';
+export type { ChatStreamEvent, ConversationState, ConversationStatus, ResponseStreamEvent as EnhancedResponseStreamEvent, HasApprovalTools, InferToolEvent, InferToolEventsUnion, InferToolInput, InferToolOutput, InferToolOutputsUnion, ManualTool, NextTurnParamsContext, NextTurnParamsFunctions, ParsedToolCall, PartialResponse, StateAccessor, StepResult, StopCondition, StopWhen, Tool, ToolApprovalCheck, ToolExecutionResult, ToolExecutionResultUnion, ToolHasApproval, ToolPreliminaryResultEvent, ToolResultEvent, ToolStreamEvent, ToolWithExecute, ToolWithGenerator, TurnContext, TypedToolCall, TypedToolCallUnion, UnsentToolResult, 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';
@@ -15,7 +15,7 @@ export { applyNextTurnParamsToRequest, buildNextTurnParamsContext, executeNextTu
 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 { hasApprovalRequiredTools, hasExecuteFunction, isGeneratorTool, isRegularExecuteTool, isToolPreliminaryResultEvent, toolHasApprovalConfigured, ToolType, } from './lib/tool-types.js';
+export { hasApprovalRequiredTools, hasExecuteFunction, isGeneratorTool, isRegularExecuteTool, isToolPreliminaryResultEvent, isToolResultEvent, toolHasApprovalConfigured, ToolType, } from './lib/tool-types.js';
 export { buildTurnContext, normalizeInputToArray } from './lib/turn-context.js';
 export { appendToMessages, createInitialState, createRejectedResult, createUnsentResult, generateConversationId, partitionToolCalls, toolRequiresApproval, updateState, } from './lib/conversation-state.js';
 export { ToolEventBroadcaster } from './lib/tool-event-broadcaster.js';

package/esm/index.js

@@ -18,7 +18,7 @@ export { finishReasonIs, hasToolCall, isStopConditionMet, maxCost, maxTokensUsed
 export { extractUnsupportedContent, getUnsupportedContentSummary, hasUnsupportedContent, } from './lib/stream-transformers.js';
 // Tool creation helpers
 export { tool } from './lib/tool.js';
-export { hasApprovalRequiredTools, hasExecuteFunction, isGeneratorTool, isRegularExecuteTool, isToolPreliminaryResultEvent, toolHasApprovalConfigured, ToolType, } from './lib/tool-types.js';
+export { hasApprovalRequiredTools, hasExecuteFunction, isGeneratorTool, isRegularExecuteTool, isToolPreliminaryResultEvent, isToolResultEvent, toolHasApprovalConfigured, ToolType, } from './lib/tool-types.js';
 // Turn context helpers
 export { buildTurnContext, normalizeInputToArray } from './lib/turn-context.js';
 // Conversation state helpers

package/esm/lib/config.d.ts

@@ -45,8 +45,8 @@ 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.15";
+    readonly sdkVersion: "0.3.16";
     readonly genVersion: "2.788.4";
-    readonly userAgent: "speakeasy-sdk/typescript 0.3.15 2.788.4 1.0.0 @openrouter/sdk";
+    readonly userAgent: "speakeasy-sdk/typescript 0.3.16 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.15",
+    sdkVersion: "0.3.16",
     genVersion: "2.788.4",
-    userAgent: "speakeasy-sdk/typescript 0.3.15 2.788.4 1.0.0 @openrouter/sdk",
+    userAgent: "speakeasy-sdk/typescript 0.3.16 2.788.4 1.0.0 @openrouter/sdk",
 };
 //# sourceMappingURL=config.js.map

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

@@ -2,7 +2,7 @@ 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 { ConversationState, ResponseStreamEvent, InferToolEventsUnion, ParsedToolCall, StateAccessor, StopWhen, Tool, ToolStreamEvent, TurnContext } from './tool-types.js';
+import type { ConversationState, ResponseStreamEvent, InferToolEventsUnion, InferToolOutputsUnion, ParsedToolCall, StateAccessor, StopWhen, Tool, ToolStreamEvent, TurnContext } from './tool-types.js';
 export interface GetResponseOptions<TTools extends readonly Tool[]> {
     request: CallModelInput<TTools>;
     client: OpenRouterCore;
@@ -57,6 +57,7 @@ export declare class ModelResult<TTools extends readonly Tool[]> {
     /**
      * Get or create the tool event broadcaster (lazy initialization).
      * Ensures only one broadcaster exists for the lifetime of this ModelResult.
+     * Broadcasts both preliminary results and final tool results.
      */
     private ensureBroadcaster;
     /**
@@ -139,6 +140,7 @@ export declare class ModelResult<TTools extends readonly Tool[]> {
     /**
      * Execute all tools in a single round.
      * Runs each tool call sequentially and collects results for API submission.
+     * Emits tool.result events after each tool execution completes.
      *
      * @param toolCalls - The tool calls to execute
      * @param turnContext - The current turn context
@@ -234,9 +236,9 @@ export declare class ModelResult<TTools extends readonly Tool[]> {
     /**
      * Stream all response events as they arrive.
      * Multiple consumers can iterate over this stream concurrently.
-     * Preliminary tool results are streamed in REAL-TIME as generator tools yield.
+     * Preliminary tool results and tool results are streamed in REAL-TIME as generator tools yield.
      */
-    getFullResponsesStream(): AsyncIterableIterator<ResponseStreamEvent<InferToolEventsUnion<TTools>>>;
+    getFullResponsesStream(): AsyncIterableIterator<ResponseStreamEvent<InferToolEventsUnion<TTools>, InferToolOutputsUnion<TTools>>>;
     /**
      * Stream only text deltas as they arrive.
      * This filters the full event stream to only yield text content.

package/esm/lib/model-result.js

@@ -93,6 +93,7 @@ export class ModelResult {
     /**
      * Get or create the tool event broadcaster (lazy initialization).
      * Ensures only one broadcaster exists for the lifetime of this ModelResult.
+     * Broadcasts both preliminary results and final tool results.
      */
     ensureBroadcaster() {
         if (!this.toolEventBroadcaster) {
@@ -300,6 +301,7 @@ export class ModelResult {
     /**
      * Execute all tools in a single round.
      * Runs each tool call sequentially and collects results for API submission.
+     * Emits tool.result events after each tool execution completes.
      *
      * @param toolCalls - The tool calls to execute
      * @param turnContext - The current turn context
@@ -311,17 +313,33 @@ export class ModelResult {
             const tool = this.options.tools?.find((t) => t.function.name === toolCall.name);
             if (!tool || !hasExecuteFunction(tool))
                 continue;
+            // Track preliminary results for this specific tool call
+            const preliminaryResultsForCall = [];
             // Create callback for real-time preliminary results
             const onPreliminaryResult = this.toolEventBroadcaster
                 ? (callId, resultValue) => {
+                    // Track preliminary results for the tool.result event
+                    const typedResult = resultValue;
+                    preliminaryResultsForCall.push(typedResult);
+                    // Emit preliminary result event
                     this.toolEventBroadcaster?.push({
                         type: 'preliminary_result',
                         toolCallId: callId,
-                        result: resultValue,
+                        result: typedResult,
                     });
                 }
                 : undefined;
             const result = await executeTool(tool, toolCall, turnContext, onPreliminaryResult);
+            // Emit tool.result event with final result and any preliminary results
+            if (this.toolEventBroadcaster) {
+                const toolResultEvent = {
+                    type: 'tool_result',
+                    toolCallId: toolCall.id,
+                    result: (result.error ? { error: result.error.message } : result.result),
+                    ...(preliminaryResultsForCall.length > 0 && { preliminaryResults: preliminaryResultsForCall }),
+                };
+                this.toolEventBroadcaster.push(toolResultEvent);
+            }
             toolResults.push({
                 type: 'function_call_output',
                 id: `output_${toolCall.id}`,
@@ -799,7 +817,7 @@ export class ModelResult {
     /**
      * Stream all response events as they arrive.
      * Multiple consumers can iterate over this stream concurrently.
-     * Preliminary tool results are streamed in REAL-TIME as generator tools yield.
+     * Preliminary tool results and tool results are streamed in REAL-TIME as generator tools yield.
      */
     getFullResponsesStream() {
         return async function* () {
@@ -819,14 +837,25 @@ export class ModelResult {
             for await (const event of consumer) {
                 yield event;
             }
-            // Yield tool preliminary results as they arrive (real-time!)
+            // Yield tool events as they arrive (real-time!)
             for await (const event of toolEventConsumer) {
-                yield {
-                    type: 'tool.preliminary_result',
-                    toolCallId: event.toolCallId,
-                    result: event.result,
-                    timestamp: Date.now(),
-                };
+                if (event.type === 'preliminary_result') {
+                    yield {
+                        type: 'tool.preliminary_result',
+                        toolCallId: event.toolCallId,
+                        result: event.result,
+                        timestamp: Date.now(),
+                    };
+                }
+                else if (event.type === 'tool_result') {
+                    yield {
+                        type: 'tool.result',
+                        toolCallId: event.toolCallId,
+                        result: event.result,
+                        timestamp: Date.now(),
+                        ...(event.preliminaryResults && { preliminaryResults: event.preliminaryResults }),
+                    };
+                }
             }
             // Ensure execution completed (handles errors)
             await executionPromise;
@@ -916,9 +945,11 @@ export class ModelResult {
                     content: delta,
                 };
             }
-            // Yield tool events as they arrive (real-time!)
+            // Yield only preliminary_result events (filter out tool_result events)
             for await (const event of toolEventConsumer) {
-                yield event;
+                if (event.type === 'preliminary_result') {
+                    yield event;
+                }
             }
             // Ensure execution completed (handles errors)
             await executionPromise;

package/esm/lib/tool-executor.js

@@ -87,6 +87,14 @@ export function validateToolInput(schema, args) {
 export function validateToolOutput(schema, result) {
     return z4.parse(schema, result);
 }
+/**
+ * Try to validate a value against a Zod schema without throwing
+ * @returns true if validation succeeds, false otherwise
+ */
+function tryValidate(schema, value) {
+    const result = z4.safeParse(schema, value);
+    return result.success;
+}
 /**
  * Parse tool call arguments from JSON string
  */
@@ -150,29 +158,45 @@ export async function executeGeneratorTool(tool, toolCall, context, onPreliminar
         // Validate input - the schema validation ensures type safety at runtime
         // The inputSchema's inferred type matches the execute function's parameter type by construction
         const validatedInput = validateToolInput(tool.function.inputSchema, toolCall.arguments);
-        // Execute generator and collect all results
+        // Stream preliminary results in realtime
+        // Final result is identified by: matches outputSchema BUT NOT eventSchema
+        // All other yields are preliminary results (validated against eventSchema)
+        // If no explicit final result is found, the last emitted value is used as the final result
         const preliminaryResults = [];
-        let lastEmittedValue = null;
+        let finalResult = undefined;
+        let hasFinalResult = false;
+        let lastEmittedValue = undefined;
         let hasEmittedValue = false;
         for await (const event of tool.function.execute(validatedInput, context)) {
+            lastEmittedValue = event;
             hasEmittedValue = true;
-            // Validate event against eventSchema
-            const validatedEvent = validateToolOutput(tool.function.eventSchema, event);
-            preliminaryResults.push(validatedEvent);
-            lastEmittedValue = validatedEvent;
-            // Emit preliminary result via callback
-            if (onPreliminaryResult) {
-                onPreliminaryResult(toolCall.id, validatedEvent);
+            // Try to determine if this is the final result:
+            // It must match outputSchema but NOT match eventSchema
+            const matchesOutputSchema = tryValidate(tool.function.outputSchema, event);
+            const matchesEventSchema = tryValidate(tool.function.eventSchema, event);
+            if (matchesOutputSchema && !matchesEventSchema && !hasFinalResult) {
+                // This is the final result - matches output but not event schema
+                finalResult = validateToolOutput(tool.function.outputSchema, event);
+                hasFinalResult = true;
+            }
+            else {
+                // This is a preliminary result - validate against eventSchema and emit in realtime
+                const validatedPreliminary = validateToolOutput(tool.function.eventSchema, event);
+                preliminaryResults.push(validatedPreliminary);
+                if (onPreliminaryResult) {
+                    onPreliminaryResult(toolCall.id, validatedPreliminary);
+                }
             }
         }
         // Generator must emit at least one value
         if (!hasEmittedValue) {
             throw new Error(`Generator tool "${toolCall.name}" completed without emitting any values`);
         }
-        // Validate the last emitted value against outputSchema (this is the final result)
-        const finalResult = validateToolOutput(tool.function.outputSchema, lastEmittedValue);
-        // Remove last item from preliminaryResults since it's the final output
-        preliminaryResults.pop();
+        // If no explicit final result was found (no yield matched outputSchema but not eventSchema),
+        // use the last emitted value as the final result
+        if (!hasFinalResult) {
+            finalResult = validateToolOutput(tool.function.outputSchema, lastEmittedValue);
+        }
         return {
             toolCallId: toolCall.id,
             toolName: toolCall.name,

package/esm/lib/tool-types.d.ts

@@ -175,6 +175,13 @@ export type TypedToolCallUnion<T extends readonly Tool[]> = {
 export type ToolExecutionResultUnion<T extends readonly Tool[]> = {
     [K in keyof T]: T[K] extends Tool ? ToolExecutionResult<T[K]> : never;
 }[number];
+/**
+ * Union of output types for all tools in a tuple
+ * Used for typing tool result events
+ */
+export type InferToolOutputsUnion<T extends readonly Tool[]> = {
+    [K in keyof T]: T[K] extends Tool ? InferToolOutput<T[K]> : never;
+}[number];
 /**
  * Extracts the event type from a generator tool definition
  * Returns `never` for non-generator tools
@@ -300,16 +307,34 @@ export type ToolPreliminaryResultEvent<TEvent = unknown> = {
     result: TEvent;
     timestamp: number;
 };
+/**
+ * Tool result event emitted when a tool execution completes
+ * Contains the final result and any preliminary results that were emitted
+ * @template TResult - The result type from the tool's outputSchema
+ * @template TPreliminaryResults - The event type from generator tools' eventSchema
+ */
+export type ToolResultEvent<TResult = unknown, TPreliminaryResults = unknown> = {
+    type: 'tool.result';
+    toolCallId: string;
+    result: TResult;
+    timestamp: number;
+    preliminaryResults?: TPreliminaryResults[];
+};
 /**
  * Enhanced stream event types for getFullResponsesStream
- * Extends OpenResponsesStreamEvent with tool preliminary results
+ * Extends OpenResponsesStreamEvent with tool preliminary results and tool results
  * @template TEvent - The event type from generator tools
+ * @template TResult - The result type from tool execution
  */
-export type ResponseStreamEvent<TEvent = unknown> = OpenResponsesStreamEvent | ToolPreliminaryResultEvent<TEvent>;
+export type ResponseStreamEvent<TEvent = unknown, TResult = unknown> = OpenResponsesStreamEvent | ToolPreliminaryResultEvent<TEvent> | ToolResultEvent<TResult, TEvent>;
 /**
  * Type guard to check if an event is a tool preliminary result event
  */
 export declare function isToolPreliminaryResultEvent<TEvent = unknown>(event: ResponseStreamEvent<TEvent>): event is ToolPreliminaryResultEvent<TEvent>;
+/**
+ * Type guard to check if an event is a tool result event
+ */
+export declare function isToolResultEvent<TResult = unknown, TPreliminaryResults = unknown>(event: ResponseStreamEvent<TPreliminaryResults, TResult>): event is ToolResultEvent<TResult, TPreliminaryResults>;
 /**
  * Tool stream event types for getToolStream
  * Includes both argument deltas and preliminary results

package/esm/lib/tool-types.js

@@ -35,6 +35,12 @@ export function isManualTool(tool) {
 export function isToolPreliminaryResultEvent(event) {
     return event.type === 'tool.preliminary_result';
 }
+/**
+ * Type guard to check if an event is a tool result event
+ */
+export function isToolResultEvent(event) {
+    return event.type === 'tool.result';
+}
 /**
  * Type guard to check if a tool has approval configured at runtime
  */

package/esm/models/outputmodality.d.ts

@@ -4,6 +4,7 @@ export declare const OutputModality: {
     readonly Text: "text";
     readonly Image: "image";
     readonly Embeddings: "embeddings";
+    readonly Audio: "audio";
 };
 export type OutputModality = OpenEnum<typeof OutputModality>;
 /** @internal */

package/esm/models/outputmodality.js

@@ -7,6 +7,7 @@ export const OutputModality = {
     Text: "text",
     Image: "image",
     Embeddings: "embeddings",
+    Audio: "audio",
 };
 /** @internal */
 export const OutputModality$inboundSchema = openEnums.inboundSchema(OutputModality);

package/esm/models/publicendpoint.d.ts

@@ -35,6 +35,10 @@ export type Pricing = {
      * A value in string format that is a large number
      */
     audio?: string | undefined;
+    /**
+     * A value in string format that is a large number
+     */
+    audioOutput?: string | undefined;
     /**
      * A value in string format that is a large number
      */
@@ -74,6 +78,10 @@ export type PublicEndpointQuantization = OpenEnum<typeof PublicEndpointQuantizat
  */
 export type PublicEndpoint = {
     name: string;
+    /**
+     * The unique identifier for the model (permaslug)
+     */
+    modelId: string;
     modelName: string;
     contextLength: number;
     pricing: Pricing;

package/esm/models/publicendpoint.js

@@ -30,6 +30,7 @@ export const Pricing$inboundSchema = z.object({
     image_token: z.string().optional(),
     image_output: z.string().optional(),
     audio: z.string().optional(),
+    audio_output: z.string().optional(),
     input_audio_cache: z.string().optional(),
     web_search: z.string().optional(),
     internal_reasoning: z.string().optional(),
@@ -40,6 +41,7 @@ export const Pricing$inboundSchema = z.object({
     return remap$(v, {
         "image_token": "imageToken",
         "image_output": "imageOutput",
+        "audio_output": "audioOutput",
         "input_audio_cache": "inputAudioCache",
         "web_search": "webSearch",
         "internal_reasoning": "internalReasoning",
@@ -55,6 +57,7 @@ export const PublicEndpointQuantization$inboundSchema = openEnums.inboundSchema(
 /** @internal */
 export const PublicEndpoint$inboundSchema = z.object({
     name: z.string(),
+    model_id: z.string(),
     model_name: z.string(),
     context_length: z.number(),
     pricing: z.lazy(() => Pricing$inboundSchema),
@@ -71,6 +74,7 @@ export const PublicEndpoint$inboundSchema = z.object({
     throughput_last_30m: z.nullable(PercentileStats$inboundSchema),
 }).transform((v) => {
     return remap$(v, {
+        "model_id": "modelId",
         "model_name": "modelName",
         "context_length": "contextLength",
         "provider_name": "providerName",

package/esm/models/publicpricing.d.ts

@@ -33,6 +33,10 @@ export type PublicPricing = {
      * A value in string format that is a large number
      */
     audio?: string | undefined;
+    /**
+     * A value in string format that is a large number
+     */
+    audioOutput?: string | undefined;
     /**
      * A value in string format that is a large number
      */

package/esm/models/publicpricing.js

@@ -15,6 +15,7 @@ export const PublicPricing$inboundSchema = z
     image_token: z.string().optional(),
     image_output: z.string().optional(),
     audio: z.string().optional(),
+    audio_output: z.string().optional(),
     input_audio_cache: z.string().optional(),
     web_search: z.string().optional(),
     internal_reasoning: z.string().optional(),
@@ -25,6 +26,7 @@ export const PublicPricing$inboundSchema = z
     return remap$(v, {
         "image_token": "imageToken",
         "image_output": "imageOutput",
+        "audio_output": "audioOutput",
         "input_audio_cache": "inputAudioCache",
         "web_search": "webSearch",
         "internal_reasoning": "internalReasoning",

package/jsr.json

@@ -2,7 +2,7 @@
 
 {
   "name": "@openrouter/sdk",
-  "version": "0.3.15",
+  "version": "0.3.16",
   "exports": {
     ".": "./src/index.ts",    
     "./models/errors": "./src/models/errors/index.ts",    

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openrouter/sdk",
-  "version": "0.3.15",
+  "version": "0.3.16",
   "author": "OpenRouter",
   "description": "The OpenRouter TypeScript SDK is a type-safe toolkit for building AI applications with access to 300+ language models through a unified API.",
   "keywords": [