@openrouter/sdk 0.5.1 → 0.9.11

package/esm/models/chatgenerationparams.js

@@ -6,41 +6,58 @@ 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 { 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 { Schema0$outboundSchema, } from "./schema0.js";
+import { ResponseFormatTextPython$outboundSchema, } from "./responseformattextpython.js";
+import { ToolChoiceOption$outboundSchema, } from "./toolchoiceoption.js";
 import { ToolDefinitionJson$outboundSchema, } from "./tooldefinitionjson.js";
-export const ChatGenerationParamsDataCollection = {
-    Deny: "deny",
-    Allow: "allow",
+import { WebSearchEngine$outboundSchema, } from "./websearchengine.js";
+export const ChatGenerationParamsSortEnum = {
+    Price: "price",
+    Throughput: "throughput",
+    Latency: "latency",
 };
-export const Quantizations = {
-    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",
 };
-export const PdfEngine = {
-    MistralOcr: "mistral-ocr",
-    PdfText: "pdf-text",
-    Native: "native",
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
+export const ChatGenerationParamsBy = {
+    Price: "price",
+    Throughput: "throughput",
+    Latency: "latency",
 };
-export const Engine = {
-    Native: "native",
-    Exa: "exa",
+/**
+ * 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",
 };
-export const Route = {
-    Fallback: "fallback",
-    Sort: "sort",
+/**
+ * The provider sorting strategy (price, throughput, latency)
+ */
+export const ChatGenerationParamsProviderSort = {
+    Price: "price",
+    Throughput: "throughput",
+    Latency: "latency",
 };
+/**
+ * Constrains effort on reasoning for reasoning models
+ */
 export const Effort = {
     Xhigh: "xhigh",
     High: "high",
@@ -54,79 +71,97 @@ export const Modality = {
     Image: "image",
 };
 /** @internal */
-export const ChatGenerationParamsDataCollection$outboundSchema = openEnums.outboundSchema(ChatGenerationParamsDataCollection);
+export const ChatGenerationParamsOrder$outboundSchema = z.union([ProviderName$outboundSchema, z.string()]);
+export function chatGenerationParamsOrderToJSON(chatGenerationParamsOrder) {
+    return JSON.stringify(ChatGenerationParamsOrder$outboundSchema.parse(chatGenerationParamsOrder));
+}
 /** @internal */
-export const Quantizations$outboundSchema = openEnums.outboundSchema(Quantizations);
+export const ChatGenerationParamsOnly$outboundSchema = z.union([ProviderName$outboundSchema, z.string()]);
+export function chatGenerationParamsOnlyToJSON(chatGenerationParamsOnly) {
+    return JSON.stringify(ChatGenerationParamsOnly$outboundSchema.parse(chatGenerationParamsOnly));
+}
 /** @internal */
-export const ChatGenerationParamsMaxPrice$outboundSchema = z.object({
-    prompt: z.any().optional(),
-    completion: z.any().optional(),
-    image: z.any().optional(),
-    audio: z.any().optional(),
-    request: z.any().optional(),
-});
-export function chatGenerationParamsMaxPriceToJSON(chatGenerationParamsMaxPrice) {
-    return JSON.stringify(ChatGenerationParamsMaxPrice$outboundSchema.parse(chatGenerationParamsMaxPrice));
+export const ChatGenerationParamsIgnore$outboundSchema = z.union([ProviderName$outboundSchema, z.string()]);
+export function chatGenerationParamsIgnoreToJSON(chatGenerationParamsIgnore) {
+    return JSON.stringify(ChatGenerationParamsIgnore$outboundSchema.parse(chatGenerationParamsIgnore));
 }
 /** @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 const ChatGenerationParamsSortEnum$outboundSchema = openEnums.outboundSchema(ChatGenerationParamsSortEnum);
+/** @internal */
+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 chatGenerationParamsPreferredMinThroughputToJSON(chatGenerationParamsPreferredMinThroughput) {
-    return JSON.stringify(ChatGenerationParamsPreferredMinThroughput$outboundSchema.parse(chatGenerationParamsPreferredMinThroughput));
+export function chatGenerationParamsProviderSortConfigToJSON(chatGenerationParamsProviderSortConfig) {
+    return JSON.stringify(ChatGenerationParamsProviderSortConfig$outboundSchema.parse(chatGenerationParamsProviderSortConfig));
 }
 /** @internal */
-export const ChatGenerationParamsPreferredMinThroughputUnion$outboundSchema = z.union([
-    z.number(),
-    z.lazy(() => ChatGenerationParamsPreferredMinThroughput$outboundSchema),
+export const ChatGenerationParamsProviderSortConfigUnion$outboundSchema = z.union([
+    z.lazy(() => ChatGenerationParamsProviderSortConfig$outboundSchema),
+    ChatGenerationParamsProviderSortConfigEnum$outboundSchema,
 ]);
-export function chatGenerationParamsPreferredMinThroughputUnionToJSON(chatGenerationParamsPreferredMinThroughputUnion) {
-    return JSON.stringify(ChatGenerationParamsPreferredMinThroughputUnion$outboundSchema.parse(chatGenerationParamsPreferredMinThroughputUnion));
+export function chatGenerationParamsProviderSortConfigUnionToJSON(chatGenerationParamsProviderSortConfigUnion) {
+    return JSON.stringify(ChatGenerationParamsProviderSortConfigUnion$outboundSchema.parse(chatGenerationParamsProviderSortConfigUnion));
 }
 /** @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));
-}
+export const ChatGenerationParamsProviderSort$outboundSchema = openEnums.outboundSchema(ChatGenerationParamsProviderSort);
 /** @internal */
-export const ChatGenerationParamsPreferredMaxLatencyUnion$outboundSchema = z.union([
-    z.number(),
-    z.lazy(() => ChatGenerationParamsPreferredMaxLatency$outboundSchema),
+export const ChatGenerationParamsSortUnion$outboundSchema = z.union([
+    ChatGenerationParamsProviderSort$outboundSchema,
+    z.union([
+        z.lazy(() => ChatGenerationParamsProviderSortConfig$outboundSchema),
+        ChatGenerationParamsProviderSortConfigEnum$outboundSchema,
+    ]),
+    ChatGenerationParamsSortEnum$outboundSchema,
 ]);
-export function chatGenerationParamsPreferredMaxLatencyUnionToJSON(chatGenerationParamsPreferredMaxLatencyUnion) {
-    return JSON.stringify(ChatGenerationParamsPreferredMaxLatencyUnion$outboundSchema.parse(chatGenerationParamsPreferredMaxLatencyUnion));
+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(ChatGenerationParamsDataCollection$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(Schema0$outboundSchema)).optional(),
-    only: z.nullable(z.array(Schema0$outboundSchema)).optional(),
-    ignore: z.nullable(z.array(Schema0$outboundSchema)).optional(),
-    quantizations: z.nullable(z.array(Quantizations$outboundSchema)).optional(),
-    sort: z.nullable(ProviderSortUnion$outboundSchema).optional(),
-    maxPrice: z.lazy(() => ChatGenerationParamsMaxPrice$outboundSchema)
+    order: z.nullable(z.array(z.union([ProviderName$outboundSchema, z.string()])))
         .optional(),
-    preferredMinThroughput: z.nullable(z.union([
-        z.number(),
-        z.lazy(() => ChatGenerationParamsPreferredMinThroughput$outboundSchema),
-    ])).optional(),
-    preferredMaxLatency: z.nullable(z.union([
-        z.number(),
-        z.lazy(() => ChatGenerationParamsPreferredMaxLatency$outboundSchema),
+    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",
@@ -150,34 +185,21 @@ export function chatGenerationParamsPluginResponseHealingToJSON(chatGenerationPa
     return JSON.stringify(ChatGenerationParamsPluginResponseHealing$outboundSchema.parse(chatGenerationParamsPluginResponseHealing));
 }
 /** @internal */
-export const PdfEngine$outboundSchema = openEnums
-    .outboundSchema(PdfEngine);
-/** @internal */
-export const Pdf$outboundSchema = z.object({
-    engine: PdfEngine$outboundSchema.optional(),
-});
-export function pdfToJSON(pdf) {
-    return JSON.stringify(Pdf$outboundSchema.parse(pdf));
-}
-/** @internal */
 export const ChatGenerationParamsPluginFileParser$outboundSchema = z.object({
     id: z.literal("file-parser"),
     enabled: z.boolean().optional(),
-    pdf: z.lazy(() => Pdf$outboundSchema).optional(),
+    pdf: PDFParserOptions$outboundSchema.optional(),
 });
 export function chatGenerationParamsPluginFileParserToJSON(chatGenerationParamsPluginFileParser) {
     return JSON.stringify(ChatGenerationParamsPluginFileParser$outboundSchema.parse(chatGenerationParamsPluginFileParser));
 }
 /** @internal */
-export const Engine$outboundSchema = openEnums
-    .outboundSchema(Engine);
-/** @internal */
 export const ChatGenerationParamsPluginWeb$outboundSchema = z.object({
     id: z.literal("web"),
     enabled: z.boolean().optional(),
     maxResults: z.number().optional(),
     searchPrompt: z.string().optional(),
-    engine: Engine$outboundSchema.optional(),
+    engine: WebSearchEngine$outboundSchema.optional(),
 }).transform((v) => {
     return remap$(v, {
         maxResults: "max_results",
@@ -219,47 +241,47 @@ export function chatGenerationParamsPluginUnionToJSON(chatGenerationParamsPlugin
     return JSON.stringify(ChatGenerationParamsPluginUnion$outboundSchema.parse(chatGenerationParamsPluginUnion));
 }
 /** @internal */
-export const Route$outboundSchema = openEnums
-    .outboundSchema(Route);
+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(ReasoningSummaryVerbosity$outboundSchema).optional(),
+    summary: z.nullable(z.any()).optional(),
 });
 export function reasoningToJSON(reasoning) {
     return JSON.stringify(Reasoning$outboundSchema.parse(reasoning));
 }
 /** @internal */
-export const ResponseFormatPython$outboundSchema = z.object({
-    type: z.literal("python"),
-});
-export function responseFormatPythonToJSON(responseFormatPython) {
-    return JSON.stringify(ResponseFormatPython$outboundSchema.parse(responseFormatPython));
-}
-/** @internal */
-export const ResponseFormatJSONObject$outboundSchema = z.object({
-    type: z.literal("json_object"),
-});
-export function responseFormatJSONObjectToJSON(responseFormatJSONObject) {
-    return JSON.stringify(ResponseFormatJSONObject$outboundSchema.parse(responseFormatJSONObject));
-}
-/** @internal */
-export const ResponseFormatText$outboundSchema = z.object({
-    type: z.literal("text"),
-});
-export function responseFormatTextToJSON(responseFormatText) {
-    return JSON.stringify(ResponseFormatText$outboundSchema.parse(responseFormatText));
-}
-/** @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));
@@ -268,23 +290,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()]);
+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));
 }
@@ -301,9 +313,9 @@ export const ChatGenerationParams$outboundSchema = z.object({
         z.lazy(() => ChatGenerationParamsPluginFileParser$outboundSchema),
         z.lazy(() => ChatGenerationParamsPluginResponseHealing$outboundSchema),
     ])).optional(),
-    route: z.nullable(Route$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(),
@@ -317,23 +329,24 @@ 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()]))
-        .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(),
 }).transform((v) => {
     return remap$(v, {
@@ -346,6 +359,7 @@ 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",

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

@@ -4,20 +4,25 @@ import { ChatMessageContentItemAudio, ChatMessageContentItemAudio$Outbound } fro
 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 | 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 | 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

@@ -8,21 +8,42 @@ import { ChatMessageContentItemAudio$inboundSchema, ChatMessageContentItemAudio$
 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") })),
+    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") })),
+    z.union([
+        ChatMessageContentItemVideoLegacy$outboundSchema,
+        ChatMessageContentItemVideo$outboundSchema,
+    ]),
 ]);
 export function chatMessageContentItemToJSON(chatMessageContentItem) {
     return JSON.stringify(ChatMessageContentItem$outboundSchema.parse(chatMessageContentItem));

package/esm/models/chatmessagecontentitemaudio.d.ts

@@ -1,15 +1,33 @@
 import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const ChatMessageContentItemAudioType: {
+    readonly InputAudio: "input_audio";
+};
+export type ChatMessageContentItemAudioType = ClosedEnum<typeof ChatMessageContentItemAudioType>;
 export type ChatMessageContentItemAudioInputAudio = {
+    /**
+     * Base64 encoded audio data
+     */
     data: string;
+    /**
+     * Audio format (e.g., wav, mp3, flac, m4a, ogg, aiff, aac, pcm16, pcm24). Supported formats vary by provider.
+     */
     format: string;
 };
+/**
+ * Audio input content part. Supported audio formats vary by provider.
+ */
 export type ChatMessageContentItemAudio = {
-    type: "input_audio";
+    type: ChatMessageContentItemAudioType;
     inputAudio: ChatMessageContentItemAudioInputAudio;
 };
 /** @internal */
+export declare const ChatMessageContentItemAudioType$inboundSchema: z.ZodEnum<typeof ChatMessageContentItemAudioType>;
+/** @internal */
+export declare const ChatMessageContentItemAudioType$outboundSchema: z.ZodEnum<typeof ChatMessageContentItemAudioType>;
+/** @internal */
 export declare const ChatMessageContentItemAudioInputAudio$inboundSchema: z.ZodType<ChatMessageContentItemAudioInputAudio, unknown>;
 /** @internal */
 export type ChatMessageContentItemAudioInputAudio$Outbound = {
@@ -24,7 +42,7 @@ export declare function chatMessageContentItemAudioInputAudioFromJSON(jsonString
 export declare const ChatMessageContentItemAudio$inboundSchema: z.ZodType<ChatMessageContentItemAudio, unknown>;
 /** @internal */
 export type ChatMessageContentItemAudio$Outbound = {
-    type: "input_audio";
+    type: string;
     input_audio: ChatMessageContentItemAudioInputAudio$Outbound;
 };
 /** @internal */

package/esm/models/chatmessagecontentitemaudio.js

@@ -5,6 +5,13 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
+export const ChatMessageContentItemAudioType = {
+    InputAudio: "input_audio",
+};
+/** @internal */
+export const ChatMessageContentItemAudioType$inboundSchema = z.enum(ChatMessageContentItemAudioType);
+/** @internal */
+export const ChatMessageContentItemAudioType$outboundSchema = ChatMessageContentItemAudioType$inboundSchema;
 /** @internal */
 export const ChatMessageContentItemAudioInputAudio$inboundSchema = z.object({
     data: z.string(),
@@ -23,7 +30,7 @@ export function chatMessageContentItemAudioInputAudioFromJSON(jsonString) {
 }
 /** @internal */
 export const ChatMessageContentItemAudio$inboundSchema = z.object({
-    type: z.literal("input_audio"),
+    type: ChatMessageContentItemAudioType$inboundSchema,
     input_audio: z.lazy(() => ChatMessageContentItemAudioInputAudio$inboundSchema),
 }).transform((v) => {
     return remap$(v, {
@@ -32,7 +39,7 @@ export const ChatMessageContentItemAudio$inboundSchema = z.object({
 });
 /** @internal */
 export const ChatMessageContentItemAudio$outboundSchema = z.object({
-    type: z.literal("input_audio"),
+    type: ChatMessageContentItemAudioType$outboundSchema,
     inputAudio: z.lazy(() => ChatMessageContentItemAudioInputAudio$outboundSchema),
 }).transform((v) => {
     return remap$(v, {