@opencode-ai/ai 0.0.0-next-15898 → 0.0.0-next-15903

package/README.md

@@ -36,15 +36,33 @@ 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" } },
+    options: {
+      n: 2,
+      size: "1024x1024",
+      quality: "high", // inferred from the OpenAI image model
+      outputFormat: "webp",
+      future_option: true, // unknown native options pass through unchanged
+    },
   })
 
   return response.images // GeneratedImage[] with owned bytes or a provider URL
 })
 ```
 
+Provider-native image options belong to each request. Raw `http.body` fields have final precedence over them:
+
+```ts
+const model = OpenAI.configure({ apiKey }).image("gpt-image-2")
+
+yield *
+  Image.generate({
+    model,
+    prompt,
+    options: { quality: "medium" },
+    http,
+  })
+```
+
 Conversational image generation remains part of the LLM interaction. OpenAI Responses exposes it through its hosted image tool:
 
 ```ts

package/dist/image-client.d.ts

@@ -1,19 +1,19 @@
 import { Context, Effect, Layer } from "effect";
 import { RequestExecutor } from "./route/executor";
-import type { ImageRequest, ImageResponse } from "./image";
+import type { ImageOptions, ImageRequestFor, 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>;
+    readonly generate: <Options extends ImageOptions>(request: ImageRequestFor<Options>) => 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 generate: <Options extends ImageOptions>(request: ImageRequestFor<Options>) => 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>;
+    readonly generate: <Options extends ImageOptions>(request: ImageRequestFor<Options>) => Effect.Effect<ImageResponse, LLMError>;
 };
 export {};

package/dist/image.d.ts

@@ -1,59 +1,52 @@
 import { Effect, Schema } from "effect";
 import { HttpOptions, LLMError, ModelID, ProviderID, Usage } from "./schema";
-import { type Execute as ImageExecute } from "./image-client";
-export interface ImageRoute {
+import { Service, type Execute as ImageExecute } from "./image-client";
+export interface ImageRoute<Options extends ImageOptions = ImageOptions> {
     readonly id: string;
-    readonly generate: (request: ImageRequest, execute: ImageExecute) => Effect.Effect<ImageResponse, LLMError>;
+    readonly generate: (request: ImageRequestFor<Options>, execute: ImageExecute) => Effect.Effect<ImageResponse, LLMError>;
 }
-export declare class ImageModel {
+export type ImageOptions = Record<string, unknown>;
+export declare class ImageModel<Options extends ImageOptions = ImageOptions> {
+    protected readonly _Options: (options: Options) => Options;
     readonly id: ModelID;
     readonly provider: ProviderID;
-    readonly route: ImageRoute;
-    readonly defaults?: ImageModelDefaults;
-    constructor(input: ImageModel.Input);
-    static make(input: ImageModel.MakeInput): ImageModel;
+    readonly route: ImageRoute<Options>;
+    readonly http?: HttpOptions;
+    constructor(input: ImageModel.Input<Options>);
+    static make<Options extends ImageOptions = ImageOptions>(input: ImageModel.MakeInput<Options>): ImageModel<Options>;
 }
 export declare namespace ImageModel {
-    interface Input {
+    interface Input<Options extends ImageOptions = ImageOptions> {
         readonly id: ModelID;
         readonly provider: ProviderID;
-        readonly route: ImageRoute;
-        readonly defaults?: ImageModelDefaults;
+        readonly route: ImageRoute<Options>;
+        readonly http?: HttpOptions;
     }
-    interface MakeInput extends Omit<Input, "id" | "provider"> {
+    interface MakeInput<Options extends ImageOptions = ImageOptions> extends Omit<Input<Options>, "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>;
+export declare const ImageModelSchema: Schema.declare<ImageModel<ImageOptions>, ImageModel<ImageOptions>>;
 declare const ImageRequest_base: Schema.Class<ImageRequest, Schema.Struct<{
-    readonly model: Schema.declare<ImageModel, ImageModel>;
+    readonly model: Schema.declare<ImageModel<ImageOptions>, ImageModel<ImageOptions>>;
     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 options: Schema.optional<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 {
+    protected readonly _ImageRequest: void;
 }
-export type ImageRequestInput = Omit<ConstructorParameters<typeof ImageRequest>[0], "http"> & {
-    readonly http?: HttpOptions.Input;
+export type ImageRequestFor<Options extends ImageOptions = ImageOptions> = Omit<ImageRequest, "model" | "options"> & {
+    readonly model: ImageModel<Options>;
+    readonly options?: Options;
 };
+export type ImageModelOptions<Model> = Model extends ImageModel<infer Options> ? Options : never;
+export type ImageRequestInput<Model extends object = ImageModel> = Omit<ConstructorParameters<typeof ImageRequest>[0], "model" | "options" | "http"> & {
+    readonly model: Model;
+    readonly options?: NoInfer<ImageModelOptions<Model>>;
+    readonly http?: HttpOptions.Input;
+} & (Model extends ImageModel<ImageModelOptions<Model>> ? unknown : never);
 declare const GeneratedImage_base: Schema.Class<GeneratedImage, Schema.Struct<{
     readonly mediaType: Schema.String;
     readonly data: Schema.Union<readonly [Schema.String, Schema.Uint8Array]>;
@@ -69,10 +62,12 @@ declare const ImageResponse_base: Schema.Class<ImageResponse, Schema.Struct<{
 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 function request<const Model extends object>(input: ImageRequestInput<Model>): ImageRequestFor<ImageModelOptions<Model>>;
+export declare function request(input: ImageRequest): ImageRequest;
+export declare function generate<const Model extends object>(input: ImageRequestInput<Model>): Effect.Effect<ImageResponse, LLMError, Service>;
+export declare function generate(input: ImageRequest): Effect.Effect<ImageResponse, LLMError, Service>;
 export declare const Image: {
-    readonly request: (input: ImageRequest | ImageRequestInput) => ImageRequest;
-    readonly generate: (input: ImageRequest | ImageRequestInput) => Effect.Effect<ImageResponse, LLMError, never>;
+    readonly request: typeof request;
+    readonly generate: typeof generate;
 };
 export {};

package/dist/image.js

@@ -1,43 +1,34 @@
 import { Effect, Schema } from "effect";
 import { HttpOptions, InvalidRequestReason, LLMError, ModelID, ProviderID, ProviderMetadata, Usage } from "./schema";
-import { ImageClient } from "./image-client";
+import { ImageClient, Service } from "./image-client";
 export class ImageModel {
     id;
     provider;
     route;
-    defaults;
+    http;
     constructor(input) {
         this.id = input.id;
         this.provider = input.provider;
         this.route = input.route;
-        this.defaults = input.defaults;
+        this.http = input.http;
     }
     static make(input) {
         return new ImageModel({
             id: ModelID.make(input.id),
             provider: ProviderID.make(input.provider),
             route: input.route,
-            defaults: input.defaults,
+            http: input.http,
         });
     }
 }
 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))),
+    options: Schema.optional(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")({
@@ -55,22 +46,25 @@ export class ImageResponse extends Schema.Class("Image.Response")({
         return this.images[0];
     }
 }
-export const request = (input) => {
+export function request(input) {
     if (input instanceof ImageRequest)
         return input;
     return new ImageRequest({
         ...input,
+        model: input.model,
         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 function generate(input) {
+    return Effect.try({
+        try: () => (input instanceof ImageRequest ? input : request(input)),
+        catch: (error) => new LLMError({
+            module: "Image",
+            method: "generate",
+            reason: new InvalidRequestReason({ message: error instanceof Error ? error.message : String(error) }),
+        }),
+    }).pipe(Effect.flatMap((request) => ImageClient.generate(request)));
+}
 export const Image = {
     request,
     generate,

package/dist/index.d.ts

@@ -6,8 +6,8 @@ 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 { GeneratedImage, ImageModel, ImageRequest, ImageResponse } from "./image";
+export type { ImageModelOptions, ImageOptions, ImageRequestFor, ImageRequestInput, ImageRoute } from "./image";
 export { Image } from "./image";
 export { Tool, ToolFailure, toDefinitions } from "./tool";
 export { ToolRuntime } from "./tool-runtime";

package/dist/index.js

@@ -5,7 +5,7 @@ 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 { GeneratedImage, ImageModel, ImageRequest, ImageResponse } from "./image";
 export { Image } from "./image";
 export { Tool, ToolFailure, toDefinitions } from "./tool";
 export { ToolRuntime } from "./tool-runtime";

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

@@ -70,14 +70,14 @@ export declare const route: Route<{
         readonly strict?: boolean | 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 background?: "auto" | "opaque" | "transparent" | undefined;
         readonly input_fidelity?: "low" | "high" | undefined;
         readonly partial_images?: number | undefined;
+        readonly quality?: "low" | "medium" | "high" | "auto" | undefined;
+        readonly size?: string | undefined;
     })[] | undefined;
     readonly temperature?: number | undefined;
     readonly tool_choice?: "required" | "none" | "auto" | import("effect/Schema").Struct.ReadonlySide<{

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

@@ -1,36 +1,30 @@
-import { Schema } from "effect";
-import { ImageModel, type ImageModelDefaults } from "../image";
+import { ImageModel } from "../image";
 import { type Definition as AuthDefinition } from "../route/auth";
+import { type HttpOptions } from "../schema";
 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";
+export type OpenAIImageString<Known extends string> = Known | (string & {});
+export type OpenAIImageOptions = {
+    readonly n?: number;
+    readonly size?: OpenAIImageString<"auto" | "256x256" | "512x512" | "1024x1024" | "1536x1024" | "1024x1536" | "1792x1024" | "1024x1792">;
+    readonly quality?: OpenAIImageString<"auto" | "low" | "medium" | "high" | "standard" | "hd">;
+    readonly background?: OpenAIImageString<"auto" | "opaque" | "transparent">;
+    readonly moderation?: OpenAIImageString<"auto" | "low">;
+    readonly outputFormat?: OpenAIImageString<"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>;
+} & Record<string, unknown>;
+export type OpenAIImageBody = Record<string, unknown> & {
+    readonly model: string;
+    readonly prompt: string;
+};
 export interface ModelInput {
     readonly id: string;
     readonly auth: AuthDefinition;
     readonly baseURL?: string;
     readonly headers?: Record<string, string>;
-    readonly defaults?: ImageModelDefaults;
+    readonly http?: HttpOptions;
 }
-export declare const model: (input: ModelInput) => ImageModel;
+export declare const model: (input: ModelInput) => ImageModel<OpenAIImageOptions>;
 export declare const OpenAIImages: {
-    readonly model: (input: ModelInput) => ImageModel;
+    readonly model: (input: ModelInput) => ImageModel<OpenAIImageOptions>;
 };
-export {};

package/dist/protocols/openai-images.js

@@ -1,24 +1,13 @@
 import { Effect, Encoding, Schema } from "effect";
 import { Headers, HttpClientRequest } from "effect/unstable/http";
-import { ImageModel, GeneratedImage, ImageResponse, } from "../image";
+import { ImageModel, GeneratedImage, ImageResponse } from "../image";
 import { Auth } from "../route/auth";
-import { InvalidProviderOutputReason, LLMError, Usage, mergeHttpOptions, mergeJsonRecords } from "../schema";
+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),
@@ -34,22 +23,14 @@ const OpenAIImageResponse = Schema.Struct({
         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);
+const nativeOptions = (options) => {
+    if (!options)
+        return undefined;
+    const { outputFormat, outputCompression, ...native } = options;
     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,
+        output_format: outputFormat,
+        output_compression: outputCompression,
+        ...native,
     };
 };
 const invalidOutput = (message) => new LLMError({
@@ -64,37 +45,13 @@ const applyQuery = (url, query) => {
     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 http = mergeHttpOptions(request.model.http, request.http);
+            const requestBody = mergeJsonRecords({ model: request.model.id, prompt: request.prompt }, nativeOptions(request.options), http?.body);
+            const text = ProviderShared.encodeJson(requestBody);
             const url = applyQuery(`${(input.baseURL ?? DEFAULT_BASE_URL).replace(/\/$/, "")}${PATH}`, http?.query);
             const headers = yield* Auth.toEffect(input.auth)({
                 request,
@@ -106,7 +63,7 @@ export const model = (input) => {
             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 format = decoded.output_format ?? (typeof requestBody.output_format === "string" ? requestBody.output_format : "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({
@@ -138,7 +95,7 @@ export const model = (input) => {
             });
         }),
     };
-    return ImageModel.make({ id: input.id, provider: "openai", route, defaults: input.defaults });
+    return ImageModel.make({ id: input.id, provider: "openai", route, http: input.http });
 };
 export const OpenAIImages = {
     model,

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

@@ -164,14 +164,14 @@ export declare const protocol: Protocol<{
         readonly strict?: boolean | 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 background?: "auto" | "opaque" | "transparent" | undefined;
         readonly input_fidelity?: "low" | "high" | undefined;
         readonly partial_images?: number | undefined;
+        readonly quality?: "low" | "medium" | "high" | "auto" | undefined;
+        readonly size?: string | undefined;
     })[] | undefined;
     readonly temperature?: number | undefined;
     readonly tool_choice?: "required" | "none" | "auto" | Schema.Struct.ReadonlySide<{
@@ -316,14 +316,14 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
         readonly strict?: boolean | 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 background?: "auto" | "opaque" | "transparent" | undefined;
         readonly input_fidelity?: "low" | "high" | undefined;
         readonly partial_images?: number | undefined;
+        readonly quality?: "low" | "medium" | "high" | "auto" | undefined;
+        readonly size?: string | undefined;
     })[] | undefined;
     readonly temperature?: number | undefined;
     readonly tool_choice?: "required" | "none" | "auto" | Schema.Struct.ReadonlySide<{
@@ -405,14 +405,14 @@ export declare const route: Route<{
         readonly strict?: boolean | 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 background?: "auto" | "opaque" | "transparent" | undefined;
         readonly input_fidelity?: "low" | "high" | undefined;
         readonly partial_images?: number | undefined;
+        readonly quality?: "low" | "medium" | "high" | "auto" | undefined;
+        readonly size?: string | undefined;
     })[] | undefined;
     readonly temperature?: number | undefined;
     readonly tool_choice?: "required" | "none" | "auto" | Schema.Struct.ReadonlySide<{
@@ -494,14 +494,14 @@ export declare const webSocketTransport: import("../route/transport/websocket").
         readonly strict?: boolean | 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 background?: "auto" | "opaque" | "transparent" | undefined;
         readonly input_fidelity?: "low" | "high" | undefined;
         readonly partial_images?: number | undefined;
+        readonly quality?: "low" | "medium" | "high" | "auto" | undefined;
+        readonly size?: string | undefined;
     })[] | undefined;
     readonly temperature?: number | undefined;
     readonly tool_choice?: "required" | "none" | "auto" | Schema.Struct.ReadonlySide<{
@@ -583,14 +583,14 @@ export declare const webSocketTransport: import("../route/transport/websocket").
         readonly strict?: boolean | 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 background?: "auto" | "opaque" | "transparent" | undefined;
         readonly input_fidelity?: "low" | "high" | undefined;
         readonly partial_images?: number | undefined;
+        readonly quality?: "low" | "medium" | "high" | "auto" | undefined;
+        readonly size?: string | undefined;
     })[] | undefined;
     readonly temperature?: number | undefined;
     readonly tool_choice?: "required" | "none" | "auto" | Schema.Struct.ReadonlySide<{
@@ -672,14 +672,14 @@ export declare const webSocketRoute: Route<{
         readonly strict?: boolean | 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 background?: "auto" | "opaque" | "transparent" | undefined;
         readonly input_fidelity?: "low" | "high" | undefined;
         readonly partial_images?: number | undefined;
+        readonly quality?: "low" | "medium" | "high" | "auto" | undefined;
+        readonly size?: string | undefined;
     })[] | undefined;
     readonly temperature?: number | undefined;
     readonly tool_choice?: "required" | "none" | "auto" | Schema.Struct.ReadonlySide<{

package/dist/providers/azure.d.ts

@@ -149,14 +149,14 @@ export declare const routes: (RouteDef<{
         readonly strict?: boolean | 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 background?: "auto" | "opaque" | "transparent" | undefined;
         readonly input_fidelity?: "low" | "high" | undefined;
         readonly partial_images?: number | undefined;
+        readonly quality?: "low" | "medium" | "high" | "auto" | undefined;
+        readonly size?: string | undefined;
     })[] | undefined;
     readonly temperature?: number | undefined;
     readonly tool_choice?: "required" | "none" | "auto" | import("effect/Schema").Struct.ReadonlySide<{

package/dist/providers/github-copilot.d.ts

@@ -137,14 +137,14 @@ export declare const routes: (import("../route").Route<{
         readonly strict?: boolean | 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 background?: "auto" | "opaque" | "transparent" | undefined;
         readonly input_fidelity?: "low" | "high" | undefined;
         readonly partial_images?: number | undefined;
+        readonly quality?: "low" | "medium" | "high" | "auto" | undefined;
+        readonly size?: string | undefined;
     })[] | undefined;
     readonly temperature?: number | undefined;
     readonly tool_choice?: "required" | "none" | "auto" | import("effect/Schema").Struct.ReadonlySide<{

package/dist/providers/google-vertex-responses.d.ts

@@ -81,14 +81,14 @@ export declare const routes: import("../route").Route<{
         readonly strict?: boolean | 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 background?: "auto" | "opaque" | "transparent" | undefined;
         readonly input_fidelity?: "low" | "high" | undefined;
         readonly partial_images?: number | undefined;
+        readonly quality?: "low" | "medium" | "high" | "auto" | undefined;
+        readonly size?: string | undefined;
     })[] | undefined;
     readonly temperature?: number | undefined;
     readonly tool_choice?: "required" | "none" | "auto" | import("effect/Schema").Struct.ReadonlySide<{

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

@@ -79,14 +79,14 @@ export declare const routes: import("../route").Route<{
         readonly strict?: boolean | 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 background?: "auto" | "opaque" | "transparent" | undefined;
         readonly input_fidelity?: "low" | "high" | undefined;
         readonly partial_images?: number | undefined;
+        readonly quality?: "low" | "medium" | "high" | "auto" | undefined;
+        readonly size?: string | undefined;
     })[] | undefined;
     readonly temperature?: number | undefined;
     readonly tool_choice?: "required" | "none" | "auto" | import("effect/Schema").Struct.ReadonlySide<{

package/dist/providers/openai.d.ts

@@ -3,7 +3,7 @@ import type { Route, RouteDefaultsInput } from "../route/client";
 import type { ProviderPackage } from "../provider-package";
 import { ToolDefinition, type ModelID } from "../schema";
 import { type OpenAIProviderOptionsInput } from "./openai-options";
-import { type OpenAIImageOptions } from "../protocols/openai-images";
+import { type OpenAIImageString } from "../protocols/openai-images";
 export type { OpenAIOptionsInput, OpenAIResponseIncludable } from "./openai-options";
 export type { OpenAIImageOptions } from "../protocols/openai-images";
 export declare const id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
@@ -135,14 +135,14 @@ export declare const routes: (Route<{
         readonly strict?: boolean | 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 background?: "auto" | "opaque" | "transparent" | undefined;
         readonly input_fidelity?: "low" | "high" | undefined;
         readonly partial_images?: number | undefined;
+        readonly quality?: "low" | "medium" | "high" | "auto" | undefined;
+        readonly size?: string | undefined;
     })[] | undefined;
     readonly temperature?: number | undefined;
     readonly tool_choice?: "required" | "none" | "auto" | import("effect/Schema").Struct.ReadonlySide<{
@@ -223,14 +223,14 @@ export declare const routes: (Route<{
         readonly strict?: boolean | 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 background?: "auto" | "opaque" | "transparent" | undefined;
         readonly input_fidelity?: "low" | "high" | undefined;
         readonly partial_images?: number | undefined;
+        readonly quality?: "low" | "medium" | "high" | "auto" | undefined;
+        readonly size?: string | undefined;
     })[] | undefined;
     readonly temperature?: number | undefined;
     readonly tool_choice?: "required" | "none" | "auto" | import("effect/Schema").Struct.ReadonlySide<{
@@ -251,20 +251,16 @@ export type Config = RouteDefaultsInput & ProviderAuthOption<"optional"> & {
     readonly baseURL?: string;
     readonly queryParams?: Record<string, string>;
     readonly providerOptions?: OpenAIProviderOptionsInput;
-    readonly image?: ImageConfig;
 };
-export interface ImageConfig {
-    readonly providerOptions?: OpenAIImageOptions;
-}
 export interface ImageGenerationOptions {
-    readonly action?: "auto" | "generate" | "edit";
-    readonly background?: "auto" | "opaque" | "transparent";
-    readonly inputFidelity?: "low" | "high";
+    readonly action?: OpenAIImageString<"auto" | "generate" | "edit">;
+    readonly background?: OpenAIImageString<"auto" | "opaque" | "transparent">;
+    readonly inputFidelity?: OpenAIImageString<"low" | "high">;
     readonly outputCompression?: number;
-    readonly outputFormat?: "png" | "jpeg" | "webp";
+    readonly outputFormat?: OpenAIImageString<"png" | "jpeg" | "webp">;
     readonly partialImages?: number;
-    readonly quality?: "auto" | "low" | "medium" | "high";
-    readonly size?: string;
+    readonly quality?: OpenAIImageString<"auto" | "low" | "medium" | "high" | "standard" | "hd">;
+    readonly size?: OpenAIImageString<"auto" | "256x256" | "512x512" | "1024x1024" | "1536x1024" | "1024x1536" | "1792x1024" | "1024x1792">;
 }
 export declare const imageGeneration: (options?: ImageGenerationOptions) => ToolDefinition;
 export interface Settings extends ProviderPackage.Settings {
@@ -282,7 +278,7 @@ export declare const configure: (input?: Config) => {
     responses: (id: string | ModelID) => import("..").Model;
     responsesWebSocket: (id: string | ModelID) => import("..").Model;
     chat: (id: string | ModelID) => import("..").Model;
-    image: (modelID: string | ModelID) => import("..").ImageModel;
+    image: (modelID: string | ModelID) => import("..").ImageModel<import("./openai").OpenAIImageOptions>;
     configure: (input?: Config) => /*elided*/ any;
 };
 export declare const provider: {
@@ -291,14 +287,14 @@ export declare const provider: {
     responses: (id: string | ModelID) => import("..").Model;
     responsesWebSocket: (id: string | ModelID) => import("..").Model;
     chat: (id: string | ModelID) => import("..").Model;
-    image: (modelID: string | ModelID) => import("..").ImageModel;
+    image: (modelID: string | ModelID) => import("..").ImageModel<import("./openai").OpenAIImageOptions>;
     configure: (input?: Config) => {
         id: string & import("effect/Brand").Brand<"LLM.ProviderID">;
         model: (id: string | ModelID) => import("..").Model;
         responses: (id: string | ModelID) => import("..").Model;
         responsesWebSocket: (id: string | ModelID) => import("..").Model;
         chat: (id: string | ModelID) => import("..").Model;
-        image: (modelID: string | ModelID) => import("..").ImageModel;
+        image: (modelID: string | ModelID) => import("..").ImageModel<import("./openai").OpenAIImageOptions>;
         configure: /*elided*/ any;
     };
 };
@@ -307,4 +303,4 @@ export declare const chatModel: ProviderPackage.Definition<Settings>["model"];
 export declare const responses: (id: string | ModelID) => import("..").Model;
 export declare const responsesWebSocket: (id: string | ModelID) => import("..").Model;
 export declare const chat: (id: string | ModelID) => import("..").Model;
-export declare const image: (modelID: string | ModelID) => import("..").ImageModel;
+export declare const image: (modelID: string | ModelID) => import("..").ImageModel<import("./openai").OpenAIImageOptions>;

package/dist/providers/openai.js

@@ -26,7 +26,7 @@ export const imageGeneration = (options = {}) => ToolDefinition.make({
 });
 const auth = (options) => AuthOptions.bearer(options, "OPENAI_API_KEY");
 const defaults = (input) => {
-    const { apiKey: _, auth: _auth, baseURL: _baseURL, queryParams: _queryParams, image: _image, ...rest } = input;
+    const { apiKey: _, auth: _auth, baseURL: _baseURL, queryParams: _queryParams, ...rest } = input;
     return rest;
 };
 const configuredRoute = (route, input) => route.with({
@@ -46,10 +46,7 @@ export const configure = (input = {}) => {
         auth: auth(input),
         baseURL: input.baseURL,
         headers: input.headers,
-        defaults: {
-            providerOptions: input.image?.providerOptions === undefined ? undefined : { openai: { ...input.image.providerOptions } },
-            http: mergeHttpOptions(input.http === undefined ? undefined : HttpOptions.make(input.http), input.queryParams === undefined ? undefined : new HttpOptions({ query: input.queryParams })),
-        },
+        http: mergeHttpOptions(input.http === undefined ? undefined : HttpOptions.make(input.http), input.queryParams === undefined ? undefined : new HttpOptions({ query: input.queryParams })),
     });
     return {
         id,

package/dist/providers/xai.d.ts

@@ -133,14 +133,14 @@ export declare const routes: (import("../route").Route<{
         readonly strict?: boolean | 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 background?: "auto" | "opaque" | "transparent" | undefined;
         readonly input_fidelity?: "low" | "high" | undefined;
         readonly partial_images?: number | undefined;
+        readonly quality?: "low" | "medium" | "high" | "auto" | undefined;
+        readonly size?: string | undefined;
     })[] | undefined;
     readonly temperature?: number | undefined;
     readonly tool_choice?: "required" | "none" | "auto" | import("effect/Schema").Struct.ReadonlySide<{

package/package.json

@@ -1,13 +1,13 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.0.0-next-15898",
+  "version": "0.0.0-next-15903",
   "name": "@opencode-ai/ai",
   "type": "module",
   "license": "MIT",
   "scripts": {
     "setup:recording-env": "bun run script/setup-recording-env.ts",
     "test": "bun test --timeout 30000 --only-failures",
-    "typecheck": "tsgo --noEmit",
+    "typecheck": "tsgo --noEmit && tsgo --noEmit -p tsconfig.types.json",
     "build": "tsc -p tsconfig.build.json"
   },
   "files": [
@@ -26,7 +26,7 @@
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "4.0.0-beta.98",
-    "@opencode-ai/http-recorder": "0.0.0-next-15898",
+    "@opencode-ai/http-recorder": "0.0.0-next-15903",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.3.13",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",
@@ -35,7 +35,7 @@
   "dependencies": {
     "@smithy/eventstream-codec": "4.2.14",
     "@smithy/util-utf8": "4.2.2",
-    "@opencode-ai/schema": "0.0.0-next-15898",
+    "@opencode-ai/schema": "0.0.0-next-15903",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-beta.98",
     "google-auth-library": "10.5.0"