@opencode-ai/ai 0.0.0-next-15825 → 0.0.0-next-15830

package/README.md

@@ -1,6 +1,6 @@
 # @opencode-ai/ai
 
-Schema-first LLM core for opencode. One typed request, response, event, and tool language; provider quirks live in adapters, not in calling code.
+Schema-first AI primitives for opencode. Provider quirks live in adapters, not in calling code.
 
 ```ts
 import { Effect } from "effect"
@@ -24,6 +24,45 @@ const program = Effect.gen(function* () {
 
 Run `LLMClient.stream(request)` instead of `generate` when you want incremental `LLMEvent`s. The event stream is provider-neutral — same shape across OpenAI Chat, OpenAI Responses, Anthropic Messages, Gemini, Bedrock Converse, and any OpenAI-compatible deployment.
 
+## Image generation
+
+Use `Image.generate` with an image model for direct asset generation:
+
+```ts
+import { Image } from "@opencode-ai/ai"
+import { OpenAI } from "@opencode-ai/ai/providers"
+
+const program = Effect.gen(function* () {
+  const response = yield* Image.generate({
+    model: OpenAI.configure({ apiKey: process.env.OPENAI_API_KEY }).image("gpt-image-2"),
+    prompt: "A robot tending a rooftop garden",
+    count: 2,
+    size: { width: 1024, height: 1024 },
+    providerOptions: { openai: { quality: "high", outputFormat: "webp" } },
+  })
+
+  return response.images // GeneratedImage[] with owned bytes or a provider URL
+})
+```
+
+Conversational image generation remains part of the LLM interaction. OpenAI Responses exposes it through its hosted image tool:
+
+```ts
+const program = Effect.gen(function* () {
+  const response = yield* LLM.generate(
+    LLM.request({
+      model: OpenAI.configure({ apiKey }).responses("gpt-5"),
+      prompt: "Design a solarpunk rooftop garden, then show me.",
+      tools: [OpenAI.imageGeneration({ quality: "high" })],
+    }),
+  )
+
+  return response.message
+})
+```
+
+The hosted result is represented as a provider-executed tool call and tool result. Its image is a `file` content item with a data URI, so retaining `response.message` preserves the generated image for continuation.
+
 ## Public API
 
 - **`LLM.request({...})`** — build a provider-neutral `LLMRequest`. Accepts ergonomic inputs (`system: string`, `prompt: string`) that normalize into the canonical Schema classes.
@@ -32,6 +71,8 @@ Run `LLMClient.stream(request)` instead of `generate` when you want incremental
 - **`Model.make(...)` / `ToolCallPart.make(...)` / `ToolResultPart.make(...)` / `ToolDefinition.make(...)`** — model and tool-related constructors from the canonical schema model.
 - **`LLMClient.prepare(request)`** — compile a request through protocol body construction, validation, and HTTP preparation without sending. Useful for inspection and testing.
 - **`LLMEvent.is.*`** — typed guards (`is.textDelta`, `is.toolCall`, `is.finish`, …) for filtering streams.
+- **`Image.generate({...})`** — generate images through a provider-neutral image request and response model.
+- **`ImageClient`** — Effect service and layer for image execution, parallel to `LLMClient`.
 
 ## Caching
 
@@ -182,7 +223,7 @@ Adding a new model or deployment is usually 5-15 lines using `Route.make({ proto
 
 ## Effect
 
-This package is built on Effect. Public methods return `Effect` or `Stream`; provide `LLMClient.layer` for runtime dispatch and import the provider/protocol modules for the routes you use. The example at `example/tutorial.ts` is a runnable walkthrough.
+This package is built on Effect. Public methods return `Effect` or `Stream`; provide `LLMClient.layer` for LLM dispatch and `ImageClient.layer` for image dispatch, then import the provider/protocol modules for the routes you use. The example at `example/tutorial.ts` is a runnable walkthrough.
 
 ## See also
 

package/dist/image-client.d.ts

@@ -0,0 +1,19 @@
+import { Context, Effect, Layer } from "effect";
+import { RequestExecutor } from "./route/executor";
+import type { ImageRequest, ImageResponse } from "./image";
+import type { LLMError } from "./schema";
+export type Execute = RequestExecutor.Interface["execute"];
+export interface Interface {
+    readonly generate: (request: ImageRequest) => Effect.Effect<ImageResponse, LLMError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/ImageClient", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const generate: (request: ImageRequest) => Effect.Effect<ImageResponse, LLMError>;
+export declare const layer: Layer.Layer<Service, never, RequestExecutor.Service>;
+export declare const ImageClient: {
+    readonly Service: typeof Service;
+    readonly layer: Layer.Layer<Service, never, RequestExecutor.Service>;
+    readonly generate: (request: ImageRequest) => Effect.Effect<ImageResponse, LLMError>;
+};
+export {};

package/dist/image-client.js

@@ -0,0 +1,19 @@
+import { Context, Effect, Layer } from "effect";
+import { RequestExecutor } from "./route/executor";
+export class Service extends Context.Service()("@opencode/ImageClient") {
+}
+export const generate = (request) => Effect.gen(function* () {
+    const client = yield* Service;
+    return yield* client.generate(request);
+});
+export const layer = Layer.effect(Service, Effect.gen(function* () {
+    const executor = yield* RequestExecutor.Service;
+    return Service.of({
+        generate: (request) => request.model.route.generate(request, executor.execute),
+    });
+}));
+export const ImageClient = {
+    Service,
+    layer,
+    generate,
+};

package/dist/image.d.ts

@@ -0,0 +1,78 @@
+import { Effect, Schema } from "effect";
+import { HttpOptions, LLMError, ModelID, ProviderID, Usage } from "./schema";
+import { type Execute as ImageExecute } from "./image-client";
+export interface ImageRoute {
+    readonly id: string;
+    readonly generate: (request: ImageRequest, execute: ImageExecute) => Effect.Effect<ImageResponse, LLMError>;
+}
+export declare class ImageModel {
+    readonly id: ModelID;
+    readonly provider: ProviderID;
+    readonly route: ImageRoute;
+    readonly defaults?: ImageModelDefaults;
+    constructor(input: ImageModel.Input);
+    static make(input: ImageModel.MakeInput): ImageModel;
+}
+export declare namespace ImageModel {
+    interface Input {
+        readonly id: ModelID;
+        readonly provider: ProviderID;
+        readonly route: ImageRoute;
+        readonly defaults?: ImageModelDefaults;
+    }
+    interface MakeInput extends Omit<Input, "id" | "provider"> {
+        readonly id: string | ModelID;
+        readonly provider: string | ProviderID;
+    }
+}
+export interface ImageModelDefaults {
+    readonly providerOptions?: Record<string, Record<string, unknown>>;
+    readonly http?: HttpOptions;
+}
+export declare const ImageModelSchema: Schema.declare<ImageModel, ImageModel>;
+export declare const ImageSize: Schema.Struct<{
+    readonly width: Schema.Int;
+    readonly height: Schema.Int;
+}>;
+export type ImageSize = Schema.Schema.Type<typeof ImageSize>;
+declare const ImageRequest_base: Schema.Class<ImageRequest, Schema.Struct<{
+    readonly model: Schema.declare<ImageModel, ImageModel>;
+    readonly prompt: Schema.String;
+    readonly count: Schema.optional<Schema.Int>;
+    readonly size: Schema.optional<Schema.Struct<{
+        readonly width: Schema.Int;
+        readonly height: Schema.Int;
+    }>>;
+    readonly aspectRatio: Schema.optional<Schema.String>;
+    readonly seed: Schema.optional<Schema.Number>;
+    readonly providerOptions: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+    readonly http: Schema.optional<typeof HttpOptions>;
+    readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+}>, {}>;
+export declare class ImageRequest extends ImageRequest_base {
+}
+export type ImageRequestInput = Omit<ConstructorParameters<typeof ImageRequest>[0], "http"> & {
+    readonly http?: HttpOptions.Input;
+};
+declare const GeneratedImage_base: Schema.Class<GeneratedImage, Schema.Struct<{
+    readonly mediaType: Schema.String;
+    readonly data: Schema.Union<readonly [Schema.String, Schema.Uint8Array]>;
+    readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+}>, {}>;
+export declare class GeneratedImage extends GeneratedImage_base {
+}
+declare const ImageResponse_base: Schema.Class<ImageResponse, Schema.Struct<{
+    readonly images: Schema.$Array<typeof GeneratedImage>;
+    readonly usage: Schema.optional<typeof Usage>;
+    readonly providerMetadata: Schema.optional<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>;
+}>, {}>;
+export declare class ImageResponse extends ImageResponse_base {
+    get image(): GeneratedImage;
+}
+export declare const request: (input: ImageRequest | ImageRequestInput) => ImageRequest;
+export declare const generate: (input: ImageRequest | ImageRequestInput) => Effect.Effect<ImageResponse, LLMError, never>;
+export declare const Image: {
+    readonly request: (input: ImageRequest | ImageRequestInput) => ImageRequest;
+    readonly generate: (input: ImageRequest | ImageRequestInput) => Effect.Effect<ImageResponse, LLMError, never>;
+};
+export {};

package/dist/image.js

@@ -0,0 +1,77 @@
+import { Effect, Schema } from "effect";
+import { HttpOptions, InvalidRequestReason, LLMError, ModelID, ProviderID, ProviderMetadata, Usage } from "./schema";
+import { ImageClient } from "./image-client";
+export class ImageModel {
+    id;
+    provider;
+    route;
+    defaults;
+    constructor(input) {
+        this.id = input.id;
+        this.provider = input.provider;
+        this.route = input.route;
+        this.defaults = input.defaults;
+    }
+    static make(input) {
+        return new ImageModel({
+            id: ModelID.make(input.id),
+            provider: ProviderID.make(input.provider),
+            route: input.route,
+            defaults: input.defaults,
+        });
+    }
+}
+export const ImageModelSchema = Schema.declare((value) => value instanceof ImageModel, {
+    expected: "Image.Model",
+});
+export const ImageSize = Schema.Struct({
+    width: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)),
+    height: Schema.Int.check(Schema.isGreaterThanOrEqualTo(1)),
+}).annotate({ identifier: "Image.Size" });
+export class ImageRequest extends Schema.Class("Image.Request")({
+    model: ImageModelSchema,
+    prompt: Schema.String,
+    count: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(1))),
+    size: Schema.optional(ImageSize),
+    aspectRatio: Schema.optional(Schema.String),
+    seed: Schema.optional(Schema.Number),
+    providerOptions: Schema.optional(Schema.Record(Schema.String, Schema.Record(Schema.String, Schema.Unknown))),
+    http: Schema.optional(HttpOptions),
+    metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+}) {
+}
+export class GeneratedImage extends Schema.Class("Image.Generated")({
+    mediaType: Schema.String,
+    data: Schema.Union([Schema.String, Schema.Uint8Array]),
+    providerMetadata: Schema.optional(ProviderMetadata),
+}) {
+}
+export class ImageResponse extends Schema.Class("Image.Response")({
+    images: Schema.Array(GeneratedImage),
+    usage: Schema.optional(Usage),
+    providerMetadata: Schema.optional(ProviderMetadata),
+}) {
+    get image() {
+        return this.images[0];
+    }
+}
+export const request = (input) => {
+    if (input instanceof ImageRequest)
+        return input;
+    return new ImageRequest({
+        ...input,
+        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+    });
+};
+export const generate = (input) => Effect.try({
+    try: () => request(input),
+    catch: (error) => new LLMError({
+        module: "Image",
+        method: "generate",
+        reason: new InvalidRequestReason({ message: error instanceof Error ? error.message : String(error) }),
+    }),
+}).pipe(Effect.flatMap(ImageClient.generate));
+export const Image = {
+    request,
+    generate,
+};

package/dist/index.d.ts

@@ -1,10 +1,14 @@
 export { LLMClient } from "./route/client";
+export { ImageClient } from "./image-client";
 export { Auth } from "./route/auth";
 export { Provider } from "./provider";
 export { ProviderPackage } from "./provider-package";
 export { isContextOverflow, isContextOverflowFailure } from "./provider-error";
 export type { RouteModelInput, RouteRoutedModelInput, Interface as LLMClientShape, Service as LLMClientService, } from "./route/client";
 export * from "./schema";
+export { GeneratedImage, ImageModel, ImageRequest, ImageResponse, ImageSize } from "./image";
+export type { ImageModelDefaults, ImageRequestInput, ImageRoute } from "./image";
+export { Image } from "./image";
 export { Tool, ToolFailure, toDefinitions } from "./tool";
 export { ToolRuntime } from "./tool-runtime";
 export type { DispatchResult as ToolDispatchResult, ToolSettlement } from "./tool-runtime";

package/dist/index.js

@@ -1,9 +1,12 @@
 export { LLMClient } from "./route/client";
+export { ImageClient } from "./image-client";
 export { Auth } from "./route/auth";
 export { Provider } from "./provider";
 export { ProviderPackage } from "./provider-package";
 export { isContextOverflow, isContextOverflowFailure } from "./provider-error";
 export * from "./schema";
+export { GeneratedImage, ImageModel, ImageRequest, ImageResponse, ImageSize } from "./image";
+export { Image } from "./image";
 export { Tool, ToolFailure, toDefinitions } from "./tool";
 export { ToolRuntime } from "./tool-runtime";
 export * as LLM from "./llm";

package/dist/protocols/index.d.ts

@@ -2,6 +2,7 @@ export * as AnthropicMessages from "./anthropic-messages";
 export * as BedrockConverse from "./bedrock-converse";
 export * as Gemini from "./gemini";
 export * as OpenAIChat from "./openai-chat";
+export * as OpenAIImages from "./openai-images";
 export * as OpenAICompatibleChat from "./openai-compatible-chat";
 export * as OpenAICompatibleResponses from "./openai-compatible-responses";
 export * as OpenAIResponses from "./openai-responses";

package/dist/protocols/index.js

@@ -2,6 +2,7 @@ export * as AnthropicMessages from "./anthropic-messages";
 export * as BedrockConverse from "./bedrock-converse";
 export * as Gemini from "./gemini";
 export * as OpenAIChat from "./openai-chat";
+export * as OpenAIImages from "./openai-images";
 export * as OpenAICompatibleChat from "./openai-compatible-chat";
 export * as OpenAICompatibleResponses from "./openai-compatible-responses";
 export * as OpenAIResponses from "./openai-responses";

package/dist/protocols/openai-compatible-responses.d.ts

@@ -60,7 +60,7 @@ export declare const route: Route<{
         readonly effort?: string | undefined;
         readonly summary?: "auto" | undefined;
     } | undefined;
-    readonly tools?: readonly {
+    readonly tools?: readonly ({
         readonly type: "function";
         readonly name: string;
         readonly description: string;
@@ -68,11 +68,23 @@ export declare const route: Route<{
             readonly [x: string]: unknown;
         };
         readonly strict?: boolean | undefined;
-    }[] | undefined;
+    } | {
+        readonly type: "image_generation";
+        readonly size?: string | undefined;
+        readonly quality?: "low" | "medium" | "high" | "auto" | undefined;
+        readonly background?: "auto" | "opaque" | "transparent" | undefined;
+        readonly output_format?: "png" | "jpeg" | "webp" | undefined;
+        readonly output_compression?: number | undefined;
+        readonly action?: "generate" | "auto" | "edit" | undefined;
+        readonly input_fidelity?: "low" | "high" | undefined;
+        readonly partial_images?: number | undefined;
+    })[] | undefined;
     readonly temperature?: number | undefined;
     readonly tool_choice?: "required" | "none" | "auto" | import("effect/Schema").Struct.ReadonlySide<{
         readonly type: import("effect/Schema").tag<"function">;
         readonly name: import("effect/Schema").String;
+    }, "Type"> | import("effect/Schema").Struct.ReadonlySide<{
+        readonly type: import("effect/Schema").tag<"image_generation">;
     }, "Type"> | undefined;
     readonly top_p?: number | undefined;
     readonly store?: boolean | undefined;

package/dist/protocols/openai-images.d.ts

@@ -0,0 +1,36 @@
+import { Schema } from "effect";
+import { ImageModel, type ImageModelDefaults } from "../image";
+import { type Definition as AuthDefinition } from "../route/auth";
+export declare const DEFAULT_BASE_URL = "https://api.openai.com/v1";
+export declare const PATH = "/images/generations";
+export interface OpenAIImageOptions {
+    readonly quality?: "auto" | "low" | "medium" | "high";
+    readonly background?: "auto" | "opaque" | "transparent";
+    readonly moderation?: "auto" | "low";
+    readonly outputFormat?: "png" | "jpeg" | "webp";
+    readonly outputCompression?: number;
+}
+declare const OpenAIImageBody: Schema.Struct<{
+    readonly model: Schema.String;
+    readonly prompt: Schema.String;
+    readonly n: Schema.optional<Schema.Int>;
+    readonly size: Schema.optional<Schema.String>;
+    readonly quality: Schema.optional<Schema.Literals<readonly ["auto", "low", "medium", "high"]>>;
+    readonly background: Schema.optional<Schema.Literals<readonly ["auto", "opaque", "transparent"]>>;
+    readonly moderation: Schema.optional<Schema.Literals<readonly ["auto", "low"]>>;
+    readonly output_format: Schema.optional<Schema.Literals<readonly ["png", "jpeg", "webp"]>>;
+    readonly output_compression: Schema.optional<Schema.Int>;
+}>;
+export type OpenAIImageBody = Schema.Schema.Type<typeof OpenAIImageBody>;
+export interface ModelInput {
+    readonly id: string;
+    readonly auth: AuthDefinition;
+    readonly baseURL?: string;
+    readonly headers?: Record<string, string>;
+    readonly defaults?: ImageModelDefaults;
+}
+export declare const model: (input: ModelInput) => ImageModel;
+export declare const OpenAIImages: {
+    readonly model: (input: ModelInput) => ImageModel;
+};
+export {};

package/dist/protocols/openai-images.js

@@ -0,0 +1,145 @@
+import { Effect, Encoding, Schema } from "effect";
+import { Headers, HttpClientRequest } from "effect/unstable/http";
+import { ImageModel, GeneratedImage, ImageResponse, } from "../image";
+import { Auth } from "../route/auth";
+import { InvalidProviderOutputReason, LLMError, Usage, mergeHttpOptions, mergeJsonRecords } from "../schema";
+import { ProviderShared } from "./shared";
+import { OpenAIImage } from "./utils/openai-image";
+const ADAPTER = "openai-images";
+export const DEFAULT_BASE_URL = "https://api.openai.com/v1";
+export const PATH = "/images/generations";
+const OpenAIImageBody = Schema.Struct({
+    model: Schema.String,
+    prompt: Schema.String,
+    n: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(1))),
+    size: Schema.optional(Schema.String),
+    quality: Schema.optional(Schema.Literals(["auto", "low", "medium", "high"])),
+    background: Schema.optional(Schema.Literals(["auto", "opaque", "transparent"])),
+    moderation: Schema.optional(Schema.Literals(["auto", "low"])),
+    output_format: Schema.optional(Schema.Literals(["png", "jpeg", "webp"])),
+    output_compression: Schema.optional(Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: 100 }))),
+});
+const OpenAIImageResponse = Schema.Struct({
+    data: Schema.Array(Schema.Struct({
+        b64_json: Schema.optional(Schema.String),
+        url: Schema.optional(Schema.String),
+        revised_prompt: Schema.optional(Schema.String),
+    })),
+    output_format: Schema.optional(Schema.String),
+    usage: Schema.optional(Schema.Struct({
+        input_tokens: Schema.optional(Schema.Number),
+        output_tokens: Schema.optional(Schema.Number),
+        total_tokens: Schema.optional(Schema.Number),
+        input_tokens_details: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+        output_tokens_details: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+    })),
+});
+const providerOptions = (request) => ({
+    ...request.model.defaults?.providerOptions?.openai,
+    ...request.providerOptions?.openai,
+});
+const body = (request) => {
+    const options = providerOptions(request);
+    return {
+        model: request.model.id,
+        prompt: request.prompt,
+        n: request.count,
+        size: request.size === undefined ? undefined : `${request.size.width}x${request.size.height}`,
+        quality: options.quality,
+        background: options.background,
+        moderation: options.moderation,
+        output_format: options.outputFormat,
+        output_compression: options.outputCompression,
+    };
+};
+const invalidOutput = (message) => new LLMError({
+    module: ADAPTER,
+    method: "generate",
+    reason: new InvalidProviderOutputReason({ message, route: ADAPTER }),
+});
+const applyQuery = (url, query) => {
+    if (!query)
+        return url;
+    const next = new URL(url);
+    Object.entries(query).forEach(([key, value]) => next.searchParams.set(key, value));
+    return next.toString();
+};
+const PROTOCOL_BODY_FIELDS = new Set([
+    "model",
+    "prompt",
+    "n",
+    "size",
+    "quality",
+    "background",
+    "moderation",
+    "output_format",
+    "output_compression",
+]);
+const bodyWithOverlay = Effect.fn("OpenAIImages.bodyWithOverlay")(function* (imageBody, overlay) {
+    if (!overlay)
+        return imageBody;
+    const reserved = Object.keys(overlay).filter((key) => PROTOCOL_BODY_FIELDS.has(key));
+    if (reserved.length > 0)
+        return yield* ProviderShared.invalidRequest(`http.body cannot overlay protocol-owned field(s): ${reserved.join(", ")}`);
+    return mergeJsonRecords(imageBody, overlay) ?? imageBody;
+});
+export const model = (input) => {
+    const route = {
+        id: ADAPTER,
+        generate: Effect.fn("OpenAIImages.generate")(function* (request, execute) {
+            if (request.aspectRatio !== undefined)
+                return yield* ProviderShared.invalidRequest("OpenAI Images does not support the common aspectRatio option");
+            if (request.seed !== undefined)
+                return yield* ProviderShared.invalidRequest("OpenAI Images does not support the common seed option");
+            const requestBody = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(OpenAIImageBody))(body(request));
+            const http = mergeHttpOptions(request.model.defaults?.http, request.http);
+            const overlaidBody = yield* bodyWithOverlay(requestBody, http?.body);
+            const text = ProviderShared.encodeJson(overlaidBody);
+            const url = applyQuery(`${(input.baseURL ?? DEFAULT_BASE_URL).replace(/\/$/, "")}${PATH}`, http?.query);
+            const headers = yield* Auth.toEffect(input.auth)({
+                request,
+                method: "POST",
+                url,
+                body: text,
+                headers: Headers.fromInput({ ...input.headers, ...http?.headers }),
+            });
+            const response = yield* execute(HttpClientRequest.post(url).pipe(HttpClientRequest.setHeaders(headers), HttpClientRequest.bodyText(text, "application/json")));
+            const payload = yield* response.json.pipe(Effect.mapError(() => invalidOutput("Failed to read the OpenAI Images response")));
+            const decoded = yield* Schema.decodeUnknownEffect(OpenAIImageResponse)(payload).pipe(Effect.mapError(() => invalidOutput("OpenAI Images returned an invalid response")));
+            const format = decoded.output_format ?? providerOptions(request).outputFormat ?? "png";
+            const images = yield* Effect.forEach(decoded.data, (item, index) => {
+                if (item.b64_json)
+                    return Effect.fromResult(Encoding.decodeBase64(item.b64_json)).pipe(Effect.mapError(() => invalidOutput(`OpenAI Images result ${index} contains invalid base64 data`)), Effect.map((data) => new GeneratedImage({
+                        mediaType: `image/${format}`,
+                        data,
+                        providerMetadata: item.revised_prompt === undefined ? undefined : { openai: { revisedPrompt: item.revised_prompt } },
+                    })));
+                if (item.url)
+                    return Effect.succeed(new GeneratedImage({
+                        mediaType: `image/${format}`,
+                        data: item.url,
+                        providerMetadata: item.revised_prompt === undefined ? undefined : { openai: { revisedPrompt: item.revised_prompt } },
+                    }));
+                return Effect.fail(invalidOutput(`OpenAI Images result ${index} has neither image data nor a URL`));
+            });
+            if (images.length === 0)
+                return yield* invalidOutput("OpenAI Images returned no images");
+            return new ImageResponse({
+                images,
+                usage: decoded.usage === undefined
+                    ? undefined
+                    : new Usage({
+                        inputTokens: decoded.usage.input_tokens,
+                        outputTokens: decoded.usage.output_tokens,
+                        totalTokens: decoded.usage.total_tokens,
+                        providerMetadata: { openai: decoded.usage },
+                    }),
+                providerMetadata: { openai: { outputFormat: format } },
+            });
+        }),
+    };
+    return ImageModel.make({ id: input.id, provider: "openai", route, defaults: input.defaults });
+};
+export const OpenAIImages = {
+    model,
+};