@openrouter/sdk 0.3.7 → 0.3.10

package/esm/lib/tool.d.ts

@@ -0,0 +1,99 @@
+import type { ZodObject, ZodRawShape, ZodType, z } from "zod/v4";
+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.9",
   "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.10",
   "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",