@openrouter/sdk 0.8.0 → 0.9.11

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, {

package/esm/models/chatmessagecontentitemcachecontrol.d.ts

@@ -1,17 +1,28 @@
 import * as z from "zod/v4";
-import { OpenEnum } from "../types/enums.js";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const ChatMessageContentItemCacheControlType: {
+    readonly Ephemeral: "ephemeral";
+};
+export type ChatMessageContentItemCacheControlType = ClosedEnum<typeof ChatMessageContentItemCacheControlType>;
 export declare const Ttl: {
     readonly Fivem: "5m";
     readonly Oneh: "1h";
 };
 export type Ttl = OpenEnum<typeof Ttl>;
+/**
+ * Cache control for the content part
+ */
 export type ChatMessageContentItemCacheControl = {
-    type: "ephemeral";
+    type: ChatMessageContentItemCacheControlType;
     ttl?: Ttl | undefined;
 };
 /** @internal */
+export declare const ChatMessageContentItemCacheControlType$inboundSchema: z.ZodEnum<typeof ChatMessageContentItemCacheControlType>;
+/** @internal */
+export declare const ChatMessageContentItemCacheControlType$outboundSchema: z.ZodEnum<typeof ChatMessageContentItemCacheControlType>;
+/** @internal */
 export declare const Ttl$inboundSchema: z.ZodType<Ttl, unknown>;
 /** @internal */
 export declare const Ttl$outboundSchema: z.ZodType<string, Ttl>;
@@ -19,7 +30,7 @@ export declare const Ttl$outboundSchema: z.ZodType<string, Ttl>;
 export declare const ChatMessageContentItemCacheControl$inboundSchema: z.ZodType<ChatMessageContentItemCacheControl, unknown>;
 /** @internal */
 export type ChatMessageContentItemCacheControl$Outbound = {
-    type: "ephemeral";
+    type: string;
     ttl?: string | undefined;
 };
 /** @internal */

package/esm/models/chatmessagecontentitemcachecontrol.js

@@ -5,11 +5,18 @@
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 import * as openEnums from "../types/enums.js";
+export const ChatMessageContentItemCacheControlType = {
+    Ephemeral: "ephemeral",
+};
 export const Ttl = {
     Fivem: "5m",
     Oneh: "1h",
 };
 /** @internal */
+export const ChatMessageContentItemCacheControlType$inboundSchema = z.enum(ChatMessageContentItemCacheControlType);
+/** @internal */
+export const ChatMessageContentItemCacheControlType$outboundSchema = ChatMessageContentItemCacheControlType$inboundSchema;
+/** @internal */
 export const Ttl$inboundSchema = openEnums
     .inboundSchema(Ttl);
 /** @internal */
@@ -17,12 +24,12 @@ export const Ttl$outboundSchema = openEnums
     .outboundSchema(Ttl);
 /** @internal */
 export const ChatMessageContentItemCacheControl$inboundSchema = z.object({
-    type: z.literal("ephemeral"),
+    type: ChatMessageContentItemCacheControlType$inboundSchema,
     ttl: Ttl$inboundSchema.optional(),
 });
 /** @internal */
 export const ChatMessageContentItemCacheControl$outboundSchema = z.object({
-    type: z.literal("ephemeral"),
+    type: ChatMessageContentItemCacheControlType$outboundSchema,
     ttl: Ttl$outboundSchema.optional(),
 });
 export function chatMessageContentItemCacheControlToJSON(chatMessageContentItemCacheControl) {

package/esm/models/chatmessagecontentitemimage.d.ts

@@ -1,22 +1,45 @@
 import * as z from "zod/v4";
-import { OpenEnum } from "../types/enums.js";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const ChatMessageContentItemImageType: {
+    readonly ImageUrl: "image_url";
+};
+export type ChatMessageContentItemImageType = ClosedEnum<typeof ChatMessageContentItemImageType>;
+/**
+ * Image detail level for vision models
+ */
 export declare const ChatMessageContentItemImageDetail: {
     readonly Auto: "auto";
     readonly Low: "low";
     readonly High: "high";
 };
+/**
+ * Image detail level for vision models
+ */
 export type ChatMessageContentItemImageDetail = OpenEnum<typeof ChatMessageContentItemImageDetail>;
 export type ChatMessageContentItemImageImageUrl = {
+    /**
+     * URL of the image (data: URLs supported)
+     */
     url: string;
+    /**
+     * Image detail level for vision models
+     */
     detail?: ChatMessageContentItemImageDetail | undefined;
 };
+/**
+ * Image content part for vision models
+ */
 export type ChatMessageContentItemImage = {
-    type: "image_url";
+    type: ChatMessageContentItemImageType;
     imageUrl: ChatMessageContentItemImageImageUrl;
 };
 /** @internal */
+export declare const ChatMessageContentItemImageType$inboundSchema: z.ZodEnum<typeof ChatMessageContentItemImageType>;
+/** @internal */
+export declare const ChatMessageContentItemImageType$outboundSchema: z.ZodEnum<typeof ChatMessageContentItemImageType>;
+/** @internal */
 export declare const ChatMessageContentItemImageDetail$inboundSchema: z.ZodType<ChatMessageContentItemImageDetail, unknown>;
 /** @internal */
 export declare const ChatMessageContentItemImageDetail$outboundSchema: z.ZodType<string, ChatMessageContentItemImageDetail>;
@@ -35,7 +58,7 @@ export declare function chatMessageContentItemImageImageUrlFromJSON(jsonString:
 export declare const ChatMessageContentItemImage$inboundSchema: z.ZodType<ChatMessageContentItemImage, unknown>;
 /** @internal */
 export type ChatMessageContentItemImage$Outbound = {
-    type: "image_url";
+    type: string;
     image_url: ChatMessageContentItemImageImageUrl$Outbound;
 };
 /** @internal */

package/esm/models/chatmessagecontentitemimage.js

@@ -6,12 +6,22 @@ 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 ChatMessageContentItemImageType = {
+    ImageUrl: "image_url",
+};
+/**
+ * Image detail level for vision models
+ */
 export const ChatMessageContentItemImageDetail = {
     Auto: "auto",
     Low: "low",
     High: "high",
 };
 /** @internal */
+export const ChatMessageContentItemImageType$inboundSchema = z.enum(ChatMessageContentItemImageType);
+/** @internal */
+export const ChatMessageContentItemImageType$outboundSchema = ChatMessageContentItemImageType$inboundSchema;
+/** @internal */
 export const ChatMessageContentItemImageDetail$inboundSchema = openEnums.inboundSchema(ChatMessageContentItemImageDetail);
 /** @internal */
 export const ChatMessageContentItemImageDetail$outboundSchema = openEnums.outboundSchema(ChatMessageContentItemImageDetail);
@@ -33,7 +43,7 @@ export function chatMessageContentItemImageImageUrlFromJSON(jsonString) {
 }
 /** @internal */
 export const ChatMessageContentItemImage$inboundSchema = z.object({
-    type: z.literal("image_url"),
+    type: ChatMessageContentItemImageType$inboundSchema,
     image_url: z.lazy(() => ChatMessageContentItemImageImageUrl$inboundSchema),
 }).transform((v) => {
     return remap$(v, {
@@ -42,7 +52,7 @@ export const ChatMessageContentItemImage$inboundSchema = z.object({
 });
 /** @internal */
 export const ChatMessageContentItemImage$outboundSchema = z.object({
-    type: z.literal("image_url"),
+    type: ChatMessageContentItemImageType$outboundSchema,
     imageUrl: z.lazy(() => ChatMessageContentItemImageImageUrl$outboundSchema),
 }).transform((v) => {
     return remap$(v, {

package/esm/models/chatmessagecontentitemtext.d.ts

@@ -1,17 +1,32 @@
 import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { ChatMessageContentItemCacheControl, ChatMessageContentItemCacheControl$Outbound } from "./chatmessagecontentitemcachecontrol.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const ChatMessageContentItemTextType: {
+    readonly Text: "text";
+};
+export type ChatMessageContentItemTextType = ClosedEnum<typeof ChatMessageContentItemTextType>;
+/**
+ * Text content part
+ */
 export type ChatMessageContentItemText = {
-    type: "text";
+    type: ChatMessageContentItemTextType;
     text: string;
+    /**
+     * Cache control for the content part
+     */
     cacheControl?: ChatMessageContentItemCacheControl | undefined;
 };
 /** @internal */
+export declare const ChatMessageContentItemTextType$inboundSchema: z.ZodEnum<typeof ChatMessageContentItemTextType>;
+/** @internal */
+export declare const ChatMessageContentItemTextType$outboundSchema: z.ZodEnum<typeof ChatMessageContentItemTextType>;
+/** @internal */
 export declare const ChatMessageContentItemText$inboundSchema: z.ZodType<ChatMessageContentItemText, unknown>;
 /** @internal */
 export type ChatMessageContentItemText$Outbound = {
-    type: "text";
+    type: string;
     text: string;
     cache_control?: ChatMessageContentItemCacheControl$Outbound | undefined;
 };

package/esm/models/chatmessagecontentitemtext.js

@@ -6,9 +6,16 @@ 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";
+export const ChatMessageContentItemTextType = {
+    Text: "text",
+};
+/** @internal */
+export const ChatMessageContentItemTextType$inboundSchema = z.enum(ChatMessageContentItemTextType);
+/** @internal */
+export const ChatMessageContentItemTextType$outboundSchema = ChatMessageContentItemTextType$inboundSchema;
 /** @internal */
 export const ChatMessageContentItemText$inboundSchema = z.object({
-    type: z.literal("text"),
+    type: ChatMessageContentItemTextType$inboundSchema,
     text: z.string(),
     cache_control: ChatMessageContentItemCacheControl$inboundSchema.optional(),
 }).transform((v) => {
@@ -18,7 +25,7 @@ export const ChatMessageContentItemText$inboundSchema = z.object({
 });
 /** @internal */
 export const ChatMessageContentItemText$outboundSchema = z.object({
-    type: z.literal("text"),
+    type: ChatMessageContentItemTextType$outboundSchema,
     text: z.string(),
     cacheControl: ChatMessageContentItemCacheControl$outboundSchema.optional(),
 }).transform((v) => {

package/esm/models/chatmessagecontentitemvideo.d.ts

@@ -1,68 +1,25 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export type VideoUrl2 = {
-    url: string;
-};
-export type ChatMessageContentItemVideoVideoURL = {
+import { VideoInput, VideoInput$Outbound } from "./videoinput.js";
+/**
+ * Video input content part
+ */
+export type ChatMessageContentItemVideo = {
     type: "video_url";
-    videoUrl: VideoUrl2;
-};
-export type VideoUrl1 = {
-    url: string;
-};
-export type ChatMessageContentItemVideoInputVideo = {
-    type: "input_video";
-    videoUrl: VideoUrl1;
-};
-export type ChatMessageContentItemVideo = ChatMessageContentItemVideoInputVideo | ChatMessageContentItemVideoVideoURL;
-/** @internal */
-export declare const VideoUrl2$inboundSchema: z.ZodType<VideoUrl2, unknown>;
-/** @internal */
-export type VideoUrl2$Outbound = {
-    url: string;
+    /**
+     * Video input object
+     */
+    videoUrl: VideoInput;
 };
 /** @internal */
-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>;
+export declare const ChatMessageContentItemVideo$inboundSchema: z.ZodType<ChatMessageContentItemVideo, unknown>;
 /** @internal */
-export type ChatMessageContentItemVideoVideoURL$Outbound = {
+export type ChatMessageContentItemVideo$Outbound = {
     type: "video_url";
-    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: VideoUrl1$Outbound;
+    video_url: VideoInput$Outbound;
 };
 /** @internal */
-export declare const ChatMessageContentItemVideoInputVideo$outboundSchema: z.ZodType<ChatMessageContentItemVideoInputVideo$Outbound, ChatMessageContentItemVideoInputVideo>;
-export declare function chatMessageContentItemVideoInputVideoToJSON(chatMessageContentItemVideoInputVideo: ChatMessageContentItemVideoInputVideo): string;
-export declare function chatMessageContentItemVideoInputVideoFromJSON(jsonString: string): SafeParseResult<ChatMessageContentItemVideoInputVideo, SDKValidationError>;
-/** @internal */
-export declare const ChatMessageContentItemVideo$inboundSchema: z.ZodType<ChatMessageContentItemVideo, unknown>;
-/** @internal */
-export type ChatMessageContentItemVideo$Outbound = ChatMessageContentItemVideoInputVideo$Outbound | ChatMessageContentItemVideoVideoURL$Outbound;
-/** @internal */
 export declare const ChatMessageContentItemVideo$outboundSchema: z.ZodType<ChatMessageContentItemVideo$Outbound, ChatMessageContentItemVideo>;
 export declare function chatMessageContentItemVideoToJSON(chatMessageContentItemVideo: ChatMessageContentItemVideo): string;
 export declare function chatMessageContentItemVideoFromJSON(jsonString: string): SafeParseResult<ChatMessageContentItemVideo, SDKValidationError>;

package/esm/models/chatmessagecontentitemvideo.js

@@ -5,92 +5,25 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
+import { VideoInput$inboundSchema, VideoInput$outboundSchema, } from "./videoinput.js";
 /** @internal */
-export const VideoUrl2$inboundSchema = z.object({
-    url: z.string(),
-});
-/** @internal */
-export const VideoUrl2$outboundSchema = z.object({
-    url: z.string(),
-});
-export function videoUrl2ToJSON(videoUrl2) {
-    return JSON.stringify(VideoUrl2$outboundSchema.parse(videoUrl2));
-}
-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({
+export const ChatMessageContentItemVideo$inboundSchema = z.object({
     type: z.literal("video_url"),
-    video_url: z.lazy(() => VideoUrl2$inboundSchema),
+    video_url: VideoInput$inboundSchema,
 }).transform((v) => {
     return remap$(v, {
         "video_url": "videoUrl",
     });
 });
 /** @internal */
-export const ChatMessageContentItemVideoVideoURL$outboundSchema = z.object({
+export const ChatMessageContentItemVideo$outboundSchema = z.object({
     type: z.literal("video_url"),
-    videoUrl: z.lazy(() => VideoUrl2$outboundSchema),
-}).transform((v) => {
-    return remap$(v, {
-        videoUrl: "video_url",
-    });
-});
-export function chatMessageContentItemVideoVideoURLToJSON(chatMessageContentItemVideoVideoURL) {
-    return JSON.stringify(ChatMessageContentItemVideoVideoURL$outboundSchema.parse(chatMessageContentItemVideoVideoURL));
-}
-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: z.lazy(() => VideoUrl1$inboundSchema),
-}).transform((v) => {
-    return remap$(v, {
-        "video_url": "videoUrl",
-    });
-});
-/** @internal */
-export const ChatMessageContentItemVideoInputVideo$outboundSchema = z.object({
-    type: z.literal("input_video"),
-    videoUrl: z.lazy(() => VideoUrl1$outboundSchema),
+    videoUrl: VideoInput$outboundSchema,
 }).transform((v) => {
     return remap$(v, {
         videoUrl: "video_url",
     });
 });
-export function chatMessageContentItemVideoInputVideoToJSON(chatMessageContentItemVideoInputVideo) {
-    return JSON.stringify(ChatMessageContentItemVideoInputVideo$outboundSchema.parse(chatMessageContentItemVideoInputVideo));
-}
-export function chatMessageContentItemVideoInputVideoFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => ChatMessageContentItemVideoInputVideo$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageContentItemVideoInputVideo' from JSON`);
-}
-/** @internal */
-export const ChatMessageContentItemVideo$inboundSchema = z.union([
-    z.lazy(() => ChatMessageContentItemVideoInputVideo$inboundSchema),
-    z.lazy(() => ChatMessageContentItemVideoVideoURL$inboundSchema),
-]);
-/** @internal */
-export const ChatMessageContentItemVideo$outboundSchema = z.union([
-    z.lazy(() => ChatMessageContentItemVideoInputVideo$outboundSchema),
-    z.lazy(() => ChatMessageContentItemVideoVideoURL$outboundSchema),
-]);
 export function chatMessageContentItemVideoToJSON(chatMessageContentItemVideo) {
     return JSON.stringify(ChatMessageContentItemVideo$outboundSchema.parse(chatMessageContentItemVideo));
 }

package/esm/models/chatmessagecontentitemvideolegacy.d.ts

@@ -0,0 +1,28 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { VideoInput, VideoInput$Outbound } from "./videoinput.js";
+/**
+ * Video input content part (legacy format - deprecated)
+ *
+ * @deprecated class: This will be removed in a future release, please migrate away from it as soon as possible.
+ */
+export type ChatMessageContentItemVideoLegacy = {
+    type: "input_video";
+    /**
+     * Video input object
+     */
+    videoUrl: VideoInput;
+};
+/** @internal */
+export declare const ChatMessageContentItemVideoLegacy$inboundSchema: z.ZodType<ChatMessageContentItemVideoLegacy, unknown>;
+/** @internal */
+export type ChatMessageContentItemVideoLegacy$Outbound = {
+    type: "input_video";
+    video_url: VideoInput$Outbound;
+};
+/** @internal */
+export declare const ChatMessageContentItemVideoLegacy$outboundSchema: z.ZodType<ChatMessageContentItemVideoLegacy$Outbound, ChatMessageContentItemVideoLegacy>;
+export declare function chatMessageContentItemVideoLegacyToJSON(chatMessageContentItemVideoLegacy: ChatMessageContentItemVideoLegacy): string;
+export declare function chatMessageContentItemVideoLegacyFromJSON(jsonString: string): SafeParseResult<ChatMessageContentItemVideoLegacy, SDKValidationError>;
+//# sourceMappingURL=chatmessagecontentitemvideolegacy.d.ts.map

package/esm/models/chatmessagecontentitemvideolegacy.js

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 785ee29d8430
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { VideoInput$inboundSchema, VideoInput$outboundSchema, } from "./videoinput.js";
+/** @internal */
+export const ChatMessageContentItemVideoLegacy$inboundSchema = z.object({
+    type: z.literal("input_video"),
+    video_url: VideoInput$inboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        "video_url": "videoUrl",
+    });
+});
+/** @internal */
+export const ChatMessageContentItemVideoLegacy$outboundSchema = z.object({
+    type: z.literal("input_video"),
+    videoUrl: VideoInput$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        videoUrl: "video_url",
+    });
+});
+export function chatMessageContentItemVideoLegacyToJSON(chatMessageContentItemVideoLegacy) {
+    return JSON.stringify(ChatMessageContentItemVideoLegacy$outboundSchema.parse(chatMessageContentItemVideoLegacy));
+}
+export function chatMessageContentItemVideoLegacyFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatMessageContentItemVideoLegacy$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageContentItemVideoLegacy' from JSON`);
+}
+//# sourceMappingURL=chatmessagecontentitemvideolegacy.js.map

package/esm/models/chatmessagetokenlogprob.d.ts

@@ -6,10 +6,25 @@ export type ChatMessageTokenLogprobTopLogprob = {
     logprob: number;
     bytes: Array<number> | null;
 };
+/**
+ * Token log probability information
+ */
 export type ChatMessageTokenLogprob = {
+    /**
+     * The token
+     */
     token: string;
+    /**
+     * Log probability of the token
+     */
     logprob: number;
+    /**
+     * UTF-8 bytes of the token
+     */
     bytes: Array<number> | null;
+    /**
+     * Top alternative tokens with probabilities
+     */
     topLogprobs: Array<ChatMessageTokenLogprobTopLogprob>;
 };
 /** @internal */

package/esm/models/chatmessagetokenlogprobs.d.ts

@@ -2,8 +2,17 @@ import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { ChatMessageTokenLogprob } from "./chatmessagetokenlogprob.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Log probabilities for the completion
+ */
 export type ChatMessageTokenLogprobs = {
+    /**
+     * Log probabilities for content tokens
+     */
     content: Array<ChatMessageTokenLogprob> | null;
+    /**
+     * Log probabilities for refusal tokens
+     */
     refusal: Array<ChatMessageTokenLogprob> | null;
 };
 /** @internal */

package/esm/models/chatmessagetoolcall.d.ts

@@ -1,16 +1,37 @@
 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 ChatMessageToolCallType: {
+    readonly Function: "function";
+};
+export type ChatMessageToolCallType = ClosedEnum<typeof ChatMessageToolCallType>;
 export type ChatMessageToolCallFunction = {
+    /**
+     * Function name to call
+     */
     name: string;
+    /**
+     * Function arguments as JSON string
+     */
     arguments: string;
 };
+/**
+ * Tool call made by the assistant
+ */
 export type ChatMessageToolCall = {
+    /**
+     * Tool call identifier
+     */
     id: string;
-    type: "function";
+    type: ChatMessageToolCallType;
     function: ChatMessageToolCallFunction;
 };
 /** @internal */
+export declare const ChatMessageToolCallType$inboundSchema: z.ZodEnum<typeof ChatMessageToolCallType>;
+/** @internal */
+export declare const ChatMessageToolCallType$outboundSchema: z.ZodEnum<typeof ChatMessageToolCallType>;
+/** @internal */
 export declare const ChatMessageToolCallFunction$inboundSchema: z.ZodType<ChatMessageToolCallFunction, unknown>;
 /** @internal */
 export type ChatMessageToolCallFunction$Outbound = {
@@ -26,7 +47,7 @@ export declare const ChatMessageToolCall$inboundSchema: z.ZodType<ChatMessageToo
 /** @internal */
 export type ChatMessageToolCall$Outbound = {
     id: string;
-    type: "function";
+    type: string;
     function: ChatMessageToolCallFunction$Outbound;
 };
 /** @internal */

package/esm/models/chatmessagetoolcall.js

@@ -4,6 +4,13 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
+export const ChatMessageToolCallType = {
+    Function: "function",
+};
+/** @internal */
+export const ChatMessageToolCallType$inboundSchema = z.enum(ChatMessageToolCallType);
+/** @internal */
+export const ChatMessageToolCallType$outboundSchema = ChatMessageToolCallType$inboundSchema;
 /** @internal */
 export const ChatMessageToolCallFunction$inboundSchema = z.object({
     name: z.string(),
@@ -23,13 +30,13 @@ export function chatMessageToolCallFunctionFromJSON(jsonString) {
 /** @internal */
 export const ChatMessageToolCall$inboundSchema = z.object({
     id: z.string(),
-    type: z.literal("function"),
+    type: ChatMessageToolCallType$inboundSchema,
     function: z.lazy(() => ChatMessageToolCallFunction$inboundSchema),
 });
 /** @internal */
 export const ChatMessageToolCall$outboundSchema = z.object({
     id: z.string(),
-    type: z.literal("function"),
+    type: ChatMessageToolCallType$outboundSchema,
     function: z.lazy(() => ChatMessageToolCallFunction$outboundSchema),
 });
 export function chatMessageToolCallToJSON(chatMessageToolCall) {