@openrouter/sdk 0.2.11 → 0.3.2

package/esm/models/providersort.js

@@ -2,9 +2,6 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 import * as openEnums from "../types/enums.js";
-/**
- * The sorting strategy to use for this request, if "order" is not specified. When set, no load balancing is performed.
- */
 export const ProviderSort = {
     Price: "price",
     Throughput: "throughput",

package/esm/models/providersortconfig.d.ts

@@ -0,0 +1,23 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+import { ProviderSort } from "./providersort.js";
+export declare const Partition: {
+    readonly Model: "model";
+    readonly None: "none";
+};
+export type Partition = OpenEnum<typeof Partition>;
+export type ProviderSortConfig = {
+    by?: ProviderSort | null | undefined;
+    partition?: Partition | null | undefined;
+};
+/** @internal */
+export declare const Partition$outboundSchema: z.ZodType<string, Partition>;
+/** @internal */
+export type ProviderSortConfig$Outbound = {
+    by?: string | null | undefined;
+    partition?: string | null | undefined;
+};
+/** @internal */
+export declare const ProviderSortConfig$outboundSchema: z.ZodType<ProviderSortConfig$Outbound, ProviderSortConfig>;
+export declare function providerSortConfigToJSON(providerSortConfig: ProviderSortConfig): string;
+//# sourceMappingURL=providersortconfig.d.ts.map

package/esm/models/providersortconfig.js

@@ -0,0 +1,22 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4";
+import * as openEnums from "../types/enums.js";
+import { ProviderSort$outboundSchema } from "./providersort.js";
+export const Partition = {
+    Model: "model",
+    None: "none",
+};
+/** @internal */
+export const Partition$outboundSchema = openEnums
+    .outboundSchema(Partition);
+/** @internal */
+export const ProviderSortConfig$outboundSchema = z.object({
+    by: z.nullable(ProviderSort$outboundSchema).optional(),
+    partition: z.nullable(Partition$outboundSchema).optional(),
+});
+export function providerSortConfigToJSON(providerSortConfig) {
+    return JSON.stringify(ProviderSortConfig$outboundSchema.parse(providerSortConfig));
+}
+//# sourceMappingURL=providersortconfig.js.map

package/esm/models/providersortunion.d.ts

@@ -0,0 +1,10 @@
+import * as z from "zod/v4";
+import { ProviderSort } from "./providersort.js";
+import { ProviderSortConfig, ProviderSortConfig$Outbound } from "./providersortconfig.js";
+export type ProviderSortUnion = ProviderSort | ProviderSortConfig;
+/** @internal */
+export type ProviderSortUnion$Outbound = string | ProviderSortConfig$Outbound;
+/** @internal */
+export declare const ProviderSortUnion$outboundSchema: z.ZodType<ProviderSortUnion$Outbound, ProviderSortUnion>;
+export declare function providerSortUnionToJSON(providerSortUnion: ProviderSortUnion): string;
+//# sourceMappingURL=providersortunion.d.ts.map

package/esm/models/providersortunion.js

@@ -0,0 +1,12 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4";
+import { ProviderSort$outboundSchema } from "./providersort.js";
+import { ProviderSortConfig$outboundSchema, } from "./providersortconfig.js";
+/** @internal */
+export const ProviderSortUnion$outboundSchema = z.union([ProviderSort$outboundSchema, ProviderSortConfig$outboundSchema]);
+export function providerSortUnionToJSON(providerSortUnion) {
+    return JSON.stringify(ProviderSortUnion$outboundSchema.parse(providerSortUnion));
+}
+//# sourceMappingURL=providersortunion.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.11",
+  "version": "0.3.2",
   "exports": {
     ".": "./src/index.ts",    
     "./models/errors": "./src/models/errors/index.ts",    

package/package.json

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

package/tsconfig.json

@@ -1,6 +1,6 @@
 {
   "compilerOptions": {
-    "incremental": true,
+    "incremental": false,
     "target": "ES2020",
     "lib": ["ES2022", "DOM", "DOM.Iterable"],
     "jsx": "react-jsx",