@openrouter/sdk 0.10.2 → 0.11.2

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

@@ -1,28 +1,28 @@
 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 = {
+export type ChatStreamDelta = {
     /**
      * The role of the message author
      */
-    role?: ChatStreamingMessageChunkRole | undefined;
+    role?: ChatStreamDeltaRole | undefined;
     /**
      * Message content delta
      */
@@ -38,16 +38,16 @@ export type ChatStreamingMessageChunk = {
     /**
      * Tool calls delta
      */
-    toolCalls?: Array<ChatStreamingMessageToolCall> | undefined;
+    toolCalls?: Array<ChatStreamToolCall> | undefined;
     /**
      * Reasoning details for extended thinking models
      */
     reasoningDetails?: Array<ReasoningDetailUnion> | undefined;
-    audio?: ChatCompletionAudioOutput | undefined;
+    audio?: ChatAudioOutput | 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({
+    role: ChatStreamDeltaRole$inboundSchema.optional(),
+    content: z.nullable(z.string()).optional(),
+    reasoning: z.nullable(z.string()).optional(),
+    refusal: z.nullable(z.string()).optional(),
+    tool_calls: z.array(ChatStreamToolCall$inboundSchema).optional(),
+    reasoning_details: z.array(ReasoningDetailUnion$inboundSchema).optional(),
+    audio: ChatAudioOutput$inboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "tool_calls": "toolCalls",
+        "reasoning_details": "reasoningDetails",
+    });
+});
+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";
+/**
+ * Tool call type
+ */
+export declare const ChatStreamToolCallType: {
+    readonly Function: "function";
+};
+/**
+ * Tool call type
+ */
+export type ChatStreamToolCallType = ClosedEnum<typeof ChatStreamToolCallType>;
+/**
+ * Function call details
+ */
+export type ChatStreamToolCallFunction = {
+    /**
+     * Function name
+     */
+    name?: string | undefined;
+    /**
+     * Function arguments as JSON string
+     */
+    arguments?: string | undefined;
+};
+/**
+ * Tool call delta for streaming responses
+ */
+export type ChatStreamToolCall = {
+    /**
+     * Tool call index in the array
+     */
+    index: number;
+    /**
+     * Tool call identifier
+     */
+    id?: string | undefined;
+    /**
+     * Tool call type
+     */
+    type?: ChatStreamToolCallType | undefined;
+    /**
+     * Function call details
+     */
+    function?: ChatStreamToolCallFunction | undefined;
+};
+/** @internal */
+export declare const ChatStreamToolCallType$inboundSchema: z.ZodEnum<typeof ChatStreamToolCallType>;
+/** @internal */
+export declare const ChatStreamToolCallFunction$inboundSchema: z.ZodType<ChatStreamToolCallFunction, unknown>;
+export declare function chatStreamToolCallFunctionFromJSON(jsonString: string): SafeParseResult<ChatStreamToolCallFunction, SDKValidationError>;
+/** @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 ChatStreamToolCallType$inboundSchema = z.enum(ChatStreamToolCallType);
+/** @internal */
+export const ChatStreamToolCallFunction$inboundSchema = z.object({
+    name: z.string().optional(),
+    arguments: 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 ChatStreamToolCall$inboundSchema = z.object({
+    index: z.number(),
+    id: z.string().optional(),
+    type: ChatStreamToolCallType$inboundSchema.optional(),
+    function: z.lazy(() => ChatStreamToolCallFunction$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 = {
+    role: "system";
+    /**
+     * System message content
+     */
+    content: string | Array<ChatContentText>;
+    /**
+     * Optional name for the system message
+     */
+    name?: string | undefined;
+};
+/** @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 = {
+    role: "system";
+    content: string | Array<ChatContentText$Outbound>;
+    name?: string | undefined;
+};
+/** @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({
+    role: z.literal("system"),
+    content: z.union([z.string(), z.array(ChatContentText$outboundSchema)]),
+    name: z.string().optional(),
+});
+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 = {
+    token: string;
+    logprob: number;
+    bytes: Array<number> | null;
+};
+/**
+ * Token log probability information
+ */
+export type ChatTokenLogprob = {
+    /**
+     * 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<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({
+    token: z.string(),
+    logprob: z.number(),
+    bytes: z.nullable(z.array(z.number())),
+});
+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({
+    token: z.string(),
+    logprob: z.number(),
+    bytes: z.nullable(z.array(z.number())),
+    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 declare const ChatToolCallType: {
+    readonly Function: "function";
+};
+export type ChatToolCallType = ClosedEnum<typeof ChatToolCallType>;
+export type ChatToolCallFunction = {
+    /**
+     * Function name to call
+     */
+    name: string;
+    /**
+     * Function arguments as JSON string
+     */
+    arguments: string;
+};
+/**
+ * Tool call made by the assistant
+ */
+export type ChatToolCall = {
+    /**
+     * Tool call identifier
+     */
+    id: string;
+    type: ChatToolCallType;
+    function: ChatToolCallFunction;
+};
+/** @internal */
+export declare const ChatToolCallType$inboundSchema: z.ZodEnum<typeof ChatToolCallType>;
+/** @internal */
+export declare const ChatToolCallType$outboundSchema: z.ZodEnum<typeof ChatToolCallType>;
+/** @internal */
+export declare const ChatToolCallFunction$inboundSchema: z.ZodType<ChatToolCallFunction, unknown>;
+/** @internal */
+export type ChatToolCallFunction$Outbound = {
+    name: string;
+    arguments: 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 ChatToolCall$inboundSchema: z.ZodType<ChatToolCall, unknown>;
+/** @internal */
+export type ChatToolCall$Outbound = {
+    id: string;
+    type: string;
+    function: ChatToolCallFunction$Outbound;
+};
+/** @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 ChatToolCallType$inboundSchema = z.enum(ChatToolCallType);
+/** @internal */
+export const ChatToolCallType$outboundSchema = ChatToolCallType$inboundSchema;
+/** @internal */
+export const ChatToolCallFunction$inboundSchema = z.object({
+    name: z.string(),
+    arguments: z.string(),
+});
+/** @internal */
+export const ChatToolCallFunction$outboundSchema = z.object({
+    name: z.string(),
+    arguments: 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 ChatToolCall$inboundSchema = z
+    .object({
+    id: z.string(),
+    type: ChatToolCallType$inboundSchema,
+    function: z.lazy(() => ChatToolCallFunction$inboundSchema),
+});
+/** @internal */
+export const ChatToolCall$outboundSchema = z.object({
+    id: z.string(),
+    type: ChatToolCallType$outboundSchema,
+    function: z.lazy(() => ChatToolCallFunction$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

package/esm/models/chattoolchoice.js

@@ -0,0 +1,32 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: f553e5b216ba
+ */
+import * as z from "zod/v4";
+import { ChatNamedToolChoice$outboundSchema, } from "./chatnamedtoolchoice.js";
+export const ChatToolChoiceRequired = {
+    Required: "required",
+};
+export const ChatToolChoiceAuto = {
+    Auto: "auto",
+};
+export const ChatToolChoiceNone = {
+    None: "none",
+};
+/** @internal */
+export const ChatToolChoiceRequired$outboundSchema = z.enum(ChatToolChoiceRequired);
+/** @internal */
+export const ChatToolChoiceAuto$outboundSchema = z.enum(ChatToolChoiceAuto);
+/** @internal */
+export const ChatToolChoiceNone$outboundSchema = z.enum(ChatToolChoiceNone);
+/** @internal */
+export const ChatToolChoice$outboundSchema = z.union([
+    ChatNamedToolChoice$outboundSchema,
+    ChatToolChoiceNone$outboundSchema,
+    ChatToolChoiceAuto$outboundSchema,
+    ChatToolChoiceRequired$outboundSchema,
+]);
+export function chatToolChoiceToJSON(chatToolChoice) {
+    return JSON.stringify(ChatToolChoice$outboundSchema.parse(chatToolChoice));
+}
+//# sourceMappingURL=chattoolchoice.js.map

package/esm/models/chattoolmessage.d.ts

@@ -0,0 +1,35 @@
+import * as z from "zod/v4";
+import { ChatContentItems, ChatContentItems$Outbound } from "./chatcontentitems.js";
+/**
+ * Tool response content
+ */
+export type ChatToolMessageContent = string | Array<ChatContentItems>;
+/**
+ * Tool response message
+ */
+export type ChatToolMessage = {
+    role: "tool";
+    /**
+     * Tool response content
+     */
+    content: string | Array<ChatContentItems>;
+    /**
+     * ID of the assistant message tool call this message responds to
+     */
+    toolCallId: string;
+};
+/** @internal */
+export type ChatToolMessageContent$Outbound = string | Array<ChatContentItems$Outbound>;
+/** @internal */
+export declare const ChatToolMessageContent$outboundSchema: z.ZodType<ChatToolMessageContent$Outbound, ChatToolMessageContent>;
+export declare function chatToolMessageContentToJSON(chatToolMessageContent: ChatToolMessageContent): string;
+/** @internal */
+export type ChatToolMessage$Outbound = {
+    role: "tool";
+    content: string | Array<ChatContentItems$Outbound>;
+    tool_call_id: string;
+};
+/** @internal */
+export declare const ChatToolMessage$outboundSchema: z.ZodType<ChatToolMessage$Outbound, ChatToolMessage>;
+export declare function chatToolMessageToJSON(chatToolMessage: ChatToolMessage): string;
+//# sourceMappingURL=chattoolmessage.d.ts.map

package/esm/models/chattoolmessage.js

@@ -0,0 +1,26 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 446b465db30a
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { ChatContentItems$outboundSchema, } from "./chatcontentitems.js";
+/** @internal */
+export const ChatToolMessageContent$outboundSchema = z.union([z.string(), z.array(ChatContentItems$outboundSchema)]);
+export function chatToolMessageContentToJSON(chatToolMessageContent) {
+    return JSON.stringify(ChatToolMessageContent$outboundSchema.parse(chatToolMessageContent));
+}
+/** @internal */
+export const ChatToolMessage$outboundSchema = z.object({
+    role: z.literal("tool"),
+    content: z.union([z.string(), z.array(ChatContentItems$outboundSchema)]),
+    toolCallId: z.string(),
+}).transform((v) => {
+    return remap$(v, {
+        toolCallId: "tool_call_id",
+    });
+});
+export function chatToolMessageToJSON(chatToolMessage) {
+    return JSON.stringify(ChatToolMessage$outboundSchema.parse(chatToolMessage));
+}
+//# sourceMappingURL=chattoolmessage.js.map

package/esm/models/{chatgenerationtokenusage.d.ts → chatusage.d.ts}

@@ -46,7 +46,7 @@ export type PromptTokensDetails = {
 /**
  * Token usage statistics
  */
-export type ChatGenerationTokenUsage = {
+export type ChatUsage = {
     /**
      * Number of tokens in the completion
      */
@@ -75,6 +75,6 @@ export declare function completionTokensDetailsFromJSON(jsonString: string): Saf
 export declare const PromptTokensDetails$inboundSchema: z.ZodType<PromptTokensDetails, unknown>;
 export declare function promptTokensDetailsFromJSON(jsonString: string): SafeParseResult<PromptTokensDetails, SDKValidationError>;
 /** @internal */
-export declare const ChatGenerationTokenUsage$inboundSchema: z.ZodType<ChatGenerationTokenUsage, unknown>;
-export declare function chatGenerationTokenUsageFromJSON(jsonString: string): SafeParseResult<ChatGenerationTokenUsage, SDKValidationError>;
-//# sourceMappingURL=chatgenerationtokenusage.d.ts.map
+export declare const ChatUsage$inboundSchema: z.ZodType<ChatUsage, unknown>;
+export declare function chatUsageFromJSON(jsonString: string): SafeParseResult<ChatUsage, SDKValidationError>;
+//# sourceMappingURL=chatusage.d.ts.map

package/esm/models/{chatgenerationtokenusage.js → chatusage.js}

@@ -1,6 +1,6 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- * @generated-id: 1d57b0d238b8
+ * @generated-id: 1e677d1ed4fc
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
@@ -40,7 +40,7 @@ export function promptTokensDetailsFromJSON(jsonString) {
     return safeParse(jsonString, (x) => PromptTokensDetails$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'PromptTokensDetails' from JSON`);
 }
 /** @internal */
-export const ChatGenerationTokenUsage$inboundSchema = z.object({
+export const ChatUsage$inboundSchema = z.object({
     completion_tokens: z.number(),
     prompt_tokens: z.number(),
     total_tokens: z.number(),
@@ -55,7 +55,7 @@ export const ChatGenerationTokenUsage$inboundSchema = z.object({
         "prompt_tokens_details": "promptTokensDetails",
     });
 });
-export function chatGenerationTokenUsageFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => ChatGenerationTokenUsage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatGenerationTokenUsage' from JSON`);
+export function chatUsageFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatUsage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatUsage' from JSON`);
 }
-//# sourceMappingURL=chatgenerationtokenusage.js.map
+//# sourceMappingURL=chatusage.js.map