@openrouter/sdk 0.1.25 → 0.2.6

package/biome.json

@@ -0,0 +1,171 @@
+{
+  "$schema": "https://biomejs.dev/schemas/2.3.8/schema.json",
+  "vcs": {
+    "enabled": true,
+    "clientKind": "git",
+    "useIgnoreFile": true,
+    "defaultBranch": "main"
+  },
+  "files": {
+    "ignoreUnknown": false,
+    "includes": [
+      "**",
+      "./.vscode/extensions/**",
+      "!**/*.json",
+      "!**/*.test.ts.snap",
+      "!**/logger.ts"
+    ]
+  },
+  "formatter": {
+    "enabled": true,
+    "indentStyle": "space",
+    "indentWidth": 2,
+    "lineWidth": 100,
+    "expand": "always",
+    "attributePosition": "multiline"
+  },
+  "assist": {
+    "actions": {
+      "source": {
+        "organizeImports": {
+          "level": "on",
+          "options": {
+            "groups": [
+              {
+                "type": true
+              },
+              ":BLANK_LINE:",
+              {
+                "type": false
+              },
+              [
+                ":NODE:"
+              ],
+              ":BLANK_LINE:",
+              [
+                "!@openrouter-monorepo/**"
+              ],
+              ":BLANK_LINE:",
+              [
+                "@openrouter-monorepo/**",
+                "@/**"
+              ],
+              ":BLANK_LINE:",
+              ":ALIAS:"
+            ]
+          }
+        }
+      }
+    }
+  },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true,
+      "nursery": {
+        "noFloatingPromises": "off"
+      },
+      "a11y": {
+        "useSemanticElements": "off"
+      },
+      "complexity": {
+        "useLiteralKeys": "off",
+        "noExtraBooleanCast": "off",
+        "noForEach": "off",
+        "noBannedTypes": "error",
+        "noUselessSwitchCase": "off"
+      },
+      "style": {
+        "noNonNullAssertion": "off",
+        "useNodejsImportProtocol": "error",
+        "useTemplate": "off",
+        "useBlockStatements": "error",
+        "noParameterAssign": "error",
+        "useConst": "error",
+        "useAsConstAssertion": "error",
+        "useDefaultParameterLast": "error",
+        "useEnumInitializers": "error",
+        "useSelfClosingElements": "error",
+        "useSingleVarDeclarator": "error",
+        "noUnusedTemplateLiteral": "error",
+        "useNumberNamespace": "error",
+        "noInferrableTypes": "error",
+        "noUselessElse": "error",
+        "useImportType": {
+          "level": "on",
+          "options": {
+            "style": "separatedType"
+          }
+        },
+        "noRestrictedImports": {
+          "level": "error",
+          "options": {
+            "paths": {
+              "node:module": "Don't use `node:module`. Did you mean to import `wrap` from our `@openrouter-monorepo/type-utils/result-monad` package?",
+              "crypto": "Use `node:crypto` instead of `crypto` to follow the Node.js import protocol."
+            }
+          }
+        }
+      },
+      "correctness": {
+        "noUnusedImports": "error",
+        "useExhaustiveDependencies": "off",
+        "noUnknownFunction": "off",
+        "noChildrenProp": "off",
+        "noInnerDeclarations": "error",
+        "useParseIntRadix": "error"
+      },
+      "suspicious": {
+        "noExplicitAny": "warn",
+        "noArrayIndexKey": "off",
+        "noAssignInExpressions": "error",
+        "noAsyncPromiseExecutor": "off",
+        "noFallthroughSwitchClause": "error",
+        "noConsole": "error",
+        "noDoubleEquals": {
+          "level": "error",
+          "options": {
+            "ignoreNull": false
+          }
+        },
+        "noExtraNonNullAssertion": "error",
+        "noUnknownAtRules": "off"
+      },
+      "performance": {
+        "recommended": true,
+        "noAccumulatingSpread": "error"
+      },
+      "security": {
+        "recommended": true
+      }
+    },
+    "includes": [
+      "**",
+      "!**/*.test.ts.snap"
+    ]
+  },
+  "javascript": {
+    "formatter": {
+      "expand": "always",
+      "lineWidth": 100,
+      "arrowParentheses": "always",
+      "jsxQuoteStyle": "single",
+      "attributePosition": "multiline",
+      "quoteProperties": "asNeeded",
+      "trailingCommas": "all",
+      "semicolons": "always",
+      "bracketSpacing": true,
+      "bracketSameLine": false,
+      "quoteStyle": "single",
+      "enabled": true
+    }
+  },
+  "css": {
+    "parser": {
+      "tailwindDirectives": true
+    },
+    "formatter": {
+      "quoteStyle": "single"
+    }
+  }
+}

package/esm/funcs/callModel.d.ts

@@ -1,8 +1,8 @@
-import { OpenRouterCore } from "../core.js";
-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";
+import type { OpenRouterCore } from '../core.js';
+import type { RequestOptions } from '../lib/sdks.js';
+import type { Tool, MaxToolRounds } from '../lib/tool-types.js';
+import type * as models from '../models/index.js';
+import { ResponseWrapper } from '../lib/response-wrapper.js';
 /**
  * Input type that accepts both chat-style messages and responses-style input
  */
@@ -10,7 +10,7 @@ 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"];
+export type CallModelTools = Tool[] | models.ToolDefinitionJson[] | models.OpenResponsesRequest['tools'];
 /**
  * Get a response with multiple consumption patterns
  *
@@ -79,7 +79,7 @@ export type CallModelTools = EnhancedTool[] | models.ToolDefinitionJson[] | mode
  * }
  * ```
  */
-export declare function callModel(client: OpenRouterCore, request: Omit<models.OpenResponsesRequest, "stream" | "tools" | "input"> & {
+export declare function callModel(client: OpenRouterCore, request: Omit<models.OpenResponsesRequest, 'stream' | 'tools' | 'input'> & {
     input?: CallModelInput;
     tools?: CallModelTools;
     maxToolRounds?: MaxToolRounds;

package/esm/funcs/callModel.js

@@ -1,13 +1,15 @@
-import { ResponseWrapper } from "../lib/response-wrapper.js";
-import { convertEnhancedToolsToAPIFormat } from "../lib/tool-executor.js";
+import { ResponseWrapper } from '../lib/response-wrapper.js';
+import { convertToolsToAPIFormat } from '../lib/tool-executor.js';
 /**
  * Check if input is chat-style messages (Message[])
  */
 function isChatStyleMessages(input) {
-    if (!Array.isArray(input))
+    if (!Array.isArray(input)) {
         return false;
-    if (input.length === 0)
+    }
+    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.)
@@ -17,22 +19,30 @@ function isChatStyleMessages(input) {
  * Check if tools are chat-style (ToolDefinitionJson[])
  */
 function isChatStyleTools(tools) {
-    if (!Array.isArray(tools))
+    if (!Array.isArray(tools)) {
         return false;
-    if (tools.length === 0)
+    }
+    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);
+    const fn = first?.['function'];
+    return (first &&
+        'function' in first &&
+        fn !== undefined &&
+        fn !== null &&
+        'name' in fn &&
+        !('inputSchema' in fn));
 }
 /**
  * Convert chat-style tools to responses-style
  */
 function convertChatToResponsesTools(tools) {
     return tools.map((tool) => ({
-        type: "function",
+        type: 'function',
         name: tool.function.name,
         description: tool.function.description ?? null,
         strict: tool.function.strict ?? null,
@@ -46,35 +56,35 @@ function convertChatToResponsesInput(messages) {
     return messages.map((msg) => {
         // Extract extra fields like cache_control
         const { role, content, ...extraFields } = msg;
-        if (role === "tool") {
+        if (role === 'tool') {
             const toolMsg = msg;
             return {
-                type: "function_call_output",
+                type: 'function_call_output',
                 callId: toolMsg.toolCallId,
-                output: typeof toolMsg.content === "string" ? toolMsg.content : JSON.stringify(toolMsg.content),
+                output: typeof toolMsg.content === 'string' ? toolMsg.content : JSON.stringify(toolMsg.content),
                 ...extraFields,
             };
         }
         // Handle assistant messages with tool calls
-        if (role === "assistant") {
+        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"
+                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"
+        const convertedContent = typeof content === 'string'
             ? content
             : content === null || content === undefined
-                ? ""
+                ? ''
                 : JSON.stringify(content);
         return {
             role: role,
@@ -154,9 +164,7 @@ function convertChatToResponsesInput(messages) {
 export function callModel(client, request, options) {
     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 convertedInput = input && isChatStyleMessages(input) ? convertChatToResponsesInput(input) : input;
     const apiRequest = {
         ...restRequest,
         input: convertedInput,
@@ -166,14 +174,16 @@ export function callModel(client, request, options) {
     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;
+        const fn = firstTool?.['function'];
+        isEnhancedTools =
+            'function' in firstTool && fn !== undefined && fn !== null && 'inputSchema' in fn;
         isChatTools = !isEnhancedTools && isChatStyleTools(tools);
     }
     const enhancedTools = isEnhancedTools ? tools : undefined;
     // Convert tools to API format based on their type
     let apiTools;
     if (enhancedTools) {
-        apiTools = convertEnhancedToolsToAPIFormat(enhancedTools);
+        apiTools = convertToolsToAPIFormat(enhancedTools);
     }
     else if (isChatTools) {
         apiTools = convertChatToResponsesTools(tools);
@@ -184,7 +194,9 @@ export function callModel(client, request, options) {
     // Build the request with converted tools
     const finalRequest = {
         ...apiRequest,
-        ...(apiTools && { tools: apiTools }),
+        ...(apiTools && {
+            tools: apiTools,
+        }),
     };
     const wrapperOptions = {
         client,

package/esm/funcs/oAuthCreateAuthorizationUrl.d.ts

@@ -1,6 +1,6 @@
-import z from "zod/v3";
-import { OpenRouterCore } from "../core.js";
-import { Result } from "../types/fp.js";
+import type { OpenRouterCore } from '../core.js';
+import type { Result } from '../types/fp.js';
+import z from 'zod/v3';
 declare const CreateAuthorizationurlParamsSchema: z.ZodUnion<[z.ZodObject<{
     callbackUrl: z.ZodUnion<[z.ZodString, z.ZodType<URL, z.ZodTypeDef, URL>]>;
     limit: z.ZodOptional<z.ZodNumber>;

package/esm/funcs/oAuthCreateAuthorizationUrl.js

@@ -1,12 +1,18 @@
-import z from "zod/v3";
-import { serverURLFromOptions } from "../lib/config.js";
+import z from 'zod/v3';
+import { serverURLFromOptions } from '../lib/config.js';
 const CreateAuthorizationUrlBaseSchema = z.object({
-    callbackUrl: z.union([z.string().url(), z.instanceof(URL)]),
+    callbackUrl: z.union([
+        z.string().url(),
+        z.instanceof(URL),
+    ]),
     limit: z.number().optional(),
 });
 const CreateAuthorizationurlParamsSchema = z.union([
     CreateAuthorizationUrlBaseSchema.extend({
-        codeChallengeMethod: z.enum(["S256", "plain"]),
+        codeChallengeMethod: z.enum([
+            'S256',
+            'plain',
+        ]),
         codeChallenge: z.string(),
     }),
     CreateAuthorizationUrlBaseSchema,
@@ -23,22 +29,32 @@ const CreateAuthorizationurlParamsSchema = z.union([
  */
 export function oAuthCreateAuthorizationUrl(client, params) {
     const parsedParams = CreateAuthorizationurlParamsSchema.safeParse(params);
-    if (!parsedParams.success)
-        return { ok: false, error: parsedParams.error };
+    if (!parsedParams.success) {
+        return {
+            ok: false,
+            error: parsedParams.error,
+        };
+    }
     const baseURL = serverURLFromOptions(client._options);
     if (!baseURL) {
-        return { ok: false, error: new Error("No server URL configured") };
+        return {
+            ok: false,
+            error: new Error('No server URL configured'),
+        };
     }
     // Clone the URL to avoid mutating the original
-    const authURL = new URL("/auth", baseURL);
-    authURL.searchParams.set("callback_url", parsedParams.data.callbackUrl.toString());
-    if ("codeChallengeMethod" in parsedParams.data) {
-        authURL.searchParams.set("code_challenge", parsedParams.data.codeChallenge);
-        authURL.searchParams.set("code_challenge_method", parsedParams.data.codeChallengeMethod);
+    const authURL = new URL('/auth', baseURL);
+    authURL.searchParams.set('callback_url', parsedParams.data.callbackUrl.toString());
+    if ('codeChallengeMethod' in parsedParams.data) {
+        authURL.searchParams.set('code_challenge', parsedParams.data.codeChallenge);
+        authURL.searchParams.set('code_challenge_method', parsedParams.data.codeChallengeMethod);
     }
     if (parsedParams.data.limit !== undefined) {
-        authURL.searchParams.set("limit", parsedParams.data.limit.toString());
+        authURL.searchParams.set('limit', parsedParams.data.limit.toString());
     }
-    return { ok: true, value: authURL.toString() };
+    return {
+        ok: true,
+        value: authURL.toString(),
+    };
 }
 //# sourceMappingURL=oAuthCreateAuthorizationUrl.js.map

package/esm/funcs/oAuthCreateSHA256CodeChallenge.d.ts

@@ -1,5 +1,5 @@
-import z from "zod/v3";
-import { Result } from "../types/fp.js";
+import type { Result } from '../types/fp.js';
+import z from 'zod/v3';
 declare const CreateSHA256CodeChallengeRequestSchema: z.ZodObject<{
     /**
      * If not provided, a random code verifier will be generated.

package/esm/funcs/oAuthCreateSHA256CodeChallenge.js

@@ -1,4 +1,4 @@
-import z from "zod/v3";
+import z from 'zod/v3';
 const CreateSHA256CodeChallengeRequestSchema = z.object({
     /**
      * If not provided, a random code verifier will be generated.
@@ -7,23 +7,20 @@ const CreateSHA256CodeChallengeRequestSchema = z.object({
      */
     codeVerifier: z
         .string()
-        .min(43, "Code verifier must be at least 43 characters")
-        .max(128, "Code verifier must be at most 128 characters")
-        .regex(/^[A-Za-z0-9\-._~]+$/, "Code verifier must only contain unreserved characters: [A-Za-z0-9-._~]")
+        .min(43, 'Code verifier must be at least 43 characters')
+        .max(128, 'Code verifier must be at most 128 characters')
+        .regex(/^[A-Za-z0-9\-._~]+$/, 'Code verifier must only contain unreserved characters: [A-Za-z0-9-._~]')
         .optional(),
 });
 /**
  * Convert a Uint8Array to base64url encoding (RFC 4648)
  */
 function arrayBufferToBase64Url(buffer) {
-    let binary = "";
+    let binary = '';
     for (let i = 0; i < buffer.length; i++) {
         binary += String.fromCharCode(buffer[i]);
     }
-    return btoa(binary)
-        .replace(/\+/g, "-")
-        .replace(/\//g, "_")
-        .replace(/=+$/, "");
+    return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
 }
 /**
  * Generate a cryptographically random code verifier per RFC 7636
@@ -48,13 +45,17 @@ function generateCodeVerifier() {
  */
 export async function oAuthCreateSHA256CodeChallenge(params = {}) {
     const parsedParams = CreateSHA256CodeChallengeRequestSchema.safeParse(params);
-    if (!parsedParams.success)
-        return { ok: false, error: parsedParams.error };
+    if (!parsedParams.success) {
+        return {
+            ok: false,
+            error: parsedParams.error,
+        };
+    }
     const { codeVerifier = generateCodeVerifier() } = parsedParams.data;
     // Generate SHA-256 hash
     const encoder = new TextEncoder();
     const data = encoder.encode(codeVerifier);
-    const hash = await crypto.subtle.digest("SHA-256", data);
+    const hash = await crypto.subtle.digest('SHA-256', data);
     // Convert hash to base64url
     const hashArray = new Uint8Array(hash);
     const codeChallenge = arrayBufferToBase64Url(hashArray);

package/esm/hooks/registration.d.ts

@@ -1,3 +1,3 @@
-import { Hooks } from "./types.js";
-export declare function initHooks(hooks: Hooks): void;
+import type { Hooks } from './types.js';
+export declare function initHooks(_hooks: Hooks): void;
 //# sourceMappingURL=registration.d.ts.map

package/esm/hooks/registration.js

@@ -3,8 +3,7 @@
  * Any hooks you wish to add should be registered in the initHooks function. Feel free to define them
  * in this file or in separate files in the hooks folder.
  */
-// @ts-expect-error remove this line when you add your first hook and hooks is used
-export function initHooks(hooks) {
+export function initHooks(_hooks) {
     // Add hooks by calling hooks.register{ClientInit/BeforeCreateRequest/BeforeRequest/AfterSuccess/AfterError}Hook
     // with an instance of a hook that implements that specific Hook interface
     // Hooks are registered per SDK instance, and are valid for the lifetime of the SDK instance

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.25";
-    readonly genVersion: "2.760.2";
-    readonly userAgent: "speakeasy-sdk/typescript 0.1.25 2.760.2 1.0.0 @openrouter/sdk";
+    readonly sdkVersion: "0.2.6";
+    readonly genVersion: "2.768.0";
+    readonly userAgent: "speakeasy-sdk/typescript 0.2.6 2.768.0 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.25",
-    genVersion: "2.760.2",
-    userAgent: "speakeasy-sdk/typescript 0.1.25 2.760.2 1.0.0 @openrouter/sdk",
+    sdkVersion: "0.2.6",
+    genVersion: "2.768.0",
+    userAgent: "speakeasy-sdk/typescript 0.2.6 2.768.0 1.0.0 @openrouter/sdk",
 };
 //# sourceMappingURL=config.js.map

package/esm/lib/encodings.d.ts

@@ -38,6 +38,7 @@ export declare function queryJoin(...args: (string | undefined)[]): string;
 type QueryEncoderOptions = {
     explode?: boolean;
     charEncoding?: "percent" | "none";
+    allowEmptyValue?: string[];
 };
 type QueryEncoder = (key: string, value: unknown, options?: QueryEncoderOptions) => string | undefined;
 type BulkQueryEncoder = (values: Record<string, unknown>, options?: QueryEncoderOptions) => string;

package/esm/lib/encodings.js

@@ -83,7 +83,9 @@ export function encodeLabel(key, value, options) {
             encValue = mapped?.join("").slice(1);
         }
         else {
-            const k = options?.explode && isPlainObject(value) ? `${encodeString(pk)}=` : "";
+            const k = options?.explode && isPlainObject(value)
+                ? `${encodeString(pk)}=`
+                : "";
             encValue = `${k}${encodeValue(pv)}`;
         }
         out += encValue == null ? "" : `.${encValue}`;
@@ -325,7 +327,16 @@ export function queryEncoder(f) {
             explode: options?.explode ?? true,
             charEncoding: options?.charEncoding ?? "percent",
         };
+        const allowEmptySet = new Set(options?.allowEmptyValue ?? []);
         const encoded = Object.entries(values).map(([key, value]) => {
+            if (allowEmptySet.has(key)) {
+                if (value === undefined
+                    || value === null
+                    || value === ""
+                    || (Array.isArray(value) && value.length === 0)) {
+                    return `${encodeURIComponent(key)}=`;
+                }
+            }
             return f(key, value, opts);
         });
         return queryJoin(...encoded);

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

@@ -1,12 +1,12 @@
-import { OpenRouterCore } from "../core.js";
-import { RequestOptions } from "./sdks.js";
-import * as models from "../models/index.js";
-import { EnhancedTool, ParsedToolCall, MaxToolRounds, EnhancedResponseStreamEvent, ToolStreamEvent, ChatStreamEvent } from "./tool-types.js";
+import type { OpenRouterCore } from '../core.js';
+import type * as models from '../models/index.js';
+import type { RequestOptions } from './sdks.js';
+import type { ChatStreamEvent, EnhancedResponseStreamEvent, Tool, MaxToolRounds, ParsedToolCall, ToolStreamEvent } from './tool-types.js';
 export interface GetResponseOptions {
     request: models.OpenResponsesRequest;
     client: OpenRouterCore;
     options?: RequestOptions;
-    tools?: EnhancedTool[];
+    tools?: Tool[];
     maxToolRounds?: MaxToolRounds;
 }
 /**