@openrouter/sdk 0.3.11 → 0.3.14

package/esm/index.d.ts

@@ -17,5 +17,6 @@ export { extractUnsupportedContent, getUnsupportedContentSummary, hasUnsupported
 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 { ToolEventBroadcaster } from './lib/tool-event-broadcaster.js';
 export * from './sdk/sdk.js';
 //# sourceMappingURL=index.d.ts.map

package/esm/index.js

@@ -21,5 +21,7 @@ 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';
+// Real-time tool event broadcasting
+export { ToolEventBroadcaster } from './lib/tool-event-broadcaster.js';
 export * from './sdk/sdk.js';
 //# sourceMappingURL=index.js.map

package/esm/lib/anthropic-compat.test.js

@@ -9,12 +9,15 @@ function createMockResponse(overrides) {
         id: "resp_test",
         object: "response",
         createdAt: Date.now(),
+        completedAt: Date.now(),
         model: "openai/gpt-4",
         status: "completed",
         error: null,
         incompleteDetails: null,
         temperature: null,
         topP: null,
+        presencePenalty: null,
+        frequencyPenalty: null,
         metadata: null,
         tools: [],
         toolChoice: "auto",

package/esm/lib/chat-compat.test.js

@@ -9,12 +9,15 @@ function createMockResponse(overrides) {
         id: "resp_test",
         object: "response",
         createdAt: Date.now(),
+        completedAt: Date.now(),
         model: "openai/gpt-4",
         status: "completed",
         error: null,
         incompleteDetails: null,
         temperature: null,
         topP: null,
+        presencePenalty: null,
+        frequencyPenalty: null,
         metadata: null,
         tools: [],
         toolChoice: "auto",

package/esm/lib/config.d.ts

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

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

@@ -37,10 +37,15 @@ export declare class ModelResult<TTools extends readonly Tool[]> {
     private initPromise;
     private toolExecutionPromise;
     private finalResponse;
-    private preliminaryResults;
+    private toolEventBroadcaster;
     private allToolExecutionRounds;
     private resolvedRequest;
     constructor(options: GetResponseOptions<TTools>);
+    /**
+     * Get or create the tool event broadcaster (lazy initialization).
+     * Ensures only one broadcaster exists for the lifetime of this ModelResult.
+     */
+    private ensureBroadcaster;
     /**
      * Type guard to check if a value is a non-streaming response
      */
@@ -73,7 +78,7 @@ export declare class ModelResult<TTools extends readonly Tool[]> {
     /**
      * Stream all response events as they arrive.
      * Multiple consumers can iterate over this stream concurrently.
-     * Includes preliminary tool result events after tool execution.
+     * Preliminary tool results are streamed in REAL-TIME as generator tools yield.
      */
     getFullResponsesStream(): AsyncIterableIterator<ResponseStreamEvent<InferToolEventsUnion<TTools>>>;
     /**
@@ -95,7 +100,7 @@ export declare class ModelResult<TTools extends readonly Tool[]> {
     getReasoningStream(): AsyncIterableIterator<string>;
     /**
      * Stream tool call argument deltas and preliminary results.
-     * This filters the full event stream to yield:
+     * Preliminary results are streamed in REAL-TIME as generator tools yield.
      * - Tool call argument deltas as { type: "delta", content: string }
      * - Preliminary results as { type: "preliminary_result", toolCallId, result }
      */

package/esm/lib/model-result.js

@@ -1,3 +1,4 @@
+import { ToolEventBroadcaster } from './tool-event-broadcaster.js';
 import { betaResponsesSend } from '../funcs/betaResponsesSend.js';
 import { hasAsyncFunctions, resolveAsyncFunctions, } from './async-params.js';
 import { ReusableReadableStream } from './reusable-stream.js';
@@ -51,12 +52,22 @@ export class ModelResult {
         this.initPromise = null;
         this.toolExecutionPromise = null;
         this.finalResponse = null;
-        this.preliminaryResults = new Map();
+        this.toolEventBroadcaster = null;
         this.allToolExecutionRounds = [];
         // Track resolved request after async function resolution
         this.resolvedRequest = null;
         this.options = options;
     }
+    /**
+     * Get or create the tool event broadcaster (lazy initialization).
+     * Ensures only one broadcaster exists for the lifetime of this ModelResult.
+     */
+    ensureBroadcaster() {
+        if (!this.toolEventBroadcaster) {
+            this.toolEventBroadcaster = new ToolEventBroadcaster();
+        }
+        return this.toolEventBroadcaster;
+    }
     /**
      * Type guard to check if a value is a non-streaming response
      */
@@ -91,8 +102,7 @@ export class ModelResult {
                 // Already resolved, extract non-function fields
                 // Since request is CallModelInput, we need to filter out stopWhen
                 // Note: tools are already in API format at this point (converted in callModel())
-                // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                const { stopWhen, ...rest } = this.options.request;
+                const { stopWhen: _, ...rest } = this.options.request;
                 // Cast to ResolvedCallModelInput - we know it's resolved if hasAsyncFunctions returned false
                 baseRequest = rest;
             }
@@ -215,11 +225,17 @@ export class ModelResult {
                     if (!tool || !hasExecuteFunction(tool)) {
                         continue;
                     }
-                    const result = await executeTool(tool, toolCall, turnContext);
-                    // Store preliminary results
-                    if (result.preliminaryResults && result.preliminaryResults.length > 0) {
-                        this.preliminaryResults.set(toolCall.id, result.preliminaryResults);
-                    }
+                    // Create callback for real-time preliminary results
+                    const onPreliminaryResult = this.toolEventBroadcaster
+                        ? (callId, resultValue) => {
+                            this.toolEventBroadcaster?.push({
+                                type: 'preliminary_result',
+                                toolCallId: callId,
+                                result: resultValue,
+                            });
+                        }
+                        : undefined;
+                    const result = await executeTool(tool, toolCall, turnContext, onPreliminaryResult);
                     toolResults.push({
                         type: 'function_call_output',
                         id: `output_${toolCall.id}`,
@@ -335,7 +351,7 @@ export class ModelResult {
     /**
      * Stream all response events as they arrive.
      * Multiple consumers can iterate over this stream concurrently.
-     * Includes preliminary tool result events after tool execution.
+     * Preliminary tool results are streamed in REAL-TIME as generator tools yield.
      */
     getFullResponsesStream() {
         return async function* () {
@@ -343,24 +359,29 @@ export class ModelResult {
             if (!this.reusableStream) {
                 throw new Error('Stream not initialized');
             }
+            // Get or create broadcaster for real-time tool events (lazy init prevents race conditions)
+            const broadcaster = this.ensureBroadcaster();
+            const toolEventConsumer = broadcaster.createConsumer();
+            // Start tool execution in background (completes broadcaster when done)
+            const executionPromise = this.executeToolsIfNeeded().finally(() => {
+                broadcaster.complete();
+            });
             const consumer = this.reusableStream.createConsumer();
-            // Yield original events directly
+            // Yield original API events
             for await (const event of consumer) {
                 yield event;
             }
-            // After stream completes, check if tools were executed and emit preliminary results
-            await this.executeToolsIfNeeded();
-            // Emit all preliminary results as new event types
-            for (const [toolCallId, results] of this.preliminaryResults) {
-                for (const result of results) {
-                    yield {
-                        type: 'tool.preliminary_result',
-                        toolCallId,
-                        result: result,
-                        timestamp: Date.now(),
-                    };
-                }
+            // Yield tool preliminary results 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(),
+                };
             }
+            // Ensure execution completed (handles errors)
+            await executionPromise;
         }.call(this);
     }
     /**
@@ -423,7 +444,7 @@ export class ModelResult {
     }
     /**
      * Stream tool call argument deltas and preliminary results.
-     * This filters the full event stream to yield:
+     * Preliminary results are streamed in REAL-TIME as generator tools yield.
      * - Tool call argument deltas as { type: "delta", content: string }
      * - Preliminary results as { type: "preliminary_result", toolCallId, result }
      */
@@ -433,25 +454,26 @@ export class ModelResult {
             if (!this.reusableStream) {
                 throw new Error('Stream not initialized');
             }
-            // Yield tool deltas as structured events
+            // Get or create broadcaster for real-time tool events (lazy init prevents race conditions)
+            const broadcaster = this.ensureBroadcaster();
+            const toolEventConsumer = broadcaster.createConsumer();
+            // Start tool execution in background (completes broadcaster when done)
+            const executionPromise = this.executeToolsIfNeeded().finally(() => {
+                broadcaster.complete();
+            });
+            // Yield tool deltas from API stream
             for await (const delta of extractToolDeltas(this.reusableStream)) {
                 yield {
                     type: 'delta',
                     content: delta,
                 };
             }
-            // After stream completes, check if tools were executed and emit preliminary results
-            await this.executeToolsIfNeeded();
-            // Emit all preliminary results
-            for (const [toolCallId, results] of this.preliminaryResults) {
-                for (const result of results) {
-                    yield {
-                        type: 'preliminary_result',
-                        toolCallId,
-                        result: result,
-                    };
-                }
+            // Yield tool events as they arrive (real-time!)
+            for await (const event of toolEventConsumer) {
+                yield event;
             }
+            // Ensure execution completed (handles errors)
+            await executionPromise;
         }.call(this);
     }
     /**

package/esm/lib/tool-event-broadcaster.d.ts

@@ -0,0 +1,44 @@
+/**
+ * A push-based event broadcaster that supports multiple concurrent consumers.
+ * Similar to ReusableReadableStream but for push-based events from tool execution.
+ *
+ * Each consumer gets their own position in the buffer and receives all events
+ * from their join point onward. This enables real-time streaming of generator
+ * tool preliminary results to multiple consumers simultaneously.
+ *
+ * @template T - The event type being broadcast
+ */
+export declare class ToolEventBroadcaster<T> {
+    private buffer;
+    private consumers;
+    private nextConsumerId;
+    private isComplete;
+    private completionError;
+    /**
+     * Push a new event to all consumers.
+     * Events are buffered so late-joining consumers can catch up.
+     */
+    push(event: T): void;
+    /**
+     * Mark the broadcaster as complete - no more events will be pushed.
+     * Optionally pass an error to signal failure to all consumers.
+     * Cleans up buffer and consumers after completion.
+     */
+    complete(error?: Error): void;
+    /**
+     * Clean up resources after all consumers have finished.
+     * Called automatically after complete(), but can be called manually.
+     */
+    private cleanup;
+    /**
+     * Create a new consumer that can independently iterate over events.
+     * Consumers can join at any time and will receive events from position 0.
+     * Multiple consumers can be created and will all receive the same events.
+     */
+    createConsumer(): AsyncIterableIterator<T>;
+    /**
+     * Notify all waiting consumers that new data is available or stream completed
+     */
+    private notifyWaitingConsumers;
+}
+//# sourceMappingURL=tool-event-broadcaster.d.ts.map

package/esm/lib/tool-event-broadcaster.js

@@ -0,0 +1,146 @@
+/**
+ * A push-based event broadcaster that supports multiple concurrent consumers.
+ * Similar to ReusableReadableStream but for push-based events from tool execution.
+ *
+ * Each consumer gets their own position in the buffer and receives all events
+ * from their join point onward. This enables real-time streaming of generator
+ * tool preliminary results to multiple consumers simultaneously.
+ *
+ * @template T - The event type being broadcast
+ */
+export class ToolEventBroadcaster {
+    constructor() {
+        this.buffer = [];
+        this.consumers = new Map();
+        this.nextConsumerId = 0;
+        this.isComplete = false;
+        this.completionError = null;
+    }
+    /**
+     * Push a new event to all consumers.
+     * Events are buffered so late-joining consumers can catch up.
+     */
+    push(event) {
+        if (this.isComplete) {
+            return;
+        }
+        this.buffer.push(event);
+        this.notifyWaitingConsumers();
+    }
+    /**
+     * Mark the broadcaster as complete - no more events will be pushed.
+     * Optionally pass an error to signal failure to all consumers.
+     * Cleans up buffer and consumers after completion.
+     */
+    complete(error) {
+        this.isComplete = true;
+        this.completionError = error ?? null;
+        this.notifyWaitingConsumers();
+        // Schedule cleanup after consumers have processed completion
+        queueMicrotask(() => this.cleanup());
+    }
+    /**
+     * Clean up resources after all consumers have finished.
+     * Called automatically after complete(), but can be called manually.
+     */
+    cleanup() {
+        // Only cleanup if complete and all consumers are done
+        if (this.isComplete && this.consumers.size === 0) {
+            this.buffer = [];
+        }
+    }
+    /**
+     * Create a new consumer that can independently iterate over events.
+     * Consumers can join at any time and will receive events from position 0.
+     * Multiple consumers can be created and will all receive the same events.
+     */
+    createConsumer() {
+        const consumerId = this.nextConsumerId++;
+        const state = {
+            position: 0,
+            waitingPromise: null,
+            cancelled: false,
+        };
+        this.consumers.set(consumerId, state);
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        return {
+            async next() {
+                const consumer = self.consumers.get(consumerId);
+                if (!consumer) {
+                    return { done: true, value: undefined };
+                }
+                if (consumer.cancelled) {
+                    return { done: true, value: undefined };
+                }
+                // Return buffered event if available
+                if (consumer.position < self.buffer.length) {
+                    const value = self.buffer[consumer.position];
+                    consumer.position++;
+                    return { done: false, value };
+                }
+                // If complete and caught up, we're done
+                if (self.isComplete) {
+                    self.consumers.delete(consumerId);
+                    self.cleanup();
+                    if (self.completionError) {
+                        throw self.completionError;
+                    }
+                    return { done: true, value: undefined };
+                }
+                // Set up waiting promise FIRST to avoid race condition
+                const waitPromise = new Promise((resolve, reject) => {
+                    consumer.waitingPromise = { resolve, reject };
+                    // Immediately check if we should resolve after setting up promise
+                    if (self.isComplete ||
+                        self.completionError ||
+                        consumer.position < self.buffer.length) {
+                        resolve();
+                    }
+                });
+                await waitPromise;
+                consumer.waitingPromise = null;
+                // Recursively try again after waking up
+                return this.next();
+            },
+            async return() {
+                const consumer = self.consumers.get(consumerId);
+                if (consumer) {
+                    consumer.cancelled = true;
+                    self.consumers.delete(consumerId);
+                    self.cleanup();
+                }
+                return { done: true, value: undefined };
+            },
+            async throw(e) {
+                const consumer = self.consumers.get(consumerId);
+                if (consumer) {
+                    consumer.cancelled = true;
+                    self.consumers.delete(consumerId);
+                    self.cleanup();
+                }
+                throw e;
+            },
+            [Symbol.asyncIterator]() {
+                return this;
+            },
+        };
+    }
+    /**
+     * Notify all waiting consumers that new data is available or stream completed
+     */
+    notifyWaitingConsumers() {
+        for (const consumer of this.consumers.values()) {
+            if (consumer.waitingPromise) {
+                if (this.completionError) {
+                    consumer.waitingPromise.reject(this.completionError);
+                }
+                else {
+                    consumer.waitingPromise.resolve();
+                }
+                consumer.waitingPromise = null;
+            }
+        }
+    }
+}
+//# sourceMappingURL=tool-event-broadcaster.js.map

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

@@ -1,10 +1,25 @@
-import type { ZodType } from 'zod';
+import type { $ZodType } from 'zod/v4/core';
 import type { APITool, Tool, ParsedToolCall, ToolExecutionResult, TurnContext } from './tool-types.js';
+import * as z4 from 'zod/v4';
+export declare const ZodError: z4.z.core.$constructor<z4.ZodError<unknown>, z4.z.core.$ZodIssue[]>;
 /**
- * Convert a Zod schema to JSON Schema using Zod v4's toJSONSchema function
- * Uses type assertion to bridge zod (user schemas) and zod/v4 (toJSONSchema)
+ * Recursively remove keys prefixed with ~ from an object.
+ * These are metadata properties (like ~standard from Standard Schema)
+ * that should not be sent to downstream providers.
+ * @see https://github.com/OpenRouterTeam/typescript-sdk/issues/131
+ *
+ * When given a Record<string, unknown>, returns Record<string, unknown>.
+ * When given unknown, returns unknown (preserves primitives, null, etc).
  */
-export declare function convertZodToJsonSchema(zodSchema: ZodType): Record<string, unknown>;
+export declare function sanitizeJsonSchema(obj: Record<string, unknown>): Record<string, unknown>;
+export declare function sanitizeJsonSchema(obj: unknown): unknown;
+/**
+ * Convert a Zod schema to JSON Schema using Zod v4's toJSONSchema function.
+ * Accepts ZodType from the main zod package for user compatibility.
+ * The resulting schema is sanitized to remove metadata properties (like ~standard)
+ * that would cause 400 errors with downstream providers.
+ */
+export declare function convertZodToJsonSchema(zodSchema: $ZodType): Record<string, unknown>;
 /**
  * Convert tools to OpenRouter API format
  * Accepts readonly arrays for better type compatibility
@@ -14,12 +29,12 @@ export declare function convertToolsToAPIFormat(tools: readonly Tool[]): APITool
  * Validate tool input against Zod schema
  * @throws ZodError if validation fails
  */
-export declare function validateToolInput<T>(schema: ZodType<T>, args: unknown): T;
+export declare function validateToolInput<T>(schema: $ZodType<T>, args: unknown): T;
 /**
  * Validate tool output against Zod schema
  * @throws ZodError if validation fails
  */
-export declare function validateToolOutput<T>(schema: ZodType<T>, result: unknown): T;
+export declare function validateToolOutput<T>(schema: $ZodType<T>, result: unknown): T;
 /**
  * Parse tool call arguments from JSON string
  */

package/esm/lib/tool-executor.js

@@ -1,15 +1,64 @@
-import { toJSONSchema, ZodError } from 'zod/v4';
+import * as z4 from 'zod/v4';
 import { hasExecuteFunction, isGeneratorTool, isRegularExecuteTool } from './tool-types.js';
+// Re-export ZodError for convenience
+export const ZodError = z4.ZodError;
 /**
- * Convert a Zod schema to JSON Schema using Zod v4's toJSONSchema function
- * Uses type assertion to bridge zod (user schemas) and zod/v4 (toJSONSchema)
+ * Typeguard to check if a value is a non-null object (not an array).
+ */
+function isNonNullObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export function sanitizeJsonSchema(obj) {
+    if (obj === null || typeof obj !== 'object') {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(sanitizeJsonSchema);
+    }
+    // At this point, obj is a non-null, non-array object
+    // Use typeguard to narrow the type for type-safe property access
+    if (!isNonNullObject(obj)) {
+        return obj;
+    }
+    const result = {};
+    for (const key of Object.keys(obj)) {
+        if (!key.startsWith('~')) {
+            result[key] = sanitizeJsonSchema(obj[key]);
+        }
+    }
+    return result;
+}
+/**
+ * Typeguard to check if a value is a valid Zod schema compatible with zod/v4.
+ * Zod schemas have a _zod property that contains schema metadata.
+ */
+function isZodSchema(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    if (!('_zod' in value)) {
+        return false;
+    }
+    // After the 'in' check, TypeScript knows value has _zod property
+    return typeof value._zod === 'object';
+}
+/**
+ * Convert a Zod schema to JSON Schema using Zod v4's toJSONSchema function.
+ * Accepts ZodType from the main zod package for user compatibility.
+ * The resulting schema is sanitized to remove metadata properties (like ~standard)
+ * that would cause 400 errors with downstream providers.
  */
 export function convertZodToJsonSchema(zodSchema) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const jsonSchema = toJSONSchema(zodSchema, {
+    if (!isZodSchema(zodSchema)) {
+        throw new Error('Invalid Zod schema provided');
+    }
+    // Use draft-7 as it's closest to OpenAPI 3.0's JSON Schema variant
+    const jsonSchema = z4.toJSONSchema(zodSchema, {
         target: 'draft-7',
     });
-    return jsonSchema;
+    // jsonSchema is always a Record<string, unknown> from toJSONSchema
+    // The overloaded sanitizeJsonSchema preserves this type
+    return sanitizeJsonSchema(jsonSchema);
 }
 /**
  * Convert tools to OpenRouter API format
@@ -29,14 +78,14 @@ export function convertToolsToAPIFormat(tools) {
  * @throws ZodError if validation fails
  */
 export function validateToolInput(schema, args) {
-    return schema.parse(args);
+    return z4.parse(schema, args);
 }
 /**
  * Validate tool output against Zod schema
  * @throws ZodError if validation fails
  */
 export function validateToolOutput(schema, result) {
-    return schema.parse(result);
+    return z4.parse(schema, result);
 }
 /**
  * Parse tool call arguments from JSON string