@openrouter/sdk 0.10.2 → 0.11.2

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 = {
+    role: "developer";
+    /**
+     * Developer message content
+     */
+    content: string | Array<ChatContentText>;
+    /**
+     * Optional name for the developer message
+     */
+    name?: string | undefined;
+};
+/** @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 = {
+    role: "developer";
+    content: string | Array<ChatContentText$Outbound>;
+    name?: string | undefined;
+};
+/** @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({
+    role: z.literal("developer"),
+    content: z.union([z.string(), z.array(ChatContentText$outboundSchema)]),
+    name: z.string().optional(),
+});
+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 = {
+    type: "grammar";
+    /**
+     * Custom grammar for text generation
+     */
+    grammar: string;
+};
+/** @internal */
+export type ChatFormatGrammarConfig$Outbound = {
+    type: "grammar";
+    grammar: string;
+};
+/** @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({
+    type: z.literal("grammar"),
+    grammar: z.string(),
+});
+export function chatFormatGrammarConfigToJSON(chatFormatGrammarConfig) {
+    return JSON.stringify(ChatFormatGrammarConfig$outboundSchema.parse(chatFormatGrammarConfig));
+}
+//# sourceMappingURL=chatformatgrammarconfig.js.map

package/esm/models/chatformatjsonschemaconfig.d.ts

@@ -0,0 +1,21 @@
+import * as z from "zod/v4";
+import { ChatJsonSchemaConfig, ChatJsonSchemaConfig$Outbound } from "./chatjsonschemaconfig.js";
+/**
+ * JSON Schema response format for structured outputs
+ */
+export type ChatFormatJsonSchemaConfig = {
+    type: "json_schema";
+    /**
+     * JSON Schema configuration object
+     */
+    jsonSchema: ChatJsonSchemaConfig;
+};
+/** @internal */
+export type ChatFormatJsonSchemaConfig$Outbound = {
+    type: "json_schema";
+    json_schema: ChatJsonSchemaConfig$Outbound;
+};
+/** @internal */
+export declare const ChatFormatJsonSchemaConfig$outboundSchema: z.ZodType<ChatFormatJsonSchemaConfig$Outbound, ChatFormatJsonSchemaConfig>;
+export declare function chatFormatJsonSchemaConfigToJSON(chatFormatJsonSchemaConfig: ChatFormatJsonSchemaConfig): string;
+//# sourceMappingURL=chatformatjsonschemaconfig.d.ts.map

package/esm/models/chatformatjsonschemaconfig.js

@@ -0,0 +1,20 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 7e02597be9a9
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { ChatJsonSchemaConfig$outboundSchema, } from "./chatjsonschemaconfig.js";
+/** @internal */
+export const ChatFormatJsonSchemaConfig$outboundSchema = z.object({
+    type: z.literal("json_schema"),
+    jsonSchema: ChatJsonSchemaConfig$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        jsonSchema: "json_schema",
+    });
+});
+export function chatFormatJsonSchemaConfigToJSON(chatFormatJsonSchemaConfig) {
+    return JSON.stringify(ChatFormatJsonSchemaConfig$outboundSchema.parse(chatFormatJsonSchemaConfig));
+}
+//# sourceMappingURL=chatformatjsonschemaconfig.js.map

package/esm/models/chatformatpythonconfig.d.ts

@@ -0,0 +1,15 @@
+import * as z from "zod/v4";
+/**
+ * Python code response format
+ */
+export type ChatFormatPythonConfig = {
+    type: "python";
+};
+/** @internal */
+export type ChatFormatPythonConfig$Outbound = {
+    type: "python";
+};
+/** @internal */
+export declare const ChatFormatPythonConfig$outboundSchema: z.ZodType<ChatFormatPythonConfig$Outbound, ChatFormatPythonConfig>;
+export declare function chatFormatPythonConfigToJSON(chatFormatPythonConfig: ChatFormatPythonConfig): string;
+//# sourceMappingURL=chatformatpythonconfig.d.ts.map

package/esm/models/chatformatpythonconfig.js

@@ -0,0 +1,13 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 7ba831befa19
+ */
+import * as z from "zod/v4";
+/** @internal */
+export const ChatFormatPythonConfig$outboundSchema = z.object({
+    type: z.literal("python"),
+});
+export function chatFormatPythonConfigToJSON(chatFormatPythonConfig) {
+    return JSON.stringify(ChatFormatPythonConfig$outboundSchema.parse(chatFormatPythonConfig));
+}
+//# sourceMappingURL=chatformatpythonconfig.js.map

package/esm/models/chatformattextconfig.d.ts

@@ -0,0 +1,15 @@
+import * as z from "zod/v4";
+/**
+ * Default text response format
+ */
+export type ChatFormatTextConfig = {
+    type: "text";
+};
+/** @internal */
+export type ChatFormatTextConfig$Outbound = {
+    type: "text";
+};
+/** @internal */
+export declare const ChatFormatTextConfig$outboundSchema: z.ZodType<ChatFormatTextConfig$Outbound, ChatFormatTextConfig>;
+export declare function chatFormatTextConfigToJSON(chatFormatTextConfig: ChatFormatTextConfig): string;
+//# sourceMappingURL=chatformattextconfig.d.ts.map

package/esm/models/chatformattextconfig.js

@@ -0,0 +1,13 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: cb7d0915102e
+ */
+import * as z from "zod/v4";
+/** @internal */
+export const ChatFormatTextConfig$outboundSchema = z.object({
+    type: z.literal("text"),
+});
+export function chatFormatTextConfigToJSON(chatFormatTextConfig) {
+    return JSON.stringify(ChatFormatTextConfig$outboundSchema.parse(chatFormatTextConfig));
+}
+//# sourceMappingURL=chatformattextconfig.js.map

package/esm/models/chatfunctiontool.d.ts

@@ -0,0 +1,77 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { ChatContentCacheControl, ChatContentCacheControl$Outbound } from "./chatcontentcachecontrol.js";
+import { ChatWebSearchServerTool, ChatWebSearchServerTool$Outbound } from "./chatwebsearchservertool.js";
+import { ChatWebSearchShorthand, ChatWebSearchShorthand$Outbound } from "./chatwebsearchshorthand.js";
+import { DatetimeServerTool, DatetimeServerTool$Outbound } from "./datetimeservertool.js";
+export declare const ChatFunctionToolType: {
+    readonly Function: "function";
+};
+export type ChatFunctionToolType = ClosedEnum<typeof ChatFunctionToolType>;
+/**
+ * Function definition for tool calling
+ */
+export type ChatFunctionToolFunctionFunction = {
+    /**
+     * Function name (a-z, A-Z, 0-9, underscores, dashes, max 64 chars)
+     */
+    name: string;
+    /**
+     * Function description for the model
+     */
+    description?: string | undefined;
+    /**
+     * Function parameters as JSON Schema object
+     */
+    parameters?: {
+        [k: string]: any | null;
+    } | undefined;
+    /**
+     * Enable strict schema adherence
+     */
+    strict?: boolean | null | undefined;
+};
+export type ChatFunctionToolFunction = {
+    type: ChatFunctionToolType;
+    /**
+     * Function definition for tool calling
+     */
+    function: ChatFunctionToolFunctionFunction;
+    /**
+     * Cache control for the content part
+     */
+    cacheControl?: ChatContentCacheControl | undefined;
+};
+/**
+ * Tool definition for function calling (regular function or OpenRouter built-in server tool)
+ */
+export type ChatFunctionTool = ChatFunctionToolFunction | DatetimeServerTool | ChatWebSearchServerTool | ChatWebSearchShorthand;
+/** @internal */
+export declare const ChatFunctionToolType$outboundSchema: z.ZodEnum<typeof ChatFunctionToolType>;
+/** @internal */
+export type ChatFunctionToolFunctionFunction$Outbound = {
+    name: string;
+    description?: string | undefined;
+    parameters?: {
+        [k: string]: any | null;
+    } | undefined;
+    strict?: boolean | null | undefined;
+};
+/** @internal */
+export declare const ChatFunctionToolFunctionFunction$outboundSchema: z.ZodType<ChatFunctionToolFunctionFunction$Outbound, ChatFunctionToolFunctionFunction>;
+export declare function chatFunctionToolFunctionFunctionToJSON(chatFunctionToolFunctionFunction: ChatFunctionToolFunctionFunction): string;
+/** @internal */
+export type ChatFunctionToolFunction$Outbound = {
+    type: string;
+    function: ChatFunctionToolFunctionFunction$Outbound;
+    cache_control?: ChatContentCacheControl$Outbound | undefined;
+};
+/** @internal */
+export declare const ChatFunctionToolFunction$outboundSchema: z.ZodType<ChatFunctionToolFunction$Outbound, ChatFunctionToolFunction>;
+export declare function chatFunctionToolFunctionToJSON(chatFunctionToolFunction: ChatFunctionToolFunction): string;
+/** @internal */
+export type ChatFunctionTool$Outbound = ChatFunctionToolFunction$Outbound | DatetimeServerTool$Outbound | ChatWebSearchServerTool$Outbound | ChatWebSearchShorthand$Outbound;
+/** @internal */
+export declare const ChatFunctionTool$outboundSchema: z.ZodType<ChatFunctionTool$Outbound, ChatFunctionTool>;
+export declare function chatFunctionToolToJSON(chatFunctionTool: ChatFunctionTool): string;
+//# sourceMappingURL=chatfunctiontool.d.ts.map

package/esm/models/chatfunctiontool.js

@@ -0,0 +1,49 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 400104319b29
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { ChatContentCacheControl$outboundSchema, } from "./chatcontentcachecontrol.js";
+import { ChatWebSearchServerTool$outboundSchema, } from "./chatwebsearchservertool.js";
+import { ChatWebSearchShorthand$outboundSchema, } from "./chatwebsearchshorthand.js";
+import { DatetimeServerTool$outboundSchema, } from "./datetimeservertool.js";
+export const ChatFunctionToolType = {
+    Function: "function",
+};
+/** @internal */
+export const ChatFunctionToolType$outboundSchema = z.enum(ChatFunctionToolType);
+/** @internal */
+export const ChatFunctionToolFunctionFunction$outboundSchema = z.object({
+    name: z.string(),
+    description: z.string().optional(),
+    parameters: z.record(z.string(), z.nullable(z.any())).optional(),
+    strict: z.nullable(z.boolean()).optional(),
+});
+export function chatFunctionToolFunctionFunctionToJSON(chatFunctionToolFunctionFunction) {
+    return JSON.stringify(ChatFunctionToolFunctionFunction$outboundSchema.parse(chatFunctionToolFunctionFunction));
+}
+/** @internal */
+export const ChatFunctionToolFunction$outboundSchema = z.object({
+    type: ChatFunctionToolType$outboundSchema,
+    function: z.lazy(() => ChatFunctionToolFunctionFunction$outboundSchema),
+    cacheControl: ChatContentCacheControl$outboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        cacheControl: "cache_control",
+    });
+});
+export function chatFunctionToolFunctionToJSON(chatFunctionToolFunction) {
+    return JSON.stringify(ChatFunctionToolFunction$outboundSchema.parse(chatFunctionToolFunction));
+}
+/** @internal */
+export const ChatFunctionTool$outboundSchema = z.union([
+    z.lazy(() => ChatFunctionToolFunction$outboundSchema),
+    DatetimeServerTool$outboundSchema,
+    ChatWebSearchServerTool$outboundSchema,
+    ChatWebSearchShorthand$outboundSchema,
+]);
+export function chatFunctionToolToJSON(chatFunctionTool) {
+    return JSON.stringify(ChatFunctionTool$outboundSchema.parse(chatFunctionTool));
+}
+//# sourceMappingURL=chatfunctiontool.js.map

package/esm/models/{jsonschemaconfig.d.ts → chatjsonschemaconfig.d.ts}

@@ -2,7 +2,7 @@ import * as z from "zod/v4";
 /**
  * JSON Schema configuration object
  */
-export type JSONSchemaConfig = {
+export type ChatJsonSchemaConfig = {
     /**
      * Schema name (a-z, A-Z, 0-9, underscores, dashes, max 64 chars)
      */
@@ -23,7 +23,7 @@ export type JSONSchemaConfig = {
     strict?: boolean | null | undefined;
 };
 /** @internal */
-export type JSONSchemaConfig$Outbound = {
+export type ChatJsonSchemaConfig$Outbound = {
     name: string;
     description?: string | undefined;
     schema?: {
@@ -32,6 +32,6 @@ export type JSONSchemaConfig$Outbound = {
     strict?: boolean | null | undefined;
 };
 /** @internal */
-export declare const JSONSchemaConfig$outboundSchema: z.ZodType<JSONSchemaConfig$Outbound, JSONSchemaConfig>;
-export declare function jsonSchemaConfigToJSON(jsonSchemaConfig: JSONSchemaConfig): string;
-//# sourceMappingURL=jsonschemaconfig.d.ts.map
+export declare const ChatJsonSchemaConfig$outboundSchema: z.ZodType<ChatJsonSchemaConfig$Outbound, ChatJsonSchemaConfig>;
+export declare function chatJsonSchemaConfigToJSON(chatJsonSchemaConfig: ChatJsonSchemaConfig): string;
+//# sourceMappingURL=chatjsonschemaconfig.d.ts.map

package/esm/models/{jsonschemaconfig.js → chatjsonschemaconfig.js}

@@ -1,16 +1,16 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- * @generated-id: a5dbdd0305ec
+ * @generated-id: 1ad0e5d930fb
  */
 import * as z from "zod/v4";
 /** @internal */
-export const JSONSchemaConfig$outboundSchema = z.object({
+export const ChatJsonSchemaConfig$outboundSchema = z.object({
     name: z.string(),
     description: z.string().optional(),
     schema: z.record(z.string(), z.nullable(z.any())).optional(),
     strict: z.nullable(z.boolean()).optional(),
 });
-export function jsonSchemaConfigToJSON(jsonSchemaConfig) {
-    return JSON.stringify(JSONSchemaConfig$outboundSchema.parse(jsonSchemaConfig));
+export function chatJsonSchemaConfigToJSON(chatJsonSchemaConfig) {
+    return JSON.stringify(ChatJsonSchemaConfig$outboundSchema.parse(chatJsonSchemaConfig));
 }
-//# sourceMappingURL=jsonschemaconfig.js.map
+//# sourceMappingURL=chatjsonschemaconfig.js.map

package/esm/models/chatmessages.d.ts

@@ -0,0 +1,20 @@
+import * as z from "zod/v4";
+import { ChatAssistantMessage, ChatAssistantMessage$Outbound } from "./chatassistantmessage.js";
+import { ChatDeveloperMessage, ChatDeveloperMessage$Outbound } from "./chatdevelopermessage.js";
+import { ChatSystemMessage, ChatSystemMessage$Outbound } from "./chatsystemmessage.js";
+import { ChatToolMessage, ChatToolMessage$Outbound } from "./chattoolmessage.js";
+import { ChatUserMessage, ChatUserMessage$Outbound } from "./chatusermessage.js";
+/**
+ * Chat completion message with role-based discrimination
+ */
+export type ChatMessages = ChatSystemMessage | ChatUserMessage | ChatDeveloperMessage | (ChatAssistantMessage & {
+    role: "assistant";
+}) | ChatToolMessage;
+/** @internal */
+export type ChatMessages$Outbound = ChatSystemMessage$Outbound | ChatUserMessage$Outbound | ChatDeveloperMessage$Outbound | (ChatAssistantMessage$Outbound & {
+    role: "assistant";
+}) | ChatToolMessage$Outbound;
+/** @internal */
+export declare const ChatMessages$outboundSchema: z.ZodType<ChatMessages$Outbound, ChatMessages>;
+export declare function chatMessagesToJSON(chatMessages: ChatMessages): string;
+//# sourceMappingURL=chatmessages.d.ts.map

package/esm/models/chatmessages.js

@@ -0,0 +1,22 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: f21e02796127
+ */
+import * as z from "zod/v4";
+import { ChatAssistantMessage$outboundSchema, } from "./chatassistantmessage.js";
+import { ChatDeveloperMessage$outboundSchema, } from "./chatdevelopermessage.js";
+import { ChatSystemMessage$outboundSchema, } from "./chatsystemmessage.js";
+import { ChatToolMessage$outboundSchema, } from "./chattoolmessage.js";
+import { ChatUserMessage$outboundSchema, } from "./chatusermessage.js";
+/** @internal */
+export const ChatMessages$outboundSchema = z.union([
+    ChatSystemMessage$outboundSchema,
+    ChatUserMessage$outboundSchema,
+    ChatDeveloperMessage$outboundSchema,
+    ChatAssistantMessage$outboundSchema.and(z.object({ role: z.literal("assistant") })),
+    ChatToolMessage$outboundSchema,
+]);
+export function chatMessagesToJSON(chatMessages) {
+    return JSON.stringify(ChatMessages$outboundSchema.parse(chatMessages));
+}
+//# sourceMappingURL=chatmessages.js.map

package/esm/models/chatnamedtoolchoice.d.ts

@@ -0,0 +1,37 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+export declare const ChatNamedToolChoiceType: {
+    readonly Function: "function";
+};
+export type ChatNamedToolChoiceType = ClosedEnum<typeof ChatNamedToolChoiceType>;
+export type ChatNamedToolChoiceFunction = {
+    /**
+     * Function name to call
+     */
+    name: string;
+};
+/**
+ * Named tool choice for specific function
+ */
+export type ChatNamedToolChoice = {
+    type: ChatNamedToolChoiceType;
+    function: ChatNamedToolChoiceFunction;
+};
+/** @internal */
+export declare const ChatNamedToolChoiceType$outboundSchema: z.ZodEnum<typeof ChatNamedToolChoiceType>;
+/** @internal */
+export type ChatNamedToolChoiceFunction$Outbound = {
+    name: string;
+};
+/** @internal */
+export declare const ChatNamedToolChoiceFunction$outboundSchema: z.ZodType<ChatNamedToolChoiceFunction$Outbound, ChatNamedToolChoiceFunction>;
+export declare function chatNamedToolChoiceFunctionToJSON(chatNamedToolChoiceFunction: ChatNamedToolChoiceFunction): string;
+/** @internal */
+export type ChatNamedToolChoice$Outbound = {
+    type: string;
+    function: ChatNamedToolChoiceFunction$Outbound;
+};
+/** @internal */
+export declare const ChatNamedToolChoice$outboundSchema: z.ZodType<ChatNamedToolChoice$Outbound, ChatNamedToolChoice>;
+export declare function chatNamedToolChoiceToJSON(chatNamedToolChoice: ChatNamedToolChoice): string;
+//# sourceMappingURL=chatnamedtoolchoice.d.ts.map

package/esm/models/chatnamedtoolchoice.js

@@ -0,0 +1,26 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: bc876a8e64eb
+ */
+import * as z from "zod/v4";
+export const ChatNamedToolChoiceType = {
+    Function: "function",
+};
+/** @internal */
+export const ChatNamedToolChoiceType$outboundSchema = z.enum(ChatNamedToolChoiceType);
+/** @internal */
+export const ChatNamedToolChoiceFunction$outboundSchema = z.object({
+    name: z.string(),
+});
+export function chatNamedToolChoiceFunctionToJSON(chatNamedToolChoiceFunction) {
+    return JSON.stringify(ChatNamedToolChoiceFunction$outboundSchema.parse(chatNamedToolChoiceFunction));
+}
+/** @internal */
+export const ChatNamedToolChoice$outboundSchema = z.object({
+    type: ChatNamedToolChoiceType$outboundSchema,
+    function: z.lazy(() => ChatNamedToolChoiceFunction$outboundSchema),
+});
+export function chatNamedToolChoiceToJSON(chatNamedToolChoice) {
+    return JSON.stringify(ChatNamedToolChoice$outboundSchema.parse(chatNamedToolChoice));
+}
+//# sourceMappingURL=chatnamedtoolchoice.js.map