@openrouter/sdk 0.11.2 → 0.12.1

package/esm/models/chatstreamchunk.js

@@ -11,30 +11,30 @@ export const ChatStreamChunkObject = {
     ChatCompletionChunk: "chat.completion.chunk",
 };
 /** @internal */
-export const ChatStreamChunkObject$inboundSchema = z.enum(ChatStreamChunkObject);
-/** @internal */
 export const ErrorT$inboundSchema = z.object({
+    code: z.int(),
     message: z.string(),
-    code: z.number(),
 });
 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({
-    id: z.string(),
     choices: z.array(ChatStreamChoice$inboundSchema),
-    created: z.number(),
+    created: z.int(),
+    error: z.lazy(() => ErrorT$inboundSchema).optional(),
+    id: z.string(),
     model: z.string(),
     object: ChatStreamChunkObject$inboundSchema,
-    system_fingerprint: z.string().optional(),
     service_tier: z.nullable(z.string()).optional(),
-    error: z.lazy(() => ErrorT$inboundSchema).optional(),
+    system_fingerprint: z.string().optional(),
     usage: ChatUsage$inboundSchema.optional(),
 }).transform((v) => {
     return remap$(v, {
-        "system_fingerprint": "systemFingerprint",
         "service_tier": "serviceTier",
+        "system_fingerprint": "systemFingerprint",
     });
 });
 export function chatStreamChunkFromJSON(jsonString) {

package/esm/models/chatstreamdelta.d.ts

@@ -19,10 +19,7 @@ export type ChatStreamDeltaRole = ClosedEnum<typeof ChatStreamDeltaRole>;
  * Delta changes in streaming response
  */
 export type ChatStreamDelta = {
-    /**
-     * The role of the message author
-     */
-    role?: ChatStreamDeltaRole | undefined;
+    audio?: ChatAudioOutput | undefined;
     /**
      * Message content delta
      */
@@ -31,19 +28,22 @@ export type ChatStreamDelta = {
      * 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<ChatStreamToolCall> | undefined;
+    role?: ChatStreamDeltaRole | undefined;
     /**
-     * Reasoning details for extended thinking models
+     * Tool calls delta
      */
-    reasoningDetails?: Array<ReasoningDetailUnion> | undefined;
-    audio?: ChatAudioOutput | undefined;
+    toolCalls?: Array<ChatStreamToolCall> | undefined;
 };
 /** @internal */
 export declare const ChatStreamDeltaRole$inboundSchema: z.ZodEnum<typeof ChatStreamDeltaRole>;

package/esm/models/chatstreamdelta.js

@@ -18,17 +18,17 @@ export const ChatStreamDeltaRole = {
 export const ChatStreamDeltaRole$inboundSchema = z.enum(ChatStreamDeltaRole);
 /** @internal */
 export const ChatStreamDelta$inboundSchema = z.object({
-    role: ChatStreamDeltaRole$inboundSchema.optional(),
+    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(),
-    reasoning_details: z.array(ReasoningDetailUnion$inboundSchema).optional(),
-    audio: ChatAudioOutput$inboundSchema.optional(),
 }).transform((v) => {
     return remap$(v, {
-        "tool_calls": "toolCalls",
         "reasoning_details": "reasoningDetails",
+        "tool_calls": "toolCalls",
     });
 });
 export function chatStreamDeltaFromJSON(jsonString) {

package/esm/models/chatstreamtoolcall.d.ts

@@ -2,6 +2,19 @@ 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
  */
@@ -12,46 +25,33 @@ export declare const ChatStreamToolCallType: {
  * 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
+     * Function call details
      */
-    index: number;
+    function?: ChatStreamToolCallFunction | undefined;
     /**
      * Tool call identifier
      */
     id?: string | undefined;
     /**
-     * Tool call type
+     * Tool call index in the array
      */
-    type?: ChatStreamToolCallType | undefined;
+    index: number;
     /**
-     * Function call details
+     * Tool call type
      */
-    function?: ChatStreamToolCallFunction | undefined;
+    type?: ChatStreamToolCallType | 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 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

@@ -11,21 +11,21 @@ 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(),
+    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({
-    index: z.number(),
+    function: z.lazy(() => ChatStreamToolCallFunction$inboundSchema).optional(),
     id: z.string().optional(),
+    index: z.int(),
     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`);

package/esm/models/chatsystemmessage.d.ts

@@ -8,7 +8,6 @@ export type ChatSystemMessageContent = string | Array<ChatContentText>;
  * System message for setting behavior
  */
 export type ChatSystemMessage = {
-    role: "system";
     /**
      * System message content
      */
@@ -17,6 +16,7 @@ export type ChatSystemMessage = {
      * Optional name for the system message
      */
     name?: string | undefined;
+    role: "system";
 };
 /** @internal */
 export type ChatSystemMessageContent$Outbound = string | Array<ChatContentText$Outbound>;
@@ -25,9 +25,9 @@ export declare const ChatSystemMessageContent$outboundSchema: z.ZodType<ChatSyst
 export declare function chatSystemMessageContentToJSON(chatSystemMessageContent: ChatSystemMessageContent): string;
 /** @internal */
 export type ChatSystemMessage$Outbound = {
-    role: "system";
     content: string | Array<ChatContentText$Outbound>;
     name?: string | undefined;
+    role: "system";
 };
 /** @internal */
 export declare const ChatSystemMessage$outboundSchema: z.ZodType<ChatSystemMessage$Outbound, ChatSystemMessage>;

package/esm/models/chatsystemmessage.js

@@ -11,9 +11,9 @@ export function chatSystemMessageContentToJSON(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(),
+    role: z.literal("system"),
 });
 export function chatSystemMessageToJSON(chatSystemMessage) {
     return JSON.stringify(ChatSystemMessage$outboundSchema.parse(chatSystemMessage));

package/esm/models/chattokenlogprob.d.ts

@@ -2,26 +2,26 @@ 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;
+    logprob: number;
+    token: string;
 };
 /**
  * Token log probability information
  */
 export type ChatTokenLogprob = {
     /**
-     * The token
+     * UTF-8 bytes of the token
      */
-    token: string;
+    bytes: Array<number> | null;
     /**
      * Log probability of the token
      */
     logprob: number;
     /**
-     * UTF-8 bytes of the token
+     * The token
      */
-    bytes: Array<number> | null;
+    token: string;
     /**
      * Top alternative tokens with probabilities
      */

package/esm/models/chattokenlogprob.js

@@ -7,18 +7,18 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const ChatTokenLogprobTopLogprob$inboundSchema = z.object({
-    token: z.string(),
+    bytes: z.nullable(z.array(z.int())),
     logprob: z.number(),
-    bytes: z.nullable(z.array(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({
-    token: z.string(),
+    bytes: z.nullable(z.array(z.int())),
     logprob: z.number(),
-    bytes: z.nullable(z.array(z.number())),
+    token: z.string(),
     top_logprobs: z.array(z.lazy(() => ChatTokenLogprobTopLogprob$inboundSchema)),
 }).transform((v) => {
     return remap$(v, {

package/esm/models/chattoolcall.d.ts

@@ -2,53 +2,53 @@ 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;
+    /**
+     * 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;
-    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;
+    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;
-    function: ChatToolCallFunction$Outbound;
 };
 /** @internal */
 export declare const ChatToolCall$outboundSchema: z.ZodType<ChatToolCall$Outbound, ChatToolCall>;

package/esm/models/chattoolcall.js

@@ -8,18 +8,14 @@ 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(),
+    name: z.string(),
 });
 /** @internal */
 export const ChatToolCallFunction$outboundSchema = z.object({
-    name: z.string(),
     arguments: z.string(),
+    name: z.string(),
 });
 export function chatToolCallFunctionToJSON(chatToolCallFunction) {
     return JSON.stringify(ChatToolCallFunction$outboundSchema.parse(chatToolCallFunction));
@@ -28,17 +24,21 @@ 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,
-    function: z.lazy(() => ChatToolCallFunction$inboundSchema),
 });
 /** @internal */
 export const ChatToolCall$outboundSchema = z.object({
+    function: z.lazy(() => ChatToolCallFunction$outboundSchema),
     id: z.string(),
     type: ChatToolCallType$outboundSchema,
-    function: z.lazy(() => ChatToolCallFunction$outboundSchema),
 });
 export function chatToolCallToJSON(chatToolCall) {
     return JSON.stringify(ChatToolCall$outboundSchema.parse(chatToolCall));

package/esm/models/chattoolmessage.d.ts

@@ -8,11 +8,11 @@ export type ChatToolMessageContent = string | Array<ChatContentItems>;
  * Tool response message
  */
 export type ChatToolMessage = {
-    role: "tool";
     /**
      * Tool response content
      */
     content: string | Array<ChatContentItems>;
+    role: "tool";
     /**
      * ID of the assistant message tool call this message responds to
      */
@@ -25,8 +25,8 @@ export declare const ChatToolMessageContent$outboundSchema: z.ZodType<ChatToolMe
 export declare function chatToolMessageContentToJSON(chatToolMessageContent: ChatToolMessageContent): string;
 /** @internal */
 export type ChatToolMessage$Outbound = {
-    role: "tool";
     content: string | Array<ChatContentItems$Outbound>;
+    role: "tool";
     tool_call_id: string;
 };
 /** @internal */

package/esm/models/chattoolmessage.js

@@ -12,8 +12,8 @@ export function chatToolMessageContentToJSON(chatToolMessageContent) {
 }
 /** @internal */
 export const ChatToolMessage$outboundSchema = z.object({
-    role: z.literal("tool"),
     content: z.union([z.string(), z.array(ChatContentItems$outboundSchema)]),
+    role: z.literal("tool"),
     toolCallId: z.string(),
 }).transform((v) => {
     return remap$(v, {

package/esm/models/chatusage.d.ts

@@ -6,38 +6,38 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
  */
 export type CompletionTokensDetails = {
     /**
-     * Tokens used for reasoning
+     * Accepted prediction tokens
      */
-    reasoningTokens?: number | null | undefined;
+    acceptedPredictionTokens?: number | undefined;
     /**
      * Tokens used for audio output
      */
-    audioTokens?: number | null | undefined;
+    audioTokens?: number | undefined;
     /**
-     * Accepted prediction tokens
+     * Tokens used for reasoning
      */
-    acceptedPredictionTokens?: number | null | undefined;
+    reasoningTokens?: number | undefined;
     /**
      * Rejected prediction tokens
      */
-    rejectedPredictionTokens?: number | null | undefined;
+    rejectedPredictionTokens?: number | undefined;
 };
 /**
  * Detailed prompt token usage
  */
 export type PromptTokensDetails = {
     /**
-     * Cached prompt tokens
+     * Audio input tokens
      */
-    cachedTokens?: number | undefined;
+    audioTokens?: number | undefined;
     /**
      * Tokens written to cache. Only returned for models with explicit caching and cache write pricing.
      */
     cacheWriteTokens?: number | undefined;
     /**
-     * Audio input tokens
+     * Cached prompt tokens
      */
-    audioTokens?: number | undefined;
+    cachedTokens?: number | undefined;
     /**
      * Video input tokens
      */
@@ -51,22 +51,22 @@ export type ChatUsage = {
      * Number of tokens in the completion
      */
     completionTokens: number;
-    /**
-     * Number of tokens in the prompt
-     */
-    promptTokens: number;
-    /**
-     * Total number of tokens
-     */
-    totalTokens: number;
     /**
      * Detailed completion token usage
      */
     completionTokensDetails?: CompletionTokensDetails | null | undefined;
+    /**
+     * Number of tokens in the prompt
+     */
+    promptTokens: number;
     /**
      * Detailed prompt token usage
      */
     promptTokensDetails?: PromptTokensDetails | null | undefined;
+    /**
+     * Total number of tokens
+     */
+    totalTokens: number;
 };
 /** @internal */
 export declare const CompletionTokensDetails$inboundSchema: z.ZodType<CompletionTokensDetails, unknown>;

package/esm/models/chatusage.js

@@ -7,15 +7,15 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
 export const CompletionTokensDetails$inboundSchema = z.object({
-    reasoning_tokens: z.nullable(z.number()).optional(),
-    audio_tokens: z.nullable(z.number()).optional(),
-    accepted_prediction_tokens: z.nullable(z.number()).optional(),
-    rejected_prediction_tokens: z.nullable(z.number()).optional(),
+    accepted_prediction_tokens: z.int().optional(),
+    audio_tokens: z.int().optional(),
+    reasoning_tokens: z.int().optional(),
+    rejected_prediction_tokens: z.int().optional(),
 }).transform((v) => {
     return remap$(v, {
-        "reasoning_tokens": "reasoningTokens",
-        "audio_tokens": "audioTokens",
         "accepted_prediction_tokens": "acceptedPredictionTokens",
+        "audio_tokens": "audioTokens",
+        "reasoning_tokens": "reasoningTokens",
         "rejected_prediction_tokens": "rejectedPredictionTokens",
     });
 });
@@ -24,15 +24,15 @@ export function completionTokensDetailsFromJSON(jsonString) {
 }
 /** @internal */
 export const PromptTokensDetails$inboundSchema = z.object({
-    cached_tokens: z.number().optional(),
-    cache_write_tokens: z.number().optional(),
-    audio_tokens: z.number().optional(),
-    video_tokens: z.number().optional(),
+    audio_tokens: z.int().optional(),
+    cache_write_tokens: z.int().optional(),
+    cached_tokens: z.int().optional(),
+    video_tokens: z.int().optional(),
 }).transform((v) => {
     return remap$(v, {
-        "cached_tokens": "cachedTokens",
-        "cache_write_tokens": "cacheWriteTokens",
         "audio_tokens": "audioTokens",
+        "cache_write_tokens": "cacheWriteTokens",
+        "cached_tokens": "cachedTokens",
         "video_tokens": "videoTokens",
     });
 });
@@ -41,18 +41,18 @@ export function promptTokensDetailsFromJSON(jsonString) {
 }
 /** @internal */
 export const ChatUsage$inboundSchema = z.object({
-    completion_tokens: z.number(),
-    prompt_tokens: z.number(),
-    total_tokens: z.number(),
+    completion_tokens: z.int(),
     completion_tokens_details: z.nullable(z.lazy(() => CompletionTokensDetails$inboundSchema)).optional(),
+    prompt_tokens: z.int(),
     prompt_tokens_details: z.nullable(z.lazy(() => PromptTokensDetails$inboundSchema)).optional(),
+    total_tokens: z.int(),
 }).transform((v) => {
     return remap$(v, {
         "completion_tokens": "completionTokens",
-        "prompt_tokens": "promptTokens",
-        "total_tokens": "totalTokens",
         "completion_tokens_details": "completionTokensDetails",
+        "prompt_tokens": "promptTokens",
         "prompt_tokens_details": "promptTokensDetails",
+        "total_tokens": "totalTokens",
     });
 });
 export function chatUsageFromJSON(jsonString) {

package/esm/models/chatusermessage.d.ts

@@ -8,7 +8,6 @@ export type ChatUserMessageContent = string | Array<ChatContentItems>;
  * User message
  */
 export type ChatUserMessage = {
-    role: "user";
     /**
      * User message content
      */
@@ -17,6 +16,7 @@ export type ChatUserMessage = {
      * Optional name for the user
      */
     name?: string | undefined;
+    role: "user";
 };
 /** @internal */
 export type ChatUserMessageContent$Outbound = string | Array<ChatContentItems$Outbound>;
@@ -25,9 +25,9 @@ export declare const ChatUserMessageContent$outboundSchema: z.ZodType<ChatUserMe
 export declare function chatUserMessageContentToJSON(chatUserMessageContent: ChatUserMessageContent): string;
 /** @internal */
 export type ChatUserMessage$Outbound = {
-    role: "user";
     content: string | Array<ChatContentItems$Outbound>;
     name?: string | undefined;
+    role: "user";
 };
 /** @internal */
 export declare const ChatUserMessage$outboundSchema: z.ZodType<ChatUserMessage$Outbound, ChatUserMessage>;

package/esm/models/chatusermessage.js

@@ -11,9 +11,9 @@ export function chatUserMessageContentToJSON(chatUserMessageContent) {
 }
 /** @internal */
 export const ChatUserMessage$outboundSchema = z.object({
-    role: z.literal("user"),
     content: z.union([z.string(), z.array(ChatContentItems$outboundSchema)]),
     name: z.string().optional(),
+    role: z.literal("user"),
 });
 export function chatUserMessageToJSON(chatUserMessage) {
     return JSON.stringify(ChatUserMessage$outboundSchema.parse(chatUserMessage));