@openrouter/sdk 0.1.27 → 0.2.9

package/esm/models/chatcompletionfinishreason.js

@@ -0,0 +1,14 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as openEnums from "../types/enums.js";
+export const ChatCompletionFinishReason = {
+    ToolCalls: "tool_calls",
+    Stop: "stop",
+    Length: "length",
+    ContentFilter: "content_filter",
+    Error: "error",
+};
+/** @internal */
+export const ChatCompletionFinishReason$inboundSchema = openEnums.inboundSchema(ChatCompletionFinishReason);
+//# sourceMappingURL=chatcompletionfinishreason.js.map

package/esm/models/chatgenerationparams.d.ts

@@ -27,8 +27,11 @@ export type ChatGenerationParamsResponseFormatJSONObject = {
 export type ChatGenerationParamsResponseFormatText = {
     type: "text";
 };
-export type ChatGenerationParamsResponseFormatUnion = ResponseFormatJSONSchema | ResponseFormatTextGrammar | ChatGenerationParamsResponseFormatText | ChatGenerationParamsResponseFormatJSONObject | ChatGenerationParamsResponseFormatPython;
+export type ChatGenerationParamsResponseFormatUnion = ChatGenerationParamsResponseFormatText | ChatGenerationParamsResponseFormatJSONObject | ResponseFormatJSONSchema | ResponseFormatTextGrammar | ChatGenerationParamsResponseFormatPython;
 export type ChatGenerationParamsStop = string | Array<string>;
+export type Debug = {
+    echoUpstreamBody?: boolean | undefined;
+};
 export type ChatGenerationParams = {
     messages: Array<Message>;
     model?: string | undefined;
@@ -46,7 +49,7 @@ export type ChatGenerationParams = {
     } | undefined;
     presencePenalty?: number | null | undefined;
     reasoning?: Reasoning | undefined;
-    responseFormat?: ResponseFormatJSONSchema | ResponseFormatTextGrammar | ChatGenerationParamsResponseFormatText | ChatGenerationParamsResponseFormatJSONObject | ChatGenerationParamsResponseFormatPython | undefined;
+    responseFormat?: ChatGenerationParamsResponseFormatText | ChatGenerationParamsResponseFormatJSONObject | ResponseFormatJSONSchema | ResponseFormatTextGrammar | ChatGenerationParamsResponseFormatPython | undefined;
     seed?: number | null | undefined;
     stop?: string | Array<string> | null | undefined;
     stream?: boolean | undefined;
@@ -56,6 +59,7 @@ export type ChatGenerationParams = {
     tools?: Array<ToolDefinitionJson> | undefined;
     topP?: number | null | undefined;
     user?: string | undefined;
+    debug?: Debug | undefined;
 };
 /** @internal */
 export declare const Effort$outboundSchema: z.ZodType<string, Effort>;
@@ -89,7 +93,7 @@ export type ChatGenerationParamsResponseFormatText$Outbound = {
 export declare const ChatGenerationParamsResponseFormatText$outboundSchema: z.ZodType<ChatGenerationParamsResponseFormatText$Outbound, ChatGenerationParamsResponseFormatText>;
 export declare function chatGenerationParamsResponseFormatTextToJSON(chatGenerationParamsResponseFormatText: ChatGenerationParamsResponseFormatText): string;
 /** @internal */
-export type ChatGenerationParamsResponseFormatUnion$Outbound = ResponseFormatJSONSchema$Outbound | ResponseFormatTextGrammar$Outbound | ChatGenerationParamsResponseFormatText$Outbound | ChatGenerationParamsResponseFormatJSONObject$Outbound | ChatGenerationParamsResponseFormatPython$Outbound;
+export type ChatGenerationParamsResponseFormatUnion$Outbound = ChatGenerationParamsResponseFormatText$Outbound | ChatGenerationParamsResponseFormatJSONObject$Outbound | ResponseFormatJSONSchema$Outbound | ResponseFormatTextGrammar$Outbound | ChatGenerationParamsResponseFormatPython$Outbound;
 /** @internal */
 export declare const ChatGenerationParamsResponseFormatUnion$outboundSchema: z.ZodType<ChatGenerationParamsResponseFormatUnion$Outbound, ChatGenerationParamsResponseFormatUnion>;
 export declare function chatGenerationParamsResponseFormatUnionToJSON(chatGenerationParamsResponseFormatUnion: ChatGenerationParamsResponseFormatUnion): string;
@@ -99,6 +103,13 @@ export type ChatGenerationParamsStop$Outbound = string | Array<string>;
 export declare const ChatGenerationParamsStop$outboundSchema: z.ZodType<ChatGenerationParamsStop$Outbound, ChatGenerationParamsStop>;
 export declare function chatGenerationParamsStopToJSON(chatGenerationParamsStop: ChatGenerationParamsStop): 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 ChatGenerationParams$Outbound = {
     messages: Array<Message$Outbound>;
     model?: string | undefined;
@@ -116,7 +127,7 @@ export type ChatGenerationParams$Outbound = {
     } | undefined;
     presence_penalty?: number | null | undefined;
     reasoning?: Reasoning$Outbound | undefined;
-    response_format?: ResponseFormatJSONSchema$Outbound | ResponseFormatTextGrammar$Outbound | ChatGenerationParamsResponseFormatText$Outbound | ChatGenerationParamsResponseFormatJSONObject$Outbound | ChatGenerationParamsResponseFormatPython$Outbound | undefined;
+    response_format?: ChatGenerationParamsResponseFormatText$Outbound | ChatGenerationParamsResponseFormatJSONObject$Outbound | ResponseFormatJSONSchema$Outbound | ResponseFormatTextGrammar$Outbound | ChatGenerationParamsResponseFormatPython$Outbound | undefined;
     seed?: number | null | undefined;
     stop?: string | Array<string> | null | undefined;
     stream: boolean;
@@ -126,6 +137,7 @@ export type ChatGenerationParams$Outbound = {
     tools?: Array<ToolDefinitionJson$Outbound> | undefined;
     top_p?: number | null | undefined;
     user?: string | undefined;
+    debug?: Debug$Outbound | undefined;
 };
 /** @internal */
 export declare const ChatGenerationParams$outboundSchema: z.ZodType<ChatGenerationParams$Outbound, ChatGenerationParams>;

package/esm/models/chatgenerationparams.js

@@ -51,10 +51,10 @@ export function chatGenerationParamsResponseFormatTextToJSON(chatGenerationParam
 }
 /** @internal */
 export const ChatGenerationParamsResponseFormatUnion$outboundSchema = z.union([
-    ResponseFormatJSONSchema$outboundSchema,
-    ResponseFormatTextGrammar$outboundSchema,
     z.lazy(() => ChatGenerationParamsResponseFormatText$outboundSchema),
     z.lazy(() => ChatGenerationParamsResponseFormatJSONObject$outboundSchema),
+    ResponseFormatJSONSchema$outboundSchema,
+    ResponseFormatTextGrammar$outboundSchema,
     z.lazy(() => ChatGenerationParamsResponseFormatPython$outboundSchema),
 ]);
 export function chatGenerationParamsResponseFormatUnionToJSON(chatGenerationParamsResponseFormatUnion) {
@@ -66,6 +66,17 @@ export function chatGenerationParamsStopToJSON(chatGenerationParamsStop) {
     return JSON.stringify(ChatGenerationParamsStop$outboundSchema.parse(chatGenerationParamsStop));
 }
 /** @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 ChatGenerationParams$outboundSchema = z.object({
     messages: z.array(Message$outboundSchema),
     model: z.string().optional(),
@@ -80,10 +91,10 @@ export const ChatGenerationParams$outboundSchema = z.object({
     presencePenalty: z.nullable(z.number()).optional(),
     reasoning: z.lazy(() => Reasoning$outboundSchema).optional(),
     responseFormat: z.union([
-        ResponseFormatJSONSchema$outboundSchema,
-        ResponseFormatTextGrammar$outboundSchema,
         z.lazy(() => ChatGenerationParamsResponseFormatText$outboundSchema),
         z.lazy(() => ChatGenerationParamsResponseFormatJSONObject$outboundSchema),
+        ResponseFormatJSONSchema$outboundSchema,
+        ResponseFormatTextGrammar$outboundSchema,
         z.lazy(() => ChatGenerationParamsResponseFormatPython$outboundSchema),
     ]).optional(),
     seed: z.nullable(z.int()).optional(),
@@ -95,6 +106,7 @@ export const ChatGenerationParams$outboundSchema = z.object({
     tools: z.array(ToolDefinitionJson$outboundSchema).optional(),
     topP: z.nullable(z.number()).optional(),
     user: z.string().optional(),
+    debug: z.lazy(() => Debug$outboundSchema).optional(),
 }).transform((v) => {
     return remap$(v, {
         frequencyPenalty: "frequency_penalty",

package/esm/models/chatmessagecontentitem.d.ts

@@ -1,20 +1,11 @@
 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 { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export type ChatMessageContentItem = (ChatMessageContentItemText & {
-    type: "text";
-}) | (ChatMessageContentItemImage & {
-    type: "image_url";
-}) | (ChatMessageContentItemAudio & {
-    type: "input_audio";
-}) | (ChatMessageContentItemFile & {
-    type: "file";
-}) | (ChatMessageContentItemVideo & {
+export type ChatMessageContentItem = ChatMessageContentItemText | ChatMessageContentItemImage | ChatMessageContentItemAudio | (ChatMessageContentItemVideo & {
     type: "input_video";
 }) | (ChatMessageContentItemVideo & {
     type: "video_url";
@@ -22,15 +13,7 @@ export type ChatMessageContentItem = (ChatMessageContentItemText & {
 /** @internal */
 export declare const ChatMessageContentItem$inboundSchema: z.ZodType<ChatMessageContentItem, unknown>;
 /** @internal */
-export type ChatMessageContentItem$Outbound = (ChatMessageContentItemText$Outbound & {
-    type: "text";
-}) | (ChatMessageContentItemImage$Outbound & {
-    type: "image_url";
-}) | (ChatMessageContentItemAudio$Outbound & {
-    type: "input_audio";
-}) | (ChatMessageContentItemFile$Outbound & {
-    type: "file";
-}) | (ChatMessageContentItemVideo$Outbound & {
+export type ChatMessageContentItem$Outbound = ChatMessageContentItemText$Outbound | ChatMessageContentItemImage$Outbound | ChatMessageContentItemAudio$Outbound | (ChatMessageContentItemVideo$Outbound & {
     type: "input_video";
 }) | (ChatMessageContentItemVideo$Outbound & {
     type: "video_url";

package/esm/models/chatmessagecontentitem.js

@@ -4,25 +4,22 @@
 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";
 /** @internal */
 export const ChatMessageContentItem$inboundSchema = z.union([
-    ChatMessageContentItemText$inboundSchema.and(z.object({ type: z.literal("text") })),
-    ChatMessageContentItemImage$inboundSchema.and(z.object({ type: z.literal("image_url") })),
-    ChatMessageContentItemAudio$inboundSchema.and(z.object({ type: z.literal("input_audio") })),
-    ChatMessageContentItemFile$inboundSchema.and(z.object({ type: z.literal("file") })),
+    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") })),
 ]);
 /** @internal */
 export const ChatMessageContentItem$outboundSchema = z.union([
-    ChatMessageContentItemText$outboundSchema.and(z.object({ type: z.literal("text") })),
-    ChatMessageContentItemImage$outboundSchema.and(z.object({ type: z.literal("image_url") })),
-    ChatMessageContentItemAudio$outboundSchema.and(z.object({ type: z.literal("input_audio") })),
-    ChatMessageContentItemFile$outboundSchema.and(z.object({ type: z.literal("file") })),
+    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") })),
 ]);

package/esm/models/chatmessagecontentitemaudio.d.ts

@@ -1,30 +1,15 @@
 import * as z from "zod/v4";
-import { OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export declare const ChatMessageContentItemAudioFormat: {
-    readonly Wav: "wav";
-    readonly Mp3: "mp3";
-    readonly Flac: "flac";
-    readonly M4a: "m4a";
-    readonly Ogg: "ogg";
-    readonly Pcm16: "pcm16";
-    readonly Pcm24: "pcm24";
-};
-export type ChatMessageContentItemAudioFormat = OpenEnum<typeof ChatMessageContentItemAudioFormat>;
 export type ChatMessageContentItemAudioInputAudio = {
     data: string;
-    format: ChatMessageContentItemAudioFormat;
+    format: string;
 };
 export type ChatMessageContentItemAudio = {
     type: "input_audio";
     inputAudio: ChatMessageContentItemAudioInputAudio;
 };
 /** @internal */
-export declare const ChatMessageContentItemAudioFormat$inboundSchema: z.ZodType<ChatMessageContentItemAudioFormat, unknown>;
-/** @internal */
-export declare const ChatMessageContentItemAudioFormat$outboundSchema: z.ZodType<string, ChatMessageContentItemAudioFormat>;
-/** @internal */
 export declare const ChatMessageContentItemAudioInputAudio$inboundSchema: z.ZodType<ChatMessageContentItemAudioInputAudio, unknown>;
 /** @internal */
 export type ChatMessageContentItemAudioInputAudio$Outbound = {

package/esm/models/chatmessagecontentitemaudio.js

@@ -4,29 +4,15 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-import * as openEnums from "../types/enums.js";
-export const ChatMessageContentItemAudioFormat = {
-    Wav: "wav",
-    Mp3: "mp3",
-    Flac: "flac",
-    M4a: "m4a",
-    Ogg: "ogg",
-    Pcm16: "pcm16",
-    Pcm24: "pcm24",
-};
-/** @internal */
-export const ChatMessageContentItemAudioFormat$inboundSchema = openEnums.inboundSchema(ChatMessageContentItemAudioFormat);
-/** @internal */
-export const ChatMessageContentItemAudioFormat$outboundSchema = openEnums.outboundSchema(ChatMessageContentItemAudioFormat);
 /** @internal */
 export const ChatMessageContentItemAudioInputAudio$inboundSchema = z.object({
     data: z.string(),
-    format: ChatMessageContentItemAudioFormat$inboundSchema,
+    format: z.string(),
 });
 /** @internal */
 export const ChatMessageContentItemAudioInputAudio$outboundSchema = z.object({
     data: z.string(),
-    format: ChatMessageContentItemAudioFormat$outboundSchema,
+    format: z.string(),
 });
 export function chatMessageContentItemAudioInputAudioToJSON(chatMessageContentItemAudioInputAudio) {
     return JSON.stringify(ChatMessageContentItemAudioInputAudio$outboundSchema.parse(chatMessageContentItemAudioInputAudio));

package/esm/models/chatmessagecontentitemcachecontrol.d.ts

@@ -0,0 +1,29 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const Ttl: {
+    readonly Fivem: "5m";
+    readonly Oneh: "1h";
+};
+export type Ttl = OpenEnum<typeof Ttl>;
+export type ChatMessageContentItemCacheControl = {
+    type: "ephemeral";
+    ttl?: Ttl | undefined;
+};
+/** @internal */
+export declare const Ttl$inboundSchema: z.ZodType<Ttl, unknown>;
+/** @internal */
+export declare const Ttl$outboundSchema: z.ZodType<string, Ttl>;
+/** @internal */
+export declare const ChatMessageContentItemCacheControl$inboundSchema: z.ZodType<ChatMessageContentItemCacheControl, unknown>;
+/** @internal */
+export type ChatMessageContentItemCacheControl$Outbound = {
+    type: "ephemeral";
+    ttl?: string | undefined;
+};
+/** @internal */
+export declare const ChatMessageContentItemCacheControl$outboundSchema: z.ZodType<ChatMessageContentItemCacheControl$Outbound, ChatMessageContentItemCacheControl>;
+export declare function chatMessageContentItemCacheControlToJSON(chatMessageContentItemCacheControl: ChatMessageContentItemCacheControl): string;
+export declare function chatMessageContentItemCacheControlFromJSON(jsonString: string): SafeParseResult<ChatMessageContentItemCacheControl, SDKValidationError>;
+//# sourceMappingURL=chatmessagecontentitemcachecontrol.d.ts.map

package/esm/models/chatmessagecontentitemcachecontrol.js

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+export const Ttl = {
+    Fivem: "5m",
+    Oneh: "1h",
+};
+/** @internal */
+export const Ttl$inboundSchema = openEnums
+    .inboundSchema(Ttl);
+/** @internal */
+export const Ttl$outboundSchema = openEnums
+    .outboundSchema(Ttl);
+/** @internal */
+export const ChatMessageContentItemCacheControl$inboundSchema = z.object({
+    type: z.literal("ephemeral"),
+    ttl: Ttl$inboundSchema.optional(),
+});
+/** @internal */
+export const ChatMessageContentItemCacheControl$outboundSchema = z.object({
+    type: z.literal("ephemeral"),
+    ttl: Ttl$outboundSchema.optional(),
+});
+export function chatMessageContentItemCacheControlToJSON(chatMessageContentItemCacheControl) {
+    return JSON.stringify(ChatMessageContentItemCacheControl$outboundSchema.parse(chatMessageContentItemCacheControl));
+}
+export function chatMessageContentItemCacheControlFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatMessageContentItemCacheControl$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageContentItemCacheControl' from JSON`);
+}
+//# sourceMappingURL=chatmessagecontentitemcachecontrol.js.map

package/esm/models/chatmessagecontentitemtext.d.ts

@@ -1,9 +1,11 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
+import { ChatMessageContentItemCacheControl, ChatMessageContentItemCacheControl$Outbound } from "./chatmessagecontentitemcachecontrol.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 export type ChatMessageContentItemText = {
     type: "text";
     text: string;
+    cacheControl?: ChatMessageContentItemCacheControl | undefined;
 };
 /** @internal */
 export declare const ChatMessageContentItemText$inboundSchema: z.ZodType<ChatMessageContentItemText, unknown>;
@@ -11,6 +13,7 @@ export declare const ChatMessageContentItemText$inboundSchema: z.ZodType<ChatMes
 export type ChatMessageContentItemText$Outbound = {
     type: "text";
     text: string;
+    cache_control?: ChatMessageContentItemCacheControl$Outbound | undefined;
 };
 /** @internal */
 export declare const ChatMessageContentItemText$outboundSchema: z.ZodType<ChatMessageContentItemText$Outbound, ChatMessageContentItemText>;

package/esm/models/chatmessagecontentitemtext.js

@@ -2,16 +2,28 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
+import { ChatMessageContentItemCacheControl$inboundSchema, ChatMessageContentItemCacheControl$outboundSchema, } from "./chatmessagecontentitemcachecontrol.js";
 /** @internal */
 export const ChatMessageContentItemText$inboundSchema = z.object({
     type: z.literal("text"),
     text: z.string(),
+    cache_control: ChatMessageContentItemCacheControl$inboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "cache_control": "cacheControl",
+    });
 });
 /** @internal */
 export const ChatMessageContentItemText$outboundSchema = z.object({
     type: z.literal("text"),
     text: z.string(),
+    cacheControl: ChatMessageContentItemCacheControl$outboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        cacheControl: "cache_control",
+    });
 });
 export function chatMessageContentItemTextToJSON(chatMessageContentItemText) {
     return JSON.stringify(ChatMessageContentItemText$outboundSchema.parse(chatMessageContentItemText));

package/esm/models/chatmessagecontentitemvideo.d.ts

@@ -1,46 +1,58 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-import { VideoURL, VideoURL$Outbound } from "./videourl.js";
-export type ChatMessageContentItemVideoVideoUrlVideoUrl = {
+export type VideoUrl2 = {
     url: string;
 };
 export type ChatMessageContentItemVideoVideoURL = {
     type: "video_url";
-    videoUrl: ChatMessageContentItemVideoVideoUrlVideoUrl;
+    videoUrl: VideoUrl2;
+};
+export type VideoUrl1 = {
+    url: string;
 };
 export type ChatMessageContentItemVideoInputVideo = {
     type: "input_video";
-    videoUrl: VideoURL;
+    videoUrl: VideoUrl1;
 };
 export type ChatMessageContentItemVideo = ChatMessageContentItemVideoInputVideo | ChatMessageContentItemVideoVideoURL;
 /** @internal */
-export declare const ChatMessageContentItemVideoVideoUrlVideoUrl$inboundSchema: z.ZodType<ChatMessageContentItemVideoVideoUrlVideoUrl, unknown>;
+export declare const VideoUrl2$inboundSchema: z.ZodType<VideoUrl2, unknown>;
 /** @internal */
-export type ChatMessageContentItemVideoVideoUrlVideoUrl$Outbound = {
+export type VideoUrl2$Outbound = {
     url: string;
 };
 /** @internal */
-export declare const ChatMessageContentItemVideoVideoUrlVideoUrl$outboundSchema: z.ZodType<ChatMessageContentItemVideoVideoUrlVideoUrl$Outbound, ChatMessageContentItemVideoVideoUrlVideoUrl>;
-export declare function chatMessageContentItemVideoVideoUrlVideoUrlToJSON(chatMessageContentItemVideoVideoUrlVideoUrl: ChatMessageContentItemVideoVideoUrlVideoUrl): string;
-export declare function chatMessageContentItemVideoVideoUrlVideoUrlFromJSON(jsonString: string): SafeParseResult<ChatMessageContentItemVideoVideoUrlVideoUrl, SDKValidationError>;
+export declare const VideoUrl2$outboundSchema: z.ZodType<VideoUrl2$Outbound, VideoUrl2>;
+export declare function videoUrl2ToJSON(videoUrl2: VideoUrl2): string;
+export declare function videoUrl2FromJSON(jsonString: string): SafeParseResult<VideoUrl2, SDKValidationError>;
 /** @internal */
 export declare const ChatMessageContentItemVideoVideoURL$inboundSchema: z.ZodType<ChatMessageContentItemVideoVideoURL, unknown>;
 /** @internal */
 export type ChatMessageContentItemVideoVideoURL$Outbound = {
     type: "video_url";
-    video_url: ChatMessageContentItemVideoVideoUrlVideoUrl$Outbound;
+    video_url: VideoUrl2$Outbound;
 };
 /** @internal */
 export declare const ChatMessageContentItemVideoVideoURL$outboundSchema: z.ZodType<ChatMessageContentItemVideoVideoURL$Outbound, ChatMessageContentItemVideoVideoURL>;
 export declare function chatMessageContentItemVideoVideoURLToJSON(chatMessageContentItemVideoVideoURL: ChatMessageContentItemVideoVideoURL): string;
 export declare function chatMessageContentItemVideoVideoURLFromJSON(jsonString: string): SafeParseResult<ChatMessageContentItemVideoVideoURL, SDKValidationError>;
 /** @internal */
+export declare const VideoUrl1$inboundSchema: z.ZodType<VideoUrl1, unknown>;
+/** @internal */
+export type VideoUrl1$Outbound = {
+    url: string;
+};
+/** @internal */
+export declare const VideoUrl1$outboundSchema: z.ZodType<VideoUrl1$Outbound, VideoUrl1>;
+export declare function videoUrl1ToJSON(videoUrl1: VideoUrl1): string;
+export declare function videoUrl1FromJSON(jsonString: string): SafeParseResult<VideoUrl1, SDKValidationError>;
+/** @internal */
 export declare const ChatMessageContentItemVideoInputVideo$inboundSchema: z.ZodType<ChatMessageContentItemVideoInputVideo, unknown>;
 /** @internal */
 export type ChatMessageContentItemVideoInputVideo$Outbound = {
     type: "input_video";
-    video_url: VideoURL$Outbound;
+    video_url: VideoUrl1$Outbound;
 };
 /** @internal */
 export declare const ChatMessageContentItemVideoInputVideo$outboundSchema: z.ZodType<ChatMessageContentItemVideoInputVideo$Outbound, ChatMessageContentItemVideoInputVideo>;

package/esm/models/chatmessagecontentitemvideo.js

@@ -4,25 +4,24 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-import { VideoURL$inboundSchema, VideoURL$outboundSchema, } from "./videourl.js";
 /** @internal */
-export const ChatMessageContentItemVideoVideoUrlVideoUrl$inboundSchema = z.object({
+export const VideoUrl2$inboundSchema = z.object({
     url: z.string(),
 });
 /** @internal */
-export const ChatMessageContentItemVideoVideoUrlVideoUrl$outboundSchema = z.object({
+export const VideoUrl2$outboundSchema = z.object({
     url: z.string(),
 });
-export function chatMessageContentItemVideoVideoUrlVideoUrlToJSON(chatMessageContentItemVideoVideoUrlVideoUrl) {
-    return JSON.stringify(ChatMessageContentItemVideoVideoUrlVideoUrl$outboundSchema.parse(chatMessageContentItemVideoVideoUrlVideoUrl));
+export function videoUrl2ToJSON(videoUrl2) {
+    return JSON.stringify(VideoUrl2$outboundSchema.parse(videoUrl2));
 }
-export function chatMessageContentItemVideoVideoUrlVideoUrlFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => ChatMessageContentItemVideoVideoUrlVideoUrl$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageContentItemVideoVideoUrlVideoUrl' from JSON`);
+export function videoUrl2FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => VideoUrl2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'VideoUrl2' from JSON`);
 }
 /** @internal */
 export const ChatMessageContentItemVideoVideoURL$inboundSchema = z.object({
     type: z.literal("video_url"),
-    video_url: z.lazy(() => ChatMessageContentItemVideoVideoUrlVideoUrl$inboundSchema),
+    video_url: z.lazy(() => VideoUrl2$inboundSchema),
 }).transform((v) => {
     return remap$(v, {
         "video_url": "videoUrl",
@@ -31,7 +30,7 @@ export const ChatMessageContentItemVideoVideoURL$inboundSchema = z.object({
 /** @internal */
 export const ChatMessageContentItemVideoVideoURL$outboundSchema = z.object({
     type: z.literal("video_url"),
-    videoUrl: z.lazy(() => ChatMessageContentItemVideoVideoUrlVideoUrl$outboundSchema),
+    videoUrl: z.lazy(() => VideoUrl2$outboundSchema),
 }).transform((v) => {
     return remap$(v, {
         videoUrl: "video_url",
@@ -44,9 +43,23 @@ export function chatMessageContentItemVideoVideoURLFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ChatMessageContentItemVideoVideoURL$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageContentItemVideoVideoURL' from JSON`);
 }
 /** @internal */
+export const VideoUrl1$inboundSchema = z.object({
+    url: z.string(),
+});
+/** @internal */
+export const VideoUrl1$outboundSchema = z.object({
+    url: z.string(),
+});
+export function videoUrl1ToJSON(videoUrl1) {
+    return JSON.stringify(VideoUrl1$outboundSchema.parse(videoUrl1));
+}
+export function videoUrl1FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => VideoUrl1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'VideoUrl1' from JSON`);
+}
+/** @internal */
 export const ChatMessageContentItemVideoInputVideo$inboundSchema = z.object({
     type: z.literal("input_video"),
-    video_url: VideoURL$inboundSchema,
+    video_url: z.lazy(() => VideoUrl1$inboundSchema),
 }).transform((v) => {
     return remap$(v, {
         "video_url": "videoUrl",
@@ -55,7 +68,7 @@ export const ChatMessageContentItemVideoInputVideo$inboundSchema = z.object({
 /** @internal */
 export const ChatMessageContentItemVideoInputVideo$outboundSchema = z.object({
     type: z.literal("input_video"),
-    videoUrl: VideoURL$outboundSchema,
+    videoUrl: z.lazy(() => VideoUrl1$outboundSchema),
 }).transform((v) => {
     return remap$(v, {
         videoUrl: "video_url",

package/esm/models/chatresponsechoice.d.ts

@@ -1,36 +1,16 @@
 import * as z from "zod/v4";
-import { OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { AssistantMessage } from "./assistantmessage.js";
+import { ChatCompletionFinishReason } from "./chatcompletionfinishreason.js";
 import { ChatMessageTokenLogprobs } from "./chatmessagetokenlogprobs.js";
-import { ChatStreamingMessageChunk } from "./chatstreamingmessagechunk.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export declare const ChatCompletionFinishReason: {
-    readonly ToolCalls: "tool_calls";
-    readonly Stop: "stop";
-    readonly Length: "length";
-    readonly ContentFilter: "content_filter";
-    readonly Error: "error";
-};
-export type ChatCompletionFinishReason = OpenEnum<typeof ChatCompletionFinishReason>;
 export type ChatResponseChoice = {
     finishReason: ChatCompletionFinishReason | null;
     index: number;
     message: AssistantMessage;
     logprobs?: ChatMessageTokenLogprobs | null | undefined;
 };
-export type ChatStreamingChoice = {
-    delta: ChatStreamingMessageChunk;
-    finishReason: ChatCompletionFinishReason | null;
-    index: number;
-    logprobs?: ChatMessageTokenLogprobs | null | undefined;
-};
-/** @internal */
-export declare const ChatCompletionFinishReason$inboundSchema: z.ZodType<ChatCompletionFinishReason, unknown>;
 /** @internal */
 export declare const ChatResponseChoice$inboundSchema: z.ZodType<ChatResponseChoice, unknown>;
 export declare function chatResponseChoiceFromJSON(jsonString: string): SafeParseResult<ChatResponseChoice, SDKValidationError>;
-/** @internal */
-export declare const ChatStreamingChoice$inboundSchema: z.ZodType<ChatStreamingChoice, unknown>;
-export declare function chatStreamingChoiceFromJSON(jsonString: string): SafeParseResult<ChatStreamingChoice, SDKValidationError>;
 //# sourceMappingURL=chatresponsechoice.d.ts.map

package/esm/models/chatresponsechoice.js

@@ -4,19 +4,9 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-import * as openEnums from "../types/enums.js";
 import { AssistantMessage$inboundSchema, } from "./assistantmessage.js";
+import { ChatCompletionFinishReason$inboundSchema, } from "./chatcompletionfinishreason.js";
 import { ChatMessageTokenLogprobs$inboundSchema, } from "./chatmessagetokenlogprobs.js";
-import { ChatStreamingMessageChunk$inboundSchema, } from "./chatstreamingmessagechunk.js";
-export const ChatCompletionFinishReason = {
-    ToolCalls: "tool_calls",
-    Stop: "stop",
-    Length: "length",
-    ContentFilter: "content_filter",
-    Error: "error",
-};
-/** @internal */
-export const ChatCompletionFinishReason$inboundSchema = openEnums.inboundSchema(ChatCompletionFinishReason);
 /** @internal */
 export const ChatResponseChoice$inboundSchema = z.object({
     finish_reason: z.nullable(ChatCompletionFinishReason$inboundSchema),
@@ -31,18 +21,4 @@ export const ChatResponseChoice$inboundSchema = z.object({
 export function chatResponseChoiceFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ChatResponseChoice$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatResponseChoice' from JSON`);
 }
-/** @internal */
-export const ChatStreamingChoice$inboundSchema = z.object({
-    delta: ChatStreamingMessageChunk$inboundSchema,
-    finish_reason: z.nullable(ChatCompletionFinishReason$inboundSchema),
-    index: z.number(),
-    logprobs: z.nullable(ChatMessageTokenLogprobs$inboundSchema).optional(),
-}).transform((v) => {
-    return remap$(v, {
-        "finish_reason": "finishReason",
-    });
-});
-export function chatStreamingChoiceFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => ChatStreamingChoice$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatStreamingChoice' from JSON`);
-}
 //# sourceMappingURL=chatresponsechoice.js.map

package/esm/models/chatstreamingchoice.d.ts

@@ -0,0 +1,16 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { ChatCompletionFinishReason } from "./chatcompletionfinishreason.js";
+import { ChatMessageTokenLogprobs } from "./chatmessagetokenlogprobs.js";
+import { ChatStreamingMessageChunk } from "./chatstreamingmessagechunk.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type ChatStreamingChoice = {
+    delta: ChatStreamingMessageChunk;
+    finishReason: ChatCompletionFinishReason | null;
+    index: number;
+    logprobs?: ChatMessageTokenLogprobs | null | undefined;
+};
+/** @internal */
+export declare const ChatStreamingChoice$inboundSchema: z.ZodType<ChatStreamingChoice, unknown>;
+export declare function chatStreamingChoiceFromJSON(jsonString: string): SafeParseResult<ChatStreamingChoice, SDKValidationError>;
+//# sourceMappingURL=chatstreamingchoice.d.ts.map