@openrouter/sdk 1.4.25 → 1.5.1

package/esm/models/createobservabilitydestinationrequest.d.ts

@@ -37,6 +37,10 @@ export type CreateObservabilityDestinationRequest = {
      * When true, include cost and billing generation metadata.
      */
     broadcastGenerationCost?: boolean | undefined;
+    /**
+     * Beta. When true, include openrouter_cost_allocation: per-token-kind usage and cost, sent only when they reconcile with the billed cost.
+     */
+    broadcastGenerationCostAllocation?: boolean | undefined;
     /**
      * When true, include identity generation metadata.
      */
@@ -90,6 +94,7 @@ export declare const CreateObservabilityDestinationRequestType$outboundSchema: z
 export type CreateObservabilityDestinationRequest$Outbound = {
     api_key_hashes?: Array<string> | null | undefined;
     broadcast_generation_cost: boolean;
+    broadcast_generation_cost_allocation: boolean;
     broadcast_generation_identity: boolean;
     broadcast_generation_request_context: boolean;
     config: {

package/esm/models/createobservabilitydestinationrequest.js

@@ -36,6 +36,7 @@ export const CreateObservabilityDestinationRequestType$outboundSchema = openEnum
 export const CreateObservabilityDestinationRequest$outboundSchema = z.object({
     apiKeyHashes: z.nullable(z.array(z.string())).optional(),
     broadcastGenerationCost: z.boolean().default(false),
+    broadcastGenerationCostAllocation: z.boolean().default(false),
     broadcastGenerationIdentity: z.boolean().default(false),
     broadcastGenerationRequestContext: z.boolean().default(false),
     config: z.record(z.string(), z.any()),
@@ -52,6 +53,7 @@ export const CreateObservabilityDestinationRequest$outboundSchema = z.object({
     return remap$(v, {
         apiKeyHashes: "api_key_hashes",
         broadcastGenerationCost: "broadcast_generation_cost",
+        broadcastGenerationCostAllocation: "broadcast_generation_cost_allocation",
         broadcastGenerationIdentity: "broadcast_generation_identity",
         broadcastGenerationRequestContext: "broadcast_generation_request_context",
         filterRules: "filter_rules",

package/esm/models/customtool.d.ts

@@ -29,6 +29,7 @@ export type CustomTool = {
      * Lets the model keep working after calling this tool instead of waiting for its output. The tool is still executed by the client; return the result in a later request as a `function_call_output` with the original `call_id`. Only honored by providers whose Responses API supports async tools; ignored elsewhere.
      */
     async?: boolean | undefined;
+    deferLoading?: boolean | undefined;
     description?: string | undefined;
     format?: FormatText | FormatGrammar | discriminatedUnionTypes.Unknown<"type"> | undefined;
     name: string;
@@ -77,6 +78,7 @@ export declare const CustomTool$inboundSchema: z.ZodType<CustomTool, unknown>;
 /** @internal */
 export type CustomTool$Outbound = {
     async?: boolean | undefined;
+    defer_loading?: boolean | undefined;
     description?: string | undefined;
     format?: FormatText$Outbound | FormatGrammar$Outbound | undefined;
     name: string;

package/esm/models/customtool.js

@@ -3,6 +3,7 @@
  * @generated-id: b293ddf87321
  */
 import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { discriminatedUnion } from "../types/discriminatedUnion.js";
 import * as openEnums from "../types/enums.js";
@@ -78,6 +79,7 @@ export const CustomToolTypeCustom$outboundSchema = CustomToolTypeCustom$inboundS
 export const CustomTool$inboundSchema = z
     .object({
     async: z.boolean().optional(),
+    defer_loading: z.boolean().optional(),
     description: z.string().optional(),
     format: discriminatedUnion("type", {
         text: z.lazy(() => FormatText$inboundSchema),
@@ -85,10 +87,15 @@ export const CustomTool$inboundSchema = z
     }).optional(),
     name: z.string(),
     type: CustomToolTypeCustom$inboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        "defer_loading": "deferLoading",
+    });
 });
 /** @internal */
 export const CustomTool$outboundSchema = z.object({
     async: z.boolean().optional(),
+    deferLoading: z.boolean().optional(),
     description: z.string().optional(),
     format: z.union([
         z.lazy(() => FormatText$outboundSchema),
@@ -96,6 +103,10 @@ export const CustomTool$outboundSchema = z.object({
     ]).optional(),
     name: z.string(),
     type: CustomToolTypeCustom$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        deferLoading: "defer_loading",
+    });
 });
 export function customToolToJSON(customTool) {
     return JSON.stringify(CustomTool$outboundSchema.parse(customTool));

package/esm/models/decisionsboxanswer.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";
+export type Box = {
+    bottom: number;
+    left: number;
+    right: number;
+    top: number;
+};
+export type DecisionsBoxAnswer = {
+    box: Box;
+    confidence?: number | undefined;
+    type: "box";
+};
+/** @internal */
+export declare const Box$inboundSchema: z.ZodType<Box, unknown>;
+export declare function boxFromJSON(jsonString: string): SafeParseResult<Box, SDKValidationError>;
+/** @internal */
+export declare const DecisionsBoxAnswer$inboundSchema: z.ZodType<DecisionsBoxAnswer, unknown>;
+export declare function decisionsBoxAnswerFromJSON(jsonString: string): SafeParseResult<DecisionsBoxAnswer, SDKValidationError>;
+//# sourceMappingURL=decisionsboxanswer.d.ts.map

package/esm/models/decisionsboxanswer.js

@@ -0,0 +1,26 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 3c99e6f4aecb
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const Box$inboundSchema = z.object({
+    bottom: z.number(),
+    left: z.number(),
+    right: z.number(),
+    top: z.number(),
+});
+export function boxFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Box$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Box' from JSON`);
+}
+/** @internal */
+export const DecisionsBoxAnswer$inboundSchema = z.object({
+    box: z.lazy(() => Box$inboundSchema),
+    confidence: z.number().optional(),
+    type: z.literal("box"),
+});
+export function decisionsBoxAnswerFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => DecisionsBoxAnswer$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'DecisionsBoxAnswer' from JSON`);
+}
+//# sourceMappingURL=decisionsboxanswer.js.map

package/esm/models/decisionsboxquestion.d.ts

@@ -0,0 +1,34 @@
+import * as z from "zod/v4";
+/**
+ * A plain string, or a JSON object or array of structured guidance.
+ */
+export type DecisionsBoxQuestionInstructions = string | {
+    [k: string]: any;
+} | Array<any>;
+export type DecisionsBoxQuestion = {
+    /**
+     * A plain string, or a JSON object or array of structured guidance.
+     */
+    instructions: string | {
+        [k: string]: any;
+    } | Array<any>;
+    type: "box";
+};
+/** @internal */
+export type DecisionsBoxQuestionInstructions$Outbound = string | {
+    [k: string]: any;
+} | Array<any>;
+/** @internal */
+export declare const DecisionsBoxQuestionInstructions$outboundSchema: z.ZodType<DecisionsBoxQuestionInstructions$Outbound, DecisionsBoxQuestionInstructions>;
+export declare function decisionsBoxQuestionInstructionsToJSON(decisionsBoxQuestionInstructions: DecisionsBoxQuestionInstructions): string;
+/** @internal */
+export type DecisionsBoxQuestion$Outbound = {
+    instructions: string | {
+        [k: string]: any;
+    } | Array<any>;
+    type: "box";
+};
+/** @internal */
+export declare const DecisionsBoxQuestion$outboundSchema: z.ZodType<DecisionsBoxQuestion$Outbound, DecisionsBoxQuestion>;
+export declare function decisionsBoxQuestionToJSON(decisionsBoxQuestion: DecisionsBoxQuestion): string;
+//# sourceMappingURL=decisionsboxquestion.d.ts.map

package/esm/models/decisionsboxquestion.js

@@ -0,0 +1,23 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 6eacc9460742
+ */
+import * as z from "zod/v4";
+/** @internal */
+export const DecisionsBoxQuestionInstructions$outboundSchema = z.union([z.string(), z.record(z.string(), z.any()), z.array(z.any())]);
+export function decisionsBoxQuestionInstructionsToJSON(decisionsBoxQuestionInstructions) {
+    return JSON.stringify(DecisionsBoxQuestionInstructions$outboundSchema.parse(decisionsBoxQuestionInstructions));
+}
+/** @internal */
+export const DecisionsBoxQuestion$outboundSchema = z.object({
+    instructions: z.union([
+        z.string(),
+        z.record(z.string(), z.any()),
+        z.array(z.any()),
+    ]),
+    type: z.literal("box"),
+});
+export function decisionsBoxQuestionToJSON(decisionsBoxQuestion) {
+    return JSON.stringify(DecisionsBoxQuestion$outboundSchema.parse(decisionsBoxQuestion));
+}
+//# sourceMappingURL=decisionsboxquestion.js.map

package/esm/models/decisionsrequest.d.ts

@@ -1,13 +1,14 @@
 import * as z from "zod/v4";
+import { DecisionsBoxQuestion, DecisionsBoxQuestion$Outbound } from "./decisionsboxquestion.js";
 import { DecisionsChoiceQuestion, DecisionsChoiceQuestion$Outbound } from "./decisionschoicequestion.js";
 import { DecisionsNoulQuestion, DecisionsNoulQuestion$Outbound } from "./decisionsnoulquestion.js";
 import { DecisionsScoreQuestion, DecisionsScoreQuestion$Outbound } from "./decisionsscorequestion.js";
 import { ProviderPreferences, ProviderPreferences$Outbound } from "./providerpreferences.js";
 import { TraceConfig, TraceConfig$Outbound } from "./traceconfig.js";
 /**
- * A Decisions question using a boolean, choice, or ordered score evaluation.
+ * A Decisions question using a boolean, choice, ordered score, or image bounding-box evaluation.
  */
-export type Questions = DecisionsChoiceQuestion | DecisionsNoulQuestion | DecisionsScoreQuestion;
+export type Questions = DecisionsBoxQuestion | DecisionsChoiceQuestion | DecisionsNoulQuestion | DecisionsScoreQuestion;
 /**
  * The content to evaluate: a plain string, or a JSON object or array of related context.
  */
@@ -18,7 +19,7 @@ export type DecisionsRequest = {
     model: string;
     provider?: ProviderPreferences | null | undefined;
     questions: {
-        [k: string]: DecisionsChoiceQuestion | DecisionsNoulQuestion | DecisionsScoreQuestion;
+        [k: string]: DecisionsBoxQuestion | DecisionsChoiceQuestion | DecisionsNoulQuestion | DecisionsScoreQuestion;
     };
     /**
      * A unique identifier for grouping related requests (e.g., a conversation or agent workflow). Used for observability grouping in Broadcast and private logging; never sent to the provider. If provided in both the request body and the x-session-id header, the body value takes precedence. Maximum of 256 characters.
@@ -37,7 +38,7 @@ export type DecisionsRequest = {
     user?: string | undefined;
 };
 /** @internal */
-export type Questions$Outbound = DecisionsChoiceQuestion$Outbound | DecisionsNoulQuestion$Outbound | DecisionsScoreQuestion$Outbound;
+export type Questions$Outbound = DecisionsBoxQuestion$Outbound | DecisionsChoiceQuestion$Outbound | DecisionsNoulQuestion$Outbound | DecisionsScoreQuestion$Outbound;
 /** @internal */
 export declare const Questions$outboundSchema: z.ZodType<Questions$Outbound, Questions>;
 export declare function questionsToJSON(questions: Questions): string;
@@ -53,7 +54,7 @@ export type DecisionsRequest$Outbound = {
     model: string;
     provider?: ProviderPreferences$Outbound | null | undefined;
     questions: {
-        [k: string]: DecisionsChoiceQuestion$Outbound | DecisionsNoulQuestion$Outbound | DecisionsScoreQuestion$Outbound;
+        [k: string]: DecisionsBoxQuestion$Outbound | DecisionsChoiceQuestion$Outbound | DecisionsNoulQuestion$Outbound | DecisionsScoreQuestion$Outbound;
     };
     session_id?: string | undefined;
     state: string | {

package/esm/models/decisionsrequest.js

@@ -4,6 +4,7 @@
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
+import { DecisionsBoxQuestion$outboundSchema, } from "./decisionsboxquestion.js";
 import { DecisionsChoiceQuestion$outboundSchema, } from "./decisionschoicequestion.js";
 import { DecisionsNoulQuestion$outboundSchema, } from "./decisionsnoulquestion.js";
 import { DecisionsScoreQuestion$outboundSchema, } from "./decisionsscorequestion.js";
@@ -11,6 +12,7 @@ import { ProviderPreferences$outboundSchema, } from "./providerpreferences.js";
 import { TraceConfig$outboundSchema, } from "./traceconfig.js";
 /** @internal */
 export const Questions$outboundSchema = z.union([
+    DecisionsBoxQuestion$outboundSchema,
     DecisionsChoiceQuestion$outboundSchema,
     DecisionsNoulQuestion$outboundSchema,
     DecisionsScoreQuestion$outboundSchema,
@@ -32,6 +34,7 @@ export const DecisionsRequest$outboundSchema = z.object({
     model: z.string(),
     provider: z.nullable(ProviderPreferences$outboundSchema).optional(),
     questions: z.record(z.string(), z.union([
+        DecisionsBoxQuestion$outboundSchema,
         DecisionsChoiceQuestion$outboundSchema,
         DecisionsNoulQuestion$outboundSchema,
         DecisionsScoreQuestion$outboundSchema,

package/esm/models/decisionsresponse.d.ts

@@ -1,14 +1,15 @@
 import * as z from "zod/v4";
 import * as discriminatedUnionTypes from "../types/discriminatedUnion.js";
 import { Result as SafeParseResult } from "../types/fp.js";
+import { DecisionsBoxAnswer } from "./decisionsboxanswer.js";
 import { DecisionsChoiceAnswer } from "./decisionschoiceanswer.js";
 import { DecisionsNoulAnswer } from "./decisionsnoulanswer.js";
 import { DecisionsScoreAnswer } from "./decisionsscoreanswer.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 /**
- * A Decisions answer using a boolean, choice, or score evaluation.
+ * A Decisions answer using a boolean, choice, score, or image bounding-box evaluation.
  */
-export type Answers = DecisionsChoiceAnswer | DecisionsNoulAnswer | DecisionsScoreAnswer | discriminatedUnionTypes.Unknown<"type">;
+export type Answers = DecisionsBoxAnswer | DecisionsChoiceAnswer | DecisionsNoulAnswer | DecisionsScoreAnswer | discriminatedUnionTypes.Unknown<"type">;
 export type DecisionsResponseUsage = {
     cost?: number | undefined;
     inputTokens: number;
@@ -16,7 +17,7 @@ export type DecisionsResponseUsage = {
 };
 export type DecisionsResponse = {
     answers: {
-        [k: string]: DecisionsChoiceAnswer | DecisionsNoulAnswer | DecisionsScoreAnswer | discriminatedUnionTypes.Unknown<"type">;
+        [k: string]: DecisionsBoxAnswer | DecisionsChoiceAnswer | DecisionsNoulAnswer | DecisionsScoreAnswer | discriminatedUnionTypes.Unknown<"type">;
     };
     id?: string | undefined;
     model: string;

package/esm/models/decisionsresponse.js

@@ -6,11 +6,13 @@ import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { discriminatedUnion } from "../types/discriminatedUnion.js";
+import { DecisionsBoxAnswer$inboundSchema, } from "./decisionsboxanswer.js";
 import { DecisionsChoiceAnswer$inboundSchema, } from "./decisionschoiceanswer.js";
 import { DecisionsNoulAnswer$inboundSchema, } from "./decisionsnoulanswer.js";
 import { DecisionsScoreAnswer$inboundSchema, } from "./decisionsscoreanswer.js";
 /** @internal */
 export const Answers$inboundSchema = discriminatedUnion("type", {
+    box: DecisionsBoxAnswer$inboundSchema,
     choice: DecisionsChoiceAnswer$inboundSchema,
     noul: DecisionsNoulAnswer$inboundSchema,
     score: DecisionsScoreAnswer$inboundSchema,
@@ -35,6 +37,7 @@ export function decisionsResponseUsageFromJSON(jsonString) {
 /** @internal */
 export const DecisionsResponse$inboundSchema = z.object({
     answers: z.record(z.string(), discriminatedUnion("type", {
+        box: DecisionsBoxAnswer$inboundSchema,
         choice: DecisionsChoiceAnswer$inboundSchema,
         noul: DecisionsNoulAnswer$inboundSchema,
         score: DecisionsScoreAnswer$inboundSchema,

package/esm/models/deferredbm25search.d.ts

@@ -0,0 +1,17 @@
+import * as z from "zod/v4";
+/**
+ * Deterministic BM25 retrieval over supplied tool definitions.
+ */
+export type DeferredBm25Search = {
+    maxResults?: number | undefined;
+    type: "bm25";
+};
+/** @internal */
+export type DeferredBm25Search$Outbound = {
+    max_results?: number | undefined;
+    type: "bm25";
+};
+/** @internal */
+export declare const DeferredBm25Search$outboundSchema: z.ZodType<DeferredBm25Search$Outbound, DeferredBm25Search>;
+export declare function deferredBm25SearchToJSON(deferredBm25Search: DeferredBm25Search): string;
+//# sourceMappingURL=deferredbm25search.d.ts.map

package/esm/models/deferredbm25search.js

@@ -0,0 +1,19 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: e5f784d4b792
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+/** @internal */
+export const DeferredBm25Search$outboundSchema = z.object({
+    maxResults: z.int().optional(),
+    type: z.literal("bm25"),
+}).transform((v) => {
+    return remap$(v, {
+        maxResults: "max_results",
+    });
+});
+export function deferredBm25SearchToJSON(deferredBm25Search) {
+    return JSON.stringify(DeferredBm25Search$outboundSchema.parse(deferredBm25Search));
+}
+//# sourceMappingURL=deferredbm25search.js.map

package/esm/models/deferredcustomsearch.d.ts

@@ -0,0 +1,21 @@
+import * as z from "zod/v4";
+/**
+ * Caller-executed search returning existing tool identities under result_key.
+ */
+export type DeferredCustomSearch = {
+    maxResults?: number | undefined;
+    resultKey: string;
+    toolId: string;
+    type: "custom";
+};
+/** @internal */
+export type DeferredCustomSearch$Outbound = {
+    max_results?: number | undefined;
+    result_key: string;
+    tool_id: string;
+    type: "custom";
+};
+/** @internal */
+export declare const DeferredCustomSearch$outboundSchema: z.ZodType<DeferredCustomSearch$Outbound, DeferredCustomSearch>;
+export declare function deferredCustomSearchToJSON(deferredCustomSearch: DeferredCustomSearch): string;
+//# sourceMappingURL=deferredcustomsearch.d.ts.map

package/esm/models/deferredcustomsearch.js

@@ -0,0 +1,23 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: dc25441f118f
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+/** @internal */
+export const DeferredCustomSearch$outboundSchema = z.object({
+    maxResults: z.int().optional(),
+    resultKey: z.string(),
+    toolId: z.string(),
+    type: z.literal("custom"),
+}).transform((v) => {
+    return remap$(v, {
+        maxResults: "max_results",
+        resultKey: "result_key",
+        toolId: "tool_id",
+    });
+});
+export function deferredCustomSearchToJSON(deferredCustomSearch) {
+    return JSON.stringify(DeferredCustomSearch$outboundSchema.parse(deferredCustomSearch));
+}
+//# sourceMappingURL=deferredcustomsearch.js.map

package/esm/models/deferredregexsearch.d.ts

@@ -0,0 +1,17 @@
+import * as z from "zod/v4";
+/**
+ * Versioned safe-regex retrieval over supplied tool definitions.
+ */
+export type DeferredRegexSearch = {
+    maxResults?: number | undefined;
+    type: "regex";
+};
+/** @internal */
+export type DeferredRegexSearch$Outbound = {
+    max_results?: number | undefined;
+    type: "regex";
+};
+/** @internal */
+export declare const DeferredRegexSearch$outboundSchema: z.ZodType<DeferredRegexSearch$Outbound, DeferredRegexSearch>;
+export declare function deferredRegexSearchToJSON(deferredRegexSearch: DeferredRegexSearch): string;
+//# sourceMappingURL=deferredregexsearch.d.ts.map

package/esm/models/deferredregexsearch.js

@@ -0,0 +1,19 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 5304a4a58a5d
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+/** @internal */
+export const DeferredRegexSearch$outboundSchema = z.object({
+    maxResults: z.int().optional(),
+    type: z.literal("regex"),
+}).transform((v) => {
+    return remap$(v, {
+        maxResults: "max_results",
+    });
+});
+export function deferredRegexSearchToJSON(deferredRegexSearch) {
+    return JSON.stringify(DeferredRegexSearch$outboundSchema.parse(deferredRegexSearch));
+}
+//# sourceMappingURL=deferredregexsearch.js.map

package/esm/models/deferredtoolscontrol.d.ts

@@ -0,0 +1,62 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { DeferredToolsSearchStrategy, DeferredToolsSearchStrategy$Outbound } from "./deferredtoolssearchstrategy.js";
+/**
+ * Loading profile. Only `portable` is available in this release: OpenRouter serves deferral with router-built search and call wrappers on any model.
+ */
+export declare const Profile: {
+    readonly Portable: "portable";
+};
+/**
+ * Loading profile. Only `portable` is available in this release: OpenRouter serves deferral with router-built search and call wrappers on any model.
+ */
+export type Profile = ClosedEnum<typeof Profile>;
+export declare const Protocol: {
+    readonly V1: "v1";
+};
+export type Protocol = ClosedEnum<typeof Protocol>;
+/**
+ * Where tool-call arguments are checked against the original schema. Only `runtime` (in OpenRouter) is available in this release.
+ */
+export declare const Validation: {
+    readonly Runtime: "runtime";
+};
+/**
+ * Where tool-call arguments are checked against the original schema. Only `runtime` (in OpenRouter) is available in this release.
+ */
+export type Validation = ClosedEnum<typeof Validation>;
+/**
+ * Opt-in versioned router-level deferred-tool protocol. Replay assistant reasoning unchanged on continuation; keep the catalog unchanged.
+ */
+export type DeferredToolsControl = {
+    /**
+     * Loading profile. Only `portable` is available in this release: OpenRouter serves deferral with router-built search and call wrappers on any model.
+     */
+    profile: Profile;
+    protocol: Protocol;
+    /**
+     * Router-local regex/BM25 or caller-owned custom search.
+     */
+    search: DeferredToolsSearchStrategy;
+    /**
+     * Where tool-call arguments are checked against the original schema. Only `runtime` (in OpenRouter) is available in this release.
+     */
+    validation: Validation;
+};
+/** @internal */
+export declare const Profile$outboundSchema: z.ZodEnum<typeof Profile>;
+/** @internal */
+export declare const Protocol$outboundSchema: z.ZodEnum<typeof Protocol>;
+/** @internal */
+export declare const Validation$outboundSchema: z.ZodEnum<typeof Validation>;
+/** @internal */
+export type DeferredToolsControl$Outbound = {
+    profile: string;
+    protocol: string;
+    search: DeferredToolsSearchStrategy$Outbound;
+    validation: string;
+};
+/** @internal */
+export declare const DeferredToolsControl$outboundSchema: z.ZodType<DeferredToolsControl$Outbound, DeferredToolsControl>;
+export declare function deferredToolsControlToJSON(deferredToolsControl: DeferredToolsControl): string;
+//# sourceMappingURL=deferredtoolscontrol.d.ts.map

package/esm/models/deferredtoolscontrol.js

@@ -0,0 +1,38 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 117738d3058e
+ */
+import * as z from "zod/v4";
+import { DeferredToolsSearchStrategy$outboundSchema, } from "./deferredtoolssearchstrategy.js";
+/**
+ * Loading profile. Only `portable` is available in this release: OpenRouter serves deferral with router-built search and call wrappers on any model.
+ */
+export const Profile = {
+    Portable: "portable",
+};
+export const Protocol = {
+    V1: "v1",
+};
+/**
+ * Where tool-call arguments are checked against the original schema. Only `runtime` (in OpenRouter) is available in this release.
+ */
+export const Validation = {
+    Runtime: "runtime",
+};
+/** @internal */
+export const Profile$outboundSchema = z.enum(Profile);
+/** @internal */
+export const Protocol$outboundSchema = z.enum(Protocol);
+/** @internal */
+export const Validation$outboundSchema = z.enum(Validation);
+/** @internal */
+export const DeferredToolsControl$outboundSchema = z.object({
+    profile: Profile$outboundSchema,
+    protocol: Protocol$outboundSchema,
+    search: DeferredToolsSearchStrategy$outboundSchema,
+    validation: Validation$outboundSchema,
+});
+export function deferredToolsControlToJSON(deferredToolsControl) {
+    return JSON.stringify(DeferredToolsControl$outboundSchema.parse(deferredToolsControl));
+}
+//# sourceMappingURL=deferredtoolscontrol.js.map

package/esm/models/deferredtoolssearchstrategy.d.ts

@@ -0,0 +1,14 @@
+import * as z from "zod/v4";
+import { DeferredBm25Search, DeferredBm25Search$Outbound } from "./deferredbm25search.js";
+import { DeferredCustomSearch, DeferredCustomSearch$Outbound } from "./deferredcustomsearch.js";
+import { DeferredRegexSearch, DeferredRegexSearch$Outbound } from "./deferredregexsearch.js";
+/**
+ * Router-local regex/BM25 or caller-owned custom search.
+ */
+export type DeferredToolsSearchStrategy = DeferredBm25Search | DeferredCustomSearch | DeferredRegexSearch;
+/** @internal */
+export type DeferredToolsSearchStrategy$Outbound = DeferredBm25Search$Outbound | DeferredCustomSearch$Outbound | DeferredRegexSearch$Outbound;
+/** @internal */
+export declare const DeferredToolsSearchStrategy$outboundSchema: z.ZodType<DeferredToolsSearchStrategy$Outbound, DeferredToolsSearchStrategy>;
+export declare function deferredToolsSearchStrategyToJSON(deferredToolsSearchStrategy: DeferredToolsSearchStrategy): string;
+//# sourceMappingURL=deferredtoolssearchstrategy.d.ts.map

package/esm/models/deferredtoolssearchstrategy.js

@@ -0,0 +1,18 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 13c3e936a219
+ */
+import * as z from "zod/v4";
+import { DeferredBm25Search$outboundSchema, } from "./deferredbm25search.js";
+import { DeferredCustomSearch$outboundSchema, } from "./deferredcustomsearch.js";
+import { DeferredRegexSearch$outboundSchema, } from "./deferredregexsearch.js";
+/** @internal */
+export const DeferredToolsSearchStrategy$outboundSchema = z.union([
+    DeferredBm25Search$outboundSchema,
+    DeferredCustomSearch$outboundSchema,
+    DeferredRegexSearch$outboundSchema,
+]);
+export function deferredToolsSearchStrategyToJSON(deferredToolsSearchStrategy) {
+    return JSON.stringify(DeferredToolsSearchStrategy$outboundSchema.parse(deferredToolsSearchStrategy));
+}
+//# sourceMappingURL=deferredtoolssearchstrategy.js.map

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

@@ -9,10 +9,18 @@ export type BatchPaymentRequiredResponseErrorData = {
     createdAt: number;
     endpoint: string;
     error: models.BatchPaymentRequiredResponseError;
+    /**
+     * Unix timestamp after which the assigned provider no longer completes unfinished requests. Derived from the provider's documented batch window, so it can exceed `created_at` plus `completion_window` (Google Vertex can take up to 96 hours). `null` when the provider documents no hard expiry.
+     */
+    expiresAt: number | null;
     finalizedAt: number | null;
     id: string;
     model: string;
     object: models.BatchPaymentRequiredResponseObject;
+    /**
+     * Provider OpenRouter assigned to run the batch, using the same name as the `provider` field of sync responses.
+     */
+    provider: string | null;
     requestCounts: models.BatchPaymentRequiredResponseRequestCounts;
     /**
      * Always null: results are withheld until the batch charge is covered.
@@ -29,10 +37,18 @@ export declare class BatchPaymentRequiredResponseError extends OpenRouterError {
     createdAt: number;
     endpoint: string;
     error: models.BatchPaymentRequiredResponseError;
+    /**
+     * Unix timestamp after which the assigned provider no longer completes unfinished requests. Derived from the provider's documented batch window, so it can exceed `created_at` plus `completion_window` (Google Vertex can take up to 96 hours). `null` when the provider documents no hard expiry.
+     */
+    expiresAt: number | null;
     finalizedAt: number | null;
     id: string;
     model: string;
     object: models.BatchPaymentRequiredResponseObject;
+    /**
+     * Provider OpenRouter assigned to run the batch, using the same name as the `provider` field of sync responses.
+     */
+    provider: string | null;
     requestCounts: models.BatchPaymentRequiredResponseRequestCounts;
     /**
      * Always null: results are withheld until the batch charge is covered.

package/esm/models/errors/batchpaymentrequiredresponseerror.js

@@ -19,10 +19,12 @@ export class BatchPaymentRequiredResponseError extends OpenRouterError {
         this.createdAt = err.createdAt;
         this.endpoint = err.endpoint;
         this.error = err.error;
+        this.expiresAt = err.expiresAt;
         this.finalizedAt = err.finalizedAt;
         this.id = err.id;
         this.model = err.model;
         this.object = err.object;
+        this.provider = err.provider;
         this.requestCounts = err.requestCounts;
         this.results = err.results;
         this.status = err.status;
@@ -36,10 +38,12 @@ export const BatchPaymentRequiredResponseError$inboundSchema = z.object({
     created_at: z.int(),
     endpoint: z.string(),
     error: z.lazy(() => models_BatchPaymentRequiredResponseError$inboundSchema),
+    expires_at: z.nullable(z.int()),
     finalized_at: z.nullable(z.int()),
     id: z.string(),
     model: z.string(),
     object: models_BatchPaymentRequiredResponseObject$inboundSchema,
+    provider: z.nullable(z.string()),
     request_counts: z.lazy(() => models_BatchPaymentRequiredResponseRequestCounts$inboundSchema),
     results: z.nullable(z.any()),
     status: models_BatchPaymentRequiredResponseStatus$inboundSchema,
@@ -52,6 +56,7 @@ export const BatchPaymentRequiredResponseError$inboundSchema = z.object({
     const remapped = remap$(v, {
         "completion_window": "completionWindow",
         "created_at": "createdAt",
+        "expires_at": "expiresAt",
         "finalized_at": "finalizedAt",
         "request_counts": "requestCounts",
     });