@openrouter/sdk 0.3.11 → 0.3.12

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/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.12";
     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.12 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.12",
     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.12 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

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

@@ -1,4 +1,4 @@
-import type { ZodObject, ZodRawShape, ZodType, z } from 'zod';
+import type { $ZodObject, $ZodShape, $ZodType, infer as zodInfer } from 'zod/v4/core';
 import type * as models from '../models/index.js';
 import type { OpenResponsesStreamEvent } from '../models/index.js';
 import type { ModelResult } from './model-result.js';
@@ -53,18 +53,18 @@ export type NextTurnParamsFunctions<TInput> = {
 /**
  * Base tool function interface with inputSchema
  */
-export interface BaseToolFunction<TInput extends ZodObject<ZodRawShape>> {
+export interface BaseToolFunction<TInput extends $ZodObject<$ZodShape>> {
     name: string;
     description?: string;
     inputSchema: TInput;
-    nextTurnParams?: NextTurnParamsFunctions<z.infer<TInput>>;
+    nextTurnParams?: NextTurnParamsFunctions<zodInfer<TInput>>;
 }
 /**
  * Regular tool with synchronous or asynchronous execute function and optional outputSchema
  */
-export interface ToolFunctionWithExecute<TInput extends ZodObject<ZodRawShape>, TOutput extends ZodType = ZodType<unknown>> extends BaseToolFunction<TInput> {
+export interface ToolFunctionWithExecute<TInput extends $ZodObject<$ZodShape>, TOutput extends $ZodType = $ZodType<unknown>> extends BaseToolFunction<TInput> {
     outputSchema?: TOutput;
-    execute: (params: z.infer<TInput>, context?: TurnContext) => Promise<z.infer<TOutput>> | z.infer<TOutput>;
+    execute: (params: zodInfer<TInput>, context?: TurnContext) => Promise<zodInfer<TOutput>> | zodInfer<TOutput>;
 }
 /**
  * Generator-based tool with async generator execute function
@@ -88,42 +88,42 @@ export interface ToolFunctionWithExecute<TInput extends ZodObject<ZodRawShape>,
  * }
  * ```
  */
-export interface ToolFunctionWithGenerator<TInput extends ZodObject<ZodRawShape>, TEvent extends ZodType = ZodType<unknown>, TOutput extends ZodType = ZodType<unknown>> extends BaseToolFunction<TInput> {
+export interface ToolFunctionWithGenerator<TInput extends $ZodObject<$ZodShape>, TEvent extends $ZodType = $ZodType<unknown>, TOutput extends $ZodType = $ZodType<unknown>> extends BaseToolFunction<TInput> {
     eventSchema: TEvent;
     outputSchema: TOutput;
-    execute: (params: z.infer<TInput>, context?: TurnContext) => AsyncGenerator<z.infer<TEvent> | z.infer<TOutput>>;
+    execute: (params: zodInfer<TInput>, context?: TurnContext) => AsyncGenerator<zodInfer<TEvent> | zodInfer<TOutput>>;
 }
 /**
  * Manual tool without execute function - requires manual handling by developer
  */
-export interface ManualToolFunction<TInput extends ZodObject<ZodRawShape>, TOutput extends ZodType = ZodType<unknown>> extends BaseToolFunction<TInput> {
+export interface ManualToolFunction<TInput extends $ZodObject<$ZodShape>, TOutput extends $ZodType = $ZodType<unknown>> extends BaseToolFunction<TInput> {
     outputSchema?: TOutput;
 }
 /**
  * Tool with execute function (regular or generator)
  */
-export type ToolWithExecute<TInput extends ZodObject<ZodRawShape> = ZodObject<ZodRawShape>, TOutput extends ZodType = ZodType<unknown>> = {
+export type ToolWithExecute<TInput extends $ZodObject<$ZodShape> = $ZodObject<$ZodShape>, TOutput extends $ZodType = $ZodType<unknown>> = {
     type: ToolType.Function;
     function: ToolFunctionWithExecute<TInput, TOutput>;
 };
 /**
  * Tool with generator execute function
  */
-export type ToolWithGenerator<TInput extends ZodObject<ZodRawShape> = ZodObject<ZodRawShape>, TEvent extends ZodType = ZodType<unknown>, TOutput extends ZodType = ZodType<unknown>> = {
+export type ToolWithGenerator<TInput extends $ZodObject<$ZodShape> = $ZodObject<$ZodShape>, TEvent extends $ZodType = $ZodType<unknown>, TOutput extends $ZodType = $ZodType<unknown>> = {
     type: ToolType.Function;
     function: ToolFunctionWithGenerator<TInput, TEvent, TOutput>;
 };
 /**
  * Tool without execute function (manual handling)
  */
-export type ManualTool<TInput extends ZodObject<ZodRawShape> = ZodObject<ZodRawShape>, TOutput extends ZodType = ZodType<unknown>> = {
+export type ManualTool<TInput extends $ZodObject<$ZodShape> = $ZodObject<$ZodShape>, TOutput extends $ZodType = $ZodType<unknown>> = {
     type: ToolType.Function;
     function: ManualToolFunction<TInput, TOutput>;
 };
 /**
  * Union type of all enhanced tool types
  */
-export type Tool = ToolWithExecute<ZodObject<ZodRawShape>, ZodType<unknown>> | ToolWithGenerator<ZodObject<ZodRawShape>, ZodType<unknown>, ZodType<unknown>> | ManualTool<ZodObject<ZodRawShape>, ZodType<unknown>>;
+export type Tool = ToolWithExecute<$ZodObject<$ZodShape>, $ZodType<unknown>> | ToolWithGenerator<$ZodObject<$ZodShape>, $ZodType<unknown>, $ZodType<unknown>> | ManualTool<$ZodObject<$ZodShape>, $ZodType<unknown>>;
 /**
  * Extracts the input type from a tool definition
  */
@@ -131,7 +131,7 @@ export type InferToolInput<T> = T extends {
     function: {
         inputSchema: infer S;
     };
-} ? S extends ZodType ? z.infer<S> : unknown : unknown;
+} ? S extends $ZodType ? zodInfer<S> : unknown : unknown;
 /**
  * Extracts the output type from a tool definition
  */
@@ -139,7 +139,7 @@ export type InferToolOutput<T> = T extends {
     function: {
         outputSchema: infer S;
     };
-} ? S extends ZodType ? z.infer<S> : unknown : unknown;
+} ? S extends $ZodType ? zodInfer<S> : unknown : unknown;
 /**
  * A tool call with typed arguments based on the tool's inputSchema
  */
@@ -172,7 +172,7 @@ export type InferToolEvent<T> = T extends {
     function: {
         eventSchema: infer S;
     };
-} ? S extends ZodType ? z.infer<S> : never : never;
+} ? S extends $ZodType ? zodInfer<S> : never : never;
 /**
  * Union of event types for all generator tools in a tuple
  * Filters out non-generator tools (which return `never`)
@@ -216,8 +216,8 @@ export interface ParsedToolCall<T extends Tool> {
 export interface ToolExecutionResult<T extends Tool> {
     toolCallId: string;
     toolName: string;
-    result: T extends ToolWithExecute<any, infer O> | ToolWithGenerator<any, any, infer O> ? z.infer<O> : unknown;
-    preliminaryResults?: T extends ToolWithGenerator<any, infer E, any> ? z.infer<E>[] : undefined;
+    result: T extends ToolWithExecute<any, infer O> | ToolWithGenerator<any, any, infer O> ? zodInfer<O> : unknown;
+    preliminaryResults?: T extends ToolWithGenerator<any, infer E, any> ? zodInfer<E>[] : undefined;
     error?: Error;
 }
 /**

package/esm/lib/tool.d.ts

@@ -1,49 +1,49 @@
-import type { ZodObject, ZodRawShape, ZodType, z } from "zod";
+import type { $ZodObject, $ZodShape, $ZodType, infer as zodInfer } from 'zod/v4/core';
 import { type TurnContext, type ToolWithExecute, type ToolWithGenerator, type ManualTool, type NextTurnParamsFunctions } from "./tool-types.js";
 /**
  * Configuration for a regular tool with outputSchema
  */
-type RegularToolConfigWithOutput<TInput extends ZodObject<ZodRawShape>, TOutput extends ZodType> = {
+type RegularToolConfigWithOutput<TInput extends $ZodObject<$ZodShape>, TOutput extends $ZodType> = {
     name: string;
     description?: string;
     inputSchema: TInput;
     outputSchema: TOutput;
     eventSchema?: undefined;
-    nextTurnParams?: NextTurnParamsFunctions<z.infer<TInput>>;
-    execute: (params: z.infer<TInput>, context?: TurnContext) => Promise<z.infer<TOutput>> | z.infer<TOutput>;
+    nextTurnParams?: NextTurnParamsFunctions<zodInfer<TInput>>;
+    execute: (params: zodInfer<TInput>, context?: TurnContext) => Promise<zodInfer<TOutput>> | zodInfer<TOutput>;
 };
 /**
  * Configuration for a regular tool without outputSchema (infers return type from execute)
  */
-type RegularToolConfigWithoutOutput<TInput extends ZodObject<ZodRawShape>, TReturn> = {
+type RegularToolConfigWithoutOutput<TInput extends $ZodObject<$ZodShape>, TReturn> = {
     name: string;
     description?: string;
     inputSchema: TInput;
     outputSchema?: undefined;
     eventSchema?: undefined;
-    nextTurnParams?: NextTurnParamsFunctions<z.infer<TInput>>;
-    execute: (params: z.infer<TInput>, context?: TurnContext) => Promise<TReturn> | TReturn;
+    nextTurnParams?: NextTurnParamsFunctions<zodInfer<TInput>>;
+    execute: (params: zodInfer<TInput>, context?: TurnContext) => Promise<TReturn> | TReturn;
 };
 /**
  * Configuration for a generator tool (with eventSchema)
  */
-type GeneratorToolConfig<TInput extends ZodObject<ZodRawShape>, TEvent extends ZodType, TOutput extends ZodType> = {
+type GeneratorToolConfig<TInput extends $ZodObject<$ZodShape>, TEvent extends $ZodType, TOutput extends $ZodType> = {
     name: string;
     description?: string;
     inputSchema: TInput;
     eventSchema: TEvent;
     outputSchema: TOutput;
-    nextTurnParams?: NextTurnParamsFunctions<z.infer<TInput>>;
-    execute: (params: z.infer<TInput>, context?: TurnContext) => AsyncGenerator<z.infer<TEvent> | z.infer<TOutput>>;
+    nextTurnParams?: NextTurnParamsFunctions<zodInfer<TInput>>;
+    execute: (params: zodInfer<TInput>, context?: TurnContext) => AsyncGenerator<zodInfer<TEvent> | zodInfer<TOutput>>;
 };
 /**
  * Configuration for a manual tool (execute: false, no eventSchema or outputSchema)
  */
-type ManualToolConfig<TInput extends ZodObject<ZodRawShape>> = {
+type ManualToolConfig<TInput extends $ZodObject<$ZodShape>> = {
     name: string;
     description?: string;
     inputSchema: TInput;
-    nextTurnParams?: NextTurnParamsFunctions<z.infer<TInput>>;
+    nextTurnParams?: NextTurnParamsFunctions<zodInfer<TInput>>;
     execute: false;
 };
 /**
@@ -91,9 +91,9 @@ type ManualToolConfig<TInput extends ZodObject<ZodRawShape>> = {
  * });
  * ```
  */
-export declare function tool<TInput extends ZodObject<ZodRawShape>, TEvent extends ZodType, TOutput extends ZodType>(config: GeneratorToolConfig<TInput, TEvent, TOutput>): ToolWithGenerator<TInput, TEvent, TOutput>;
-export declare function tool<TInput extends ZodObject<ZodRawShape>>(config: ManualToolConfig<TInput>): ManualTool<TInput>;
-export declare function tool<TInput extends ZodObject<ZodRawShape>, TOutput extends ZodType>(config: RegularToolConfigWithOutput<TInput, TOutput>): ToolWithExecute<TInput, TOutput>;
-export declare function tool<TInput extends ZodObject<ZodRawShape>, TReturn>(config: RegularToolConfigWithoutOutput<TInput, TReturn>): ToolWithExecute<TInput, ZodType<TReturn>>;
+export declare function tool<TInput extends $ZodObject<$ZodShape>, TEvent extends $ZodType, TOutput extends $ZodType>(config: GeneratorToolConfig<TInput, TEvent, TOutput>): ToolWithGenerator<TInput, TEvent, TOutput>;
+export declare function tool<TInput extends $ZodObject<$ZodShape>>(config: ManualToolConfig<TInput>): ManualTool<TInput>;
+export declare function tool<TInput extends $ZodObject<$ZodShape>, TOutput extends $ZodType>(config: RegularToolConfigWithOutput<TInput, TOutput>): ToolWithExecute<TInput, TOutput>;
+export declare function tool<TInput extends $ZodObject<$ZodShape>, TReturn>(config: RegularToolConfigWithoutOutput<TInput, TReturn>): ToolWithExecute<TInput, $ZodType<TReturn>>;
 export {};
 //# sourceMappingURL=tool.d.ts.map

package/jsr.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openrouter/sdk",
-  "version": "0.3.11",
+  "version": "0.3.12",
   "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": [
@@ -69,11 +69,9 @@
     "build": "tsc",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "npm run build",
-    "test": "vitest --run",
-    "test:watch": "vitest"
-  },
-  "peerDependencies": {
-
+    "test": "vitest --run --project unit",
+    "test:e2e": "vitest --run --project e2e",
+    "test:watch": "vitest --watch --project unit"
   },
   "devDependencies": {
     "@eslint/js": "^9.19.0",
@@ -87,5 +85,6 @@
   },
   "dependencies": {
     "zod": "^3.25.0 || ^4.0.0"
-  }
+  },
+  "packageManager": "pnpm@10.22.0"
 }

package/vitest.config.ts

@@ -1,36 +1,45 @@
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
 import { config } from 'dotenv';
 import { defineConfig } from 'vitest/config';
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
 // Load environment variables from .env file if it exists
 // This will not override existing environment variables
 config({
-  path: join(__dirname, '.env'),
+  path: new URL('.env', import.meta.url),
 });
 
 export default defineConfig({
   test: {
     globals: true,
     environment: 'node',
-    // Don't override env vars - just let them pass through from the system
-    // The env object here will be merged with process.env
     env: {
       OPENROUTER_API_KEY: process.env.OPENROUTER_API_KEY,
     },
-    include: [
-      'tests/**/*.test.ts',
-    ],
-    hookTimeout: 30000,
-    testTimeout: 30000,
     typecheck: {
       enabled: true,
-      include: [
-        'tests/**/*.test.ts',
-      ],
     },
+    projects: [
+      {
+        extends: true,
+        test: {
+          name: 'unit',
+          include: [
+            'tests/unit/**/*.test.ts', 
+            'tests/funcs/**/*.test.ts', 
+            'tests/sdk/**/*.test.ts'
+          ],
+          testTimeout: 10000,
+          hookTimeout: 10000,
+        },
+      },
+      {
+        extends: true,
+        test: {
+          name: 'e2e',
+          include: ['tests/e2e/**/*.test.ts'],
+          testTimeout: 30000,
+          hookTimeout: 30000,
+        },
+      },
+    ],
   },
 });

package/.zed/settings.json

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