@openrouter/sdk 0.1.27 → 0.2.9

package/esm/models/openresponseseasyinputmessage.d.ts

@@ -25,36 +25,12 @@ export declare const OpenResponsesEasyInputMessageRoleUser: {
 };
 export type OpenResponsesEasyInputMessageRoleUser = ClosedEnum<typeof OpenResponsesEasyInputMessageRoleUser>;
 export type OpenResponsesEasyInputMessageRoleUnion = OpenResponsesEasyInputMessageRoleUser | OpenResponsesEasyInputMessageRoleSystem | OpenResponsesEasyInputMessageRoleAssistant | OpenResponsesEasyInputMessageRoleDeveloper;
-export type OpenResponsesEasyInputMessageContent1 = (ResponseInputText & {
-    type: "input_text";
-}) | (ResponseInputImage & {
-    type: "input_image";
-}) | (ResponseInputAudio & {
-    type: "input_audio";
-}) | (ResponseInputFile & {
-    type: "input_file";
-});
-export type OpenResponsesEasyInputMessageContent2 = Array<(ResponseInputText & {
-    type: "input_text";
-}) | (ResponseInputImage & {
-    type: "input_image";
-}) | (ResponseInputAudio & {
-    type: "input_audio";
-}) | (ResponseInputFile & {
-    type: "input_file";
-})> | string;
+export type OpenResponsesEasyInputMessageContent1 = ResponseInputText | ResponseInputImage | ResponseInputFile | ResponseInputAudio;
+export type OpenResponsesEasyInputMessageContent2 = Array<ResponseInputText | ResponseInputImage | ResponseInputFile | ResponseInputAudio> | string;
 export type OpenResponsesEasyInputMessage = {
     type?: OpenResponsesEasyInputMessageType | undefined;
     role: OpenResponsesEasyInputMessageRoleUser | OpenResponsesEasyInputMessageRoleSystem | OpenResponsesEasyInputMessageRoleAssistant | OpenResponsesEasyInputMessageRoleDeveloper;
-    content: Array<(ResponseInputText & {
-        type: "input_text";
-    }) | (ResponseInputImage & {
-        type: "input_image";
-    }) | (ResponseInputAudio & {
-        type: "input_audio";
-    }) | (ResponseInputFile & {
-        type: "input_file";
-    })> | string;
+    content: Array<ResponseInputText | ResponseInputImage | ResponseInputFile | ResponseInputAudio> | string;
 };
 /** @internal */
 export declare const OpenResponsesEasyInputMessageType$outboundSchema: z.ZodEnum<typeof OpenResponsesEasyInputMessageType>;
@@ -72,28 +48,12 @@ export type OpenResponsesEasyInputMessageRoleUnion$Outbound = string | string |
 export declare const OpenResponsesEasyInputMessageRoleUnion$outboundSchema: z.ZodType<OpenResponsesEasyInputMessageRoleUnion$Outbound, OpenResponsesEasyInputMessageRoleUnion>;
 export declare function openResponsesEasyInputMessageRoleUnionToJSON(openResponsesEasyInputMessageRoleUnion: OpenResponsesEasyInputMessageRoleUnion): string;
 /** @internal */
-export type OpenResponsesEasyInputMessageContent1$Outbound = (ResponseInputText$Outbound & {
-    type: "input_text";
-}) | (ResponseInputImage$Outbound & {
-    type: "input_image";
-}) | (ResponseInputAudio$Outbound & {
-    type: "input_audio";
-}) | (ResponseInputFile$Outbound & {
-    type: "input_file";
-});
+export type OpenResponsesEasyInputMessageContent1$Outbound = ResponseInputText$Outbound | ResponseInputImage$Outbound | ResponseInputFile$Outbound | ResponseInputAudio$Outbound;
 /** @internal */
 export declare const OpenResponsesEasyInputMessageContent1$outboundSchema: z.ZodType<OpenResponsesEasyInputMessageContent1$Outbound, OpenResponsesEasyInputMessageContent1>;
 export declare function openResponsesEasyInputMessageContent1ToJSON(openResponsesEasyInputMessageContent1: OpenResponsesEasyInputMessageContent1): string;
 /** @internal */
-export type OpenResponsesEasyInputMessageContent2$Outbound = Array<(ResponseInputText$Outbound & {
-    type: "input_text";
-}) | (ResponseInputImage$Outbound & {
-    type: "input_image";
-}) | (ResponseInputAudio$Outbound & {
-    type: "input_audio";
-}) | (ResponseInputFile$Outbound & {
-    type: "input_file";
-})> | string;
+export type OpenResponsesEasyInputMessageContent2$Outbound = Array<ResponseInputText$Outbound | ResponseInputImage$Outbound | ResponseInputFile$Outbound | ResponseInputAudio$Outbound> | string;
 /** @internal */
 export declare const OpenResponsesEasyInputMessageContent2$outboundSchema: z.ZodType<OpenResponsesEasyInputMessageContent2$Outbound, OpenResponsesEasyInputMessageContent2>;
 export declare function openResponsesEasyInputMessageContent2ToJSON(openResponsesEasyInputMessageContent2: OpenResponsesEasyInputMessageContent2): string;
@@ -101,15 +61,7 @@ export declare function openResponsesEasyInputMessageContent2ToJSON(openResponse
 export type OpenResponsesEasyInputMessage$Outbound = {
     type?: string | undefined;
     role: string | string | string | string;
-    content: Array<(ResponseInputText$Outbound & {
-        type: "input_text";
-    }) | (ResponseInputImage$Outbound & {
-        type: "input_image";
-    }) | (ResponseInputAudio$Outbound & {
-        type: "input_audio";
-    }) | (ResponseInputFile$Outbound & {
-        type: "input_file";
-    })> | string;
+    content: Array<ResponseInputText$Outbound | ResponseInputImage$Outbound | ResponseInputFile$Outbound | ResponseInputAudio$Outbound> | string;
 };
 /** @internal */
 export declare const OpenResponsesEasyInputMessage$outboundSchema: z.ZodType<OpenResponsesEasyInputMessage$Outbound, OpenResponsesEasyInputMessage>;

package/esm/models/openresponseseasyinputmessage.js

@@ -43,10 +43,10 @@ export function openResponsesEasyInputMessageRoleUnionToJSON(openResponsesEasyIn
 }
 /** @internal */
 export const OpenResponsesEasyInputMessageContent1$outboundSchema = z.union([
-    ResponseInputText$outboundSchema.and(z.object({ type: z.literal("input_text") })),
-    ResponseInputImage$outboundSchema.and(z.object({ type: z.literal("input_image") })),
-    ResponseInputAudio$outboundSchema.and(z.object({ type: z.literal("input_audio") })),
-    ResponseInputFile$outboundSchema.and(z.object({ type: z.literal("input_file") })),
+    ResponseInputText$outboundSchema,
+    ResponseInputImage$outboundSchema,
+    ResponseInputFile$outboundSchema,
+    ResponseInputAudio$outboundSchema,
 ]);
 export function openResponsesEasyInputMessageContent1ToJSON(openResponsesEasyInputMessageContent1) {
     return JSON.stringify(OpenResponsesEasyInputMessageContent1$outboundSchema.parse(openResponsesEasyInputMessageContent1));
@@ -54,10 +54,10 @@ export function openResponsesEasyInputMessageContent1ToJSON(openResponsesEasyInp
 /** @internal */
 export const OpenResponsesEasyInputMessageContent2$outboundSchema = z.union([
     z.array(z.union([
-        ResponseInputText$outboundSchema.and(z.object({ type: z.literal("input_text") })),
-        ResponseInputImage$outboundSchema.and(z.object({ type: z.literal("input_image") })),
-        ResponseInputAudio$outboundSchema.and(z.object({ type: z.literal("input_audio") })),
-        ResponseInputFile$outboundSchema.and(z.object({ type: z.literal("input_file") })),
+        ResponseInputText$outboundSchema,
+        ResponseInputImage$outboundSchema,
+        ResponseInputFile$outboundSchema,
+        ResponseInputAudio$outboundSchema,
     ])),
     z.string(),
 ]);
@@ -75,10 +75,10 @@ export const OpenResponsesEasyInputMessage$outboundSchema = z.object({
     ]),
     content: z.union([
         z.array(z.union([
-            ResponseInputText$outboundSchema.and(z.object({ type: z.literal("input_text") })),
-            ResponseInputImage$outboundSchema.and(z.object({ type: z.literal("input_image") })),
-            ResponseInputAudio$outboundSchema.and(z.object({ type: z.literal("input_audio") })),
-            ResponseInputFile$outboundSchema.and(z.object({ type: z.literal("input_file") })),
+            ResponseInputText$outboundSchema,
+            ResponseInputImage$outboundSchema,
+            ResponseInputFile$outboundSchema,
+            ResponseInputAudio$outboundSchema,
         ])),
         z.string(),
     ]),

package/esm/models/openresponseserrorevent.d.ts

@@ -1,24 +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 OpenResponsesErrorEventType: {
-    readonly Error: "error";
-};
-export type OpenResponsesErrorEventType = ClosedEnum<typeof OpenResponsesErrorEventType>;
 /**
  * Event emitted when an error occurs during streaming
  */
 export type OpenResponsesErrorEvent = {
-    type: OpenResponsesErrorEventType;
+    type: "error";
     code: string | null;
     message: string;
     param: string | null;
     sequenceNumber: number;
 };
 /** @internal */
-export declare const OpenResponsesErrorEventType$inboundSchema: z.ZodEnum<typeof OpenResponsesErrorEventType>;
-/** @internal */
 export declare const OpenResponsesErrorEvent$inboundSchema: z.ZodType<OpenResponsesErrorEvent, unknown>;
 export declare function openResponsesErrorEventFromJSON(jsonString: string): SafeParseResult<OpenResponsesErrorEvent, SDKValidationError>;
 //# sourceMappingURL=openresponseserrorevent.d.ts.map

package/esm/models/openresponseserrorevent.js

@@ -4,14 +4,9 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-export const OpenResponsesErrorEventType = {
-    Error: "error",
-};
-/** @internal */
-export const OpenResponsesErrorEventType$inboundSchema = z.enum(OpenResponsesErrorEventType);
 /** @internal */
 export const OpenResponsesErrorEvent$inboundSchema = z.object({
-    type: OpenResponsesErrorEventType$inboundSchema,
+    type: z.literal("error"),
     code: z.nullable(z.string()),
     message: z.string(),
     param: z.nullable(z.string()),

package/esm/models/openresponsesimagegencallcompleted.d.ts

@@ -1,23 +1,16 @@
 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 OpenResponsesImageGenCallCompletedType: {
-    readonly ResponseImageGenerationCallCompleted: "response.image_generation_call.completed";
-};
-export type OpenResponsesImageGenCallCompletedType = ClosedEnum<typeof OpenResponsesImageGenCallCompletedType>;
 /**
  * Image generation call completed
  */
 export type OpenResponsesImageGenCallCompleted = {
-    type: OpenResponsesImageGenCallCompletedType;
+    type: "response.image_generation_call.completed";
     itemId: string;
     outputIndex: number;
     sequenceNumber: number;
 };
 /** @internal */
-export declare const OpenResponsesImageGenCallCompletedType$inboundSchema: z.ZodEnum<typeof OpenResponsesImageGenCallCompletedType>;
-/** @internal */
 export declare const OpenResponsesImageGenCallCompleted$inboundSchema: z.ZodType<OpenResponsesImageGenCallCompleted, unknown>;
 export declare function openResponsesImageGenCallCompletedFromJSON(jsonString: string): SafeParseResult<OpenResponsesImageGenCallCompleted, SDKValidationError>;
 //# sourceMappingURL=openresponsesimagegencallcompleted.d.ts.map

package/esm/models/openresponsesimagegencallcompleted.js

@@ -4,14 +4,9 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-export const OpenResponsesImageGenCallCompletedType = {
-    ResponseImageGenerationCallCompleted: "response.image_generation_call.completed",
-};
-/** @internal */
-export const OpenResponsesImageGenCallCompletedType$inboundSchema = z.enum(OpenResponsesImageGenCallCompletedType);
 /** @internal */
 export const OpenResponsesImageGenCallCompleted$inboundSchema = z.object({
-    type: OpenResponsesImageGenCallCompletedType$inboundSchema,
+    type: z.literal("response.image_generation_call.completed"),
     item_id: z.string(),
     output_index: z.number(),
     sequence_number: z.number(),

package/esm/models/openresponsesimagegencallgenerating.d.ts

@@ -1,23 +1,16 @@
 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 OpenResponsesImageGenCallGeneratingType: {
-    readonly ResponseImageGenerationCallGenerating: "response.image_generation_call.generating";
-};
-export type OpenResponsesImageGenCallGeneratingType = ClosedEnum<typeof OpenResponsesImageGenCallGeneratingType>;
 /**
  * Image generation call is generating
  */
 export type OpenResponsesImageGenCallGenerating = {
-    type: OpenResponsesImageGenCallGeneratingType;
+    type: "response.image_generation_call.generating";
     itemId: string;
     outputIndex: number;
     sequenceNumber: number;
 };
 /** @internal */
-export declare const OpenResponsesImageGenCallGeneratingType$inboundSchema: z.ZodEnum<typeof OpenResponsesImageGenCallGeneratingType>;
-/** @internal */
 export declare const OpenResponsesImageGenCallGenerating$inboundSchema: z.ZodType<OpenResponsesImageGenCallGenerating, unknown>;
 export declare function openResponsesImageGenCallGeneratingFromJSON(jsonString: string): SafeParseResult<OpenResponsesImageGenCallGenerating, SDKValidationError>;
 //# sourceMappingURL=openresponsesimagegencallgenerating.d.ts.map

package/esm/models/openresponsesimagegencallgenerating.js

@@ -4,14 +4,9 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-export const OpenResponsesImageGenCallGeneratingType = {
-    ResponseImageGenerationCallGenerating: "response.image_generation_call.generating",
-};
-/** @internal */
-export const OpenResponsesImageGenCallGeneratingType$inboundSchema = z.enum(OpenResponsesImageGenCallGeneratingType);
 /** @internal */
 export const OpenResponsesImageGenCallGenerating$inboundSchema = z.object({
-    type: OpenResponsesImageGenCallGeneratingType$inboundSchema,
+    type: z.literal("response.image_generation_call.generating"),
     item_id: z.string(),
     output_index: z.number(),
     sequence_number: z.number(),

package/esm/models/openresponsesimagegencallinprogress.d.ts

@@ -1,23 +1,16 @@
 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 OpenResponsesImageGenCallInProgressType: {
-    readonly ResponseImageGenerationCallInProgress: "response.image_generation_call.in_progress";
-};
-export type OpenResponsesImageGenCallInProgressType = ClosedEnum<typeof OpenResponsesImageGenCallInProgressType>;
 /**
  * Image generation call in progress
  */
 export type OpenResponsesImageGenCallInProgress = {
-    type: OpenResponsesImageGenCallInProgressType;
+    type: "response.image_generation_call.in_progress";
     itemId: string;
     outputIndex: number;
     sequenceNumber: number;
 };
 /** @internal */
-export declare const OpenResponsesImageGenCallInProgressType$inboundSchema: z.ZodEnum<typeof OpenResponsesImageGenCallInProgressType>;
-/** @internal */
 export declare const OpenResponsesImageGenCallInProgress$inboundSchema: z.ZodType<OpenResponsesImageGenCallInProgress, unknown>;
 export declare function openResponsesImageGenCallInProgressFromJSON(jsonString: string): SafeParseResult<OpenResponsesImageGenCallInProgress, SDKValidationError>;
 //# sourceMappingURL=openresponsesimagegencallinprogress.d.ts.map

package/esm/models/openresponsesimagegencallinprogress.js

@@ -4,14 +4,9 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-export const OpenResponsesImageGenCallInProgressType = {
-    ResponseImageGenerationCallInProgress: "response.image_generation_call.in_progress",
-};
-/** @internal */
-export const OpenResponsesImageGenCallInProgressType$inboundSchema = z.enum(OpenResponsesImageGenCallInProgressType);
 /** @internal */
 export const OpenResponsesImageGenCallInProgress$inboundSchema = z.object({
-    type: OpenResponsesImageGenCallInProgressType$inboundSchema,
+    type: z.literal("response.image_generation_call.in_progress"),
     item_id: z.string(),
     output_index: z.number(),
     sequence_number: z.number(),

package/esm/models/openresponsesimagegencallpartialimage.d.ts

@@ -1,16 +1,11 @@
 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 OpenResponsesImageGenCallPartialImageType: {
-    readonly ResponseImageGenerationCallPartialImage: "response.image_generation_call.partial_image";
-};
-export type OpenResponsesImageGenCallPartialImageType = ClosedEnum<typeof OpenResponsesImageGenCallPartialImageType>;
 /**
  * Image generation call with partial image
  */
 export type OpenResponsesImageGenCallPartialImage = {
-    type: OpenResponsesImageGenCallPartialImageType;
+    type: "response.image_generation_call.partial_image";
     itemId: string;
     outputIndex: number;
     sequenceNumber: number;
@@ -18,8 +13,6 @@ export type OpenResponsesImageGenCallPartialImage = {
     partialImageIndex: number;
 };
 /** @internal */
-export declare const OpenResponsesImageGenCallPartialImageType$inboundSchema: z.ZodEnum<typeof OpenResponsesImageGenCallPartialImageType>;
-/** @internal */
 export declare const OpenResponsesImageGenCallPartialImage$inboundSchema: z.ZodType<OpenResponsesImageGenCallPartialImage, unknown>;
 export declare function openResponsesImageGenCallPartialImageFromJSON(jsonString: string): SafeParseResult<OpenResponsesImageGenCallPartialImage, SDKValidationError>;
 //# sourceMappingURL=openresponsesimagegencallpartialimage.d.ts.map

package/esm/models/openresponsesimagegencallpartialimage.js

@@ -4,14 +4,9 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-export const OpenResponsesImageGenCallPartialImageType = {
-    ResponseImageGenerationCallPartialImage: "response.image_generation_call.partial_image",
-};
-/** @internal */
-export const OpenResponsesImageGenCallPartialImageType$inboundSchema = z.enum(OpenResponsesImageGenCallPartialImageType);
 /** @internal */
 export const OpenResponsesImageGenCallPartialImage$inboundSchema = z.object({
-    type: OpenResponsesImageGenCallPartialImageType$inboundSchema,
+    type: z.literal("response.image_generation_call.partial_image"),
     item_id: z.string(),
     output_index: z.number(),
     sequence_number: z.number(),

package/esm/models/openresponsesinputmessageitem.d.ts

@@ -21,28 +21,12 @@ export declare const OpenResponsesInputMessageItemRoleUser: {
 };
 export type OpenResponsesInputMessageItemRoleUser = ClosedEnum<typeof OpenResponsesInputMessageItemRoleUser>;
 export type OpenResponsesInputMessageItemRoleUnion = OpenResponsesInputMessageItemRoleUser | OpenResponsesInputMessageItemRoleSystem | OpenResponsesInputMessageItemRoleDeveloper;
-export type OpenResponsesInputMessageItemContent = (ResponseInputText & {
-    type: "input_text";
-}) | (ResponseInputImage & {
-    type: "input_image";
-}) | (ResponseInputAudio & {
-    type: "input_audio";
-}) | (ResponseInputFile & {
-    type: "input_file";
-});
+export type OpenResponsesInputMessageItemContent = ResponseInputText | ResponseInputImage | ResponseInputFile | ResponseInputAudio;
 export type OpenResponsesInputMessageItem = {
     id?: string | undefined;
     type?: OpenResponsesInputMessageItemType | undefined;
     role: OpenResponsesInputMessageItemRoleUser | OpenResponsesInputMessageItemRoleSystem | OpenResponsesInputMessageItemRoleDeveloper;
-    content: Array<(ResponseInputText & {
-        type: "input_text";
-    }) | (ResponseInputImage & {
-        type: "input_image";
-    }) | (ResponseInputAudio & {
-        type: "input_audio";
-    }) | (ResponseInputFile & {
-        type: "input_file";
-    })>;
+    content: Array<ResponseInputText | ResponseInputImage | ResponseInputFile | ResponseInputAudio>;
 };
 /** @internal */
 export declare const OpenResponsesInputMessageItemType$outboundSchema: z.ZodEnum<typeof OpenResponsesInputMessageItemType>;
@@ -58,15 +42,7 @@ export type OpenResponsesInputMessageItemRoleUnion$Outbound = string | string |
 export declare const OpenResponsesInputMessageItemRoleUnion$outboundSchema: z.ZodType<OpenResponsesInputMessageItemRoleUnion$Outbound, OpenResponsesInputMessageItemRoleUnion>;
 export declare function openResponsesInputMessageItemRoleUnionToJSON(openResponsesInputMessageItemRoleUnion: OpenResponsesInputMessageItemRoleUnion): string;
 /** @internal */
-export type OpenResponsesInputMessageItemContent$Outbound = (ResponseInputText$Outbound & {
-    type: "input_text";
-}) | (ResponseInputImage$Outbound & {
-    type: "input_image";
-}) | (ResponseInputAudio$Outbound & {
-    type: "input_audio";
-}) | (ResponseInputFile$Outbound & {
-    type: "input_file";
-});
+export type OpenResponsesInputMessageItemContent$Outbound = ResponseInputText$Outbound | ResponseInputImage$Outbound | ResponseInputFile$Outbound | ResponseInputAudio$Outbound;
 /** @internal */
 export declare const OpenResponsesInputMessageItemContent$outboundSchema: z.ZodType<OpenResponsesInputMessageItemContent$Outbound, OpenResponsesInputMessageItemContent>;
 export declare function openResponsesInputMessageItemContentToJSON(openResponsesInputMessageItemContent: OpenResponsesInputMessageItemContent): string;
@@ -75,15 +51,7 @@ export type OpenResponsesInputMessageItem$Outbound = {
     id?: string | undefined;
     type?: string | undefined;
     role: string | string | string;
-    content: Array<(ResponseInputText$Outbound & {
-        type: "input_text";
-    }) | (ResponseInputImage$Outbound & {
-        type: "input_image";
-    }) | (ResponseInputAudio$Outbound & {
-        type: "input_audio";
-    }) | (ResponseInputFile$Outbound & {
-        type: "input_file";
-    })>;
+    content: Array<ResponseInputText$Outbound | ResponseInputImage$Outbound | ResponseInputFile$Outbound | ResponseInputAudio$Outbound>;
 };
 /** @internal */
 export declare const OpenResponsesInputMessageItem$outboundSchema: z.ZodType<OpenResponsesInputMessageItem$Outbound, OpenResponsesInputMessageItem>;

package/esm/models/openresponsesinputmessageitem.js

@@ -37,10 +37,10 @@ export function openResponsesInputMessageItemRoleUnionToJSON(openResponsesInputM
 }
 /** @internal */
 export const OpenResponsesInputMessageItemContent$outboundSchema = z.union([
-    ResponseInputText$outboundSchema.and(z.object({ type: z.literal("input_text") })),
-    ResponseInputImage$outboundSchema.and(z.object({ type: z.literal("input_image") })),
-    ResponseInputAudio$outboundSchema.and(z.object({ type: z.literal("input_audio") })),
-    ResponseInputFile$outboundSchema.and(z.object({ type: z.literal("input_file") })),
+    ResponseInputText$outboundSchema,
+    ResponseInputImage$outboundSchema,
+    ResponseInputFile$outboundSchema,
+    ResponseInputAudio$outboundSchema,
 ]);
 export function openResponsesInputMessageItemContentToJSON(openResponsesInputMessageItemContent) {
     return JSON.stringify(OpenResponsesInputMessageItemContent$outboundSchema.parse(openResponsesInputMessageItemContent));
@@ -55,10 +55,10 @@ export const OpenResponsesInputMessageItem$outboundSchema = z.object({
         OpenResponsesInputMessageItemRoleDeveloper$outboundSchema,
     ]),
     content: z.array(z.union([
-        ResponseInputText$outboundSchema.and(z.object({ type: z.literal("input_text") })),
-        ResponseInputImage$outboundSchema.and(z.object({ type: z.literal("input_image") })),
-        ResponseInputAudio$outboundSchema.and(z.object({ type: z.literal("input_audio") })),
-        ResponseInputFile$outboundSchema.and(z.object({ type: z.literal("input_file") })),
+        ResponseInputText$outboundSchema,
+        ResponseInputImage$outboundSchema,
+        ResponseInputFile$outboundSchema,
+        ResponseInputAudio$outboundSchema,
     ])),
 });
 export function openResponsesInputMessageItemToJSON(openResponsesInputMessageItem) {

package/esm/models/openresponsesnonstreamingresponse.d.ts

@@ -22,15 +22,11 @@ export declare const ObjectT: {
     readonly Response: "response";
 };
 export type ObjectT = ClosedEnum<typeof ObjectT>;
-export declare const OpenResponsesNonStreamingResponseType: {
-    readonly Function: "function";
-};
-export type OpenResponsesNonStreamingResponseType = ClosedEnum<typeof OpenResponsesNonStreamingResponseType>;
 /**
  * Function tool definition
  */
 export type OpenResponsesNonStreamingResponseToolFunction = {
-    type: OpenResponsesNonStreamingResponseType;
+    type: "function";
     name: string;
     description?: string | null | undefined;
     strict?: boolean | null | undefined;
@@ -92,8 +88,6 @@ export type OpenResponsesNonStreamingResponse = {
 /** @internal */
 export declare const ObjectT$inboundSchema: z.ZodEnum<typeof ObjectT>;
 /** @internal */
-export declare const OpenResponsesNonStreamingResponseType$inboundSchema: z.ZodEnum<typeof OpenResponsesNonStreamingResponseType>;
-/** @internal */
 export declare const OpenResponsesNonStreamingResponseToolFunction$inboundSchema: z.ZodType<OpenResponsesNonStreamingResponseToolFunction, unknown>;
 export declare function openResponsesNonStreamingResponseToolFunctionFromJSON(jsonString: string): SafeParseResult<OpenResponsesNonStreamingResponseToolFunction, SDKValidationError>;
 /** @internal */

package/esm/models/openresponsesnonstreamingresponse.js

@@ -23,16 +23,11 @@ import { ResponseTextConfig$inboundSchema, } from "./responsetextconfig.js";
 export const ObjectT = {
     Response: "response",
 };
-export const OpenResponsesNonStreamingResponseType = {
-    Function: "function",
-};
 /** @internal */
 export const ObjectT$inboundSchema = z.enum(ObjectT);
 /** @internal */
-export const OpenResponsesNonStreamingResponseType$inboundSchema = z.enum(OpenResponsesNonStreamingResponseType);
-/** @internal */
 export const OpenResponsesNonStreamingResponseToolFunction$inboundSchema = z.object({
-    type: OpenResponsesNonStreamingResponseType$inboundSchema,
+    type: z.literal("function"),
     name: z.string(),
     description: z.nullable(z.string()).optional(),
     strict: z.nullable(z.boolean()).optional(),

package/esm/models/openresponsesreasoningdeltaevent.d.ts

@@ -1,16 +1,11 @@
 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 OpenResponsesReasoningDeltaEventType: {
-    readonly ResponseReasoningTextDelta: "response.reasoning_text.delta";
-};
-export type OpenResponsesReasoningDeltaEventType = ClosedEnum<typeof OpenResponsesReasoningDeltaEventType>;
 /**
  * Event emitted when reasoning text delta is streamed
  */
 export type OpenResponsesReasoningDeltaEvent = {
-    type: OpenResponsesReasoningDeltaEventType;
+    type: "response.reasoning_text.delta";
     outputIndex: number;
     itemId: string;
     contentIndex: number;
@@ -18,8 +13,6 @@ export type OpenResponsesReasoningDeltaEvent = {
     sequenceNumber: number;
 };
 /** @internal */
-export declare const OpenResponsesReasoningDeltaEventType$inboundSchema: z.ZodEnum<typeof OpenResponsesReasoningDeltaEventType>;
-/** @internal */
 export declare const OpenResponsesReasoningDeltaEvent$inboundSchema: z.ZodType<OpenResponsesReasoningDeltaEvent, unknown>;
 export declare function openResponsesReasoningDeltaEventFromJSON(jsonString: string): SafeParseResult<OpenResponsesReasoningDeltaEvent, SDKValidationError>;
 //# sourceMappingURL=openresponsesreasoningdeltaevent.d.ts.map

package/esm/models/openresponsesreasoningdeltaevent.js

@@ -4,14 +4,9 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-export const OpenResponsesReasoningDeltaEventType = {
-    ResponseReasoningTextDelta: "response.reasoning_text.delta",
-};
-/** @internal */
-export const OpenResponsesReasoningDeltaEventType$inboundSchema = z.enum(OpenResponsesReasoningDeltaEventType);
 /** @internal */
 export const OpenResponsesReasoningDeltaEvent$inboundSchema = z.object({
-    type: OpenResponsesReasoningDeltaEventType$inboundSchema,
+    type: z.literal("response.reasoning_text.delta"),
     output_index: z.number(),
     item_id: z.string(),
     content_index: z.number(),

package/esm/models/openresponsesreasoningdoneevent.d.ts

@@ -1,16 +1,11 @@
 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 OpenResponsesReasoningDoneEventType: {
-    readonly ResponseReasoningTextDone: "response.reasoning_text.done";
-};
-export type OpenResponsesReasoningDoneEventType = ClosedEnum<typeof OpenResponsesReasoningDoneEventType>;
 /**
  * Event emitted when reasoning text streaming is complete
  */
 export type OpenResponsesReasoningDoneEvent = {
-    type: OpenResponsesReasoningDoneEventType;
+    type: "response.reasoning_text.done";
     outputIndex: number;
     itemId: string;
     contentIndex: number;
@@ -18,8 +13,6 @@ export type OpenResponsesReasoningDoneEvent = {
     sequenceNumber: number;
 };
 /** @internal */
-export declare const OpenResponsesReasoningDoneEventType$inboundSchema: z.ZodEnum<typeof OpenResponsesReasoningDoneEventType>;
-/** @internal */
 export declare const OpenResponsesReasoningDoneEvent$inboundSchema: z.ZodType<OpenResponsesReasoningDoneEvent, unknown>;
 export declare function openResponsesReasoningDoneEventFromJSON(jsonString: string): SafeParseResult<OpenResponsesReasoningDoneEvent, SDKValidationError>;
 //# sourceMappingURL=openresponsesreasoningdoneevent.d.ts.map

package/esm/models/openresponsesreasoningdoneevent.js

@@ -4,14 +4,9 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-export const OpenResponsesReasoningDoneEventType = {
-    ResponseReasoningTextDone: "response.reasoning_text.done",
-};
-/** @internal */
-export const OpenResponsesReasoningDoneEventType$inboundSchema = z.enum(OpenResponsesReasoningDoneEventType);
 /** @internal */
 export const OpenResponsesReasoningDoneEvent$inboundSchema = z.object({
-    type: OpenResponsesReasoningDoneEventType$inboundSchema,
+    type: z.literal("response.reasoning_text.done"),
     output_index: z.number(),
     item_id: z.string(),
     content_index: z.number(),

package/esm/models/openresponsesreasoningsummarypartaddedevent.d.ts

@@ -1,17 +1,12 @@
 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";
 import { ReasoningSummaryText } from "./reasoningsummarytext.js";
-export declare const OpenResponsesReasoningSummaryPartAddedEventType: {
-    readonly ResponseReasoningSummaryPartAdded: "response.reasoning_summary_part.added";
-};
-export type OpenResponsesReasoningSummaryPartAddedEventType = ClosedEnum<typeof OpenResponsesReasoningSummaryPartAddedEventType>;
 /**
  * Event emitted when a reasoning summary part is added
  */
 export type OpenResponsesReasoningSummaryPartAddedEvent = {
-    type: OpenResponsesReasoningSummaryPartAddedEventType;
+    type: "response.reasoning_summary_part.added";
     outputIndex: number;
     itemId: string;
     summaryIndex: number;
@@ -19,8 +14,6 @@ export type OpenResponsesReasoningSummaryPartAddedEvent = {
     sequenceNumber: number;
 };
 /** @internal */
-export declare const OpenResponsesReasoningSummaryPartAddedEventType$inboundSchema: z.ZodEnum<typeof OpenResponsesReasoningSummaryPartAddedEventType>;
-/** @internal */
 export declare const OpenResponsesReasoningSummaryPartAddedEvent$inboundSchema: z.ZodType<OpenResponsesReasoningSummaryPartAddedEvent, unknown>;
 export declare function openResponsesReasoningSummaryPartAddedEventFromJSON(jsonString: string): SafeParseResult<OpenResponsesReasoningSummaryPartAddedEvent, SDKValidationError>;
 //# sourceMappingURL=openresponsesreasoningsummarypartaddedevent.d.ts.map

package/esm/models/openresponsesreasoningsummarypartaddedevent.js

@@ -5,14 +5,9 @@ import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { ReasoningSummaryText$inboundSchema, } from "./reasoningsummarytext.js";
-export const OpenResponsesReasoningSummaryPartAddedEventType = {
-    ResponseReasoningSummaryPartAdded: "response.reasoning_summary_part.added",
-};
-/** @internal */
-export const OpenResponsesReasoningSummaryPartAddedEventType$inboundSchema = z.enum(OpenResponsesReasoningSummaryPartAddedEventType);
 /** @internal */
 export const OpenResponsesReasoningSummaryPartAddedEvent$inboundSchema = z.object({
-    type: OpenResponsesReasoningSummaryPartAddedEventType$inboundSchema,
+    type: z.literal("response.reasoning_summary_part.added"),
     output_index: z.number(),
     item_id: z.string(),
     summary_index: z.number(),