@openrouter/sdk 0.1.27 → 0.2.6

package/esm/models/chatgenerationparams.js

@@ -51,10 +51,10 @@ export function chatGenerationParamsResponseFormatTextToJSON(chatGenerationParam
 }
 /** @internal */
 export const ChatGenerationParamsResponseFormatUnion$outboundSchema = z.union([
-    ResponseFormatJSONSchema$outboundSchema,
-    ResponseFormatTextGrammar$outboundSchema,
     z.lazy(() => ChatGenerationParamsResponseFormatText$outboundSchema),
     z.lazy(() => ChatGenerationParamsResponseFormatJSONObject$outboundSchema),
+    ResponseFormatJSONSchema$outboundSchema,
+    ResponseFormatTextGrammar$outboundSchema,
     z.lazy(() => ChatGenerationParamsResponseFormatPython$outboundSchema),
 ]);
 export function chatGenerationParamsResponseFormatUnionToJSON(chatGenerationParamsResponseFormatUnion) {
@@ -80,10 +80,10 @@ export const ChatGenerationParams$outboundSchema = z.object({
     presencePenalty: z.nullable(z.number()).optional(),
     reasoning: z.lazy(() => Reasoning$outboundSchema).optional(),
     responseFormat: z.union([
-        ResponseFormatJSONSchema$outboundSchema,
-        ResponseFormatTextGrammar$outboundSchema,
         z.lazy(() => ChatGenerationParamsResponseFormatText$outboundSchema),
         z.lazy(() => ChatGenerationParamsResponseFormatJSONObject$outboundSchema),
+        ResponseFormatJSONSchema$outboundSchema,
+        ResponseFormatTextGrammar$outboundSchema,
         z.lazy(() => ChatGenerationParamsResponseFormatPython$outboundSchema),
     ]).optional(),
     seed: z.nullable(z.int()).optional(),

package/esm/models/chatmessagecontentitem.d.ts

@@ -1,20 +1,11 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { ChatMessageContentItemAudio, ChatMessageContentItemAudio$Outbound } from "./chatmessagecontentitemaudio.js";
-import { ChatMessageContentItemFile, ChatMessageContentItemFile$Outbound } from "./chatmessagecontentitemfile.js";
 import { ChatMessageContentItemImage, ChatMessageContentItemImage$Outbound } from "./chatmessagecontentitemimage.js";
 import { ChatMessageContentItemText, ChatMessageContentItemText$Outbound } from "./chatmessagecontentitemtext.js";
 import { ChatMessageContentItemVideo, ChatMessageContentItemVideo$Outbound } from "./chatmessagecontentitemvideo.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export type ChatMessageContentItem = (ChatMessageContentItemText & {
-    type: "text";
-}) | (ChatMessageContentItemImage & {
-    type: "image_url";
-}) | (ChatMessageContentItemAudio & {
-    type: "input_audio";
-}) | (ChatMessageContentItemFile & {
-    type: "file";
-}) | (ChatMessageContentItemVideo & {
+export type ChatMessageContentItem = ChatMessageContentItemText | ChatMessageContentItemImage | ChatMessageContentItemAudio | (ChatMessageContentItemVideo & {
     type: "input_video";
 }) | (ChatMessageContentItemVideo & {
     type: "video_url";
@@ -22,15 +13,7 @@ export type ChatMessageContentItem = (ChatMessageContentItemText & {
 /** @internal */
 export declare const ChatMessageContentItem$inboundSchema: z.ZodType<ChatMessageContentItem, unknown>;
 /** @internal */
-export type ChatMessageContentItem$Outbound = (ChatMessageContentItemText$Outbound & {
-    type: "text";
-}) | (ChatMessageContentItemImage$Outbound & {
-    type: "image_url";
-}) | (ChatMessageContentItemAudio$Outbound & {
-    type: "input_audio";
-}) | (ChatMessageContentItemFile$Outbound & {
-    type: "file";
-}) | (ChatMessageContentItemVideo$Outbound & {
+export type ChatMessageContentItem$Outbound = ChatMessageContentItemText$Outbound | ChatMessageContentItemImage$Outbound | ChatMessageContentItemAudio$Outbound | (ChatMessageContentItemVideo$Outbound & {
     type: "input_video";
 }) | (ChatMessageContentItemVideo$Outbound & {
     type: "video_url";

package/esm/models/chatmessagecontentitem.js

@@ -4,25 +4,22 @@
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 import { ChatMessageContentItemAudio$inboundSchema, ChatMessageContentItemAudio$outboundSchema, } from "./chatmessagecontentitemaudio.js";
-import { ChatMessageContentItemFile$inboundSchema, ChatMessageContentItemFile$outboundSchema, } from "./chatmessagecontentitemfile.js";
 import { ChatMessageContentItemImage$inboundSchema, ChatMessageContentItemImage$outboundSchema, } from "./chatmessagecontentitemimage.js";
 import { ChatMessageContentItemText$inboundSchema, ChatMessageContentItemText$outboundSchema, } from "./chatmessagecontentitemtext.js";
 import { ChatMessageContentItemVideo$inboundSchema, ChatMessageContentItemVideo$outboundSchema, } from "./chatmessagecontentitemvideo.js";
 /** @internal */
 export const ChatMessageContentItem$inboundSchema = z.union([
-    ChatMessageContentItemText$inboundSchema.and(z.object({ type: z.literal("text") })),
-    ChatMessageContentItemImage$inboundSchema.and(z.object({ type: z.literal("image_url") })),
-    ChatMessageContentItemAudio$inboundSchema.and(z.object({ type: z.literal("input_audio") })),
-    ChatMessageContentItemFile$inboundSchema.and(z.object({ type: z.literal("file") })),
+    ChatMessageContentItemText$inboundSchema,
+    ChatMessageContentItemImage$inboundSchema,
+    ChatMessageContentItemAudio$inboundSchema,
     ChatMessageContentItemVideo$inboundSchema.and(z.object({ type: z.literal("input_video") })),
     z.lazy(() => ChatMessageContentItemVideo$inboundSchema).and(z.object({ type: z.literal("video_url") })),
 ]);
 /** @internal */
 export const ChatMessageContentItem$outboundSchema = z.union([
-    ChatMessageContentItemText$outboundSchema.and(z.object({ type: z.literal("text") })),
-    ChatMessageContentItemImage$outboundSchema.and(z.object({ type: z.literal("image_url") })),
-    ChatMessageContentItemAudio$outboundSchema.and(z.object({ type: z.literal("input_audio") })),
-    ChatMessageContentItemFile$outboundSchema.and(z.object({ type: z.literal("file") })),
+    ChatMessageContentItemText$outboundSchema,
+    ChatMessageContentItemImage$outboundSchema,
+    ChatMessageContentItemAudio$outboundSchema,
     ChatMessageContentItemVideo$outboundSchema.and(z.object({ type: z.literal("input_video") })),
     z.lazy(() => ChatMessageContentItemVideo$outboundSchema).and(z.object({ type: z.literal("video_url") })),
 ]);

package/esm/models/chatmessagecontentitemcachecontrol.d.ts

@@ -0,0 +1,29 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const Ttl: {
+    readonly Fivem: "5m";
+    readonly Oneh: "1h";
+};
+export type Ttl = OpenEnum<typeof Ttl>;
+export type ChatMessageContentItemCacheControl = {
+    type: "ephemeral";
+    ttl?: Ttl | undefined;
+};
+/** @internal */
+export declare const Ttl$inboundSchema: z.ZodType<Ttl, unknown>;
+/** @internal */
+export declare const Ttl$outboundSchema: z.ZodType<string, Ttl>;
+/** @internal */
+export declare const ChatMessageContentItemCacheControl$inboundSchema: z.ZodType<ChatMessageContentItemCacheControl, unknown>;
+/** @internal */
+export type ChatMessageContentItemCacheControl$Outbound = {
+    type: "ephemeral";
+    ttl?: string | undefined;
+};
+/** @internal */
+export declare const ChatMessageContentItemCacheControl$outboundSchema: z.ZodType<ChatMessageContentItemCacheControl$Outbound, ChatMessageContentItemCacheControl>;
+export declare function chatMessageContentItemCacheControlToJSON(chatMessageContentItemCacheControl: ChatMessageContentItemCacheControl): string;
+export declare function chatMessageContentItemCacheControlFromJSON(jsonString: string): SafeParseResult<ChatMessageContentItemCacheControl, SDKValidationError>;
+//# sourceMappingURL=chatmessagecontentitemcachecontrol.d.ts.map

package/esm/models/chatmessagecontentitemcachecontrol.js

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+export const Ttl = {
+    Fivem: "5m",
+    Oneh: "1h",
+};
+/** @internal */
+export const Ttl$inboundSchema = openEnums
+    .inboundSchema(Ttl);
+/** @internal */
+export const Ttl$outboundSchema = openEnums
+    .outboundSchema(Ttl);
+/** @internal */
+export const ChatMessageContentItemCacheControl$inboundSchema = z.object({
+    type: z.literal("ephemeral"),
+    ttl: Ttl$inboundSchema.optional(),
+});
+/** @internal */
+export const ChatMessageContentItemCacheControl$outboundSchema = z.object({
+    type: z.literal("ephemeral"),
+    ttl: Ttl$outboundSchema.optional(),
+});
+export function chatMessageContentItemCacheControlToJSON(chatMessageContentItemCacheControl) {
+    return JSON.stringify(ChatMessageContentItemCacheControl$outboundSchema.parse(chatMessageContentItemCacheControl));
+}
+export function chatMessageContentItemCacheControlFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatMessageContentItemCacheControl$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageContentItemCacheControl' from JSON`);
+}
+//# sourceMappingURL=chatmessagecontentitemcachecontrol.js.map

package/esm/models/chatmessagecontentitemtext.d.ts

@@ -1,9 +1,11 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
+import { ChatMessageContentItemCacheControl, ChatMessageContentItemCacheControl$Outbound } from "./chatmessagecontentitemcachecontrol.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 export type ChatMessageContentItemText = {
     type: "text";
     text: string;
+    cacheControl?: ChatMessageContentItemCacheControl | undefined;
 };
 /** @internal */
 export declare const ChatMessageContentItemText$inboundSchema: z.ZodType<ChatMessageContentItemText, unknown>;
@@ -11,6 +13,7 @@ export declare const ChatMessageContentItemText$inboundSchema: z.ZodType<ChatMes
 export type ChatMessageContentItemText$Outbound = {
     type: "text";
     text: string;
+    cache_control?: ChatMessageContentItemCacheControl$Outbound | undefined;
 };
 /** @internal */
 export declare const ChatMessageContentItemText$outboundSchema: z.ZodType<ChatMessageContentItemText$Outbound, ChatMessageContentItemText>;

package/esm/models/chatmessagecontentitemtext.js

@@ -2,16 +2,28 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
+import { ChatMessageContentItemCacheControl$inboundSchema, ChatMessageContentItemCacheControl$outboundSchema, } from "./chatmessagecontentitemcachecontrol.js";
 /** @internal */
 export const ChatMessageContentItemText$inboundSchema = z.object({
     type: z.literal("text"),
     text: z.string(),
+    cache_control: ChatMessageContentItemCacheControl$inboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "cache_control": "cacheControl",
+    });
 });
 /** @internal */
 export const ChatMessageContentItemText$outboundSchema = z.object({
     type: z.literal("text"),
     text: z.string(),
+    cacheControl: ChatMessageContentItemCacheControl$outboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        cacheControl: "cache_control",
+    });
 });
 export function chatMessageContentItemTextToJSON(chatMessageContentItemText) {
     return JSON.stringify(ChatMessageContentItemText$outboundSchema.parse(chatMessageContentItemText));

package/esm/models/chatmessagecontentitemvideo.d.ts

@@ -1,46 +1,58 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-import { VideoURL, VideoURL$Outbound } from "./videourl.js";
-export type ChatMessageContentItemVideoVideoUrlVideoUrl = {
+export type VideoUrl2 = {
     url: string;
 };
 export type ChatMessageContentItemVideoVideoURL = {
     type: "video_url";
-    videoUrl: ChatMessageContentItemVideoVideoUrlVideoUrl;
+    videoUrl: VideoUrl2;
+};
+export type VideoUrl1 = {
+    url: string;
 };
 export type ChatMessageContentItemVideoInputVideo = {
     type: "input_video";
-    videoUrl: VideoURL;
+    videoUrl: VideoUrl1;
 };
 export type ChatMessageContentItemVideo = ChatMessageContentItemVideoInputVideo | ChatMessageContentItemVideoVideoURL;
 /** @internal */
-export declare const ChatMessageContentItemVideoVideoUrlVideoUrl$inboundSchema: z.ZodType<ChatMessageContentItemVideoVideoUrlVideoUrl, unknown>;
+export declare const VideoUrl2$inboundSchema: z.ZodType<VideoUrl2, unknown>;
 /** @internal */
-export type ChatMessageContentItemVideoVideoUrlVideoUrl$Outbound = {
+export type VideoUrl2$Outbound = {
     url: string;
 };
 /** @internal */
-export declare const ChatMessageContentItemVideoVideoUrlVideoUrl$outboundSchema: z.ZodType<ChatMessageContentItemVideoVideoUrlVideoUrl$Outbound, ChatMessageContentItemVideoVideoUrlVideoUrl>;
-export declare function chatMessageContentItemVideoVideoUrlVideoUrlToJSON(chatMessageContentItemVideoVideoUrlVideoUrl: ChatMessageContentItemVideoVideoUrlVideoUrl): string;
-export declare function chatMessageContentItemVideoVideoUrlVideoUrlFromJSON(jsonString: string): SafeParseResult<ChatMessageContentItemVideoVideoUrlVideoUrl, SDKValidationError>;
+export declare const VideoUrl2$outboundSchema: z.ZodType<VideoUrl2$Outbound, VideoUrl2>;
+export declare function videoUrl2ToJSON(videoUrl2: VideoUrl2): string;
+export declare function videoUrl2FromJSON(jsonString: string): SafeParseResult<VideoUrl2, SDKValidationError>;
 /** @internal */
 export declare const ChatMessageContentItemVideoVideoURL$inboundSchema: z.ZodType<ChatMessageContentItemVideoVideoURL, unknown>;
 /** @internal */
 export type ChatMessageContentItemVideoVideoURL$Outbound = {
     type: "video_url";
-    video_url: ChatMessageContentItemVideoVideoUrlVideoUrl$Outbound;
+    video_url: VideoUrl2$Outbound;
 };
 /** @internal */
 export declare const ChatMessageContentItemVideoVideoURL$outboundSchema: z.ZodType<ChatMessageContentItemVideoVideoURL$Outbound, ChatMessageContentItemVideoVideoURL>;
 export declare function chatMessageContentItemVideoVideoURLToJSON(chatMessageContentItemVideoVideoURL: ChatMessageContentItemVideoVideoURL): string;
 export declare function chatMessageContentItemVideoVideoURLFromJSON(jsonString: string): SafeParseResult<ChatMessageContentItemVideoVideoURL, SDKValidationError>;
 /** @internal */
+export declare const VideoUrl1$inboundSchema: z.ZodType<VideoUrl1, unknown>;
+/** @internal */
+export type VideoUrl1$Outbound = {
+    url: string;
+};
+/** @internal */
+export declare const VideoUrl1$outboundSchema: z.ZodType<VideoUrl1$Outbound, VideoUrl1>;
+export declare function videoUrl1ToJSON(videoUrl1: VideoUrl1): string;
+export declare function videoUrl1FromJSON(jsonString: string): SafeParseResult<VideoUrl1, SDKValidationError>;
+/** @internal */
 export declare const ChatMessageContentItemVideoInputVideo$inboundSchema: z.ZodType<ChatMessageContentItemVideoInputVideo, unknown>;
 /** @internal */
 export type ChatMessageContentItemVideoInputVideo$Outbound = {
     type: "input_video";
-    video_url: VideoURL$Outbound;
+    video_url: VideoUrl1$Outbound;
 };
 /** @internal */
 export declare const ChatMessageContentItemVideoInputVideo$outboundSchema: z.ZodType<ChatMessageContentItemVideoInputVideo$Outbound, ChatMessageContentItemVideoInputVideo>;

package/esm/models/chatmessagecontentitemvideo.js

@@ -4,25 +4,24 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-import { VideoURL$inboundSchema, VideoURL$outboundSchema, } from "./videourl.js";
 /** @internal */
-export const ChatMessageContentItemVideoVideoUrlVideoUrl$inboundSchema = z.object({
+export const VideoUrl2$inboundSchema = z.object({
     url: z.string(),
 });
 /** @internal */
-export const ChatMessageContentItemVideoVideoUrlVideoUrl$outboundSchema = z.object({
+export const VideoUrl2$outboundSchema = z.object({
     url: z.string(),
 });
-export function chatMessageContentItemVideoVideoUrlVideoUrlToJSON(chatMessageContentItemVideoVideoUrlVideoUrl) {
-    return JSON.stringify(ChatMessageContentItemVideoVideoUrlVideoUrl$outboundSchema.parse(chatMessageContentItemVideoVideoUrlVideoUrl));
+export function videoUrl2ToJSON(videoUrl2) {
+    return JSON.stringify(VideoUrl2$outboundSchema.parse(videoUrl2));
 }
-export function chatMessageContentItemVideoVideoUrlVideoUrlFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => ChatMessageContentItemVideoVideoUrlVideoUrl$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageContentItemVideoVideoUrlVideoUrl' from JSON`);
+export function videoUrl2FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => VideoUrl2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'VideoUrl2' from JSON`);
 }
 /** @internal */
 export const ChatMessageContentItemVideoVideoURL$inboundSchema = z.object({
     type: z.literal("video_url"),
-    video_url: z.lazy(() => ChatMessageContentItemVideoVideoUrlVideoUrl$inboundSchema),
+    video_url: z.lazy(() => VideoUrl2$inboundSchema),
 }).transform((v) => {
     return remap$(v, {
         "video_url": "videoUrl",
@@ -31,7 +30,7 @@ export const ChatMessageContentItemVideoVideoURL$inboundSchema = z.object({
 /** @internal */
 export const ChatMessageContentItemVideoVideoURL$outboundSchema = z.object({
     type: z.literal("video_url"),
-    videoUrl: z.lazy(() => ChatMessageContentItemVideoVideoUrlVideoUrl$outboundSchema),
+    videoUrl: z.lazy(() => VideoUrl2$outboundSchema),
 }).transform((v) => {
     return remap$(v, {
         videoUrl: "video_url",
@@ -44,9 +43,23 @@ export function chatMessageContentItemVideoVideoURLFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ChatMessageContentItemVideoVideoURL$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageContentItemVideoVideoURL' from JSON`);
 }
 /** @internal */
+export const VideoUrl1$inboundSchema = z.object({
+    url: z.string(),
+});
+/** @internal */
+export const VideoUrl1$outboundSchema = z.object({
+    url: z.string(),
+});
+export function videoUrl1ToJSON(videoUrl1) {
+    return JSON.stringify(VideoUrl1$outboundSchema.parse(videoUrl1));
+}
+export function videoUrl1FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => VideoUrl1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'VideoUrl1' from JSON`);
+}
+/** @internal */
 export const ChatMessageContentItemVideoInputVideo$inboundSchema = z.object({
     type: z.literal("input_video"),
-    video_url: VideoURL$inboundSchema,
+    video_url: z.lazy(() => VideoUrl1$inboundSchema),
 }).transform((v) => {
     return remap$(v, {
         "video_url": "videoUrl",
@@ -55,7 +68,7 @@ export const ChatMessageContentItemVideoInputVideo$inboundSchema = z.object({
 /** @internal */
 export const ChatMessageContentItemVideoInputVideo$outboundSchema = z.object({
     type: z.literal("input_video"),
-    videoUrl: VideoURL$outboundSchema,
+    videoUrl: z.lazy(() => VideoUrl1$outboundSchema),
 }).transform((v) => {
     return remap$(v, {
         videoUrl: "video_url",

package/esm/models/chatresponsechoice.d.ts

@@ -1,36 +1,16 @@
 import * as z from "zod/v4";
-import { OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { AssistantMessage } from "./assistantmessage.js";
+import { ChatCompletionFinishReason } from "./chatcompletionfinishreason.js";
 import { ChatMessageTokenLogprobs } from "./chatmessagetokenlogprobs.js";
-import { ChatStreamingMessageChunk } from "./chatstreamingmessagechunk.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export declare const ChatCompletionFinishReason: {
-    readonly ToolCalls: "tool_calls";
-    readonly Stop: "stop";
-    readonly Length: "length";
-    readonly ContentFilter: "content_filter";
-    readonly Error: "error";
-};
-export type ChatCompletionFinishReason = OpenEnum<typeof ChatCompletionFinishReason>;
 export type ChatResponseChoice = {
     finishReason: ChatCompletionFinishReason | null;
     index: number;
     message: AssistantMessage;
     logprobs?: ChatMessageTokenLogprobs | null | undefined;
 };
-export type ChatStreamingChoice = {
-    delta: ChatStreamingMessageChunk;
-    finishReason: ChatCompletionFinishReason | null;
-    index: number;
-    logprobs?: ChatMessageTokenLogprobs | null | undefined;
-};
-/** @internal */
-export declare const ChatCompletionFinishReason$inboundSchema: z.ZodType<ChatCompletionFinishReason, unknown>;
 /** @internal */
 export declare const ChatResponseChoice$inboundSchema: z.ZodType<ChatResponseChoice, unknown>;
 export declare function chatResponseChoiceFromJSON(jsonString: string): SafeParseResult<ChatResponseChoice, SDKValidationError>;
-/** @internal */
-export declare const ChatStreamingChoice$inboundSchema: z.ZodType<ChatStreamingChoice, unknown>;
-export declare function chatStreamingChoiceFromJSON(jsonString: string): SafeParseResult<ChatStreamingChoice, SDKValidationError>;
 //# sourceMappingURL=chatresponsechoice.d.ts.map

package/esm/models/chatresponsechoice.js

@@ -4,19 +4,9 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-import * as openEnums from "../types/enums.js";
 import { AssistantMessage$inboundSchema, } from "./assistantmessage.js";
+import { ChatCompletionFinishReason$inboundSchema, } from "./chatcompletionfinishreason.js";
 import { ChatMessageTokenLogprobs$inboundSchema, } from "./chatmessagetokenlogprobs.js";
-import { ChatStreamingMessageChunk$inboundSchema, } from "./chatstreamingmessagechunk.js";
-export const ChatCompletionFinishReason = {
-    ToolCalls: "tool_calls",
-    Stop: "stop",
-    Length: "length",
-    ContentFilter: "content_filter",
-    Error: "error",
-};
-/** @internal */
-export const ChatCompletionFinishReason$inboundSchema = openEnums.inboundSchema(ChatCompletionFinishReason);
 /** @internal */
 export const ChatResponseChoice$inboundSchema = z.object({
     finish_reason: z.nullable(ChatCompletionFinishReason$inboundSchema),
@@ -31,18 +21,4 @@ export const ChatResponseChoice$inboundSchema = z.object({
 export function chatResponseChoiceFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ChatResponseChoice$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatResponseChoice' from JSON`);
 }
-/** @internal */
-export const ChatStreamingChoice$inboundSchema = z.object({
-    delta: ChatStreamingMessageChunk$inboundSchema,
-    finish_reason: z.nullable(ChatCompletionFinishReason$inboundSchema),
-    index: z.number(),
-    logprobs: z.nullable(ChatMessageTokenLogprobs$inboundSchema).optional(),
-}).transform((v) => {
-    return remap$(v, {
-        "finish_reason": "finishReason",
-    });
-});
-export function chatStreamingChoiceFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => ChatStreamingChoice$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatStreamingChoice' from JSON`);
-}
 //# sourceMappingURL=chatresponsechoice.js.map

package/esm/models/chatstreamingchoice.d.ts

@@ -0,0 +1,16 @@
+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";
+export type ChatStreamingChoice = {
+    delta: ChatStreamingMessageChunk;
+    finishReason: ChatCompletionFinishReason | null;
+    index: number;
+    logprobs?: ChatMessageTokenLogprobs | null | undefined;
+};
+/** @internal */
+export declare const ChatStreamingChoice$inboundSchema: z.ZodType<ChatStreamingChoice, unknown>;
+export declare function chatStreamingChoiceFromJSON(jsonString: string): SafeParseResult<ChatStreamingChoice, SDKValidationError>;
+//# sourceMappingURL=chatstreamingchoice.d.ts.map

package/esm/models/chatstreamingchoice.js

@@ -0,0 +1,24 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+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),
+    index: z.number(),
+    logprobs: z.nullable(ChatMessageTokenLogprobs$inboundSchema).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "finish_reason": "finishReason",
+    });
+});
+export function chatStreamingChoiceFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatStreamingChoice$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatStreamingChoice' from JSON`);
+}
+//# sourceMappingURL=chatstreamingchoice.js.map

package/esm/models/chatstreamingresponsechunk.d.ts

@@ -1,7 +1,7 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { ChatGenerationTokenUsage } from "./chatgenerationtokenusage.js";
-import { ChatStreamingChoice } from "./chatresponsechoice.js";
+import { ChatStreamingChoice } from "./chatstreamingchoice.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 export type ChatStreamingResponseChunkError = {
     message: string;

package/esm/models/chatstreamingresponsechunk.js

@@ -5,7 +5,7 @@ import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { ChatGenerationTokenUsage$inboundSchema, } from "./chatgenerationtokenusage.js";
-import { ChatStreamingChoice$inboundSchema, } from "./chatresponsechoice.js";
+import { ChatStreamingChoice$inboundSchema, } from "./chatstreamingchoice.js";
 /** @internal */
 export const ChatStreamingResponseChunkError$inboundSchema = z.object({
     message: z.string(),

package/esm/models/completionchoice.d.ts

@@ -14,6 +14,8 @@ export type CompletionChoice = {
     index: number;
     logprobs: CompletionLogprobs | null;
     finishReason: CompletionFinishReason | null;
+    nativeFinishReason?: string | undefined;
+    reasoning?: string | null | undefined;
 };
 /** @internal */
 export declare const CompletionFinishReason$inboundSchema: z.ZodType<CompletionFinishReason, unknown>;

package/esm/models/completionchoice.js

@@ -19,9 +19,12 @@ export const CompletionChoice$inboundSchema = z.object({
     index: z.number(),
     logprobs: z.nullable(CompletionLogprobs$inboundSchema),
     finish_reason: z.nullable(CompletionFinishReason$inboundSchema),
+    native_finish_reason: z.string().optional(),
+    reasoning: z.nullable(z.string()).optional(),
 }).transform((v) => {
     return remap$(v, {
         "finish_reason": "finishReason",
+        "native_finish_reason": "nativeFinishReason",
     });
 });
 export function completionChoiceFromJSON(jsonString) {

package/esm/models/completioncreateparams.d.ts

@@ -15,7 +15,7 @@ export type CompletionCreateParamsResponseFormatJSONObject = {
 export type CompletionCreateParamsResponseFormatText = {
     type: "text";
 };
-export type CompletionCreateParamsResponseFormatUnion = ResponseFormatJSONSchema | ResponseFormatTextGrammar | CompletionCreateParamsResponseFormatText | CompletionCreateParamsResponseFormatJSONObject | CompletionCreateParamsResponseFormatPython;
+export type CompletionCreateParamsResponseFormatUnion = CompletionCreateParamsResponseFormatText | CompletionCreateParamsResponseFormatJSONObject | ResponseFormatJSONSchema | ResponseFormatTextGrammar | CompletionCreateParamsResponseFormatPython;
 export type CompletionCreateParams = {
     model?: string | undefined;
     models?: Array<string> | undefined;
@@ -41,7 +41,7 @@ export type CompletionCreateParams = {
     metadata?: {
         [k: string]: string;
     } | null | undefined;
-    responseFormat?: ResponseFormatJSONSchema | ResponseFormatTextGrammar | CompletionCreateParamsResponseFormatText | CompletionCreateParamsResponseFormatJSONObject | CompletionCreateParamsResponseFormatPython | null | undefined;
+    responseFormat?: CompletionCreateParamsResponseFormatText | CompletionCreateParamsResponseFormatJSONObject | ResponseFormatJSONSchema | ResponseFormatTextGrammar | CompletionCreateParamsResponseFormatPython | null | undefined;
 };
 /** @internal */
 export type Prompt$Outbound = string | Array<string> | Array<number> | Array<Array<number>>;
@@ -82,7 +82,7 @@ export type CompletionCreateParamsResponseFormatText$Outbound = {
 export declare const CompletionCreateParamsResponseFormatText$outboundSchema: z.ZodType<CompletionCreateParamsResponseFormatText$Outbound, CompletionCreateParamsResponseFormatText>;
 export declare function completionCreateParamsResponseFormatTextToJSON(completionCreateParamsResponseFormatText: CompletionCreateParamsResponseFormatText): string;
 /** @internal */
-export type CompletionCreateParamsResponseFormatUnion$Outbound = ResponseFormatJSONSchema$Outbound | ResponseFormatTextGrammar$Outbound | CompletionCreateParamsResponseFormatText$Outbound | CompletionCreateParamsResponseFormatJSONObject$Outbound | CompletionCreateParamsResponseFormatPython$Outbound;
+export type CompletionCreateParamsResponseFormatUnion$Outbound = CompletionCreateParamsResponseFormatText$Outbound | CompletionCreateParamsResponseFormatJSONObject$Outbound | ResponseFormatJSONSchema$Outbound | ResponseFormatTextGrammar$Outbound | CompletionCreateParamsResponseFormatPython$Outbound;
 /** @internal */
 export declare const CompletionCreateParamsResponseFormatUnion$outboundSchema: z.ZodType<CompletionCreateParamsResponseFormatUnion$Outbound, CompletionCreateParamsResponseFormatUnion>;
 export declare function completionCreateParamsResponseFormatUnionToJSON(completionCreateParamsResponseFormatUnion: CompletionCreateParamsResponseFormatUnion): string;
@@ -112,7 +112,7 @@ export type CompletionCreateParams$Outbound = {
     metadata?: {
         [k: string]: string;
     } | null | undefined;
-    response_format?: ResponseFormatJSONSchema$Outbound | ResponseFormatTextGrammar$Outbound | CompletionCreateParamsResponseFormatText$Outbound | CompletionCreateParamsResponseFormatJSONObject$Outbound | CompletionCreateParamsResponseFormatPython$Outbound | null | undefined;
+    response_format?: CompletionCreateParamsResponseFormatText$Outbound | CompletionCreateParamsResponseFormatJSONObject$Outbound | ResponseFormatJSONSchema$Outbound | ResponseFormatTextGrammar$Outbound | CompletionCreateParamsResponseFormatPython$Outbound | null | undefined;
 };
 /** @internal */
 export declare const CompletionCreateParams$outboundSchema: z.ZodType<CompletionCreateParams$Outbound, CompletionCreateParams>;

package/esm/models/completioncreateparams.js

@@ -55,10 +55,10 @@ export function completionCreateParamsResponseFormatTextToJSON(completionCreateP
 }
 /** @internal */
 export const CompletionCreateParamsResponseFormatUnion$outboundSchema = z.union([
-    ResponseFormatJSONSchema$outboundSchema,
-    ResponseFormatTextGrammar$outboundSchema,
     z.lazy(() => CompletionCreateParamsResponseFormatText$outboundSchema),
     z.lazy(() => CompletionCreateParamsResponseFormatJSONObject$outboundSchema),
+    ResponseFormatJSONSchema$outboundSchema,
+    ResponseFormatTextGrammar$outboundSchema,
     z.lazy(() => CompletionCreateParamsResponseFormatPython$outboundSchema),
 ]);
 export function completionCreateParamsResponseFormatUnionToJSON(completionCreateParamsResponseFormatUnion) {
@@ -93,10 +93,10 @@ export const CompletionCreateParams$outboundSchema = z.object({
     user: z.string().optional(),
     metadata: z.nullable(z.record(z.string(), z.string())).optional(),
     responseFormat: z.nullable(z.union([
-        ResponseFormatJSONSchema$outboundSchema,
-        ResponseFormatTextGrammar$outboundSchema,
         z.lazy(() => CompletionCreateParamsResponseFormatText$outboundSchema),
         z.lazy(() => CompletionCreateParamsResponseFormatJSONObject$outboundSchema),
+        ResponseFormatJSONSchema$outboundSchema,
+        ResponseFormatTextGrammar$outboundSchema,
         z.lazy(() => CompletionCreateParamsResponseFormatPython$outboundSchema),
     ])).optional(),
 }).transform((v) => {

package/esm/models/completionresponse.d.ts

@@ -8,6 +8,7 @@ export type CompletionResponse = {
     object: "text_completion";
     created: number;
     model: string;
+    provider?: string | undefined;
     systemFingerprint?: string | undefined;
     choices: Array<CompletionChoice>;
     usage?: CompletionUsage | undefined;

package/esm/models/completionresponse.js

@@ -12,6 +12,7 @@ export const CompletionResponse$inboundSchema = z.object({
     object: z.literal("text_completion"),
     created: z.number(),
     model: z.string(),
+    provider: z.string().optional(),
     system_fingerprint: z.string().optional(),
     choices: z.array(CompletionChoice$inboundSchema),
     usage: CompletionUsage$inboundSchema.optional(),

package/esm/models/filecitation.d.ts

@@ -1,26 +1,17 @@
 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 FileCitationType: {
-    readonly FileCitation: "file_citation";
-};
-export type FileCitationType = ClosedEnum<typeof FileCitationType>;
 export type FileCitation = {
-    type: FileCitationType;
+    type: "file_citation";
     fileId: string;
     filename: string;
     index: number;
 };
 /** @internal */
-export declare const FileCitationType$inboundSchema: z.ZodEnum<typeof FileCitationType>;
-/** @internal */
-export declare const FileCitationType$outboundSchema: z.ZodEnum<typeof FileCitationType>;
-/** @internal */
 export declare const FileCitation$inboundSchema: z.ZodType<FileCitation, unknown>;
 /** @internal */
 export type FileCitation$Outbound = {
-    type: string;
+    type: "file_citation";
     file_id: string;
     filename: string;
     index: number;