@openrouter/sdk 0.3.7 → 0.3.11

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

@@ -1,4 +1,4 @@
-import type { ZodObject, ZodRawShape, ZodType, z } from 'zod/v4';
+import type { ZodObject, ZodRawShape, ZodType, z } from 'zod';
 import type * as models from '../models/index.js';
 import type { OpenResponsesStreamEvent } from '../models/index.js';
 import type { ModelResult } from './model-result.js';
@@ -9,19 +9,47 @@ export declare enum ToolType {
     Function = "function"
 }
 /**
- * Turn context passed to tool execute functions
+ * Turn context passed to tool execute functions and async parameter resolution
  * Contains information about the current conversation state
  */
 export interface TurnContext {
-    /** Number of tool execution turns so far (1-indexed: first turn = 1) */
+    /** The specific tool call being executed (only available during tool execution) */
+    toolCall?: models.OpenResponsesFunctionToolCall;
+    /** Number of tool execution turns so far (1-indexed: first turn = 1, 0 = initial request) */
     numberOfTurns: number;
-    /** Current message history being sent to the API */
-    messageHistory: models.OpenResponsesInput;
-    /** Model name if request.model is set */
-    model?: string;
-    /** Model names if request.models is set */
-    models?: string[];
+    /** The full request being sent to the API (only available during tool execution) */
+    turnRequest?: models.OpenResponsesRequest;
 }
+/**
+ * Context passed to nextTurnParams functions
+ * Contains current request state for parameter computation
+ * Allows modification of key request parameters between turns
+ */
+export type NextTurnParamsContext = {
+    /** Current input (messages) */
+    input: models.OpenResponsesInput;
+    /** Current model selection */
+    model: string;
+    /** Current models array */
+    models: string[];
+    /** Current temperature */
+    temperature: number | null;
+    /** Current maxOutputTokens */
+    maxOutputTokens: number | null;
+    /** Current topP */
+    topP: number | null;
+    /** Current topK */
+    topK?: number | undefined;
+    /** Current instructions */
+    instructions: string | null;
+};
+/**
+ * Functions to compute next turn parameters
+ * Each function receives the tool's input params and current request context
+ */
+export type NextTurnParamsFunctions<TInput> = {
+    [K in keyof NextTurnParamsContext]?: (params: TInput, context: NextTurnParamsContext) => NextTurnParamsContext[K] | Promise<NextTurnParamsContext[K]>;
+};
 /**
  * Base tool function interface with inputSchema
  */
@@ -29,6 +57,7 @@ export interface BaseToolFunction<TInput extends ZodObject<ZodRawShape>> {
     name: string;
     description?: string;
     inputSchema: TInput;
+    nextTurnParams?: NextTurnParamsFunctions<z.infer<TInput>>;
 }
 /**
  * Regular tool with synchronous or asynchronous execute function and optional outputSchema
@@ -42,6 +71,10 @@ export interface ToolFunctionWithExecute<TInput extends ZodObject<ZodRawShape>,
  * Emits preliminary events (validated by eventSchema) during execution
  * and a final output (validated by outputSchema) as the last emission
  *
+ * The generator can yield both events and the final output.
+ * All yields are validated against eventSchema (which should be a union of event and output types),
+ * and the last yield is additionally validated against outputSchema.
+ *
  * @example
  * ```typescript
  * {
@@ -58,7 +91,7 @@ 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> {
     eventSchema: TEvent;
     outputSchema: TOutput;
-    execute: (params: z.infer<TInput>, context?: TurnContext) => AsyncGenerator<z.infer<TEvent>>;
+    execute: (params: z.infer<TInput>, context?: TurnContext) => AsyncGenerator<z.infer<TEvent> | z.infer<TOutput>>;
 }
 /**
  * Manual tool without execute function - requires manual handling by developer
@@ -91,6 +124,62 @@ export type ManualTool<TInput extends ZodObject<ZodRawShape> = ZodObject<ZodRawS
  * 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>>;
+/**
+ * Extracts the input type from a tool definition
+ */
+export type InferToolInput<T> = T extends {
+    function: {
+        inputSchema: infer S;
+    };
+} ? S extends ZodType ? z.infer<S> : unknown : unknown;
+/**
+ * Extracts the output type from a tool definition
+ */
+export type InferToolOutput<T> = T extends {
+    function: {
+        outputSchema: infer S;
+    };
+} ? S extends ZodType ? z.infer<S> : unknown : unknown;
+/**
+ * A tool call with typed arguments based on the tool's inputSchema
+ */
+export type TypedToolCall<T extends Tool> = {
+    id: string;
+    name: T extends {
+        function: {
+            name: infer N;
+        };
+    } ? N : string;
+    arguments: InferToolInput<T>;
+};
+/**
+ * Union of typed tool calls for a tuple of tools
+ */
+export type TypedToolCallUnion<T extends readonly Tool[]> = {
+    [K in keyof T]: T[K] extends Tool ? TypedToolCall<T[K]> : never;
+}[number];
+/**
+ * Union of typed tool execution results for a tuple of tools
+ */
+export type ToolExecutionResultUnion<T extends readonly Tool[]> = {
+    [K in keyof T]: T[K] extends Tool ? ToolExecutionResult<T[K]> : never;
+}[number];
+/**
+ * Extracts the event type from a generator tool definition
+ * Returns `never` for non-generator tools
+ */
+export type InferToolEvent<T> = T extends {
+    function: {
+        eventSchema: infer S;
+    };
+} ? S extends ZodType ? z.infer<S> : never : never;
+/**
+ * Union of event types for all generator tools in a tuple
+ * Filters out non-generator tools (which return `never`)
+ */
+export type InferToolEventsUnion<T extends readonly Tool[]> = {
+    [K in keyof T]: T[K] extends Tool ? InferToolEvent<T[K]> : never;
+}[number];
 /**
  * Type guard to check if a tool has an execute function
  */
@@ -103,34 +192,75 @@ export declare function isGeneratorTool(tool: Tool): tool is ToolWithGenerator;
  * Type guard to check if a tool is a regular execution tool (not generator)
  */
 export declare function isRegularExecuteTool(tool: Tool): tool is ToolWithExecute;
+/**
+ * Type guard to check if a tool is a manual tool (no execute function)
+ */
+export declare function isManualTool(tool: Tool): tool is ManualTool;
 /**
  * Parsed tool call from API response
+ * @template T - The tool type to infer argument types from
  */
-export interface ParsedToolCall {
+export interface ParsedToolCall<T extends Tool> {
     id: string;
-    name: string;
-    arguments: unknown;
+    name: T extends {
+        function: {
+            name: infer N;
+        };
+    } ? N : string;
+    arguments: InferToolInput<T>;
 }
 /**
  * Result of tool execution
+ * @template T - The tool type to infer result types from
  */
-export interface ToolExecutionResult {
+export interface ToolExecutionResult<T extends Tool> {
     toolCallId: string;
     toolName: string;
-    result: unknown;
-    preliminaryResults?: unknown[];
+    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;
     error?: Error;
 }
 /**
- * Type for maxToolRounds - can be a number or a function that determines if execution should continue
+ * Warning from step execution
+ */
+export interface Warning {
+    type: string;
+    message: string;
+}
+/**
+ * Result of a single step in the tool execution loop
+ * Compatible with Vercel AI SDK pattern
+ */
+export interface StepResult<TTools extends readonly Tool[] = readonly Tool[]> {
+    readonly stepType: 'initial' | 'continue';
+    readonly text: string;
+    readonly toolCalls: TypedToolCallUnion<TTools>[];
+    readonly toolResults: ToolExecutionResultUnion<TTools>[];
+    readonly response: models.OpenResponsesNonStreamingResponse;
+    readonly usage?: models.OpenResponsesUsage | undefined;
+    readonly finishReason?: string | undefined;
+    readonly warnings?: Warning[] | undefined;
+    readonly experimental_providerMetadata?: Record<string, unknown> | undefined;
+}
+/**
+ * A condition function that determines whether to stop tool execution
+ * Returns true to STOP execution, false to CONTINUE
+ * (Matches Vercel AI SDK semantics)
+ */
+export type StopCondition<TTools extends readonly Tool[] = readonly Tool[]> = (options: {
+    readonly steps: ReadonlyArray<StepResult<TTools>>;
+}) => boolean | Promise<boolean>;
+/**
+ * Stop condition configuration
+ * Can be a single condition or array of conditions
  */
-export type MaxToolRounds = number | ((context: TurnContext) => boolean);
+export type StopWhen<TTools extends readonly Tool[] = readonly Tool[]> = StopCondition<TTools> | ReadonlyArray<StopCondition<TTools>>;
 /**
  * Result of executeTools operation
  */
-export interface ExecuteToolsResult {
-    finalResponse: ModelResult;
-    allResponses: ModelResult[];
+export interface ExecuteToolsResult<TTools extends readonly Tool[]> {
+    finalResponse: ModelResult<TTools>;
+    allResponses: ModelResult<TTools>[];
     toolResults: Map<string, {
         result: unknown;
         preliminaryResults?: unknown[];
@@ -151,39 +281,43 @@ export interface APITool {
 }
 /**
  * Tool preliminary result event emitted during generator tool execution
+ * @template TEvent - The event type from the tool's eventSchema
  */
-export type ToolPreliminaryResultEvent = {
+export type ToolPreliminaryResultEvent<TEvent = unknown> = {
     type: 'tool.preliminary_result';
     toolCallId: string;
-    result: unknown;
+    result: TEvent;
     timestamp: number;
 };
 /**
  * Enhanced stream event types for getFullResponsesStream
  * Extends OpenResponsesStreamEvent with tool preliminary results
+ * @template TEvent - The event type from generator tools
  */
-export type EnhancedResponseStreamEvent = OpenResponsesStreamEvent | ToolPreliminaryResultEvent;
+export type ResponseStreamEvent<TEvent = unknown> = OpenResponsesStreamEvent | ToolPreliminaryResultEvent<TEvent>;
 /**
  * Type guard to check if an event is a tool preliminary result event
  */
-export declare function isToolPreliminaryResultEvent(event: EnhancedResponseStreamEvent): event is ToolPreliminaryResultEvent;
+export declare function isToolPreliminaryResultEvent<TEvent = unknown>(event: ResponseStreamEvent<TEvent>): event is ToolPreliminaryResultEvent<TEvent>;
 /**
  * Tool stream event types for getToolStream
  * Includes both argument deltas and preliminary results
+ * @template TEvent - The event type from generator tools
  */
-export type ToolStreamEvent = {
+export type ToolStreamEvent<TEvent = unknown> = {
     type: 'delta';
     content: string;
 } | {
     type: 'preliminary_result';
     toolCallId: string;
-    result: unknown;
+    result: TEvent;
 };
 /**
  * Chat stream event types for getFullChatStream
  * Includes content deltas, completion events, and tool preliminary results
+ * @template TEvent - The event type from generator tools
  */
-export type ChatStreamEvent = {
+export type ChatStreamEvent<TEvent = unknown> = {
     type: 'content.delta';
     delta: string;
 } | {
@@ -192,7 +326,7 @@ export type ChatStreamEvent = {
 } | {
     type: 'tool.preliminary_result';
     toolCallId: string;
-    result: unknown;
+    result: TEvent;
 } | {
     type: string;
     event: OpenResponsesStreamEvent;

package/esm/lib/tool-types.js

@@ -23,6 +23,12 @@ export function isGeneratorTool(tool) {
 export function isRegularExecuteTool(tool) {
     return hasExecuteFunction(tool) && !isGeneratorTool(tool);
 }
+/**
+ * Type guard to check if a tool is a manual tool (no execute function)
+ */
+export function isManualTool(tool) {
+    return !('execute' in tool.function);
+}
 /**
  * Type guard to check if an event is a tool preliminary result event
  */

package/esm/lib/tool.d.ts

@@ -0,0 +1,99 @@
+import type { ZodObject, ZodRawShape, ZodType, z } from "zod";
+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> = {
+    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>;
+};
+/**
+ * Configuration for a regular tool without outputSchema (infers return type from execute)
+ */
+type RegularToolConfigWithoutOutput<TInput extends ZodObject<ZodRawShape>, 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;
+};
+/**
+ * Configuration for a generator tool (with eventSchema)
+ */
+type GeneratorToolConfig<TInput extends ZodObject<ZodRawShape>, 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>>;
+};
+/**
+ * Configuration for a manual tool (execute: false, no eventSchema or outputSchema)
+ */
+type ManualToolConfig<TInput extends ZodObject<ZodRawShape>> = {
+    name: string;
+    description?: string;
+    inputSchema: TInput;
+    nextTurnParams?: NextTurnParamsFunctions<z.infer<TInput>>;
+    execute: false;
+};
+/**
+ * Creates a tool with full type inference from Zod schemas.
+ *
+ * The tool type is automatically determined based on the configuration:
+ * - **Generator tool**: When `eventSchema` is provided
+ * - **Regular tool**: When `execute` is a function (no `eventSchema`)
+ * - **Manual tool**: When `execute: false` is set
+ *
+ * @example Regular tool:
+ * ```typescript
+ * const weatherTool = tool({
+ *   name: "get_weather",
+ *   description: "Get weather for a location",
+ *   inputSchema: z.object({ location: z.string() }),
+ *   outputSchema: z.object({ temperature: z.number() }),
+ *   execute: async (params) => {
+ *     // params is typed as { location: string }
+ *     return { temperature: 72 }; // return type is enforced
+ *   },
+ * });
+ * ```
+ *
+ * @example Generator tool (with eventSchema):
+ * ```typescript
+ * const progressTool = tool({
+ *   name: "process_data",
+ *   inputSchema: z.object({ data: z.string() }),
+ *   eventSchema: z.object({ progress: z.number() }),
+ *   outputSchema: z.object({ result: z.string() }),
+ *   execute: async function* (params) {
+ *     yield { progress: 50 }; // typed as event
+ *     yield { result: "done" }; // typed as output
+ *   },
+ * });
+ * ```
+ *
+ * @example Manual tool (execute: false):
+ * ```typescript
+ * const manualTool = tool({
+ *   name: "external_action",
+ *   inputSchema: z.object({ action: z.string() }),
+ *   execute: false,
+ * });
+ * ```
+ */
+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 {};
+//# sourceMappingURL=tool.d.ts.map

package/esm/lib/tool.js

@@ -0,0 +1,71 @@
+import { ToolType, } from "./tool-types.js";
+/**
+ * Type guard to check if config is a generator tool config (has eventSchema)
+ */
+function isGeneratorConfig(config) {
+    return "eventSchema" in config && config.eventSchema !== undefined;
+}
+/**
+ * Type guard to check if config is a manual tool config (execute === false)
+ */
+function isManualConfig(config) {
+    return config.execute === false;
+}
+// Implementation
+export function tool(config) {
+    // Check for manual tool first (execute === false)
+    if (isManualConfig(config)) {
+        const fn = {
+            name: config.name,
+            inputSchema: config.inputSchema,
+        };
+        if (config.description !== undefined) {
+            fn.description = config.description;
+        }
+        if (config.nextTurnParams !== undefined) {
+            fn.nextTurnParams = config.nextTurnParams;
+        }
+        return {
+            type: ToolType.Function,
+            function: fn,
+        };
+    }
+    // Check for generator tool (has eventSchema)
+    if (isGeneratorConfig(config)) {
+        const fn = {
+            name: config.name,
+            inputSchema: config.inputSchema,
+            eventSchema: config.eventSchema,
+            outputSchema: config.outputSchema,
+            // Types now align - config.execute matches the interface type
+            execute: config.execute,
+        };
+        if (config.description !== undefined) {
+            fn.description = config.description;
+        }
+        if (config.nextTurnParams !== undefined) {
+            fn.nextTurnParams = config.nextTurnParams;
+        }
+        return {
+            type: ToolType.Function,
+            function: fn,
+        };
+    }
+    // Regular tool (has execute function, no eventSchema)
+    // TypeScript can't infer the relationship between TReturn and TOutput
+    // So we build the object without type annotation, then return with correct type
+    const functionObj = {
+        name: config.name,
+        inputSchema: config.inputSchema,
+        execute: config.execute,
+        ...(config.description !== undefined && { description: config.description }),
+        ...(config.outputSchema !== undefined && { outputSchema: config.outputSchema }),
+        ...(config.nextTurnParams !== undefined && { nextTurnParams: config.nextTurnParams }),
+    };
+    // The function signature guarantees this is type-safe via overloads
+    return {
+        type: ToolType.Function,
+        function: functionObj,
+    };
+}
+//# sourceMappingURL=tool.js.map

package/esm/lib/turn-context.d.ts

@@ -0,0 +1,50 @@
+import * as models from '../models/index.js';
+import type { TurnContext } from './tool-types.js';
+/**
+ * Options for building a turn context
+ */
+export interface BuildTurnContextOptions {
+    /** Number of turns so far (1-indexed for tool execution, 0 for initial request) */
+    numberOfTurns: number;
+    /** The specific tool call being executed (optional for initial/async resolution contexts) */
+    toolCall?: models.OpenResponsesFunctionToolCall;
+    /** The full request being sent to the API (optional for initial/async resolution contexts) */
+    turnRequest?: models.OpenResponsesRequest;
+}
+/**
+ * Build a turn context for tool execution or async parameter resolution
+ *
+ * @param options - Options for building the context
+ * @returns A TurnContext object
+ *
+ * @example
+ * ```typescript
+ * // For tool execution with full context
+ * const context = buildTurnContext({
+ *   numberOfTurns: 1,
+ *   toolCall: rawToolCall,
+ *   turnRequest: currentRequest,
+ * });
+ *
+ * // For async parameter resolution (partial context)
+ * const context = buildTurnContext({
+ *   numberOfTurns: 0,
+ * });
+ * ```
+ */
+export declare function buildTurnContext(options: BuildTurnContextOptions): TurnContext;
+/**
+ * Normalize OpenResponsesInput to an array format
+ * Converts string input to array with single user message
+ *
+ * @param input - The input to normalize
+ * @returns Array format of the input
+ *
+ * @example
+ * ```typescript
+ * const arrayInput = normalizeInputToArray("Hello!");
+ * // Returns: [{ role: "user", content: "Hello!" }]
+ * ```
+ */
+export declare function normalizeInputToArray(input: models.OpenResponsesInput): Array<models.OpenResponsesInput1>;
+//# sourceMappingURL=turn-context.d.ts.map

package/esm/lib/turn-context.js

@@ -0,0 +1,59 @@
+import * as models from '../models/index.js';
+/**
+ * Build a turn context for tool execution or async parameter resolution
+ *
+ * @param options - Options for building the context
+ * @returns A TurnContext object
+ *
+ * @example
+ * ```typescript
+ * // For tool execution with full context
+ * const context = buildTurnContext({
+ *   numberOfTurns: 1,
+ *   toolCall: rawToolCall,
+ *   turnRequest: currentRequest,
+ * });
+ *
+ * // For async parameter resolution (partial context)
+ * const context = buildTurnContext({
+ *   numberOfTurns: 0,
+ * });
+ * ```
+ */
+export function buildTurnContext(options) {
+    const context = {
+        numberOfTurns: options.numberOfTurns,
+    };
+    if (options.toolCall !== undefined) {
+        context.toolCall = options.toolCall;
+    }
+    if (options.turnRequest !== undefined) {
+        context.turnRequest = options.turnRequest;
+    }
+    return context;
+}
+/**
+ * Normalize OpenResponsesInput to an array format
+ * Converts string input to array with single user message
+ *
+ * @param input - The input to normalize
+ * @returns Array format of the input
+ *
+ * @example
+ * ```typescript
+ * const arrayInput = normalizeInputToArray("Hello!");
+ * // Returns: [{ role: "user", content: "Hello!" }]
+ * ```
+ */
+export function normalizeInputToArray(input) {
+    if (typeof input === 'string') {
+        // Construct object with all required fields - type is optional
+        const message = {
+            role: models.OpenResponsesEasyInputMessageRoleUser.User,
+            content: input,
+        };
+        return [message];
+    }
+    return input;
+}
+//# sourceMappingURL=turn-context.js.map

package/esm/sdk/sdk.d.ts

@@ -12,13 +12,11 @@ import { Models } from "./models.js";
 import { OAuth } from "./oauth.js";
 import { ParametersT } from "./parameters.js";
 import { Providers } from "./providers.js";
+import { type CallModelInput } from "../funcs/call-model.js";
 import type { ModelResult } from "../lib/model-result.js";
 import type { RequestOptions } from "../lib/sdks.js";
-import { type MaxToolRounds, Tool, ToolType } from "../lib/tool-types.js";
-import type { OpenResponsesRequest } from "../models/openresponsesrequest.js";
-import type { OpenResponsesInput } from "../models/openresponsesinput.js";
+import { type Tool, ToolType } from "../lib/tool-types.js";
 export { ToolType };
-export type { MaxToolRounds };
 export declare class OpenRouter extends ClientSDK {
     private _beta?;
     get beta(): Beta;
@@ -46,10 +44,6 @@ export declare class OpenRouter extends ClientSDK {
     get chat(): Chat;
     private _completions?;
     get completions(): Completions;
-    callModel(request: Omit<OpenResponsesRequest, "stream" | "tools" | "input"> & {
-        input?: OpenResponsesInput;
-        tools?: Tool[];
-        maxToolRounds?: MaxToolRounds;
-    }, options?: RequestOptions): ModelResult;
+    callModel<TTools extends readonly Tool[]>(request: CallModelInput<TTools>, options?: RequestOptions): ModelResult<TTools>;
 }
 //# sourceMappingURL=sdk.d.ts.map

package/jsr.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openrouter/sdk",
-  "version": "0.3.7",
+  "version": "0.3.11",
   "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": [
@@ -67,10 +67,13 @@
   "scripts": {
     "lint": "eslint --cache --max-warnings=0 src",
     "build": "tsc",
-    "prepublishOnly": "npm run build"
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build",
+    "test": "vitest --run",
+    "test:watch": "vitest"
   },
   "peerDependencies": {
-    
+
   },
   "devDependencies": {
     "@eslint/js": "^9.19.0",