@openrouter/sdk 0.3.11 → 0.3.14

package/esm/lib/tool-types.d.ts

@@ -1,4 +1,4 @@
-import type { ZodObject, ZodRawShape, ZodType, z } from 'zod';
+import type { $ZodObject, $ZodShape, $ZodType, infer as zodInfer } from 'zod/v4/core';
 import type * as models from '../models/index.js';
 import type { OpenResponsesStreamEvent } from '../models/index.js';
 import type { ModelResult } from './model-result.js';
@@ -53,18 +53,18 @@ export type NextTurnParamsFunctions<TInput> = {
 /**
  * Base tool function interface with inputSchema
  */
-export interface BaseToolFunction<TInput extends ZodObject<ZodRawShape>> {
+export interface BaseToolFunction<TInput extends $ZodObject<$ZodShape>> {
     name: string;
     description?: string;
     inputSchema: TInput;
-    nextTurnParams?: NextTurnParamsFunctions<z.infer<TInput>>;
+    nextTurnParams?: NextTurnParamsFunctions<zodInfer<TInput>>;
 }
 /**
  * Regular tool with synchronous or asynchronous execute function and optional outputSchema
  */
-export interface ToolFunctionWithExecute<TInput extends ZodObject<ZodRawShape>, TOutput extends ZodType = ZodType<unknown>> extends BaseToolFunction<TInput> {
+export interface ToolFunctionWithExecute<TInput extends $ZodObject<$ZodShape>, TOutput extends $ZodType = $ZodType<unknown>> extends BaseToolFunction<TInput> {
     outputSchema?: TOutput;
-    execute: (params: z.infer<TInput>, context?: TurnContext) => Promise<z.infer<TOutput>> | z.infer<TOutput>;
+    execute: (params: zodInfer<TInput>, context?: TurnContext) => Promise<zodInfer<TOutput>> | zodInfer<TOutput>;
 }
 /**
  * Generator-based tool with async generator execute function
@@ -88,42 +88,42 @@ export interface ToolFunctionWithExecute<TInput extends ZodObject<ZodRawShape>,
  * }
  * ```
  */
-export interface ToolFunctionWithGenerator<TInput extends ZodObject<ZodRawShape>, TEvent extends ZodType = ZodType<unknown>, TOutput extends ZodType = ZodType<unknown>> extends BaseToolFunction<TInput> {
+export interface ToolFunctionWithGenerator<TInput extends $ZodObject<$ZodShape>, TEvent extends $ZodType = $ZodType<unknown>, TOutput extends $ZodType = $ZodType<unknown>> extends BaseToolFunction<TInput> {
     eventSchema: TEvent;
     outputSchema: TOutput;
-    execute: (params: z.infer<TInput>, context?: TurnContext) => AsyncGenerator<z.infer<TEvent> | z.infer<TOutput>>;
+    execute: (params: zodInfer<TInput>, context?: TurnContext) => AsyncGenerator<zodInfer<TEvent> | zodInfer<TOutput>>;
 }
 /**
  * Manual tool without execute function - requires manual handling by developer
  */
-export interface ManualToolFunction<TInput extends ZodObject<ZodRawShape>, TOutput extends ZodType = ZodType<unknown>> extends BaseToolFunction<TInput> {
+export interface ManualToolFunction<TInput extends $ZodObject<$ZodShape>, TOutput extends $ZodType = $ZodType<unknown>> extends BaseToolFunction<TInput> {
     outputSchema?: TOutput;
 }
 /**
  * Tool with execute function (regular or generator)
  */
-export type ToolWithExecute<TInput extends ZodObject<ZodRawShape> = ZodObject<ZodRawShape>, TOutput extends ZodType = ZodType<unknown>> = {
+export type ToolWithExecute<TInput extends $ZodObject<$ZodShape> = $ZodObject<$ZodShape>, TOutput extends $ZodType = $ZodType<unknown>> = {
     type: ToolType.Function;
     function: ToolFunctionWithExecute<TInput, TOutput>;
 };
 /**
  * Tool with generator execute function
  */
-export type ToolWithGenerator<TInput extends ZodObject<ZodRawShape> = ZodObject<ZodRawShape>, TEvent extends ZodType = ZodType<unknown>, TOutput extends ZodType = ZodType<unknown>> = {
+export type ToolWithGenerator<TInput extends $ZodObject<$ZodShape> = $ZodObject<$ZodShape>, TEvent extends $ZodType = $ZodType<unknown>, TOutput extends $ZodType = $ZodType<unknown>> = {
     type: ToolType.Function;
     function: ToolFunctionWithGenerator<TInput, TEvent, TOutput>;
 };
 /**
  * Tool without execute function (manual handling)
  */
-export type ManualTool<TInput extends ZodObject<ZodRawShape> = ZodObject<ZodRawShape>, TOutput extends ZodType = ZodType<unknown>> = {
+export type ManualTool<TInput extends $ZodObject<$ZodShape> = $ZodObject<$ZodShape>, TOutput extends $ZodType = $ZodType<unknown>> = {
     type: ToolType.Function;
     function: ManualToolFunction<TInput, TOutput>;
 };
 /**
  * Union type of all enhanced tool types
  */
-export type Tool = ToolWithExecute<ZodObject<ZodRawShape>, ZodType<unknown>> | ToolWithGenerator<ZodObject<ZodRawShape>, ZodType<unknown>, ZodType<unknown>> | ManualTool<ZodObject<ZodRawShape>, ZodType<unknown>>;
+export type Tool = ToolWithExecute<$ZodObject<$ZodShape>, $ZodType<unknown>> | ToolWithGenerator<$ZodObject<$ZodShape>, $ZodType<unknown>, $ZodType<unknown>> | ManualTool<$ZodObject<$ZodShape>, $ZodType<unknown>>;
 /**
  * Extracts the input type from a tool definition
  */
@@ -131,7 +131,7 @@ export type InferToolInput<T> = T extends {
     function: {
         inputSchema: infer S;
     };
-} ? S extends ZodType ? z.infer<S> : unknown : unknown;
+} ? S extends $ZodType ? zodInfer<S> : unknown : unknown;
 /**
  * Extracts the output type from a tool definition
  */
@@ -139,7 +139,7 @@ export type InferToolOutput<T> = T extends {
     function: {
         outputSchema: infer S;
     };
-} ? S extends ZodType ? z.infer<S> : unknown : unknown;
+} ? S extends $ZodType ? zodInfer<S> : unknown : unknown;
 /**
  * A tool call with typed arguments based on the tool's inputSchema
  */
@@ -172,7 +172,7 @@ export type InferToolEvent<T> = T extends {
     function: {
         eventSchema: infer S;
     };
-} ? S extends ZodType ? z.infer<S> : never : never;
+} ? S extends $ZodType ? zodInfer<S> : never : never;
 /**
  * Union of event types for all generator tools in a tuple
  * Filters out non-generator tools (which return `never`)
@@ -216,8 +216,8 @@ export interface ParsedToolCall<T extends Tool> {
 export interface ToolExecutionResult<T extends Tool> {
     toolCallId: string;
     toolName: string;
-    result: T extends ToolWithExecute<any, infer O> | ToolWithGenerator<any, any, infer O> ? z.infer<O> : unknown;
-    preliminaryResults?: T extends ToolWithGenerator<any, infer E, any> ? z.infer<E>[] : undefined;
+    result: T extends ToolWithExecute<any, infer O> | ToolWithGenerator<any, any, infer O> ? zodInfer<O> : unknown;
+    preliminaryResults?: T extends ToolWithGenerator<any, infer E, any> ? zodInfer<E>[] : undefined;
     error?: Error;
 }
 /**
@@ -237,7 +237,7 @@ export interface StepResult<TTools extends readonly Tool[] = readonly Tool[]> {
     readonly toolCalls: TypedToolCallUnion<TTools>[];
     readonly toolResults: ToolExecutionResultUnion<TTools>[];
     readonly response: models.OpenResponsesNonStreamingResponse;
-    readonly usage?: models.OpenResponsesUsage | undefined;
+    readonly usage?: models.OpenResponsesUsage | null | undefined;
     readonly finishReason?: string | undefined;
     readonly warnings?: Warning[] | undefined;
     readonly experimental_providerMetadata?: Record<string, unknown> | undefined;

package/esm/lib/tool.d.ts

@@ -1,49 +1,49 @@
-import type { ZodObject, ZodRawShape, ZodType, z } from "zod";
+import type { $ZodObject, $ZodShape, $ZodType, infer as zodInfer } from 'zod/v4/core';
 import { type TurnContext, type ToolWithExecute, type ToolWithGenerator, type ManualTool, type NextTurnParamsFunctions } from "./tool-types.js";
 /**
  * Configuration for a regular tool with outputSchema
  */
-type RegularToolConfigWithOutput<TInput extends ZodObject<ZodRawShape>, TOutput extends ZodType> = {
+type RegularToolConfigWithOutput<TInput extends $ZodObject<$ZodShape>, TOutput extends $ZodType> = {
     name: string;
     description?: string;
     inputSchema: TInput;
     outputSchema: TOutput;
     eventSchema?: undefined;
-    nextTurnParams?: NextTurnParamsFunctions<z.infer<TInput>>;
-    execute: (params: z.infer<TInput>, context?: TurnContext) => Promise<z.infer<TOutput>> | z.infer<TOutput>;
+    nextTurnParams?: NextTurnParamsFunctions<zodInfer<TInput>>;
+    execute: (params: zodInfer<TInput>, context?: TurnContext) => Promise<zodInfer<TOutput>> | zodInfer<TOutput>;
 };
 /**
  * Configuration for a regular tool without outputSchema (infers return type from execute)
  */
-type RegularToolConfigWithoutOutput<TInput extends ZodObject<ZodRawShape>, TReturn> = {
+type RegularToolConfigWithoutOutput<TInput extends $ZodObject<$ZodShape>, TReturn> = {
     name: string;
     description?: string;
     inputSchema: TInput;
     outputSchema?: undefined;
     eventSchema?: undefined;
-    nextTurnParams?: NextTurnParamsFunctions<z.infer<TInput>>;
-    execute: (params: z.infer<TInput>, context?: TurnContext) => Promise<TReturn> | TReturn;
+    nextTurnParams?: NextTurnParamsFunctions<zodInfer<TInput>>;
+    execute: (params: zodInfer<TInput>, context?: TurnContext) => Promise<TReturn> | TReturn;
 };
 /**
  * Configuration for a generator tool (with eventSchema)
  */
-type GeneratorToolConfig<TInput extends ZodObject<ZodRawShape>, TEvent extends ZodType, TOutput extends ZodType> = {
+type GeneratorToolConfig<TInput extends $ZodObject<$ZodShape>, TEvent extends $ZodType, TOutput extends $ZodType> = {
     name: string;
     description?: string;
     inputSchema: TInput;
     eventSchema: TEvent;
     outputSchema: TOutput;
-    nextTurnParams?: NextTurnParamsFunctions<z.infer<TInput>>;
-    execute: (params: z.infer<TInput>, context?: TurnContext) => AsyncGenerator<z.infer<TEvent> | z.infer<TOutput>>;
+    nextTurnParams?: NextTurnParamsFunctions<zodInfer<TInput>>;
+    execute: (params: zodInfer<TInput>, context?: TurnContext) => AsyncGenerator<zodInfer<TEvent> | zodInfer<TOutput>>;
 };
 /**
  * Configuration for a manual tool (execute: false, no eventSchema or outputSchema)
  */
-type ManualToolConfig<TInput extends ZodObject<ZodRawShape>> = {
+type ManualToolConfig<TInput extends $ZodObject<$ZodShape>> = {
     name: string;
     description?: string;
     inputSchema: TInput;
-    nextTurnParams?: NextTurnParamsFunctions<z.infer<TInput>>;
+    nextTurnParams?: NextTurnParamsFunctions<zodInfer<TInput>>;
     execute: false;
 };
 /**
@@ -91,9 +91,9 @@ type ManualToolConfig<TInput extends ZodObject<ZodRawShape>> = {
  * });
  * ```
  */
-export declare function tool<TInput extends ZodObject<ZodRawShape>, TEvent extends ZodType, TOutput extends ZodType>(config: GeneratorToolConfig<TInput, TEvent, TOutput>): ToolWithGenerator<TInput, TEvent, TOutput>;
-export declare function tool<TInput extends ZodObject<ZodRawShape>>(config: ManualToolConfig<TInput>): ManualTool<TInput>;
-export declare function tool<TInput extends ZodObject<ZodRawShape>, TOutput extends ZodType>(config: RegularToolConfigWithOutput<TInput, TOutput>): ToolWithExecute<TInput, TOutput>;
-export declare function tool<TInput extends ZodObject<ZodRawShape>, TReturn>(config: RegularToolConfigWithoutOutput<TInput, TReturn>): ToolWithExecute<TInput, ZodType<TReturn>>;
+export declare function tool<TInput extends $ZodObject<$ZodShape>, TEvent extends $ZodType, TOutput extends $ZodType>(config: GeneratorToolConfig<TInput, TEvent, TOutput>): ToolWithGenerator<TInput, TEvent, TOutput>;
+export declare function tool<TInput extends $ZodObject<$ZodShape>>(config: ManualToolConfig<TInput>): ManualTool<TInput>;
+export declare function tool<TInput extends $ZodObject<$ZodShape>, TOutput extends $ZodType>(config: RegularToolConfigWithOutput<TInput, TOutput>): ToolWithExecute<TInput, TOutput>;
+export declare function tool<TInput extends $ZodObject<$ZodShape>, TReturn>(config: RegularToolConfigWithoutOutput<TInput, TReturn>): ToolWithExecute<TInput, $ZodType<TReturn>>;
 export {};
 //# sourceMappingURL=tool.d.ts.map

package/esm/models/chatgenerationparams.d.ts

@@ -35,6 +35,20 @@ export type ChatGenerationParamsMaxPrice = {
     audio?: any | undefined;
     request?: any | undefined;
 };
+export type ChatGenerationParamsPreferredMinThroughput = {
+    p50?: number | null | undefined;
+    p75?: number | null | undefined;
+    p90?: number | null | undefined;
+    p99?: number | null | undefined;
+};
+export type ChatGenerationParamsPreferredMinThroughputUnion = number | ChatGenerationParamsPreferredMinThroughput;
+export type ChatGenerationParamsPreferredMaxLatency = {
+    p50?: number | null | undefined;
+    p75?: number | null | undefined;
+    p90?: number | null | undefined;
+    p99?: number | null | undefined;
+};
+export type ChatGenerationParamsPreferredMaxLatencyUnion = number | ChatGenerationParamsPreferredMaxLatency;
 export type ChatGenerationParamsProvider = {
     /**
      * Whether to allow backup providers to serve requests
@@ -83,10 +97,14 @@ export type ChatGenerationParamsProvider = {
      * The object specifying the maximum price you want to pay for this request. USD price per million tokens, for prompt and completion.
      */
     maxPrice?: ChatGenerationParamsMaxPrice | undefined;
-    preferredMinThroughput?: number | null | undefined;
-    preferredMaxLatency?: number | null | undefined;
-    minThroughput?: number | null | undefined;
-    maxLatency?: number | null | undefined;
+    /**
+     * Preferred minimum throughput (in tokens per second). Can be a number (applies to p50) or an object with percentile-specific cutoffs. Endpoints below the threshold(s) may still be used, but are deprioritized in routing. When using fallback models, this may cause a fallback model to be used instead of the primary model if it meets the threshold.
+     */
+    preferredMinThroughput?: number | ChatGenerationParamsPreferredMinThroughput | null | undefined;
+    /**
+     * Preferred maximum latency (in seconds). Can be a number (applies to p50) or an object with percentile-specific cutoffs. Endpoints above the threshold(s) may still be used, but are deprioritized in routing. When using fallback models, this may cause a fallback model to be used instead of the primary model if it meets the threshold.
+     */
+    preferredMaxLatency?: number | ChatGenerationParamsPreferredMaxLatency | null | undefined;
 };
 export type ChatGenerationParamsPluginResponseHealing = {
     id: "response-healing";
@@ -121,7 +139,12 @@ export type ChatGenerationParamsPluginWeb = {
 export type ChatGenerationParamsPluginModeration = {
     id: "moderation";
 };
-export type ChatGenerationParamsPluginUnion = ChatGenerationParamsPluginModeration | ChatGenerationParamsPluginWeb | ChatGenerationParamsPluginFileParser | ChatGenerationParamsPluginResponseHealing;
+export type ChatGenerationParamsPluginAutoRouter = {
+    id: "auto-router";
+    enabled?: boolean | undefined;
+    allowedModels?: Array<string> | undefined;
+};
+export type ChatGenerationParamsPluginUnion = ChatGenerationParamsPluginAutoRouter | ChatGenerationParamsPluginModeration | ChatGenerationParamsPluginWeb | ChatGenerationParamsPluginFileParser | ChatGenerationParamsPluginResponseHealing;
 export declare const Route: {
     readonly Fallback: "fallback";
     readonly Sort: "sort";
@@ -154,6 +177,12 @@ export type ChatGenerationParamsStop = string | Array<string>;
 export type Debug = {
     echoUpstreamBody?: boolean | undefined;
 };
+export type ChatGenerationParamsImageConfig = string | number;
+export declare const Modality: {
+    readonly Text: "text";
+    readonly Image: "image";
+};
+export type Modality = OpenEnum<typeof Modality>;
 export type ChatGenerationParams = {
     /**
      * When multiple model providers are available, optionally indicate your routing preference.
@@ -162,7 +191,7 @@ export type ChatGenerationParams = {
     /**
      * Plugins you want to enable for this request, including their settings.
      */
-    plugins?: Array<ChatGenerationParamsPluginModeration | ChatGenerationParamsPluginWeb | ChatGenerationParamsPluginFileParser | ChatGenerationParamsPluginResponseHealing> | undefined;
+    plugins?: Array<ChatGenerationParamsPluginAutoRouter | ChatGenerationParamsPluginModeration | ChatGenerationParamsPluginWeb | ChatGenerationParamsPluginFileParser | ChatGenerationParamsPluginResponseHealing> | undefined;
     route?: Route | null | undefined;
     user?: string | undefined;
     /**
@@ -195,6 +224,10 @@ export type ChatGenerationParams = {
     tools?: Array<ToolDefinitionJson> | undefined;
     topP?: number | null | undefined;
     debug?: Debug | undefined;
+    imageConfig?: {
+        [k: string]: string | number;
+    } | undefined;
+    modalities?: Array<Modality> | undefined;
 };
 /** @internal */
 export declare const ChatGenerationParamsDataCollection$outboundSchema: z.ZodType<string, ChatGenerationParamsDataCollection>;
@@ -212,6 +245,36 @@ export type ChatGenerationParamsMaxPrice$Outbound = {
 export declare const ChatGenerationParamsMaxPrice$outboundSchema: z.ZodType<ChatGenerationParamsMaxPrice$Outbound, ChatGenerationParamsMaxPrice>;
 export declare function chatGenerationParamsMaxPriceToJSON(chatGenerationParamsMaxPrice: ChatGenerationParamsMaxPrice): string;
 /** @internal */
+export type ChatGenerationParamsPreferredMinThroughput$Outbound = {
+    p50?: number | null | undefined;
+    p75?: number | null | undefined;
+    p90?: number | null | undefined;
+    p99?: number | null | undefined;
+};
+/** @internal */
+export declare const ChatGenerationParamsPreferredMinThroughput$outboundSchema: z.ZodType<ChatGenerationParamsPreferredMinThroughput$Outbound, ChatGenerationParamsPreferredMinThroughput>;
+export declare function chatGenerationParamsPreferredMinThroughputToJSON(chatGenerationParamsPreferredMinThroughput: ChatGenerationParamsPreferredMinThroughput): string;
+/** @internal */
+export type ChatGenerationParamsPreferredMinThroughputUnion$Outbound = number | ChatGenerationParamsPreferredMinThroughput$Outbound;
+/** @internal */
+export declare const ChatGenerationParamsPreferredMinThroughputUnion$outboundSchema: z.ZodType<ChatGenerationParamsPreferredMinThroughputUnion$Outbound, ChatGenerationParamsPreferredMinThroughputUnion>;
+export declare function chatGenerationParamsPreferredMinThroughputUnionToJSON(chatGenerationParamsPreferredMinThroughputUnion: ChatGenerationParamsPreferredMinThroughputUnion): string;
+/** @internal */
+export type ChatGenerationParamsPreferredMaxLatency$Outbound = {
+    p50?: number | null | undefined;
+    p75?: number | null | undefined;
+    p90?: number | null | undefined;
+    p99?: number | null | undefined;
+};
+/** @internal */
+export declare const ChatGenerationParamsPreferredMaxLatency$outboundSchema: z.ZodType<ChatGenerationParamsPreferredMaxLatency$Outbound, ChatGenerationParamsPreferredMaxLatency>;
+export declare function chatGenerationParamsPreferredMaxLatencyToJSON(chatGenerationParamsPreferredMaxLatency: ChatGenerationParamsPreferredMaxLatency): string;
+/** @internal */
+export type ChatGenerationParamsPreferredMaxLatencyUnion$Outbound = number | ChatGenerationParamsPreferredMaxLatency$Outbound;
+/** @internal */
+export declare const ChatGenerationParamsPreferredMaxLatencyUnion$outboundSchema: z.ZodType<ChatGenerationParamsPreferredMaxLatencyUnion$Outbound, ChatGenerationParamsPreferredMaxLatencyUnion>;
+export declare function chatGenerationParamsPreferredMaxLatencyUnionToJSON(chatGenerationParamsPreferredMaxLatencyUnion: ChatGenerationParamsPreferredMaxLatencyUnion): string;
+/** @internal */
 export type ChatGenerationParamsProvider$Outbound = {
     allow_fallbacks?: boolean | null | undefined;
     require_parameters?: boolean | null | undefined;
@@ -224,10 +287,8 @@ export type ChatGenerationParamsProvider$Outbound = {
     quantizations?: Array<string> | null | undefined;
     sort?: ProviderSortUnion$Outbound | null | undefined;
     max_price?: ChatGenerationParamsMaxPrice$Outbound | undefined;
-    preferred_min_throughput?: number | null | undefined;
-    preferred_max_latency?: number | null | undefined;
-    min_throughput?: number | null | undefined;
-    max_latency?: number | null | undefined;
+    preferred_min_throughput?: number | ChatGenerationParamsPreferredMinThroughput$Outbound | null | undefined;
+    preferred_max_latency?: number | ChatGenerationParamsPreferredMaxLatency$Outbound | null | undefined;
 };
 /** @internal */
 export declare const ChatGenerationParamsProvider$outboundSchema: z.ZodType<ChatGenerationParamsProvider$Outbound, ChatGenerationParamsProvider>;
@@ -279,7 +340,16 @@ export type ChatGenerationParamsPluginModeration$Outbound = {
 export declare const ChatGenerationParamsPluginModeration$outboundSchema: z.ZodType<ChatGenerationParamsPluginModeration$Outbound, ChatGenerationParamsPluginModeration>;
 export declare function chatGenerationParamsPluginModerationToJSON(chatGenerationParamsPluginModeration: ChatGenerationParamsPluginModeration): string;
 /** @internal */
-export type ChatGenerationParamsPluginUnion$Outbound = ChatGenerationParamsPluginModeration$Outbound | ChatGenerationParamsPluginWeb$Outbound | ChatGenerationParamsPluginFileParser$Outbound | ChatGenerationParamsPluginResponseHealing$Outbound;
+export type ChatGenerationParamsPluginAutoRouter$Outbound = {
+    id: "auto-router";
+    enabled?: boolean | undefined;
+    allowed_models?: Array<string> | undefined;
+};
+/** @internal */
+export declare const ChatGenerationParamsPluginAutoRouter$outboundSchema: z.ZodType<ChatGenerationParamsPluginAutoRouter$Outbound, ChatGenerationParamsPluginAutoRouter>;
+export declare function chatGenerationParamsPluginAutoRouterToJSON(chatGenerationParamsPluginAutoRouter: ChatGenerationParamsPluginAutoRouter): string;
+/** @internal */
+export type ChatGenerationParamsPluginUnion$Outbound = ChatGenerationParamsPluginAutoRouter$Outbound | ChatGenerationParamsPluginModeration$Outbound | ChatGenerationParamsPluginWeb$Outbound | ChatGenerationParamsPluginFileParser$Outbound | ChatGenerationParamsPluginResponseHealing$Outbound;
 /** @internal */
 export declare const ChatGenerationParamsPluginUnion$outboundSchema: z.ZodType<ChatGenerationParamsPluginUnion$Outbound, ChatGenerationParamsPluginUnion>;
 export declare function chatGenerationParamsPluginUnionToJSON(chatGenerationParamsPluginUnion: ChatGenerationParamsPluginUnion): string;
@@ -334,9 +404,16 @@ export type Debug$Outbound = {
 export declare const Debug$outboundSchema: z.ZodType<Debug$Outbound, Debug>;
 export declare function debugToJSON(debug: Debug): string;
 /** @internal */
+export type ChatGenerationParamsImageConfig$Outbound = string | number;
+/** @internal */
+export declare const ChatGenerationParamsImageConfig$outboundSchema: z.ZodType<ChatGenerationParamsImageConfig$Outbound, ChatGenerationParamsImageConfig>;
+export declare function chatGenerationParamsImageConfigToJSON(chatGenerationParamsImageConfig: ChatGenerationParamsImageConfig): string;
+/** @internal */
+export declare const Modality$outboundSchema: z.ZodType<string, Modality>;
+/** @internal */
 export type ChatGenerationParams$Outbound = {
     provider?: ChatGenerationParamsProvider$Outbound | null | undefined;
-    plugins?: Array<ChatGenerationParamsPluginModeration$Outbound | ChatGenerationParamsPluginWeb$Outbound | ChatGenerationParamsPluginFileParser$Outbound | ChatGenerationParamsPluginResponseHealing$Outbound> | undefined;
+    plugins?: Array<ChatGenerationParamsPluginAutoRouter$Outbound | ChatGenerationParamsPluginModeration$Outbound | ChatGenerationParamsPluginWeb$Outbound | ChatGenerationParamsPluginFileParser$Outbound | ChatGenerationParamsPluginResponseHealing$Outbound> | undefined;
     route?: string | null | undefined;
     user?: string | undefined;
     session_id?: string | undefined;
@@ -366,6 +443,10 @@ export type ChatGenerationParams$Outbound = {
     tools?: Array<ToolDefinitionJson$Outbound> | undefined;
     top_p?: number | null | undefined;
     debug?: Debug$Outbound | undefined;
+    image_config?: {
+        [k: string]: string | number;
+    } | undefined;
+    modalities?: Array<string> | undefined;
 };
 /** @internal */
 export declare const ChatGenerationParams$outboundSchema: z.ZodType<ChatGenerationParams$Outbound, ChatGenerationParams>;

package/esm/models/chatgenerationparams.js

@@ -49,6 +49,10 @@ export const Effort = {
     Minimal: "minimal",
     None: "none",
 };
+export const Modality = {
+    Text: "text",
+    Image: "image",
+};
 /** @internal */
 export const ChatGenerationParamsDataCollection$outboundSchema = openEnums.outboundSchema(ChatGenerationParamsDataCollection);
 /** @internal */
@@ -65,6 +69,42 @@ export function chatGenerationParamsMaxPriceToJSON(chatGenerationParamsMaxPrice)
     return JSON.stringify(ChatGenerationParamsMaxPrice$outboundSchema.parse(chatGenerationParamsMaxPrice));
 }
 /** @internal */
+export const ChatGenerationParamsPreferredMinThroughput$outboundSchema = z.object({
+    p50: z.nullable(z.number()).optional(),
+    p75: z.nullable(z.number()).optional(),
+    p90: z.nullable(z.number()).optional(),
+    p99: z.nullable(z.number()).optional(),
+});
+export function chatGenerationParamsPreferredMinThroughputToJSON(chatGenerationParamsPreferredMinThroughput) {
+    return JSON.stringify(ChatGenerationParamsPreferredMinThroughput$outboundSchema.parse(chatGenerationParamsPreferredMinThroughput));
+}
+/** @internal */
+export const ChatGenerationParamsPreferredMinThroughputUnion$outboundSchema = z.union([
+    z.number(),
+    z.lazy(() => ChatGenerationParamsPreferredMinThroughput$outboundSchema),
+]);
+export function chatGenerationParamsPreferredMinThroughputUnionToJSON(chatGenerationParamsPreferredMinThroughputUnion) {
+    return JSON.stringify(ChatGenerationParamsPreferredMinThroughputUnion$outboundSchema.parse(chatGenerationParamsPreferredMinThroughputUnion));
+}
+/** @internal */
+export const ChatGenerationParamsPreferredMaxLatency$outboundSchema = z.object({
+    p50: z.nullable(z.number()).optional(),
+    p75: z.nullable(z.number()).optional(),
+    p90: z.nullable(z.number()).optional(),
+    p99: z.nullable(z.number()).optional(),
+});
+export function chatGenerationParamsPreferredMaxLatencyToJSON(chatGenerationParamsPreferredMaxLatency) {
+    return JSON.stringify(ChatGenerationParamsPreferredMaxLatency$outboundSchema.parse(chatGenerationParamsPreferredMaxLatency));
+}
+/** @internal */
+export const ChatGenerationParamsPreferredMaxLatencyUnion$outboundSchema = z.union([
+    z.number(),
+    z.lazy(() => ChatGenerationParamsPreferredMaxLatency$outboundSchema),
+]);
+export function chatGenerationParamsPreferredMaxLatencyUnionToJSON(chatGenerationParamsPreferredMaxLatencyUnion) {
+    return JSON.stringify(ChatGenerationParamsPreferredMaxLatencyUnion$outboundSchema.parse(chatGenerationParamsPreferredMaxLatencyUnion));
+}
+/** @internal */
 export const ChatGenerationParamsProvider$outboundSchema = z.object({
     allowFallbacks: z.nullable(z.boolean()).optional(),
     requireParameters: z.nullable(z.boolean()).optional(),
@@ -79,10 +119,14 @@ export const ChatGenerationParamsProvider$outboundSchema = z.object({
     sort: z.nullable(ProviderSortUnion$outboundSchema).optional(),
     maxPrice: z.lazy(() => ChatGenerationParamsMaxPrice$outboundSchema)
         .optional(),
-    preferredMinThroughput: z.nullable(z.number()).optional(),
-    preferredMaxLatency: z.nullable(z.number()).optional(),
-    minThroughput: z.nullable(z.number()).optional(),
-    maxLatency: z.nullable(z.number()).optional(),
+    preferredMinThroughput: z.nullable(z.union([
+        z.number(),
+        z.lazy(() => ChatGenerationParamsPreferredMinThroughput$outboundSchema),
+    ])).optional(),
+    preferredMaxLatency: z.nullable(z.union([
+        z.number(),
+        z.lazy(() => ChatGenerationParamsPreferredMaxLatency$outboundSchema),
+    ])).optional(),
 }).transform((v) => {
     return remap$(v, {
         allowFallbacks: "allow_fallbacks",
@@ -92,8 +136,6 @@ export const ChatGenerationParamsProvider$outboundSchema = z.object({
         maxPrice: "max_price",
         preferredMinThroughput: "preferred_min_throughput",
         preferredMaxLatency: "preferred_max_latency",
-        minThroughput: "min_throughput",
-        maxLatency: "max_latency",
     });
 });
 export function chatGenerationParamsProviderToJSON(chatGenerationParamsProvider) {
@@ -153,7 +195,21 @@ export function chatGenerationParamsPluginModerationToJSON(chatGenerationParamsP
     return JSON.stringify(ChatGenerationParamsPluginModeration$outboundSchema.parse(chatGenerationParamsPluginModeration));
 }
 /** @internal */
+export const ChatGenerationParamsPluginAutoRouter$outboundSchema = z.object({
+    id: z.literal("auto-router"),
+    enabled: z.boolean().optional(),
+    allowedModels: z.array(z.string()).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        allowedModels: "allowed_models",
+    });
+});
+export function chatGenerationParamsPluginAutoRouterToJSON(chatGenerationParamsPluginAutoRouter) {
+    return JSON.stringify(ChatGenerationParamsPluginAutoRouter$outboundSchema.parse(chatGenerationParamsPluginAutoRouter));
+}
+/** @internal */
 export const ChatGenerationParamsPluginUnion$outboundSchema = z.union([
+    z.lazy(() => ChatGenerationParamsPluginAutoRouter$outboundSchema),
     z.lazy(() => ChatGenerationParamsPluginModeration$outboundSchema),
     z.lazy(() => ChatGenerationParamsPluginWeb$outboundSchema),
     z.lazy(() => ChatGenerationParamsPluginFileParser$outboundSchema),
@@ -225,9 +281,18 @@ export function debugToJSON(debug) {
     return JSON.stringify(Debug$outboundSchema.parse(debug));
 }
 /** @internal */
+export const ChatGenerationParamsImageConfig$outboundSchema = z.union([z.string(), z.number()]);
+export function chatGenerationParamsImageConfigToJSON(chatGenerationParamsImageConfig) {
+    return JSON.stringify(ChatGenerationParamsImageConfig$outboundSchema.parse(chatGenerationParamsImageConfig));
+}
+/** @internal */
+export const Modality$outboundSchema = openEnums
+    .outboundSchema(Modality);
+/** @internal */
 export const ChatGenerationParams$outboundSchema = z.object({
     provider: z.nullable(z.lazy(() => ChatGenerationParamsProvider$outboundSchema)).optional(),
     plugins: z.array(z.union([
+        z.lazy(() => ChatGenerationParamsPluginAutoRouter$outboundSchema),
         z.lazy(() => ChatGenerationParamsPluginModeration$outboundSchema),
         z.lazy(() => ChatGenerationParamsPluginWeb$outboundSchema),
         z.lazy(() => ChatGenerationParamsPluginFileParser$outboundSchema),
@@ -264,6 +329,9 @@ export const ChatGenerationParams$outboundSchema = z.object({
     tools: z.array(ToolDefinitionJson$outboundSchema).optional(),
     topP: z.nullable(z.number()).optional(),
     debug: z.lazy(() => Debug$outboundSchema).optional(),
+    imageConfig: z.record(z.string(), z.union([z.string(), z.number()]))
+        .optional(),
+    modalities: z.array(Modality$outboundSchema).optional(),
 }).transform((v) => {
     return remap$(v, {
         sessionId: "session_id",
@@ -277,6 +345,7 @@ export const ChatGenerationParams$outboundSchema = z.object({
         streamOptions: "stream_options",
         toolChoice: "tool_choice",
         topP: "top_p",
+        imageConfig: "image_config",
     });
 });
 export function chatGenerationParamsToJSON(chatGenerationParams) {

package/esm/models/chatgenerationtokenusage.d.ts

@@ -9,6 +9,7 @@ export type CompletionTokensDetails = {
 };
 export type PromptTokensDetails = {
     cachedTokens?: number | undefined;
+    cacheWriteTokens?: number | undefined;
     audioTokens?: number | undefined;
     videoTokens?: number | undefined;
 };

package/esm/models/chatgenerationtokenusage.js

@@ -25,11 +25,13 @@ export function completionTokensDetailsFromJSON(jsonString) {
 /** @internal */
 export const PromptTokensDetails$inboundSchema = z.object({
     cached_tokens: z.number().optional(),
+    cache_write_tokens: z.number().optional(),
     audio_tokens: z.number().optional(),
     video_tokens: z.number().optional(),
 }).transform((v) => {
     return remap$(v, {
         "cached_tokens": "cachedTokens",
+        "cache_write_tokens": "cacheWriteTokens",
         "audio_tokens": "audioTokens",
         "video_tokens": "videoTokens",
     });

package/esm/models/chatmessagetokenlogprob.d.ts

@@ -1,7 +1,7 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export type TopLogprob = {
+export type ChatMessageTokenLogprobTopLogprob = {
     token: string;
     logprob: number;
     bytes: Array<number> | null;
@@ -10,11 +10,11 @@ export type ChatMessageTokenLogprob = {
     token: string;
     logprob: number;
     bytes: Array<number> | null;
-    topLogprobs: Array<TopLogprob>;
+    topLogprobs: Array<ChatMessageTokenLogprobTopLogprob>;
 };
 /** @internal */
-export declare const TopLogprob$inboundSchema: z.ZodType<TopLogprob, unknown>;
-export declare function topLogprobFromJSON(jsonString: string): SafeParseResult<TopLogprob, SDKValidationError>;
+export declare const ChatMessageTokenLogprobTopLogprob$inboundSchema: z.ZodType<ChatMessageTokenLogprobTopLogprob, unknown>;
+export declare function chatMessageTokenLogprobTopLogprobFromJSON(jsonString: string): SafeParseResult<ChatMessageTokenLogprobTopLogprob, SDKValidationError>;
 /** @internal */
 export declare const ChatMessageTokenLogprob$inboundSchema: z.ZodType<ChatMessageTokenLogprob, unknown>;
 export declare function chatMessageTokenLogprobFromJSON(jsonString: string): SafeParseResult<ChatMessageTokenLogprob, SDKValidationError>;

package/esm/models/chatmessagetokenlogprob.js

@@ -6,21 +6,20 @@ import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
-export const TopLogprob$inboundSchema = z
-    .object({
+export const ChatMessageTokenLogprobTopLogprob$inboundSchema = z.object({
     token: z.string(),
     logprob: z.number(),
     bytes: z.nullable(z.array(z.number())),
 });
-export function topLogprobFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => TopLogprob$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'TopLogprob' from JSON`);
+export function chatMessageTokenLogprobTopLogprobFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatMessageTokenLogprobTopLogprob$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageTokenLogprobTopLogprob' from JSON`);
 }
 /** @internal */
 export const ChatMessageTokenLogprob$inboundSchema = z.object({
     token: z.string(),
     logprob: z.number(),
     bytes: z.nullable(z.array(z.number())),
-    top_logprobs: z.array(z.lazy(() => TopLogprob$inboundSchema)),
+    top_logprobs: z.array(z.lazy(() => ChatMessageTokenLogprobTopLogprob$inboundSchema)),
 }).transform((v) => {
     return remap$(v, {
         "top_logprobs": "topLogprobs",

package/esm/models/index.d.ts

@@ -97,7 +97,12 @@ export * from "./payloadtoolargeresponseerrordata.js";
 export * from "./paymentrequiredresponseerrordata.js";
 export * from "./pdfparserengine.js";
 export * from "./pdfparseroptions.js";
+export * from "./percentilelatencycutoffs.js";
+export * from "./percentilestats.js";
+export * from "./percentilethroughputcutoffs.js";
 export * from "./perrequestlimits.js";
+export * from "./preferredmaxlatency.js";
+export * from "./preferredminthroughput.js";
 export * from "./providername.js";
 export * from "./provideroverloadedresponseerrordata.js";
 export * from "./providerpreferences.js";
@@ -118,6 +123,7 @@ export * from "./responseinputaudio.js";
 export * from "./responseinputfile.js";
 export * from "./responseinputimage.js";
 export * from "./responseinputtext.js";
+export * from "./responseinputvideo.js";
 export * from "./responseoutputtext.js";
 export * from "./responseserrorfield.js";
 export * from "./responsesformatjsonobject.js";
@@ -129,6 +135,7 @@ export * from "./responsesoutputitemfilesearchcall.js";
 export * from "./responsesoutputitemfunctioncall.js";
 export * from "./responsesoutputitemreasoning.js";
 export * from "./responsesoutputmessage.js";
+export * from "./responsesoutputmodality.js";
 export * from "./responsessearchcontextsize.js";
 export * from "./responseswebsearchcalloutput.js";
 export * from "./responseswebsearchuserlocation.js";