@openrouter/sdk 0.3.14 → 0.3.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openrouter/sdk",
-  "version": "0.3.14",
+  "version": "0.3.15",
   "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": [
@@ -64,15 +64,17 @@
     "type": "git",
     "url": "https://github.com/OpenRouterTeam/typescript-sdk.git"
   },
-  "scripts": {
-    "lint": "eslint --cache --max-warnings=0 src",
-    "build": "tsc",
-    "typecheck": "tsc --noEmit",
-    "prepublishOnly": "npm run build",
-    "test": "vitest --run --project unit",
-    "test:e2e": "vitest --run --project e2e",
-    "test:watch": "vitest --watch --project unit"
-  },
+    "scripts": {
+      "lint": "eslint --cache --max-warnings=0 src",
+      "build": "tsc",
+      "typecheck": "tsc --noEmit",
+      "prepublishOnly": "npm run build",
+      "postinstall": "node scripts/check-types.js || true",
+      "test": "vitest --run --project unit",
+      "test:e2e": "vitest --run --project e2e",
+      "test:watch": "vitest --watch --project unit"
+    },
+  "peerDependencies": {},
   "devDependencies": {
     "@eslint/js": "^9.19.0",
     "@types/node": "^22.13.12",

package/scripts/check-types.js

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+/**
+ * Postinstall script to check if model types are stale.
+ * Similar to update-browserslist-db, this warns users when their
+ * generated types are outdated.
+ *
+ * This script:
+ * 1. Reads the MODEL_HASH from the generated types file
+ * 2. Fetches current models from the OpenRouter API
+ * 3. Computes a hash of the current models
+ * 4. Warns to stderr if the hashes don't match
+ *
+ * Exit codes:
+ * - 0: Types are up to date OR check was skipped
+ * - Does NOT fail on stale types (to avoid breaking installs)
+ */
+
+import { createHash } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { dirname, resolve } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const TYPES_FILE_PATH = resolve(__dirname, '../src/types/models.ts');
+const API_URL = 'https://openrouter.ai/api/v1/models';
+const TIMEOUT_MS = 5000;
+
+/**
+ * Type guard for Node.js errors with error codes
+ * @param {unknown} error
+ * @returns {error is NodeJS.ErrnoException}
+ */
+function isNodeError(error) {
+  return error instanceof Error && 'code' in error;
+}
+
+/**
+ * Compute SHA-256 hash of sorted model IDs (first 16 chars)
+ * @param {string[]} modelIds
+ * @returns {string}
+ */
+function computeHash(modelIds) {
+  const sorted = [...modelIds].sort();
+  const content = sorted.join('\n');
+  const hash = createHash('sha256').update(content).digest('hex');
+  return hash.substring(0, 16);
+}
+
+/**
+ * Extract MODEL_HASH from types file content
+ * @param {string} content
+ * @returns {string | null}
+ */
+function extractHash(content) {
+  const match = content.match(/export const MODEL_HASH = '([a-f0-9]+)'/);
+  return match ? match[1] : null;
+}
+
+/**
+ * Fetch models from API with timeout
+ * @returns {Promise<string[]>}
+ */
+async function fetchModels() {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), TIMEOUT_MS);
+
+  try {
+    const response = await fetch(API_URL, { signal: controller.signal });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    if (!data?.data || !Array.isArray(data.data)) {
+      throw new Error('Invalid API response structure');
+    }
+    return data.data.map((m) => m.id);
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+async function main() {
+  if (process.env.CI) {
+    return;
+  }
+
+  if (process.env.OPENROUTER_SKIP_TYPE_CHECK) {
+    return;
+  }
+
+  try {
+    /** @type {string | null} */
+    let existingHash;
+    try {
+      const content = await readFile(TYPES_FILE_PATH, 'utf-8');
+      existingHash = extractHash(content);
+    } catch (error) {
+      if (isNodeError(error) && error.code === 'ENOENT') {
+        return;
+      }
+      throw error;
+    }
+
+    if (!existingHash) {
+      return;
+    }
+
+    const modelIds = await fetchModels();
+    const currentHash = computeHash(modelIds);
+
+    if (existingHash !== currentHash) {
+      process.stderr.write(
+        '\n' +
+          '\x1b[33m' +
+          'OpenRouter model types are outdated.\n' +
+          'Run: npx @openrouter/cli types\n' +
+          '\x1b[0m',
+      );
+    }
+  } catch {
+    // Silently ignore errors - we don't want to break installs
+  }
+}
+
+main();

package/esm/models/operations/getparameters.d.ts

@@ -1,87 +0,0 @@
-import * as z from "zod/v4";
-import { OpenEnum } from "../../types/enums.js";
-import { Result as SafeParseResult } from "../../types/fp.js";
-import { SDKValidationError } from "../errors/sdkvalidationerror.js";
-import * as models from "../index.js";
-export type GetParametersSecurity = {
-    bearer: string;
-};
-export type GetParametersRequest = {
-    author: string;
-    slug: string;
-    provider?: models.ProviderName | undefined;
-};
-export declare const SupportedParameter: {
-    readonly Temperature: "temperature";
-    readonly TopP: "top_p";
-    readonly TopK: "top_k";
-    readonly MinP: "min_p";
-    readonly TopA: "top_a";
-    readonly FrequencyPenalty: "frequency_penalty";
-    readonly PresencePenalty: "presence_penalty";
-    readonly RepetitionPenalty: "repetition_penalty";
-    readonly MaxTokens: "max_tokens";
-    readonly LogitBias: "logit_bias";
-    readonly Logprobs: "logprobs";
-    readonly TopLogprobs: "top_logprobs";
-    readonly Seed: "seed";
-    readonly ResponseFormat: "response_format";
-    readonly StructuredOutputs: "structured_outputs";
-    readonly Stop: "stop";
-    readonly Tools: "tools";
-    readonly ToolChoice: "tool_choice";
-    readonly ParallelToolCalls: "parallel_tool_calls";
-    readonly IncludeReasoning: "include_reasoning";
-    readonly Reasoning: "reasoning";
-    readonly ReasoningEffort: "reasoning_effort";
-    readonly WebSearchOptions: "web_search_options";
-    readonly Verbosity: "verbosity";
-};
-export type SupportedParameter = OpenEnum<typeof SupportedParameter>;
-/**
- * Parameter analytics data
- */
-export type GetParametersData = {
-    /**
-     * Model identifier
-     */
-    model: string;
-    /**
-     * List of parameters supported by this model
-     */
-    supportedParameters: Array<SupportedParameter>;
-};
-/**
- * Returns the parameters for the specified model
- */
-export type GetParametersResponse = {
-    /**
-     * Parameter analytics data
-     */
-    data: GetParametersData;
-};
-/** @internal */
-export type GetParametersSecurity$Outbound = {
-    bearer: string;
-};
-/** @internal */
-export declare const GetParametersSecurity$outboundSchema: z.ZodType<GetParametersSecurity$Outbound, GetParametersSecurity>;
-export declare function getParametersSecurityToJSON(getParametersSecurity: GetParametersSecurity): string;
-/** @internal */
-export type GetParametersRequest$Outbound = {
-    author: string;
-    slug: string;
-    provider?: string | undefined;
-};
-/** @internal */
-export declare const GetParametersRequest$outboundSchema: z.ZodType<GetParametersRequest$Outbound, GetParametersRequest>;
-export declare function getParametersRequestToJSON(getParametersRequest: GetParametersRequest): string;
-/** @internal */
-export declare const SupportedParameter$inboundSchema: z.ZodType<SupportedParameter, unknown>;
-/** @internal */
-export declare const GetParametersData$inboundSchema: z.ZodType<GetParametersData, unknown>;
-export declare function getParametersDataFromJSON(jsonString: string): SafeParseResult<GetParametersData, SDKValidationError>;
-/** @internal */
-export declare const GetParametersResponse$inboundSchema: z.ZodType<GetParametersResponse, unknown>;
-export declare function getParametersResponseFromJSON(jsonString: string): SafeParseResult<GetParametersResponse, SDKValidationError>;
-//# sourceMappingURL=getparameters.d.ts.map

package/esm/models/operations/getparameters.js

@@ -1,73 +0,0 @@
-/*
- * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- * @generated-id: 9b364a4cca61
- */
-import * as z from "zod/v4";
-import { remap as remap$ } from "../../lib/primitives.js";
-import { safeParse } from "../../lib/schemas.js";
-import * as openEnums from "../../types/enums.js";
-import * as models from "../index.js";
-export const SupportedParameter = {
-    Temperature: "temperature",
-    TopP: "top_p",
-    TopK: "top_k",
-    MinP: "min_p",
-    TopA: "top_a",
-    FrequencyPenalty: "frequency_penalty",
-    PresencePenalty: "presence_penalty",
-    RepetitionPenalty: "repetition_penalty",
-    MaxTokens: "max_tokens",
-    LogitBias: "logit_bias",
-    Logprobs: "logprobs",
-    TopLogprobs: "top_logprobs",
-    Seed: "seed",
-    ResponseFormat: "response_format",
-    StructuredOutputs: "structured_outputs",
-    Stop: "stop",
-    Tools: "tools",
-    ToolChoice: "tool_choice",
-    ParallelToolCalls: "parallel_tool_calls",
-    IncludeReasoning: "include_reasoning",
-    Reasoning: "reasoning",
-    ReasoningEffort: "reasoning_effort",
-    WebSearchOptions: "web_search_options",
-    Verbosity: "verbosity",
-};
-/** @internal */
-export const GetParametersSecurity$outboundSchema = z.object({
-    bearer: z.string(),
-});
-export function getParametersSecurityToJSON(getParametersSecurity) {
-    return JSON.stringify(GetParametersSecurity$outboundSchema.parse(getParametersSecurity));
-}
-/** @internal */
-export const GetParametersRequest$outboundSchema = z.object({
-    author: z.string(),
-    slug: z.string(),
-    provider: models.ProviderName$outboundSchema.optional(),
-});
-export function getParametersRequestToJSON(getParametersRequest) {
-    return JSON.stringify(GetParametersRequest$outboundSchema.parse(getParametersRequest));
-}
-/** @internal */
-export const SupportedParameter$inboundSchema = openEnums.inboundSchema(SupportedParameter);
-/** @internal */
-export const GetParametersData$inboundSchema = z.object({
-    model: z.string(),
-    supported_parameters: z.array(SupportedParameter$inboundSchema),
-}).transform((v) => {
-    return remap$(v, {
-        "supported_parameters": "supportedParameters",
-    });
-});
-export function getParametersDataFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => GetParametersData$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'GetParametersData' from JSON`);
-}
-/** @internal */
-export const GetParametersResponse$inboundSchema = z.object({
-    data: z.lazy(() => GetParametersData$inboundSchema),
-});
-export function getParametersResponseFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => GetParametersResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'GetParametersResponse' from JSON`);
-}
-//# sourceMappingURL=getparameters.js.map

package/esm/models/schema3.d.ts

@@ -1,51 +0,0 @@
-import * as z from "zod/v4";
-import { OpenEnum } from "../types/enums.js";
-import { Result as SafeParseResult } from "../types/fp.js";
-import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export declare const Schema5: {
-    readonly Unknown: "unknown";
-    readonly OpenaiResponsesV1: "openai-responses-v1";
-    readonly AzureOpenaiResponsesV1: "azure-openai-responses-v1";
-    readonly XaiResponsesV1: "xai-responses-v1";
-    readonly AnthropicClaudeV1: "anthropic-claude-v1";
-    readonly GoogleGeminiV1: "google-gemini-v1";
-};
-export type Schema5 = OpenEnum<typeof Schema5>;
-export type Schema3ReasoningText = {
-    type: "reasoning.text";
-    text?: string | null | undefined;
-    signature?: string | null | undefined;
-    id?: string | null | undefined;
-    format?: Schema5 | null | undefined;
-    index?: number | undefined;
-};
-export type Schema3ReasoningEncrypted = {
-    type: "reasoning.encrypted";
-    data: string;
-    id?: string | null | undefined;
-    format?: Schema5 | null | undefined;
-    index?: number | undefined;
-};
-export type Schema3ReasoningSummary = {
-    type: "reasoning.summary";
-    summary: string;
-    id?: string | null | undefined;
-    format?: Schema5 | null | undefined;
-    index?: number | undefined;
-};
-export type Schema3 = Schema3ReasoningSummary | Schema3ReasoningEncrypted | Schema3ReasoningText;
-/** @internal */
-export declare const Schema5$inboundSchema: z.ZodType<Schema5, unknown>;
-/** @internal */
-export declare const Schema3ReasoningText$inboundSchema: z.ZodType<Schema3ReasoningText, unknown>;
-export declare function schema3ReasoningTextFromJSON(jsonString: string): SafeParseResult<Schema3ReasoningText, SDKValidationError>;
-/** @internal */
-export declare const Schema3ReasoningEncrypted$inboundSchema: z.ZodType<Schema3ReasoningEncrypted, unknown>;
-export declare function schema3ReasoningEncryptedFromJSON(jsonString: string): SafeParseResult<Schema3ReasoningEncrypted, SDKValidationError>;
-/** @internal */
-export declare const Schema3ReasoningSummary$inboundSchema: z.ZodType<Schema3ReasoningSummary, unknown>;
-export declare function schema3ReasoningSummaryFromJSON(jsonString: string): SafeParseResult<Schema3ReasoningSummary, SDKValidationError>;
-/** @internal */
-export declare const Schema3$inboundSchema: z.ZodType<Schema3, unknown>;
-export declare function schema3FromJSON(jsonString: string): SafeParseResult<Schema3, SDKValidationError>;
-//# sourceMappingURL=schema3.d.ts.map

package/esm/models/schema3.js

@@ -1,62 +0,0 @@
-/*
- * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- * @generated-id: 6f7380bcbcea
- */
-import * as z from "zod/v4";
-import { safeParse } from "../lib/schemas.js";
-import * as openEnums from "../types/enums.js";
-export const Schema5 = {
-    Unknown: "unknown",
-    OpenaiResponsesV1: "openai-responses-v1",
-    AzureOpenaiResponsesV1: "azure-openai-responses-v1",
-    XaiResponsesV1: "xai-responses-v1",
-    AnthropicClaudeV1: "anthropic-claude-v1",
-    GoogleGeminiV1: "google-gemini-v1",
-};
-/** @internal */
-export const Schema5$inboundSchema = openEnums
-    .inboundSchema(Schema5);
-/** @internal */
-export const Schema3ReasoningText$inboundSchema = z.object({
-    type: z.literal("reasoning.text"),
-    text: z.nullable(z.string()).optional(),
-    signature: z.nullable(z.string()).optional(),
-    id: z.nullable(z.string()).optional(),
-    format: z.nullable(Schema5$inboundSchema).optional(),
-    index: z.number().optional(),
-});
-export function schema3ReasoningTextFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => Schema3ReasoningText$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Schema3ReasoningText' from JSON`);
-}
-/** @internal */
-export const Schema3ReasoningEncrypted$inboundSchema = z.object({
-    type: z.literal("reasoning.encrypted"),
-    data: z.string(),
-    id: z.nullable(z.string()).optional(),
-    format: z.nullable(Schema5$inboundSchema).optional(),
-    index: z.number().optional(),
-});
-export function schema3ReasoningEncryptedFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => Schema3ReasoningEncrypted$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Schema3ReasoningEncrypted' from JSON`);
-}
-/** @internal */
-export const Schema3ReasoningSummary$inboundSchema = z.object({
-    type: z.literal("reasoning.summary"),
-    summary: z.string(),
-    id: z.nullable(z.string()).optional(),
-    format: z.nullable(Schema5$inboundSchema).optional(),
-    index: z.number().optional(),
-});
-export function schema3ReasoningSummaryFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => Schema3ReasoningSummary$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Schema3ReasoningSummary' from JSON`);
-}
-/** @internal */
-export const Schema3$inboundSchema = z.union([
-    z.lazy(() => Schema3ReasoningSummary$inboundSchema),
-    z.lazy(() => Schema3ReasoningEncrypted$inboundSchema),
-    z.lazy(() => Schema3ReasoningText$inboundSchema),
-]);
-export function schema3FromJSON(jsonString) {
-    return safeParse(jsonString, (x) => Schema3$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Schema3' from JSON`);
-}
-//# sourceMappingURL=schema3.js.map

package/esm/sdk/parameters.d.ts

@@ -1,9 +0,0 @@
-import { ClientSDK, RequestOptions } from "../lib/sdks.js";
-import * as operations from "../models/operations/index.js";
-export declare class ParametersT extends ClientSDK {
-    /**
-     * Get a model's supported parameters and data about which are most popular
-     */
-    getParameters(security: operations.GetParametersSecurity, request: operations.GetParametersRequest, options?: RequestOptions): Promise<operations.GetParametersResponse>;
-}
-//# sourceMappingURL=parameters.d.ts.map

package/esm/sdk/parameters.js

@@ -1,16 +0,0 @@
-/*
- * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- * @generated-id: 6e4ef00c29b7
- */
-import { parametersGetParameters } from "../funcs/parametersGetParameters.js";
-import { ClientSDK } from "../lib/sdks.js";
-import { unwrapAsync } from "../types/fp.js";
-export class ParametersT extends ClientSDK {
-    /**
-     * Get a model's supported parameters and data about which are most popular
-     */
-    async getParameters(security, request, options) {
-        return unwrapAsync(parametersGetParameters(this, security, request, options));
-    }
-}
-//# sourceMappingURL=parameters.js.map