@openrouter/sdk 0.1.23 → 0.1.25

package/esm/funcs/callModel.d.ts

@@ -3,6 +3,14 @@ import { RequestOptions } from "../lib/sdks.js";
 import { ResponseWrapper } from "../lib/response-wrapper.js";
 import * as models from "../models/index.js";
 import { EnhancedTool, MaxToolRounds } from "../lib/tool-types.js";
+/**
+ * Input type that accepts both chat-style messages and responses-style input
+ */
+export type CallModelInput = models.OpenResponsesInput | models.Message[];
+/**
+ * Tool type that accepts chat-style, responses-style, or enhanced tools
+ */
+export type CallModelTools = EnhancedTool[] | models.ToolDefinitionJson[] | models.OpenResponsesRequest["tools"];
 /**
  * Get a response with multiple consumption patterns
  *
@@ -12,6 +20,7 @@ import { EnhancedTool, MaxToolRounds } from "../lib/tool-types.js";
  *
  * - `await response.getMessage()` - Get the completed message (tools auto-executed)
  * - `await response.getText()` - Get just the text content (tools auto-executed)
+ * - `await response.getResponse()` - Get full response with usage data (inputTokens, cachedTokens, etc.)
  * - `for await (const delta of response.getTextStream())` - Stream text deltas
  * - `for await (const delta of response.getReasoningStream())` - Stream reasoning deltas
  * - `for await (const event of response.getToolStream())` - Stream tool events (incl. preliminary results)
@@ -70,8 +79,9 @@ import { EnhancedTool, MaxToolRounds } from "../lib/tool-types.js";
  * }
  * ```
  */
-export declare function callModel(client: OpenRouterCore, request: Omit<models.OpenResponsesRequest, "stream" | "tools"> & {
-    tools?: EnhancedTool[] | models.OpenResponsesRequest["tools"];
+export declare function callModel(client: OpenRouterCore, request: Omit<models.OpenResponsesRequest, "stream" | "tools" | "input"> & {
+    input?: CallModelInput;
+    tools?: CallModelTools;
     maxToolRounds?: MaxToolRounds;
 }, options?: RequestOptions): ResponseWrapper;
 //# sourceMappingURL=callModel.d.ts.map

package/esm/funcs/callModel.js

@@ -1,5 +1,88 @@
 import { ResponseWrapper } from "../lib/response-wrapper.js";
 import { convertEnhancedToolsToAPIFormat } from "../lib/tool-executor.js";
+/**
+ * Check if input is chat-style messages (Message[])
+ */
+function isChatStyleMessages(input) {
+    if (!Array.isArray(input))
+        return false;
+    if (input.length === 0)
+        return false;
+    const first = input[0];
+    // Chat-style messages have role but no 'type' field at top level
+    // Responses-style items have 'type' field (like 'message', 'function_call', etc.)
+    return first && 'role' in first && !('type' in first);
+}
+/**
+ * Check if tools are chat-style (ToolDefinitionJson[])
+ */
+function isChatStyleTools(tools) {
+    if (!Array.isArray(tools))
+        return false;
+    if (tools.length === 0)
+        return false;
+    const first = tools[0];
+    // Chat-style tools have nested 'function' property with 'name' inside
+    // Enhanced tools have 'function' with 'inputSchema'
+    // Responses-style tools have 'name' at top level
+    return first && 'function' in first && first.function && 'name' in first.function && !('inputSchema' in first.function);
+}
+/**
+ * Convert chat-style tools to responses-style
+ */
+function convertChatToResponsesTools(tools) {
+    return tools.map((tool) => ({
+        type: "function",
+        name: tool.function.name,
+        description: tool.function.description ?? null,
+        strict: tool.function.strict ?? null,
+        parameters: tool.function.parameters ?? null,
+    }));
+}
+/**
+ * Convert chat-style messages to responses-style input
+ */
+function convertChatToResponsesInput(messages) {
+    return messages.map((msg) => {
+        // Extract extra fields like cache_control
+        const { role, content, ...extraFields } = msg;
+        if (role === "tool") {
+            const toolMsg = msg;
+            return {
+                type: "function_call_output",
+                callId: toolMsg.toolCallId,
+                output: typeof toolMsg.content === "string" ? toolMsg.content : JSON.stringify(toolMsg.content),
+                ...extraFields,
+            };
+        }
+        // Handle assistant messages with tool calls
+        if (role === "assistant") {
+            const assistantMsg = msg;
+            // If it has tool calls, we need to convert them
+            // For now, just convert the content part
+            return {
+                role: "assistant",
+                content: typeof assistantMsg.content === "string"
+                    ? assistantMsg.content
+                    : assistantMsg.content === null
+                        ? ""
+                        : JSON.stringify(assistantMsg.content),
+                ...extraFields,
+            };
+        }
+        // System, user, developer messages
+        const convertedContent = typeof content === "string"
+            ? content
+            : content === null || content === undefined
+                ? ""
+                : JSON.stringify(content);
+        return {
+            role: role,
+            content: convertedContent,
+            ...extraFields,
+        };
+    });
+}
 /**
  * Get a response with multiple consumption patterns
  *
@@ -9,6 +92,7 @@ import { convertEnhancedToolsToAPIFormat } from "../lib/tool-executor.js";
  *
  * - `await response.getMessage()` - Get the completed message (tools auto-executed)
  * - `await response.getText()` - Get just the text content (tools auto-executed)
+ * - `await response.getResponse()` - Get full response with usage data (inputTokens, cachedTokens, etc.)
  * - `for await (const delta of response.getTextStream())` - Stream text deltas
  * - `for await (const delta of response.getReasoningStream())` - Stream reasoning deltas
  * - `for await (const event of response.getToolStream())` - Stream tool events (incl. preliminary results)
@@ -68,16 +152,35 @@ import { convertEnhancedToolsToAPIFormat } from "../lib/tool-executor.js";
  * ```
  */
 export function callModel(client, request, options) {
-    const { tools, maxToolRounds, ...apiRequest } = request;
-    // Separate enhanced tools from API tools
+    const { tools, maxToolRounds, input, ...restRequest } = request;
+    // Convert chat-style messages to responses-style input if needed
+    const convertedInput = input && isChatStyleMessages(input)
+        ? convertChatToResponsesInput(input)
+        : input;
+    const apiRequest = {
+        ...restRequest,
+        input: convertedInput,
+    };
+    // Determine tool type and convert as needed
     let isEnhancedTools = false;
-    if (tools && tools.length > 0) {
+    let isChatTools = false;
+    if (tools && Array.isArray(tools) && tools.length > 0) {
         const firstTool = tools[0];
         isEnhancedTools = "function" in firstTool && firstTool.function && "inputSchema" in firstTool.function;
+        isChatTools = !isEnhancedTools && isChatStyleTools(tools);
     }
     const enhancedTools = isEnhancedTools ? tools : undefined;
-    // Convert enhanced tools to API format if provided, otherwise use tools as-is
-    const apiTools = enhancedTools ? convertEnhancedToolsToAPIFormat(enhancedTools) : tools;
+    // Convert tools to API format based on their type
+    let apiTools;
+    if (enhancedTools) {
+        apiTools = convertEnhancedToolsToAPIFormat(enhancedTools);
+    }
+    else if (isChatTools) {
+        apiTools = convertChatToResponsesTools(tools);
+    }
+    else {
+        apiTools = tools;
+    }
     // Build the request with converted tools
     const finalRequest = {
         ...apiRequest,

package/esm/lib/config.d.ts

@@ -45,8 +45,8 @@ export declare function serverURLFromOptions(options: SDKOptions): URL | null;
 export declare const SDK_METADATA: {
     readonly language: "typescript";
     readonly openapiDocVersion: "1.0.0";
-    readonly sdkVersion: "0.1.23";
-    readonly genVersion: "2.755.9";
-    readonly userAgent: "speakeasy-sdk/typescript 0.1.23 2.755.9 1.0.0 @openrouter/sdk";
+    readonly sdkVersion: "0.1.25";
+    readonly genVersion: "2.760.2";
+    readonly userAgent: "speakeasy-sdk/typescript 0.1.25 2.760.2 1.0.0 @openrouter/sdk";
 };
 //# sourceMappingURL=config.d.ts.map

package/esm/lib/config.js

@@ -25,8 +25,8 @@ export function serverURLFromOptions(options) {
 export const SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.0.0",
-    sdkVersion: "0.1.23",
-    genVersion: "2.755.9",
-    userAgent: "speakeasy-sdk/typescript 0.1.23 2.755.9 1.0.0 @openrouter/sdk",
+    sdkVersion: "0.1.25",
+    genVersion: "2.760.2",
+    userAgent: "speakeasy-sdk/typescript 0.1.25 2.760.2 1.0.0 @openrouter/sdk",
 };
 //# sourceMappingURL=config.js.map

package/esm/lib/response-wrapper.d.ts

@@ -55,6 +55,12 @@ export declare class ResponseWrapper {
      * This will consume the stream until completion, execute any tools, and extract the text.
      */
     getText(): Promise<string>;
+    /**
+     * Get the complete response object including usage information.
+     * This will consume the stream until completion and execute any tools.
+     * Returns the full OpenResponsesNonStreamingResponse with usage data (inputTokens, outputTokens, cachedTokens, etc.)
+     */
+    getResponse(): Promise<models.OpenResponsesNonStreamingResponse>;
     /**
      * Stream all response events as they arrive.
      * Multiple consumers can iterate over this stream concurrently.

package/esm/lib/response-wrapper.js

@@ -228,6 +228,18 @@ export class ResponseWrapper {
         })();
         return this.textPromise;
     }
+    /**
+     * Get the complete response object including usage information.
+     * This will consume the stream until completion and execute any tools.
+     * Returns the full OpenResponsesNonStreamingResponse with usage data (inputTokens, outputTokens, cachedTokens, etc.)
+     */
+    async getResponse() {
+        await this.executeToolsIfNeeded();
+        if (!this.finalResponse) {
+            throw new Error("Response not available");
+        }
+        return this.finalResponse;
+    }
     /**
      * Stream all response events as they arrive.
      * Multiple consumers can iterate over this stream concurrently.

package/esm/models/chatstreamingresponsechunk.js

@@ -40,7 +40,8 @@ export const ChatStreamingResponseChunk$inboundSchema = z.object({
         }
         catch (err) {
             ctx.addIssue({
-                code: z.ZodIssueCode.custom,
+                input: v,
+                code: "custom",
                 message: `malformed json: ${err}`,
             });
             return z.NEVER;

package/esm/models/operations/createresponses.js

@@ -13,7 +13,8 @@ export const CreateResponsesResponseBody$inboundSchema = z.object({
         }
         catch (err) {
             ctx.addIssue({
-                code: z.ZodIssueCode.custom,
+                input: v,
+                code: "custom",
                 message: `malformed json: ${err}`,
             });
             return z.NEVER;

package/esm/sdk/sdk.d.ts

@@ -45,8 +45,9 @@ export declare class OpenRouter extends ClientSDK {
     get chat(): Chat;
     private _completions?;
     get completions(): Completions;
-    callModel(request: Omit<models.OpenResponsesRequest, "stream" | "tools"> & {
-        tools?: EnhancedTool[] | models.OpenResponsesRequest["tools"];
+    callModel(request: Omit<models.OpenResponsesRequest, "stream" | "tools" | "input"> & {
+        input?: import("../funcs/callModel.js").CallModelInput;
+        tools?: import("../funcs/callModel.js").CallModelTools;
         maxToolRounds?: MaxToolRounds;
     }, options?: RequestOptions): ResponseWrapper;
 }

package/esm/types/enums.d.ts

@@ -1,16 +1,9 @@
 import * as z from "zod/v4";
-declare const __brand: unique symbol;
-export type Unrecognized<T> = T & {
-    [__brand]: "unrecognized";
-};
+import { Unrecognized } from "./unrecognized.js";
 export type ClosedEnum<T extends Readonly<Record<string, string | number>>> = T[keyof T];
 export type OpenEnum<T extends Readonly<Record<string, string | number>>> = T[keyof T] | Unrecognized<T[keyof T] extends number ? number : string>;
-export declare function unrecognizedCounter(): {
-    count: () => number;
-};
 export declare function inboundSchema<T extends Record<string, string>>(enumObj: T): z.ZodType<OpenEnum<T>, unknown>;
 export declare function inboundSchemaInt<T extends Record<string, number | string>>(enumObj: T): z.ZodType<OpenEnum<T>, unknown>;
 export declare function outboundSchema<T extends Record<string, string>>(_: T): z.ZodType<string, OpenEnum<T>>;
 export declare function outboundSchemaInt<T extends Record<string, number | string>>(_: T): z.ZodType<number, OpenEnum<T>>;
-export {};
 //# sourceMappingURL=enums.d.ts.map

package/esm/types/enums.js

@@ -2,24 +2,7 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 import * as z from "zod/v4";
-function unrecognized(value) {
-    unrecognizedCount++;
-    return value;
-}
-let unrecognizedCount = 0;
-let refCount = 0;
-export function unrecognizedCounter() {
-    refCount++;
-    const start = unrecognizedCount;
-    return {
-        count: () => {
-            const count = unrecognizedCount - start;
-            if (--refCount === 0)
-                unrecognizedCount = 0;
-            return count;
-        },
-    };
-}
+import { unrecognized } from "./unrecognized.js";
 export function inboundSchema(enumObj) {
     const options = Object.values(enumObj);
     return z.union([

package/esm/types/index.d.ts

@@ -1,7 +1,8 @@
 export { blobLikeSchema, isBlobLike } from "./blobs.js";
-export type { ClosedEnum, OpenEnum, Unrecognized } from "./enums.js";
+export type { ClosedEnum, OpenEnum } from "./enums.js";
 export type { Result } from "./fp.js";
 export type { PageIterator, Paginator } from "./operations.js";
 export { createPageIterator } from "./operations.js";
 export { RFCDate } from "./rfcdate.js";
+export * from "./unrecognized.js";
 //# sourceMappingURL=index.d.ts.map

package/esm/types/index.js

@@ -4,4 +4,5 @@
 export { blobLikeSchema, isBlobLike } from "./blobs.js";
 export { createPageIterator } from "./operations.js";
 export { RFCDate } from "./rfcdate.js";
+export * from "./unrecognized.js";
 //# sourceMappingURL=index.js.map

package/esm/types/unrecognized.d.ts

@@ -0,0 +1,10 @@
+declare const __brand: unique symbol;
+export type Unrecognized<T> = T & {
+    [__brand]: "unrecognized";
+};
+declare function unrecognized<T>(value: T): Unrecognized<T>;
+export declare function startCountingUnrecognized(): {
+    end: () => number;
+};
+export { unrecognized };
+//# sourceMappingURL=unrecognized.d.ts.map

package/esm/types/unrecognized.js

@@ -0,0 +1,23 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+function unrecognized(value) {
+    globalCount++;
+    return value;
+}
+let globalCount = 0;
+let refCount = 0;
+export function startCountingUnrecognized() {
+    refCount++;
+    const start = globalCount;
+    return {
+        end: () => {
+            const count = globalCount - start;
+            if (--refCount === 0)
+                globalCount = 0;
+            return count;
+        },
+    };
+}
+export { unrecognized };
+//# sourceMappingURL=unrecognized.js.map

package/jsr.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openrouter/sdk",
-  "version": "0.1.23",
+  "version": "0.1.25",
   "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": [