@openrouter/sdk 0.12.79 → 0.13.13

package/esm/models/fusionservertoolconfig.d.ts

@@ -1,9 +1,11 @@
 import * as z from "zod/v4";
 import { OpenEnum } from "../types/enums.js";
+import { AnthropicCacheControlDirective, AnthropicCacheControlDirective$Outbound } from "./anthropiccachecontroldirective.js";
 /**
  * Reasoning effort level for panelist and judge inner calls.
  */
 export declare const FusionServerToolConfigEffort: {
+    readonly Max: "max";
     readonly Xhigh: "xhigh";
     readonly High: "high";
     readonly Medium: "medium";
@@ -28,6 +30,18 @@ export type FusionServerToolConfigReasoning = {
      */
     maxTokens?: number | undefined;
 };
+export type FusionServerToolConfigTool = {
+    /**
+     * Optional configuration forwarded as the tool's `parameters` object.
+     */
+    parameters?: {
+        [k: string]: any | null;
+    } | undefined;
+    /**
+     * Server tool type identifier (e.g. "openrouter:web_search", "openrouter:web_fetch").
+     */
+    type: string;
+};
 /**
  * Configuration for the openrouter:fusion server tool.
  */
@@ -36,6 +50,10 @@ export type FusionServerToolConfig = {
      * Slugs of models to run in parallel as the analysis panel. Each model receives the user prompt with openrouter:web_search and openrouter:web_fetch enabled, then a judge model summarizes the collective output into structured analysis JSON. Capped at 8 models to bound cost amplification. Defaults to the Quality preset from /labs/fusion.
      */
     analysisModels?: Array<string> | undefined;
+    /**
+     * Enable automatic prompt caching. When set at the top level, the system automatically applies cache breakpoints to the last cacheable block in the request. Currently supported for Anthropic Claude models.
+     */
+    cacheControl?: AnthropicCacheControlDirective | undefined;
     /**
      * Maximum number of output tokens (including reasoning tokens) each panelist and the judge model may produce per inner call. Controls the total output budget so reasoning-heavy models like GPT-5.5 do not exhaust their token allowance before producing visible text. When omitted, the provider's default applies.
      */
@@ -53,9 +71,13 @@ export type FusionServerToolConfig = {
      */
     reasoning?: FusionServerToolConfigReasoning | undefined;
     /**
-     * Sampling temperature forwarded to panelist and judge inner calls. When omitted, the provider's default applies.
+     * Temperature forwarded to panelist inner calls. The judge always runs at temperature 0 regardless of this value. When omitted, the provider's default applies.
      */
     temperature?: number | undefined;
+    /**
+     * Server tools available to panelist and judge inner calls. Each entry uses the same `{ type, parameters? }` shorthand as the outer Chat Completions request. When omitted, defaults to `[{ type: "openrouter:web_search" }, { type: "openrouter:web_fetch" }]`. Pass an empty array to disable tools entirely (panelists answer from parametric knowledge only).
+     */
+    tools?: Array<FusionServerToolConfigTool> | undefined;
 };
 /** @internal */
 export declare const FusionServerToolConfigEffort$outboundSchema: z.ZodType<string, FusionServerToolConfigEffort>;
@@ -68,13 +90,25 @@ export type FusionServerToolConfigReasoning$Outbound = {
 export declare const FusionServerToolConfigReasoning$outboundSchema: z.ZodType<FusionServerToolConfigReasoning$Outbound, FusionServerToolConfigReasoning>;
 export declare function fusionServerToolConfigReasoningToJSON(fusionServerToolConfigReasoning: FusionServerToolConfigReasoning): string;
 /** @internal */
+export type FusionServerToolConfigTool$Outbound = {
+    parameters?: {
+        [k: string]: any | null;
+    } | undefined;
+    type: string;
+};
+/** @internal */
+export declare const FusionServerToolConfigTool$outboundSchema: z.ZodType<FusionServerToolConfigTool$Outbound, FusionServerToolConfigTool>;
+export declare function fusionServerToolConfigToolToJSON(fusionServerToolConfigTool: FusionServerToolConfigTool): string;
+/** @internal */
 export type FusionServerToolConfig$Outbound = {
     analysis_models?: Array<string> | undefined;
+    cache_control?: AnthropicCacheControlDirective$Outbound | undefined;
     max_completion_tokens?: number | undefined;
     max_tool_calls?: number | undefined;
     model?: string | undefined;
     reasoning?: FusionServerToolConfigReasoning$Outbound | undefined;
     temperature?: number | undefined;
+    tools?: Array<FusionServerToolConfigTool$Outbound> | undefined;
 };
 /** @internal */
 export declare const FusionServerToolConfig$outboundSchema: z.ZodType<FusionServerToolConfig$Outbound, FusionServerToolConfig>;

package/esm/models/fusionservertoolconfig.js

@@ -5,10 +5,12 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import * as openEnums from "../types/enums.js";
+import { AnthropicCacheControlDirective$outboundSchema, } from "./anthropiccachecontroldirective.js";
 /**
  * Reasoning effort level for panelist and judge inner calls.
  */
 export const FusionServerToolConfigEffort = {
+    Max: "max",
     Xhigh: "xhigh",
     High: "high",
     Medium: "medium",
@@ -31,17 +33,29 @@ export function fusionServerToolConfigReasoningToJSON(fusionServerToolConfigReas
     return JSON.stringify(FusionServerToolConfigReasoning$outboundSchema.parse(fusionServerToolConfigReasoning));
 }
 /** @internal */
+export const FusionServerToolConfigTool$outboundSchema = z.object({
+    parameters: z.record(z.string(), z.nullable(z.any())).optional(),
+    type: z.string(),
+});
+export function fusionServerToolConfigToolToJSON(fusionServerToolConfigTool) {
+    return JSON.stringify(FusionServerToolConfigTool$outboundSchema.parse(fusionServerToolConfigTool));
+}
+/** @internal */
 export const FusionServerToolConfig$outboundSchema = z.object({
     analysisModels: z.array(z.string()).optional(),
+    cacheControl: AnthropicCacheControlDirective$outboundSchema.optional(),
     maxCompletionTokens: z.int().optional(),
     maxToolCalls: z.int().optional(),
     model: z.string().optional(),
     reasoning: z.lazy(() => FusionServerToolConfigReasoning$outboundSchema)
         .optional(),
     temperature: z.number().optional(),
+    tools: z.array(z.lazy(() => FusionServerToolConfigTool$outboundSchema))
+        .optional(),
 }).transform((v) => {
     return remap$(v, {
         analysisModels: "analysis_models",
+        cacheControl: "cache_control",
         maxCompletionTokens: "max_completion_tokens",
         maxToolCalls: "max_tool_calls",
     });

package/esm/models/generationresponse.d.ts

@@ -13,11 +13,23 @@ export declare const ApiType: {
     readonly Tts: "tts";
     readonly Stt: "stt";
     readonly Video: "video";
+    readonly Image: "image";
 };
 /**
  * Type of API used for the generation
  */
 export type ApiType = OpenEnum<typeof ApiType>;
+/**
+ * The data region this generation was routed through. 'europe' for EU-routed requests, 'global' otherwise.
+ */
+export declare const DataRegion: {
+    readonly Global: "global";
+    readonly Europe: "europe";
+};
+/**
+ * The data region this generation was routed through. 'europe' for EU-routed requests, 'global' otherwise.
+ */
+export type DataRegion = OpenEnum<typeof DataRegion>;
 /**
  * Generation data
  */
@@ -42,6 +54,10 @@ export type GenerationResponseData = {
      * ISO 8601 timestamp of when the generation was created
      */
     createdAt: string;
+    /**
+     * The data region this generation was routed through. 'europe' for EU-routed requests, 'global' otherwise.
+     */
+    dataRegion: DataRegion;
     /**
      * External user identifier
      */
@@ -126,6 +142,10 @@ export type GenerationResponseData = {
      * Origin URL of the request
      */
     origin: string;
+    /**
+     * ID of the preset used for this generation, null if no preset was used
+     */
+    presetId: string | null;
     /**
      * Name of the provider that served the request
      */
@@ -203,6 +223,8 @@ export type GenerationResponse = {
 /** @internal */
 export declare const ApiType$inboundSchema: z.ZodType<ApiType, unknown>;
 /** @internal */
+export declare const DataRegion$inboundSchema: z.ZodType<DataRegion, unknown>;
+/** @internal */
 export declare const GenerationResponseData$inboundSchema: z.ZodType<GenerationResponseData, unknown>;
 export declare function generationResponseDataFromJSON(jsonString: string): SafeParseResult<GenerationResponseData, SDKValidationError>;
 /** @internal */

package/esm/models/generationresponse.js

@@ -17,17 +17,28 @@ export const ApiType = {
     Tts: "tts",
     Stt: "stt",
     Video: "video",
+    Image: "image",
+};
+/**
+ * The data region this generation was routed through. 'europe' for EU-routed requests, 'global' otherwise.
+ */
+export const DataRegion = {
+    Global: "global",
+    Europe: "europe",
 };
 /** @internal */
 export const ApiType$inboundSchema = openEnums
     .inboundSchema(ApiType);
 /** @internal */
+export const DataRegion$inboundSchema = openEnums.inboundSchema(DataRegion);
+/** @internal */
 export const GenerationResponseData$inboundSchema = z.object({
     api_type: z.nullable(ApiType$inboundSchema),
     app_id: z.nullable(z.int()),
     cache_discount: z.nullable(z.number()),
     cancelled: z.nullable(z.boolean()),
     created_at: z.string(),
+    data_region: DataRegion$inboundSchema,
     external_user: z.nullable(z.string()),
     finish_reason: z.nullable(z.string()),
     generation_time: z.nullable(z.number()),
@@ -49,6 +60,7 @@ export const GenerationResponseData$inboundSchema = z.object({
     num_media_prompt: z.nullable(z.int()),
     num_search_results: z.nullable(z.int()),
     origin: z.string(),
+    preset_id: z.nullable(z.string()),
     provider_name: z.nullable(z.string()),
     provider_responses: z.nullable(z.array(ProviderResponse$inboundSchema)),
     request_id: z.nullable(z.string()).optional(),
@@ -71,6 +83,7 @@ export const GenerationResponseData$inboundSchema = z.object({
         "app_id": "appId",
         "cache_discount": "cacheDiscount",
         "created_at": "createdAt",
+        "data_region": "dataRegion",
         "external_user": "externalUser",
         "finish_reason": "finishReason",
         "generation_time": "generationTime",
@@ -88,6 +101,7 @@ export const GenerationResponseData$inboundSchema = z.object({
         "num_media_completion": "numMediaCompletion",
         "num_media_prompt": "numMediaPrompt",
         "num_search_results": "numSearchResults",
+        "preset_id": "presetId",
         "provider_name": "providerName",
         "provider_responses": "providerResponses",
         "request_id": "requestId",

package/esm/models/getpresetresponse.d.ts

@@ -0,0 +1,17 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { PresetWithDesignatedVersion } from "./presetwithdesignatedversion.js";
+/**
+ * A preset with its currently designated version.
+ */
+export type GetPresetResponse = {
+    /**
+     * A preset with its currently designated version.
+     */
+    data: PresetWithDesignatedVersion;
+};
+/** @internal */
+export declare const GetPresetResponse$inboundSchema: z.ZodType<GetPresetResponse, unknown>;
+export declare function getPresetResponseFromJSON(jsonString: string): SafeParseResult<GetPresetResponse, SDKValidationError>;
+//# sourceMappingURL=getpresetresponse.d.ts.map

package/esm/models/getpresetresponse.js

@@ -0,0 +1,15 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: f3c5ddbd4b26
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { PresetWithDesignatedVersion$inboundSchema, } from "./presetwithdesignatedversion.js";
+/** @internal */
+export const GetPresetResponse$inboundSchema = z.object({
+    data: PresetWithDesignatedVersion$inboundSchema,
+});
+export function getPresetResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => GetPresetResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'GetPresetResponse' from JSON`);
+}
+//# sourceMappingURL=getpresetresponse.js.map

package/esm/models/getpresetversionresponse.d.ts

@@ -0,0 +1,17 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { PresetDesignatedVersion } from "./presetdesignatedversion.js";
+/**
+ * A single version of a preset.
+ */
+export type GetPresetVersionResponse = {
+    /**
+     * A specific version of a preset, containing config and optional system prompt.
+     */
+    data: PresetDesignatedVersion | null;
+};
+/** @internal */
+export declare const GetPresetVersionResponse$inboundSchema: z.ZodType<GetPresetVersionResponse, unknown>;
+export declare function getPresetVersionResponseFromJSON(jsonString: string): SafeParseResult<GetPresetVersionResponse, SDKValidationError>;
+//# sourceMappingURL=getpresetversionresponse.d.ts.map

package/esm/models/getpresetversionresponse.js

@@ -0,0 +1,15 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 28f0dd1227c4
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { PresetDesignatedVersion$inboundSchema, } from "./presetdesignatedversion.js";
+/** @internal */
+export const GetPresetVersionResponse$inboundSchema = z.object({
+    data: z.nullable(PresetDesignatedVersion$inboundSchema),
+});
+export function getPresetVersionResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => GetPresetVersionResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'GetPresetVersionResponse' from JSON`);
+}
+//# sourceMappingURL=getpresetversionresponse.js.map

package/esm/models/imageendpoint.d.ts

@@ -0,0 +1,41 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { CapabilityDescriptor } from "./capabilitydescriptor.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { ImagePricingEntry } from "./imagepricingentry.js";
+/**
+ * An endpoint that serves a given image model.
+ */
+export type ImageEndpoint = {
+    /**
+     * Provider-specific options accepted under provider.options[provider_slug].
+     */
+    allowedPassthroughParameters: Array<string>;
+    /**
+     * Billable pricing lines for this endpoint.
+     */
+    pricing: Array<ImagePricingEntry>;
+    /**
+     * Provider display name
+     */
+    providerName: string;
+    /**
+     * Provider slug
+     */
+    providerSlug: string;
+    /**
+     * Provider tag for request-side selection
+     */
+    providerTag: string | null;
+    supportedParameters: {
+        [k: string]: CapabilityDescriptor;
+    };
+    /**
+     * Whether this endpoint supports native SSE streaming (`stream: true` in the request).
+     */
+    supportsStreaming: boolean;
+};
+/** @internal */
+export declare const ImageEndpoint$inboundSchema: z.ZodType<ImageEndpoint, unknown>;
+export declare function imageEndpointFromJSON(jsonString: string): SafeParseResult<ImageEndpoint, SDKValidationError>;
+//# sourceMappingURL=imageendpoint.d.ts.map

package/esm/models/imageendpoint.js

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: e13b5353df71
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { CapabilityDescriptor$inboundSchema, } from "./capabilitydescriptor.js";
+import { ImagePricingEntry$inboundSchema, } from "./imagepricingentry.js";
+/** @internal */
+export const ImageEndpoint$inboundSchema = z
+    .object({
+    allowed_passthrough_parameters: z.array(z.string()),
+    pricing: z.array(ImagePricingEntry$inboundSchema),
+    provider_name: z.string(),
+    provider_slug: z.string(),
+    provider_tag: z.nullable(z.string()),
+    supported_parameters: z.record(z.string(), CapabilityDescriptor$inboundSchema),
+    supports_streaming: z.boolean(),
+}).transform((v) => {
+    return remap$(v, {
+        "allowed_passthrough_parameters": "allowedPassthroughParameters",
+        "provider_name": "providerName",
+        "provider_slug": "providerSlug",
+        "provider_tag": "providerTag",
+        "supported_parameters": "supportedParameters",
+        "supports_streaming": "supportsStreaming",
+    });
+});
+export function imageEndpointFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ImageEndpoint$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ImageEndpoint' from JSON`);
+}
+//# sourceMappingURL=imageendpoint.js.map

package/esm/models/imagegencompletedevent.d.ts

@@ -0,0 +1,29 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { ImageGenerationUsage } from "./imagegenerationusage.js";
+/**
+ * Emitted when generation completes and the final image is available
+ */
+export type ImageGenCompletedEvent = {
+    /**
+     * Base64-encoded final image data
+     */
+    b64Json: string;
+    /**
+     * Unix timestamp (seconds) when the image was generated
+     */
+    created: number;
+    /**
+     * The event type
+     */
+    type: "image_generation.completed";
+    /**
+     * Token and cost usage for the image generation request, when available
+     */
+    usage?: ImageGenerationUsage | undefined;
+};
+/** @internal */
+export declare const ImageGenCompletedEvent$inboundSchema: z.ZodType<ImageGenCompletedEvent, unknown>;
+export declare function imageGenCompletedEventFromJSON(jsonString: string): SafeParseResult<ImageGenCompletedEvent, SDKValidationError>;
+//# sourceMappingURL=imagegencompletedevent.d.ts.map

package/esm/models/imagegencompletedevent.js

@@ -0,0 +1,23 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: df990f384b54
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { ImageGenerationUsage$inboundSchema, } from "./imagegenerationusage.js";
+/** @internal */
+export const ImageGenCompletedEvent$inboundSchema = z.object({
+    b64_json: z.string(),
+    created: z.int(),
+    type: z.literal("image_generation.completed"),
+    usage: ImageGenerationUsage$inboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "b64_json": "b64Json",
+    });
+});
+export function imageGenCompletedEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ImageGenCompletedEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ImageGenCompletedEvent' from JSON`);
+}
+//# sourceMappingURL=imagegencompletedevent.js.map