@openrouter/sdk 0.8.0 → 0.10.2

package/esm/models/chatmessagecontentitemvideolegacy.js

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 785ee29d8430
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { VideoInput$inboundSchema, VideoInput$outboundSchema, } from "./videoinput.js";
+/** @internal */
+export const ChatMessageContentItemVideoLegacy$inboundSchema = z.object({
+    type: z.literal("input_video"),
+    video_url: VideoInput$inboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        "video_url": "videoUrl",
+    });
+});
+/** @internal */
+export const ChatMessageContentItemVideoLegacy$outboundSchema = z.object({
+    type: z.literal("input_video"),
+    videoUrl: VideoInput$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        videoUrl: "video_url",
+    });
+});
+export function chatMessageContentItemVideoLegacyToJSON(chatMessageContentItemVideoLegacy) {
+    return JSON.stringify(ChatMessageContentItemVideoLegacy$outboundSchema.parse(chatMessageContentItemVideoLegacy));
+}
+export function chatMessageContentItemVideoLegacyFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatMessageContentItemVideoLegacy$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageContentItemVideoLegacy' from JSON`);
+}
+//# sourceMappingURL=chatmessagecontentitemvideolegacy.js.map

package/esm/models/chatmessagetokenlogprob.d.ts

@@ -6,10 +6,25 @@ export type ChatMessageTokenLogprobTopLogprob = {
     logprob: number;
     bytes: Array<number> | null;
 };
+/**
+ * Token log probability information
+ */
 export type ChatMessageTokenLogprob = {
+    /**
+     * 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<ChatMessageTokenLogprobTopLogprob>;
 };
 /** @internal */

package/esm/models/chatmessagetokenlogprobs.d.ts

@@ -2,9 +2,18 @@ import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { ChatMessageTokenLogprob } from "./chatmessagetokenlogprob.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Log probabilities for the completion
+ */
 export type ChatMessageTokenLogprobs = {
+    /**
+     * Log probabilities for content tokens
+     */
     content: Array<ChatMessageTokenLogprob> | null;
-    refusal: Array<ChatMessageTokenLogprob> | null;
+    /**
+     * Log probabilities for refusal tokens
+     */
+    refusal?: Array<ChatMessageTokenLogprob> | null | undefined;
 };
 /** @internal */
 export declare const ChatMessageTokenLogprobs$inboundSchema: z.ZodType<ChatMessageTokenLogprobs, unknown>;

package/esm/models/chatmessagetokenlogprobs.js

@@ -8,7 +8,8 @@ import { ChatMessageTokenLogprob$inboundSchema, } from "./chatmessagetokenlogpro
 /** @internal */
 export const ChatMessageTokenLogprobs$inboundSchema = z.object({
     content: z.nullable(z.array(ChatMessageTokenLogprob$inboundSchema)),
-    refusal: z.nullable(z.array(ChatMessageTokenLogprob$inboundSchema)),
+    refusal: z.nullable(z.array(ChatMessageTokenLogprob$inboundSchema))
+        .optional(),
 });
 export function chatMessageTokenLogprobsFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ChatMessageTokenLogprobs$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageTokenLogprobs' from JSON`);

package/esm/models/chatmessagetoolcall.d.ts

@@ -1,16 +1,37 @@
 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 ChatMessageToolCallType: {
+    readonly Function: "function";
+};
+export type ChatMessageToolCallType = ClosedEnum<typeof ChatMessageToolCallType>;
 export type ChatMessageToolCallFunction = {
+    /**
+     * Function name to call
+     */
     name: string;
+    /**
+     * Function arguments as JSON string
+     */
     arguments: string;
 };
+/**
+ * Tool call made by the assistant
+ */
 export type ChatMessageToolCall = {
+    /**
+     * Tool call identifier
+     */
     id: string;
-    type: "function";
+    type: ChatMessageToolCallType;
     function: ChatMessageToolCallFunction;
 };
 /** @internal */
+export declare const ChatMessageToolCallType$inboundSchema: z.ZodEnum<typeof ChatMessageToolCallType>;
+/** @internal */
+export declare const ChatMessageToolCallType$outboundSchema: z.ZodEnum<typeof ChatMessageToolCallType>;
+/** @internal */
 export declare const ChatMessageToolCallFunction$inboundSchema: z.ZodType<ChatMessageToolCallFunction, unknown>;
 /** @internal */
 export type ChatMessageToolCallFunction$Outbound = {
@@ -26,7 +47,7 @@ export declare const ChatMessageToolCall$inboundSchema: z.ZodType<ChatMessageToo
 /** @internal */
 export type ChatMessageToolCall$Outbound = {
     id: string;
-    type: "function";
+    type: string;
     function: ChatMessageToolCallFunction$Outbound;
 };
 /** @internal */

package/esm/models/chatmessagetoolcall.js

@@ -4,6 +4,13 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
+export const ChatMessageToolCallType = {
+    Function: "function",
+};
+/** @internal */
+export const ChatMessageToolCallType$inboundSchema = z.enum(ChatMessageToolCallType);
+/** @internal */
+export const ChatMessageToolCallType$outboundSchema = ChatMessageToolCallType$inboundSchema;
 /** @internal */
 export const ChatMessageToolCallFunction$inboundSchema = z.object({
     name: z.string(),
@@ -23,13 +30,13 @@ export function chatMessageToolCallFunctionFromJSON(jsonString) {
 /** @internal */
 export const ChatMessageToolCall$inboundSchema = z.object({
     id: z.string(),
-    type: z.literal("function"),
+    type: ChatMessageToolCallType$inboundSchema,
     function: z.lazy(() => ChatMessageToolCallFunction$inboundSchema),
 });
 /** @internal */
 export const ChatMessageToolCall$outboundSchema = z.object({
     id: z.string(),
-    type: z.literal("function"),
+    type: ChatMessageToolCallType$outboundSchema,
     function: z.lazy(() => ChatMessageToolCallFunction$outboundSchema),
 });
 export function chatMessageToolCallToJSON(chatMessageToolCall) {

package/esm/models/chatresponse.d.ts

@@ -1,18 +1,46 @@
 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 { ChatResponseChoice } from "./chatresponsechoice.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const ChatResponseObject: {
+    readonly ChatCompletion: "chat.completion";
+};
+export type ChatResponseObject = ClosedEnum<typeof ChatResponseObject>;
+/**
+ * Chat completion response
+ */
 export type ChatResponse = {
+    /**
+     * Unique completion identifier
+     */
     id: string;
+    /**
+     * List of completion choices
+     */
     choices: Array<ChatResponseChoice>;
+    /**
+     * Unix timestamp of creation
+     */
     created: number;
+    /**
+     * Model used for completion
+     */
     model: string;
-    object: "chat.completion";
-    systemFingerprint?: string | null | undefined;
+    object: ChatResponseObject;
+    /**
+     * System fingerprint
+     */
+    systemFingerprint: string | null;
+    /**
+     * Token usage statistics
+     */
     usage?: ChatGenerationTokenUsage | undefined;
 };
 /** @internal */
+export declare const ChatResponseObject$inboundSchema: z.ZodEnum<typeof ChatResponseObject>;
+/** @internal */
 export declare const ChatResponse$inboundSchema: z.ZodType<ChatResponse, unknown>;
 export declare function chatResponseFromJSON(jsonString: string): SafeParseResult<ChatResponse, SDKValidationError>;
 //# sourceMappingURL=chatresponse.d.ts.map

package/esm/models/chatresponse.js

@@ -7,6 +7,11 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { ChatGenerationTokenUsage$inboundSchema, } from "./chatgenerationtokenusage.js";
 import { ChatResponseChoice$inboundSchema, } from "./chatresponsechoice.js";
+export const ChatResponseObject = {
+    ChatCompletion: "chat.completion",
+};
+/** @internal */
+export const ChatResponseObject$inboundSchema = z.enum(ChatResponseObject);
 /** @internal */
 export const ChatResponse$inboundSchema = z
     .object({
@@ -14,8 +19,8 @@ export const ChatResponse$inboundSchema = z
     choices: z.array(ChatResponseChoice$inboundSchema),
     created: z.number(),
     model: z.string(),
-    object: z.literal("chat.completion"),
-    system_fingerprint: z.nullable(z.string()).optional(),
+    object: ChatResponseObject$inboundSchema,
+    system_fingerprint: z.nullable(z.string()),
     usage: ChatGenerationTokenUsage$inboundSchema.optional(),
 }).transform((v) => {
     return remap$(v, {

package/esm/models/chatresponsechoice.d.ts

@@ -1,13 +1,24 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { AssistantMessage } from "./assistantmessage.js";
-import { ChatCompletionFinishReason } from "./chatcompletionfinishreason.js";
 import { ChatMessageTokenLogprobs } from "./chatmessagetokenlogprobs.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Chat completion choice
+ */
 export type ChatResponseChoice = {
-    finishReason: ChatCompletionFinishReason | null;
+    finishReason?: any | null | undefined;
+    /**
+     * Choice index
+     */
     index: number;
+    /**
+     * Assistant message for requests and responses
+     */
     message: AssistantMessage;
+    /**
+     * Log probabilities for the completion
+     */
     logprobs?: ChatMessageTokenLogprobs | null | undefined;
 };
 /** @internal */

package/esm/models/chatresponsechoice.js

@@ -6,11 +6,10 @@ import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { AssistantMessage$inboundSchema, } from "./assistantmessage.js";
-import { ChatCompletionFinishReason$inboundSchema, } from "./chatcompletionfinishreason.js";
 import { ChatMessageTokenLogprobs$inboundSchema, } from "./chatmessagetokenlogprobs.js";
 /** @internal */
 export const ChatResponseChoice$inboundSchema = z.object({
-    finish_reason: z.nullable(ChatCompletionFinishReason$inboundSchema),
+    finish_reason: z.nullable(z.any()).optional(),
     index: z.number(),
     message: AssistantMessage$inboundSchema,
     logprobs: z.nullable(ChatMessageTokenLogprobs$inboundSchema).optional(),

package/esm/models/chatstreamingchoice.d.ts

@@ -1,13 +1,24 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
-import { ChatCompletionFinishReason } from "./chatcompletionfinishreason.js";
 import { ChatMessageTokenLogprobs } from "./chatmessagetokenlogprobs.js";
 import { ChatStreamingMessageChunk } from "./chatstreamingmessagechunk.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Streaming completion choice chunk
+ */
 export type ChatStreamingChoice = {
+    /**
+     * Delta changes in streaming response
+     */
     delta: ChatStreamingMessageChunk;
-    finishReason: ChatCompletionFinishReason | null;
+    finishReason?: any | null | undefined;
+    /**
+     * Choice index
+     */
     index: number;
+    /**
+     * Log probabilities for the completion
+     */
     logprobs?: ChatMessageTokenLogprobs | null | undefined;
 };
 /** @internal */

package/esm/models/chatstreamingchoice.js

@@ -5,13 +5,12 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-import { ChatCompletionFinishReason$inboundSchema, } from "./chatcompletionfinishreason.js";
 import { ChatMessageTokenLogprobs$inboundSchema, } from "./chatmessagetokenlogprobs.js";
 import { ChatStreamingMessageChunk$inboundSchema, } from "./chatstreamingmessagechunk.js";
 /** @internal */
 export const ChatStreamingChoice$inboundSchema = z.object({
     delta: ChatStreamingMessageChunk$inboundSchema,
-    finish_reason: z.nullable(ChatCompletionFinishReason$inboundSchema),
+    finish_reason: z.nullable(z.any()).optional(),
     index: z.number(),
     logprobs: z.nullable(ChatMessageTokenLogprobs$inboundSchema).optional(),
 }).transform((v) => {

package/esm/models/chatstreamingmessagechunk.d.ts

@@ -1,20 +1,49 @@
 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 { SDKValidationError } from "./errors/sdkvalidationerror.js";
-import { Schema19 } from "./schema19.js";
+import { ReasoningDetailUnion } from "./reasoningdetailunion.js";
+/**
+ * The role of the message author
+ */
 export declare const ChatStreamingMessageChunkRole: {
     readonly Assistant: "assistant";
 };
+/**
+ * The role of the message author
+ */
 export type ChatStreamingMessageChunkRole = ClosedEnum<typeof ChatStreamingMessageChunkRole>;
+/**
+ * Delta changes in streaming response
+ */
 export type ChatStreamingMessageChunk = {
+    /**
+     * The role of the message author
+     */
     role?: ChatStreamingMessageChunkRole | undefined;
+    /**
+     * Message content delta
+     */
     content?: string | null | undefined;
+    /**
+     * Reasoning content delta
+     */
     reasoning?: string | null | undefined;
+    /**
+     * Refusal message delta
+     */
     refusal?: string | null | undefined;
+    /**
+     * Tool calls delta
+     */
     toolCalls?: Array<ChatStreamingMessageToolCall> | undefined;
-    reasoningDetails?: Array<Schema19> | undefined;
+    /**
+     * Reasoning details for extended thinking models
+     */
+    reasoningDetails?: Array<ReasoningDetailUnion> | undefined;
+    audio?: ChatCompletionAudioOutput | undefined;
 };
 /** @internal */
 export declare const ChatStreamingMessageChunkRole$inboundSchema: z.ZodEnum<typeof ChatStreamingMessageChunkRole>;

package/esm/models/chatstreamingmessagechunk.js

@@ -5,8 +5,12 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
+import { ChatCompletionAudioOutput$inboundSchema, } from "./chatcompletionaudiooutput.js";
 import { ChatStreamingMessageToolCall$inboundSchema, } from "./chatstreamingmessagetoolcall.js";
-import { Schema19$inboundSchema } from "./schema19.js";
+import { ReasoningDetailUnion$inboundSchema, } from "./reasoningdetailunion.js";
+/**
+ * The role of the message author
+ */
 export const ChatStreamingMessageChunkRole = {
     Assistant: "assistant",
 };
@@ -19,7 +23,8 @@ export const ChatStreamingMessageChunk$inboundSchema = z.object({
     reasoning: z.nullable(z.string()).optional(),
     refusal: z.nullable(z.string()).optional(),
     tool_calls: z.array(ChatStreamingMessageToolCall$inboundSchema).optional(),
-    reasoning_details: z.array(Schema19$inboundSchema).optional(),
+    reasoning_details: z.array(ReasoningDetailUnion$inboundSchema).optional(),
+    audio: ChatCompletionAudioOutput$inboundSchema.optional(),
 }).transform((v) => {
     return remap$(v, {
         "tool_calls": "toolCalls",

package/esm/models/chatstreamingmessagetoolcall.d.ts

@@ -1,17 +1,54 @@
 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 ChatStreamingMessageToolCallType: {
+    readonly Function: "function";
+};
+/**
+ * Tool call type
+ */
+export type ChatStreamingMessageToolCallType = ClosedEnum<typeof ChatStreamingMessageToolCallType>;
+/**
+ * Function call details
+ */
 export type ChatStreamingMessageToolCallFunction = {
+    /**
+     * Function name
+     */
     name?: string | undefined;
+    /**
+     * Function arguments as JSON string
+     */
     arguments?: string | undefined;
 };
+/**
+ * Tool call delta for streaming responses
+ */
 export type ChatStreamingMessageToolCall = {
+    /**
+     * Tool call index in the array
+     */
     index: number;
+    /**
+     * Tool call identifier
+     */
     id?: string | undefined;
-    type?: "function" | undefined;
+    /**
+     * Tool call type
+     */
+    type?: ChatStreamingMessageToolCallType | undefined;
+    /**
+     * Function call details
+     */
     function?: ChatStreamingMessageToolCallFunction | undefined;
 };
 /** @internal */
+export declare const ChatStreamingMessageToolCallType$inboundSchema: z.ZodEnum<typeof ChatStreamingMessageToolCallType>;
+/** @internal */
 export declare const ChatStreamingMessageToolCallFunction$inboundSchema: z.ZodType<ChatStreamingMessageToolCallFunction, unknown>;
 export declare function chatStreamingMessageToolCallFunctionFromJSON(jsonString: string): SafeParseResult<ChatStreamingMessageToolCallFunction, SDKValidationError>;
 /** @internal */

package/esm/models/chatstreamingmessagetoolcall.js

@@ -4,6 +4,14 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
+/**
+ * Tool call type
+ */
+export const ChatStreamingMessageToolCallType = {
+    Function: "function",
+};
+/** @internal */
+export const ChatStreamingMessageToolCallType$inboundSchema = z.enum(ChatStreamingMessageToolCallType);
 /** @internal */
 export const ChatStreamingMessageToolCallFunction$inboundSchema = z.object({
     name: z.string().optional(),
@@ -16,7 +24,7 @@ export function chatStreamingMessageToolCallFunctionFromJSON(jsonString) {
 export const ChatStreamingMessageToolCall$inboundSchema = z.object({
     index: z.number(),
     id: z.string().optional(),
-    type: z.literal("function").optional(),
+    type: ChatStreamingMessageToolCallType$inboundSchema.optional(),
     function: z.lazy(() => ChatStreamingMessageToolCallFunction$inboundSchema)
         .optional(),
 });

package/esm/models/chatstreamingresponsechunk.d.ts

@@ -1,31 +1,65 @@
 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 { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export type ChatStreamingResponseChunkError = {
+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;
 };
-export type ChatStreamingResponseChunkData = {
+/**
+ * Streaming chat completion chunk
+ */
+export type ChatStreamingResponseChunk = {
+    /**
+     * Unique chunk identifier
+     */
     id: string;
+    /**
+     * List of streaming chunk choices
+     */
     choices: Array<ChatStreamingChoice>;
+    /**
+     * Unix timestamp of creation
+     */
     created: number;
+    /**
+     * Model used for completion
+     */
     model: string;
-    object: "chat.completion.chunk";
-    systemFingerprint?: string | null | undefined;
-    error?: ChatStreamingResponseChunkError | undefined;
+    object: ChatStreamingResponseChunkObject;
+    /**
+     * System fingerprint
+     */
+    systemFingerprint?: string | undefined;
+    /**
+     * Error information
+     */
+    error?: ErrorT | undefined;
+    /**
+     * Token usage statistics
+     */
     usage?: ChatGenerationTokenUsage | undefined;
 };
-export type ChatStreamingResponseChunk = {
-    data: ChatStreamingResponseChunkData;
-};
 /** @internal */
-export declare const ChatStreamingResponseChunkError$inboundSchema: z.ZodType<ChatStreamingResponseChunkError, unknown>;
-export declare function chatStreamingResponseChunkErrorFromJSON(jsonString: string): SafeParseResult<ChatStreamingResponseChunkError, SDKValidationError>;
+export declare const ChatStreamingResponseChunkObject$inboundSchema: z.ZodEnum<typeof ChatStreamingResponseChunkObject>;
 /** @internal */
-export declare const ChatStreamingResponseChunkData$inboundSchema: z.ZodType<ChatStreamingResponseChunkData, unknown>;
-export declare function chatStreamingResponseChunkDataFromJSON(jsonString: string): SafeParseResult<ChatStreamingResponseChunkData, SDKValidationError>;
+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>;

package/esm/models/chatstreamingresponsechunk.js

@@ -7,48 +7,34 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { ChatGenerationTokenUsage$inboundSchema, } from "./chatgenerationtokenusage.js";
 import { ChatStreamingChoice$inboundSchema, } from "./chatstreamingchoice.js";
+export const ChatStreamingResponseChunkObject = {
+    ChatCompletionChunk: "chat.completion.chunk",
+};
 /** @internal */
-export const ChatStreamingResponseChunkError$inboundSchema = z.object({
+export const ChatStreamingResponseChunkObject$inboundSchema = z.enum(ChatStreamingResponseChunkObject);
+/** @internal */
+export const ErrorT$inboundSchema = z.object({
     message: z.string(),
     code: z.number(),
 });
-export function chatStreamingResponseChunkErrorFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => ChatStreamingResponseChunkError$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatStreamingResponseChunkError' from JSON`);
+export function errorFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ErrorT$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ErrorT' from JSON`);
 }
 /** @internal */
-export const ChatStreamingResponseChunkData$inboundSchema = z.object({
+export const ChatStreamingResponseChunk$inboundSchema = z.object({
     id: z.string(),
     choices: z.array(ChatStreamingChoice$inboundSchema),
     created: z.number(),
     model: z.string(),
-    object: z.literal("chat.completion.chunk"),
-    system_fingerprint: z.nullable(z.string()).optional(),
-    error: z.lazy(() => ChatStreamingResponseChunkError$inboundSchema).optional(),
+    object: ChatStreamingResponseChunkObject$inboundSchema,
+    system_fingerprint: z.string().optional(),
+    error: z.lazy(() => ErrorT$inboundSchema).optional(),
     usage: ChatGenerationTokenUsage$inboundSchema.optional(),
 }).transform((v) => {
     return remap$(v, {
         "system_fingerprint": "systemFingerprint",
     });
 });
-export function chatStreamingResponseChunkDataFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => ChatStreamingResponseChunkData$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatStreamingResponseChunkData' from JSON`);
-}
-/** @internal */
-export const ChatStreamingResponseChunk$inboundSchema = z.object({
-    data: z.string().transform((v, ctx) => {
-        try {
-            return JSON.parse(v);
-        }
-        catch (err) {
-            ctx.addIssue({
-                input: v,
-                code: "custom",
-                message: `malformed json: ${err}`,
-            });
-            return z.NEVER;
-        }
-    }).pipe(z.lazy(() => ChatStreamingResponseChunkData$inboundSchema)),
-});
 export function chatStreamingResponseChunkFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ChatStreamingResponseChunk$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatStreamingResponseChunk' from JSON`);
 }

package/esm/models/chatstreamoptions.d.ts

@@ -1,5 +1,13 @@
 import * as z from "zod/v4";
+/**
+ * Streaming configuration options
+ */
 export type ChatStreamOptions = {
+    /**
+     * Deprecated: This field has no effect. Full usage details are always included.
+     *
+     * @deprecated field: This will be removed in a future release, please migrate away from it as soon as possible.
+     */
     includeUsage?: boolean | undefined;
 };
 /** @internal */