@openrouter/sdk 0.1.11 → 0.1.13

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.13";
+    readonly genVersion: "2.755.9";
+    readonly userAgent: "speakeasy-sdk/typescript 0.1.13 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.13",
+    genVersion: "2.755.9",
+    userAgent: "speakeasy-sdk/typescript 0.1.13 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

@@ -13,6 +13,8 @@ export type ChatMessageContentItem = (ChatMessageContentItemText & {
     type: "input_audio";
 }) | (ChatMessageContentItemVideo & {
     type: "input_video";
+}) | (ChatMessageContentItemVideo & {
+    type: "video_url";
 });
 /** @internal */
 export declare const ChatMessageContentItem$inboundSchema: z.ZodType<ChatMessageContentItem, unknown>;
@@ -25,6 +27,8 @@ export type ChatMessageContentItem$Outbound = (ChatMessageContentItemText$Outbou
     type: "input_audio";
 }) | (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

@@ -13,6 +13,7 @@ export const ChatMessageContentItem$inboundSchema = z.union([
     ChatMessageContentItemImage$inboundSchema.and(z.object({ type: z.literal("image_url") })),
     ChatMessageContentItemAudio$inboundSchema.and(z.object({ type: z.literal("input_audio") })),
     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([
@@ -20,6 +21,7 @@ export const ChatMessageContentItem$outboundSchema = z.union([
     ChatMessageContentItemImage$outboundSchema.and(z.object({ type: z.literal("image_url") })),
     ChatMessageContentItemAudio$outboundSchema.and(z.object({ type: z.literal("input_audio") })),
     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/chatmessagecontentitemvideo.d.ts

@@ -1,31 +1,68 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export type VideoUrl = {
+export type VideoUrl2 = {
     url: string;
 };
-export type ChatMessageContentItemVideo = {
+export type ChatMessageContentItemVideoVideoURL = {
+    type: "video_url";
+    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 VideoUrl$inboundSchema: z.ZodType<VideoUrl, unknown>;
+export declare const VideoUrl2$inboundSchema: z.ZodType<VideoUrl2, unknown>;
 /** @internal */
-export type VideoUrl$Outbound = {
+export type VideoUrl2$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 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 ChatMessageContentItemVideo$inboundSchema: z.ZodType<ChatMessageContentItemVideo, unknown>;
+export declare const ChatMessageContentItemVideoVideoURL$inboundSchema: z.ZodType<ChatMessageContentItemVideoVideoURL, unknown>;
 /** @internal */
-export type ChatMessageContentItemVideo$Outbound = {
+export type ChatMessageContentItemVideoVideoURL$Outbound = {
+    type: "video_url";
+    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>;
+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

@@ -5,38 +5,91 @@ import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
-export const VideoUrl$inboundSchema = z.object({
+export const VideoUrl2$inboundSchema = z.object({
     url: z.string(),
 });
 /** @internal */
-export const VideoUrl$outboundSchema = z
-    .object({
+export const VideoUrl2$outboundSchema = z.object({
     url: z.string(),
 });
-export function videoUrlToJSON(videoUrl) {
-    return JSON.stringify(VideoUrl$outboundSchema.parse(videoUrl));
+export function videoUrl2ToJSON(videoUrl2) {
+    return JSON.stringify(VideoUrl2$outboundSchema.parse(videoUrl2));
 }
-export function videoUrlFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => VideoUrl$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'VideoUrl' 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 ChatMessageContentItemVideo$inboundSchema = z.object({
+export const ChatMessageContentItemVideoVideoURL$inboundSchema = z.object({
+    type: z.literal("video_url"),
+    video_url: z.lazy(() => VideoUrl2$inboundSchema),
+}).transform((v) => {
+    return remap$(v, {
+        "video_url": "videoUrl",
+    });
+});
+/** @internal */
+export const ChatMessageContentItemVideoVideoURL$outboundSchema = z.object({
+    type: z.literal("video_url"),
+    videoUrl: z.lazy(() => VideoUrl2$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 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: z.lazy(() => VideoUrl$inboundSchema),
+    video_url: z.lazy(() => VideoUrl1$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: z.lazy(() => VideoUrl1$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,7 +2,6 @@ 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";
@@ -16,7 +15,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 +25,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 +95,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";

package/esm/models/index.js

@@ -5,7 +5,6 @@ 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";
@@ -19,7 +18,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 +28,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 +98,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";

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);

package/esm/models/openresponsesrequest.d.ts

@@ -1,5 +1,6 @@
 import * as z from "zod/v4";
 import { ClosedEnum, OpenEnum } from "../types/enums.js";
+import { DataCollection } from "./datacollection.js";
 import { OpenAIResponsesIncludable } from "./openairesponsesincludable.js";
 import { OpenAIResponsesPrompt, OpenAIResponsesPrompt$Outbound } from "./openairesponsesprompt.js";
 import { OpenAIResponsesToolChoiceUnion, OpenAIResponsesToolChoiceUnion$Outbound } from "./openairesponsestoolchoiceunion.js";
@@ -11,6 +12,7 @@ import { OpenResponsesWebSearchPreview20250311Tool, OpenResponsesWebSearchPrevie
 import { OpenResponsesWebSearchPreviewTool, OpenResponsesWebSearchPreviewTool$Outbound } from "./openresponseswebsearchpreviewtool.js";
 import { OpenResponsesWebSearchTool, OpenResponsesWebSearchTool$Outbound } from "./openresponseswebsearchtool.js";
 import { ProviderName } from "./providername.js";
+import { ProviderSort } from "./providersort.js";
 import { Quantization } from "./quantization.js";
 export declare const OpenResponsesRequestType: {
     readonly Function: "function";
@@ -42,40 +44,9 @@ export declare const Truncation: {
     readonly Disabled: "disabled";
 };
 export type Truncation = OpenEnum<typeof Truncation>;
-/**
- * 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>;
 export type Order = ProviderName | string;
 export type Only = ProviderName | string;
 export type Ignore = ProviderName | string;
-/**
- * The sorting strategy to use for this request, if "order" is not specified. When set, no load balancing is performed.
- */
-export declare const Sort: {
-    readonly Price: "price";
-    readonly Throughput: "throughput";
-    readonly Latency: "latency";
-};
-/**
- * The sorting strategy to use for this request, if "order" is not specified. When set, no load balancing is performed.
- */
-export type Sort = OpenEnum<typeof Sort>;
 /**
  * The object specifying the maximum price you want to pay for this request. USD price per million tokens, for prompt and completion.
  */
@@ -122,6 +93,7 @@ export type Provider = {
      *
      * @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.
      */
     dataCollection?: DataCollection | null | undefined;
@@ -152,7 +124,7 @@ export type Provider = {
     /**
      * The sorting strategy to use for this request, if "order" is not specified. When set, no load balancing is performed.
      */
-    sort?: Sort | null | undefined;
+    sort?: ProviderSort | null | undefined;
     /**
      * The object specifying the maximum price you want to pay for this request. USD price per million tokens, for prompt and completion.
      */
@@ -279,8 +251,6 @@ export declare const ServiceTier$outboundSchema: z.ZodType<string, ServiceTier>;
 /** @internal */
 export declare const Truncation$outboundSchema: z.ZodType<string, Truncation>;
 /** @internal */
-export declare const DataCollection$outboundSchema: z.ZodType<string, DataCollection>;
-/** @internal */
 export type Order$Outbound = string | string;
 /** @internal */
 export declare const Order$outboundSchema: z.ZodType<Order$Outbound, Order>;
@@ -296,8 +266,6 @@ export type Ignore$Outbound = string | string;
 export declare const Ignore$outboundSchema: z.ZodType<Ignore$Outbound, Ignore>;
 export declare function ignoreToJSON(ignore: Ignore): string;
 /** @internal */
-export declare const Sort$outboundSchema: z.ZodType<string, Sort>;
-/** @internal */
 export type MaxPrice$Outbound = {
     prompt?: any | undefined;
     completion?: any | undefined;