@openrouter/sdk 0.8.0 → 0.10.2

package/esm/models/chatgenerationparams.d.ts

@@ -1,59 +1,249 @@
 import * as z from "zod/v4";
-import { OpenEnum } from "../types/enums.js";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
 import { ChatStreamOptions, ChatStreamOptions$Outbound } from "./chatstreamoptions.js";
+import { ContextCompressionEngine } from "./contextcompressionengine.js";
+import { DataCollection } from "./datacollection.js";
+import { DebugOptions, DebugOptions$Outbound } from "./debugoptions.js";
 import { Message, Message$Outbound } from "./message.js";
-import { ProviderSortUnion, ProviderSortUnion$Outbound } from "./providersortunion.js";
-import { ReasoningSummaryVerbosity } from "./reasoningsummaryverbosity.js";
+import { PDFParserOptions, PDFParserOptions$Outbound } from "./pdfparseroptions.js";
+import { PreferredMaxLatency, PreferredMaxLatency$Outbound } from "./preferredmaxlatency.js";
+import { PreferredMinThroughput, PreferredMinThroughput$Outbound } from "./preferredminthroughput.js";
+import { ProviderName } from "./providername.js";
+import { Quantization } from "./quantization.js";
+import { ResponseFormatJSONObject, ResponseFormatJSONObject$Outbound } from "./responseformatjsonobject.js";
 import { ResponseFormatJSONSchema, ResponseFormatJSONSchema$Outbound } from "./responseformatjsonschema.js";
+import { ResponseFormatText, ResponseFormatText$Outbound } from "./responseformattext.js";
 import { ResponseFormatTextGrammar, ResponseFormatTextGrammar$Outbound } from "./responseformattextgrammar.js";
-import { Schema10, Schema10$Outbound } from "./schema10.js";
-import { Schema17, Schema17$Outbound } from "./schema17.js";
-import { Schema5, Schema5$Outbound } from "./schema5.js";
+import { ResponseFormatTextPython, ResponseFormatTextPython$Outbound } from "./responseformattextpython.js";
+import { ToolChoiceOption, ToolChoiceOption$Outbound } from "./toolchoiceoption.js";
 import { ToolDefinitionJson, ToolDefinitionJson$Outbound } from "./tooldefinitionjson.js";
-export declare const Schema3: {
-    readonly Deny: "deny";
-    readonly Allow: "allow";
-};
-export type Schema3 = OpenEnum<typeof Schema3>;
-export declare const Schema8: {
-    readonly Int4: "int4";
-    readonly Int8: "int8";
-    readonly Fp4: "fp4";
-    readonly Fp6: "fp6";
-    readonly Fp8: "fp8";
-    readonly Fp16: "fp16";
-    readonly Bf16: "bf16";
-    readonly Fp32: "fp32";
-    readonly Unknown: "unknown";
-};
-export type Schema8 = OpenEnum<typeof Schema8>;
-export type Schema15 = {
-    p50?: number | null | undefined;
-    p75?: number | null | undefined;
-    p90?: number | null | undefined;
-    p99?: number | null | undefined;
-};
-export type Schema15Union = number | Schema15;
-export type Schema0 = {
+import { WebSearchEngine } from "./websearchengine.js";
+export type ChatGenerationParamsOrder = ProviderName | string;
+export type ChatGenerationParamsOnly = ProviderName | string;
+export type ChatGenerationParamsIgnore = ProviderName | string;
+export declare const ChatGenerationParamsSortEnum: {
+    readonly Price: "price";
+    readonly Throughput: "throughput";
+    readonly Latency: "latency";
+    readonly Exacto: "exacto";
+};
+export type ChatGenerationParamsSortEnum = OpenEnum<typeof ChatGenerationParamsSortEnum>;
+export declare const ChatGenerationParamsProviderSortConfigEnum: {
+    readonly Price: "price";
+    readonly Throughput: "throughput";
+    readonly Latency: "latency";
+    readonly Exacto: "exacto";
+};
+export type ChatGenerationParamsProviderSortConfigEnum = ClosedEnum<typeof ChatGenerationParamsProviderSortConfigEnum>;
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
+export declare const ChatGenerationParamsBy: {
+    readonly Price: "price";
+    readonly Throughput: "throughput";
+    readonly Latency: "latency";
+    readonly Exacto: "exacto";
+};
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
+export type ChatGenerationParamsBy = OpenEnum<typeof ChatGenerationParamsBy>;
+/**
+ * Partitioning strategy for sorting: "model" (default) groups endpoints by model before sorting (fallback models remain fallbacks), "none" sorts all endpoints together regardless of model.
+ */
+export declare const ChatGenerationParamsPartition: {
+    readonly Model: "model";
+    readonly None: "none";
+};
+/**
+ * Partitioning strategy for sorting: "model" (default) groups endpoints by model before sorting (fallback models remain fallbacks), "none" sorts all endpoints together regardless of model.
+ */
+export type ChatGenerationParamsPartition = OpenEnum<typeof ChatGenerationParamsPartition>;
+export type ChatGenerationParamsProviderSortConfig = {
+    /**
+     * The provider sorting strategy (price, throughput, latency)
+     */
+    by?: ChatGenerationParamsBy | null | undefined;
+    /**
+     * Partitioning strategy for sorting: "model" (default) groups endpoints by model before sorting (fallback models remain fallbacks), "none" sorts all endpoints together regardless of model.
+     */
+    partition?: ChatGenerationParamsPartition | null | undefined;
+};
+export type ChatGenerationParamsProviderSortConfigUnion = ChatGenerationParamsProviderSortConfig | ChatGenerationParamsProviderSortConfigEnum;
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
+export declare const ChatGenerationParamsProviderSort: {
+    readonly Price: "price";
+    readonly Throughput: "throughput";
+    readonly Latency: "latency";
+    readonly Exacto: "exacto";
+};
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
+export type ChatGenerationParamsProviderSort = OpenEnum<typeof ChatGenerationParamsProviderSort>;
+/**
+ * The sorting strategy to use for this request, if "order" is not specified. When set, no load balancing is performed.
+ */
+export type ChatGenerationParamsSortUnion = ChatGenerationParamsProviderSort | ChatGenerationParamsProviderSortConfig | ChatGenerationParamsProviderSortConfigEnum | ChatGenerationParamsSortEnum;
+/**
+ * The object specifying the maximum price you want to pay for this request. USD price per million tokens, for prompt and completion.
+ */
+export type ChatGenerationParamsMaxPrice = {
+    /**
+     * Price per million prompt tokens
+     */
+    prompt?: string | undefined;
+    completion?: string | undefined;
+    image?: string | undefined;
+    audio?: string | undefined;
+    request?: string | undefined;
+};
+/**
+ * When multiple model providers are available, optionally indicate your routing preference.
+ */
+export type ChatGenerationParamsProvider = {
+    /**
+     * Whether to allow backup providers to serve requests
+     *
+     * @remarks
+     * - true: (default) when the primary provider (or your custom providers in "order") is unavailable, use the next best provider.
+     * - false: use only the primary/custom provider, and return the upstream error if it's unavailable.
+     */
     allowFallbacks?: boolean | null | undefined;
+    /**
+     * Whether to filter providers to only those that support the parameters you've provided. If this setting is omitted or set to false, then providers will receive only the parameters they support, and ignore the rest.
+     */
     requireParameters?: boolean | null | undefined;
-    dataCollection?: Schema3 | null | undefined;
+    /**
+     * Data collection setting. If no available model provider meets the requirement, your request will return an error.
+     *
+     * @remarks
+     * - allow: (default) allow providers which store user data non-transiently and may train on it
+     *
+     * - deny: use only providers which do not collect user data.
+     */
+    dataCollection?: DataCollection | null | undefined;
+    /**
+     * Whether to restrict routing to only ZDR (Zero Data Retention) endpoints. When true, only endpoints that do not retain prompts will be used.
+     */
     zdr?: boolean | null | undefined;
+    /**
+     * Whether to restrict routing to only models that allow text distillation. When true, only models where the author has allowed distillation will be used.
+     */
     enforceDistillableText?: boolean | null | undefined;
-    order?: Array<Schema5> | null | undefined;
-    only?: Array<Schema5> | null | undefined;
-    ignore?: Array<Schema5> | null | undefined;
-    quantizations?: Array<Schema8> | null | undefined;
-    sort?: ProviderSortUnion | null | undefined;
-    maxPrice?: Schema10 | undefined;
-    preferredMinThroughput?: number | Schema15 | null | undefined;
-    preferredMaxLatency?: number | Schema15 | null | undefined;
-};
-export declare const Route: {
-    readonly Fallback: "fallback";
-    readonly Sort: "sort";
-};
-export type Route = OpenEnum<typeof Route>;
+    /**
+     * An ordered list of provider slugs. The router will attempt to use the first provider in the subset of this list that supports your requested model, and fall back to the next if it is unavailable. If no providers are available, the request will fail with an error message.
+     */
+    order?: Array<ProviderName | string> | null | undefined;
+    /**
+     * List of provider slugs to allow. If provided, this list is merged with your account-wide allowed provider settings for this request.
+     */
+    only?: Array<ProviderName | string> | null | undefined;
+    /**
+     * List of provider slugs to ignore. If provided, this list is merged with your account-wide ignored provider settings for this request.
+     */
+    ignore?: Array<ProviderName | string> | null | undefined;
+    /**
+     * A list of quantization levels to filter the provider by.
+     */
+    quantizations?: Array<Quantization> | null | undefined;
+    sort?: ChatGenerationParamsProviderSort | ChatGenerationParamsProviderSortConfig | ChatGenerationParamsProviderSortConfigEnum | ChatGenerationParamsSortEnum | null | undefined;
+    /**
+     * 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;
+    /**
+     * 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?: PreferredMinThroughput | 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?: PreferredMaxLatency | null | undefined;
+};
+export type ChatGenerationParamsPluginContextCompression = {
+    id: "context-compression";
+    /**
+     * Set to false to disable the context-compression plugin for this request. Defaults to true.
+     */
+    enabled?: boolean | undefined;
+    /**
+     * The compression engine to use. Defaults to "middle-out".
+     */
+    engine?: ContextCompressionEngine | undefined;
+};
+export type ChatGenerationParamsPluginResponseHealing = {
+    id: "response-healing";
+    /**
+     * Set to false to disable the response-healing plugin for this request. Defaults to true.
+     */
+    enabled?: boolean | undefined;
+};
+export type ChatGenerationParamsPluginFileParser = {
+    id: "file-parser";
+    /**
+     * Set to false to disable the file-parser plugin for this request. Defaults to true.
+     */
+    enabled?: boolean | undefined;
+    /**
+     * Options for PDF parsing.
+     */
+    pdf?: PDFParserOptions | undefined;
+};
+export type ChatGenerationParamsPluginWeb = {
+    id: "web";
+    /**
+     * Set to false to disable the web-search plugin for this request. Defaults to true.
+     */
+    enabled?: boolean | undefined;
+    maxResults?: number | undefined;
+    searchPrompt?: string | undefined;
+    /**
+     * The search engine to use for web search.
+     */
+    engine?: WebSearchEngine | undefined;
+    /**
+     * A list of domains to restrict web search results to. Supports wildcards (e.g. "*.substack.com") and path filtering (e.g. "openai.com/blog").
+     */
+    includeDomains?: Array<string> | undefined;
+    /**
+     * A list of domains to exclude from web search results. Supports wildcards (e.g. "*.substack.com") and path filtering (e.g. "openai.com/blog").
+     */
+    excludeDomains?: Array<string> | undefined;
+};
+export type ChatGenerationParamsPluginModeration = {
+    id: "moderation";
+};
+export type ChatGenerationParamsPluginAutoRouter = {
+    id: "auto-router";
+    /**
+     * Set to false to disable the auto-router plugin for this request. Defaults to true.
+     */
+    enabled?: boolean | undefined;
+    /**
+     * List of model patterns to filter which models the auto-router can route between. Supports wildcards (e.g., "anthropic/*" matches all Anthropic models). When not specified, uses the default supported models list.
+     */
+    allowedModels?: Array<string> | undefined;
+};
+export type ChatGenerationParamsPluginUnion = ChatGenerationParamsPluginAutoRouter | ChatGenerationParamsPluginModeration | ChatGenerationParamsPluginWeb | ChatGenerationParamsPluginFileParser | ChatGenerationParamsPluginResponseHealing | ChatGenerationParamsPluginContextCompression;
+/**
+ * Metadata for observability and tracing. Known keys (trace_id, trace_name, span_name, generation_name, parent_span_id) have special handling. Additional keys are passed through as custom metadata to configured broadcast destinations.
+ */
+export type ChatGenerationParamsTrace = {
+    traceId?: string | undefined;
+    traceName?: string | undefined;
+    spanName?: string | undefined;
+    generationName?: string | undefined;
+    parentSpanId?: string | undefined;
+    additionalProperties?: {
+        [k: string]: any | null;
+    } | undefined;
+};
+/**
+ * Constrains effort on reasoning for reasoning models
+ */
 export declare const Effort: {
     readonly Xhigh: "xhigh";
     readonly High: "high";
@@ -62,170 +252,374 @@ export declare const Effort: {
     readonly Minimal: "minimal";
     readonly None: "none";
 };
+/**
+ * Constrains effort on reasoning for reasoning models
+ */
 export type Effort = OpenEnum<typeof Effort>;
+/**
+ * Configuration options for reasoning models
+ */
 export type Reasoning = {
+    /**
+     * Constrains effort on reasoning for reasoning models
+     */
     effort?: Effort | null | undefined;
-    summary?: ReasoningSummaryVerbosity | null | undefined;
-};
-export type ResponseFormatPython = {
-    type: "python";
+    summary?: any | null | undefined;
 };
-export type ResponseFormatJSONObject = {
-    type: "json_object";
-};
-export type ResponseFormatText = {
-    type: "text";
-};
-export type ResponseFormat = ResponseFormatText | ResponseFormatJSONObject | ResponseFormatJSONSchema | ResponseFormatTextGrammar | ResponseFormatPython;
-export type Stop = string | Array<string>;
-export type Debug = {
-    echoUpstreamBody?: boolean | undefined;
-};
-export type ChatGenerationParamsImageConfig = string | number | Array<any>;
+/**
+ * Response format configuration
+ */
+export type ResponseFormat = ResponseFormatText | ResponseFormatJSONObject | ResponseFormatJSONSchema | ResponseFormatTextGrammar | ResponseFormatTextPython;
+/**
+ * Stop sequences (up to 4)
+ */
+export type Stop = string | Array<string> | any;
+export type ChatGenerationParamsImageConfig = string | number | Array<any | null>;
 export declare const Modality: {
     readonly Text: "text";
     readonly Image: "image";
+    readonly Audio: "audio";
 };
 export type Modality = OpenEnum<typeof Modality>;
+export declare const ChatGenerationParamsType: {
+    readonly Ephemeral: "ephemeral";
+};
+export type ChatGenerationParamsType = ClosedEnum<typeof ChatGenerationParamsType>;
+export declare const ChatGenerationParamsTtl: {
+    readonly Fivem: "5m";
+    readonly Oneh: "1h";
+};
+export type ChatGenerationParamsTtl = OpenEnum<typeof ChatGenerationParamsTtl>;
+/**
+ * Enable automatic prompt caching. When set, the system automatically applies cache breakpoints to the last cacheable block in the request. Currently supported for Anthropic Claude models.
+ */
+export type CacheControl = {
+    type: ChatGenerationParamsType;
+    ttl?: ChatGenerationParamsTtl | undefined;
+};
+/**
+ * Chat completion request parameters
+ */
 export type ChatGenerationParams = {
-    provider?: Schema0 | null | undefined;
-    plugins?: Array<Schema17> | undefined;
-    route?: Route | null | undefined;
+    /**
+     * When multiple model providers are available, optionally indicate your routing preference.
+     */
+    provider?: ChatGenerationParamsProvider | null | undefined;
+    /**
+     * Plugins you want to enable for this request, including their settings.
+     */
+    plugins?: Array<ChatGenerationParamsPluginAutoRouter | ChatGenerationParamsPluginModeration | ChatGenerationParamsPluginWeb | ChatGenerationParamsPluginFileParser | ChatGenerationParamsPluginResponseHealing | ChatGenerationParamsPluginContextCompression> | undefined;
+    /**
+     * Unique user identifier
+     */
     user?: string | undefined;
+    /**
+     * A unique identifier for grouping related requests (e.g., a conversation or agent workflow) for observability. If provided in both the request body and the x-session-id header, the body value takes precedence. Maximum of 128 characters.
+     */
     sessionId?: string | undefined;
+    /**
+     * Metadata for observability and tracing. Known keys (trace_id, trace_name, span_name, generation_name, parent_span_id) have special handling. Additional keys are passed through as custom metadata to configured broadcast destinations.
+     */
+    trace?: ChatGenerationParamsTrace | undefined;
+    /**
+     * List of messages for the conversation
+     */
     messages: Array<Message>;
+    /**
+     * Model to use for completion
+     */
     model?: string | undefined;
+    /**
+     * Models to use for completion
+     */
     models?: Array<string> | undefined;
+    /**
+     * Frequency penalty (-2.0 to 2.0)
+     */
     frequencyPenalty?: number | null | undefined;
+    /**
+     * Token logit bias adjustments
+     */
     logitBias?: {
         [k: string]: number;
     } | null | undefined;
+    /**
+     * Return log probabilities
+     */
     logprobs?: boolean | null | undefined;
+    /**
+     * Number of top log probabilities to return (0-20)
+     */
     topLogprobs?: number | null | undefined;
+    /**
+     * Maximum tokens in completion
+     */
     maxCompletionTokens?: number | null | undefined;
+    /**
+     * Maximum tokens (deprecated, use max_completion_tokens). Note: some providers enforce a minimum of 16.
+     */
     maxTokens?: number | null | undefined;
+    /**
+     * Key-value pairs for additional object information (max 16 pairs, 64 char keys, 512 char values)
+     */
     metadata?: {
         [k: string]: string;
     } | undefined;
+    /**
+     * Presence penalty (-2.0 to 2.0)
+     */
     presencePenalty?: number | null | undefined;
+    /**
+     * Configuration options for reasoning models
+     */
     reasoning?: Reasoning | undefined;
-    responseFormat?: ResponseFormatText | ResponseFormatJSONObject | ResponseFormatJSONSchema | ResponseFormatTextGrammar | ResponseFormatPython | undefined;
+    /**
+     * Response format configuration
+     */
+    responseFormat?: ResponseFormatText | ResponseFormatJSONObject | ResponseFormatJSONSchema | ResponseFormatTextGrammar | ResponseFormatTextPython | undefined;
+    /**
+     * Random seed for deterministic outputs
+     */
     seed?: number | null | undefined;
-    stop?: string | Array<string> | null | undefined;
+    /**
+     * Stop sequences (up to 4)
+     */
+    stop?: string | Array<string> | any | null | undefined;
+    /**
+     * Enable streaming response
+     */
     stream?: boolean | undefined;
+    /**
+     * Streaming configuration options
+     */
     streamOptions?: ChatStreamOptions | null | undefined;
+    /**
+     * Sampling temperature (0-2)
+     */
     temperature?: number | null | undefined;
-    toolChoice?: any | undefined;
+    parallelToolCalls?: boolean | null | undefined;
+    /**
+     * Tool choice configuration
+     */
+    toolChoice?: ToolChoiceOption | undefined;
+    /**
+     * Available tools for function calling
+     */
     tools?: Array<ToolDefinitionJson> | undefined;
+    /**
+     * Nucleus sampling parameter (0-1)
+     */
     topP?: number | null | undefined;
-    debug?: Debug | undefined;
+    /**
+     * Debug options for inspecting request transformations (streaming only)
+     */
+    debug?: DebugOptions | undefined;
+    /**
+     * Provider-specific image configuration options. Keys and values vary by model/provider. See https://openrouter.ai/docs/guides/overview/multimodal/image-generation for more details.
+     */
     imageConfig?: {
-        [k: string]: string | number | Array<any>;
+        [k: string]: string | number | Array<any | null>;
     } | undefined;
+    /**
+     * Output modalities for the response. Supported values are "text", "image", and "audio".
+     */
     modalities?: Array<Modality> | undefined;
+    /**
+     * Enable automatic prompt caching. When set, the system automatically applies cache breakpoints to the last cacheable block in the request. Currently supported for Anthropic Claude models.
+     */
+    cacheControl?: CacheControl | undefined;
 };
 /** @internal */
-export declare const Schema3$outboundSchema: z.ZodType<string, Schema3>;
+export type ChatGenerationParamsOrder$Outbound = string | string;
+/** @internal */
+export declare const ChatGenerationParamsOrder$outboundSchema: z.ZodType<ChatGenerationParamsOrder$Outbound, ChatGenerationParamsOrder>;
+export declare function chatGenerationParamsOrderToJSON(chatGenerationParamsOrder: ChatGenerationParamsOrder): string;
+/** @internal */
+export type ChatGenerationParamsOnly$Outbound = string | string;
+/** @internal */
+export declare const ChatGenerationParamsOnly$outboundSchema: z.ZodType<ChatGenerationParamsOnly$Outbound, ChatGenerationParamsOnly>;
+export declare function chatGenerationParamsOnlyToJSON(chatGenerationParamsOnly: ChatGenerationParamsOnly): string;
 /** @internal */
-export declare const Schema8$outboundSchema: z.ZodType<string, Schema8>;
+export type ChatGenerationParamsIgnore$Outbound = string | string;
 /** @internal */
-export type Schema15$Outbound = {
-    p50?: number | null | undefined;
-    p75?: number | null | undefined;
-    p90?: number | null | undefined;
-    p99?: number | null | undefined;
+export declare const ChatGenerationParamsIgnore$outboundSchema: z.ZodType<ChatGenerationParamsIgnore$Outbound, ChatGenerationParamsIgnore>;
+export declare function chatGenerationParamsIgnoreToJSON(chatGenerationParamsIgnore: ChatGenerationParamsIgnore): string;
+/** @internal */
+export declare const ChatGenerationParamsSortEnum$outboundSchema: z.ZodType<string, ChatGenerationParamsSortEnum>;
+/** @internal */
+export declare const ChatGenerationParamsProviderSortConfigEnum$outboundSchema: z.ZodEnum<typeof ChatGenerationParamsProviderSortConfigEnum>;
+/** @internal */
+export declare const ChatGenerationParamsBy$outboundSchema: z.ZodType<string, ChatGenerationParamsBy>;
+/** @internal */
+export declare const ChatGenerationParamsPartition$outboundSchema: z.ZodType<string, ChatGenerationParamsPartition>;
+/** @internal */
+export type ChatGenerationParamsProviderSortConfig$Outbound = {
+    by?: string | null | undefined;
+    partition?: string | null | undefined;
 };
 /** @internal */
-export declare const Schema15$outboundSchema: z.ZodType<Schema15$Outbound, Schema15>;
-export declare function schema15ToJSON(schema15: Schema15): string;
+export declare const ChatGenerationParamsProviderSortConfig$outboundSchema: z.ZodType<ChatGenerationParamsProviderSortConfig$Outbound, ChatGenerationParamsProviderSortConfig>;
+export declare function chatGenerationParamsProviderSortConfigToJSON(chatGenerationParamsProviderSortConfig: ChatGenerationParamsProviderSortConfig): string;
+/** @internal */
+export type ChatGenerationParamsProviderSortConfigUnion$Outbound = ChatGenerationParamsProviderSortConfig$Outbound | string;
+/** @internal */
+export declare const ChatGenerationParamsProviderSortConfigUnion$outboundSchema: z.ZodType<ChatGenerationParamsProviderSortConfigUnion$Outbound, ChatGenerationParamsProviderSortConfigUnion>;
+export declare function chatGenerationParamsProviderSortConfigUnionToJSON(chatGenerationParamsProviderSortConfigUnion: ChatGenerationParamsProviderSortConfigUnion): string;
+/** @internal */
+export declare const ChatGenerationParamsProviderSort$outboundSchema: z.ZodType<string, ChatGenerationParamsProviderSort>;
 /** @internal */
-export type Schema15Union$Outbound = number | Schema15$Outbound;
+export type ChatGenerationParamsSortUnion$Outbound = string | ChatGenerationParamsProviderSortConfig$Outbound | string | string;
 /** @internal */
-export declare const Schema15Union$outboundSchema: z.ZodType<Schema15Union$Outbound, Schema15Union>;
-export declare function schema15UnionToJSON(schema15Union: Schema15Union): string;
+export declare const ChatGenerationParamsSortUnion$outboundSchema: z.ZodType<ChatGenerationParamsSortUnion$Outbound, ChatGenerationParamsSortUnion>;
+export declare function chatGenerationParamsSortUnionToJSON(chatGenerationParamsSortUnion: ChatGenerationParamsSortUnion): string;
 /** @internal */
-export type Schema0$Outbound = {
+export type ChatGenerationParamsMaxPrice$Outbound = {
+    prompt?: string | undefined;
+    completion?: string | undefined;
+    image?: string | undefined;
+    audio?: string | undefined;
+    request?: string | undefined;
+};
+/** @internal */
+export declare const ChatGenerationParamsMaxPrice$outboundSchema: z.ZodType<ChatGenerationParamsMaxPrice$Outbound, ChatGenerationParamsMaxPrice>;
+export declare function chatGenerationParamsMaxPriceToJSON(chatGenerationParamsMaxPrice: ChatGenerationParamsMaxPrice): string;
+/** @internal */
+export type ChatGenerationParamsProvider$Outbound = {
     allow_fallbacks?: boolean | null | undefined;
     require_parameters?: boolean | null | undefined;
     data_collection?: string | null | undefined;
     zdr?: boolean | null | undefined;
     enforce_distillable_text?: boolean | null | undefined;
-    order?: Array<Schema5$Outbound> | null | undefined;
-    only?: Array<Schema5$Outbound> | null | undefined;
-    ignore?: Array<Schema5$Outbound> | null | undefined;
+    order?: Array<string | string> | null | undefined;
+    only?: Array<string | string> | null | undefined;
+    ignore?: Array<string | string> | null | undefined;
     quantizations?: Array<string> | null | undefined;
-    sort?: ProviderSortUnion$Outbound | null | undefined;
-    max_price?: Schema10$Outbound | undefined;
-    preferred_min_throughput?: number | Schema15$Outbound | null | undefined;
-    preferred_max_latency?: number | Schema15$Outbound | null | undefined;
+    sort?: string | ChatGenerationParamsProviderSortConfig$Outbound | string | string | null | undefined;
+    max_price?: ChatGenerationParamsMaxPrice$Outbound | undefined;
+    preferred_min_throughput?: PreferredMinThroughput$Outbound | null | undefined;
+    preferred_max_latency?: PreferredMaxLatency$Outbound | null | undefined;
 };
 /** @internal */
-export declare const Schema0$outboundSchema: z.ZodType<Schema0$Outbound, Schema0>;
-export declare function schema0ToJSON(schema0: Schema0): string;
+export declare const ChatGenerationParamsProvider$outboundSchema: z.ZodType<ChatGenerationParamsProvider$Outbound, ChatGenerationParamsProvider>;
+export declare function chatGenerationParamsProviderToJSON(chatGenerationParamsProvider: ChatGenerationParamsProvider): string;
 /** @internal */
-export declare const Route$outboundSchema: z.ZodType<string, Route>;
+export type ChatGenerationParamsPluginContextCompression$Outbound = {
+    id: "context-compression";
+    enabled?: boolean | undefined;
+    engine?: string | undefined;
+};
 /** @internal */
-export declare const Effort$outboundSchema: z.ZodType<string, Effort>;
+export declare const ChatGenerationParamsPluginContextCompression$outboundSchema: z.ZodType<ChatGenerationParamsPluginContextCompression$Outbound, ChatGenerationParamsPluginContextCompression>;
+export declare function chatGenerationParamsPluginContextCompressionToJSON(chatGenerationParamsPluginContextCompression: ChatGenerationParamsPluginContextCompression): string;
 /** @internal */
-export type Reasoning$Outbound = {
-    effort?: string | null | undefined;
-    summary?: string | null | undefined;
+export type ChatGenerationParamsPluginResponseHealing$Outbound = {
+    id: "response-healing";
+    enabled?: boolean | undefined;
 };
 /** @internal */
-export declare const Reasoning$outboundSchema: z.ZodType<Reasoning$Outbound, Reasoning>;
-export declare function reasoningToJSON(reasoning: Reasoning): string;
+export declare const ChatGenerationParamsPluginResponseHealing$outboundSchema: z.ZodType<ChatGenerationParamsPluginResponseHealing$Outbound, ChatGenerationParamsPluginResponseHealing>;
+export declare function chatGenerationParamsPluginResponseHealingToJSON(chatGenerationParamsPluginResponseHealing: ChatGenerationParamsPluginResponseHealing): string;
 /** @internal */
-export type ResponseFormatPython$Outbound = {
-    type: "python";
+export type ChatGenerationParamsPluginFileParser$Outbound = {
+    id: "file-parser";
+    enabled?: boolean | undefined;
+    pdf?: PDFParserOptions$Outbound | undefined;
 };
 /** @internal */
-export declare const ResponseFormatPython$outboundSchema: z.ZodType<ResponseFormatPython$Outbound, ResponseFormatPython>;
-export declare function responseFormatPythonToJSON(responseFormatPython: ResponseFormatPython): string;
+export declare const ChatGenerationParamsPluginFileParser$outboundSchema: z.ZodType<ChatGenerationParamsPluginFileParser$Outbound, ChatGenerationParamsPluginFileParser>;
+export declare function chatGenerationParamsPluginFileParserToJSON(chatGenerationParamsPluginFileParser: ChatGenerationParamsPluginFileParser): string;
 /** @internal */
-export type ResponseFormatJSONObject$Outbound = {
-    type: "json_object";
+export type ChatGenerationParamsPluginWeb$Outbound = {
+    id: "web";
+    enabled?: boolean | undefined;
+    max_results?: number | undefined;
+    search_prompt?: string | undefined;
+    engine?: string | undefined;
+    include_domains?: Array<string> | undefined;
+    exclude_domains?: Array<string> | undefined;
 };
 /** @internal */
-export declare const ResponseFormatJSONObject$outboundSchema: z.ZodType<ResponseFormatJSONObject$Outbound, ResponseFormatJSONObject>;
-export declare function responseFormatJSONObjectToJSON(responseFormatJSONObject: ResponseFormatJSONObject): string;
+export declare const ChatGenerationParamsPluginWeb$outboundSchema: z.ZodType<ChatGenerationParamsPluginWeb$Outbound, ChatGenerationParamsPluginWeb>;
+export declare function chatGenerationParamsPluginWebToJSON(chatGenerationParamsPluginWeb: ChatGenerationParamsPluginWeb): string;
 /** @internal */
-export type ResponseFormatText$Outbound = {
-    type: "text";
+export type ChatGenerationParamsPluginModeration$Outbound = {
+    id: "moderation";
 };
 /** @internal */
-export declare const ResponseFormatText$outboundSchema: z.ZodType<ResponseFormatText$Outbound, ResponseFormatText>;
-export declare function responseFormatTextToJSON(responseFormatText: ResponseFormatText): string;
+export declare const ChatGenerationParamsPluginModeration$outboundSchema: z.ZodType<ChatGenerationParamsPluginModeration$Outbound, ChatGenerationParamsPluginModeration>;
+export declare function chatGenerationParamsPluginModerationToJSON(chatGenerationParamsPluginModeration: ChatGenerationParamsPluginModeration): string;
 /** @internal */
-export type ResponseFormat$Outbound = ResponseFormatText$Outbound | ResponseFormatJSONObject$Outbound | ResponseFormatJSONSchema$Outbound | ResponseFormatTextGrammar$Outbound | ResponseFormatPython$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 | ChatGenerationParamsPluginContextCompression$Outbound;
+/** @internal */
+export declare const ChatGenerationParamsPluginUnion$outboundSchema: z.ZodType<ChatGenerationParamsPluginUnion$Outbound, ChatGenerationParamsPluginUnion>;
+export declare function chatGenerationParamsPluginUnionToJSON(chatGenerationParamsPluginUnion: ChatGenerationParamsPluginUnion): string;
+/** @internal */
+export type ChatGenerationParamsTrace$Outbound = {
+    trace_id?: string | undefined;
+    trace_name?: string | undefined;
+    span_name?: string | undefined;
+    generation_name?: string | undefined;
+    parent_span_id?: string | undefined;
+    [additionalProperties: string]: unknown;
+};
+/** @internal */
+export declare const ChatGenerationParamsTrace$outboundSchema: z.ZodType<ChatGenerationParamsTrace$Outbound, ChatGenerationParamsTrace>;
+export declare function chatGenerationParamsTraceToJSON(chatGenerationParamsTrace: ChatGenerationParamsTrace): string;
+/** @internal */
+export declare const Effort$outboundSchema: z.ZodType<string, Effort>;
+/** @internal */
+export type Reasoning$Outbound = {
+    effort?: string | null | undefined;
+    summary?: any | null | undefined;
+};
+/** @internal */
+export declare const Reasoning$outboundSchema: z.ZodType<Reasoning$Outbound, Reasoning>;
+export declare function reasoningToJSON(reasoning: Reasoning): string;
+/** @internal */
+export type ResponseFormat$Outbound = ResponseFormatText$Outbound | ResponseFormatJSONObject$Outbound | ResponseFormatJSONSchema$Outbound | ResponseFormatTextGrammar$Outbound | ResponseFormatTextPython$Outbound;
 /** @internal */
 export declare const ResponseFormat$outboundSchema: z.ZodType<ResponseFormat$Outbound, ResponseFormat>;
 export declare function responseFormatToJSON(responseFormat: ResponseFormat): string;
 /** @internal */
-export type Stop$Outbound = string | Array<string>;
+export type Stop$Outbound = string | Array<string> | any;
 /** @internal */
 export declare const Stop$outboundSchema: z.ZodType<Stop$Outbound, Stop>;
 export declare function stopToJSON(stop: Stop): string;
 /** @internal */
-export type Debug$Outbound = {
-    echo_upstream_body?: boolean | undefined;
-};
-/** @internal */
-export declare const Debug$outboundSchema: z.ZodType<Debug$Outbound, Debug>;
-export declare function debugToJSON(debug: Debug): string;
-/** @internal */
-export type ChatGenerationParamsImageConfig$Outbound = string | number | Array<any>;
+export type ChatGenerationParamsImageConfig$Outbound = string | number | Array<any | null>;
 /** @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 declare const ChatGenerationParamsType$outboundSchema: z.ZodEnum<typeof ChatGenerationParamsType>;
+/** @internal */
+export declare const ChatGenerationParamsTtl$outboundSchema: z.ZodType<string, ChatGenerationParamsTtl>;
+/** @internal */
+export type CacheControl$Outbound = {
+    type: string;
+    ttl?: string | undefined;
+};
+/** @internal */
+export declare const CacheControl$outboundSchema: z.ZodType<CacheControl$Outbound, CacheControl>;
+export declare function cacheControlToJSON(cacheControl: CacheControl): string;
+/** @internal */
 export type ChatGenerationParams$Outbound = {
-    provider?: Schema0$Outbound | null | undefined;
-    plugins?: Array<Schema17$Outbound> | undefined;
-    route?: string | null | undefined;
+    provider?: ChatGenerationParamsProvider$Outbound | null | undefined;
+    plugins?: Array<ChatGenerationParamsPluginAutoRouter$Outbound | ChatGenerationParamsPluginModeration$Outbound | ChatGenerationParamsPluginWeb$Outbound | ChatGenerationParamsPluginFileParser$Outbound | ChatGenerationParamsPluginResponseHealing$Outbound | ChatGenerationParamsPluginContextCompression$Outbound> | undefined;
     user?: string | undefined;
     session_id?: string | undefined;
+    trace?: ChatGenerationParamsTrace$Outbound | undefined;
     messages: Array<Message$Outbound>;
     model?: string | undefined;
     models?: Array<string> | undefined;
@@ -242,20 +636,22 @@ export type ChatGenerationParams$Outbound = {
     } | undefined;
     presence_penalty?: number | null | undefined;
     reasoning?: Reasoning$Outbound | undefined;
-    response_format?: ResponseFormatText$Outbound | ResponseFormatJSONObject$Outbound | ResponseFormatJSONSchema$Outbound | ResponseFormatTextGrammar$Outbound | ResponseFormatPython$Outbound | undefined;
+    response_format?: ResponseFormatText$Outbound | ResponseFormatJSONObject$Outbound | ResponseFormatJSONSchema$Outbound | ResponseFormatTextGrammar$Outbound | ResponseFormatTextPython$Outbound | undefined;
     seed?: number | null | undefined;
-    stop?: string | Array<string> | null | undefined;
+    stop?: string | Array<string> | any | null | undefined;
     stream: boolean;
     stream_options?: ChatStreamOptions$Outbound | null | undefined;
-    temperature?: number | null | undefined;
-    tool_choice?: any | undefined;
+    temperature: number | null;
+    parallel_tool_calls?: boolean | null | undefined;
+    tool_choice?: ToolChoiceOption$Outbound | undefined;
     tools?: Array<ToolDefinitionJson$Outbound> | undefined;
-    top_p?: number | null | undefined;
-    debug?: Debug$Outbound | undefined;
+    top_p: number | null;
+    debug?: DebugOptions$Outbound | undefined;
     image_config?: {
-        [k: string]: string | number | Array<any>;
+        [k: string]: string | number | Array<any | null>;
     } | undefined;
     modalities?: Array<string> | undefined;
+    cache_control?: CacheControl$Outbound | undefined;
 };
 /** @internal */
 export declare const ChatGenerationParams$outboundSchema: z.ZodType<ChatGenerationParams$Outbound, ChatGenerationParams>;