@openrouter/sdk 0.12.29 → 0.12.31

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

@@ -44,16 +44,11 @@ export type SendChatCompletionRequestRequest = {
      * @remarks
      */
     appCategories?: string | undefined;
-    chatRequest: models.ChatRequest;
-};
-/**
- * Successful chat completion response
- */
-export type SendChatCompletionRequestResponseBody = {
     /**
-     * Streaming chat completion chunk
+     * Opt-in to surface routing metadata on the response under `openrouter_metadata`. Defaults to `disabled`.
      */
-    data: models.ChatStreamChunk;
+    xOpenRouterExperimentalMetadata?: models.MetadataLevel | undefined;
+    chatRequest: models.ChatRequest;
 };
 export type SendChatCompletionRequestResponse = models.ChatResult | EventStream<models.ChatStreamChunk>;
 /** @internal */
@@ -61,15 +56,13 @@ export type SendChatCompletionRequestRequest$Outbound = {
     "HTTP-Referer"?: string | undefined;
     appTitle?: string | undefined;
     appCategories?: string | undefined;
+    "X-OpenRouter-Experimental-Metadata"?: string | undefined;
     ChatRequest: models.ChatRequest$Outbound;
 };
 /** @internal */
 export declare const SendChatCompletionRequestRequest$outboundSchema: z.ZodType<SendChatCompletionRequestRequest$Outbound, SendChatCompletionRequestRequest>;
 export declare function sendChatCompletionRequestRequestToJSON(sendChatCompletionRequestRequest: SendChatCompletionRequestRequest): string;
 /** @internal */
-export declare const SendChatCompletionRequestResponseBody$inboundSchema: z.ZodType<SendChatCompletionRequestResponseBody, unknown>;
-export declare function sendChatCompletionRequestResponseBodyFromJSON(jsonString: string): SafeParseResult<SendChatCompletionRequestResponseBody, SDKValidationError>;
-/** @internal */
 export declare const SendChatCompletionRequestResponse$inboundSchema: z.ZodType<SendChatCompletionRequestResponse, unknown>;
 export declare function sendChatCompletionRequestResponseFromJSON(jsonString: string): SafeParseResult<SendChatCompletionRequestResponse, SDKValidationError>;
 //# sourceMappingURL=sendchatcompletionrequest.d.ts.map

package/esm/models/operations/sendchatcompletionrequest.js

@@ -12,10 +12,13 @@ export const SendChatCompletionRequestRequest$outboundSchema = z.object({
     httpReferer: z.string().optional(),
     appTitle: z.string().optional(),
     appCategories: z.string().optional(),
+    xOpenRouterExperimentalMetadata: models.MetadataLevel$outboundSchema
+        .optional(),
     chatRequest: models.ChatRequest$outboundSchema,
 }).transform((v) => {
     return remap$(v, {
         httpReferer: "HTTP-Referer",
+        xOpenRouterExperimentalMetadata: "X-OpenRouter-Experimental-Metadata",
         chatRequest: "ChatRequest",
     });
 });
@@ -23,25 +26,6 @@ export function sendChatCompletionRequestRequestToJSON(sendChatCompletionRequest
     return JSON.stringify(SendChatCompletionRequestRequest$outboundSchema.parse(sendChatCompletionRequestRequest));
 }
 /** @internal */
-export const SendChatCompletionRequestResponseBody$inboundSchema = z.object({
-    data: z.string().transform((v, ctx) => {
-        try {
-            return JSON.parse(v);
-        }
-        catch (err) {
-            ctx.addIssue({
-                input: v,
-                code: "custom",
-                message: `malformed json: ${err}`,
-            });
-            return z.NEVER;
-        }
-    }).pipe(models.ChatStreamChunk$inboundSchema),
-});
-export function sendChatCompletionRequestResponseBodyFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => SendChatCompletionRequestResponseBody$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'SendChatCompletionRequestResponseBody' from JSON`);
-}
-/** @internal */
 export const SendChatCompletionRequestResponse$inboundSchema = z.union([
     models.ChatResult$inboundSchema,
     z.custom(x => x instanceof ReadableStream)
@@ -51,7 +35,8 @@ export const SendChatCompletionRequestResponse$inboundSchema = z.union([
                 return { done: true, value: undefined };
             return {
                 done: false,
-                value: z.lazy(() => SendChatCompletionRequestResponseBody$inboundSchema).parse(rawEvent)?.data,
+                value: models.ChatStreamingResponse$inboundSchema.parse(rawEvent)
+                    ?.data,
             };
         });
     }),

package/esm/models/pipelinestage.d.ts

@@ -0,0 +1,21 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { PipelineStageType } from "./pipelinestagetype.js";
+export type PipelineStage = {
+    costUsd?: number | null | undefined;
+    data?: {
+        [k: string]: any | null;
+    } | undefined;
+    guardrailId?: string | undefined;
+    guardrailScope?: string | undefined;
+    name: string;
+    /**
+     * Categorical kind of a pipeline stage. Multiple plugins can share a type (e.g. all guardrail-level plugins emit `guardrail`); the `name` field disambiguates which plugin emitted it.
+     */
+    type: PipelineStageType;
+};
+/** @internal */
+export declare const PipelineStage$inboundSchema: z.ZodType<PipelineStage, unknown>;
+export declare function pipelineStageFromJSON(jsonString: string): SafeParseResult<PipelineStage, SDKValidationError>;
+//# sourceMappingURL=pipelinestage.d.ts.map

package/esm/models/pipelinestage.js

@@ -0,0 +1,28 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: d737d34295bb
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { PipelineStageType$inboundSchema, } from "./pipelinestagetype.js";
+/** @internal */
+export const PipelineStage$inboundSchema = z
+    .object({
+    cost_usd: z.nullable(z.number()).optional(),
+    data: z.record(z.string(), z.nullable(z.any())).optional(),
+    guardrail_id: z.string().optional(),
+    guardrail_scope: z.string().optional(),
+    name: z.string(),
+    type: PipelineStageType$inboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        "cost_usd": "costUsd",
+        "guardrail_id": "guardrailId",
+        "guardrail_scope": "guardrailScope",
+    });
+});
+export function pipelineStageFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => PipelineStage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'PipelineStage' from JSON`);
+}
+//# sourceMappingURL=pipelinestage.js.map

package/esm/models/pipelinestagetype.d.ts

@@ -0,0 +1,21 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+/**
+ * Categorical kind of a pipeline stage. Multiple plugins can share a type (e.g. all guardrail-level plugins emit `guardrail`); the `name` field disambiguates which plugin emitted it.
+ */
+export declare const PipelineStageType: {
+    readonly Router: "router";
+    readonly Guardrail: "guardrail";
+    readonly WebSearch: "web_search";
+    readonly FileParser: "file_parser";
+    readonly ServerTools: "server_tools";
+    readonly ResponseHealing: "response_healing";
+    readonly ContextCompression: "context_compression";
+};
+/**
+ * Categorical kind of a pipeline stage. Multiple plugins can share a type (e.g. all guardrail-level plugins emit `guardrail`); the `name` field disambiguates which plugin emitted it.
+ */
+export type PipelineStageType = OpenEnum<typeof PipelineStageType>;
+/** @internal */
+export declare const PipelineStageType$inboundSchema: z.ZodType<PipelineStageType, unknown>;
+//# sourceMappingURL=pipelinestagetype.d.ts.map

package/esm/models/pipelinestagetype.js

@@ -0,0 +1,20 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 5e7558516b45
+ */
+import * as openEnums from "../types/enums.js";
+/**
+ * Categorical kind of a pipeline stage. Multiple plugins can share a type (e.g. all guardrail-level plugins emit `guardrail`); the `name` field disambiguates which plugin emitted it.
+ */
+export const PipelineStageType = {
+    Router: "router",
+    Guardrail: "guardrail",
+    WebSearch: "web_search",
+    FileParser: "file_parser",
+    ServerTools: "server_tools",
+    ResponseHealing: "response_healing",
+    ContextCompression: "context_compression",
+};
+/** @internal */
+export const PipelineStageType$inboundSchema = openEnums.inboundSchema(PipelineStageType);
+//# sourceMappingURL=pipelinestagetype.js.map

package/esm/models/responsesstreamingresponse.d.ts

@@ -0,0 +1,14 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { StreamEvents } from "./streamevents.js";
+export type ResponsesStreamingResponse = {
+    /**
+     * Union of all possible event types emitted during response streaming
+     */
+    data: StreamEvents;
+};
+/** @internal */
+export declare const ResponsesStreamingResponse$inboundSchema: z.ZodType<ResponsesStreamingResponse, unknown>;
+export declare function responsesStreamingResponseFromJSON(jsonString: string): SafeParseResult<ResponsesStreamingResponse, SDKValidationError>;
+//# sourceMappingURL=responsesstreamingresponse.d.ts.map

package/esm/models/responsesstreamingresponse.js

@@ -0,0 +1,27 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 69284d63df45
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { StreamEvents$inboundSchema } from "./streamevents.js";
+/** @internal */
+export const ResponsesStreamingResponse$inboundSchema = z.object({
+    data: z.string().transform((v, ctx) => {
+        try {
+            return JSON.parse(v);
+        }
+        catch (err) {
+            ctx.addIssue({
+                input: v,
+                code: "custom",
+                message: `malformed json: ${err}`,
+            });
+            return z.NEVER;
+        }
+    }).pipe(StreamEvents$inboundSchema),
+});
+export function responsesStreamingResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ResponsesStreamingResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ResponsesStreamingResponse' from JSON`);
+}
+//# sourceMappingURL=responsesstreamingresponse.js.map

package/esm/models/routerattempt.d.ts

@@ -0,0 +1,12 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type RouterAttempt = {
+    model: string;
+    provider: string;
+    status: number;
+};
+/** @internal */
+export declare const RouterAttempt$inboundSchema: z.ZodType<RouterAttempt, unknown>;
+export declare function routerAttemptFromJSON(jsonString: string): SafeParseResult<RouterAttempt, SDKValidationError>;
+//# sourceMappingURL=routerattempt.d.ts.map

package/esm/models/routerattempt.js

@@ -0,0 +1,17 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 353df41da8e5
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const RouterAttempt$inboundSchema = z
+    .object({
+    model: z.string(),
+    provider: z.string(),
+    status: z.int(),
+});
+export function routerAttemptFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => RouterAttempt$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'RouterAttempt' from JSON`);
+}
+//# sourceMappingURL=routerattempt.js.map

package/esm/models/routerparams.d.ts

@@ -0,0 +1,16 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type RouterParams = {
+    qualityFloor?: number | undefined;
+    sort?: string | undefined;
+    throughputFloor?: number | undefined;
+    versionGroup?: string | undefined;
+    additionalProperties?: {
+        [k: string]: any | null;
+    } | undefined;
+};
+/** @internal */
+export declare const RouterParams$inboundSchema: z.ZodType<RouterParams, unknown>;
+export declare function routerParamsFromJSON(jsonString: string): SafeParseResult<RouterParams, SDKValidationError>;
+//# sourceMappingURL=routerparams.d.ts.map

package/esm/models/routerparams.js

@@ -0,0 +1,24 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 3b3282458763
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { collectExtraKeys as collectExtraKeys$, safeParse, } from "../lib/schemas.js";
+/** @internal */
+export const RouterParams$inboundSchema = collectExtraKeys$(z.object({
+    quality_floor: z.number().optional(),
+    sort: z.string().optional(),
+    throughput_floor: z.number().optional(),
+    version_group: z.string().optional(),
+}).catchall(z.any()), "additionalProperties", true).transform((v) => {
+    return remap$(v, {
+        "quality_floor": "qualityFloor",
+        "throughput_floor": "throughputFloor",
+        "version_group": "versionGroup",
+    });
+});
+export function routerParamsFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => RouterParams$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'RouterParams' from JSON`);
+}
+//# sourceMappingURL=routerparams.js.map

package/esm/models/routingstrategy.d.ts

@@ -0,0 +1,16 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+export declare const RoutingStrategy: {
+    readonly Direct: "direct";
+    readonly Auto: "auto";
+    readonly Free: "free";
+    readonly Latest: "latest";
+    readonly Alias: "alias";
+    readonly Fallback: "fallback";
+    readonly Pareto: "pareto";
+    readonly Bodybuilder: "bodybuilder";
+};
+export type RoutingStrategy = OpenEnum<typeof RoutingStrategy>;
+/** @internal */
+export declare const RoutingStrategy$inboundSchema: z.ZodType<RoutingStrategy, unknown>;
+//# sourceMappingURL=routingstrategy.d.ts.map

package/esm/models/routingstrategy.js

@@ -0,0 +1,18 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 40bcbedca097
+ */
+import * as openEnums from "../types/enums.js";
+export const RoutingStrategy = {
+    Direct: "direct",
+    Auto: "auto",
+    Free: "free",
+    Latest: "latest",
+    Alias: "alias",
+    Fallback: "fallback",
+    Pareto: "pareto",
+    Bodybuilder: "bodybuilder",
+};
+/** @internal */
+export const RoutingStrategy$inboundSchema = openEnums.inboundSchema(RoutingStrategy);
+//# sourceMappingURL=routingstrategy.js.map

package/jsr.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openrouter/sdk",
-  "version": "0.12.29",
+  "version": "0.12.31",
   "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": [
@@ -69,14 +69,14 @@
     "lint": "eslint --cache --max-warnings=0 src",
     "build": "tsc",
     "prepublishOnly": "npm run build",
-    "compile": "tsc",
-    "postinstall": "node scripts/check-types.js || true",
     "prepare": "npm run build",
-    "test:transit": "exit 0",
-    "test:watch": "vitest --watch --project unit",
     "test": "vitest --run --project unit",
-    "test:e2e": "vitest --run --project e2e",
+    "test:watch": "vitest --watch --project unit",
     "typecheck": "tsc --noEmit",
+    "compile": "tsc",
+    "postinstall": "node scripts/check-types.js || true",
+    "test:e2e": "vitest --run --project e2e",
+    "test:transit": "exit 0",
     "typecheck:transit": "exit 0"
   },
   "peerDependencies": {},