@openrouter/sdk 0.8.0 → 0.10.2

package/esm/models/openresponsesfilesearchtool.js

@@ -0,0 +1,180 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 0f461c2f2470
+ */
+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 { CompoundFilter$inboundSchema, CompoundFilter$outboundSchema, } from "./compoundfilter.js";
+export const FiltersType = {
+    Eq: "eq",
+    Ne: "ne",
+    Gt: "gt",
+    Gte: "gte",
+    Lt: "lt",
+    Lte: "lte",
+};
+export const Ranker = {
+    Auto: "auto",
+    Default20241115: "default-2024-11-15",
+};
+/** @internal */
+export const FiltersType$inboundSchema = openEnums.inboundSchema(FiltersType);
+/** @internal */
+export const FiltersType$outboundSchema = openEnums.outboundSchema(FiltersType);
+/** @internal */
+export const Value1$inboundSchema = z.union([
+    z.string(),
+    z.number(),
+]);
+/** @internal */
+export const Value1$outboundSchema = z
+    .union([z.string(), z.number()]);
+export function value1ToJSON(value1) {
+    return JSON.stringify(Value1$outboundSchema.parse(value1));
+}
+export function value1FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Value1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Value1' from JSON`);
+}
+/** @internal */
+export const Value2$inboundSchema = z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.array(z.union([z.string(), z.number()])),
+]);
+/** @internal */
+export const Value2$outboundSchema = z
+    .union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.array(z.union([z.string(), z.number()])),
+]);
+export function value2ToJSON(value2) {
+    return JSON.stringify(Value2$outboundSchema.parse(value2));
+}
+export function value2FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Value2$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Value2' from JSON`);
+}
+/** @internal */
+export const OpenResponsesFileSearchToolFilters$inboundSchema = z.object({
+    key: z.string(),
+    type: FiltersType$inboundSchema,
+    value: z.union([
+        z.string(),
+        z.number(),
+        z.boolean(),
+        z.array(z.union([z.string(), z.number()])),
+    ]),
+});
+/** @internal */
+export const OpenResponsesFileSearchToolFilters$outboundSchema = z.object({
+    key: z.string(),
+    type: FiltersType$outboundSchema,
+    value: z.union([
+        z.string(),
+        z.number(),
+        z.boolean(),
+        z.array(z.union([z.string(), z.number()])),
+    ]),
+});
+export function openResponsesFileSearchToolFiltersToJSON(openResponsesFileSearchToolFilters) {
+    return JSON.stringify(OpenResponsesFileSearchToolFilters$outboundSchema.parse(openResponsesFileSearchToolFilters));
+}
+export function openResponsesFileSearchToolFiltersFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesFileSearchToolFilters$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesFileSearchToolFilters' from JSON`);
+}
+/** @internal */
+export const Filters$inboundSchema = z.union([
+    z.lazy(() => OpenResponsesFileSearchToolFilters$inboundSchema),
+    CompoundFilter$inboundSchema,
+    z.any(),
+]);
+/** @internal */
+export const Filters$outboundSchema = z
+    .union([
+    z.lazy(() => OpenResponsesFileSearchToolFilters$outboundSchema),
+    CompoundFilter$outboundSchema,
+    z.any(),
+]);
+export function filtersToJSON(filters) {
+    return JSON.stringify(Filters$outboundSchema.parse(filters));
+}
+export function filtersFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Filters$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Filters' from JSON`);
+}
+/** @internal */
+export const Ranker$inboundSchema = openEnums
+    .inboundSchema(Ranker);
+/** @internal */
+export const Ranker$outboundSchema = openEnums
+    .outboundSchema(Ranker);
+/** @internal */
+export const RankingOptions$inboundSchema = z.object({
+    ranker: Ranker$inboundSchema.optional(),
+    score_threshold: z.number().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "score_threshold": "scoreThreshold",
+    });
+});
+/** @internal */
+export const RankingOptions$outboundSchema = z.object({
+    ranker: Ranker$outboundSchema.optional(),
+    scoreThreshold: z.number().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        scoreThreshold: "score_threshold",
+    });
+});
+export function rankingOptionsToJSON(rankingOptions) {
+    return JSON.stringify(RankingOptions$outboundSchema.parse(rankingOptions));
+}
+export function rankingOptionsFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => RankingOptions$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'RankingOptions' from JSON`);
+}
+/** @internal */
+export const OpenResponsesFileSearchTool$inboundSchema = z.object({
+    type: z.literal("file_search"),
+    vector_store_ids: z.array(z.string()),
+    filters: z.nullable(z.union([
+        z.lazy(() => OpenResponsesFileSearchToolFilters$inboundSchema),
+        CompoundFilter$inboundSchema,
+        z.any(),
+    ])).optional(),
+    max_num_results: z.int().optional(),
+    ranking_options: z.lazy(() => RankingOptions$inboundSchema).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "vector_store_ids": "vectorStoreIds",
+        "max_num_results": "maxNumResults",
+        "ranking_options": "rankingOptions",
+    });
+});
+/** @internal */
+export const OpenResponsesFileSearchTool$outboundSchema = z.object({
+    type: z.literal("file_search"),
+    vectorStoreIds: z.array(z.string()),
+    filters: z.nullable(z.union([
+        z.lazy(() => OpenResponsesFileSearchToolFilters$outboundSchema),
+        CompoundFilter$outboundSchema,
+        z.any(),
+    ])).optional(),
+    maxNumResults: z.int().optional(),
+    rankingOptions: z.lazy(() => RankingOptions$outboundSchema).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        vectorStoreIds: "vector_store_ids",
+        maxNumResults: "max_num_results",
+        rankingOptions: "ranking_options",
+    });
+});
+export function openResponsesFileSearchToolToJSON(openResponsesFileSearchTool) {
+    return JSON.stringify(OpenResponsesFileSearchTool$outboundSchema.parse(openResponsesFileSearchTool));
+}
+export function openResponsesFileSearchToolFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesFileSearchTool$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesFileSearchTool' from JSON`);
+}
+//# sourceMappingURL=openresponsesfilesearchtool.js.map

package/esm/models/openresponsesfunctioncalloutput.d.ts

@@ -1,28 +1,67 @@
 import * as z from "zod/v4";
-import { ClosedEnum } from "../types/enums.js";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
+import { ResponseInputFile, ResponseInputFile$Outbound } from "./responseinputfile.js";
+import { ResponseInputText, ResponseInputText$Outbound } from "./responseinputtext.js";
 import { ToolCallStatus } from "./toolcallstatus.js";
-export declare const OpenResponsesFunctionCallOutputType: {
+export declare const OpenResponsesFunctionCallOutputTypeFunctionCallOutput: {
     readonly FunctionCallOutput: "function_call_output";
 };
-export type OpenResponsesFunctionCallOutputType = ClosedEnum<typeof OpenResponsesFunctionCallOutputType>;
+export type OpenResponsesFunctionCallOutputTypeFunctionCallOutput = ClosedEnum<typeof OpenResponsesFunctionCallOutputTypeFunctionCallOutput>;
+export declare const OpenResponsesFunctionCallOutputDetail: {
+    readonly Auto: "auto";
+    readonly High: "high";
+    readonly Low: "low";
+};
+export type OpenResponsesFunctionCallOutputDetail = OpenEnum<typeof OpenResponsesFunctionCallOutputDetail>;
+/**
+ * Image input content item
+ */
+export type OutputInputImage = {
+    type: "input_image";
+    detail: OpenResponsesFunctionCallOutputDetail;
+    imageUrl?: string | null | undefined;
+};
+export type OpenResponsesFunctionCallOutputOutputUnion1 = ResponseInputText | OutputInputImage | ResponseInputFile;
+export type OpenResponsesFunctionCallOutputOutputUnion2 = string | Array<ResponseInputText | OutputInputImage | ResponseInputFile>;
 /**
  * The output from a function call execution
  */
 export type OpenResponsesFunctionCallOutput = {
-    type: OpenResponsesFunctionCallOutputType;
+    type: OpenResponsesFunctionCallOutputTypeFunctionCallOutput;
     id?: string | null | undefined;
     callId: string;
-    output: string;
+    output: string | Array<ResponseInputText | OutputInputImage | ResponseInputFile>;
     status?: ToolCallStatus | null | undefined;
 };
 /** @internal */
-export declare const OpenResponsesFunctionCallOutputType$outboundSchema: z.ZodEnum<typeof OpenResponsesFunctionCallOutputType>;
+export declare const OpenResponsesFunctionCallOutputTypeFunctionCallOutput$outboundSchema: z.ZodEnum<typeof OpenResponsesFunctionCallOutputTypeFunctionCallOutput>;
+/** @internal */
+export declare const OpenResponsesFunctionCallOutputDetail$outboundSchema: z.ZodType<string, OpenResponsesFunctionCallOutputDetail>;
+/** @internal */
+export type OutputInputImage$Outbound = {
+    type: "input_image";
+    detail: string;
+    image_url?: string | null | undefined;
+};
+/** @internal */
+export declare const OutputInputImage$outboundSchema: z.ZodType<OutputInputImage$Outbound, OutputInputImage>;
+export declare function outputInputImageToJSON(outputInputImage: OutputInputImage): string;
+/** @internal */
+export type OpenResponsesFunctionCallOutputOutputUnion1$Outbound = ResponseInputText$Outbound | OutputInputImage$Outbound | ResponseInputFile$Outbound;
+/** @internal */
+export declare const OpenResponsesFunctionCallOutputOutputUnion1$outboundSchema: z.ZodType<OpenResponsesFunctionCallOutputOutputUnion1$Outbound, OpenResponsesFunctionCallOutputOutputUnion1>;
+export declare function openResponsesFunctionCallOutputOutputUnion1ToJSON(openResponsesFunctionCallOutputOutputUnion1: OpenResponsesFunctionCallOutputOutputUnion1): string;
+/** @internal */
+export type OpenResponsesFunctionCallOutputOutputUnion2$Outbound = string | Array<ResponseInputText$Outbound | OutputInputImage$Outbound | ResponseInputFile$Outbound>;
+/** @internal */
+export declare const OpenResponsesFunctionCallOutputOutputUnion2$outboundSchema: z.ZodType<OpenResponsesFunctionCallOutputOutputUnion2$Outbound, OpenResponsesFunctionCallOutputOutputUnion2>;
+export declare function openResponsesFunctionCallOutputOutputUnion2ToJSON(openResponsesFunctionCallOutputOutputUnion2: OpenResponsesFunctionCallOutputOutputUnion2): string;
 /** @internal */
 export type OpenResponsesFunctionCallOutput$Outbound = {
     type: string;
     id?: string | null | undefined;
     call_id: string;
-    output: string;
+    output: string | Array<ResponseInputText$Outbound | OutputInputImage$Outbound | ResponseInputFile$Outbound>;
     status?: string | null | undefined;
 };
 /** @internal */

package/esm/models/openresponsesfunctioncalloutput.js

@@ -4,18 +4,70 @@
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
+import * as openEnums from "../types/enums.js";
+import { ResponseInputFile$outboundSchema, } from "./responseinputfile.js";
+import { ResponseInputText$outboundSchema, } from "./responseinputtext.js";
 import { ToolCallStatus$outboundSchema, } from "./toolcallstatus.js";
-export const OpenResponsesFunctionCallOutputType = {
+export const OpenResponsesFunctionCallOutputTypeFunctionCallOutput = {
     FunctionCallOutput: "function_call_output",
 };
+export const OpenResponsesFunctionCallOutputDetail = {
+    Auto: "auto",
+    High: "high",
+    Low: "low",
+};
+/** @internal */
+export const OpenResponsesFunctionCallOutputTypeFunctionCallOutput$outboundSchema = z
+    .enum(OpenResponsesFunctionCallOutputTypeFunctionCallOutput);
+/** @internal */
+export const OpenResponsesFunctionCallOutputDetail$outboundSchema = openEnums.outboundSchema(OpenResponsesFunctionCallOutputDetail);
+/** @internal */
+export const OutputInputImage$outboundSchema = z.object({
+    type: z.literal("input_image"),
+    detail: OpenResponsesFunctionCallOutputDetail$outboundSchema,
+    imageUrl: z.nullable(z.string()).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        imageUrl: "image_url",
+    });
+});
+export function outputInputImageToJSON(outputInputImage) {
+    return JSON.stringify(OutputInputImage$outboundSchema.parse(outputInputImage));
+}
 /** @internal */
-export const OpenResponsesFunctionCallOutputType$outboundSchema = z.enum(OpenResponsesFunctionCallOutputType);
+export const OpenResponsesFunctionCallOutputOutputUnion1$outboundSchema = z.union([
+    ResponseInputText$outboundSchema,
+    z.lazy(() => OutputInputImage$outboundSchema),
+    ResponseInputFile$outboundSchema,
+]);
+export function openResponsesFunctionCallOutputOutputUnion1ToJSON(openResponsesFunctionCallOutputOutputUnion1) {
+    return JSON.stringify(OpenResponsesFunctionCallOutputOutputUnion1$outboundSchema.parse(openResponsesFunctionCallOutputOutputUnion1));
+}
+/** @internal */
+export const OpenResponsesFunctionCallOutputOutputUnion2$outboundSchema = z.union([
+    z.string(),
+    z.array(z.union([
+        ResponseInputText$outboundSchema,
+        z.lazy(() => OutputInputImage$outboundSchema),
+        ResponseInputFile$outboundSchema,
+    ])),
+]);
+export function openResponsesFunctionCallOutputOutputUnion2ToJSON(openResponsesFunctionCallOutputOutputUnion2) {
+    return JSON.stringify(OpenResponsesFunctionCallOutputOutputUnion2$outboundSchema.parse(openResponsesFunctionCallOutputOutputUnion2));
+}
 /** @internal */
 export const OpenResponsesFunctionCallOutput$outboundSchema = z.object({
-    type: OpenResponsesFunctionCallOutputType$outboundSchema,
+    type: OpenResponsesFunctionCallOutputTypeFunctionCallOutput$outboundSchema,
     id: z.nullable(z.string()).optional(),
     callId: z.string(),
-    output: z.string(),
+    output: z.union([
+        z.string(),
+        z.array(z.union([
+            ResponseInputText$outboundSchema,
+            z.lazy(() => OutputInputImage$outboundSchema),
+            ResponseInputFile$outboundSchema,
+        ])),
+    ]),
     status: z.nullable(ToolCallStatus$outboundSchema).optional(),
 }).transform((v) => {
     return remap$(v, {

package/esm/models/openresponsesfunctionshelltool.d.ts

@@ -0,0 +1,20 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Shell tool configuration
+ */
+export type OpenResponsesFunctionShellTool = {
+    type: "shell";
+};
+/** @internal */
+export declare const OpenResponsesFunctionShellTool$inboundSchema: z.ZodType<OpenResponsesFunctionShellTool, unknown>;
+/** @internal */
+export type OpenResponsesFunctionShellTool$Outbound = {
+    type: "shell";
+};
+/** @internal */
+export declare const OpenResponsesFunctionShellTool$outboundSchema: z.ZodType<OpenResponsesFunctionShellTool$Outbound, OpenResponsesFunctionShellTool>;
+export declare function openResponsesFunctionShellToolToJSON(openResponsesFunctionShellTool: OpenResponsesFunctionShellTool): string;
+export declare function openResponsesFunctionShellToolFromJSON(jsonString: string): SafeParseResult<OpenResponsesFunctionShellTool, SDKValidationError>;
+//# sourceMappingURL=openresponsesfunctionshelltool.d.ts.map

package/esm/models/openresponsesfunctionshelltool.js

@@ -0,0 +1,21 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: d23282e24d97
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const OpenResponsesFunctionShellTool$inboundSchema = z.object({
+    type: z.literal("shell"),
+});
+/** @internal */
+export const OpenResponsesFunctionShellTool$outboundSchema = z.object({
+    type: z.literal("shell"),
+});
+export function openResponsesFunctionShellToolToJSON(openResponsesFunctionShellTool) {
+    return JSON.stringify(OpenResponsesFunctionShellTool$outboundSchema.parse(openResponsesFunctionShellTool));
+}
+export function openResponsesFunctionShellToolFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesFunctionShellTool$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesFunctionShellTool' from JSON`);
+}
+//# sourceMappingURL=openresponsesfunctionshelltool.js.map

package/esm/models/openresponsesimagegenerationtool.d.ts

@@ -0,0 +1,125 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const Background: {
+    readonly Transparent: "transparent";
+    readonly Opaque: "opaque";
+    readonly Auto: "auto";
+};
+export type Background = OpenEnum<typeof Background>;
+export declare const InputFidelity: {
+    readonly High: "high";
+    readonly Low: "low";
+};
+export type InputFidelity = OpenEnum<typeof InputFidelity>;
+export type InputImageMask = {
+    imageUrl?: string | undefined;
+    fileId?: string | undefined;
+};
+export declare const ModelEnum: {
+    readonly GptImage1: "gpt-image-1";
+    readonly GptImage1Mini: "gpt-image-1-mini";
+};
+export type ModelEnum = OpenEnum<typeof ModelEnum>;
+export declare const Moderation: {
+    readonly Auto: "auto";
+    readonly Low: "low";
+};
+export type Moderation = OpenEnum<typeof Moderation>;
+export declare const OutputFormat: {
+    readonly Png: "png";
+    readonly Webp: "webp";
+    readonly Jpeg: "jpeg";
+};
+export type OutputFormat = OpenEnum<typeof OutputFormat>;
+export declare const Quality: {
+    readonly Low: "low";
+    readonly Medium: "medium";
+    readonly High: "high";
+    readonly Auto: "auto";
+};
+export type Quality = OpenEnum<typeof Quality>;
+export declare const Size: {
+    readonly OneThousandAndTwentyFourx1024: "1024x1024";
+    readonly OneThousandAndTwentyFourx1536: "1024x1536";
+    readonly OneThousandFiveHundredAndThirtySixx1024: "1536x1024";
+    readonly Auto: "auto";
+};
+export type Size = OpenEnum<typeof Size>;
+/**
+ * Image generation tool configuration
+ */
+export type OpenResponsesImageGenerationTool = {
+    type: "image_generation";
+    background?: Background | undefined;
+    inputFidelity?: InputFidelity | null | undefined;
+    inputImageMask?: InputImageMask | undefined;
+    model?: ModelEnum | undefined;
+    moderation?: Moderation | undefined;
+    outputCompression?: number | undefined;
+    outputFormat?: OutputFormat | undefined;
+    partialImages?: number | undefined;
+    quality?: Quality | undefined;
+    size?: Size | undefined;
+};
+/** @internal */
+export declare const Background$inboundSchema: z.ZodType<Background, unknown>;
+/** @internal */
+export declare const Background$outboundSchema: z.ZodType<string, Background>;
+/** @internal */
+export declare const InputFidelity$inboundSchema: z.ZodType<InputFidelity, unknown>;
+/** @internal */
+export declare const InputFidelity$outboundSchema: z.ZodType<string, InputFidelity>;
+/** @internal */
+export declare const InputImageMask$inboundSchema: z.ZodType<InputImageMask, unknown>;
+/** @internal */
+export type InputImageMask$Outbound = {
+    image_url?: string | undefined;
+    file_id?: string | undefined;
+};
+/** @internal */
+export declare const InputImageMask$outboundSchema: z.ZodType<InputImageMask$Outbound, InputImageMask>;
+export declare function inputImageMaskToJSON(inputImageMask: InputImageMask): string;
+export declare function inputImageMaskFromJSON(jsonString: string): SafeParseResult<InputImageMask, SDKValidationError>;
+/** @internal */
+export declare const ModelEnum$inboundSchema: z.ZodType<ModelEnum, unknown>;
+/** @internal */
+export declare const ModelEnum$outboundSchema: z.ZodType<string, ModelEnum>;
+/** @internal */
+export declare const Moderation$inboundSchema: z.ZodType<Moderation, unknown>;
+/** @internal */
+export declare const Moderation$outboundSchema: z.ZodType<string, Moderation>;
+/** @internal */
+export declare const OutputFormat$inboundSchema: z.ZodType<OutputFormat, unknown>;
+/** @internal */
+export declare const OutputFormat$outboundSchema: z.ZodType<string, OutputFormat>;
+/** @internal */
+export declare const Quality$inboundSchema: z.ZodType<Quality, unknown>;
+/** @internal */
+export declare const Quality$outboundSchema: z.ZodType<string, Quality>;
+/** @internal */
+export declare const Size$inboundSchema: z.ZodType<Size, unknown>;
+/** @internal */
+export declare const Size$outboundSchema: z.ZodType<string, Size>;
+/** @internal */
+export declare const OpenResponsesImageGenerationTool$inboundSchema: z.ZodType<OpenResponsesImageGenerationTool, unknown>;
+/** @internal */
+export type OpenResponsesImageGenerationTool$Outbound = {
+    type: "image_generation";
+    background?: string | undefined;
+    input_fidelity?: string | null | undefined;
+    input_image_mask?: InputImageMask$Outbound | undefined;
+    model?: string | undefined;
+    moderation?: string | undefined;
+    output_compression?: number | undefined;
+    output_format?: string | undefined;
+    partial_images?: number | undefined;
+    quality?: string | undefined;
+    size?: string | undefined;
+};
+/** @internal */
+export declare const OpenResponsesImageGenerationTool$outboundSchema: z.ZodType<OpenResponsesImageGenerationTool$Outbound, OpenResponsesImageGenerationTool>;
+export declare function openResponsesImageGenerationToolToJSON(openResponsesImageGenerationTool: OpenResponsesImageGenerationTool): string;
+export declare function openResponsesImageGenerationToolFromJSON(jsonString: string): SafeParseResult<OpenResponsesImageGenerationTool, SDKValidationError>;
+//# sourceMappingURL=openresponsesimagegenerationtool.d.ts.map

package/esm/models/openresponsesimagegenerationtool.js

@@ -0,0 +1,153 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 149a19208595
+ */
+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";
+export const Background = {
+    Transparent: "transparent",
+    Opaque: "opaque",
+    Auto: "auto",
+};
+export const InputFidelity = {
+    High: "high",
+    Low: "low",
+};
+export const ModelEnum = {
+    GptImage1: "gpt-image-1",
+    GptImage1Mini: "gpt-image-1-mini",
+};
+export const Moderation = {
+    Auto: "auto",
+    Low: "low",
+};
+export const OutputFormat = {
+    Png: "png",
+    Webp: "webp",
+    Jpeg: "jpeg",
+};
+export const Quality = {
+    Low: "low",
+    Medium: "medium",
+    High: "high",
+    Auto: "auto",
+};
+export const Size = {
+    OneThousandAndTwentyFourx1024: "1024x1024",
+    OneThousandAndTwentyFourx1536: "1024x1536",
+    OneThousandFiveHundredAndThirtySixx1024: "1536x1024",
+    Auto: "auto",
+};
+/** @internal */
+export const Background$inboundSchema = openEnums.inboundSchema(Background);
+/** @internal */
+export const Background$outboundSchema = openEnums.outboundSchema(Background);
+/** @internal */
+export const InputFidelity$inboundSchema = openEnums.inboundSchema(InputFidelity);
+/** @internal */
+export const InputFidelity$outboundSchema = openEnums.outboundSchema(InputFidelity);
+/** @internal */
+export const InputImageMask$inboundSchema = z.object({
+    image_url: z.string().optional(),
+    file_id: z.string().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "image_url": "imageUrl",
+        "file_id": "fileId",
+    });
+});
+/** @internal */
+export const InputImageMask$outboundSchema = z.object({
+    imageUrl: z.string().optional(),
+    fileId: z.string().optional(),
+}).transform((v) => {
+    return remap$(v, {
+        imageUrl: "image_url",
+        fileId: "file_id",
+    });
+});
+export function inputImageMaskToJSON(inputImageMask) {
+    return JSON.stringify(InputImageMask$outboundSchema.parse(inputImageMask));
+}
+export function inputImageMaskFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => InputImageMask$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'InputImageMask' from JSON`);
+}
+/** @internal */
+export const ModelEnum$inboundSchema = openEnums
+    .inboundSchema(ModelEnum);
+/** @internal */
+export const ModelEnum$outboundSchema = openEnums
+    .outboundSchema(ModelEnum);
+/** @internal */
+export const Moderation$inboundSchema = openEnums.inboundSchema(Moderation);
+/** @internal */
+export const Moderation$outboundSchema = openEnums.outboundSchema(Moderation);
+/** @internal */
+export const OutputFormat$inboundSchema = openEnums.inboundSchema(OutputFormat);
+/** @internal */
+export const OutputFormat$outboundSchema = openEnums.outboundSchema(OutputFormat);
+/** @internal */
+export const Quality$inboundSchema = openEnums
+    .inboundSchema(Quality);
+/** @internal */
+export const Quality$outboundSchema = openEnums
+    .outboundSchema(Quality);
+/** @internal */
+export const Size$inboundSchema = openEnums
+    .inboundSchema(Size);
+/** @internal */
+export const Size$outboundSchema = openEnums
+    .outboundSchema(Size);
+/** @internal */
+export const OpenResponsesImageGenerationTool$inboundSchema = z.object({
+    type: z.literal("image_generation"),
+    background: Background$inboundSchema.optional(),
+    input_fidelity: z.nullable(InputFidelity$inboundSchema).optional(),
+    input_image_mask: z.lazy(() => InputImageMask$inboundSchema).optional(),
+    model: ModelEnum$inboundSchema.optional(),
+    moderation: Moderation$inboundSchema.optional(),
+    output_compression: z.number().optional(),
+    output_format: OutputFormat$inboundSchema.optional(),
+    partial_images: z.number().optional(),
+    quality: Quality$inboundSchema.optional(),
+    size: Size$inboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "input_fidelity": "inputFidelity",
+        "input_image_mask": "inputImageMask",
+        "output_compression": "outputCompression",
+        "output_format": "outputFormat",
+        "partial_images": "partialImages",
+    });
+});
+/** @internal */
+export const OpenResponsesImageGenerationTool$outboundSchema = z.object({
+    type: z.literal("image_generation"),
+    background: Background$outboundSchema.optional(),
+    inputFidelity: z.nullable(InputFidelity$outboundSchema).optional(),
+    inputImageMask: z.lazy(() => InputImageMask$outboundSchema).optional(),
+    model: ModelEnum$outboundSchema.optional(),
+    moderation: Moderation$outboundSchema.optional(),
+    outputCompression: z.number().optional(),
+    outputFormat: OutputFormat$outboundSchema.optional(),
+    partialImages: z.number().optional(),
+    quality: Quality$outboundSchema.optional(),
+    size: Size$outboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        inputFidelity: "input_fidelity",
+        inputImageMask: "input_image_mask",
+        outputCompression: "output_compression",
+        outputFormat: "output_format",
+        partialImages: "partial_images",
+    });
+});
+export function openResponsesImageGenerationToolToJSON(openResponsesImageGenerationTool) {
+    return JSON.stringify(OpenResponsesImageGenerationTool$outboundSchema.parse(openResponsesImageGenerationTool));
+}
+export function openResponsesImageGenerationToolFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => OpenResponsesImageGenerationTool$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesImageGenerationTool' from JSON`);
+}
+//# sourceMappingURL=openresponsesimagegenerationtool.js.map

package/esm/models/openresponsesinputmessageitem.d.ts

@@ -40,7 +40,7 @@ export type OpenResponsesInputMessageItem = {
     id?: string | undefined;
     type?: OpenResponsesInputMessageItemTypeMessage | undefined;
     role: OpenResponsesInputMessageItemRoleUser | OpenResponsesInputMessageItemRoleSystem | OpenResponsesInputMessageItemRoleDeveloper;
-    content: Array<ResponseInputText | OpenResponsesInputMessageItemContentInputImage | ResponseInputFile | ResponseInputAudio | ResponseInputVideo>;
+    content?: Array<ResponseInputText | OpenResponsesInputMessageItemContentInputImage | ResponseInputFile | ResponseInputAudio | ResponseInputVideo> | null | undefined;
 };
 /** @internal */
 export declare const OpenResponsesInputMessageItemTypeMessage$outboundSchema: z.ZodEnum<typeof OpenResponsesInputMessageItemTypeMessage>;
@@ -76,7 +76,7 @@ export type OpenResponsesInputMessageItem$Outbound = {
     id?: string | undefined;
     type?: string | undefined;
     role: string | string | string;
-    content: Array<ResponseInputText$Outbound | OpenResponsesInputMessageItemContentInputImage$Outbound | ResponseInputFile$Outbound | ResponseInputAudio$Outbound | ResponseInputVideo$Outbound>;
+    content?: Array<ResponseInputText$Outbound | OpenResponsesInputMessageItemContentInputImage$Outbound | ResponseInputFile$Outbound | ResponseInputAudio$Outbound | ResponseInputVideo$Outbound> | null | undefined;
 };
 /** @internal */
 export declare const OpenResponsesInputMessageItem$outboundSchema: z.ZodType<OpenResponsesInputMessageItem$Outbound, OpenResponsesInputMessageItem>;