@openrouter/sdk 0.8.0 → 0.10.2

package/esm/models/chatgenerationparams.js

@@ -6,34 +6,63 @@ import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import * as openEnums from "../types/enums.js";
 import { ChatStreamOptions$outboundSchema, } from "./chatstreamoptions.js";
+import { ContextCompressionEngine$outboundSchema, } from "./contextcompressionengine.js";
+import { DataCollection$outboundSchema, } from "./datacollection.js";
+import { DebugOptions$outboundSchema, } from "./debugoptions.js";
 import { Message$outboundSchema, } from "./message.js";
-import { ProviderSortUnion$outboundSchema, } from "./providersortunion.js";
-import { ReasoningSummaryVerbosity$outboundSchema, } from "./reasoningsummaryverbosity.js";
+import { PDFParserOptions$outboundSchema, } from "./pdfparseroptions.js";
+import { PreferredMaxLatency$outboundSchema, } from "./preferredmaxlatency.js";
+import { PreferredMinThroughput$outboundSchema, } from "./preferredminthroughput.js";
+import { ProviderName$outboundSchema } from "./providername.js";
+import { Quantization$outboundSchema } from "./quantization.js";
+import { ResponseFormatJSONObject$outboundSchema, } from "./responseformatjsonobject.js";
 import { ResponseFormatJSONSchema$outboundSchema, } from "./responseformatjsonschema.js";
+import { ResponseFormatText$outboundSchema, } from "./responseformattext.js";
 import { ResponseFormatTextGrammar$outboundSchema, } from "./responseformattextgrammar.js";
-import { Schema10$outboundSchema, } from "./schema10.js";
-import { Schema17$outboundSchema, } from "./schema17.js";
-import { Schema5$outboundSchema, } from "./schema5.js";
+import { ResponseFormatTextPython$outboundSchema, } from "./responseformattextpython.js";
+import { ToolChoiceOption$outboundSchema, } from "./toolchoiceoption.js";
 import { ToolDefinitionJson$outboundSchema, } from "./tooldefinitionjson.js";
-export const Schema3 = {
-    Deny: "deny",
-    Allow: "allow",
+import { WebSearchEngine$outboundSchema, } from "./websearchengine.js";
+export const ChatGenerationParamsSortEnum = {
+    Price: "price",
+    Throughput: "throughput",
+    Latency: "latency",
+    Exacto: "exacto",
 };
-export const Schema8 = {
-    Int4: "int4",
-    Int8: "int8",
-    Fp4: "fp4",
-    Fp6: "fp6",
-    Fp8: "fp8",
-    Fp16: "fp16",
-    Bf16: "bf16",
-    Fp32: "fp32",
-    Unknown: "unknown",
+export const ChatGenerationParamsProviderSortConfigEnum = {
+    Price: "price",
+    Throughput: "throughput",
+    Latency: "latency",
+    Exacto: "exacto",
 };
-export const Route = {
-    Fallback: "fallback",
-    Sort: "sort",
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
+export const ChatGenerationParamsBy = {
+    Price: "price",
+    Throughput: "throughput",
+    Latency: "latency",
+    Exacto: "exacto",
 };
+/**
+ * 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 const ChatGenerationParamsPartition = {
+    Model: "model",
+    None: "none",
+};
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
+export const ChatGenerationParamsProviderSort = {
+    Price: "price",
+    Throughput: "throughput",
+    Latency: "latency",
+    Exacto: "exacto",
+};
+/**
+ * Constrains effort on reasoning for reasoning models
+ */
 export const Effort = {
     Xhigh: "xhigh",
     High: "high",
@@ -45,45 +74,107 @@ export const Effort = {
 export const Modality = {
     Text: "text",
     Image: "image",
+    Audio: "audio",
+};
+export const ChatGenerationParamsType = {
+    Ephemeral: "ephemeral",
+};
+export const ChatGenerationParamsTtl = {
+    Fivem: "5m",
+    Oneh: "1h",
 };
 /** @internal */
-export const Schema3$outboundSchema = openEnums
-    .outboundSchema(Schema3);
+export const ChatGenerationParamsOrder$outboundSchema = z.union([ProviderName$outboundSchema, z.string()]);
+export function chatGenerationParamsOrderToJSON(chatGenerationParamsOrder) {
+    return JSON.stringify(ChatGenerationParamsOrder$outboundSchema.parse(chatGenerationParamsOrder));
+}
+/** @internal */
+export const ChatGenerationParamsOnly$outboundSchema = z.union([ProviderName$outboundSchema, z.string()]);
+export function chatGenerationParamsOnlyToJSON(chatGenerationParamsOnly) {
+    return JSON.stringify(ChatGenerationParamsOnly$outboundSchema.parse(chatGenerationParamsOnly));
+}
+/** @internal */
+export const ChatGenerationParamsIgnore$outboundSchema = z.union([ProviderName$outboundSchema, z.string()]);
+export function chatGenerationParamsIgnoreToJSON(chatGenerationParamsIgnore) {
+    return JSON.stringify(ChatGenerationParamsIgnore$outboundSchema.parse(chatGenerationParamsIgnore));
+}
 /** @internal */
-export const Schema8$outboundSchema = openEnums
-    .outboundSchema(Schema8);
+export const ChatGenerationParamsSortEnum$outboundSchema = openEnums.outboundSchema(ChatGenerationParamsSortEnum);
 /** @internal */
-export const Schema15$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 const ChatGenerationParamsProviderSortConfigEnum$outboundSchema = z.enum(ChatGenerationParamsProviderSortConfigEnum);
+/** @internal */
+export const ChatGenerationParamsBy$outboundSchema = openEnums.outboundSchema(ChatGenerationParamsBy);
+/** @internal */
+export const ChatGenerationParamsPartition$outboundSchema = openEnums.outboundSchema(ChatGenerationParamsPartition);
+/** @internal */
+export const ChatGenerationParamsProviderSortConfig$outboundSchema = z.object({
+    by: z.nullable(ChatGenerationParamsBy$outboundSchema).optional(),
+    partition: z.nullable(ChatGenerationParamsPartition$outboundSchema)
+        .optional(),
 });
-export function schema15ToJSON(schema15) {
-    return JSON.stringify(Schema15$outboundSchema.parse(schema15));
+export function chatGenerationParamsProviderSortConfigToJSON(chatGenerationParamsProviderSortConfig) {
+    return JSON.stringify(ChatGenerationParamsProviderSortConfig$outboundSchema.parse(chatGenerationParamsProviderSortConfig));
 }
 /** @internal */
-export const Schema15Union$outboundSchema = z.union([z.number(), z.lazy(() => Schema15$outboundSchema)]);
-export function schema15UnionToJSON(schema15Union) {
-    return JSON.stringify(Schema15Union$outboundSchema.parse(schema15Union));
+export const ChatGenerationParamsProviderSortConfigUnion$outboundSchema = z.union([
+    z.lazy(() => ChatGenerationParamsProviderSortConfig$outboundSchema),
+    ChatGenerationParamsProviderSortConfigEnum$outboundSchema,
+]);
+export function chatGenerationParamsProviderSortConfigUnionToJSON(chatGenerationParamsProviderSortConfigUnion) {
+    return JSON.stringify(ChatGenerationParamsProviderSortConfigUnion$outboundSchema.parse(chatGenerationParamsProviderSortConfigUnion));
 }
 /** @internal */
-export const Schema0$outboundSchema = z
-    .object({
+export const ChatGenerationParamsProviderSort$outboundSchema = openEnums.outboundSchema(ChatGenerationParamsProviderSort);
+/** @internal */
+export const ChatGenerationParamsSortUnion$outboundSchema = z.union([
+    ChatGenerationParamsProviderSort$outboundSchema,
+    z.union([
+        z.lazy(() => ChatGenerationParamsProviderSortConfig$outboundSchema),
+        ChatGenerationParamsProviderSortConfigEnum$outboundSchema,
+    ]),
+    ChatGenerationParamsSortEnum$outboundSchema,
+]);
+export function chatGenerationParamsSortUnionToJSON(chatGenerationParamsSortUnion) {
+    return JSON.stringify(ChatGenerationParamsSortUnion$outboundSchema.parse(chatGenerationParamsSortUnion));
+}
+/** @internal */
+export const ChatGenerationParamsMaxPrice$outboundSchema = z.object({
+    prompt: z.string().optional(),
+    completion: z.string().optional(),
+    image: z.string().optional(),
+    audio: z.string().optional(),
+    request: z.string().optional(),
+});
+export function chatGenerationParamsMaxPriceToJSON(chatGenerationParamsMaxPrice) {
+    return JSON.stringify(ChatGenerationParamsMaxPrice$outboundSchema.parse(chatGenerationParamsMaxPrice));
+}
+/** @internal */
+export const ChatGenerationParamsProvider$outboundSchema = z.object({
     allowFallbacks: z.nullable(z.boolean()).optional(),
     requireParameters: z.nullable(z.boolean()).optional(),
-    dataCollection: z.nullable(Schema3$outboundSchema).optional(),
+    dataCollection: z.nullable(DataCollection$outboundSchema).optional(),
     zdr: z.nullable(z.boolean()).optional(),
     enforceDistillableText: z.nullable(z.boolean()).optional(),
-    order: z.nullable(z.array(Schema5$outboundSchema)).optional(),
-    only: z.nullable(z.array(Schema5$outboundSchema)).optional(),
-    ignore: z.nullable(z.array(Schema5$outboundSchema)).optional(),
-    quantizations: z.nullable(z.array(Schema8$outboundSchema)).optional(),
-    sort: z.nullable(ProviderSortUnion$outboundSchema).optional(),
-    maxPrice: Schema10$outboundSchema.optional(),
-    preferredMinThroughput: z.nullable(z.union([z.number(), z.lazy(() => Schema15$outboundSchema)])).optional(),
-    preferredMaxLatency: z.nullable(z.union([z.number(), z.lazy(() => Schema15$outboundSchema)])).optional(),
+    order: z.nullable(z.array(z.union([ProviderName$outboundSchema, z.string()])))
+        .optional(),
+    only: z.nullable(z.array(z.union([ProviderName$outboundSchema, z.string()])))
+        .optional(),
+    ignore: z.nullable(z.array(z.union([ProviderName$outboundSchema, z.string()]))).optional(),
+    quantizations: z.nullable(z.array(Quantization$outboundSchema)).optional(),
+    sort: z.nullable(z.union([
+        ChatGenerationParamsProviderSort$outboundSchema,
+        z.union([
+            z.lazy(() => ChatGenerationParamsProviderSortConfig$outboundSchema),
+            ChatGenerationParamsProviderSortConfigEnum$outboundSchema,
+        ]),
+        ChatGenerationParamsSortEnum$outboundSchema,
+    ])).optional(),
+    maxPrice: z.lazy(() => ChatGenerationParamsMaxPrice$outboundSchema)
+        .optional(),
+    preferredMinThroughput: z.nullable(PreferredMinThroughput$outboundSchema)
+        .optional(),
+    preferredMaxLatency: z.nullable(PreferredMaxLatency$outboundSchema)
+        .optional(),
 }).transform((v) => {
     return remap$(v, {
         allowFallbacks: "allow_fallbacks",
@@ -95,51 +186,129 @@ export const Schema0$outboundSchema = z
         preferredMaxLatency: "preferred_max_latency",
     });
 });
-export function schema0ToJSON(schema0) {
-    return JSON.stringify(Schema0$outboundSchema.parse(schema0));
+export function chatGenerationParamsProviderToJSON(chatGenerationParamsProvider) {
+    return JSON.stringify(ChatGenerationParamsProvider$outboundSchema.parse(chatGenerationParamsProvider));
 }
 /** @internal */
-export const Route$outboundSchema = openEnums
-    .outboundSchema(Route);
+export const ChatGenerationParamsPluginContextCompression$outboundSchema = z.object({
+    id: z.literal("context-compression"),
+    enabled: z.boolean().optional(),
+    engine: ContextCompressionEngine$outboundSchema.optional(),
+});
+export function chatGenerationParamsPluginContextCompressionToJSON(chatGenerationParamsPluginContextCompression) {
+    return JSON.stringify(ChatGenerationParamsPluginContextCompression$outboundSchema.parse(chatGenerationParamsPluginContextCompression));
+}
 /** @internal */
-export const Effort$outboundSchema = openEnums
-    .outboundSchema(Effort);
+export const ChatGenerationParamsPluginResponseHealing$outboundSchema = z.object({
+    id: z.literal("response-healing"),
+    enabled: z.boolean().optional(),
+});
+export function chatGenerationParamsPluginResponseHealingToJSON(chatGenerationParamsPluginResponseHealing) {
+    return JSON.stringify(ChatGenerationParamsPluginResponseHealing$outboundSchema.parse(chatGenerationParamsPluginResponseHealing));
+}
 /** @internal */
-export const Reasoning$outboundSchema = z.object({
-    effort: z.nullable(Effort$outboundSchema).optional(),
-    summary: z.nullable(ReasoningSummaryVerbosity$outboundSchema).optional(),
+export const ChatGenerationParamsPluginFileParser$outboundSchema = z.object({
+    id: z.literal("file-parser"),
+    enabled: z.boolean().optional(),
+    pdf: PDFParserOptions$outboundSchema.optional(),
 });
-export function reasoningToJSON(reasoning) {
-    return JSON.stringify(Reasoning$outboundSchema.parse(reasoning));
+export function chatGenerationParamsPluginFileParserToJSON(chatGenerationParamsPluginFileParser) {
+    return JSON.stringify(ChatGenerationParamsPluginFileParser$outboundSchema.parse(chatGenerationParamsPluginFileParser));
 }
 /** @internal */
-export const ResponseFormatPython$outboundSchema = z.object({
-    type: z.literal("python"),
+export const ChatGenerationParamsPluginWeb$outboundSchema = z.object({
+    id: z.literal("web"),
+    enabled: z.boolean().optional(),
+    maxResults: z.number().optional(),
+    searchPrompt: z.string().optional(),
+    engine: WebSearchEngine$outboundSchema.optional(),
+    includeDomains: z.array(z.string()).optional(),
+    excludeDomains: z.array(z.string()).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        maxResults: "max_results",
+        searchPrompt: "search_prompt",
+        includeDomains: "include_domains",
+        excludeDomains: "exclude_domains",
+    });
 });
-export function responseFormatPythonToJSON(responseFormatPython) {
-    return JSON.stringify(ResponseFormatPython$outboundSchema.parse(responseFormatPython));
+export function chatGenerationParamsPluginWebToJSON(chatGenerationParamsPluginWeb) {
+    return JSON.stringify(ChatGenerationParamsPluginWeb$outboundSchema.parse(chatGenerationParamsPluginWeb));
 }
 /** @internal */
-export const ResponseFormatJSONObject$outboundSchema = z.object({
-    type: z.literal("json_object"),
+export const ChatGenerationParamsPluginModeration$outboundSchema = z.object({
+    id: z.literal("moderation"),
+});
+export function chatGenerationParamsPluginModerationToJSON(chatGenerationParamsPluginModeration) {
+    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 responseFormatJSONObjectToJSON(responseFormatJSONObject) {
-    return JSON.stringify(ResponseFormatJSONObject$outboundSchema.parse(responseFormatJSONObject));
+export function chatGenerationParamsPluginAutoRouterToJSON(chatGenerationParamsPluginAutoRouter) {
+    return JSON.stringify(ChatGenerationParamsPluginAutoRouter$outboundSchema.parse(chatGenerationParamsPluginAutoRouter));
 }
 /** @internal */
-export const ResponseFormatText$outboundSchema = z.object({
-    type: z.literal("text"),
+export const ChatGenerationParamsPluginUnion$outboundSchema = z.union([
+    z.lazy(() => ChatGenerationParamsPluginAutoRouter$outboundSchema),
+    z.lazy(() => ChatGenerationParamsPluginModeration$outboundSchema),
+    z.lazy(() => ChatGenerationParamsPluginWeb$outboundSchema),
+    z.lazy(() => ChatGenerationParamsPluginFileParser$outboundSchema),
+    z.lazy(() => ChatGenerationParamsPluginResponseHealing$outboundSchema),
+    z.lazy(() => ChatGenerationParamsPluginContextCompression$outboundSchema),
+]);
+export function chatGenerationParamsPluginUnionToJSON(chatGenerationParamsPluginUnion) {
+    return JSON.stringify(ChatGenerationParamsPluginUnion$outboundSchema.parse(chatGenerationParamsPluginUnion));
+}
+/** @internal */
+export const ChatGenerationParamsTrace$outboundSchema = z.object({
+    traceId: z.string().optional(),
+    traceName: z.string().optional(),
+    spanName: z.string().optional(),
+    generationName: z.string().optional(),
+    parentSpanId: z.string().optional(),
+    additionalProperties: z.record(z.string(), z.nullable(z.any())).optional(),
+}).transform((v) => {
+    return {
+        ...v.additionalProperties,
+        ...remap$(v, {
+            traceId: "trace_id",
+            traceName: "trace_name",
+            spanName: "span_name",
+            generationName: "generation_name",
+            parentSpanId: "parent_span_id",
+            additionalProperties: null,
+        }),
+    };
+});
+export function chatGenerationParamsTraceToJSON(chatGenerationParamsTrace) {
+    return JSON.stringify(ChatGenerationParamsTrace$outboundSchema.parse(chatGenerationParamsTrace));
+}
+/** @internal */
+export const Effort$outboundSchema = openEnums
+    .outboundSchema(Effort);
+/** @internal */
+export const Reasoning$outboundSchema = z.object({
+    effort: z.nullable(Effort$outboundSchema).optional(),
+    summary: z.nullable(z.any()).optional(),
 });
-export function responseFormatTextToJSON(responseFormatText) {
-    return JSON.stringify(ResponseFormatText$outboundSchema.parse(responseFormatText));
+export function reasoningToJSON(reasoning) {
+    return JSON.stringify(Reasoning$outboundSchema.parse(reasoning));
 }
 /** @internal */
 export const ResponseFormat$outboundSchema = z.union([
-    z.lazy(() => ResponseFormatText$outboundSchema),
-    z.lazy(() => ResponseFormatJSONObject$outboundSchema),
+    ResponseFormatText$outboundSchema,
+    ResponseFormatJSONObject$outboundSchema,
     ResponseFormatJSONSchema$outboundSchema,
     ResponseFormatTextGrammar$outboundSchema,
-    z.lazy(() => ResponseFormatPython$outboundSchema),
+    ResponseFormatTextPython$outboundSchema,
 ]);
 export function responseFormatToJSON(responseFormat) {
     return JSON.stringify(ResponseFormat$outboundSchema.parse(responseFormat));
@@ -148,23 +317,13 @@ export function responseFormatToJSON(responseFormat) {
 export const Stop$outboundSchema = z.union([
     z.string(),
     z.array(z.string()),
+    z.any(),
 ]);
 export function stopToJSON(stop) {
     return JSON.stringify(Stop$outboundSchema.parse(stop));
 }
 /** @internal */
-export const Debug$outboundSchema = z.object({
-    echoUpstreamBody: z.boolean().optional(),
-}).transform((v) => {
-    return remap$(v, {
-        echoUpstreamBody: "echo_upstream_body",
-    });
-});
-export function debugToJSON(debug) {
-    return JSON.stringify(Debug$outboundSchema.parse(debug));
-}
-/** @internal */
-export const ChatGenerationParamsImageConfig$outboundSchema = z.union([z.string(), z.number(), z.array(z.any())]);
+export const ChatGenerationParamsImageConfig$outboundSchema = z.union([z.string(), z.number(), z.array(z.nullable(z.any()))]);
 export function chatGenerationParamsImageConfigToJSON(chatGenerationParamsImageConfig) {
     return JSON.stringify(ChatGenerationParamsImageConfig$outboundSchema.parse(chatGenerationParamsImageConfig));
 }
@@ -172,12 +331,31 @@ export function chatGenerationParamsImageConfigToJSON(chatGenerationParamsImageC
 export const Modality$outboundSchema = openEnums
     .outboundSchema(Modality);
 /** @internal */
+export const ChatGenerationParamsType$outboundSchema = z.enum(ChatGenerationParamsType);
+/** @internal */
+export const ChatGenerationParamsTtl$outboundSchema = openEnums.outboundSchema(ChatGenerationParamsTtl);
+/** @internal */
+export const CacheControl$outboundSchema = z.object({
+    type: ChatGenerationParamsType$outboundSchema,
+    ttl: ChatGenerationParamsTtl$outboundSchema.optional(),
+});
+export function cacheControlToJSON(cacheControl) {
+    return JSON.stringify(CacheControl$outboundSchema.parse(cacheControl));
+}
+/** @internal */
 export const ChatGenerationParams$outboundSchema = z.object({
-    provider: z.nullable(z.lazy(() => Schema0$outboundSchema)).optional(),
-    plugins: z.array(Schema17$outboundSchema).optional(),
-    route: z.nullable(Route$outboundSchema).optional(),
+    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),
+        z.lazy(() => ChatGenerationParamsPluginResponseHealing$outboundSchema),
+        z.lazy(() => ChatGenerationParamsPluginContextCompression$outboundSchema),
+    ])).optional(),
     user: z.string().optional(),
     sessionId: z.string().optional(),
+    trace: z.lazy(() => ChatGenerationParamsTrace$outboundSchema).optional(),
     messages: z.array(Message$outboundSchema),
     model: z.string().optional(),
     models: z.array(z.string()).optional(),
@@ -191,23 +369,26 @@ export const ChatGenerationParams$outboundSchema = z.object({
     presencePenalty: z.nullable(z.number()).optional(),
     reasoning: z.lazy(() => Reasoning$outboundSchema).optional(),
     responseFormat: z.union([
-        z.lazy(() => ResponseFormatText$outboundSchema),
-        z.lazy(() => ResponseFormatJSONObject$outboundSchema),
+        ResponseFormatText$outboundSchema,
+        ResponseFormatJSONObject$outboundSchema,
         ResponseFormatJSONSchema$outboundSchema,
         ResponseFormatTextGrammar$outboundSchema,
-        z.lazy(() => ResponseFormatPython$outboundSchema),
+        ResponseFormatTextPython$outboundSchema,
     ]).optional(),
     seed: z.nullable(z.int()).optional(),
-    stop: z.nullable(z.union([z.string(), z.array(z.string())])).optional(),
+    stop: z.nullable(z.union([z.string(), z.array(z.string()), z.any()]))
+        .optional(),
     stream: z.boolean().default(false),
     streamOptions: z.nullable(ChatStreamOptions$outboundSchema).optional(),
-    temperature: z.nullable(z.number()).optional(),
-    toolChoice: z.any().optional(),
+    temperature: z.nullable(z.number().default(1)),
+    parallelToolCalls: z.nullable(z.boolean()).optional(),
+    toolChoice: ToolChoiceOption$outboundSchema.optional(),
     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(), z.array(z.any())])).optional(),
+    topP: z.nullable(z.number().default(1)),
+    debug: DebugOptions$outboundSchema.optional(),
+    imageConfig: z.record(z.string(), z.union([z.string(), z.number(), z.array(z.nullable(z.any()))])).optional(),
     modalities: z.array(Modality$outboundSchema).optional(),
+    cacheControl: z.lazy(() => CacheControl$outboundSchema).optional(),
 }).transform((v) => {
     return remap$(v, {
         sessionId: "session_id",
@@ -219,9 +400,11 @@ export const ChatGenerationParams$outboundSchema = z.object({
         presencePenalty: "presence_penalty",
         responseFormat: "response_format",
         streamOptions: "stream_options",
+        parallelToolCalls: "parallel_tool_calls",
         toolChoice: "tool_choice",
         topP: "top_p",
         imageConfig: "image_config",
+        cacheControl: "cache_control",
     });
 });
 export function chatGenerationParamsToJSON(chatGenerationParams) {

package/esm/models/chatgenerationtokenusage.d.ts

@@ -1,23 +1,71 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Detailed completion token usage
+ */
 export type CompletionTokensDetails = {
+    /**
+     * Tokens used for reasoning
+     */
     reasoningTokens?: number | null | undefined;
+    /**
+     * Tokens used for audio output
+     */
     audioTokens?: number | null | undefined;
+    /**
+     * Accepted prediction tokens
+     */
     acceptedPredictionTokens?: number | null | undefined;
+    /**
+     * Rejected prediction tokens
+     */
     rejectedPredictionTokens?: number | null | undefined;
 };
+/**
+ * Detailed prompt token usage
+ */
 export type PromptTokensDetails = {
+    /**
+     * Cached prompt tokens
+     */
     cachedTokens?: number | undefined;
+    /**
+     * Tokens written to cache. Only returned for models with explicit caching and cache write pricing.
+     */
     cacheWriteTokens?: number | undefined;
+    /**
+     * Audio input tokens
+     */
     audioTokens?: number | undefined;
+    /**
+     * Video input tokens
+     */
     videoTokens?: number | undefined;
 };
+/**
+ * Token usage statistics
+ */
 export type ChatGenerationTokenUsage = {
+    /**
+     * Number of tokens in the completion
+     */
     completionTokens: number;
+    /**
+     * Number of tokens in the prompt
+     */
     promptTokens: number;
+    /**
+     * Total number of tokens
+     */
     totalTokens: number;
+    /**
+     * Detailed completion token usage
+     */
     completionTokensDetails?: CompletionTokensDetails | null | undefined;
+    /**
+     * Detailed prompt token usage
+     */
     promptTokensDetails?: PromptTokensDetails | null | undefined;
 };
 /** @internal */

package/esm/models/chatmessagecontentitem.d.ts

@@ -1,23 +1,29 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { ChatMessageContentItemAudio, ChatMessageContentItemAudio$Outbound } from "./chatmessagecontentitemaudio.js";
+import { ChatMessageContentItemFile, ChatMessageContentItemFile$Outbound } from "./chatmessagecontentitemfile.js";
 import { ChatMessageContentItemImage, ChatMessageContentItemImage$Outbound } from "./chatmessagecontentitemimage.js";
 import { ChatMessageContentItemText, ChatMessageContentItemText$Outbound } from "./chatmessagecontentitemtext.js";
 import { ChatMessageContentItemVideo, ChatMessageContentItemVideo$Outbound } from "./chatmessagecontentitemvideo.js";
+import { ChatMessageContentItemVideoLegacy, ChatMessageContentItemVideoLegacy$Outbound } from "./chatmessagecontentitemvideolegacy.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export type ChatMessageContentItem = ChatMessageContentItemText | ChatMessageContentItemImage | ChatMessageContentItemAudio | (ChatMessageContentItemVideo & {
-    type: "input_video";
-}) | (ChatMessageContentItemVideo & {
-    type: "video_url";
-});
+export type ChatMessageContentItem1 = ChatMessageContentItemVideoLegacy | ChatMessageContentItemVideo;
+/**
+ * Content part for chat completion messages
+ */
+export type ChatMessageContentItem = ChatMessageContentItemText | ChatMessageContentItemImage | ChatMessageContentItemAudio | ChatMessageContentItemFile | ChatMessageContentItemVideoLegacy | ChatMessageContentItemVideo;
+/** @internal */
+export declare const ChatMessageContentItem1$inboundSchema: z.ZodType<ChatMessageContentItem1, unknown>;
+/** @internal */
+export type ChatMessageContentItem1$Outbound = ChatMessageContentItemVideoLegacy$Outbound | ChatMessageContentItemVideo$Outbound;
+/** @internal */
+export declare const ChatMessageContentItem1$outboundSchema: z.ZodType<ChatMessageContentItem1$Outbound, ChatMessageContentItem1>;
+export declare function chatMessageContentItem1ToJSON(chatMessageContentItem1: ChatMessageContentItem1): string;
+export declare function chatMessageContentItem1FromJSON(jsonString: string): SafeParseResult<ChatMessageContentItem1, SDKValidationError>;
 /** @internal */
 export declare const ChatMessageContentItem$inboundSchema: z.ZodType<ChatMessageContentItem, unknown>;
 /** @internal */
-export type ChatMessageContentItem$Outbound = ChatMessageContentItemText$Outbound | ChatMessageContentItemImage$Outbound | ChatMessageContentItemAudio$Outbound | (ChatMessageContentItemVideo$Outbound & {
-    type: "input_video";
-}) | (ChatMessageContentItemVideo$Outbound & {
-    type: "video_url";
-});
+export type ChatMessageContentItem$Outbound = ChatMessageContentItemText$Outbound | ChatMessageContentItemImage$Outbound | ChatMessageContentItemAudio$Outbound | ChatMessageContentItemFile$Outbound | ChatMessageContentItemVideoLegacy$Outbound | ChatMessageContentItemVideo$Outbound;
 /** @internal */
 export declare const ChatMessageContentItem$outboundSchema: z.ZodType<ChatMessageContentItem$Outbound, ChatMessageContentItem>;
 export declare function chatMessageContentItemToJSON(chatMessageContentItem: ChatMessageContentItem): string;

package/esm/models/chatmessagecontentitem.js

@@ -5,24 +5,48 @@
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 import { ChatMessageContentItemAudio$inboundSchema, ChatMessageContentItemAudio$outboundSchema, } from "./chatmessagecontentitemaudio.js";
+import { ChatMessageContentItemFile$inboundSchema, ChatMessageContentItemFile$outboundSchema, } from "./chatmessagecontentitemfile.js";
 import { ChatMessageContentItemImage$inboundSchema, ChatMessageContentItemImage$outboundSchema, } from "./chatmessagecontentitemimage.js";
 import { ChatMessageContentItemText$inboundSchema, ChatMessageContentItemText$outboundSchema, } from "./chatmessagecontentitemtext.js";
 import { ChatMessageContentItemVideo$inboundSchema, ChatMessageContentItemVideo$outboundSchema, } from "./chatmessagecontentitemvideo.js";
+import { ChatMessageContentItemVideoLegacy$inboundSchema, ChatMessageContentItemVideoLegacy$outboundSchema, } from "./chatmessagecontentitemvideolegacy.js";
+/** @internal */
+export const ChatMessageContentItem1$inboundSchema = z.union([
+    ChatMessageContentItemVideoLegacy$inboundSchema,
+    ChatMessageContentItemVideo$inboundSchema,
+]);
+/** @internal */
+export const ChatMessageContentItem1$outboundSchema = z.union([
+    ChatMessageContentItemVideoLegacy$outboundSchema,
+    ChatMessageContentItemVideo$outboundSchema,
+]);
+export function chatMessageContentItem1ToJSON(chatMessageContentItem1) {
+    return JSON.stringify(ChatMessageContentItem1$outboundSchema.parse(chatMessageContentItem1));
+}
+export function chatMessageContentItem1FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatMessageContentItem1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageContentItem1' from JSON`);
+}
 /** @internal */
 export const ChatMessageContentItem$inboundSchema = z.union([
     ChatMessageContentItemText$inboundSchema,
     ChatMessageContentItemImage$inboundSchema,
     ChatMessageContentItemAudio$inboundSchema,
-    ChatMessageContentItemVideo$inboundSchema.and(z.object({ type: z.literal("input_video") })),
-    z.lazy(() => ChatMessageContentItemVideo$inboundSchema).and(z.object({ type: z.literal("video_url") })),
+    ChatMessageContentItemFile$inboundSchema,
+    z.union([
+        ChatMessageContentItemVideoLegacy$inboundSchema,
+        ChatMessageContentItemVideo$inboundSchema,
+    ]),
 ]);
 /** @internal */
 export const ChatMessageContentItem$outboundSchema = z.union([
     ChatMessageContentItemText$outboundSchema,
     ChatMessageContentItemImage$outboundSchema,
     ChatMessageContentItemAudio$outboundSchema,
-    ChatMessageContentItemVideo$outboundSchema.and(z.object({ type: z.literal("input_video") })),
-    z.lazy(() => ChatMessageContentItemVideo$outboundSchema).and(z.object({ type: z.literal("video_url") })),
+    ChatMessageContentItemFile$outboundSchema,
+    z.union([
+        ChatMessageContentItemVideoLegacy$outboundSchema,
+        ChatMessageContentItemVideo$outboundSchema,
+    ]),
 ]);
 export function chatMessageContentItemToJSON(chatMessageContentItem) {
     return JSON.stringify(ChatMessageContentItem$outboundSchema.parse(chatMessageContentItem));