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

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

@@ -55,16 +55,28 @@ declare const OpenAIResponsesBody: Schema.Struct<{
         }>]>>]>;
     }>]>>;
     readonly instructions: Schema.optional<Schema.String>;
-    readonly tools: Schema.optional<Schema.$Array<Schema.Struct<{
+    readonly tools: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
         readonly type: Schema.tag<"function">;
         readonly name: Schema.String;
         readonly description: Schema.String;
         readonly parameters: Schema.$Record<Schema.String, Schema.Unknown>;
         readonly strict: Schema.optional<Schema.Boolean>;
-    }>>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.tag<"image_generation">;
+        readonly action: Schema.optional<Schema.Literals<readonly ["auto", "generate", "edit"]>>;
+        readonly background: Schema.optional<Schema.Literals<readonly ["auto", "opaque", "transparent"]>>;
+        readonly input_fidelity: Schema.optional<Schema.Literals<readonly ["low", "high"]>>;
+        readonly output_compression: Schema.optional<Schema.Int>;
+        readonly output_format: Schema.optional<Schema.Literals<readonly ["png", "jpeg", "webp"]>>;
+        readonly partial_images: Schema.optional<Schema.Int>;
+        readonly quality: Schema.optional<Schema.Literals<readonly ["auto", "low", "medium", "high"]>>;
+        readonly size: Schema.optional<Schema.String>;
+    }>]>>>;
     readonly tool_choice: Schema.optional<Schema.Union<readonly [Schema.Literals<readonly ["auto", "none", "required"]>, Schema.Struct<{
         readonly type: Schema.tag<"function">;
         readonly name: Schema.String;
+    }>, Schema.Struct<{
+        readonly type: Schema.tag<"image_generation">;
     }>]>>;
     readonly store: Schema.optional<Schema.Boolean>;
     readonly service_tier: Schema.optional<Schema.Literals<readonly ["auto", "default", "flex", "priority"]>>;
@@ -142,7 +154,7 @@ export declare const protocol: Protocol<{
         readonly effort?: string | undefined;
         readonly summary?: "auto" | undefined;
     } | undefined;
-    readonly tools?: readonly {
+    readonly tools?: readonly ({
         readonly type: "function";
         readonly name: string;
         readonly description: string;
@@ -150,11 +162,23 @@ export declare const protocol: Protocol<{
             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" | Schema.Struct.ReadonlySide<{
         readonly type: Schema.tag<"function">;
         readonly name: Schema.String;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly type: Schema.tag<"image_generation">;
     }, "Type"> | undefined;
     readonly top_p?: number | undefined;
     readonly store?: boolean | undefined;
@@ -201,10 +225,12 @@ export declare const protocol: Protocol<{
         readonly error?: unknown;
         readonly name?: string | undefined;
         readonly id?: string | undefined;
+        readonly result?: string | undefined;
         readonly status?: string | undefined;
         readonly output?: unknown;
         readonly code?: string | undefined;
         readonly arguments?: string | undefined;
+        readonly output_format?: "png" | "jpeg" | "webp" | undefined;
         readonly encrypted_content?: string | null | undefined;
         readonly call_id?: string | undefined;
         readonly action?: unknown;
@@ -280,7 +306,7 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
         readonly effort?: string | undefined;
         readonly summary?: "auto" | undefined;
     } | undefined;
-    readonly tools?: readonly {
+    readonly tools?: readonly ({
         readonly type: "function";
         readonly name: string;
         readonly description: string;
@@ -288,11 +314,23 @@ export declare const httpTransport: HttpTransport.HttpJsonTransport<{
             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" | Schema.Struct.ReadonlySide<{
         readonly type: Schema.tag<"function">;
         readonly name: Schema.String;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly type: Schema.tag<"image_generation">;
     }, "Type"> | undefined;
     readonly top_p?: number | undefined;
     readonly store?: boolean | undefined;
@@ -357,7 +395,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;
@@ -365,11 +403,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" | Schema.Struct.ReadonlySide<{
         readonly type: Schema.tag<"function">;
         readonly name: Schema.String;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly type: Schema.tag<"image_generation">;
     }, "Type"> | undefined;
     readonly top_p?: number | undefined;
     readonly store?: boolean | undefined;
@@ -434,7 +484,7 @@ export declare const webSocketTransport: import("../route/transport/websocket").
         readonly effort?: string | undefined;
         readonly summary?: "auto" | undefined;
     } | undefined;
-    readonly tools?: readonly {
+    readonly tools?: readonly ({
         readonly type: "function";
         readonly name: string;
         readonly description: string;
@@ -442,11 +492,23 @@ export declare const webSocketTransport: import("../route/transport/websocket").
             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" | Schema.Struct.ReadonlySide<{
         readonly type: Schema.tag<"function">;
         readonly name: Schema.String;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly type: Schema.tag<"image_generation">;
     }, "Type"> | undefined;
     readonly top_p?: number | undefined;
     readonly store?: boolean | undefined;
@@ -511,7 +573,7 @@ export declare const webSocketTransport: import("../route/transport/websocket").
         readonly effort?: string | undefined;
         readonly summary?: "auto" | undefined;
     } | undefined;
-    readonly tools?: readonly {
+    readonly tools?: readonly ({
         readonly type: "function";
         readonly name: string;
         readonly description: string;
@@ -519,11 +581,23 @@ export declare const webSocketTransport: import("../route/transport/websocket").
             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" | Schema.Struct.ReadonlySide<{
         readonly type: Schema.tag<"function">;
         readonly name: Schema.String;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly type: Schema.tag<"image_generation">;
     }, "Type"> | undefined;
     readonly top_p?: number | undefined;
     readonly store?: boolean | undefined;
@@ -588,7 +662,7 @@ export declare const webSocketRoute: 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;
@@ -596,11 +670,23 @@ export declare const webSocketRoute: 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" | Schema.Struct.ReadonlySide<{
         readonly type: Schema.tag<"function">;
         readonly name: Schema.String;
+    }, "Type"> | Schema.Struct.ReadonlySide<{
+        readonly type: Schema.tag<"image_generation">;
     }, "Type"> | undefined;
     readonly top_p?: number | undefined;
     readonly store?: boolean | undefined;

package/dist/protocols/openai-responses.js

@@ -1,4 +1,4 @@
-import { Effect, Schema } from "effect";
+import { Effect, Encoding, Schema } from "effect";
 import { Route } from "../route/client";
 import { Auth } from "../route/auth";
 import { Endpoint } from "../route/endpoint";
@@ -11,6 +11,7 @@ import { OpenAIOptions } from "./utils/openai-options";
 import { Lifecycle } from "./utils/lifecycle";
 import { ToolSchemaProjection } from "./utils/tool-schema";
 import { ToolStream } from "./utils/tool-stream";
+import { OpenAIImage } from "./utils/openai-image";
 const ADAPTER = "openai-responses";
 export const DEFAULT_BASE_URL = "https://api.openai.com/v1";
 export const PATH = "/responses";
@@ -77,9 +78,22 @@ const OpenAIResponsesTool = Schema.Struct({
     parameters: JsonObject,
     strict: Schema.optional(Schema.Boolean),
 });
+const OpenAIResponsesImageGenerationTool = Schema.Struct({
+    type: Schema.tag("image_generation"),
+    action: Schema.optional(Schema.Literals(["auto", "generate", "edit"])),
+    background: Schema.optional(Schema.Literals(["auto", "opaque", "transparent"])),
+    input_fidelity: Schema.optional(Schema.Literals(["low", "high"])),
+    output_compression: Schema.optional(Schema.Int.check(Schema.isBetween({ minimum: 0, maximum: 100 }))),
+    output_format: Schema.optional(Schema.Literals(["png", "jpeg", "webp"])),
+    partial_images: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))),
+    quality: Schema.optional(Schema.Literals(["auto", "low", "medium", "high"])),
+    size: Schema.optional(OpenAIImage.Size),
+});
+const OpenAIResponsesTools = Schema.Union([OpenAIResponsesTool, OpenAIResponsesImageGenerationTool]);
 const OpenAIResponsesToolChoice = Schema.Union([
     Schema.Literals(["auto", "none", "required"]),
     Schema.Struct({ type: Schema.tag("function"), name: Schema.String }),
+    Schema.Struct({ type: Schema.tag("image_generation") }),
 ]);
 // Fields shared between the HTTP body and the WebSocket `response.create`
 // message. The HTTP body adds `stream: true`; the WebSocket message adds
@@ -89,7 +103,7 @@ const OpenAIResponsesCoreFields = {
     model: Schema.String,
     input: Schema.Array(OpenAIResponsesInputItem),
     instructions: Schema.optional(Schema.String),
-    tools: optionalArray(OpenAIResponsesTool),
+    tools: optionalArray(OpenAIResponsesTools),
     tool_choice: Schema.optional(OpenAIResponsesToolChoice),
     store: Schema.optional(Schema.Boolean),
     service_tier: Schema.optional(OpenAIOptions.OpenAIServiceTier),
@@ -141,6 +155,8 @@ const OpenAIResponsesStreamItem = Schema.Struct({
     outputs: Schema.optional(Schema.Unknown),
     server_label: Schema.optional(Schema.String),
     output: Schema.optional(Schema.Unknown),
+    result: Schema.optional(Schema.String),
+    output_format: Schema.optional(Schema.Literals(["png", "jpeg", "webp"])),
     error: Schema.optional(Schema.Unknown),
     encrypted_content: optionalNull(Schema.String),
 });
@@ -176,19 +192,37 @@ const invalid = ProviderShared.invalidRequest;
 // =============================================================================
 // Request Lowering
 // =============================================================================
-const lowerTool = (tool, inputSchema) => ({
-    type: "function",
-    name: tool.name,
-    description: tool.description,
-    parameters: ToolSchemaProjection.openAI(inputSchema),
-    // TODO: Read this from OpenAI-specific tool options so direct LLM callers can opt into strict schemas.
-    strict: false,
+const nativeImageToolInput = (tool) => {
+    const native = tool.native?.openai;
+    return ProviderShared.isRecord(native) && native.type === "image_generation" ? native : undefined;
+};
+const nativeImageTool = (tool) => {
+    const native = nativeImageToolInput(tool);
+    return Schema.is(OpenAIResponsesImageGenerationTool)(native) ? native : undefined;
+};
+const lowerTool = Effect.fn("OpenAIResponses.lowerTool")(function* (tool, inputSchema) {
+    const native = nativeImageToolInput(tool);
+    if (native !== undefined) {
+        if (Schema.is(OpenAIResponsesImageGenerationTool)(native))
+            return native;
+        return yield* invalid("OpenAI Responses image generation tool options are invalid");
+    }
+    return {
+        type: "function",
+        name: tool.name,
+        description: tool.description,
+        parameters: ToolSchemaProjection.openAI(inputSchema),
+        // TODO: Read this from OpenAI-specific tool options so direct LLM callers can opt into strict schemas.
+        strict: false,
+    };
 });
-const lowerToolChoice = (toolChoice) => ProviderShared.matchToolChoice("OpenAI Responses", toolChoice, {
+const lowerToolChoice = (toolChoice, tools) => ProviderShared.matchToolChoice("OpenAI Responses", toolChoice, {
     auto: () => "auto",
     none: () => "none",
     required: () => "required",
-    tool: (name) => ({ type: "function", name }),
+    tool: (name) => tools.some((tool) => tool.name === name && nativeImageTool(tool) !== undefined)
+        ? { type: "image_generation" }
+        : { type: "function", name },
 });
 const lowerToolCall = (part) => ({
     type: "function_call",
@@ -320,6 +354,13 @@ const lowerMessages = Effect.fn("OpenAIResponses.lowerMessages")(function* (requ
                     const itemID = hostedToolItemID(part);
                     if (store !== false && itemID && !hostedToolReferences.has(itemID))
                         input.push({ type: "item_reference", id: itemID });
+                    if (store === false && part.name === "image_generation" && part.result.type === "content") {
+                        const content = part.result.value;
+                        input.push({
+                            role: "user",
+                            content: yield* Effect.forEach(content, lowerToolResultContentItem),
+                        });
+                    }
                     if (itemID)
                         hostedToolReferences.add(itemID);
                     continue;
@@ -379,8 +420,8 @@ const fromRequest = Effect.fn("OpenAIResponses.fromRequest")(function* (request)
         input: yield* lowerMessages(request),
         tools: request.tools.length === 0
             ? undefined
-            : request.tools.map((tool) => lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility))),
-        tool_choice: request.toolChoice ? yield* lowerToolChoice(request.toolChoice) : undefined,
+            : yield* Effect.forEach(request.tools, (tool) => lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility))),
+        tool_choice: request.toolChoice ? yield* lowerToolChoice(request.toolChoice, request.tools) : undefined,
         stream: true,
         max_output_tokens: generation?.maxTokens,
         temperature: generation?.temperature,
@@ -452,11 +493,24 @@ const isHostedToolItem = (item) => item.type in HOSTED_TOOLS && typeof item.id =
 const isReasoningItem = (item) => item.type === "reasoning" && typeof item.id === "string" && item.id.length > 0;
 // Round-trip the full item as the structured result so consumers can extract
 // outputs / sources / status without re-decoding.
-const hostedToolResult = (item) => {
+const hostedToolResult = Effect.fn("OpenAIResponses.hostedToolResult")(function* (item) {
     const isError = typeof item.error !== "undefined" && item.error !== null;
+    if (item.type === "image_generation_call" && item.result) {
+        yield* Effect.fromResult(Encoding.decodeBase64(item.result)).pipe(Effect.mapError(() => ProviderShared.eventError(ADAPTER, "OpenAI Responses returned invalid image base64")));
+        return {
+            type: "content",
+            value: [
+                {
+                    type: "file",
+                    uri: `data:image/${item.output_format ?? "png"};base64,${item.result}`,
+                    mime: `image/${item.output_format ?? "png"}`,
+                },
+            ],
+        };
+    }
     return isError ? { type: "error", value: item.error } : { type: "json", value: item };
-};
-const hostedToolEvents = (item) => {
+});
+const hostedToolEvents = Effect.fn("OpenAIResponses.hostedToolEvents")(function* (item) {
     const tool = HOSTED_TOOLS[item.type];
     const providerMetadata = openaiMetadata({ itemId: item.id });
     return [
@@ -470,12 +524,12 @@ const hostedToolEvents = (item) => {
         LLMEvent.toolResult({
             id: item.id,
             name: tool.name,
-            result: hostedToolResult(item),
+            result: yield* hostedToolResult(item),
             providerExecuted: true,
             providerMetadata,
         }),
     ];
-};
+});
 const NO_EVENTS = [];
 // `response.completed` / `response.incomplete` are clean finishes that emit a
 // `finish` event; `response.failed` is a hard failure. All three end the stream,
@@ -671,7 +725,7 @@ const onOutputItemDone = Effect.fn("OpenAIResponses.onOutputItemDone")(function*
     if (isHostedToolItem(item)) {
         const events = [];
         const lifecycle = Lifecycle.stepStart(state.lifecycle, events);
-        events.push(...hostedToolEvents(item));
+        events.push(...(yield* hostedToolEvents(item)));
         return [{ ...state, lifecycle }, events];
     }
     if (isReasoningItem(item)) {

package/dist/protocols/utils/openai-image.d.ts

@@ -0,0 +1,5 @@
+import { Schema } from "effect";
+export declare const Size: Schema.String;
+export declare const OpenAIImage: {
+    readonly Size: Schema.String;
+};

package/dist/protocols/utils/openai-image.js

@@ -0,0 +1,18 @@
+import { Schema } from "effect";
+const dimensions = (value) => {
+    const match = /^(\d+)x(\d+)$/.exec(value);
+    if (!match)
+        return undefined;
+    return { width: Number(match[1]), height: Number(match[2]) };
+};
+export const Size = Schema.String.check(Schema.makeFilter((value) => {
+    if (value === "auto")
+        return undefined;
+    const parsed = dimensions(value);
+    if (!parsed)
+        return "image size must be `auto` or `{width}x{height}`";
+    return parsed.width > 0 && parsed.height > 0 ? undefined : "image dimensions must be positive integers";
+}));
+export const OpenAIImage = {
+    Size,
+};

package/dist/providers/azure.d.ts

@@ -138,7 +138,7 @@ export declare const routes: (RouteDef<{
         readonly effort?: string | undefined;
         readonly summary?: "auto" | undefined;
     } | undefined;
-    readonly tools?: readonly {
+    readonly tools?: readonly ({
         readonly type: "function";
         readonly name: string;
         readonly description: string;
@@ -146,11 +146,23 @@ export declare const routes: (RouteDef<{
             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/providers/github-copilot.d.ts

@@ -126,7 +126,7 @@ export declare const routes: (import("../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;
@@ -134,11 +134,23 @@ export declare const routes: (import("../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/providers/google-vertex-responses.d.ts

@@ -71,7 +71,7 @@ export declare const routes: import("../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;
@@ -79,11 +79,23 @@ export declare const routes: import("../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/providers/openai-compatible-responses.d.ts

@@ -69,7 +69,7 @@ export declare const routes: import("../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;
@@ -77,11 +77,23 @@ export declare const routes: import("../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;