@openrouter/sdk 0.10.2 → 0.12.0

package/esm/models/chatcontentfile.d.ts

@@ -0,0 +1,48 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type FileT = {
+    /**
+     * File content as base64 data URL or URL
+     */
+    fileData?: string | undefined;
+    /**
+     * File ID for previously uploaded files
+     */
+    fileId?: string | undefined;
+    /**
+     * Original filename
+     */
+    filename?: string | undefined;
+};
+/**
+ * File content part for document processing
+ */
+export type ChatContentFile = {
+    file: FileT;
+    type: "file";
+};
+/** @internal */
+export declare const FileT$inboundSchema: z.ZodType<FileT, unknown>;
+/** @internal */
+export type FileT$Outbound = {
+    file_data?: string | undefined;
+    file_id?: string | undefined;
+    filename?: string | undefined;
+};
+/** @internal */
+export declare const FileT$outboundSchema: z.ZodType<FileT$Outbound, FileT>;
+export declare function fileToJSON(fileT: FileT): string;
+export declare function fileFromJSON(jsonString: string): SafeParseResult<FileT, SDKValidationError>;
+/** @internal */
+export declare const ChatContentFile$inboundSchema: z.ZodType<ChatContentFile, unknown>;
+/** @internal */
+export type ChatContentFile$Outbound = {
+    file: FileT$Outbound;
+    type: "file";
+};
+/** @internal */
+export declare const ChatContentFile$outboundSchema: z.ZodType<ChatContentFile$Outbound, ChatContentFile>;
+export declare function chatContentFileToJSON(chatContentFile: ChatContentFile): string;
+export declare function chatContentFileFromJSON(jsonString: string): SafeParseResult<ChatContentFile, SDKValidationError>;
+//# sourceMappingURL=chatcontentfile.d.ts.map

package/esm/models/{chatmessagecontentitemfile.js → chatcontentfile.js}

@@ -1,17 +1,10 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- * @generated-id: ec73b7087290
+ * @generated-id: ee5054f5da9f
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-export const ChatMessageContentItemFileType = {
-    File: "file",
-};
-/** @internal */
-export const ChatMessageContentItemFileType$inboundSchema = z.enum(ChatMessageContentItemFileType);
-/** @internal */
-export const ChatMessageContentItemFileType$outboundSchema = ChatMessageContentItemFileType$inboundSchema;
 /** @internal */
 export const FileT$inboundSchema = z.object({
     file_data: z.string().optional(),
@@ -41,19 +34,19 @@ export function fileFromJSON(jsonString) {
     return safeParse(jsonString, (x) => FileT$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FileT' from JSON`);
 }
 /** @internal */
-export const ChatMessageContentItemFile$inboundSchema = z.object({
-    type: ChatMessageContentItemFileType$inboundSchema,
+export const ChatContentFile$inboundSchema = z.object({
     file: z.lazy(() => FileT$inboundSchema),
+    type: z.literal("file"),
 });
 /** @internal */
-export const ChatMessageContentItemFile$outboundSchema = z.object({
-    type: ChatMessageContentItemFileType$outboundSchema,
+export const ChatContentFile$outboundSchema = z.object({
     file: z.lazy(() => FileT$outboundSchema),
+    type: z.literal("file"),
 });
-export function chatMessageContentItemFileToJSON(chatMessageContentItemFile) {
-    return JSON.stringify(ChatMessageContentItemFile$outboundSchema.parse(chatMessageContentItemFile));
+export function chatContentFileToJSON(chatContentFile) {
+    return JSON.stringify(ChatContentFile$outboundSchema.parse(chatContentFile));
 }
-export function chatMessageContentItemFileFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => ChatMessageContentItemFile$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageContentItemFile' from JSON`);
+export function chatContentFileFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatContentFile$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatContentFile' from JSON`);
 }
-//# sourceMappingURL=chatmessagecontentitemfile.js.map
+//# sourceMappingURL=chatcontentfile.js.map

package/esm/models/chatcontentimage.d.ts

@@ -0,0 +1,60 @@
+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";
+/**
+ * Image detail level for vision models
+ */
+export declare const ChatContentImageDetail: {
+    readonly Auto: "auto";
+    readonly Low: "low";
+    readonly High: "high";
+};
+/**
+ * Image detail level for vision models
+ */
+export type ChatContentImageDetail = OpenEnum<typeof ChatContentImageDetail>;
+export type ChatContentImageImageUrl = {
+    /**
+     * Image detail level for vision models
+     */
+    detail?: ChatContentImageDetail | undefined;
+    /**
+     * URL of the image (data: URLs supported)
+     */
+    url: string;
+};
+/**
+ * Image content part for vision models
+ */
+export type ChatContentImage = {
+    imageUrl: ChatContentImageImageUrl;
+    type: "image_url";
+};
+/** @internal */
+export declare const ChatContentImageDetail$inboundSchema: z.ZodType<ChatContentImageDetail, unknown>;
+/** @internal */
+export declare const ChatContentImageDetail$outboundSchema: z.ZodType<string, ChatContentImageDetail>;
+/** @internal */
+export declare const ChatContentImageImageUrl$inboundSchema: z.ZodType<ChatContentImageImageUrl, unknown>;
+/** @internal */
+export type ChatContentImageImageUrl$Outbound = {
+    detail?: string | undefined;
+    url: string;
+};
+/** @internal */
+export declare const ChatContentImageImageUrl$outboundSchema: z.ZodType<ChatContentImageImageUrl$Outbound, ChatContentImageImageUrl>;
+export declare function chatContentImageImageUrlToJSON(chatContentImageImageUrl: ChatContentImageImageUrl): string;
+export declare function chatContentImageImageUrlFromJSON(jsonString: string): SafeParseResult<ChatContentImageImageUrl, SDKValidationError>;
+/** @internal */
+export declare const ChatContentImage$inboundSchema: z.ZodType<ChatContentImage, unknown>;
+/** @internal */
+export type ChatContentImage$Outbound = {
+    image_url: ChatContentImageImageUrl$Outbound;
+    type: "image_url";
+};
+/** @internal */
+export declare const ChatContentImage$outboundSchema: z.ZodType<ChatContentImage$Outbound, ChatContentImage>;
+export declare function chatContentImageToJSON(chatContentImage: ChatContentImage): string;
+export declare function chatContentImageFromJSON(jsonString: string): SafeParseResult<ChatContentImage, SDKValidationError>;
+//# sourceMappingURL=chatcontentimage.d.ts.map

package/esm/models/chatcontentimage.js

@@ -0,0 +1,61 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 0903ebf8f7a0
+ */
+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";
+/**
+ * Image detail level for vision models
+ */
+export const ChatContentImageDetail = {
+    Auto: "auto",
+    Low: "low",
+    High: "high",
+};
+/** @internal */
+export const ChatContentImageDetail$inboundSchema = openEnums.inboundSchema(ChatContentImageDetail);
+/** @internal */
+export const ChatContentImageDetail$outboundSchema = openEnums.outboundSchema(ChatContentImageDetail);
+/** @internal */
+export const ChatContentImageImageUrl$inboundSchema = z.object({
+    detail: ChatContentImageDetail$inboundSchema.optional(),
+    url: z.string(),
+});
+/** @internal */
+export const ChatContentImageImageUrl$outboundSchema = z.object({
+    detail: ChatContentImageDetail$outboundSchema.optional(),
+    url: z.string(),
+});
+export function chatContentImageImageUrlToJSON(chatContentImageImageUrl) {
+    return JSON.stringify(ChatContentImageImageUrl$outboundSchema.parse(chatContentImageImageUrl));
+}
+export function chatContentImageImageUrlFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatContentImageImageUrl$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatContentImageImageUrl' from JSON`);
+}
+/** @internal */
+export const ChatContentImage$inboundSchema = z.object({
+    image_url: z.lazy(() => ChatContentImageImageUrl$inboundSchema),
+    type: z.literal("image_url"),
+}).transform((v) => {
+    return remap$(v, {
+        "image_url": "imageUrl",
+    });
+});
+/** @internal */
+export const ChatContentImage$outboundSchema = z.object({
+    imageUrl: z.lazy(() => ChatContentImageImageUrl$outboundSchema),
+    type: z.literal("image_url"),
+}).transform((v) => {
+    return remap$(v, {
+        imageUrl: "image_url",
+    });
+});
+export function chatContentImageToJSON(chatContentImage) {
+    return JSON.stringify(ChatContentImage$outboundSchema.parse(chatContentImage));
+}
+export function chatContentImageFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatContentImage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatContentImage' from JSON`);
+}
+//# sourceMappingURL=chatcontentimage.js.map

package/esm/models/chatcontentitems.d.ts

@@ -0,0 +1,27 @@
+import * as z from "zod/v4";
+import * as discriminatedUnionTypes from "../types/discriminatedUnion.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { ChatContentAudio, ChatContentAudio$Outbound } from "./chatcontentaudio.js";
+import { ChatContentFile, ChatContentFile$Outbound } from "./chatcontentfile.js";
+import { ChatContentImage, ChatContentImage$Outbound } from "./chatcontentimage.js";
+import { ChatContentText, ChatContentText$Outbound } from "./chatcontenttext.js";
+import { ChatContentVideo, ChatContentVideo$Outbound } from "./chatcontentvideo.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { LegacyChatContentVideo, LegacyChatContentVideo$Outbound } from "./legacychatcontentvideo.js";
+/**
+ * Content part for chat completion messages
+ */
+export type ChatContentItems = ChatContentFile | ChatContentImage | ChatContentAudio | LegacyChatContentVideo | (ChatContentText & {
+    type: "text";
+}) | ChatContentVideo | discriminatedUnionTypes.Unknown<"type">;
+/** @internal */
+export declare const ChatContentItems$inboundSchema: z.ZodType<ChatContentItems, unknown>;
+/** @internal */
+export type ChatContentItems$Outbound = ChatContentFile$Outbound | ChatContentImage$Outbound | ChatContentAudio$Outbound | LegacyChatContentVideo$Outbound | (ChatContentText$Outbound & {
+    type: "text";
+}) | ChatContentVideo$Outbound;
+/** @internal */
+export declare const ChatContentItems$outboundSchema: z.ZodType<ChatContentItems$Outbound, ChatContentItems>;
+export declare function chatContentItemsToJSON(chatContentItems: ChatContentItems): string;
+export declare function chatContentItemsFromJSON(jsonString: string): SafeParseResult<ChatContentItems, SDKValidationError>;
+//# sourceMappingURL=chatcontentitems.d.ts.map

package/esm/models/chatcontentitems.js

@@ -0,0 +1,38 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 3d8c886d8084
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { discriminatedUnion } from "../types/discriminatedUnion.js";
+import { ChatContentAudio$inboundSchema, ChatContentAudio$outboundSchema, } from "./chatcontentaudio.js";
+import { ChatContentFile$inboundSchema, ChatContentFile$outboundSchema, } from "./chatcontentfile.js";
+import { ChatContentImage$inboundSchema, ChatContentImage$outboundSchema, } from "./chatcontentimage.js";
+import { ChatContentText$inboundSchema, ChatContentText$outboundSchema, } from "./chatcontenttext.js";
+import { ChatContentVideo$inboundSchema, ChatContentVideo$outboundSchema, } from "./chatcontentvideo.js";
+import { LegacyChatContentVideo$inboundSchema, LegacyChatContentVideo$outboundSchema, } from "./legacychatcontentvideo.js";
+/** @internal */
+export const ChatContentItems$inboundSchema = discriminatedUnion("type", {
+    file: ChatContentFile$inboundSchema,
+    image_url: ChatContentImage$inboundSchema,
+    input_audio: ChatContentAudio$inboundSchema,
+    input_video: LegacyChatContentVideo$inboundSchema,
+    text: ChatContentText$inboundSchema.and(z.object({ type: z.literal("text") })),
+    video_url: ChatContentVideo$inboundSchema,
+});
+/** @internal */
+export const ChatContentItems$outboundSchema = z.union([
+    ChatContentFile$outboundSchema,
+    ChatContentImage$outboundSchema,
+    ChatContentAudio$outboundSchema,
+    LegacyChatContentVideo$outboundSchema,
+    ChatContentText$outboundSchema.and(z.object({ type: z.literal("text") })),
+    ChatContentVideo$outboundSchema,
+]);
+export function chatContentItemsToJSON(chatContentItems) {
+    return JSON.stringify(ChatContentItems$outboundSchema.parse(chatContentItems));
+}
+export function chatContentItemsFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatContentItems$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatContentItems' from JSON`);
+}
+//# sourceMappingURL=chatcontentitems.js.map

package/esm/models/chatcontenttext.d.ts

@@ -0,0 +1,37 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { ChatContentCacheControl, ChatContentCacheControl$Outbound } from "./chatcontentcachecontrol.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const ChatContentTextType: {
+    readonly Text: "text";
+};
+export type ChatContentTextType = ClosedEnum<typeof ChatContentTextType>;
+/**
+ * Text content part
+ */
+export type ChatContentText = {
+    /**
+     * Cache control for the content part
+     */
+    cacheControl?: ChatContentCacheControl | undefined;
+    text: string;
+    type: ChatContentTextType;
+};
+/** @internal */
+export declare const ChatContentTextType$inboundSchema: z.ZodEnum<typeof ChatContentTextType>;
+/** @internal */
+export declare const ChatContentTextType$outboundSchema: z.ZodEnum<typeof ChatContentTextType>;
+/** @internal */
+export declare const ChatContentText$inboundSchema: z.ZodType<ChatContentText, unknown>;
+/** @internal */
+export type ChatContentText$Outbound = {
+    cache_control?: ChatContentCacheControl$Outbound | undefined;
+    text: string;
+    type: string;
+};
+/** @internal */
+export declare const ChatContentText$outboundSchema: z.ZodType<ChatContentText$Outbound, ChatContentText>;
+export declare function chatContentTextToJSON(chatContentText: ChatContentText): string;
+export declare function chatContentTextFromJSON(jsonString: string): SafeParseResult<ChatContentText, SDKValidationError>;
+//# sourceMappingURL=chatcontenttext.d.ts.map

package/esm/models/chatcontenttext.js

@@ -0,0 +1,42 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 09b5a48d2bab
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { ChatContentCacheControl$inboundSchema, ChatContentCacheControl$outboundSchema, } from "./chatcontentcachecontrol.js";
+export const ChatContentTextType = {
+    Text: "text",
+};
+/** @internal */
+export const ChatContentTextType$inboundSchema = z.enum(ChatContentTextType);
+/** @internal */
+export const ChatContentTextType$outboundSchema = ChatContentTextType$inboundSchema;
+/** @internal */
+export const ChatContentText$inboundSchema = z.object({
+    cache_control: ChatContentCacheControl$inboundSchema.optional(),
+    text: z.string(),
+    type: ChatContentTextType$inboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        "cache_control": "cacheControl",
+    });
+});
+/** @internal */
+export const ChatContentText$outboundSchema = z.object({
+    cacheControl: ChatContentCacheControl$outboundSchema.optional(),
+    text: z.string(),
+    type: ChatContentTextType$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        cacheControl: "cache_control",
+    });
+});
+export function chatContentTextToJSON(chatContentText) {
+    return JSON.stringify(ChatContentText$outboundSchema.parse(chatContentText));
+}
+export function chatContentTextFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatContentText$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatContentText' from JSON`);
+}
+//# sourceMappingURL=chatcontenttext.js.map

package/esm/models/chatcontentvideo.d.ts

@@ -0,0 +1,26 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { ChatContentVideoInput, ChatContentVideoInput$Outbound } from "./chatcontentvideoinput.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Video input content part
+ */
+export type ChatContentVideo = {
+    type: "video_url";
+    /**
+     * Video input object
+     */
+    videoUrl: ChatContentVideoInput;
+};
+/** @internal */
+export declare const ChatContentVideo$inboundSchema: z.ZodType<ChatContentVideo, unknown>;
+/** @internal */
+export type ChatContentVideo$Outbound = {
+    type: "video_url";
+    video_url: ChatContentVideoInput$Outbound;
+};
+/** @internal */
+export declare const ChatContentVideo$outboundSchema: z.ZodType<ChatContentVideo$Outbound, ChatContentVideo>;
+export declare function chatContentVideoToJSON(chatContentVideo: ChatContentVideo): string;
+export declare function chatContentVideoFromJSON(jsonString: string): SafeParseResult<ChatContentVideo, SDKValidationError>;
+//# sourceMappingURL=chatcontentvideo.d.ts.map

package/esm/models/chatcontentvideo.js

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 353c68bbb3b2
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { ChatContentVideoInput$inboundSchema, ChatContentVideoInput$outboundSchema, } from "./chatcontentvideoinput.js";
+/** @internal */
+export const ChatContentVideo$inboundSchema = z.object({
+    type: z.literal("video_url"),
+    video_url: ChatContentVideoInput$inboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        "video_url": "videoUrl",
+    });
+});
+/** @internal */
+export const ChatContentVideo$outboundSchema = z.object({
+    type: z.literal("video_url"),
+    videoUrl: ChatContentVideoInput$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        videoUrl: "video_url",
+    });
+});
+export function chatContentVideoToJSON(chatContentVideo) {
+    return JSON.stringify(ChatContentVideo$outboundSchema.parse(chatContentVideo));
+}
+export function chatContentVideoFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatContentVideo$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatContentVideo' from JSON`);
+}
+//# sourceMappingURL=chatcontentvideo.js.map

package/esm/models/chatcontentvideoinput.d.ts

@@ -0,0 +1,23 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Video input object
+ */
+export type ChatContentVideoInput = {
+    /**
+     * URL of the video (data: URLs supported)
+     */
+    url: string;
+};
+/** @internal */
+export declare const ChatContentVideoInput$inboundSchema: z.ZodType<ChatContentVideoInput, unknown>;
+/** @internal */
+export type ChatContentVideoInput$Outbound = {
+    url: string;
+};
+/** @internal */
+export declare const ChatContentVideoInput$outboundSchema: z.ZodType<ChatContentVideoInput$Outbound, ChatContentVideoInput>;
+export declare function chatContentVideoInputToJSON(chatContentVideoInput: ChatContentVideoInput): string;
+export declare function chatContentVideoInputFromJSON(jsonString: string): SafeParseResult<ChatContentVideoInput, SDKValidationError>;
+//# sourceMappingURL=chatcontentvideoinput.d.ts.map

package/esm/models/chatcontentvideoinput.js

@@ -0,0 +1,21 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: cca28e9a87db
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const ChatContentVideoInput$inboundSchema = z.object({
+    url: z.string(),
+});
+/** @internal */
+export const ChatContentVideoInput$outboundSchema = z.object({
+    url: z.string(),
+});
+export function chatContentVideoInputToJSON(chatContentVideoInput) {
+    return JSON.stringify(ChatContentVideoInput$outboundSchema.parse(chatContentVideoInput));
+}
+export function chatContentVideoInputFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatContentVideoInput$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatContentVideoInput' from JSON`);
+}
+//# sourceMappingURL=chatcontentvideoinput.js.map

package/esm/models/{debugoptions.d.ts → chatdebugoptions.d.ts}

@@ -2,17 +2,17 @@ import * as z from "zod/v4";
 /**
  * Debug options for inspecting request transformations (streaming only)
  */
-export type DebugOptions = {
+export type ChatDebugOptions = {
     /**
      * If true, includes the transformed upstream request body in a debug chunk at the start of the stream. Only works with streaming mode.
      */
     echoUpstreamBody?: boolean | undefined;
 };
 /** @internal */
-export type DebugOptions$Outbound = {
+export type ChatDebugOptions$Outbound = {
     echo_upstream_body?: boolean | undefined;
 };
 /** @internal */
-export declare const DebugOptions$outboundSchema: z.ZodType<DebugOptions$Outbound, DebugOptions>;
-export declare function debugOptionsToJSON(debugOptions: DebugOptions): string;
-//# sourceMappingURL=debugoptions.d.ts.map
+export declare const ChatDebugOptions$outboundSchema: z.ZodType<ChatDebugOptions$Outbound, ChatDebugOptions>;
+export declare function chatDebugOptionsToJSON(chatDebugOptions: ChatDebugOptions): string;
+//# sourceMappingURL=chatdebugoptions.d.ts.map

package/esm/models/{debugoptions.js → chatdebugoptions.js}

@@ -1,18 +1,18 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- * @generated-id: 12d8bc710ea7
+ * @generated-id: 6c32bdd2ee5d
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 /** @internal */
-export const DebugOptions$outboundSchema = z.object({
+export const ChatDebugOptions$outboundSchema = z.object({
     echoUpstreamBody: z.boolean().optional(),
 }).transform((v) => {
     return remap$(v, {
         echoUpstreamBody: "echo_upstream_body",
     });
 });
-export function debugOptionsToJSON(debugOptions) {
-    return JSON.stringify(DebugOptions$outboundSchema.parse(debugOptions));
+export function chatDebugOptionsToJSON(chatDebugOptions) {
+    return JSON.stringify(ChatDebugOptions$outboundSchema.parse(chatDebugOptions));
 }
-//# sourceMappingURL=debugoptions.js.map
+//# sourceMappingURL=chatdebugoptions.js.map

package/esm/models/chatdevelopermessage.d.ts

@@ -0,0 +1,35 @@
+import * as z from "zod/v4";
+import { ChatContentText, ChatContentText$Outbound } from "./chatcontenttext.js";
+/**
+ * Developer message content
+ */
+export type ChatDeveloperMessageContent = string | Array<ChatContentText>;
+/**
+ * Developer message
+ */
+export type ChatDeveloperMessage = {
+    /**
+     * Developer message content
+     */
+    content: string | Array<ChatContentText>;
+    /**
+     * Optional name for the developer message
+     */
+    name?: string | undefined;
+    role: "developer";
+};
+/** @internal */
+export type ChatDeveloperMessageContent$Outbound = string | Array<ChatContentText$Outbound>;
+/** @internal */
+export declare const ChatDeveloperMessageContent$outboundSchema: z.ZodType<ChatDeveloperMessageContent$Outbound, ChatDeveloperMessageContent>;
+export declare function chatDeveloperMessageContentToJSON(chatDeveloperMessageContent: ChatDeveloperMessageContent): string;
+/** @internal */
+export type ChatDeveloperMessage$Outbound = {
+    content: string | Array<ChatContentText$Outbound>;
+    name?: string | undefined;
+    role: "developer";
+};
+/** @internal */
+export declare const ChatDeveloperMessage$outboundSchema: z.ZodType<ChatDeveloperMessage$Outbound, ChatDeveloperMessage>;
+export declare function chatDeveloperMessageToJSON(chatDeveloperMessage: ChatDeveloperMessage): string;
+//# sourceMappingURL=chatdevelopermessage.d.ts.map

package/esm/models/chatdevelopermessage.js

@@ -0,0 +1,21 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 6a179ea58260
+ */
+import * as z from "zod/v4";
+import { ChatContentText$outboundSchema, } from "./chatcontenttext.js";
+/** @internal */
+export const ChatDeveloperMessageContent$outboundSchema = z.union([z.string(), z.array(ChatContentText$outboundSchema)]);
+export function chatDeveloperMessageContentToJSON(chatDeveloperMessageContent) {
+    return JSON.stringify(ChatDeveloperMessageContent$outboundSchema.parse(chatDeveloperMessageContent));
+}
+/** @internal */
+export const ChatDeveloperMessage$outboundSchema = z.object({
+    content: z.union([z.string(), z.array(ChatContentText$outboundSchema)]),
+    name: z.string().optional(),
+    role: z.literal("developer"),
+});
+export function chatDeveloperMessageToJSON(chatDeveloperMessage) {
+    return JSON.stringify(ChatDeveloperMessage$outboundSchema.parse(chatDeveloperMessage));
+}
+//# sourceMappingURL=chatdevelopermessage.js.map

package/esm/models/chatfinishreasonenum.d.ts

@@ -0,0 +1,13 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+export declare const ChatFinishReasonEnum: {
+    readonly ToolCalls: "tool_calls";
+    readonly Stop: "stop";
+    readonly Length: "length";
+    readonly ContentFilter: "content_filter";
+    readonly Error: "error";
+};
+export type ChatFinishReasonEnum = OpenEnum<typeof ChatFinishReasonEnum>;
+/** @internal */
+export declare const ChatFinishReasonEnum$inboundSchema: z.ZodType<ChatFinishReasonEnum, unknown>;
+//# sourceMappingURL=chatfinishreasonenum.d.ts.map

package/esm/models/{chatcompletionfinishreason.js → chatfinishreasonenum.js}

@@ -1,9 +1,9 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- * @generated-id: 6b06a4d1562d
+ * @generated-id: 699f385aa2f8
  */
 import * as openEnums from "../types/enums.js";
-export const ChatCompletionFinishReason = {
+export const ChatFinishReasonEnum = {
     ToolCalls: "tool_calls",
     Stop: "stop",
     Length: "length",
@@ -11,5 +11,5 @@ export const ChatCompletionFinishReason = {
     Error: "error",
 };
 /** @internal */
-export const ChatCompletionFinishReason$inboundSchema = openEnums.inboundSchema(ChatCompletionFinishReason);
-//# sourceMappingURL=chatcompletionfinishreason.js.map
+export const ChatFinishReasonEnum$inboundSchema = openEnums.inboundSchema(ChatFinishReasonEnum);
+//# sourceMappingURL=chatfinishreasonenum.js.map

package/esm/models/chatformatgrammarconfig.d.ts

@@ -0,0 +1,20 @@
+import * as z from "zod/v4";
+/**
+ * Custom grammar response format
+ */
+export type ChatFormatGrammarConfig = {
+    /**
+     * Custom grammar for text generation
+     */
+    grammar: string;
+    type: "grammar";
+};
+/** @internal */
+export type ChatFormatGrammarConfig$Outbound = {
+    grammar: string;
+    type: "grammar";
+};
+/** @internal */
+export declare const ChatFormatGrammarConfig$outboundSchema: z.ZodType<ChatFormatGrammarConfig$Outbound, ChatFormatGrammarConfig>;
+export declare function chatFormatGrammarConfigToJSON(chatFormatGrammarConfig: ChatFormatGrammarConfig): string;
+//# sourceMappingURL=chatformatgrammarconfig.d.ts.map

package/esm/models/chatformatgrammarconfig.js

@@ -0,0 +1,14 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 95df2fc2c178
+ */
+import * as z from "zod/v4";
+/** @internal */
+export const ChatFormatGrammarConfig$outboundSchema = z.object({
+    grammar: z.string(),
+    type: z.literal("grammar"),
+});
+export function chatFormatGrammarConfigToJSON(chatFormatGrammarConfig) {
+    return JSON.stringify(ChatFormatGrammarConfig$outboundSchema.parse(chatFormatGrammarConfig));
+}
+//# sourceMappingURL=chatformatgrammarconfig.js.map