@openrouter/sdk 1.3.29 → 1.3.31

package/esm/models/batchpaymentrequiredresponseerror.d.ts

@@ -0,0 +1,159 @@
+import * as z from "zod/v4";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { AnthropicCacheCreation } from "./anthropiccachecreation.js";
+import { AnthropicSpeed } from "./anthropicspeed.js";
+import { AnthropicUsageIteration } from "./anthropicusageiteration.js";
+import { CostDetails } from "./costdetails.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const BatchPaymentRequiredResponseCompletionWindow: {
+    readonly TwentyFourh: "24h";
+};
+export type BatchPaymentRequiredResponseCompletionWindow = ClosedEnum<typeof BatchPaymentRequiredResponseCompletionWindow>;
+export type BatchPaymentRequiredResponseError = {
+    code: number;
+    message: string;
+};
+export declare const BatchPaymentRequiredResponseObject: {
+    readonly Batch: "batch";
+};
+export type BatchPaymentRequiredResponseObject = ClosedEnum<typeof BatchPaymentRequiredResponseObject>;
+export type BatchPaymentRequiredResponseRequestCounts = {
+    completed: number;
+    failed: number;
+    total: number;
+};
+export declare const BatchPaymentRequiredResponseStatus: {
+    readonly Validating: "validating";
+    readonly InProgress: "in_progress";
+    readonly Finalizing: "finalizing";
+    readonly Completed: "completed";
+    readonly Failed: "failed";
+    readonly Expired: "expired";
+    readonly Cancelling: "cancelling";
+    readonly Cancelled: "cancelled";
+};
+export type BatchPaymentRequiredResponseStatus = OpenEnum<typeof BatchPaymentRequiredResponseStatus>;
+export type BatchPaymentRequiredResponseCompletionTokensDetails = {
+    /**
+     * Tokens generated by the model for audio output.
+     */
+    audioTokens?: number | null | undefined;
+    /**
+     * Tokens generated by the model for image output.
+     */
+    imageTokens?: number | null | undefined;
+    /**
+     * Tokens generated by the model for reasoning.
+     */
+    reasoningTokens?: number | null | undefined;
+};
+/**
+ * Breakdown of tokens used in the prompt.
+ */
+export type BatchPaymentRequiredResponsePromptTokensDetails = {
+    /**
+     * Tokens used for input audio.
+     */
+    audioTokens?: number | null | undefined;
+    /**
+     * Tokens written to cache. Only returned for models with explicit caching and cache write pricing.
+     */
+    cacheWriteTokens?: number | null | undefined;
+    /**
+     * Tokens cached by the endpoint.
+     */
+    cachedTokens?: number | null | undefined;
+    /**
+     * Tokens used for input files/documents.
+     */
+    fileTokens?: number | null | undefined;
+    /**
+     * Tokens used for input video.
+     */
+    videoTokens?: number | null | undefined;
+};
+/**
+ * Usage for server-side tool execution (e.g., web search)
+ */
+export type BatchPaymentRequiredResponseServerToolUse = {
+    /**
+     * Number of OpenRouter server tool calls that executed and produced a result.
+     */
+    toolCallsExecuted?: number | null | undefined;
+    /**
+     * Total number of OpenRouter server-orchestrated tool calls the model requested, across all tool types. Provider-native tools (e.g. native web search) are not counted here.
+     */
+    toolCallsRequested?: number | null | undefined;
+    /**
+     * Number of web searches performed by server-side tools. For server-orchestrated tool calls a web search is also counted in tool_calls_requested; provider-native web search may report web_search_requests only. Do not sum the two.
+     */
+    webSearchRequests?: number | null | undefined;
+};
+export type BatchPaymentRequiredResponseUsage = {
+    cacheCreation?: AnthropicCacheCreation | null | undefined;
+    /**
+     * The tokens generated
+     */
+    completionTokens: number;
+    completionTokensDetails?: BatchPaymentRequiredResponseCompletionTokensDetails | null | undefined;
+    /**
+     * Cost of the completion
+     */
+    cost?: number | null | undefined;
+    /**
+     * Breakdown of upstream inference costs
+     */
+    costDetails?: CostDetails | null | undefined;
+    /**
+     * Whether a request was made using a Bring Your Own Key configuration
+     */
+    isByok?: boolean | undefined;
+    iterations?: Array<AnthropicUsageIteration> | null | undefined;
+    /**
+     * Including images, input audio, and tools if any
+     */
+    promptTokens: number;
+    /**
+     * Breakdown of tokens used in the prompt.
+     */
+    promptTokensDetails?: BatchPaymentRequiredResponsePromptTokensDetails | null | undefined;
+    /**
+     * Usage for server-side tool execution (e.g., web search)
+     */
+    serverToolUse?: BatchPaymentRequiredResponseServerToolUse | null | undefined;
+    /**
+     * The service tier used by the upstream provider for this request
+     */
+    serviceTier?: string | null | undefined;
+    speed?: AnthropicSpeed | null | undefined;
+    /**
+     * Sum of the above two fields
+     */
+    totalTokens: number;
+};
+/** @internal */
+export declare const BatchPaymentRequiredResponseCompletionWindow$inboundSchema: z.ZodEnum<typeof BatchPaymentRequiredResponseCompletionWindow>;
+/** @internal */
+export declare const BatchPaymentRequiredResponseError$inboundSchema: z.ZodType<BatchPaymentRequiredResponseError, unknown>;
+export declare function batchPaymentRequiredResponseErrorFromJSON(jsonString: string): SafeParseResult<BatchPaymentRequiredResponseError, SDKValidationError>;
+/** @internal */
+export declare const BatchPaymentRequiredResponseObject$inboundSchema: z.ZodEnum<typeof BatchPaymentRequiredResponseObject>;
+/** @internal */
+export declare const BatchPaymentRequiredResponseRequestCounts$inboundSchema: z.ZodType<BatchPaymentRequiredResponseRequestCounts, unknown>;
+export declare function batchPaymentRequiredResponseRequestCountsFromJSON(jsonString: string): SafeParseResult<BatchPaymentRequiredResponseRequestCounts, SDKValidationError>;
+/** @internal */
+export declare const BatchPaymentRequiredResponseStatus$inboundSchema: z.ZodType<BatchPaymentRequiredResponseStatus, unknown>;
+/** @internal */
+export declare const BatchPaymentRequiredResponseCompletionTokensDetails$inboundSchema: z.ZodType<BatchPaymentRequiredResponseCompletionTokensDetails, unknown>;
+export declare function batchPaymentRequiredResponseCompletionTokensDetailsFromJSON(jsonString: string): SafeParseResult<BatchPaymentRequiredResponseCompletionTokensDetails, SDKValidationError>;
+/** @internal */
+export declare const BatchPaymentRequiredResponsePromptTokensDetails$inboundSchema: z.ZodType<BatchPaymentRequiredResponsePromptTokensDetails, unknown>;
+export declare function batchPaymentRequiredResponsePromptTokensDetailsFromJSON(jsonString: string): SafeParseResult<BatchPaymentRequiredResponsePromptTokensDetails, SDKValidationError>;
+/** @internal */
+export declare const BatchPaymentRequiredResponseServerToolUse$inboundSchema: z.ZodType<BatchPaymentRequiredResponseServerToolUse, unknown>;
+export declare function batchPaymentRequiredResponseServerToolUseFromJSON(jsonString: string): SafeParseResult<BatchPaymentRequiredResponseServerToolUse, SDKValidationError>;
+/** @internal */
+export declare const BatchPaymentRequiredResponseUsage$inboundSchema: z.ZodType<BatchPaymentRequiredResponseUsage, unknown>;
+export declare function batchPaymentRequiredResponseUsageFromJSON(jsonString: string): SafeParseResult<BatchPaymentRequiredResponseUsage, SDKValidationError>;
+//# sourceMappingURL=batchpaymentrequiredresponseerror.d.ts.map

package/esm/models/batchpaymentrequiredresponseerror.js

@@ -0,0 +1,136 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 9e233f8dd38a
+ */
+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 { AnthropicCacheCreation$inboundSchema, } from "./anthropiccachecreation.js";
+import { AnthropicSpeed$inboundSchema, } from "./anthropicspeed.js";
+import { AnthropicUsageIteration$inboundSchema, } from "./anthropicusageiteration.js";
+import { CostDetails$inboundSchema } from "./costdetails.js";
+export const BatchPaymentRequiredResponseCompletionWindow = {
+    TwentyFourh: "24h",
+};
+export const BatchPaymentRequiredResponseObject = {
+    Batch: "batch",
+};
+export const BatchPaymentRequiredResponseStatus = {
+    Validating: "validating",
+    InProgress: "in_progress",
+    Finalizing: "finalizing",
+    Completed: "completed",
+    Failed: "failed",
+    Expired: "expired",
+    Cancelling: "cancelling",
+    Cancelled: "cancelled",
+};
+/** @internal */
+export const BatchPaymentRequiredResponseCompletionWindow$inboundSchema = z.enum(BatchPaymentRequiredResponseCompletionWindow);
+/** @internal */
+export const BatchPaymentRequiredResponseError$inboundSchema = z.object({
+    code: z.int(),
+    message: z.string(),
+});
+export function batchPaymentRequiredResponseErrorFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => BatchPaymentRequiredResponseError$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'BatchPaymentRequiredResponseError' from JSON`);
+}
+/** @internal */
+export const BatchPaymentRequiredResponseObject$inboundSchema = z.enum(BatchPaymentRequiredResponseObject);
+/** @internal */
+export const BatchPaymentRequiredResponseRequestCounts$inboundSchema = z.object({
+    completed: z.int(),
+    failed: z.int(),
+    total: z.int(),
+});
+export function batchPaymentRequiredResponseRequestCountsFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => BatchPaymentRequiredResponseRequestCounts$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'BatchPaymentRequiredResponseRequestCounts' from JSON`);
+}
+/** @internal */
+export const BatchPaymentRequiredResponseStatus$inboundSchema = openEnums.inboundSchema(BatchPaymentRequiredResponseStatus);
+/** @internal */
+export const BatchPaymentRequiredResponseCompletionTokensDetails$inboundSchema = z
+    .object({
+    audio_tokens: z.nullable(z.int()).optional(),
+    image_tokens: z.nullable(z.int()).optional(),
+    reasoning_tokens: z.nullable(z.int()).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "audio_tokens": "audioTokens",
+        "image_tokens": "imageTokens",
+        "reasoning_tokens": "reasoningTokens",
+    });
+});
+export function batchPaymentRequiredResponseCompletionTokensDetailsFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => BatchPaymentRequiredResponseCompletionTokensDetails$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'BatchPaymentRequiredResponseCompletionTokensDetails' from JSON`);
+}
+/** @internal */
+export const BatchPaymentRequiredResponsePromptTokensDetails$inboundSchema = z
+    .object({
+    audio_tokens: z.nullable(z.int()).optional(),
+    cache_write_tokens: z.nullable(z.int()).optional(),
+    cached_tokens: z.nullable(z.int()).optional(),
+    file_tokens: z.nullable(z.int()).optional(),
+    video_tokens: z.nullable(z.int()).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "audio_tokens": "audioTokens",
+        "cache_write_tokens": "cacheWriteTokens",
+        "cached_tokens": "cachedTokens",
+        "file_tokens": "fileTokens",
+        "video_tokens": "videoTokens",
+    });
+});
+export function batchPaymentRequiredResponsePromptTokensDetailsFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => BatchPaymentRequiredResponsePromptTokensDetails$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'BatchPaymentRequiredResponsePromptTokensDetails' from JSON`);
+}
+/** @internal */
+export const BatchPaymentRequiredResponseServerToolUse$inboundSchema = z.object({
+    tool_calls_executed: z.nullable(z.int()).optional(),
+    tool_calls_requested: z.nullable(z.int()).optional(),
+    web_search_requests: z.nullable(z.int()).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "tool_calls_executed": "toolCallsExecuted",
+        "tool_calls_requested": "toolCallsRequested",
+        "web_search_requests": "webSearchRequests",
+    });
+});
+export function batchPaymentRequiredResponseServerToolUseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => BatchPaymentRequiredResponseServerToolUse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'BatchPaymentRequiredResponseServerToolUse' from JSON`);
+}
+/** @internal */
+export const BatchPaymentRequiredResponseUsage$inboundSchema = z.object({
+    cache_creation: z.nullable(AnthropicCacheCreation$inboundSchema).optional(),
+    completion_tokens: z.int(),
+    completion_tokens_details: z.nullable(z.lazy(() => BatchPaymentRequiredResponseCompletionTokensDetails$inboundSchema)).optional(),
+    cost: z.nullable(z.number()).optional(),
+    cost_details: z.nullable(CostDetails$inboundSchema).optional(),
+    is_byok: z.boolean().optional(),
+    iterations: z.nullable(z.array(AnthropicUsageIteration$inboundSchema))
+        .optional(),
+    prompt_tokens: z.int(),
+    prompt_tokens_details: z.nullable(z.lazy(() => BatchPaymentRequiredResponsePromptTokensDetails$inboundSchema)).optional(),
+    server_tool_use: z.nullable(z.lazy(() => BatchPaymentRequiredResponseServerToolUse$inboundSchema)).optional(),
+    service_tier: z.nullable(z.string()).optional(),
+    speed: z.nullable(AnthropicSpeed$inboundSchema).optional(),
+    total_tokens: z.int(),
+}).transform((v) => {
+    return remap$(v, {
+        "cache_creation": "cacheCreation",
+        "completion_tokens": "completionTokens",
+        "completion_tokens_details": "completionTokensDetails",
+        "cost_details": "costDetails",
+        "is_byok": "isByok",
+        "prompt_tokens": "promptTokens",
+        "prompt_tokens_details": "promptTokensDetails",
+        "server_tool_use": "serverToolUse",
+        "service_tier": "serviceTier",
+        "total_tokens": "totalTokens",
+    });
+});
+export function batchPaymentRequiredResponseUsageFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => BatchPaymentRequiredResponseUsage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'BatchPaymentRequiredResponseUsage' from JSON`);
+}
+//# sourceMappingURL=batchpaymentrequiredresponseerror.js.map

package/esm/models/batchproviderpreferences.d.ts

@@ -0,0 +1,25 @@
+import * as z from "zod/v4";
+import { ProviderName } from "./providername.js";
+export type BatchProviderPreferencesOnly = ProviderName | string;
+/**
+ * Batch provider routing preferences. Only `provider.only` is supported.
+ */
+export type BatchProviderPreferences = {
+    /**
+     * List of provider slugs to allow. If provided, this list is merged with your account-wide allowed provider settings for this request.
+     */
+    only?: Array<ProviderName | string> | null | undefined;
+};
+/** @internal */
+export type BatchProviderPreferencesOnly$Outbound = string | string;
+/** @internal */
+export declare const BatchProviderPreferencesOnly$outboundSchema: z.ZodType<BatchProviderPreferencesOnly$Outbound, BatchProviderPreferencesOnly>;
+export declare function batchProviderPreferencesOnlyToJSON(batchProviderPreferencesOnly: BatchProviderPreferencesOnly): string;
+/** @internal */
+export type BatchProviderPreferences$Outbound = {
+    only?: Array<string | string> | null | undefined;
+};
+/** @internal */
+export declare const BatchProviderPreferences$outboundSchema: z.ZodType<BatchProviderPreferences$Outbound, BatchProviderPreferences>;
+export declare function batchProviderPreferencesToJSON(batchProviderPreferences: BatchProviderPreferences): string;
+//# sourceMappingURL=batchproviderpreferences.d.ts.map

package/esm/models/batchproviderpreferences.js

@@ -0,0 +1,20 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 250964898edb
+ */
+import * as z from "zod/v4";
+import { ProviderName$outboundSchema } from "./providername.js";
+/** @internal */
+export const BatchProviderPreferencesOnly$outboundSchema = z.union([ProviderName$outboundSchema, z.string()]);
+export function batchProviderPreferencesOnlyToJSON(batchProviderPreferencesOnly) {
+    return JSON.stringify(BatchProviderPreferencesOnly$outboundSchema.parse(batchProviderPreferencesOnly));
+}
+/** @internal */
+export const BatchProviderPreferences$outboundSchema = z.object({
+    only: z.nullable(z.array(z.union([ProviderName$outboundSchema, z.string()])))
+        .optional(),
+});
+export function batchProviderPreferencesToJSON(batchProviderPreferences) {
+    return JSON.stringify(BatchProviderPreferences$outboundSchema.parse(batchProviderPreferences));
+}
+//# sourceMappingURL=batchproviderpreferences.js.map

package/esm/models/batchsubmitbody.d.ts

@@ -0,0 +1,62 @@
+import * as z from "zod/v4";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
+import { BatchProviderPreferences, BatchProviderPreferences$Outbound } from "./batchproviderpreferences.js";
+export declare const BatchSubmitBodyCompletionWindow: {
+    readonly TwentyFourh: "24h";
+};
+export type BatchSubmitBodyCompletionWindow = ClosedEnum<typeof BatchSubmitBodyCompletionWindow>;
+export declare const Endpoint: {
+    readonly RootV1ChatCompletions: "/v1/chat/completions";
+    readonly RootV1Responses: "/v1/responses";
+    readonly RootV1Messages: "/v1/messages";
+    readonly RootV1Embeddings: "/v1/embeddings";
+};
+export type Endpoint = OpenEnum<typeof Endpoint>;
+export type RequestT = {
+    /**
+     * Request payload for the batch `endpoint`.
+     */
+    body: {
+        [k: string]: any;
+    };
+    customId: string;
+};
+/**
+ * Batch submit request body.
+ */
+export type BatchSubmitBody = {
+    completionWindow?: BatchSubmitBodyCompletionWindow | undefined;
+    endpoint: Endpoint;
+    model: string;
+    /**
+     * Batch provider routing preferences. Only `provider.only` is supported.
+     */
+    provider?: BatchProviderPreferences | null | undefined;
+    requests: Array<RequestT>;
+};
+/** @internal */
+export declare const BatchSubmitBodyCompletionWindow$outboundSchema: z.ZodEnum<typeof BatchSubmitBodyCompletionWindow>;
+/** @internal */
+export declare const Endpoint$outboundSchema: z.ZodType<string, Endpoint>;
+/** @internal */
+export type RequestT$Outbound = {
+    body: {
+        [k: string]: any;
+    };
+    custom_id: string;
+};
+/** @internal */
+export declare const RequestT$outboundSchema: z.ZodType<RequestT$Outbound, RequestT>;
+export declare function requestToJSON(requestT: RequestT): string;
+/** @internal */
+export type BatchSubmitBody$Outbound = {
+    completion_window: string;
+    endpoint: string;
+    model: string;
+    provider?: BatchProviderPreferences$Outbound | null | undefined;
+    requests: Array<RequestT$Outbound>;
+};
+/** @internal */
+export declare const BatchSubmitBody$outboundSchema: z.ZodType<BatchSubmitBody$Outbound, BatchSubmitBody>;
+export declare function batchSubmitBodyToJSON(batchSubmitBody: BatchSubmitBody): string;
+//# sourceMappingURL=batchsubmitbody.d.ts.map

package/esm/models/batchsubmitbody.js

@@ -0,0 +1,51 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: ae38a7f7eb9d
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import * as openEnums from "../types/enums.js";
+import { BatchProviderPreferences$outboundSchema, } from "./batchproviderpreferences.js";
+export const BatchSubmitBodyCompletionWindow = {
+    TwentyFourh: "24h",
+};
+export const Endpoint = {
+    RootV1ChatCompletions: "/v1/chat/completions",
+    RootV1Responses: "/v1/responses",
+    RootV1Messages: "/v1/messages",
+    RootV1Embeddings: "/v1/embeddings",
+};
+/** @internal */
+export const BatchSubmitBodyCompletionWindow$outboundSchema = z.enum(BatchSubmitBodyCompletionWindow);
+/** @internal */
+export const Endpoint$outboundSchema = openEnums
+    .outboundSchema(Endpoint);
+/** @internal */
+export const RequestT$outboundSchema = z
+    .object({
+    body: z.record(z.string(), z.any()),
+    customId: z.string(),
+}).transform((v) => {
+    return remap$(v, {
+        customId: "custom_id",
+    });
+});
+export function requestToJSON(requestT) {
+    return JSON.stringify(RequestT$outboundSchema.parse(requestT));
+}
+/** @internal */
+export const BatchSubmitBody$outboundSchema = z.object({
+    completionWindow: BatchSubmitBodyCompletionWindow$outboundSchema.default("24h"),
+    endpoint: Endpoint$outboundSchema,
+    model: z.string(),
+    provider: z.nullable(BatchProviderPreferences$outboundSchema).optional(),
+    requests: z.array(z.lazy(() => RequestT$outboundSchema)),
+}).transform((v) => {
+    return remap$(v, {
+        completionWindow: "completion_window",
+    });
+});
+export function batchSubmitBodyToJSON(batchSubmitBody) {
+    return JSON.stringify(BatchSubmitBody$outboundSchema.parse(batchSubmitBody));
+}
+//# sourceMappingURL=batchsubmitbody.js.map

package/esm/models/debugevent.d.ts

@@ -2,40 +2,40 @@ 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 Event: {
+export declare const DebugEventEvent: {
     readonly AdapterRequest: "adapter_request";
     readonly UpstreamHeadersReceived: "upstream_headers_received";
     readonly FirstTokenReceived: "first_token_received";
     readonly UpstreamBodyEnded: "upstream_body_ended";
 };
-export type Event = OpenEnum<typeof Event>;
-export type Timings = {
+export type DebugEventEvent = OpenEnum<typeof DebugEventEvent>;
+export type DebugEventTimings = {
     epochMs: number;
-    event: Event;
+    event: DebugEventEvent;
     startMs: number;
 };
-export type Debug = {
+export type DebugEventDebug = {
     echoUpstreamBody?: {
         [k: string]: any;
     } | undefined;
-    timings?: Timings | undefined;
+    timings?: DebugEventTimings | undefined;
 };
 /**
  * Debug event emitted when debug.echo_upstream_body is true. Contains the transformed upstream request body or timing milestones.
  */
 export type DebugEvent = {
-    debug: Debug;
+    debug: DebugEventDebug;
     sequenceNumber: number;
     type: "response.debug";
 };
 /** @internal */
-export declare const Event$inboundSchema: z.ZodType<Event, unknown>;
+export declare const DebugEventEvent$inboundSchema: z.ZodType<DebugEventEvent, unknown>;
 /** @internal */
-export declare const Timings$inboundSchema: z.ZodType<Timings, unknown>;
-export declare function timingsFromJSON(jsonString: string): SafeParseResult<Timings, SDKValidationError>;
+export declare const DebugEventTimings$inboundSchema: z.ZodType<DebugEventTimings, unknown>;
+export declare function debugEventTimingsFromJSON(jsonString: string): SafeParseResult<DebugEventTimings, SDKValidationError>;
 /** @internal */
-export declare const Debug$inboundSchema: z.ZodType<Debug, unknown>;
-export declare function debugFromJSON(jsonString: string): SafeParseResult<Debug, SDKValidationError>;
+export declare const DebugEventDebug$inboundSchema: z.ZodType<DebugEventDebug, unknown>;
+export declare function debugEventDebugFromJSON(jsonString: string): SafeParseResult<DebugEventDebug, SDKValidationError>;
 /** @internal */
 export declare const DebugEvent$inboundSchema: z.ZodType<DebugEvent, unknown>;
 export declare function debugEventFromJSON(jsonString: string): SafeParseResult<DebugEvent, SDKValidationError>;

package/esm/models/debugevent.js

@@ -6,19 +6,18 @@ 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";
-export const Event = {
+export const DebugEventEvent = {
     AdapterRequest: "adapter_request",
     UpstreamHeadersReceived: "upstream_headers_received",
     FirstTokenReceived: "first_token_received",
     UpstreamBodyEnded: "upstream_body_ended",
 };
 /** @internal */
-export const Event$inboundSchema = openEnums
-    .inboundSchema(Event);
+export const DebugEventEvent$inboundSchema = openEnums.inboundSchema(DebugEventEvent);
 /** @internal */
-export const Timings$inboundSchema = z.object({
+export const DebugEventTimings$inboundSchema = z.object({
     epoch_ms: z.int(),
-    event: Event$inboundSchema,
+    event: DebugEventEvent$inboundSchema,
     start_ms: z.int(),
 }).transform((v) => {
     return remap$(v, {
@@ -26,25 +25,25 @@ export const Timings$inboundSchema = z.object({
         "start_ms": "startMs",
     });
 });
-export function timingsFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => Timings$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Timings' from JSON`);
+export function debugEventTimingsFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => DebugEventTimings$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'DebugEventTimings' from JSON`);
 }
 /** @internal */
-export const Debug$inboundSchema = z.object({
+export const DebugEventDebug$inboundSchema = z.object({
     echo_upstream_body: z.record(z.string(), z.any()).optional(),
-    timings: z.lazy(() => Timings$inboundSchema).optional(),
+    timings: z.lazy(() => DebugEventTimings$inboundSchema).optional(),
 }).transform((v) => {
     return remap$(v, {
         "echo_upstream_body": "echoUpstreamBody",
     });
 });
-export function debugFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => Debug$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Debug' from JSON`);
+export function debugEventDebugFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => DebugEventDebug$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'DebugEventDebug' from JSON`);
 }
 /** @internal */
 export const DebugEvent$inboundSchema = z
     .object({
-    debug: z.lazy(() => Debug$inboundSchema),
+    debug: z.lazy(() => DebugEventDebug$inboundSchema),
     sequence_number: z.int(),
     type: z.literal("response.debug"),
 }).transform((v) => {

package/esm/models/errors/batcherrorresponse.d.ts

@@ -0,0 +1,19 @@
+import * as z from "zod/v4";
+import * as models from "../index.js";
+import { OpenRouterError } from "./openroutererror.js";
+export type BatchErrorResponseData = {
+    error: models.BatchErrorResponseError;
+};
+export declare class BatchErrorResponse extends OpenRouterError {
+    error: models.BatchErrorResponseError;
+    /** The original data that was passed to this error instance. */
+    data$: BatchErrorResponseData;
+    constructor(err: BatchErrorResponseData, httpMeta: {
+        response: Response;
+        request: Request;
+        body: string;
+    });
+}
+/** @internal */
+export declare const BatchErrorResponse$inboundSchema: z.ZodType<BatchErrorResponse, unknown>;
+//# sourceMappingURL=batcherrorresponse.d.ts.map

package/esm/models/errors/batcherrorresponse.js

@@ -0,0 +1,32 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: f2cce3eb05df
+ */
+import * as z from "zod/v4";
+import { BatchErrorResponseError$inboundSchema as models_BatchErrorResponseError$inboundSchema } from "../batcherrorresponse.js";
+import { OpenRouterError } from "./openroutererror.js";
+export class BatchErrorResponse extends OpenRouterError {
+    constructor(err, httpMeta) {
+        const message = err.error?.message
+            || `API error occurred: ${JSON.stringify(err)}`;
+        super(message, httpMeta);
+        this.data$ = err;
+        this.error = err.error;
+        this.name = "BatchErrorResponse";
+    }
+}
+/** @internal */
+export const BatchErrorResponse$inboundSchema = z.object({
+    error: z.lazy(() => models_BatchErrorResponseError$inboundSchema),
+    request$: z.custom(x => x instanceof Request),
+    response$: z.custom(x => x instanceof Response),
+    body$: z.string(),
+})
+    .transform((v) => {
+    return new BatchErrorResponse(v, {
+        request: v.request$,
+        response: v.response$,
+        body: v.body$,
+    });
+});
+//# sourceMappingURL=batcherrorresponse.js.map