@openrouter/sdk 0.9.11 → 0.11.2

package/esm/models/functioncalloutputitem.d.ts

@@ -0,0 +1,70 @@
+import * as z from "zod/v4";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
+import { InputFile, InputFile$Outbound } from "./inputfile.js";
+import { InputText, InputText$Outbound } from "./inputtext.js";
+import { ToolCallStatusEnum } from "./toolcallstatusenum.js";
+export declare const FunctionCallOutputItemTypeFunctionCallOutput: {
+    readonly FunctionCallOutput: "function_call_output";
+};
+export type FunctionCallOutputItemTypeFunctionCallOutput = ClosedEnum<typeof FunctionCallOutputItemTypeFunctionCallOutput>;
+export declare const FunctionCallOutputItemDetail: {
+    readonly Auto: "auto";
+    readonly High: "high";
+    readonly Low: "low";
+};
+export type FunctionCallOutputItemDetail = OpenEnum<typeof FunctionCallOutputItemDetail>;
+/**
+ * Image input content item
+ */
+export type OutputInputImage = {
+    type: "input_image";
+    detail: FunctionCallOutputItemDetail;
+    imageUrl?: string | null | undefined;
+};
+export type FunctionCallOutputItemOutputUnion1 = InputText | OutputInputImage | InputFile;
+export type FunctionCallOutputItemOutputUnion2 = string | Array<InputText | OutputInputImage | InputFile>;
+/**
+ * The output from a function call execution
+ */
+export type FunctionCallOutputItem = {
+    type: FunctionCallOutputItemTypeFunctionCallOutput;
+    id?: string | null | undefined;
+    callId: string;
+    output: string | Array<InputText | OutputInputImage | InputFile>;
+    status?: ToolCallStatusEnum | null | undefined;
+};
+/** @internal */
+export declare const FunctionCallOutputItemTypeFunctionCallOutput$outboundSchema: z.ZodEnum<typeof FunctionCallOutputItemTypeFunctionCallOutput>;
+/** @internal */
+export declare const FunctionCallOutputItemDetail$outboundSchema: z.ZodType<string, FunctionCallOutputItemDetail>;
+/** @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 FunctionCallOutputItemOutputUnion1$Outbound = InputText$Outbound | OutputInputImage$Outbound | InputFile$Outbound;
+/** @internal */
+export declare const FunctionCallOutputItemOutputUnion1$outboundSchema: z.ZodType<FunctionCallOutputItemOutputUnion1$Outbound, FunctionCallOutputItemOutputUnion1>;
+export declare function functionCallOutputItemOutputUnion1ToJSON(functionCallOutputItemOutputUnion1: FunctionCallOutputItemOutputUnion1): string;
+/** @internal */
+export type FunctionCallOutputItemOutputUnion2$Outbound = string | Array<InputText$Outbound | OutputInputImage$Outbound | InputFile$Outbound>;
+/** @internal */
+export declare const FunctionCallOutputItemOutputUnion2$outboundSchema: z.ZodType<FunctionCallOutputItemOutputUnion2$Outbound, FunctionCallOutputItemOutputUnion2>;
+export declare function functionCallOutputItemOutputUnion2ToJSON(functionCallOutputItemOutputUnion2: FunctionCallOutputItemOutputUnion2): string;
+/** @internal */
+export type FunctionCallOutputItem$Outbound = {
+    type: string;
+    id?: string | null | undefined;
+    call_id: string;
+    output: string | Array<InputText$Outbound | OutputInputImage$Outbound | InputFile$Outbound>;
+    status?: string | null | undefined;
+};
+/** @internal */
+export declare const FunctionCallOutputItem$outboundSchema: z.ZodType<FunctionCallOutputItem$Outbound, FunctionCallOutputItem>;
+export declare function functionCallOutputItemToJSON(functionCallOutputItem: FunctionCallOutputItem): string;
+//# sourceMappingURL=functioncalloutputitem.d.ts.map

package/esm/models/functioncalloutputitem.js

@@ -0,0 +1,79 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 279b91cadffe
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import * as openEnums from "../types/enums.js";
+import { InputFile$outboundSchema, } from "./inputfile.js";
+import { InputText$outboundSchema, } from "./inputtext.js";
+import { ToolCallStatusEnum$outboundSchema, } from "./toolcallstatusenum.js";
+export const FunctionCallOutputItemTypeFunctionCallOutput = {
+    FunctionCallOutput: "function_call_output",
+};
+export const FunctionCallOutputItemDetail = {
+    Auto: "auto",
+    High: "high",
+    Low: "low",
+};
+/** @internal */
+export const FunctionCallOutputItemTypeFunctionCallOutput$outboundSchema = z.enum(FunctionCallOutputItemTypeFunctionCallOutput);
+/** @internal */
+export const FunctionCallOutputItemDetail$outboundSchema = openEnums.outboundSchema(FunctionCallOutputItemDetail);
+/** @internal */
+export const OutputInputImage$outboundSchema = z.object({
+    type: z.literal("input_image"),
+    detail: FunctionCallOutputItemDetail$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 FunctionCallOutputItemOutputUnion1$outboundSchema = z.union([
+    InputText$outboundSchema,
+    z.lazy(() => OutputInputImage$outboundSchema),
+    InputFile$outboundSchema,
+]);
+export function functionCallOutputItemOutputUnion1ToJSON(functionCallOutputItemOutputUnion1) {
+    return JSON.stringify(FunctionCallOutputItemOutputUnion1$outboundSchema.parse(functionCallOutputItemOutputUnion1));
+}
+/** @internal */
+export const FunctionCallOutputItemOutputUnion2$outboundSchema = z.union([
+    z.string(),
+    z.array(z.union([
+        InputText$outboundSchema,
+        z.lazy(() => OutputInputImage$outboundSchema),
+        InputFile$outboundSchema,
+    ])),
+]);
+export function functionCallOutputItemOutputUnion2ToJSON(functionCallOutputItemOutputUnion2) {
+    return JSON.stringify(FunctionCallOutputItemOutputUnion2$outboundSchema.parse(functionCallOutputItemOutputUnion2));
+}
+/** @internal */
+export const FunctionCallOutputItem$outboundSchema = z.object({
+    type: FunctionCallOutputItemTypeFunctionCallOutput$outboundSchema,
+    id: z.nullable(z.string()).optional(),
+    callId: z.string(),
+    output: z.union([
+        z.string(),
+        z.array(z.union([
+            InputText$outboundSchema,
+            z.lazy(() => OutputInputImage$outboundSchema),
+            InputFile$outboundSchema,
+        ])),
+    ]),
+    status: z.nullable(ToolCallStatusEnum$outboundSchema).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        callId: "call_id",
+    });
+});
+export function functionCallOutputItemToJSON(functionCallOutputItem) {
+    return JSON.stringify(FunctionCallOutputItem$outboundSchema.parse(functionCallOutputItem));
+}
+//# sourceMappingURL=functioncalloutputitem.js.map

package/esm/models/imagegencallcompletedevent.d.ts

@@ -0,0 +1,16 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Image generation call completed
+ */
+export type ImageGenCallCompletedEvent = {
+    type: "response.image_generation_call.completed";
+    itemId: string;
+    outputIndex: number;
+    sequenceNumber: number;
+};
+/** @internal */
+export declare const ImageGenCallCompletedEvent$inboundSchema: z.ZodType<ImageGenCallCompletedEvent, unknown>;
+export declare function imageGenCallCompletedEventFromJSON(jsonString: string): SafeParseResult<ImageGenCallCompletedEvent, SDKValidationError>;
+//# sourceMappingURL=imagegencallcompletedevent.d.ts.map

package/esm/models/{openresponsesimagegencallcompleted.js → imagegencallcompletedevent.js}

@@ -1,12 +1,12 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- * @generated-id: 8f2a1c3fbf5d
+ * @generated-id: fe8d977c7dca
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
-export const OpenResponsesImageGenCallCompleted$inboundSchema = z.object({
+export const ImageGenCallCompletedEvent$inboundSchema = z.object({
     type: z.literal("response.image_generation_call.completed"),
     item_id: z.string(),
     output_index: z.number(),
@@ -18,7 +18,7 @@ export const OpenResponsesImageGenCallCompleted$inboundSchema = z.object({
         "sequence_number": "sequenceNumber",
     });
 });
-export function openResponsesImageGenCallCompletedFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => OpenResponsesImageGenCallCompleted$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesImageGenCallCompleted' from JSON`);
+export function imageGenCallCompletedEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ImageGenCallCompletedEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ImageGenCallCompletedEvent' from JSON`);
 }
-//# sourceMappingURL=openresponsesimagegencallcompleted.js.map
+//# sourceMappingURL=imagegencallcompletedevent.js.map

package/esm/models/imagegencallgeneratingevent.d.ts

@@ -0,0 +1,16 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Image generation call is generating
+ */
+export type ImageGenCallGeneratingEvent = {
+    type: "response.image_generation_call.generating";
+    itemId: string;
+    outputIndex: number;
+    sequenceNumber: number;
+};
+/** @internal */
+export declare const ImageGenCallGeneratingEvent$inboundSchema: z.ZodType<ImageGenCallGeneratingEvent, unknown>;
+export declare function imageGenCallGeneratingEventFromJSON(jsonString: string): SafeParseResult<ImageGenCallGeneratingEvent, SDKValidationError>;
+//# sourceMappingURL=imagegencallgeneratingevent.d.ts.map

package/esm/models/{openresponsesimagegencallgenerating.js → imagegencallgeneratingevent.js}

@@ -1,12 +1,12 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- * @generated-id: 97b22c3fad75
+ * @generated-id: f2806bd9c69c
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
-export const OpenResponsesImageGenCallGenerating$inboundSchema = z.object({
+export const ImageGenCallGeneratingEvent$inboundSchema = z.object({
     type: z.literal("response.image_generation_call.generating"),
     item_id: z.string(),
     output_index: z.number(),
@@ -18,7 +18,7 @@ export const OpenResponsesImageGenCallGenerating$inboundSchema = z.object({
         "sequence_number": "sequenceNumber",
     });
 });
-export function openResponsesImageGenCallGeneratingFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => OpenResponsesImageGenCallGenerating$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesImageGenCallGenerating' from JSON`);
+export function imageGenCallGeneratingEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ImageGenCallGeneratingEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ImageGenCallGeneratingEvent' from JSON`);
 }
-//# sourceMappingURL=openresponsesimagegencallgenerating.js.map
+//# sourceMappingURL=imagegencallgeneratingevent.js.map

package/esm/models/imagegencallinprogressevent.d.ts

@@ -0,0 +1,16 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Image generation call in progress
+ */
+export type ImageGenCallInProgressEvent = {
+    type: "response.image_generation_call.in_progress";
+    itemId: string;
+    outputIndex: number;
+    sequenceNumber: number;
+};
+/** @internal */
+export declare const ImageGenCallInProgressEvent$inboundSchema: z.ZodType<ImageGenCallInProgressEvent, unknown>;
+export declare function imageGenCallInProgressEventFromJSON(jsonString: string): SafeParseResult<ImageGenCallInProgressEvent, SDKValidationError>;
+//# sourceMappingURL=imagegencallinprogressevent.d.ts.map

package/esm/models/{openresponsesimagegencallinprogress.js → imagegencallinprogressevent.js}

@@ -1,12 +1,12 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- * @generated-id: 402a8da9c8da
+ * @generated-id: f9385ea6a417
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
-export const OpenResponsesImageGenCallInProgress$inboundSchema = z.object({
+export const ImageGenCallInProgressEvent$inboundSchema = z.object({
     type: z.literal("response.image_generation_call.in_progress"),
     item_id: z.string(),
     output_index: z.number(),
@@ -18,7 +18,7 @@ export const OpenResponsesImageGenCallInProgress$inboundSchema = z.object({
         "sequence_number": "sequenceNumber",
     });
 });
-export function openResponsesImageGenCallInProgressFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => OpenResponsesImageGenCallInProgress$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesImageGenCallInProgress' from JSON`);
+export function imageGenCallInProgressEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ImageGenCallInProgressEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ImageGenCallInProgressEvent' from JSON`);
 }
-//# sourceMappingURL=openresponsesimagegencallinprogress.js.map
+//# sourceMappingURL=imagegencallinprogressevent.js.map

package/esm/models/{openresponsesimagegencallpartialimage.d.ts → imagegencallpartialimageevent.d.ts}

@@ -4,7 +4,7 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 /**
  * Image generation call with partial image
  */
-export type OpenResponsesImageGenCallPartialImage = {
+export type ImageGenCallPartialImageEvent = {
     type: "response.image_generation_call.partial_image";
     itemId: string;
     outputIndex: number;
@@ -13,6 +13,6 @@ export type OpenResponsesImageGenCallPartialImage = {
     partialImageIndex: number;
 };
 /** @internal */
-export declare const OpenResponsesImageGenCallPartialImage$inboundSchema: z.ZodType<OpenResponsesImageGenCallPartialImage, unknown>;
-export declare function openResponsesImageGenCallPartialImageFromJSON(jsonString: string): SafeParseResult<OpenResponsesImageGenCallPartialImage, SDKValidationError>;
-//# sourceMappingURL=openresponsesimagegencallpartialimage.d.ts.map
+export declare const ImageGenCallPartialImageEvent$inboundSchema: z.ZodType<ImageGenCallPartialImageEvent, unknown>;
+export declare function imageGenCallPartialImageEventFromJSON(jsonString: string): SafeParseResult<ImageGenCallPartialImageEvent, SDKValidationError>;
+//# sourceMappingURL=imagegencallpartialimageevent.d.ts.map

package/esm/models/{openresponsesimagegencallpartialimage.js → imagegencallpartialimageevent.js}

@@ -1,12 +1,12 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- * @generated-id: 053a18912617
+ * @generated-id: db1f02788378
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
-export const OpenResponsesImageGenCallPartialImage$inboundSchema = z.object({
+export const ImageGenCallPartialImageEvent$inboundSchema = z.object({
     type: z.literal("response.image_generation_call.partial_image"),
     item_id: z.string(),
     output_index: z.number(),
@@ -22,7 +22,7 @@ export const OpenResponsesImageGenCallPartialImage$inboundSchema = z.object({
         "partial_image_index": "partialImageIndex",
     });
 });
-export function openResponsesImageGenCallPartialImageFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => OpenResponsesImageGenCallPartialImage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenResponsesImageGenCallPartialImage' from JSON`);
+export function imageGenCallPartialImageEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ImageGenCallPartialImageEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ImageGenCallPartialImageEvent' from JSON`);
 }
-//# sourceMappingURL=openresponsesimagegencallpartialimage.js.map
+//# sourceMappingURL=imagegencallpartialimageevent.js.map

package/esm/models/imagegenerationservertool.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 ImageGenerationServerTool = {
+    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 ImageGenerationServerTool$inboundSchema: z.ZodType<ImageGenerationServerTool, unknown>;
+/** @internal */
+export type ImageGenerationServerTool$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 ImageGenerationServerTool$outboundSchema: z.ZodType<ImageGenerationServerTool$Outbound, ImageGenerationServerTool>;
+export declare function imageGenerationServerToolToJSON(imageGenerationServerTool: ImageGenerationServerTool): string;
+export declare function imageGenerationServerToolFromJSON(jsonString: string): SafeParseResult<ImageGenerationServerTool, SDKValidationError>;
+//# sourceMappingURL=imagegenerationservertool.d.ts.map

package/esm/models/imagegenerationservertool.js

@@ -0,0 +1,153 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 1efbad50f534
+ */
+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 ImageGenerationServerTool$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 ImageGenerationServerTool$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 imageGenerationServerToolToJSON(imageGenerationServerTool) {
+    return JSON.stringify(ImageGenerationServerTool$outboundSchema.parse(imageGenerationServerTool));
+}
+export function imageGenerationServerToolFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ImageGenerationServerTool$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ImageGenerationServerTool' from JSON`);
+}
+//# sourceMappingURL=imagegenerationservertool.js.map

package/esm/models/{openairesponsesincompletedetails.d.ts → incompletedetails.d.ts}

@@ -7,12 +7,12 @@ export declare const Reason: {
     readonly ContentFilter: "content_filter";
 };
 export type Reason = OpenEnum<typeof Reason>;
-export type OpenAIResponsesIncompleteDetails = {
+export type IncompleteDetails = {
     reason?: Reason | undefined;
 };
 /** @internal */
 export declare const Reason$inboundSchema: z.ZodType<Reason, unknown>;
 /** @internal */
-export declare const OpenAIResponsesIncompleteDetails$inboundSchema: z.ZodType<OpenAIResponsesIncompleteDetails, unknown>;
-export declare function openAIResponsesIncompleteDetailsFromJSON(jsonString: string): SafeParseResult<OpenAIResponsesIncompleteDetails, SDKValidationError>;
-//# sourceMappingURL=openairesponsesincompletedetails.d.ts.map
+export declare const IncompleteDetails$inboundSchema: z.ZodType<IncompleteDetails, unknown>;
+export declare function incompleteDetailsFromJSON(jsonString: string): SafeParseResult<IncompleteDetails, SDKValidationError>;
+//# sourceMappingURL=incompletedetails.d.ts.map

package/esm/models/{openairesponsesincompletedetails.js → incompletedetails.js}

@@ -1,6 +1,6 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- * @generated-id: f2aabee6a438
+ * @generated-id: 1d922f86c2f4
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
@@ -13,10 +13,10 @@ export const Reason = {
 export const Reason$inboundSchema = openEnums
     .inboundSchema(Reason);
 /** @internal */
-export const OpenAIResponsesIncompleteDetails$inboundSchema = z.object({
+export const IncompleteDetails$inboundSchema = z.object({
     reason: Reason$inboundSchema.optional(),
 });
-export function openAIResponsesIncompleteDetailsFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => OpenAIResponsesIncompleteDetails$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'OpenAIResponsesIncompleteDetails' from JSON`);
+export function incompleteDetailsFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => IncompleteDetails$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'IncompleteDetails' from JSON`);
 }
-//# sourceMappingURL=openairesponsesincompletedetails.js.map
+//# sourceMappingURL=incompletedetails.js.map