@openrouter/sdk 1.4.24 → 1.5.0

package/esm/models/armorplugin.d.ts

@@ -0,0 +1,92 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+import { ArmorContext, ArmorContext$Outbound } from "./armorcontext.js";
+/**
+ * `enforce` withholds blocked calls; `audit` evaluates and reports the same verdicts without withholding any calls, regardless of `on_error`. Default `enforce`.
+ */
+export declare const ArmorPluginMode: {
+    readonly Enforce: "enforce";
+    readonly Audit: "audit";
+};
+/**
+ * `enforce` withholds blocked calls; `audit` evaluates and reports the same verdicts without withholding any calls, regardless of `on_error`. Default `enforce`.
+ */
+export type ArmorPluginMode = OpenEnum<typeof ArmorPluginMode>;
+/**
+ * When the classifier cannot answer (timeout, upstream error, context too long) the call is reported `unavailable`; `block` rejects it and `log` releases it. Default `block`.
+ */
+export declare const OnError: {
+    readonly Log: "log";
+    readonly Block: "block";
+};
+/**
+ * When the classifier cannot answer (timeout, upstream error, context too long) the call is reported `unavailable`; `block` rejects it and `log` releases it. Default `block`.
+ */
+export type OnError = OpenEnum<typeof OnError>;
+/**
+ * How a blocked call reaches the caller. `text` (the default): the call is withheld and an `<openrouter_armor_blocked>` marker stands in assistant text. `custom_item` (Responses API only): the call is withheld and an `openrouter:armor_blocked` output item carries its id, name, arguments and the rule that fired. `claude_code_compatibility` (Messages API only; the default when the request carries a `dangerous_tool_use` safeguard, i.e. the client speaks Claude Code's protocol): the `tool_use` stays in `content[]` and the verdict is `flagged` in `safeguard_results`, so the client withholds execution and writes the error tool result as under the native classifier. Under `text` and `custom_item` the model received a failure result in the loop and continued in the same request; under `claude_code_compatibility` the turn ends on the flagged call and the model continues on the next request, after the client's denial.
+ */
+export declare const OutputMode: {
+    readonly Text: "text";
+    readonly CustomItem: "custom_item";
+    readonly ClaudeCodeCompatibility: "claude_code_compatibility";
+};
+/**
+ * How a blocked call reaches the caller. `text` (the default): the call is withheld and an `<openrouter_armor_blocked>` marker stands in assistant text. `custom_item` (Responses API only): the call is withheld and an `openrouter:armor_blocked` output item carries its id, name, arguments and the rule that fired. `claude_code_compatibility` (Messages API only; the default when the request carries a `dangerous_tool_use` safeguard, i.e. the client speaks Claude Code's protocol): the `tool_use` stays in `content[]` and the verdict is `flagged` in `safeguard_results`, so the client withholds execution and writes the error tool result as under the native classifier. Under `text` and `custom_item` the model received a failure result in the loop and continued in the same request; under `claude_code_compatibility` the turn ends on the flagged call and the model continues on the next request, after the client's denial.
+ */
+export type OutputMode = OpenEnum<typeof OutputMode>;
+/**
+ * Evaluates every client tool call the model emits against a rule stack (hard-deny, soft-deny, allow) before it reaches the caller. The stack merges the workspace guardrail, this plugin, and any Anthropic `safeguards`; on endpoints that support Anthropic's `dangerous-tool-use` beta the evaluation is native, elsewhere it is one decisions call per tool call. Evaluation is not billed during the beta. Verdicts are reported as `safeguard_results`.
+ */
+export type ArmorPlugin = {
+    /**
+     * The Armor context: Claude Code's `classifier_context` (v1), with `auto_mode.{hard_deny,soft_deny,allow}` rules as strings or `{ id, instructions, threshold? }` objects and `auto_mode.environment` entries as `"Name: value"` strings or `{ name, value }` objects. `threshold` applies when Armor evaluates; when the provider evaluates natively (Anthropic dangerous-tool-use beta) rules are judged at the provider's own boundary.
+     */
+    classifierContext?: ArmorContext | undefined;
+    /**
+     * Set to false to disable Armor for this request. Defaults to true.
+     */
+    enabled?: boolean | undefined;
+    /**
+     * Run provider-native server tools (web search, code execution, ...) through the agent loop so Armor evaluates them too. Defaults to false: native passthrough stands and such calls are reported `skipped`.
+     */
+    evaluateNativeTools?: boolean | undefined;
+    id: "armor";
+    /**
+     * `enforce` withholds blocked calls; `audit` evaluates and reports the same verdicts without withholding any calls, regardless of `on_error`. Default `enforce`.
+     */
+    mode?: ArmorPluginMode | undefined;
+    /**
+     * When the classifier cannot answer (timeout, upstream error, context too long) the call is reported `unavailable`; `block` rejects it and `log` releases it. Default `block`.
+     */
+    onError?: OnError | undefined;
+    /**
+     * How a blocked call reaches the caller. `text` (the default): the call is withheld and an `<openrouter_armor_blocked>` marker stands in assistant text. `custom_item` (Responses API only): the call is withheld and an `openrouter:armor_blocked` output item carries its id, name, arguments and the rule that fired. `claude_code_compatibility` (Messages API only; the default when the request carries a `dangerous_tool_use` safeguard, i.e. the client speaks Claude Code's protocol): the `tool_use` stays in `content[]` and the verdict is `flagged` in `safeguard_results`, so the client withholds execution and writes the error tool result as under the native classifier. Under `text` and `custom_item` the model received a failure result in the loop and continued in the same request; under `claude_code_compatibility` the turn ends on the flagged call and the model continues on the next request, after the client's denial.
+     */
+    outputMode?: OutputMode | undefined;
+    /**
+     * Prepend Claude Code's built-in auto-mode rule set (1 hard-deny, 72 soft-deny, 17 allow, 21 environment slots) ahead of every configured rule. Defaults to true on the Anthropic Messages API and false elsewhere.
+     */
+    useCcStyleDefaultRules?: boolean | undefined;
+};
+/** @internal */
+export declare const ArmorPluginMode$outboundSchema: z.ZodType<string, ArmorPluginMode>;
+/** @internal */
+export declare const OnError$outboundSchema: z.ZodType<string, OnError>;
+/** @internal */
+export declare const OutputMode$outboundSchema: z.ZodType<string, OutputMode>;
+/** @internal */
+export type ArmorPlugin$Outbound = {
+    classifier_context?: ArmorContext$Outbound | undefined;
+    enabled?: boolean | undefined;
+    evaluate_native_tools?: boolean | undefined;
+    id: "armor";
+    mode?: string | undefined;
+    on_error?: string | undefined;
+    output_mode?: string | undefined;
+    use_cc_style_default_rules?: boolean | undefined;
+};
+/** @internal */
+export declare const ArmorPlugin$outboundSchema: z.ZodType<ArmorPlugin$Outbound, ArmorPlugin>;
+export declare function armorPluginToJSON(armorPlugin: ArmorPlugin): string;
+//# sourceMappingURL=armorplugin.d.ts.map

package/esm/models/armorplugin.js

@@ -0,0 +1,60 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: e7fcabe37ba6
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import * as openEnums from "../types/enums.js";
+import { ArmorContext$outboundSchema, } from "./armorcontext.js";
+/**
+ * `enforce` withholds blocked calls; `audit` evaluates and reports the same verdicts without withholding any calls, regardless of `on_error`. Default `enforce`.
+ */
+export const ArmorPluginMode = {
+    Enforce: "enforce",
+    Audit: "audit",
+};
+/**
+ * When the classifier cannot answer (timeout, upstream error, context too long) the call is reported `unavailable`; `block` rejects it and `log` releases it. Default `block`.
+ */
+export const OnError = {
+    Log: "log",
+    Block: "block",
+};
+/**
+ * How a blocked call reaches the caller. `text` (the default): the call is withheld and an `<openrouter_armor_blocked>` marker stands in assistant text. `custom_item` (Responses API only): the call is withheld and an `openrouter:armor_blocked` output item carries its id, name, arguments and the rule that fired. `claude_code_compatibility` (Messages API only; the default when the request carries a `dangerous_tool_use` safeguard, i.e. the client speaks Claude Code's protocol): the `tool_use` stays in `content[]` and the verdict is `flagged` in `safeguard_results`, so the client withholds execution and writes the error tool result as under the native classifier. Under `text` and `custom_item` the model received a failure result in the loop and continued in the same request; under `claude_code_compatibility` the turn ends on the flagged call and the model continues on the next request, after the client's denial.
+ */
+export const OutputMode = {
+    Text: "text",
+    CustomItem: "custom_item",
+    ClaudeCodeCompatibility: "claude_code_compatibility",
+};
+/** @internal */
+export const ArmorPluginMode$outboundSchema = openEnums.outboundSchema(ArmorPluginMode);
+/** @internal */
+export const OnError$outboundSchema = openEnums
+    .outboundSchema(OnError);
+/** @internal */
+export const OutputMode$outboundSchema = openEnums.outboundSchema(OutputMode);
+/** @internal */
+export const ArmorPlugin$outboundSchema = z.object({
+    classifierContext: ArmorContext$outboundSchema.optional(),
+    enabled: z.boolean().optional(),
+    evaluateNativeTools: z.boolean().optional(),
+    id: z.literal("armor"),
+    mode: ArmorPluginMode$outboundSchema.optional(),
+    onError: OnError$outboundSchema.optional(),
+    outputMode: OutputMode$outboundSchema.optional(),
+    useCcStyleDefaultRules: z.boolean().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        classifierContext: "classifier_context",
+        evaluateNativeTools: "evaluate_native_tools",
+        onError: "on_error",
+        outputMode: "output_mode",
+        useCcStyleDefaultRules: "use_cc_style_default_rules",
+    });
+});
+export function armorPluginToJSON(armorPlugin) {
+    return JSON.stringify(ArmorPlugin$outboundSchema.parse(armorPlugin));
+}
+//# sourceMappingURL=armorplugin.js.map

package/esm/models/armorrule.d.ts

@@ -0,0 +1,30 @@
+import * as z from "zod/v4";
+export type ArmorRule = {
+    /**
+     * Stable id, unique within its source; reported as the deciding rule when it fires.
+     */
+    id: string;
+    /**
+     * What the rule matches, written for the classifier.
+     */
+    instructions: string;
+    /**
+     * Display name shown in verdict explanations; defaults to the id.
+     */
+    name?: string | undefined;
+    /**
+     * Probability at or above which the rule counts as matched. Defaults to 0.6 for hard-deny and soft-deny rules and 0.7 for allow rules (an exception needs stronger evidence to clear a matched soft deny).
+     */
+    threshold?: number | undefined;
+};
+/** @internal */
+export type ArmorRule$Outbound = {
+    id: string;
+    instructions: string;
+    name?: string | undefined;
+    threshold?: number | undefined;
+};
+/** @internal */
+export declare const ArmorRule$outboundSchema: z.ZodType<ArmorRule$Outbound, ArmorRule>;
+export declare function armorRuleToJSON(armorRule: ArmorRule): string;
+//# sourceMappingURL=armorrule.d.ts.map

package/esm/models/armorrule.js

@@ -0,0 +1,16 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: b6b09f7af630
+ */
+import * as z from "zod/v4";
+/** @internal */
+export const ArmorRule$outboundSchema = z.object({
+    id: z.string(),
+    instructions: z.string(),
+    name: z.string().optional(),
+    threshold: z.number().optional(),
+});
+export function armorRuleToJSON(armorRule) {
+    return JSON.stringify(ArmorRule$outboundSchema.parse(armorRule));
+}
+//# sourceMappingURL=armorrule.js.map

package/esm/models/armorsafeguardresult.d.ts

@@ -0,0 +1,69 @@
+import * as z from "zod/v4";
+import * as discriminatedUnionTypes from "../types/discriminatedUnion.js";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type ToolUsesUnavailable = {
+    reason: string;
+    type: "unavailable";
+};
+export type ToolUsesSkipped = {
+    type: "skipped";
+};
+export declare const OutcomeEnum: {
+    readonly Flagged: "flagged";
+    readonly NotFlagged: "not_flagged";
+};
+export type OutcomeEnum = OpenEnum<typeof OutcomeEnum>;
+export type ToolUsesEvaluated = {
+    explanation?: string | undefined;
+    outcome: OutcomeEnum;
+    type: "evaluated";
+};
+export type ToolUses = ToolUsesEvaluated | ToolUsesSkipped | ToolUsesUnavailable | discriminatedUnionTypes.Unknown<"type">;
+export declare const TypeAvailableEnum: {
+    readonly Available: "available";
+};
+export type TypeAvailableEnum = ClosedEnum<typeof TypeAvailableEnum>;
+export type ArmorSafeguardResultStatus = {
+    toolUses: {
+        [k: string]: ToolUsesEvaluated | ToolUsesSkipped | ToolUsesUnavailable | discriminatedUnionTypes.Unknown<"type">;
+    };
+    type: TypeAvailableEnum;
+};
+export declare const TypeDangerousToolUse: {
+    readonly DangerousToolUse: "dangerous_tool_use";
+};
+export type TypeDangerousToolUse = ClosedEnum<typeof TypeDangerousToolUse>;
+/**
+ * The outcome of OpenRouter Armor for each client tool call of the response, keyed by tool-call id, in the same shape Anthropic reports its server-side safeguards.
+ */
+export type ArmorSafeguardResult = {
+    status: ArmorSafeguardResultStatus;
+    type: TypeDangerousToolUse;
+};
+/** @internal */
+export declare const ToolUsesUnavailable$inboundSchema: z.ZodType<ToolUsesUnavailable, unknown>;
+export declare function toolUsesUnavailableFromJSON(jsonString: string): SafeParseResult<ToolUsesUnavailable, SDKValidationError>;
+/** @internal */
+export declare const ToolUsesSkipped$inboundSchema: z.ZodType<ToolUsesSkipped, unknown>;
+export declare function toolUsesSkippedFromJSON(jsonString: string): SafeParseResult<ToolUsesSkipped, SDKValidationError>;
+/** @internal */
+export declare const OutcomeEnum$inboundSchema: z.ZodType<OutcomeEnum, unknown>;
+/** @internal */
+export declare const ToolUsesEvaluated$inboundSchema: z.ZodType<ToolUsesEvaluated, unknown>;
+export declare function toolUsesEvaluatedFromJSON(jsonString: string): SafeParseResult<ToolUsesEvaluated, SDKValidationError>;
+/** @internal */
+export declare const ToolUses$inboundSchema: z.ZodType<ToolUses, unknown>;
+export declare function toolUsesFromJSON(jsonString: string): SafeParseResult<ToolUses, SDKValidationError>;
+/** @internal */
+export declare const TypeAvailableEnum$inboundSchema: z.ZodEnum<typeof TypeAvailableEnum>;
+/** @internal */
+export declare const ArmorSafeguardResultStatus$inboundSchema: z.ZodType<ArmorSafeguardResultStatus, unknown>;
+export declare function armorSafeguardResultStatusFromJSON(jsonString: string): SafeParseResult<ArmorSafeguardResultStatus, SDKValidationError>;
+/** @internal */
+export declare const TypeDangerousToolUse$inboundSchema: z.ZodEnum<typeof TypeDangerousToolUse>;
+/** @internal */
+export declare const ArmorSafeguardResult$inboundSchema: z.ZodType<ArmorSafeguardResult, unknown>;
+export declare function armorSafeguardResultFromJSON(jsonString: string): SafeParseResult<ArmorSafeguardResult, SDKValidationError>;
+//# sourceMappingURL=armorsafeguardresult.d.ts.map

package/esm/models/armorsafeguardresult.js

@@ -0,0 +1,83 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 29944500746e
+ */
+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";
+export const OutcomeEnum = {
+    Flagged: "flagged",
+    NotFlagged: "not_flagged",
+};
+export const TypeAvailableEnum = {
+    Available: "available",
+};
+export const TypeDangerousToolUse = {
+    DangerousToolUse: "dangerous_tool_use",
+};
+/** @internal */
+export const ToolUsesUnavailable$inboundSchema = z.object({
+    reason: z.string(),
+    type: z.literal("unavailable"),
+});
+export function toolUsesUnavailableFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ToolUsesUnavailable$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ToolUsesUnavailable' from JSON`);
+}
+/** @internal */
+export const ToolUsesSkipped$inboundSchema = z.object({
+    type: z.literal("skipped"),
+});
+export function toolUsesSkippedFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ToolUsesSkipped$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ToolUsesSkipped' from JSON`);
+}
+/** @internal */
+export const OutcomeEnum$inboundSchema = openEnums.inboundSchema(OutcomeEnum);
+/** @internal */
+export const ToolUsesEvaluated$inboundSchema = z.object({
+    explanation: z.string().optional(),
+    outcome: OutcomeEnum$inboundSchema,
+    type: z.literal("evaluated"),
+});
+export function toolUsesEvaluatedFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ToolUsesEvaluated$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ToolUsesEvaluated' from JSON`);
+}
+/** @internal */
+export const ToolUses$inboundSchema = discriminatedUnion("type", {
+    evaluated: z.lazy(() => ToolUsesEvaluated$inboundSchema),
+    skipped: z.lazy(() => ToolUsesSkipped$inboundSchema),
+    unavailable: z.lazy(() => ToolUsesUnavailable$inboundSchema),
+});
+export function toolUsesFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ToolUses$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ToolUses' from JSON`);
+}
+/** @internal */
+export const TypeAvailableEnum$inboundSchema = z.enum(TypeAvailableEnum);
+/** @internal */
+export const ArmorSafeguardResultStatus$inboundSchema = z.object({
+    tool_uses: z.record(z.string(), discriminatedUnion("type", {
+        evaluated: z.lazy(() => ToolUsesEvaluated$inboundSchema),
+        skipped: z.lazy(() => ToolUsesSkipped$inboundSchema),
+        unavailable: z.lazy(() => ToolUsesUnavailable$inboundSchema),
+    })),
+    type: TypeAvailableEnum$inboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        "tool_uses": "toolUses",
+    });
+});
+export function armorSafeguardResultStatusFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ArmorSafeguardResultStatus$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ArmorSafeguardResultStatus' from JSON`);
+}
+/** @internal */
+export const TypeDangerousToolUse$inboundSchema = z.enum(TypeDangerousToolUse);
+/** @internal */
+export const ArmorSafeguardResult$inboundSchema = z.object({
+    status: z.lazy(() => ArmorSafeguardResultStatus$inboundSchema),
+    type: TypeDangerousToolUse$inboundSchema,
+});
+export function armorSafeguardResultFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ArmorSafeguardResult$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ArmorSafeguardResult' from JSON`);
+}
+//# sourceMappingURL=armorsafeguardresult.js.map

package/esm/models/batchlistitem.d.ts

@@ -139,10 +139,18 @@ export type BatchListItem = {
     createdAt: number;
     endpoint: string;
     error: BatchListItemError | null;
+    /**
+     * 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: BatchListItemObject;
+    /**
+     * Provider OpenRouter assigned to run the batch, using the same name as the `provider` field of sync responses.
+     */
+    provider: string | null;
     requestCounts: BatchListItemRequestCounts;
     /**
      * Always null: retrieve the batch with `GET /batches/{id}` to access its results.

package/esm/models/batchlistitem.js

@@ -137,10 +137,12 @@ export const BatchListItem$inboundSchema = z
     created_at: z.int(),
     endpoint: z.string(),
     error: z.nullable(z.lazy(() => BatchListItemError$inboundSchema)),
+    expires_at: z.nullable(z.int()),
     finalized_at: z.nullable(z.int()),
     id: z.string(),
     model: z.string(),
     object: BatchListItemObject$inboundSchema,
+    provider: z.nullable(z.string()),
     request_counts: z.lazy(() => BatchListItemRequestCounts$inboundSchema),
     results: z.nullable(z.any()),
     status: BatchListItemStatus$inboundSchema,
@@ -149,6 +151,7 @@ export const BatchListItem$inboundSchema = z
     return remap$(v, {
         "completion_window": "completionWindow",
         "created_at": "createdAt",
+        "expires_at": "expiresAt",
         "finalized_at": "finalizedAt",
         "request_counts": "requestCounts",
     });

package/esm/models/batchobject.d.ts

@@ -13,6 +13,7 @@ import { AnthropicServiceTier } from "./anthropicservicetier.js";
 import { AnthropicSpeed } from "./anthropicspeed.js";
 import { AnthropicUsageIteration } from "./anthropicusageiteration.js";
 import { ApiErrorType } from "./apierrortype.js";
+import { ArmorSafeguardResult } from "./armorsafeguardresult.js";
 import { CostDetails } from "./costdetails.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import { FinishReason } from "./finishreason.js";
@@ -442,6 +443,10 @@ export type BodyChatCompletion = {
     object: BodyObjectChatCompletion;
     openrouterMetadata?: OpenRouterMetadata | undefined;
     provider?: string | null | undefined;
+    /**
+     * OpenRouter Armor's verdict for each client tool call of this response, present whenever Armor evaluated the response (even when nothing was flagged). Independent of the `openrouter_metadata` opt-in.
+     */
+    safeguardResults?: Array<ArmorSafeguardResult> | undefined;
     serviceTier?: string | null | undefined;
     systemFingerprint?: string | null | undefined;
     usage?: BodyUsage1 | undefined;
@@ -572,10 +577,18 @@ export type BatchObject = {
     createdAt: number;
     endpoint: string;
     error: BatchObjectError | null;
+    /**
+     * 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: BatchObjectObjectBatch;
+    /**
+     * Provider OpenRouter assigned to run the batch, using the same name as the `provider` field of sync responses.
+     */
+    provider: string | null;
     requestCounts: BatchObjectRequestCounts;
     results: Array<Result> | null;
     status: BatchObjectStatus;

package/esm/models/batchobject.js

@@ -18,6 +18,7 @@ import { AnthropicServiceTier$inboundSchema, } from "./anthropicservicetier.js";
 import { AnthropicSpeed$inboundSchema, } from "./anthropicspeed.js";
 import { AnthropicUsageIteration$inboundSchema, } from "./anthropicusageiteration.js";
 import { ApiErrorType$inboundSchema } from "./apierrortype.js";
+import { ArmorSafeguardResult$inboundSchema, } from "./armorsafeguardresult.js";
 import { CostDetails$inboundSchema } from "./costdetails.js";
 import { FinishReason$inboundSchema } from "./finishreason.js";
 import { OpenResponsesResult$inboundSchema, } from "./openresponsesresult.js";
@@ -643,12 +644,14 @@ export const BodyChatCompletion$inboundSchema = z.object({
     object: BodyObjectChatCompletion$inboundSchema,
     openrouter_metadata: OpenRouterMetadata$inboundSchema.optional(),
     provider: z.nullable(z.string()).optional(),
+    safeguard_results: z.array(ArmorSafeguardResult$inboundSchema).optional(),
     service_tier: z.nullable(z.string()).optional(),
     system_fingerprint: z.nullable(z.string()).optional(),
     usage: z.lazy(() => BodyUsage1$inboundSchema).optional(),
 }).transform((v) => {
     return remap$(v, {
         "openrouter_metadata": "openrouterMetadata",
+        "safeguard_results": "safeguardResults",
         "service_tier": "serviceTier",
         "system_fingerprint": "systemFingerprint",
     });
@@ -790,10 +793,12 @@ export const BatchObject$inboundSchema = z
     created_at: z.int(),
     endpoint: z.string(),
     error: z.nullable(z.lazy(() => BatchObjectError$inboundSchema)),
+    expires_at: z.nullable(z.int()),
     finalized_at: z.nullable(z.int()),
     id: z.string(),
     model: z.string(),
     object: BatchObjectObjectBatch$inboundSchema,
+    provider: z.nullable(z.string()),
     request_counts: z.lazy(() => BatchObjectRequestCounts$inboundSchema),
     results: z.nullable(z.array(z.lazy(() => Result$inboundSchema))),
     status: BatchObjectStatus$inboundSchema,
@@ -802,6 +807,7 @@ export const BatchObject$inboundSchema = z
     return remap$(v, {
         "completion_window": "completionWindow",
         "created_at": "createdAt",
+        "expires_at": "expiresAt",
         "finalized_at": "finalizedAt",
         "request_counts": "requestCounts",
     });

package/esm/models/batchsubmitbody.d.ts

@@ -25,6 +25,10 @@ export type RequestT = {
  * Batch submit request body.
  */
 export type BatchSubmitBody = {
+    /**
+     * HTTPS URL that receives a `batch.completed`, `batch.failed`, `batch.cancelled` or `batch.expired` webhook event when the batch reaches a terminal status. Must appear before `requests` in the request body.
+     */
+    callbackUrl?: string | undefined;
     completionWindow?: BatchSubmitBodyCompletionWindow | undefined;
     endpoint: Endpoint;
     model: string;
@@ -50,6 +54,7 @@ export declare const RequestT$outboundSchema: z.ZodType<RequestT$Outbound, Reque
 export declare function requestToJSON(requestT: RequestT): string;
 /** @internal */
 export type BatchSubmitBody$Outbound = {
+    callback_url?: string | undefined;
     completion_window: string;
     endpoint: string;
     model: string;

package/esm/models/batchsubmitbody.js

@@ -35,6 +35,7 @@ export function requestToJSON(requestT) {
 }
 /** @internal */
 export const BatchSubmitBody$outboundSchema = z.object({
+    callbackUrl: z.string().optional(),
     completionWindow: BatchSubmitBodyCompletionWindow$outboundSchema.default("24h"),
     endpoint: Endpoint$outboundSchema,
     model: z.string(),
@@ -42,6 +43,7 @@ export const BatchSubmitBody$outboundSchema = z.object({
     requests: z.array(z.lazy(() => RequestT$outboundSchema)),
 }).transform((v) => {
     return remap$(v, {
+        callbackUrl: "callback_url",
         completionWindow: "completion_window",
     });
 });

package/esm/models/byokkey.d.ts

@@ -4,7 +4,7 @@ import { Result as SafeParseResult } from "../types/fp.js";
 import { BYOKProviderSlug } from "./byokproviderslug.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 /**
- * Your declaration of the data region in which the upstream provider account behind this credential processes requests, used for routing eligibility on OpenRouter's regional hosts. `null` means undeclared and `global` is behaviorally identical: the credential follows the region OpenRouter records for the endpoint. `europe` or `us` lets requests to `eu.openrouter.ai` or `us.openrouter.ai` use this credential for that provider (private endpoints, endpoints pinned to another cloud region, cross-region inference profiles and video models are excluded). Self-declared and not verified by OpenRouter. For OpenAI and Fireworks the region comes from the key material (a `{"api_key": ..., "region": ...}` key), so the value must match the key's region. Among other providers, only Azure accepts `europe` or `us`.
+ * Your declaration of the data region in which the upstream provider account behind this credential processes requests, used for routing eligibility on OpenRouter's regional hosts. `null` means undeclared and `global` is behaviorally identical: the credential follows the region OpenRouter records for the endpoint. `europe` or `us` lets requests to `eu.openrouter.ai` or `us.openrouter.ai` use this credential for that provider (private endpoints, endpoints pinned to another cloud region, cross-region inference profiles and video models are excluded). Self-declared and not verified by OpenRouter. For OpenAI and Fireworks the region comes from the key material (a `{"api_key": ..., "region": ...}` key), so the value must match the key's region. Among other providers, Azure accepts `europe` or `us` and Anthropic accepts `us` only.
  */
 export declare const BYOKKeyDeclaredRegion: {
     readonly Global: "global";
@@ -12,7 +12,7 @@ export declare const BYOKKeyDeclaredRegion: {
     readonly Us: "us";
 };
 /**
- * Your declaration of the data region in which the upstream provider account behind this credential processes requests, used for routing eligibility on OpenRouter's regional hosts. `null` means undeclared and `global` is behaviorally identical: the credential follows the region OpenRouter records for the endpoint. `europe` or `us` lets requests to `eu.openrouter.ai` or `us.openrouter.ai` use this credential for that provider (private endpoints, endpoints pinned to another cloud region, cross-region inference profiles and video models are excluded). Self-declared and not verified by OpenRouter. For OpenAI and Fireworks the region comes from the key material (a `{"api_key": ..., "region": ...}` key), so the value must match the key's region. Among other providers, only Azure accepts `europe` or `us`.
+ * Your declaration of the data region in which the upstream provider account behind this credential processes requests, used for routing eligibility on OpenRouter's regional hosts. `null` means undeclared and `global` is behaviorally identical: the credential follows the region OpenRouter records for the endpoint. `europe` or `us` lets requests to `eu.openrouter.ai` or `us.openrouter.ai` use this credential for that provider (private endpoints, endpoints pinned to another cloud region, cross-region inference profiles and video models are excluded). Self-declared and not verified by OpenRouter. For OpenAI and Fireworks the region comes from the key material (a `{"api_key": ..., "region": ...}` key), so the value must match the key's region. Among other providers, Azure accepts `europe` or `us` and Anthropic accepts `us` only.
  */
 export type BYOKKeyDeclaredRegion = OpenEnum<typeof BYOKKeyDeclaredRegion>;
 export type BYOKKey = {
@@ -33,7 +33,7 @@ export type BYOKKey = {
      */
     createdAt: string;
     /**
-     * Your declaration of the data region in which the upstream provider account behind this credential processes requests, used for routing eligibility on OpenRouter's regional hosts. `null` means undeclared and `global` is behaviorally identical: the credential follows the region OpenRouter records for the endpoint. `europe` or `us` lets requests to `eu.openrouter.ai` or `us.openrouter.ai` use this credential for that provider (private endpoints, endpoints pinned to another cloud region, cross-region inference profiles and video models are excluded). Self-declared and not verified by OpenRouter. For OpenAI and Fireworks the region comes from the key material (a `{"api_key": ..., "region": ...}` key), so the value must match the key's region. Among other providers, only Azure accepts `europe` or `us`.
+     * Your declaration of the data region in which the upstream provider account behind this credential processes requests, used for routing eligibility on OpenRouter's regional hosts. `null` means undeclared and `global` is behaviorally identical: the credential follows the region OpenRouter records for the endpoint. `europe` or `us` lets requests to `eu.openrouter.ai` or `us.openrouter.ai` use this credential for that provider (private endpoints, endpoints pinned to another cloud region, cross-region inference profiles and video models are excluded). Self-declared and not verified by OpenRouter. For OpenAI and Fireworks the region comes from the key material (a `{"api_key": ..., "region": ...}` key), so the value must match the key's region. Among other providers, Azure accepts `europe` or `us` and Anthropic accepts `us` only.
      */
     declaredRegion: BYOKKeyDeclaredRegion | null;
     /**

package/esm/models/byokkey.js

@@ -8,7 +8,7 @@ import { safeParse } from "../lib/schemas.js";
 import * as openEnums from "../types/enums.js";
 import { BYOKProviderSlug$inboundSchema, } from "./byokproviderslug.js";
 /**
- * Your declaration of the data region in which the upstream provider account behind this credential processes requests, used for routing eligibility on OpenRouter's regional hosts. `null` means undeclared and `global` is behaviorally identical: the credential follows the region OpenRouter records for the endpoint. `europe` or `us` lets requests to `eu.openrouter.ai` or `us.openrouter.ai` use this credential for that provider (private endpoints, endpoints pinned to another cloud region, cross-region inference profiles and video models are excluded). Self-declared and not verified by OpenRouter. For OpenAI and Fireworks the region comes from the key material (a `{"api_key": ..., "region": ...}` key), so the value must match the key's region. Among other providers, only Azure accepts `europe` or `us`.
+ * Your declaration of the data region in which the upstream provider account behind this credential processes requests, used for routing eligibility on OpenRouter's regional hosts. `null` means undeclared and `global` is behaviorally identical: the credential follows the region OpenRouter records for the endpoint. `europe` or `us` lets requests to `eu.openrouter.ai` or `us.openrouter.ai` use this credential for that provider (private endpoints, endpoints pinned to another cloud region, cross-region inference profiles and video models are excluded). Self-declared and not verified by OpenRouter. For OpenAI and Fireworks the region comes from the key material (a `{"api_key": ..., "region": ...}` key), so the value must match the key's region. Among other providers, Azure accepts `europe` or `us` and Anthropic accepts `us` only.
  */
 export const BYOKKeyDeclaredRegion = {
     Global: "global",

package/esm/models/byokproviderslug.d.ts

@@ -82,6 +82,7 @@ export declare const BYOKProviderSlug: {
     readonly OpenInference: "open-inference";
     readonly Openai: "openai";
     readonly Parasail: "parasail";
+    readonly ParetoAlpha: "pareto-alpha";
     readonly Perceptron: "perceptron";
     readonly Perplexity: "perplexity";
     readonly Phala: "phala";
@@ -89,6 +90,7 @@ export declare const BYOKProviderSlug: {
     readonly Primeintellect: "primeintellect";
     readonly Quiver: "quiver";
     readonly Recraft: "recraft";
+    readonly Recursive: "recursive";
     readonly Reka: "reka";
     readonly Relace: "relace";
     readonly Respan: "respan";

package/esm/models/byokproviderslug.js

@@ -85,6 +85,7 @@ export const BYOKProviderSlug = {
     OpenInference: "open-inference",
     Openai: "openai",
     Parasail: "parasail",
+    ParetoAlpha: "pareto-alpha",
     Perceptron: "perceptron",
     Perplexity: "perplexity",
     Phala: "phala",
@@ -92,6 +93,7 @@ export const BYOKProviderSlug = {
     Primeintellect: "primeintellect",
     Quiver: "quiver",
     Recraft: "recraft",
+    Recursive: "recursive",
     Reka: "reka",
     Relace: "relace",
     Respan: "respan",

package/esm/models/chatcontenttext.d.ts

@@ -17,7 +17,7 @@ export type ChatContentText = {
      */
     cacheControl?: ChatContentCacheControl | undefined;
     /**
-     * Marks an explicit prompt-cache boundary on this content block (OpenAI-style). Everything through the block carrying this marker is part of the candidate cached prefix. Supported natively by OpenAI GPT-5.6 and newer; on providers that use Anthropic-style `cache_control`, OpenRouter converts the marker to that format automatically.
+     * Marks an explicit prompt-cache boundary on this content block (OpenAI-style). Everything through the block carrying this marker is part of the candidate cached prefix. Supported natively by OpenAI GPT-5.6 and newer; on providers that use Anthropic-style `cache_control`, OpenRouter converts the marker to that format automatically. `ttl` ("30m" or "12h") overrides the request-level `prompt_cache_options.ttl` for this boundary; 12h writes bill at the higher cache-write rate.
      */
     promptCacheBreakpoint?: PromptCacheBreakpoint | null | undefined;
     text: string;

package/esm/models/chatfunctiontool.d.ts

@@ -17,6 +17,7 @@ import { WebFetchServerTool, WebFetchServerTool$Outbound } from "./webfetchserve
  * Function definition for tool calling
  */
 export type ChatFunctionToolFunctionFunction = {
+    deferLoading?: boolean | undefined;
     /**
      * Function description for the model
      */
@@ -45,6 +46,7 @@ export type ChatFunctionToolFunction = {
      * Anthropic-style cache breakpoint for the content part. Interchangeable with the OpenAI-style `prompt_cache_breakpoint` marker: OpenRouter converts between the two based on the provider serving the request.
      */
     cacheControl?: ChatContentCacheControl | undefined;
+    deferLoading?: boolean | undefined;
     /**
      * Function definition for tool calling
      */
@@ -57,6 +59,7 @@ export type ChatFunctionToolFunction = {
 export type ChatFunctionTool = ChatFunctionToolFunction | AdvisorServerToolOpenRouter | BashServerTool | DatetimeServerTool | FilesServerTool | FusionServerToolOpenRouter | ImageGenerationServerToolOpenRouter | ChatSearchModelsServerTool | SubagentServerToolOpenRouter | WebFetchServerTool | OpenRouterWebSearchServerTool | ChatWebSearchShorthand | ChatDynamicServerTool;
 /** @internal */
 export type ChatFunctionToolFunctionFunction$Outbound = {
+    defer_loading?: boolean | undefined;
     description?: string | undefined;
     name: string;
     parameters?: {
@@ -72,6 +75,7 @@ export declare const ChatFunctionToolType$outboundSchema: z.ZodEnum<typeof ChatF
 /** @internal */
 export type ChatFunctionToolFunction$Outbound = {
     cache_control?: ChatContentCacheControl$Outbound | undefined;
+    defer_loading?: boolean | undefined;
     function: ChatFunctionToolFunctionFunction$Outbound;
     type: string;
 };