@openrouter/sdk 0.10.2 → 0.12.0

package/esm/models/{chatstreamingresponsechunk.d.ts → chatstreamchunk.d.ts}

@@ -1,66 +1,70 @@
 import * as z from "zod/v4";
 import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
-import { ChatGenerationTokenUsage } from "./chatgenerationtokenusage.js";
-import { ChatStreamingChoice } from "./chatstreamingchoice.js";
+import { ChatStreamChoice } from "./chatstreamchoice.js";
+import { ChatUsage } from "./chatusage.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export declare const ChatStreamingResponseChunkObject: {
-    readonly ChatCompletionChunk: "chat.completion.chunk";
-};
-export type ChatStreamingResponseChunkObject = ClosedEnum<typeof ChatStreamingResponseChunkObject>;
 /**
  * Error information
  */
 export type ErrorT = {
-    /**
-     * Error message
-     */
-    message: string;
     /**
      * Error code
      */
     code: number;
+    /**
+     * Error message
+     */
+    message: string;
+};
+export declare const ChatStreamChunkObject: {
+    readonly ChatCompletionChunk: "chat.completion.chunk";
 };
+export type ChatStreamChunkObject = ClosedEnum<typeof ChatStreamChunkObject>;
 /**
  * Streaming chat completion chunk
  */
-export type ChatStreamingResponseChunk = {
-    /**
-     * Unique chunk identifier
-     */
-    id: string;
+export type ChatStreamChunk = {
     /**
      * List of streaming chunk choices
      */
-    choices: Array<ChatStreamingChoice>;
+    choices: Array<ChatStreamChoice>;
     /**
      * Unix timestamp of creation
      */
     created: number;
+    /**
+     * Error information
+     */
+    error?: ErrorT | undefined;
+    /**
+     * Unique chunk identifier
+     */
+    id: string;
     /**
      * Model used for completion
      */
     model: string;
-    object: ChatStreamingResponseChunkObject;
+    object: ChatStreamChunkObject;
     /**
-     * System fingerprint
+     * The service tier used by the upstream provider for this request
      */
-    systemFingerprint?: string | undefined;
+    serviceTier?: string | null | undefined;
     /**
-     * Error information
+     * System fingerprint
      */
-    error?: ErrorT | undefined;
+    systemFingerprint?: string | undefined;
     /**
      * Token usage statistics
      */
-    usage?: ChatGenerationTokenUsage | undefined;
+    usage?: ChatUsage | undefined;
 };
 /** @internal */
-export declare const ChatStreamingResponseChunkObject$inboundSchema: z.ZodEnum<typeof ChatStreamingResponseChunkObject>;
-/** @internal */
 export declare const ErrorT$inboundSchema: z.ZodType<ErrorT, unknown>;
 export declare function errorFromJSON(jsonString: string): SafeParseResult<ErrorT, SDKValidationError>;
 /** @internal */
-export declare const ChatStreamingResponseChunk$inboundSchema: z.ZodType<ChatStreamingResponseChunk, unknown>;
-export declare function chatStreamingResponseChunkFromJSON(jsonString: string): SafeParseResult<ChatStreamingResponseChunk, SDKValidationError>;
-//# sourceMappingURL=chatstreamingresponsechunk.d.ts.map
+export declare const ChatStreamChunkObject$inboundSchema: z.ZodEnum<typeof ChatStreamChunkObject>;
+/** @internal */
+export declare const ChatStreamChunk$inboundSchema: z.ZodType<ChatStreamChunk, unknown>;
+export declare function chatStreamChunkFromJSON(jsonString: string): SafeParseResult<ChatStreamChunk, SDKValidationError>;
+//# sourceMappingURL=chatstreamchunk.d.ts.map

package/esm/models/chatstreamchunk.js

@@ -0,0 +1,43 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 361f940e91e4
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { ChatStreamChoice$inboundSchema, } from "./chatstreamchoice.js";
+import { ChatUsage$inboundSchema } from "./chatusage.js";
+export const ChatStreamChunkObject = {
+    ChatCompletionChunk: "chat.completion.chunk",
+};
+/** @internal */
+export const ErrorT$inboundSchema = z.object({
+    code: z.int(),
+    message: z.string(),
+});
+export function errorFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ErrorT$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ErrorT' from JSON`);
+}
+/** @internal */
+export const ChatStreamChunkObject$inboundSchema = z.enum(ChatStreamChunkObject);
+/** @internal */
+export const ChatStreamChunk$inboundSchema = z.object({
+    choices: z.array(ChatStreamChoice$inboundSchema),
+    created: z.int(),
+    error: z.lazy(() => ErrorT$inboundSchema).optional(),
+    id: z.string(),
+    model: z.string(),
+    object: ChatStreamChunkObject$inboundSchema,
+    service_tier: z.nullable(z.string()).optional(),
+    system_fingerprint: z.string().optional(),
+    usage: ChatUsage$inboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "service_tier": "serviceTier",
+        "system_fingerprint": "systemFingerprint",
+    });
+});
+export function chatStreamChunkFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatStreamChunk$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatStreamChunk' from JSON`);
+}
+//# sourceMappingURL=chatstreamchunk.js.map

package/esm/models/{chatstreamingmessagechunk.d.ts → chatstreamdelta.d.ts}

@@ -1,28 +1,25 @@
 import * as z from "zod/v4";
 import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
-import { ChatCompletionAudioOutput } from "./chatcompletionaudiooutput.js";
-import { ChatStreamingMessageToolCall } from "./chatstreamingmessagetoolcall.js";
+import { ChatAudioOutput } from "./chataudiooutput.js";
+import { ChatStreamToolCall } from "./chatstreamtoolcall.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import { ReasoningDetailUnion } from "./reasoningdetailunion.js";
 /**
  * The role of the message author
  */
-export declare const ChatStreamingMessageChunkRole: {
+export declare const ChatStreamDeltaRole: {
     readonly Assistant: "assistant";
 };
 /**
  * The role of the message author
  */
-export type ChatStreamingMessageChunkRole = ClosedEnum<typeof ChatStreamingMessageChunkRole>;
+export type ChatStreamDeltaRole = ClosedEnum<typeof ChatStreamDeltaRole>;
 /**
  * Delta changes in streaming response
  */
-export type ChatStreamingMessageChunk = {
-    /**
-     * The role of the message author
-     */
-    role?: ChatStreamingMessageChunkRole | undefined;
+export type ChatStreamDelta = {
+    audio?: ChatAudioOutput | undefined;
     /**
      * Message content delta
      */
@@ -31,23 +28,26 @@ export type ChatStreamingMessageChunk = {
      * Reasoning content delta
      */
     reasoning?: string | null | undefined;
+    /**
+     * Reasoning details for extended thinking models
+     */
+    reasoningDetails?: Array<ReasoningDetailUnion> | undefined;
     /**
      * Refusal message delta
      */
     refusal?: string | null | undefined;
     /**
-     * Tool calls delta
+     * The role of the message author
      */
-    toolCalls?: Array<ChatStreamingMessageToolCall> | undefined;
+    role?: ChatStreamDeltaRole | undefined;
     /**
-     * Reasoning details for extended thinking models
+     * Tool calls delta
      */
-    reasoningDetails?: Array<ReasoningDetailUnion> | undefined;
-    audio?: ChatCompletionAudioOutput | undefined;
+    toolCalls?: Array<ChatStreamToolCall> | undefined;
 };
 /** @internal */
-export declare const ChatStreamingMessageChunkRole$inboundSchema: z.ZodEnum<typeof ChatStreamingMessageChunkRole>;
+export declare const ChatStreamDeltaRole$inboundSchema: z.ZodEnum<typeof ChatStreamDeltaRole>;
 /** @internal */
-export declare const ChatStreamingMessageChunk$inboundSchema: z.ZodType<ChatStreamingMessageChunk, unknown>;
-export declare function chatStreamingMessageChunkFromJSON(jsonString: string): SafeParseResult<ChatStreamingMessageChunk, SDKValidationError>;
-//# sourceMappingURL=chatstreamingmessagechunk.d.ts.map
+export declare const ChatStreamDelta$inboundSchema: z.ZodType<ChatStreamDelta, unknown>;
+export declare function chatStreamDeltaFromJSON(jsonString: string): SafeParseResult<ChatStreamDelta, SDKValidationError>;
+//# sourceMappingURL=chatstreamdelta.d.ts.map

package/esm/models/chatstreamdelta.js

@@ -0,0 +1,37 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 74a4be948d5f
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { ChatAudioOutput$inboundSchema, } from "./chataudiooutput.js";
+import { ChatStreamToolCall$inboundSchema, } from "./chatstreamtoolcall.js";
+import { ReasoningDetailUnion$inboundSchema, } from "./reasoningdetailunion.js";
+/**
+ * The role of the message author
+ */
+export const ChatStreamDeltaRole = {
+    Assistant: "assistant",
+};
+/** @internal */
+export const ChatStreamDeltaRole$inboundSchema = z.enum(ChatStreamDeltaRole);
+/** @internal */
+export const ChatStreamDelta$inboundSchema = z.object({
+    audio: ChatAudioOutput$inboundSchema.optional(),
+    content: z.nullable(z.string()).optional(),
+    reasoning: z.nullable(z.string()).optional(),
+    reasoning_details: z.array(ReasoningDetailUnion$inboundSchema).optional(),
+    refusal: z.nullable(z.string()).optional(),
+    role: ChatStreamDeltaRole$inboundSchema.optional(),
+    tool_calls: z.array(ChatStreamToolCall$inboundSchema).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "reasoning_details": "reasoningDetails",
+        "tool_calls": "toolCalls",
+    });
+});
+export function chatStreamDeltaFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatStreamDelta$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatStreamDelta' from JSON`);
+}
+//# sourceMappingURL=chatstreamdelta.js.map

package/esm/models/chatstreamtoolcall.d.ts

@@ -0,0 +1,57 @@
+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";
+/**
+ * Function call details
+ */
+export type ChatStreamToolCallFunction = {
+    /**
+     * Function arguments as JSON string
+     */
+    arguments?: string | undefined;
+    /**
+     * Function name
+     */
+    name?: string | undefined;
+};
+/**
+ * Tool call type
+ */
+export declare const ChatStreamToolCallType: {
+    readonly Function: "function";
+};
+/**
+ * Tool call type
+ */
+export type ChatStreamToolCallType = ClosedEnum<typeof ChatStreamToolCallType>;
+/**
+ * Tool call delta for streaming responses
+ */
+export type ChatStreamToolCall = {
+    /**
+     * Function call details
+     */
+    function?: ChatStreamToolCallFunction | undefined;
+    /**
+     * Tool call identifier
+     */
+    id?: string | undefined;
+    /**
+     * Tool call index in the array
+     */
+    index: number;
+    /**
+     * Tool call type
+     */
+    type?: ChatStreamToolCallType | undefined;
+};
+/** @internal */
+export declare const ChatStreamToolCallFunction$inboundSchema: z.ZodType<ChatStreamToolCallFunction, unknown>;
+export declare function chatStreamToolCallFunctionFromJSON(jsonString: string): SafeParseResult<ChatStreamToolCallFunction, SDKValidationError>;
+/** @internal */
+export declare const ChatStreamToolCallType$inboundSchema: z.ZodEnum<typeof ChatStreamToolCallType>;
+/** @internal */
+export declare const ChatStreamToolCall$inboundSchema: z.ZodType<ChatStreamToolCall, unknown>;
+export declare function chatStreamToolCallFromJSON(jsonString: string): SafeParseResult<ChatStreamToolCall, SDKValidationError>;
+//# sourceMappingURL=chatstreamtoolcall.d.ts.map

package/esm/models/chatstreamtoolcall.js

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: bad96c4eeaf7
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+/**
+ * Tool call type
+ */
+export const ChatStreamToolCallType = {
+    Function: "function",
+};
+/** @internal */
+export const ChatStreamToolCallFunction$inboundSchema = z.object({
+    arguments: z.string().optional(),
+    name: z.string().optional(),
+});
+export function chatStreamToolCallFunctionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatStreamToolCallFunction$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatStreamToolCallFunction' from JSON`);
+}
+/** @internal */
+export const ChatStreamToolCallType$inboundSchema = z.enum(ChatStreamToolCallType);
+/** @internal */
+export const ChatStreamToolCall$inboundSchema = z.object({
+    function: z.lazy(() => ChatStreamToolCallFunction$inboundSchema).optional(),
+    id: z.string().optional(),
+    index: z.int(),
+    type: ChatStreamToolCallType$inboundSchema.optional(),
+});
+export function chatStreamToolCallFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatStreamToolCall$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatStreamToolCall' from JSON`);
+}
+//# sourceMappingURL=chatstreamtoolcall.js.map

package/esm/models/chatsystemmessage.d.ts

@@ -0,0 +1,35 @@
+import * as z from "zod/v4";
+import { ChatContentText, ChatContentText$Outbound } from "./chatcontenttext.js";
+/**
+ * System message content
+ */
+export type ChatSystemMessageContent = string | Array<ChatContentText>;
+/**
+ * System message for setting behavior
+ */
+export type ChatSystemMessage = {
+    /**
+     * System message content
+     */
+    content: string | Array<ChatContentText>;
+    /**
+     * Optional name for the system message
+     */
+    name?: string | undefined;
+    role: "system";
+};
+/** @internal */
+export type ChatSystemMessageContent$Outbound = string | Array<ChatContentText$Outbound>;
+/** @internal */
+export declare const ChatSystemMessageContent$outboundSchema: z.ZodType<ChatSystemMessageContent$Outbound, ChatSystemMessageContent>;
+export declare function chatSystemMessageContentToJSON(chatSystemMessageContent: ChatSystemMessageContent): string;
+/** @internal */
+export type ChatSystemMessage$Outbound = {
+    content: string | Array<ChatContentText$Outbound>;
+    name?: string | undefined;
+    role: "system";
+};
+/** @internal */
+export declare const ChatSystemMessage$outboundSchema: z.ZodType<ChatSystemMessage$Outbound, ChatSystemMessage>;
+export declare function chatSystemMessageToJSON(chatSystemMessage: ChatSystemMessage): string;
+//# sourceMappingURL=chatsystemmessage.d.ts.map

package/esm/models/chatsystemmessage.js

@@ -0,0 +1,21 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: e404d41c140a
+ */
+import * as z from "zod/v4";
+import { ChatContentText$outboundSchema, } from "./chatcontenttext.js";
+/** @internal */
+export const ChatSystemMessageContent$outboundSchema = z.union([z.string(), z.array(ChatContentText$outboundSchema)]);
+export function chatSystemMessageContentToJSON(chatSystemMessageContent) {
+    return JSON.stringify(ChatSystemMessageContent$outboundSchema.parse(chatSystemMessageContent));
+}
+/** @internal */
+export const ChatSystemMessage$outboundSchema = z.object({
+    content: z.union([z.string(), z.array(ChatContentText$outboundSchema)]),
+    name: z.string().optional(),
+    role: z.literal("system"),
+});
+export function chatSystemMessageToJSON(chatSystemMessage) {
+    return JSON.stringify(ChatSystemMessage$outboundSchema.parse(chatSystemMessage));
+}
+//# sourceMappingURL=chatsystemmessage.js.map

package/esm/models/chattokenlogprob.d.ts

@@ -0,0 +1,36 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type ChatTokenLogprobTopLogprob = {
+    bytes: Array<number> | null;
+    logprob: number;
+    token: string;
+};
+/**
+ * Token log probability information
+ */
+export type ChatTokenLogprob = {
+    /**
+     * UTF-8 bytes of the token
+     */
+    bytes: Array<number> | null;
+    /**
+     * Log probability of the token
+     */
+    logprob: number;
+    /**
+     * The token
+     */
+    token: string;
+    /**
+     * Top alternative tokens with probabilities
+     */
+    topLogprobs: Array<ChatTokenLogprobTopLogprob>;
+};
+/** @internal */
+export declare const ChatTokenLogprobTopLogprob$inboundSchema: z.ZodType<ChatTokenLogprobTopLogprob, unknown>;
+export declare function chatTokenLogprobTopLogprobFromJSON(jsonString: string): SafeParseResult<ChatTokenLogprobTopLogprob, SDKValidationError>;
+/** @internal */
+export declare const ChatTokenLogprob$inboundSchema: z.ZodType<ChatTokenLogprob, unknown>;
+export declare function chatTokenLogprobFromJSON(jsonString: string): SafeParseResult<ChatTokenLogprob, SDKValidationError>;
+//# sourceMappingURL=chattokenlogprob.d.ts.map

package/esm/models/chattokenlogprob.js

@@ -0,0 +1,31 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 267d5cc43c1b
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const ChatTokenLogprobTopLogprob$inboundSchema = z.object({
+    bytes: z.nullable(z.array(z.int())),
+    logprob: z.number(),
+    token: z.string(),
+});
+export function chatTokenLogprobTopLogprobFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatTokenLogprobTopLogprob$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatTokenLogprobTopLogprob' from JSON`);
+}
+/** @internal */
+export const ChatTokenLogprob$inboundSchema = z.object({
+    bytes: z.nullable(z.array(z.int())),
+    logprob: z.number(),
+    token: z.string(),
+    top_logprobs: z.array(z.lazy(() => ChatTokenLogprobTopLogprob$inboundSchema)),
+}).transform((v) => {
+    return remap$(v, {
+        "top_logprobs": "topLogprobs",
+    });
+});
+export function chatTokenLogprobFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatTokenLogprob$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatTokenLogprob' from JSON`);
+}
+//# sourceMappingURL=chattokenlogprob.js.map

package/esm/models/chattokenlogprobs.d.ts

@@ -0,0 +1,21 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { ChatTokenLogprob } from "./chattokenlogprob.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Log probabilities for the completion
+ */
+export type ChatTokenLogprobs = {
+    /**
+     * Log probabilities for content tokens
+     */
+    content: Array<ChatTokenLogprob> | null;
+    /**
+     * Log probabilities for refusal tokens
+     */
+    refusal?: Array<ChatTokenLogprob> | null | undefined;
+};
+/** @internal */
+export declare const ChatTokenLogprobs$inboundSchema: z.ZodType<ChatTokenLogprobs, unknown>;
+export declare function chatTokenLogprobsFromJSON(jsonString: string): SafeParseResult<ChatTokenLogprobs, SDKValidationError>;
+//# sourceMappingURL=chattokenlogprobs.d.ts.map

package/esm/models/chattokenlogprobs.js

@@ -0,0 +1,16 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 9dc7afbf530d
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { ChatTokenLogprob$inboundSchema, } from "./chattokenlogprob.js";
+/** @internal */
+export const ChatTokenLogprobs$inboundSchema = z.object({
+    content: z.nullable(z.array(ChatTokenLogprob$inboundSchema)),
+    refusal: z.nullable(z.array(ChatTokenLogprob$inboundSchema)).optional(),
+});
+export function chatTokenLogprobsFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatTokenLogprobs$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatTokenLogprobs' from JSON`);
+}
+//# sourceMappingURL=chattokenlogprobs.js.map

package/esm/models/chattoolcall.d.ts

@@ -0,0 +1,57 @@
+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 type ChatToolCallFunction = {
+    /**
+     * Function arguments as JSON string
+     */
+    arguments: string;
+    /**
+     * Function name to call
+     */
+    name: string;
+};
+export declare const ChatToolCallType: {
+    readonly Function: "function";
+};
+export type ChatToolCallType = ClosedEnum<typeof ChatToolCallType>;
+/**
+ * Tool call made by the assistant
+ */
+export type ChatToolCall = {
+    function: ChatToolCallFunction;
+    /**
+     * Tool call identifier
+     */
+    id: string;
+    type: ChatToolCallType;
+};
+/** @internal */
+export declare const ChatToolCallFunction$inboundSchema: z.ZodType<ChatToolCallFunction, unknown>;
+/** @internal */
+export type ChatToolCallFunction$Outbound = {
+    arguments: string;
+    name: string;
+};
+/** @internal */
+export declare const ChatToolCallFunction$outboundSchema: z.ZodType<ChatToolCallFunction$Outbound, ChatToolCallFunction>;
+export declare function chatToolCallFunctionToJSON(chatToolCallFunction: ChatToolCallFunction): string;
+export declare function chatToolCallFunctionFromJSON(jsonString: string): SafeParseResult<ChatToolCallFunction, SDKValidationError>;
+/** @internal */
+export declare const ChatToolCallType$inboundSchema: z.ZodEnum<typeof ChatToolCallType>;
+/** @internal */
+export declare const ChatToolCallType$outboundSchema: z.ZodEnum<typeof ChatToolCallType>;
+/** @internal */
+export declare const ChatToolCall$inboundSchema: z.ZodType<ChatToolCall, unknown>;
+/** @internal */
+export type ChatToolCall$Outbound = {
+    function: ChatToolCallFunction$Outbound;
+    id: string;
+    type: string;
+};
+/** @internal */
+export declare const ChatToolCall$outboundSchema: z.ZodType<ChatToolCall$Outbound, ChatToolCall>;
+export declare function chatToolCallToJSON(chatToolCall: ChatToolCall): string;
+export declare function chatToolCallFromJSON(jsonString: string): SafeParseResult<ChatToolCall, SDKValidationError>;
+//# sourceMappingURL=chattoolcall.d.ts.map

package/esm/models/chattoolcall.js

@@ -0,0 +1,49 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: f15fee305732
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+export const ChatToolCallType = {
+    Function: "function",
+};
+/** @internal */
+export const ChatToolCallFunction$inboundSchema = z.object({
+    arguments: z.string(),
+    name: z.string(),
+});
+/** @internal */
+export const ChatToolCallFunction$outboundSchema = z.object({
+    arguments: z.string(),
+    name: z.string(),
+});
+export function chatToolCallFunctionToJSON(chatToolCallFunction) {
+    return JSON.stringify(ChatToolCallFunction$outboundSchema.parse(chatToolCallFunction));
+}
+export function chatToolCallFunctionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatToolCallFunction$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatToolCallFunction' from JSON`);
+}
+/** @internal */
+export const ChatToolCallType$inboundSchema = z.enum(ChatToolCallType);
+/** @internal */
+export const ChatToolCallType$outboundSchema = ChatToolCallType$inboundSchema;
+/** @internal */
+export const ChatToolCall$inboundSchema = z
+    .object({
+    function: z.lazy(() => ChatToolCallFunction$inboundSchema),
+    id: z.string(),
+    type: ChatToolCallType$inboundSchema,
+});
+/** @internal */
+export const ChatToolCall$outboundSchema = z.object({
+    function: z.lazy(() => ChatToolCallFunction$outboundSchema),
+    id: z.string(),
+    type: ChatToolCallType$outboundSchema,
+});
+export function chatToolCallToJSON(chatToolCall) {
+    return JSON.stringify(ChatToolCall$outboundSchema.parse(chatToolCall));
+}
+export function chatToolCallFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatToolCall$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatToolCall' from JSON`);
+}
+//# sourceMappingURL=chattoolcall.js.map

package/esm/models/chattoolchoice.d.ts

@@ -0,0 +1,31 @@
+import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
+import { ChatNamedToolChoice, ChatNamedToolChoice$Outbound } from "./chatnamedtoolchoice.js";
+export declare const ChatToolChoiceRequired: {
+    readonly Required: "required";
+};
+export type ChatToolChoiceRequired = ClosedEnum<typeof ChatToolChoiceRequired>;
+export declare const ChatToolChoiceAuto: {
+    readonly Auto: "auto";
+};
+export type ChatToolChoiceAuto = ClosedEnum<typeof ChatToolChoiceAuto>;
+export declare const ChatToolChoiceNone: {
+    readonly None: "none";
+};
+export type ChatToolChoiceNone = ClosedEnum<typeof ChatToolChoiceNone>;
+/**
+ * Tool choice configuration
+ */
+export type ChatToolChoice = ChatNamedToolChoice | ChatToolChoiceNone | ChatToolChoiceAuto | ChatToolChoiceRequired;
+/** @internal */
+export declare const ChatToolChoiceRequired$outboundSchema: z.ZodEnum<typeof ChatToolChoiceRequired>;
+/** @internal */
+export declare const ChatToolChoiceAuto$outboundSchema: z.ZodEnum<typeof ChatToolChoiceAuto>;
+/** @internal */
+export declare const ChatToolChoiceNone$outboundSchema: z.ZodEnum<typeof ChatToolChoiceNone>;
+/** @internal */
+export type ChatToolChoice$Outbound = ChatNamedToolChoice$Outbound | string | string | string;
+/** @internal */
+export declare const ChatToolChoice$outboundSchema: z.ZodType<ChatToolChoice$Outbound, ChatToolChoice>;
+export declare function chatToolChoiceToJSON(chatToolChoice: ChatToolChoice): string;
+//# sourceMappingURL=chattoolchoice.d.ts.map