@openrouter/sdk 0.3.12 → 0.3.15

package/esm/models/chatgenerationparams.js

@@ -49,6 +49,10 @@ export const Effort = {
     Minimal: "minimal",
     None: "none",
 };
+export const Modality = {
+    Text: "text",
+    Image: "image",
+};
 /** @internal */
 export const ChatGenerationParamsDataCollection$outboundSchema = openEnums.outboundSchema(ChatGenerationParamsDataCollection);
 /** @internal */
@@ -65,6 +69,42 @@ export function chatGenerationParamsMaxPriceToJSON(chatGenerationParamsMaxPrice)
     return JSON.stringify(ChatGenerationParamsMaxPrice$outboundSchema.parse(chatGenerationParamsMaxPrice));
 }
 /** @internal */
+export const ChatGenerationParamsPreferredMinThroughput$outboundSchema = z.object({
+    p50: z.nullable(z.number()).optional(),
+    p75: z.nullable(z.number()).optional(),
+    p90: z.nullable(z.number()).optional(),
+    p99: z.nullable(z.number()).optional(),
+});
+export function chatGenerationParamsPreferredMinThroughputToJSON(chatGenerationParamsPreferredMinThroughput) {
+    return JSON.stringify(ChatGenerationParamsPreferredMinThroughput$outboundSchema.parse(chatGenerationParamsPreferredMinThroughput));
+}
+/** @internal */
+export const ChatGenerationParamsPreferredMinThroughputUnion$outboundSchema = z.union([
+    z.number(),
+    z.lazy(() => ChatGenerationParamsPreferredMinThroughput$outboundSchema),
+]);
+export function chatGenerationParamsPreferredMinThroughputUnionToJSON(chatGenerationParamsPreferredMinThroughputUnion) {
+    return JSON.stringify(ChatGenerationParamsPreferredMinThroughputUnion$outboundSchema.parse(chatGenerationParamsPreferredMinThroughputUnion));
+}
+/** @internal */
+export const ChatGenerationParamsPreferredMaxLatency$outboundSchema = z.object({
+    p50: z.nullable(z.number()).optional(),
+    p75: z.nullable(z.number()).optional(),
+    p90: z.nullable(z.number()).optional(),
+    p99: z.nullable(z.number()).optional(),
+});
+export function chatGenerationParamsPreferredMaxLatencyToJSON(chatGenerationParamsPreferredMaxLatency) {
+    return JSON.stringify(ChatGenerationParamsPreferredMaxLatency$outboundSchema.parse(chatGenerationParamsPreferredMaxLatency));
+}
+/** @internal */
+export const ChatGenerationParamsPreferredMaxLatencyUnion$outboundSchema = z.union([
+    z.number(),
+    z.lazy(() => ChatGenerationParamsPreferredMaxLatency$outboundSchema),
+]);
+export function chatGenerationParamsPreferredMaxLatencyUnionToJSON(chatGenerationParamsPreferredMaxLatencyUnion) {
+    return JSON.stringify(ChatGenerationParamsPreferredMaxLatencyUnion$outboundSchema.parse(chatGenerationParamsPreferredMaxLatencyUnion));
+}
+/** @internal */
 export const ChatGenerationParamsProvider$outboundSchema = z.object({
     allowFallbacks: z.nullable(z.boolean()).optional(),
     requireParameters: z.nullable(z.boolean()).optional(),
@@ -79,10 +119,14 @@ export const ChatGenerationParamsProvider$outboundSchema = z.object({
     sort: z.nullable(ProviderSortUnion$outboundSchema).optional(),
     maxPrice: z.lazy(() => ChatGenerationParamsMaxPrice$outboundSchema)
         .optional(),
-    preferredMinThroughput: z.nullable(z.number()).optional(),
-    preferredMaxLatency: z.nullable(z.number()).optional(),
-    minThroughput: z.nullable(z.number()).optional(),
-    maxLatency: z.nullable(z.number()).optional(),
+    preferredMinThroughput: z.nullable(z.union([
+        z.number(),
+        z.lazy(() => ChatGenerationParamsPreferredMinThroughput$outboundSchema),
+    ])).optional(),
+    preferredMaxLatency: z.nullable(z.union([
+        z.number(),
+        z.lazy(() => ChatGenerationParamsPreferredMaxLatency$outboundSchema),
+    ])).optional(),
 }).transform((v) => {
     return remap$(v, {
         allowFallbacks: "allow_fallbacks",
@@ -92,8 +136,6 @@ export const ChatGenerationParamsProvider$outboundSchema = z.object({
         maxPrice: "max_price",
         preferredMinThroughput: "preferred_min_throughput",
         preferredMaxLatency: "preferred_max_latency",
-        minThroughput: "min_throughput",
-        maxLatency: "max_latency",
     });
 });
 export function chatGenerationParamsProviderToJSON(chatGenerationParamsProvider) {
@@ -153,7 +195,21 @@ export function chatGenerationParamsPluginModerationToJSON(chatGenerationParamsP
     return JSON.stringify(ChatGenerationParamsPluginModeration$outboundSchema.parse(chatGenerationParamsPluginModeration));
 }
 /** @internal */
+export const ChatGenerationParamsPluginAutoRouter$outboundSchema = z.object({
+    id: z.literal("auto-router"),
+    enabled: z.boolean().optional(),
+    allowedModels: z.array(z.string()).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        allowedModels: "allowed_models",
+    });
+});
+export function chatGenerationParamsPluginAutoRouterToJSON(chatGenerationParamsPluginAutoRouter) {
+    return JSON.stringify(ChatGenerationParamsPluginAutoRouter$outboundSchema.parse(chatGenerationParamsPluginAutoRouter));
+}
+/** @internal */
 export const ChatGenerationParamsPluginUnion$outboundSchema = z.union([
+    z.lazy(() => ChatGenerationParamsPluginAutoRouter$outboundSchema),
     z.lazy(() => ChatGenerationParamsPluginModeration$outboundSchema),
     z.lazy(() => ChatGenerationParamsPluginWeb$outboundSchema),
     z.lazy(() => ChatGenerationParamsPluginFileParser$outboundSchema),
@@ -225,9 +281,18 @@ export function debugToJSON(debug) {
     return JSON.stringify(Debug$outboundSchema.parse(debug));
 }
 /** @internal */
+export const ChatGenerationParamsImageConfig$outboundSchema = z.union([z.string(), z.number()]);
+export function chatGenerationParamsImageConfigToJSON(chatGenerationParamsImageConfig) {
+    return JSON.stringify(ChatGenerationParamsImageConfig$outboundSchema.parse(chatGenerationParamsImageConfig));
+}
+/** @internal */
+export const Modality$outboundSchema = openEnums
+    .outboundSchema(Modality);
+/** @internal */
 export const ChatGenerationParams$outboundSchema = z.object({
     provider: z.nullable(z.lazy(() => ChatGenerationParamsProvider$outboundSchema)).optional(),
     plugins: z.array(z.union([
+        z.lazy(() => ChatGenerationParamsPluginAutoRouter$outboundSchema),
         z.lazy(() => ChatGenerationParamsPluginModeration$outboundSchema),
         z.lazy(() => ChatGenerationParamsPluginWeb$outboundSchema),
         z.lazy(() => ChatGenerationParamsPluginFileParser$outboundSchema),
@@ -264,6 +329,9 @@ export const ChatGenerationParams$outboundSchema = z.object({
     tools: z.array(ToolDefinitionJson$outboundSchema).optional(),
     topP: z.nullable(z.number()).optional(),
     debug: z.lazy(() => Debug$outboundSchema).optional(),
+    imageConfig: z.record(z.string(), z.union([z.string(), z.number()]))
+        .optional(),
+    modalities: z.array(Modality$outboundSchema).optional(),
 }).transform((v) => {
     return remap$(v, {
         sessionId: "session_id",
@@ -277,6 +345,7 @@ export const ChatGenerationParams$outboundSchema = z.object({
         streamOptions: "stream_options",
         toolChoice: "tool_choice",
         topP: "top_p",
+        imageConfig: "image_config",
     });
 });
 export function chatGenerationParamsToJSON(chatGenerationParams) {

package/esm/models/chatgenerationtokenusage.d.ts

@@ -9,6 +9,7 @@ export type CompletionTokensDetails = {
 };
 export type PromptTokensDetails = {
     cachedTokens?: number | undefined;
+    cacheWriteTokens?: number | undefined;
     audioTokens?: number | undefined;
     videoTokens?: number | undefined;
 };

package/esm/models/chatgenerationtokenusage.js

@@ -25,11 +25,13 @@ export function completionTokensDetailsFromJSON(jsonString) {
 /** @internal */
 export const PromptTokensDetails$inboundSchema = z.object({
     cached_tokens: z.number().optional(),
+    cache_write_tokens: z.number().optional(),
     audio_tokens: z.number().optional(),
     video_tokens: z.number().optional(),
 }).transform((v) => {
     return remap$(v, {
         "cached_tokens": "cachedTokens",
+        "cache_write_tokens": "cacheWriteTokens",
         "audio_tokens": "audioTokens",
         "video_tokens": "videoTokens",
     });

package/esm/models/chatmessagecontentitemimage.d.ts

@@ -8,35 +8,35 @@ export declare const ChatMessageContentItemImageDetail: {
     readonly High: "high";
 };
 export type ChatMessageContentItemImageDetail = OpenEnum<typeof ChatMessageContentItemImageDetail>;
-export type ImageUrl = {
+export type ChatMessageContentItemImageImageUrl = {
     url: string;
     detail?: ChatMessageContentItemImageDetail | undefined;
 };
 export type ChatMessageContentItemImage = {
     type: "image_url";
-    imageUrl: ImageUrl;
+    imageUrl: ChatMessageContentItemImageImageUrl;
 };
 /** @internal */
 export declare const ChatMessageContentItemImageDetail$inboundSchema: z.ZodType<ChatMessageContentItemImageDetail, unknown>;
 /** @internal */
 export declare const ChatMessageContentItemImageDetail$outboundSchema: z.ZodType<string, ChatMessageContentItemImageDetail>;
 /** @internal */
-export declare const ImageUrl$inboundSchema: z.ZodType<ImageUrl, unknown>;
+export declare const ChatMessageContentItemImageImageUrl$inboundSchema: z.ZodType<ChatMessageContentItemImageImageUrl, unknown>;
 /** @internal */
-export type ImageUrl$Outbound = {
+export type ChatMessageContentItemImageImageUrl$Outbound = {
     url: string;
     detail?: string | undefined;
 };
 /** @internal */
-export declare const ImageUrl$outboundSchema: z.ZodType<ImageUrl$Outbound, ImageUrl>;
-export declare function imageUrlToJSON(imageUrl: ImageUrl): string;
-export declare function imageUrlFromJSON(jsonString: string): SafeParseResult<ImageUrl, SDKValidationError>;
+export declare const ChatMessageContentItemImageImageUrl$outboundSchema: z.ZodType<ChatMessageContentItemImageImageUrl$Outbound, ChatMessageContentItemImageImageUrl>;
+export declare function chatMessageContentItemImageImageUrlToJSON(chatMessageContentItemImageImageUrl: ChatMessageContentItemImageImageUrl): string;
+export declare function chatMessageContentItemImageImageUrlFromJSON(jsonString: string): SafeParseResult<ChatMessageContentItemImageImageUrl, SDKValidationError>;
 /** @internal */
 export declare const ChatMessageContentItemImage$inboundSchema: z.ZodType<ChatMessageContentItemImage, unknown>;
 /** @internal */
 export type ChatMessageContentItemImage$Outbound = {
     type: "image_url";
-    image_url: ImageUrl$Outbound;
+    image_url: ChatMessageContentItemImageImageUrl$Outbound;
 };
 /** @internal */
 export declare const ChatMessageContentItemImage$outboundSchema: z.ZodType<ChatMessageContentItemImage$Outbound, ChatMessageContentItemImage>;

package/esm/models/chatmessagecontentitemimage.js

@@ -16,26 +16,25 @@ export const ChatMessageContentItemImageDetail$inboundSchema = openEnums.inbound
 /** @internal */
 export const ChatMessageContentItemImageDetail$outboundSchema = openEnums.outboundSchema(ChatMessageContentItemImageDetail);
 /** @internal */
-export const ImageUrl$inboundSchema = z.object({
+export const ChatMessageContentItemImageImageUrl$inboundSchema = z.object({
     url: z.string(),
     detail: ChatMessageContentItemImageDetail$inboundSchema.optional(),
 });
 /** @internal */
-export const ImageUrl$outboundSchema = z
-    .object({
+export const ChatMessageContentItemImageImageUrl$outboundSchema = z.object({
     url: z.string(),
     detail: ChatMessageContentItemImageDetail$outboundSchema.optional(),
 });
-export function imageUrlToJSON(imageUrl) {
-    return JSON.stringify(ImageUrl$outboundSchema.parse(imageUrl));
+export function chatMessageContentItemImageImageUrlToJSON(chatMessageContentItemImageImageUrl) {
+    return JSON.stringify(ChatMessageContentItemImageImageUrl$outboundSchema.parse(chatMessageContentItemImageImageUrl));
 }
-export function imageUrlFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => ImageUrl$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ImageUrl' from JSON`);
+export function chatMessageContentItemImageImageUrlFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatMessageContentItemImageImageUrl$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageContentItemImageImageUrl' from JSON`);
 }
 /** @internal */
 export const ChatMessageContentItemImage$inboundSchema = z.object({
     type: z.literal("image_url"),
-    image_url: z.lazy(() => ImageUrl$inboundSchema),
+    image_url: z.lazy(() => ChatMessageContentItemImageImageUrl$inboundSchema),
 }).transform((v) => {
     return remap$(v, {
         "image_url": "imageUrl",
@@ -44,7 +43,7 @@ export const ChatMessageContentItemImage$inboundSchema = z.object({
 /** @internal */
 export const ChatMessageContentItemImage$outboundSchema = z.object({
     type: z.literal("image_url"),
-    imageUrl: z.lazy(() => ImageUrl$outboundSchema),
+    imageUrl: z.lazy(() => ChatMessageContentItemImageImageUrl$outboundSchema),
 }).transform((v) => {
     return remap$(v, {
         imageUrl: "image_url",

package/esm/models/chatmessagetokenlogprob.d.ts

@@ -1,7 +1,7 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export type TopLogprob = {
+export type ChatMessageTokenLogprobTopLogprob = {
     token: string;
     logprob: number;
     bytes: Array<number> | null;
@@ -10,11 +10,11 @@ export type ChatMessageTokenLogprob = {
     token: string;
     logprob: number;
     bytes: Array<number> | null;
-    topLogprobs: Array<TopLogprob>;
+    topLogprobs: Array<ChatMessageTokenLogprobTopLogprob>;
 };
 /** @internal */
-export declare const TopLogprob$inboundSchema: z.ZodType<TopLogprob, unknown>;
-export declare function topLogprobFromJSON(jsonString: string): SafeParseResult<TopLogprob, SDKValidationError>;
+export declare const ChatMessageTokenLogprobTopLogprob$inboundSchema: z.ZodType<ChatMessageTokenLogprobTopLogprob, unknown>;
+export declare function chatMessageTokenLogprobTopLogprobFromJSON(jsonString: string): SafeParseResult<ChatMessageTokenLogprobTopLogprob, SDKValidationError>;
 /** @internal */
 export declare const ChatMessageTokenLogprob$inboundSchema: z.ZodType<ChatMessageTokenLogprob, unknown>;
 export declare function chatMessageTokenLogprobFromJSON(jsonString: string): SafeParseResult<ChatMessageTokenLogprob, SDKValidationError>;

package/esm/models/chatmessagetokenlogprob.js

@@ -6,21 +6,20 @@ import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
-export const TopLogprob$inboundSchema = z
-    .object({
+export const ChatMessageTokenLogprobTopLogprob$inboundSchema = z.object({
     token: z.string(),
     logprob: z.number(),
     bytes: z.nullable(z.array(z.number())),
 });
-export function topLogprobFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => TopLogprob$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'TopLogprob' from JSON`);
+export function chatMessageTokenLogprobTopLogprobFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatMessageTokenLogprobTopLogprob$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageTokenLogprobTopLogprob' from JSON`);
 }
 /** @internal */
 export const ChatMessageTokenLogprob$inboundSchema = z.object({
     token: z.string(),
     logprob: z.number(),
     bytes: z.nullable(z.array(z.number())),
-    top_logprobs: z.array(z.lazy(() => TopLogprob$inboundSchema)),
+    top_logprobs: z.array(z.lazy(() => ChatMessageTokenLogprobTopLogprob$inboundSchema)),
 }).transform((v) => {
     return remap$(v, {
         "top_logprobs": "topLogprobs",

package/esm/models/chatresponsechoice.d.ts

@@ -4,12 +4,10 @@ import { AssistantMessage } from "./assistantmessage.js";
 import { ChatCompletionFinishReason } from "./chatcompletionfinishreason.js";
 import { ChatMessageTokenLogprobs } from "./chatmessagetokenlogprobs.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-import { Schema3 } from "./schema3.js";
 export type ChatResponseChoice = {
     finishReason: ChatCompletionFinishReason | null;
     index: number;
     message: AssistantMessage;
-    reasoningDetails?: Array<Schema3> | undefined;
     logprobs?: ChatMessageTokenLogprobs | null | undefined;
 };
 /** @internal */

package/esm/models/chatresponsechoice.js

@@ -8,18 +8,15 @@ import { safeParse } from "../lib/schemas.js";
 import { AssistantMessage$inboundSchema, } from "./assistantmessage.js";
 import { ChatCompletionFinishReason$inboundSchema, } from "./chatcompletionfinishreason.js";
 import { ChatMessageTokenLogprobs$inboundSchema, } from "./chatmessagetokenlogprobs.js";
-import { Schema3$inboundSchema } from "./schema3.js";
 /** @internal */
 export const ChatResponseChoice$inboundSchema = z.object({
     finish_reason: z.nullable(ChatCompletionFinishReason$inboundSchema),
     index: z.number(),
     message: AssistantMessage$inboundSchema,
-    reasoning_details: z.array(Schema3$inboundSchema).optional(),
     logprobs: z.nullable(ChatMessageTokenLogprobs$inboundSchema).optional(),
 }).transform((v) => {
     return remap$(v, {
         "finish_reason": "finishReason",
-        "reasoning_details": "reasoningDetails",
     });
 });
 export function chatResponseChoiceFromJSON(jsonString) {

package/esm/models/chatstreamingmessagechunk.d.ts

@@ -3,7 +3,7 @@ import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { ChatStreamingMessageToolCall } from "./chatstreamingmessagetoolcall.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-import { Schema3 } from "./schema3.js";
+import { Schema2 } from "./schema2.js";
 export declare const ChatStreamingMessageChunkRole: {
     readonly Assistant: "assistant";
 };
@@ -14,7 +14,7 @@ export type ChatStreamingMessageChunk = {
     reasoning?: string | null | undefined;
     refusal?: string | null | undefined;
     toolCalls?: Array<ChatStreamingMessageToolCall> | undefined;
-    reasoningDetails?: Array<Schema3> | undefined;
+    reasoningDetails?: Array<Schema2> | undefined;
 };
 /** @internal */
 export declare const ChatStreamingMessageChunkRole$inboundSchema: z.ZodEnum<typeof ChatStreamingMessageChunkRole>;

package/esm/models/chatstreamingmessagechunk.js

@@ -6,7 +6,7 @@ import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { ChatStreamingMessageToolCall$inboundSchema, } from "./chatstreamingmessagetoolcall.js";
-import { Schema3$inboundSchema } from "./schema3.js";
+import { Schema2$inboundSchema } from "./schema2.js";
 export const ChatStreamingMessageChunkRole = {
     Assistant: "assistant",
 };
@@ -19,7 +19,7 @@ export const ChatStreamingMessageChunk$inboundSchema = z.object({
     reasoning: z.nullable(z.string()).optional(),
     refusal: z.nullable(z.string()).optional(),
     tool_calls: z.array(ChatStreamingMessageToolCall$inboundSchema).optional(),
-    reasoning_details: z.array(Schema3$inboundSchema).optional(),
+    reasoning_details: z.array(Schema2$inboundSchema).optional(),
 }).transform((v) => {
     return remap$(v, {
         "tool_calls": "toolCalls",

package/esm/models/index.d.ts

@@ -97,7 +97,12 @@ export * from "./payloadtoolargeresponseerrordata.js";
 export * from "./paymentrequiredresponseerrordata.js";
 export * from "./pdfparserengine.js";
 export * from "./pdfparseroptions.js";
+export * from "./percentilelatencycutoffs.js";
+export * from "./percentilestats.js";
+export * from "./percentilethroughputcutoffs.js";
 export * from "./perrequestlimits.js";
+export * from "./preferredmaxlatency.js";
+export * from "./preferredminthroughput.js";
 export * from "./providername.js";
 export * from "./provideroverloadedresponseerrordata.js";
 export * from "./providerpreferences.js";
@@ -118,6 +123,7 @@ export * from "./responseinputaudio.js";
 export * from "./responseinputfile.js";
 export * from "./responseinputimage.js";
 export * from "./responseinputtext.js";
+export * from "./responseinputvideo.js";
 export * from "./responseoutputtext.js";
 export * from "./responseserrorfield.js";
 export * from "./responsesformatjsonobject.js";
@@ -129,12 +135,13 @@ export * from "./responsesoutputitemfilesearchcall.js";
 export * from "./responsesoutputitemfunctioncall.js";
 export * from "./responsesoutputitemreasoning.js";
 export * from "./responsesoutputmessage.js";
+export * from "./responsesoutputmodality.js";
 export * from "./responsessearchcontextsize.js";
 export * from "./responseswebsearchcalloutput.js";
 export * from "./responseswebsearchuserlocation.js";
 export * from "./responsetextconfig.js";
 export * from "./schema0.js";
-export * from "./schema3.js";
+export * from "./schema2.js";
 export * from "./security.js";
 export * from "./serviceunavailableresponseerrordata.js";
 export * from "./systemmessage.js";

package/esm/models/index.js

@@ -101,7 +101,12 @@ export * from "./payloadtoolargeresponseerrordata.js";
 export * from "./paymentrequiredresponseerrordata.js";
 export * from "./pdfparserengine.js";
 export * from "./pdfparseroptions.js";
+export * from "./percentilelatencycutoffs.js";
+export * from "./percentilestats.js";
+export * from "./percentilethroughputcutoffs.js";
 export * from "./perrequestlimits.js";
+export * from "./preferredmaxlatency.js";
+export * from "./preferredminthroughput.js";
 export * from "./providername.js";
 export * from "./provideroverloadedresponseerrordata.js";
 export * from "./providerpreferences.js";
@@ -122,6 +127,7 @@ export * from "./responseinputaudio.js";
 export * from "./responseinputfile.js";
 export * from "./responseinputimage.js";
 export * from "./responseinputtext.js";
+export * from "./responseinputvideo.js";
 export * from "./responseoutputtext.js";
 export * from "./responseserrorfield.js";
 export * from "./responsesformatjsonobject.js";
@@ -133,12 +139,13 @@ export * from "./responsesoutputitemfilesearchcall.js";
 export * from "./responsesoutputitemfunctioncall.js";
 export * from "./responsesoutputitemreasoning.js";
 export * from "./responsesoutputmessage.js";
+export * from "./responsesoutputmodality.js";
 export * from "./responsessearchcontextsize.js";
 export * from "./responseswebsearchcalloutput.js";
 export * from "./responseswebsearchuserlocation.js";
 export * from "./responsetextconfig.js";
 export * from "./schema0.js";
-export * from "./schema3.js";
+export * from "./schema2.js";
 export * from "./security.js";
 export * from "./serviceunavailableresponseerrordata.js";
 export * from "./systemmessage.js";

package/esm/models/model.d.ts

@@ -63,6 +63,10 @@ export type Model = {
      * Default parameters for this model
      */
     defaultParameters: DefaultParameters | null;
+    /**
+     * The date after which the model may be removed. ISO 8601 date string (YYYY-MM-DD) or null if no expiration.
+     */
+    expirationDate?: string | null | undefined;
 };
 /** @internal */
 export declare const Model$inboundSchema: z.ZodType<Model, unknown>;

package/esm/models/model.js

@@ -26,6 +26,7 @@ export const Model$inboundSchema = z.object({
     per_request_limits: z.nullable(PerRequestLimits$inboundSchema),
     supported_parameters: z.array(Parameter$inboundSchema),
     default_parameters: z.nullable(DefaultParameters$inboundSchema),
+    expiration_date: z.nullable(z.string()).optional(),
 }).transform((v) => {
     return remap$(v, {
         "canonical_slug": "canonicalSlug",
@@ -35,6 +36,7 @@ export const Model$inboundSchema = z.object({
         "per_request_limits": "perRequestLimits",
         "supported_parameters": "supportedParameters",
         "default_parameters": "defaultParameters",
+        "expiration_date": "expirationDate",
     });
 });
 export function modelFromJSON(jsonString) {

package/esm/models/openairesponsesinputunion.d.ts

@@ -49,12 +49,16 @@ export declare const OpenAIResponsesInputRoleUser2: {
 };
 export type OpenAIResponsesInputRoleUser2 = ClosedEnum<typeof OpenAIResponsesInputRoleUser2>;
 export type OpenAIResponsesInputRoleUnion2 = OpenAIResponsesInputRoleUser2 | OpenAIResponsesInputRoleSystem2 | OpenAIResponsesInputRoleDeveloper2;
-export type OpenAIResponsesInputContent3 = ResponseInputText | ResponseInputImage | ResponseInputFile | ResponseInputAudio;
+export type OpenAIResponsesInputContent3 = ResponseInputText | (ResponseInputImage & {
+    type: "input_image";
+}) | ResponseInputFile | ResponseInputAudio;
 export type OpenAIResponsesInputMessage2 = {
     id: string;
     type?: OpenAIResponsesInputTypeMessage2 | undefined;
     role: OpenAIResponsesInputRoleUser2 | OpenAIResponsesInputRoleSystem2 | OpenAIResponsesInputRoleDeveloper2;
-    content: Array<ResponseInputText | ResponseInputImage | ResponseInputFile | ResponseInputAudio>;
+    content: Array<ResponseInputText | (ResponseInputImage & {
+        type: "input_image";
+    }) | ResponseInputFile | ResponseInputAudio>;
 };
 export declare const OpenAIResponsesInputTypeMessage1: {
     readonly Message: "message";
@@ -77,12 +81,18 @@ export declare const OpenAIResponsesInputRoleUser1: {
 };
 export type OpenAIResponsesInputRoleUser1 = ClosedEnum<typeof OpenAIResponsesInputRoleUser1>;
 export type OpenAIResponsesInputRoleUnion1 = OpenAIResponsesInputRoleUser1 | OpenAIResponsesInputRoleSystem1 | OpenAIResponsesInputRoleAssistant | OpenAIResponsesInputRoleDeveloper1;
-export type OpenAIResponsesInputContent1 = ResponseInputText | ResponseInputImage | ResponseInputFile | ResponseInputAudio;
-export type OpenAIResponsesInputContent2 = Array<ResponseInputText | ResponseInputImage | ResponseInputFile | ResponseInputAudio> | string;
+export type OpenAIResponsesInputContent1 = ResponseInputText | (ResponseInputImage & {
+    type: "input_image";
+}) | ResponseInputFile | ResponseInputAudio;
+export type OpenAIResponsesInputContent2 = Array<ResponseInputText | (ResponseInputImage & {
+    type: "input_image";
+}) | ResponseInputFile | ResponseInputAudio> | string;
 export type OpenAIResponsesInputMessage1 = {
     type?: OpenAIResponsesInputTypeMessage1 | undefined;
     role: OpenAIResponsesInputRoleUser1 | OpenAIResponsesInputRoleSystem1 | OpenAIResponsesInputRoleAssistant | OpenAIResponsesInputRoleDeveloper1;
-    content: Array<ResponseInputText | ResponseInputImage | ResponseInputFile | ResponseInputAudio> | string;
+    content: Array<ResponseInputText | (ResponseInputImage & {
+        type: "input_image";
+    }) | ResponseInputFile | ResponseInputAudio> | string;
 };
 export type OpenAIResponsesInputUnion1 = OpenAIResponsesInputFunctionCall | OutputMessage | OpenAIResponsesInputMessage2 | OpenAIResponsesInputFunctionCallOutput | OutputItemImageGenerationCall | OpenAIResponsesInputMessage1;
 export type OpenAIResponsesInputUnion = string | Array<OpenAIResponsesInputFunctionCall | OutputMessage | OpenAIResponsesInputMessage2 | OpenAIResponsesInputFunctionCallOutput | OutputItemImageGenerationCall | OpenAIResponsesInputMessage1> | any;

package/esm/models/openairesponsesinputunion.js

@@ -100,7 +100,7 @@ export function openAIResponsesInputRoleUnion2FromJSON(jsonString) {
 /** @internal */
 export const OpenAIResponsesInputContent3$inboundSchema = z.union([
     ResponseInputText$inboundSchema,
-    ResponseInputImage$inboundSchema,
+    ResponseInputImage$inboundSchema.and(z.object({ type: z.literal("input_image") })),
     ResponseInputFile$inboundSchema,
     ResponseInputAudio$inboundSchema,
 ]);
@@ -118,7 +118,7 @@ export const OpenAIResponsesInputMessage2$inboundSchema = z.object({
     ]),
     content: z.array(z.union([
         ResponseInputText$inboundSchema,
-        ResponseInputImage$inboundSchema,
+        ResponseInputImage$inboundSchema.and(z.object({ type: z.literal("input_image") })),
         ResponseInputFile$inboundSchema,
         ResponseInputAudio$inboundSchema,
     ])),
@@ -149,7 +149,7 @@ export function openAIResponsesInputRoleUnion1FromJSON(jsonString) {
 /** @internal */
 export const OpenAIResponsesInputContent1$inboundSchema = z.union([
     ResponseInputText$inboundSchema,
-    ResponseInputImage$inboundSchema,
+    ResponseInputImage$inboundSchema.and(z.object({ type: z.literal("input_image") })),
     ResponseInputFile$inboundSchema,
     ResponseInputAudio$inboundSchema,
 ]);
@@ -160,7 +160,7 @@ export function openAIResponsesInputContent1FromJSON(jsonString) {
 export const OpenAIResponsesInputContent2$inboundSchema = z.union([
     z.array(z.union([
         ResponseInputText$inboundSchema,
-        ResponseInputImage$inboundSchema,
+        ResponseInputImage$inboundSchema.and(z.object({ type: z.literal("input_image") })),
         ResponseInputFile$inboundSchema,
         ResponseInputAudio$inboundSchema,
     ])),
@@ -181,7 +181,7 @@ export const OpenAIResponsesInputMessage1$inboundSchema = z.object({
     content: z.union([
         z.array(z.union([
             ResponseInputText$inboundSchema,
-            ResponseInputImage$inboundSchema,
+            ResponseInputImage$inboundSchema.and(z.object({ type: z.literal("input_image") })),
             ResponseInputFile$inboundSchema,
             ResponseInputAudio$inboundSchema,
         ])),