@openrouter/sdk 0.2.9 → 0.3.1

package/esm/models/publicpricing.js

@@ -7,18 +7,18 @@ import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const PublicPricing$inboundSchema = z
     .object({
-    prompt: z.any().optional(),
-    completion: z.any().optional(),
-    request: z.any().optional(),
-    image: z.any().optional(),
-    image_token: z.any().optional(),
-    image_output: z.any().optional(),
-    audio: z.any().optional(),
-    input_audio_cache: z.any().optional(),
-    web_search: z.any().optional(),
-    internal_reasoning: z.any().optional(),
-    input_cache_read: z.any().optional(),
-    input_cache_write: z.any().optional(),
+    prompt: z.string(),
+    completion: z.string(),
+    request: z.string().optional(),
+    image: z.string().optional(),
+    image_token: z.string().optional(),
+    image_output: z.string().optional(),
+    audio: z.string().optional(),
+    input_audio_cache: z.string().optional(),
+    web_search: z.string().optional(),
+    internal_reasoning: z.string().optional(),
+    input_cache_read: z.string().optional(),
+    input_cache_write: z.string().optional(),
     discount: z.number().optional(),
 }).transform((v) => {
     return remap$(v, {

package/esm/models/schema0.d.ts

@@ -0,0 +1,83 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+export declare const Schema0Enum: {
+    readonly Ai21: "AI21";
+    readonly AionLabs: "AionLabs";
+    readonly Alibaba: "Alibaba";
+    readonly AmazonBedrock: "Amazon Bedrock";
+    readonly AmazonNova: "Amazon Nova";
+    readonly Anthropic: "Anthropic";
+    readonly ArceeAI: "Arcee AI";
+    readonly AtlasCloud: "AtlasCloud";
+    readonly Avian: "Avian";
+    readonly Azure: "Azure";
+    readonly BaseTen: "BaseTen";
+    readonly BytePlus: "BytePlus";
+    readonly BlackForestLabs: "Black Forest Labs";
+    readonly Cerebras: "Cerebras";
+    readonly Chutes: "Chutes";
+    readonly Cirrascale: "Cirrascale";
+    readonly Clarifai: "Clarifai";
+    readonly Cloudflare: "Cloudflare";
+    readonly Cohere: "Cohere";
+    readonly Crusoe: "Crusoe";
+    readonly DeepInfra: "DeepInfra";
+    readonly DeepSeek: "DeepSeek";
+    readonly Featherless: "Featherless";
+    readonly Fireworks: "Fireworks";
+    readonly Friendli: "Friendli";
+    readonly GMICloud: "GMICloud";
+    readonly GoPomelo: "GoPomelo";
+    readonly Google: "Google";
+    readonly GoogleAIStudio: "Google AI Studio";
+    readonly Groq: "Groq";
+    readonly Hyperbolic: "Hyperbolic";
+    readonly Inception: "Inception";
+    readonly InferenceNet: "InferenceNet";
+    readonly Infermatic: "Infermatic";
+    readonly Inflection: "Inflection";
+    readonly Liquid: "Liquid";
+    readonly Mara: "Mara";
+    readonly Mancer2: "Mancer 2";
+    readonly Minimax: "Minimax";
+    readonly ModelRun: "ModelRun";
+    readonly Mistral: "Mistral";
+    readonly Modular: "Modular";
+    readonly MoonshotAI: "Moonshot AI";
+    readonly Morph: "Morph";
+    readonly NCompass: "NCompass";
+    readonly Nebius: "Nebius";
+    readonly NextBit: "NextBit";
+    readonly Novita: "Novita";
+    readonly Nvidia: "Nvidia";
+    readonly OpenAI: "OpenAI";
+    readonly OpenInference: "OpenInference";
+    readonly Parasail: "Parasail";
+    readonly Perplexity: "Perplexity";
+    readonly Phala: "Phala";
+    readonly Relace: "Relace";
+    readonly SambaNova: "SambaNova";
+    readonly SiliconFlow: "SiliconFlow";
+    readonly Sourceful: "Sourceful";
+    readonly Stealth: "Stealth";
+    readonly StreamLake: "StreamLake";
+    readonly Switchpoint: "Switchpoint";
+    readonly Targon: "Targon";
+    readonly Together: "Together";
+    readonly Venice: "Venice";
+    readonly WandB: "WandB";
+    readonly Xiaomi: "Xiaomi";
+    readonly XAI: "xAI";
+    readonly ZAi: "Z.AI";
+    readonly FakeProvider: "FakeProvider";
+};
+export type Schema0Enum = OpenEnum<typeof Schema0Enum>;
+export type Schema0 = Schema0Enum | string;
+/** @internal */
+export declare const Schema0Enum$outboundSchema: z.ZodType<string, Schema0Enum>;
+/** @internal */
+export type Schema0$Outbound = string | string;
+/** @internal */
+export declare const Schema0$outboundSchema: z.ZodType<Schema0$Outbound, Schema0>;
+export declare function schema0ToJSON(schema0: Schema0): string;
+//# sourceMappingURL=schema0.d.ts.map

package/esm/models/schema0.js

@@ -0,0 +1,85 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4";
+import * as openEnums from "../types/enums.js";
+export const Schema0Enum = {
+    Ai21: "AI21",
+    AionLabs: "AionLabs",
+    Alibaba: "Alibaba",
+    AmazonBedrock: "Amazon Bedrock",
+    AmazonNova: "Amazon Nova",
+    Anthropic: "Anthropic",
+    ArceeAI: "Arcee AI",
+    AtlasCloud: "AtlasCloud",
+    Avian: "Avian",
+    Azure: "Azure",
+    BaseTen: "BaseTen",
+    BytePlus: "BytePlus",
+    BlackForestLabs: "Black Forest Labs",
+    Cerebras: "Cerebras",
+    Chutes: "Chutes",
+    Cirrascale: "Cirrascale",
+    Clarifai: "Clarifai",
+    Cloudflare: "Cloudflare",
+    Cohere: "Cohere",
+    Crusoe: "Crusoe",
+    DeepInfra: "DeepInfra",
+    DeepSeek: "DeepSeek",
+    Featherless: "Featherless",
+    Fireworks: "Fireworks",
+    Friendli: "Friendli",
+    GMICloud: "GMICloud",
+    GoPomelo: "GoPomelo",
+    Google: "Google",
+    GoogleAIStudio: "Google AI Studio",
+    Groq: "Groq",
+    Hyperbolic: "Hyperbolic",
+    Inception: "Inception",
+    InferenceNet: "InferenceNet",
+    Infermatic: "Infermatic",
+    Inflection: "Inflection",
+    Liquid: "Liquid",
+    Mara: "Mara",
+    Mancer2: "Mancer 2",
+    Minimax: "Minimax",
+    ModelRun: "ModelRun",
+    Mistral: "Mistral",
+    Modular: "Modular",
+    MoonshotAI: "Moonshot AI",
+    Morph: "Morph",
+    NCompass: "NCompass",
+    Nebius: "Nebius",
+    NextBit: "NextBit",
+    Novita: "Novita",
+    Nvidia: "Nvidia",
+    OpenAI: "OpenAI",
+    OpenInference: "OpenInference",
+    Parasail: "Parasail",
+    Perplexity: "Perplexity",
+    Phala: "Phala",
+    Relace: "Relace",
+    SambaNova: "SambaNova",
+    SiliconFlow: "SiliconFlow",
+    Sourceful: "Sourceful",
+    Stealth: "Stealth",
+    StreamLake: "StreamLake",
+    Switchpoint: "Switchpoint",
+    Targon: "Targon",
+    Together: "Together",
+    Venice: "Venice",
+    WandB: "WandB",
+    Xiaomi: "Xiaomi",
+    XAI: "xAI",
+    ZAi: "Z.AI",
+    FakeProvider: "FakeProvider",
+};
+/** @internal */
+export const Schema0Enum$outboundSchema = openEnums.outboundSchema(Schema0Enum);
+/** @internal */
+export const Schema0$outboundSchema = z
+    .union([Schema0Enum$outboundSchema, z.string()]);
+export function schema0ToJSON(schema0) {
+    return JSON.stringify(Schema0$outboundSchema.parse(schema0));
+}
+//# sourceMappingURL=schema0.js.map

package/esm/models/schema3.d.ts

@@ -0,0 +1,50 @@
+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 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

@@ -0,0 +1,60 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+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",
+    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/models/websearchengine.d.ts

@@ -0,0 +1,16 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+/**
+ * The search engine to use for web search.
+ */
+export declare const WebSearchEngine: {
+    readonly Native: "native";
+    readonly Exa: "exa";
+};
+/**
+ * The search engine to use for web search.
+ */
+export type WebSearchEngine = OpenEnum<typeof WebSearchEngine>;
+/** @internal */
+export declare const WebSearchEngine$outboundSchema: z.ZodType<string, WebSearchEngine>;
+//# sourceMappingURL=websearchengine.d.ts.map

package/esm/models/websearchengine.js

@@ -0,0 +1,14 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as openEnums from "../types/enums.js";
+/**
+ * The search engine to use for web search.
+ */
+export const WebSearchEngine = {
+    Native: "native",
+    Exa: "exa",
+};
+/** @internal */
+export const WebSearchEngine$outboundSchema = openEnums.outboundSchema(WebSearchEngine);
+//# sourceMappingURL=websearchengine.js.map

package/esm/types/discriminatedUnion.d.ts

@@ -0,0 +1,25 @@
+import * as z from "zod/v4";
+export type Unknown<Discriminator extends string, UnknownValue = "UNKNOWN"> = {
+    [K in Discriminator]: UnknownValue;
+} & {
+    raw: unknown;
+    isUnknown: true;
+};
+export declare function isUnknown<Discriminator extends string>(value: unknown): value is Unknown<Discriminator>;
+/**
+ * Forward-compatible discriminated union parser.
+ *
+ * If the input does not match one of the predefined options, it will be
+ * captured and available as `{ raw: <original input>, [discriminator]: "UNKNOWN", isUnknown: true }`.
+ *
+ * @param inputPropertyName - The discriminator property name in the input payload
+ * @param options - Map of discriminator values to their corresponding schemas
+ * @param opts - Optional configuration object
+ * @param opts.unknownValue - The value to use for the discriminator when the input is unknown (default: "UNKNOWN")
+ * @param opts.outputPropertyName - Output property name if the sanitized (camelCase) property name differs from inputPropertyName
+ */
+export declare function discriminatedUnion<InputDiscriminator extends string, TOptions extends Readonly<Record<string, z.ZodType>>, UnknownValue extends string = "UNKNOWN", OutputDiscriminator extends string = InputDiscriminator>(inputPropertyName: InputDiscriminator, options: TOptions, opts?: {
+    unknownValue?: UnknownValue;
+    outputPropertyName?: OutputDiscriminator;
+}): z.ZodType<z.output<TOptions[keyof TOptions]> | Unknown<OutputDiscriminator, UnknownValue>, unknown>;
+//# sourceMappingURL=discriminatedUnion.d.ts.map

package/esm/types/discriminatedUnion.js

@@ -0,0 +1,57 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4";
+import { startCountingUnrecognized } from "./unrecognized.js";
+const UNKNOWN = Symbol("UNKNOWN");
+export function isUnknown(value) {
+    return typeof value === "object" && value !== null && UNKNOWN in value;
+}
+/**
+ * Forward-compatible discriminated union parser.
+ *
+ * If the input does not match one of the predefined options, it will be
+ * captured and available as `{ raw: <original input>, [discriminator]: "UNKNOWN", isUnknown: true }`.
+ *
+ * @param inputPropertyName - The discriminator property name in the input payload
+ * @param options - Map of discriminator values to their corresponding schemas
+ * @param opts - Optional configuration object
+ * @param opts.unknownValue - The value to use for the discriminator when the input is unknown (default: "UNKNOWN")
+ * @param opts.outputPropertyName - Output property name if the sanitized (camelCase) property name differs from inputPropertyName
+ */
+export function discriminatedUnion(inputPropertyName, options, opts = {}) {
+    const { unknownValue = "UNKNOWN", outputPropertyName } = opts;
+    return z.unknown().transform((input) => {
+        const fallback = Object.defineProperties({
+            raw: input,
+            [outputPropertyName ?? inputPropertyName]: unknownValue,
+            isUnknown: true,
+        }, { [UNKNOWN]: { value: true, enumerable: false, configurable: false } });
+        const isObject = typeof input === "object" && input !== null;
+        if (!isObject)
+            return fallback;
+        const discriminator = input[inputPropertyName];
+        if (typeof discriminator !== "string")
+            return fallback;
+        if (!(discriminator in options))
+            return fallback;
+        const schema = options[discriminator];
+        if (!schema)
+            return fallback;
+        // Start counters before parsing to track nested unrecognized/zeroDefault values
+        const unrecognizedCtr = startCountingUnrecognized();
+        const result = schema.safeParse(input);
+        if (!result.success) {
+            // Parse failed - don't propagate any counts from the failed attempt
+            unrecognizedCtr.end(0);
+            return fallback;
+        }
+        // Parse succeeded - propagate the actual counts
+        unrecognizedCtr.end();
+        if (outputPropertyName) {
+            result.data[outputPropertyName] = discriminator;
+        }
+        return result.data;
+    });
+}
+//# sourceMappingURL=discriminatedUnion.js.map

package/jsr.json

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

package/package.json

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