@openrouter/sdk 0.1.11 → 0.1.17

package/esm/lib/config.d.ts

@@ -37,8 +37,8 @@ export declare function serverURLFromOptions(options: SDKOptions): URL | null;
 export declare const SDK_METADATA: {
     readonly language: "typescript";
     readonly openapiDocVersion: "1.0.0";
-    readonly sdkVersion: "0.1.11";
-    readonly genVersion: "2.750.0";
-    readonly userAgent: "speakeasy-sdk/typescript 0.1.11 2.750.0 1.0.0 @openrouter/sdk";
+    readonly sdkVersion: "0.1.17";
+    readonly genVersion: "2.755.9";
+    readonly userAgent: "speakeasy-sdk/typescript 0.1.17 2.755.9 1.0.0 @openrouter/sdk";
 };
 //# sourceMappingURL=config.d.ts.map

package/esm/lib/config.js

@@ -25,8 +25,8 @@ export function serverURLFromOptions(options) {
 export const SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.0.0",
-    sdkVersion: "0.1.11",
-    genVersion: "2.750.0",
-    userAgent: "speakeasy-sdk/typescript 0.1.11 2.750.0 1.0.0 @openrouter/sdk",
+    sdkVersion: "0.1.17",
+    genVersion: "2.755.9",
+    userAgent: "speakeasy-sdk/typescript 0.1.17 2.755.9 1.0.0 @openrouter/sdk",
 };
 //# sourceMappingURL=config.js.map

package/esm/models/chatgenerationparams.d.ts

@@ -7,6 +7,7 @@ import { ResponseFormatJSONSchema, ResponseFormatJSONSchema$Outbound } from "./r
 import { ResponseFormatTextGrammar, ResponseFormatTextGrammar$Outbound } from "./responseformattextgrammar.js";
 import { ToolDefinitionJson, ToolDefinitionJson$Outbound } from "./tooldefinitionjson.js";
 export declare const Effort: {
+    readonly None: "none";
     readonly Minimal: "minimal";
     readonly Low: "low";
     readonly Medium: "medium";

package/esm/models/chatgenerationparams.js

@@ -11,6 +11,7 @@ import { ResponseFormatJSONSchema$outboundSchema, } from "./responseformatjsonsc
 import { ResponseFormatTextGrammar$outboundSchema, } from "./responseformattextgrammar.js";
 import { ToolDefinitionJson$outboundSchema, } from "./tooldefinitionjson.js";
 export const Effort = {
+    None: "none",
     Minimal: "minimal",
     Low: "low",
     Medium: "medium",

package/esm/models/chatmessagecontentitem.d.ts

@@ -1,6 +1,7 @@
 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";
@@ -11,8 +12,12 @@ export type ChatMessageContentItem = (ChatMessageContentItemText & {
     type: "image_url";
 }) | (ChatMessageContentItemAudio & {
     type: "input_audio";
+}) | (ChatMessageContentItemFile & {
+    type: "file";
 }) | (ChatMessageContentItemVideo & {
     type: "input_video";
+}) | (ChatMessageContentItemVideo & {
+    type: "video_url";
 });
 /** @internal */
 export declare const ChatMessageContentItem$inboundSchema: z.ZodType<ChatMessageContentItem, unknown>;
@@ -23,8 +28,12 @@ export type ChatMessageContentItem$Outbound = (ChatMessageContentItemText$Outbou
     type: "image_url";
 }) | (ChatMessageContentItemAudio$Outbound & {
     type: "input_audio";
+}) | (ChatMessageContentItemFile$Outbound & {
+    type: "file";
 }) | (ChatMessageContentItemVideo$Outbound & {
     type: "input_video";
+}) | (ChatMessageContentItemVideo$Outbound & {
+    type: "video_url";
 });
 /** @internal */
 export declare const ChatMessageContentItem$outboundSchema: z.ZodType<ChatMessageContentItem$Outbound, ChatMessageContentItem>;

package/esm/models/chatmessagecontentitem.js

@@ -4,6 +4,7 @@
 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";
@@ -12,14 +13,18 @@ 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") })),
     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") })),
     ChatMessageContentItemVideo$outboundSchema.and(z.object({ type: z.literal("input_video") })),
+    z.lazy(() => ChatMessageContentItemVideo$outboundSchema).and(z.object({ type: z.literal("video_url") })),
 ]);
 export function chatMessageContentItemToJSON(chatMessageContentItem) {
     return JSON.stringify(ChatMessageContentItem$outboundSchema.parse(chatMessageContentItem));

package/esm/models/chatmessagecontentitemfile.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 FileT = {
+    fileData: string;
+    fileId?: string | undefined;
+    filename?: string | undefined;
+};
+export type ChatMessageContentItemFile = {
+    type: "file";
+    file: FileT;
+};
+/** @internal */
+export declare const FileT$inboundSchema: z.ZodType<FileT, unknown>;
+/** @internal */
+export type FileT$Outbound = {
+    file_data: string;
+    file_id?: string | undefined;
+    filename?: string | undefined;
+};
+/** @internal */
+export declare const FileT$outboundSchema: z.ZodType<FileT$Outbound, FileT>;
+export declare function fileToJSON(fileT: FileT): string;
+export declare function fileFromJSON(jsonString: string): SafeParseResult<FileT, SDKValidationError>;
+/** @internal */
+export declare const ChatMessageContentItemFile$inboundSchema: z.ZodType<ChatMessageContentItemFile, unknown>;
+/** @internal */
+export type ChatMessageContentItemFile$Outbound = {
+    type: "file";
+    file: FileT$Outbound;
+};
+/** @internal */
+export declare const ChatMessageContentItemFile$outboundSchema: z.ZodType<ChatMessageContentItemFile$Outbound, ChatMessageContentItemFile>;
+export declare function chatMessageContentItemFileToJSON(chatMessageContentItemFile: ChatMessageContentItemFile): string;
+export declare function chatMessageContentItemFileFromJSON(jsonString: string): SafeParseResult<ChatMessageContentItemFile, SDKValidationError>;
+//# sourceMappingURL=chatmessagecontentitemfile.d.ts.map

package/esm/models/chatmessagecontentitemfile.js

@@ -0,0 +1,51 @@
+/*
+ * 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";
+/** @internal */
+export const FileT$inboundSchema = z.object({
+    file_data: z.string(),
+    file_id: z.string().optional(),
+    filename: z.string().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "file_data": "fileData",
+        "file_id": "fileId",
+    });
+});
+/** @internal */
+export const FileT$outboundSchema = z.object({
+    fileData: z.string(),
+    fileId: z.string().optional(),
+    filename: z.string().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        fileData: "file_data",
+        fileId: "file_id",
+    });
+});
+export function fileToJSON(fileT) {
+    return JSON.stringify(FileT$outboundSchema.parse(fileT));
+}
+export function fileFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => FileT$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FileT' from JSON`);
+}
+/** @internal */
+export const ChatMessageContentItemFile$inboundSchema = z.object({
+    type: z.literal("file"),
+    file: z.lazy(() => FileT$inboundSchema),
+});
+/** @internal */
+export const ChatMessageContentItemFile$outboundSchema = z.object({
+    type: z.literal("file"),
+    file: z.lazy(() => FileT$outboundSchema),
+});
+export function chatMessageContentItemFileToJSON(chatMessageContentItemFile) {
+    return JSON.stringify(ChatMessageContentItemFile$outboundSchema.parse(chatMessageContentItemFile));
+}
+export function chatMessageContentItemFileFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatMessageContentItemFile$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageContentItemFile' from JSON`);
+}
+//# sourceMappingURL=chatmessagecontentitemfile.js.map

package/esm/models/chatmessagecontentitemvideo.d.ts

@@ -1,31 +1,56 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export type VideoUrl = {
+import { VideoURL, VideoURL$Outbound } from "./videourl.js";
+export type ChatMessageContentItemVideoVideoUrlVideoUrl = {
     url: string;
 };
-export type ChatMessageContentItemVideo = {
+export type ChatMessageContentItemVideoVideoURL = {
+    type: "video_url";
+    videoUrl: ChatMessageContentItemVideoVideoUrlVideoUrl;
+};
+export type ChatMessageContentItemVideoInputVideo = {
     type: "input_video";
-    videoUrl: VideoUrl;
+    videoUrl: VideoURL;
 };
+export type ChatMessageContentItemVideo = ChatMessageContentItemVideoInputVideo | ChatMessageContentItemVideoVideoURL;
 /** @internal */
-export declare const VideoUrl$inboundSchema: z.ZodType<VideoUrl, unknown>;
+export declare const ChatMessageContentItemVideoVideoUrlVideoUrl$inboundSchema: z.ZodType<ChatMessageContentItemVideoVideoUrlVideoUrl, unknown>;
 /** @internal */
-export type VideoUrl$Outbound = {
+export type ChatMessageContentItemVideoVideoUrlVideoUrl$Outbound = {
     url: string;
 };
 /** @internal */
-export declare const VideoUrl$outboundSchema: z.ZodType<VideoUrl$Outbound, VideoUrl>;
-export declare function videoUrlToJSON(videoUrl: VideoUrl): string;
-export declare function videoUrlFromJSON(jsonString: string): SafeParseResult<VideoUrl, SDKValidationError>;
+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>;
 /** @internal */
-export declare const ChatMessageContentItemVideo$inboundSchema: z.ZodType<ChatMessageContentItemVideo, unknown>;
+export declare const ChatMessageContentItemVideoVideoURL$inboundSchema: z.ZodType<ChatMessageContentItemVideoVideoURL, unknown>;
+/** @internal */
+export type ChatMessageContentItemVideoVideoURL$Outbound = {
+    type: "video_url";
+    video_url: ChatMessageContentItemVideoVideoUrlVideoUrl$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 type ChatMessageContentItemVideo$Outbound = {
+export declare const ChatMessageContentItemVideoInputVideo$inboundSchema: z.ZodType<ChatMessageContentItemVideoInputVideo, unknown>;
+/** @internal */
+export type ChatMessageContentItemVideoInputVideo$Outbound = {
     type: "input_video";
-    video_url: VideoUrl$Outbound;
+    video_url: VideoURL$Outbound;
 };
 /** @internal */
+export declare const ChatMessageContentItemVideoInputVideo$outboundSchema: z.ZodType<ChatMessageContentItemVideoInputVideo$Outbound, ChatMessageContentItemVideoInputVideo>;
+export declare function chatMessageContentItemVideoInputVideoToJSON(chatMessageContentItemVideoInputVideo: ChatMessageContentItemVideoInputVideo): string;
+export declare function chatMessageContentItemVideoInputVideoFromJSON(jsonString: string): SafeParseResult<ChatMessageContentItemVideoInputVideo, SDKValidationError>;
+/** @internal */
+export declare const ChatMessageContentItemVideo$inboundSchema: z.ZodType<ChatMessageContentItemVideo, unknown>;
+/** @internal */
+export type ChatMessageContentItemVideo$Outbound = ChatMessageContentItemVideoInputVideo$Outbound | ChatMessageContentItemVideoVideoURL$Outbound;
+/** @internal */
 export declare const ChatMessageContentItemVideo$outboundSchema: z.ZodType<ChatMessageContentItemVideo$Outbound, ChatMessageContentItemVideo>;
 export declare function chatMessageContentItemVideoToJSON(chatMessageContentItemVideo: ChatMessageContentItemVideo): string;
 export declare function chatMessageContentItemVideoFromJSON(jsonString: string): SafeParseResult<ChatMessageContentItemVideo, SDKValidationError>;

package/esm/models/chatmessagecontentitemvideo.js

@@ -4,39 +4,79 @@
 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 VideoUrl$inboundSchema = z.object({
+export const ChatMessageContentItemVideoVideoUrlVideoUrl$inboundSchema = z.object({
     url: z.string(),
 });
 /** @internal */
-export const VideoUrl$outboundSchema = z
-    .object({
+export const ChatMessageContentItemVideoVideoUrlVideoUrl$outboundSchema = z.object({
     url: z.string(),
 });
-export function videoUrlToJSON(videoUrl) {
-    return JSON.stringify(VideoUrl$outboundSchema.parse(videoUrl));
+export function chatMessageContentItemVideoVideoUrlVideoUrlToJSON(chatMessageContentItemVideoVideoUrlVideoUrl) {
+    return JSON.stringify(ChatMessageContentItemVideoVideoUrlVideoUrl$outboundSchema.parse(chatMessageContentItemVideoVideoUrlVideoUrl));
 }
-export function videoUrlFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => VideoUrl$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'VideoUrl' from JSON`);
+export function chatMessageContentItemVideoVideoUrlVideoUrlFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatMessageContentItemVideoVideoUrlVideoUrl$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageContentItemVideoVideoUrlVideoUrl' from JSON`);
 }
 /** @internal */
-export const ChatMessageContentItemVideo$inboundSchema = z.object({
+export const ChatMessageContentItemVideoVideoURL$inboundSchema = z.object({
+    type: z.literal("video_url"),
+    video_url: z.lazy(() => ChatMessageContentItemVideoVideoUrlVideoUrl$inboundSchema),
+}).transform((v) => {
+    return remap$(v, {
+        "video_url": "videoUrl",
+    });
+});
+/** @internal */
+export const ChatMessageContentItemVideoVideoURL$outboundSchema = z.object({
+    type: z.literal("video_url"),
+    videoUrl: z.lazy(() => ChatMessageContentItemVideoVideoUrlVideoUrl$outboundSchema),
+}).transform((v) => {
+    return remap$(v, {
+        videoUrl: "video_url",
+    });
+});
+export function chatMessageContentItemVideoVideoURLToJSON(chatMessageContentItemVideoVideoURL) {
+    return JSON.stringify(ChatMessageContentItemVideoVideoURL$outboundSchema.parse(chatMessageContentItemVideoVideoURL));
+}
+export function chatMessageContentItemVideoVideoURLFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatMessageContentItemVideoVideoURL$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageContentItemVideoVideoURL' from JSON`);
+}
+/** @internal */
+export const ChatMessageContentItemVideoInputVideo$inboundSchema = z.object({
     type: z.literal("input_video"),
-    video_url: z.lazy(() => VideoUrl$inboundSchema),
+    video_url: VideoURL$inboundSchema,
 }).transform((v) => {
     return remap$(v, {
         "video_url": "videoUrl",
     });
 });
 /** @internal */
-export const ChatMessageContentItemVideo$outboundSchema = z.object({
+export const ChatMessageContentItemVideoInputVideo$outboundSchema = z.object({
     type: z.literal("input_video"),
-    videoUrl: z.lazy(() => VideoUrl$outboundSchema),
+    videoUrl: VideoURL$outboundSchema,
 }).transform((v) => {
     return remap$(v, {
         videoUrl: "video_url",
     });
 });
+export function chatMessageContentItemVideoInputVideoToJSON(chatMessageContentItemVideoInputVideo) {
+    return JSON.stringify(ChatMessageContentItemVideoInputVideo$outboundSchema.parse(chatMessageContentItemVideoInputVideo));
+}
+export function chatMessageContentItemVideoInputVideoFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatMessageContentItemVideoInputVideo$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageContentItemVideoInputVideo' from JSON`);
+}
+/** @internal */
+export const ChatMessageContentItemVideo$inboundSchema = z.union([
+    z.lazy(() => ChatMessageContentItemVideoInputVideo$inboundSchema),
+    z.lazy(() => ChatMessageContentItemVideoVideoURL$inboundSchema),
+]);
+/** @internal */
+export const ChatMessageContentItemVideo$outboundSchema = z.union([
+    z.lazy(() => ChatMessageContentItemVideoInputVideo$outboundSchema),
+    z.lazy(() => ChatMessageContentItemVideoVideoURL$outboundSchema),
+]);
 export function chatMessageContentItemVideoToJSON(chatMessageContentItemVideo) {
     return JSON.stringify(ChatMessageContentItemVideo$outboundSchema.parse(chatMessageContentItemVideo));
 }

package/esm/models/chatresponsechoice.d.ts

@@ -1,16 +1,36 @@
 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,9 +4,19 @@
 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),
@@ -21,4 +31,18 @@ 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/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 "./chatstreamingchoice.js";
+import { ChatStreamingChoice } from "./chatresponsechoice.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 "./chatstreamingchoice.js";
+import { ChatStreamingChoice$inboundSchema, } from "./chatresponsechoice.js";
 /** @internal */
 export const ChatStreamingResponseChunkError$inboundSchema = z.object({
     message: z.string(),

package/esm/models/datacollection.d.ts

@@ -0,0 +1,26 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+/**
+ * Data collection setting. If no available model provider meets the requirement, your request will return an error.
+ *
+ * @remarks
+ * - allow: (default) allow providers which store user data non-transiently and may train on it
+ *
+ * - deny: use only providers which do not collect user data.
+ */
+export declare const DataCollection: {
+    readonly Deny: "deny";
+    readonly Allow: "allow";
+};
+/**
+ * Data collection setting. If no available model provider meets the requirement, your request will return an error.
+ *
+ * @remarks
+ * - allow: (default) allow providers which store user data non-transiently and may train on it
+ *
+ * - deny: use only providers which do not collect user data.
+ */
+export type DataCollection = OpenEnum<typeof DataCollection>;
+/** @internal */
+export declare const DataCollection$outboundSchema: z.ZodType<string, DataCollection>;
+//# sourceMappingURL=datacollection.d.ts.map

package/esm/models/datacollection.js

@@ -0,0 +1,19 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as openEnums from "../types/enums.js";
+/**
+ * Data collection setting. If no available model provider meets the requirement, your request will return an error.
+ *
+ * @remarks
+ * - allow: (default) allow providers which store user data non-transiently and may train on it
+ *
+ * - deny: use only providers which do not collect user data.
+ */
+export const DataCollection = {
+    Deny: "deny",
+    Allow: "allow",
+};
+/** @internal */
+export const DataCollection$outboundSchema = openEnums.outboundSchema(DataCollection);
+//# sourceMappingURL=datacollection.js.map

package/esm/models/index.d.ts

@@ -2,12 +2,12 @@ export * from "./activityitem.js";
 export * from "./assistantmessage.js";
 export * from "./badgatewayresponseerrordata.js";
 export * from "./badrequestresponseerrordata.js";
-export * from "./chatcompletionfinishreason.js";
 export * from "./chaterror.js";
 export * from "./chatgenerationparams.js";
 export * from "./chatgenerationtokenusage.js";
 export * from "./chatmessagecontentitem.js";
 export * from "./chatmessagecontentitemaudio.js";
+export * from "./chatmessagecontentitemfile.js";
 export * from "./chatmessagecontentitemimage.js";
 export * from "./chatmessagecontentitemtext.js";
 export * from "./chatmessagecontentitemvideo.js";
@@ -16,7 +16,6 @@ export * from "./chatmessagetokenlogprobs.js";
 export * from "./chatmessagetoolcall.js";
 export * from "./chatresponse.js";
 export * from "./chatresponsechoice.js";
-export * from "./chatstreamingchoice.js";
 export * from "./chatstreamingmessagechunk.js";
 export * from "./chatstreamingmessagetoolcall.js";
 export * from "./chatstreamingresponsechunk.js";
@@ -27,6 +26,7 @@ export * from "./completionlogprobs.js";
 export * from "./completionresponse.js";
 export * from "./completionusage.js";
 export * from "./createchargerequest.js";
+export * from "./datacollection.js";
 export * from "./defaultparameters.js";
 export * from "./edgenetworktimeoutresponseerrordata.js";
 export * from "./endpointstatus.js";
@@ -96,6 +96,7 @@ export * from "./paymentrequiredresponseerrordata.js";
 export * from "./perrequestlimits.js";
 export * from "./providername.js";
 export * from "./provideroverloadedresponseerrordata.js";
+export * from "./providersort.js";
 export * from "./publicendpoint.js";
 export * from "./publicpricing.js";
 export * from "./quantization.js";
@@ -137,6 +138,7 @@ export * from "./unauthorizedresponseerrordata.js";
 export * from "./unprocessableentityresponseerrordata.js";
 export * from "./urlcitation.js";
 export * from "./usermessage.js";
+export * from "./videourl.js";
 export * from "./websearchpreviewtooluserlocation.js";
 export * from "./websearchstatus.js";
 //# sourceMappingURL=index.d.ts.map

package/esm/models/index.js

@@ -5,12 +5,12 @@ export * from "./activityitem.js";
 export * from "./assistantmessage.js";
 export * from "./badgatewayresponseerrordata.js";
 export * from "./badrequestresponseerrordata.js";
-export * from "./chatcompletionfinishreason.js";
 export * from "./chaterror.js";
 export * from "./chatgenerationparams.js";
 export * from "./chatgenerationtokenusage.js";
 export * from "./chatmessagecontentitem.js";
 export * from "./chatmessagecontentitemaudio.js";
+export * from "./chatmessagecontentitemfile.js";
 export * from "./chatmessagecontentitemimage.js";
 export * from "./chatmessagecontentitemtext.js";
 export * from "./chatmessagecontentitemvideo.js";
@@ -19,7 +19,6 @@ export * from "./chatmessagetokenlogprobs.js";
 export * from "./chatmessagetoolcall.js";
 export * from "./chatresponse.js";
 export * from "./chatresponsechoice.js";
-export * from "./chatstreamingchoice.js";
 export * from "./chatstreamingmessagechunk.js";
 export * from "./chatstreamingmessagetoolcall.js";
 export * from "./chatstreamingresponsechunk.js";
@@ -30,6 +29,7 @@ export * from "./completionlogprobs.js";
 export * from "./completionresponse.js";
 export * from "./completionusage.js";
 export * from "./createchargerequest.js";
+export * from "./datacollection.js";
 export * from "./defaultparameters.js";
 export * from "./edgenetworktimeoutresponseerrordata.js";
 export * from "./endpointstatus.js";
@@ -99,6 +99,7 @@ export * from "./paymentrequiredresponseerrordata.js";
 export * from "./perrequestlimits.js";
 export * from "./providername.js";
 export * from "./provideroverloadedresponseerrordata.js";
+export * from "./providersort.js";
 export * from "./publicendpoint.js";
 export * from "./publicpricing.js";
 export * from "./quantization.js";
@@ -140,6 +141,7 @@ export * from "./unauthorizedresponseerrordata.js";
 export * from "./unprocessableentityresponseerrordata.js";
 export * from "./urlcitation.js";
 export * from "./usermessage.js";
+export * from "./videourl.js";
 export * from "./websearchpreviewtooluserlocation.js";
 export * from "./websearchstatus.js";
 //# sourceMappingURL=index.js.map

package/esm/models/openairesponsesreasoningeffort.d.ts

@@ -5,6 +5,7 @@ export declare const OpenAIResponsesReasoningEffort: {
     readonly Medium: "medium";
     readonly Low: "low";
     readonly Minimal: "minimal";
+    readonly None: "none";
 };
 export type OpenAIResponsesReasoningEffort = OpenEnum<typeof OpenAIResponsesReasoningEffort>;
 /** @internal */

package/esm/models/openairesponsesreasoningeffort.js

@@ -7,6 +7,7 @@ export const OpenAIResponsesReasoningEffort = {
     Medium: "medium",
     Low: "low",
     Minimal: "minimal",
+    None: "none",
 };
 /** @internal */
 export const OpenAIResponsesReasoningEffort$inboundSchema = openEnums.inboundSchema(OpenAIResponsesReasoningEffort);

package/esm/models/openresponsesreasoning.d.ts

@@ -24,6 +24,7 @@ export declare const OpenResponsesReasoningFormat: {
     readonly OpenaiResponsesV1: "openai-responses-v1";
     readonly XaiResponsesV1: "xai-responses-v1";
     readonly AnthropicClaudeV1: "anthropic-claude-v1";
+    readonly GoogleGeminiV1: "google-gemini-v1";
 };
 export type OpenResponsesReasoningFormat = OpenEnum<typeof OpenResponsesReasoningFormat>;
 /**

package/esm/models/openresponsesreasoning.js

@@ -23,6 +23,7 @@ export const OpenResponsesReasoningFormat = {
     OpenaiResponsesV1: "openai-responses-v1",
     XaiResponsesV1: "xai-responses-v1",
     AnthropicClaudeV1: "anthropic-claude-v1",
+    GoogleGeminiV1: "google-gemini-v1",
 };
 /** @internal */
 export const OpenResponsesReasoningType$outboundSchema = z.enum(OpenResponsesReasoningType);