@pi-unipi/unipi 2.3.0 → 2.4.0

package/CHANGELOG.md

@@ -6,6 +6,32 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [2.4.0] — 2026-08-09
+
+Image generation no longer requires an OpenRouter account, and `image_generate` can now edit an existing image.
+
+### Added
+
+- **`image`: image editing.** `image_generate` takes an optional `image` argument — a file path, `data:` URL, or raw base64 — and edits that image instead of generating from scratch. The result is saved and returned like any other generation.
+
+  Editing regenerates the whole image rather than masking a region, so details you did not mention can still shift. Which model you pick matters a lot here: in testing, `flux.2-pro` preserved unmentioned elements faithfully, while the `gemini-*-image` family tended to reinterpret the whole scene. Note also that image models respond to what you *describe*, not to what you negate — "no text" is as likely to add text as remove it.
+
+### Changed
+
+- **`image`: generation works with any OpenAI-compatible provider configured in pi.** Previously pi-ai shipped exactly one image provider (`openrouter`), so generating an image meant holding an OpenRouter key even when you had several other providers signed in. Every provider in pi's model registry is now bridged into pi-ai's images collection at session start, backed by a single generic adapter that posts to `{baseUrl}/images/generations`.
+
+  Credentials come from pi's existing auth — there is no separate image login. Gateways disagree on the response shape, so three known forms are normalized (`b64_json` + `media_type`, `b64_json` + `revised_prompt`, and a `data:` URL under `url`); a remote `url` is surfaced as text rather than silently dropped.
+
+  Model *discovery* remains heuristic. pi's `ProviderModelConfig` has no `output` field and the provider composer rebuilds each model from a fixed field list, so an extension cannot record "this model emits images" — hence the name-based matching, with an explicit `provider/model-id` always accepted as the escape hatch.
+
+- **`image`: errors name the provider you are actually using.** A missing key now points at that provider's environment variable and `/login` instead of unconditionally linking OpenRouter, and an unusable provider reports "no image-generation route" rather than the misleading "cannot generate images".
+
+### Fixed
+
+- **`image`: a valid API key could be reported as missing.** pi-ai resolves credentials to an `AuthResult` — `{ auth: { apiKey } }` — but the key was read from the top level, so generation failed with "No API key for provider" while a perfectly good credential sat one level down. Both shapes are now accepted.
+
+- **`image`: models discovered from the registry lost their endpoint.** Provider registration rebuilt each model from a field list that omitted `baseUrl`, so setup appeared to succeed and only the first real request failed with "No baseUrl for image model". The endpoint is now carried through discovery, and filled in from the registry at resolve time for hand-typed `provider/model-id` references, which never carry one.
+
 ## [2.3.0] — 2026-08-07
 
 Startup went from **23.1s to 0.75s** — 31× faster, and within ~0.7s of bare `pi` with no extensions at all. A cold start (empty cache) is now the same speed as a warm one.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/unipi",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "All-in-one extension suite for Pi coding agent",
   "type": "module",
   "license": "MIT",
@@ -71,26 +71,26 @@
     "typebox": "^1.1.38"
   },
   "dependencies": {
-    "@pi-unipi/ask-user": "2.3.0",
-    "@pi-unipi/btw": "2.3.0",
-    "@pi-unipi/compactor": "2.3.0",
-    "@pi-unipi/notify": "2.3.0",
-    "@pi-unipi/command-enchantment": "2.3.0",
-    "@pi-unipi/core": "2.3.0",
-    "@pi-unipi/info-screen": "2.3.0",
-    "@pi-unipi/mcp": "2.3.0",
-    "@pi-unipi/memory": "2.3.0",
-    "@pi-unipi/ralph": "2.3.0",
-    "@pi-unipi/subagents": "2.3.0",
-    "@pi-unipi/utility": "2.3.0",
-    "@pi-unipi/milestone": "2.3.0",
-    "@pi-unipi/kanboard": "2.3.0",
-    "@pi-unipi/web-api": "2.3.0",
-    "@pi-unipi/workflow": "2.3.0",
-    "@pi-unipi/footer": "2.3.0",
-    "@pi-unipi/updater": "2.3.0",
-    "@pi-unipi/input-shortcuts": "2.3.0",
-    "@pi-unipi/cocoindex": "2.3.0"
+    "@pi-unipi/ask-user": "2.4.0",
+    "@pi-unipi/btw": "2.4.0",
+    "@pi-unipi/compactor": "2.4.0",
+    "@pi-unipi/notify": "2.4.0",
+    "@pi-unipi/command-enchantment": "2.4.0",
+    "@pi-unipi/core": "2.4.0",
+    "@pi-unipi/info-screen": "2.4.0",
+    "@pi-unipi/mcp": "2.4.0",
+    "@pi-unipi/memory": "2.4.0",
+    "@pi-unipi/ralph": "2.4.0",
+    "@pi-unipi/subagents": "2.4.0",
+    "@pi-unipi/utility": "2.4.0",
+    "@pi-unipi/milestone": "2.4.0",
+    "@pi-unipi/kanboard": "2.4.0",
+    "@pi-unipi/web-api": "2.4.0",
+    "@pi-unipi/workflow": "2.4.0",
+    "@pi-unipi/footer": "2.4.0",
+    "@pi-unipi/updater": "2.4.0",
+    "@pi-unipi/input-shortcuts": "2.4.0",
+    "@pi-unipi/cocoindex": "2.4.0"
   },
   "devDependencies": {
     "@earendil-works/pi-agent-core": "^0.80.0",

package/packages/ask-user/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/ask-user",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "Structured user input tool for Pi coding agent — single-select, multi-select, freeform",
   "type": "module",
   "main": "index.ts",
@@ -40,7 +40,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.3.0"
+    "@pi-unipi/core": "2.4.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.80.0",

package/packages/autocomplete/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/command-enchantment",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "Enhanced TUI autocomplete for /unipi:* commands — colored, sorted, and grouped by package",
   "type": "module",
   "main": "src/index.ts",

package/packages/btw/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/btw",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "A pi extension for parallel side conversations with /unipi:btw — part of the Unipi suite",
   "type": "module",
   "main": "extensions/btw.ts",
@@ -37,7 +37,7 @@
     "@earendil-works/pi-tui": "^0.80.0"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.3.0"
+    "@pi-unipi/core": "2.4.0"
   },
   "pi": {
     "extensions": [],

package/packages/cocoindex/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/cocoindex",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "CocoIndex integration for Pi — AST-aware content indexing, semantic vector search, and incremental pipeline management",
   "type": "module",
   "main": "index.ts",
@@ -25,7 +25,7 @@
     "typebox": "^1.1.38"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.3.0"
+    "@pi-unipi/core": "2.4.0"
   },
   "optionalDependencies": {
     "@lancedb/lancedb": "^0.21.0"

package/packages/compactor/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/compactor",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "Context engine for Pi — zero-LLM compaction, session continuity, sandbox execution, and tool display optimization",
   "type": "module",
   "main": "src/index.ts",
@@ -34,8 +34,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.3.0",
-    "@pi-unipi/info-screen": "2.3.0",
+    "@pi-unipi/core": "2.4.0",
+    "@pi-unipi/info-screen": "2.4.0",
     "@earendil-works/pi-agent-core": "^0.80.0"
   },
   "peerDependencies": {

package/packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/core",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "Shared utilities, event types, and constants for Unipi extension suite",
   "type": "module",
   "license": "MIT",

package/packages/footer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/footer",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "Persistent status bar for Unipi — subscribes to UNIPI_EVENTS and renders key stats from all unipi packages",
   "type": "module",
   "main": "src/index.ts",
@@ -32,7 +32,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.3.0"
+    "@pi-unipi/core": "2.4.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.80.0",

package/packages/image/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/image",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "Image generation and image recognition tools for the Pi coding agent",
   "type": "module",
   "main": "src/index.ts",
@@ -34,7 +34,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.3.0"
+    "@pi-unipi/core": "2.4.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "^0.80.0",

package/packages/image/src/generate.ts

@@ -131,6 +131,8 @@ export interface GenerateOptions {
   signal?: AbortSignal;
   /** Absolute directory for saved images; omit to skip saving. */
   outputDir?: string;
+  /** Source image; when set the request is an edit rather than a generation. */
+  inputImage?: { data: string; mimeType: string };
   now?: Date;
   /** Injected images collection, for tests. */
   images?: ImagesModelsLike;
@@ -141,7 +143,7 @@ export interface GenerateOptions {
  * @throws {Error} with an actionable message when generation fails.
  */
 export async function generateImage(options: GenerateOptions): Promise<GenerateResult> {
-  const { prompt, model, signal, outputDir, now } = options;
+  const { prompt, model, signal, outputDir, now, inputImage } = options;
 
   if (!prompt.trim()) {
     throw new Error("A non-empty prompt is required.");
@@ -154,19 +156,19 @@ export async function generateImage(options: GenerateOptions): Promise<GenerateR
     );
   }
 
-  // pi-ai's images collection carries its own provider set (currently only
-  // `openrouter`) and is entirely separate from pi's chat model registry.
-  // A chat provider registered by another extension can therefore list image
-  // models that generation cannot actually drive — pi-ai answers with a bare
-  // "Unknown provider: x". Detect that here and say something useful.
+  // pi-ai's images collection has its own provider set, separate from pi's
+  // chat registry. `registerRegistryImageProviders()` bridges pi's providers
+  // in, but a model may still name a provider with no image route at all —
+  // pi-ai would answer with a bare "Unknown provider: x", so say something
+  // useful instead.
   if (!providerCanGenerate(imagesApi, model.provider)) {
     const supported = supportedProviders(imagesApi);
     throw new Error(
-      `Provider "${model.provider}" cannot generate images.\n` +
-        `→ Image generation is served by: ${supported.join(", ") || "openrouter"}.\n` +
-        `→ "${model.provider}" is a chat provider; its image models are listed for ` +
-        `recognition and reference, but generation must go through a supported provider.\n` +
-        "→ Pick one with /unipi:image-settings.",
+      `Provider "${model.provider}" has no image-generation route.\n` +
+        `→ Available: ${supported.join(", ") || "openrouter"}.\n` +
+        "→ Providers are bridged from pi automatically; one without a baseUrl " +
+        "or an API key cannot be used.\n" +
+        "→ Pick another with /unipi:image-settings.",
     );
   }
 
@@ -174,7 +176,13 @@ export async function generateImage(options: GenerateOptions): Promise<GenerateR
   // a bare OPENROUTER_API_KEY still works.
   let apiKey: string | undefined;
   try {
-    apiKey = (await imagesApi.getAuth(model))?.apiKey;
+    // pi-ai resolves to an `AuthResult`, i.e. `{ auth: { apiKey } }`. Older
+    // shapes put the key at the top level, so accept both — reading only one
+    // fails silently and looks like a missing credential.
+    const resolvedAuth = (await imagesApi.getAuth(model)) as
+      | { apiKey?: string; auth?: { apiKey?: string } }
+      | undefined;
+    apiKey = resolvedAuth?.auth?.apiKey ?? resolvedAuth?.apiKey;
   } catch {
     // Reported as a missing key below.
   }
@@ -183,14 +191,25 @@ export async function generateImage(options: GenerateOptions): Promise<GenerateR
   if (!apiKey) {
     throw new Error(
       `No API key for provider "${model.provider}".\n` +
-        `→ Add one with /login, or set the provider's API key environment variable.\n` +
-        `→ Image models are served through OpenRouter: https://openrouter.ai/keys`,
+        "→ Sign in with /login, or set the provider's API key environment variable.\n" +
+        `→ Expected environment variable: ` +
+        `${model.provider.toUpperCase().replace(/[^A-Z0-9]/g, "_")}_API_KEY`,
     );
   }
 
+  const input: Array<{ type: string; text?: string; data?: string; mimeType?: string }> =
+    [{ type: "text", text: prompt }];
+  if (inputImage) {
+    input.push({
+      type: "image",
+      data: inputImage.data,
+      mimeType: inputImage.mimeType,
+    });
+  }
+
   const result = (await imagesApi.generateImages(
     model,
-    { input: [{ type: "text", text: prompt }] },
+    { input } as { input: Array<{ type: string; text?: string }> },
     { apiKey, ...(signal ? { signal } : {}) },
   )) as AssistantImagesLike;
 

package/packages/image/src/index.ts

@@ -21,6 +21,7 @@ import {
 import { registerImageCommands } from "./commands.js";
 import { registerImageTools } from "./tools.js";
 import { listImageGenModels, listVisionModels, type ChatModelRegistry } from "./models.js";
+import { registerRegistryImageProviders } from "./register-providers.js";
 import { loadConfig } from "./settings.js";
 
 const VERSION = getPackageVersion(dirname(fileURLToPath(import.meta.url)));
@@ -43,6 +44,13 @@ export default function (pi: ExtensionAPI) {
   pi.on("session_start", async (_event, ctx) => {
     const config = loadConfig();
 
+    // Bridge pi's configured providers into pi-ai's images collection up front,
+    // so the settings picker and the info screen see them without a prior
+    // image_generate call. Best-effort: never block session start.
+    void registerRegistryImageProviders(
+      (ctx as unknown as { modelRegistry?: ChatModelRegistry }).modelRegistry,
+    ).catch(() => undefined);
+
     const tools: string[] = [];
     if (config.generate.enabled) tools.push(IMAGE_TOOLS.GENERATE);
     if (config.recognize.enabled) tools.push(IMAGE_TOOLS.RECOGNIZE);

package/packages/image/src/models.ts

@@ -211,12 +211,40 @@ export function listRegistryImageGenModels(
       provider: candidate.provider,
       name: candidate.name,
       api: candidate.api ?? "",
+      // Carry the endpoint through. The generic images adapter POSTs to
+      // `{baseUrl}/images/generations`, and this is the only place the
+      // registry's baseUrl is available — dropping it here surfaces later as
+      // "No baseUrl for image model ..." once generation is attempted.
+      ...(candidate.baseUrl ? { baseUrl: candidate.baseUrl } : {}),
       ...(candidate.output ? { output: candidate.output } : {}),
     });
   }
   return out;
 }
 
+/**
+ * Find a provider's API endpoint in pi's registry.
+ *
+ * Needed because a model can reach generation without one: a user-typed
+ * "provider/model-id" is accepted at face value by `asExplicitModelRef`, and
+ * carries no baseUrl of its own.
+ */
+export function findProviderBaseUrl(
+  registry: ChatModelRegistry | undefined,
+  provider: string,
+): string | undefined {
+  if (!registry) return undefined;
+  try {
+    const models = (registry.getAvailable?.() ?? registry.getAll()) as Array<{
+      provider?: string;
+      baseUrl?: string;
+    }>;
+    return models.find((m) => m?.provider === provider && m.baseUrl)?.baseUrl;
+  } catch {
+    return undefined;
+  }
+}
+
 /**
  * Every selectable generation model: pi-ai's built-in catalog plus anything
  * contributed by registered providers, de-duplicated by "provider/id".

package/packages/image/src/openai-images-api.ts

@@ -0,0 +1,282 @@
+/**
+ * @pi-unipi/image — Generic OpenAI-compatible images adapter
+ *
+ * ONE adapter for every provider, rather than per-provider code. It speaks the
+ * OpenAI `POST {baseUrl}/images/generations` shape, which every gateway we have
+ * tested implements (OpenAI itself, OpenRouter, and OmniRoute's fan-out to
+ * openrouter/antigravity/codex/fal-ai backends).
+ *
+ * Why not pi-ai's built-in `api/openrouter-images`?
+ * Despite the name it drives `chat.completions` with `modalities:["image"]`.
+ * Gateways that do not implement that extension answer HTTP 200 with the model
+ * *narrating* the image ("Here's the image with the circle changed…") while
+ * silently dropping `message.images`. That is invisible data loss, so we use
+ * the dedicated images endpoint instead.
+ *
+ * Editing rides the same endpoint: `POST /images/generations` with an `image`
+ * array. `/images/edits` (multipart) is NOT used — gateways reject it for most
+ * providers ("Image edit is not supported for built-in provider ...").
+ */
+
+import type { ImageGenModel } from "./models.js";
+
+/** pi-ai's `ImagesContext` input parts. */
+export interface ImagesInputPart {
+  type: string;
+  text?: string;
+  data?: string;
+  mimeType?: string;
+}
+
+export interface ImagesContextLike {
+  input: ImagesInputPart[];
+}
+
+export interface ImagesOptionsLike {
+  apiKey?: string;
+  signal?: AbortSignal;
+  headers?: Record<string, string | null>;
+  timeoutMs?: number;
+  /** Injectable fetch, for tests. */
+  fetchImpl?: typeof fetch;
+}
+
+/** pi-ai's `AssistantImages`. */
+export interface AssistantImagesLike {
+  api: string;
+  provider: string;
+  model: string;
+  output: Array<{ type: string; text?: string; data?: string; mimeType?: string }>;
+  stopReason: "stop" | "error" | "aborted";
+  errorMessage?: string;
+  timestamp: number;
+}
+
+/** Images are slow — a minute is not unusual for a large model. */
+const DEFAULT_TIMEOUT_MS = 240_000;
+
+/**
+ * One returned image, normalized.
+ *
+ * Gateways disagree on the item shape; all three observed forms are accepted:
+ *   - `{ b64_json, media_type }`   — openrouter/* (note `media_type`, not `mimeType`)
+ *   - `{ b64_json, revised_prompt }` — antigravity/*
+ *   - `{ url: "data:image/png;base64,…" }` — codex/*
+ * A plain http(s) `url` is also tolerated and reported as text, since we cannot
+ * inline bytes we did not fetch.
+ */
+interface RawImageItem {
+  b64_json?: unknown;
+  url?: unknown;
+  media_type?: unknown;
+  mime_type?: unknown;
+  mimeType?: unknown;
+  revised_prompt?: unknown;
+}
+
+function asString(value: unknown): string | undefined {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+/** Pull `{ data, mimeType }` out of one response item, whatever its shape. */
+export function normalizeImageItem(
+  item: RawImageItem,
+): { data: string; mimeType: string } | { text: string } | null {
+  const declared =
+    asString(item.media_type) ?? asString(item.mime_type) ?? asString(item.mimeType);
+
+  const b64 = asString(item.b64_json);
+  if (b64) return { data: b64, mimeType: declared ?? "image/png" };
+
+  const url = asString(item.url);
+  if (!url) return null;
+
+  // codex/* returns the bytes as a data: URL rather than b64_json.
+  const dataUrl = /^data:([^;,]+)(?:;[^,]*)*,(.*)$/s.exec(url);
+  if (dataUrl) {
+    const [, mime, payload] = dataUrl;
+    if (payload) return { data: payload, mimeType: declared ?? mime ?? "image/png" };
+    return null;
+  }
+
+  // A remote URL: surface it rather than silently dropping the result.
+  return { text: `Image available at: ${url}` };
+}
+
+/** Strip a trailing slash so `${base}/images/generations` is well-formed. */
+function joinUrl(baseUrl: string, suffix: string): string {
+  return `${baseUrl.replace(/\/+$/, "")}/${suffix.replace(/^\/+/, "")}`;
+}
+
+/**
+ * Model ids are sent to the gateway verbatim.
+ *
+ * Do NOT try to "repair" a doubled-looking segment. OmniRoute genuinely serves
+ * `fal-ai/fal-ai/nano-banana-pro` (provider `fal-ai` + model `fal-ai/nano-...`),
+ * and rewriting it to `fal-ai/nano-banana-pro` yields a 404. Confusingly the
+ * gateway *also* advertises a `fal/...` alias in `/v1/models` that the images
+ * endpoint then rejects with "Invalid image model" — an upstream inconsistency
+ * we surface rather than guess around, because a wrong guess turns a clear
+ * error into a silently different model.
+ */
+export function normalizeModelId(id: string): string {
+  return id;
+}
+
+/** Merge caller headers, dropping keys explicitly suppressed with null. */
+function buildHeaders(
+  apiKey: string,
+  extra?: Record<string, string | null>,
+): Record<string, string> {
+  const headers: Record<string, string> = {
+    Authorization: `Bearer ${apiKey}`,
+    "Content-Type": "application/json",
+  };
+  for (const [key, value] of Object.entries(extra ?? {})) {
+    if (value === null) delete headers[key];
+    else headers[key] = value;
+  }
+  return headers;
+}
+
+/** Best-effort extraction of a provider error message. */
+function describeError(status: number, statusText: string, body: string): string {
+  let detail = body.slice(0, 300);
+  try {
+    const parsed = JSON.parse(body) as { error?: { message?: string } | string };
+    if (typeof parsed.error === "string") detail = parsed.error;
+    else if (parsed.error?.message) detail = parsed.error.message;
+  } catch {
+    // Non-JSON body — the truncated text is the best we have.
+  }
+  return `${status} ${statusText}${detail ? `: ${detail}` : ""}`;
+}
+
+/** Add guidance for the gateway's confusing model-id errors. */
+function annotateModelError(message: string, model: ImageGenModel): string {
+  if (/invalid image model|not found|unknown model/i.test(message)) {
+    return (
+      `${message}\n` +
+      `→ Model id sent: "${model.id}" (provider "${model.provider}").\n` +
+      "→ Some gateways list aliases they cannot serve. Try the id exactly as it " +
+      "appears in the provider's own catalog, or pick another with /unipi:image-settings."
+    );
+  }
+  return message;
+}
+
+/**
+ * Generate (or edit) images against an OpenAI-compatible endpoint.
+ *
+ * Satisfies pi-ai's `ProviderImages` interface, so the result is returned —
+ * never thrown — with `stopReason: "error"` on failure.
+ */
+export async function generateImages(
+  model: ImageGenModel,
+  context: ImagesContextLike,
+  options?: ImagesOptionsLike,
+): Promise<AssistantImagesLike> {
+  const result: AssistantImagesLike = {
+    api: model.api || "openai-images",
+    provider: model.provider,
+    model: model.id,
+    output: [],
+    stopReason: "stop",
+    timestamp: Date.now(),
+  };
+
+  const fetchImpl = options?.fetchImpl ?? fetch;
+  const controller = new AbortController();
+  const timer = setTimeout(
+    () => controller.abort(),
+    options?.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+  );
+  const onAbort = () => controller.abort();
+  options?.signal?.addEventListener("abort", onAbort, { once: true });
+
+  try {
+    const apiKey = options?.apiKey;
+    if (!apiKey) throw new Error(`No API key for provider: ${model.provider}`);
+    if (!model.baseUrl) {
+      throw new Error(`No baseUrl for image model ${model.provider}/${model.id}`);
+    }
+
+    // Text parts form the prompt; image parts switch the request into edit mode.
+    const prompt = context.input
+      .filter((part) => part.type === "text" && part.text)
+      .map((part) => part.text as string)
+      .join("\n")
+      .trim();
+
+    const images = context.input
+      .filter((part) => part.type === "image" && part.data)
+      .map((part) => `data:${part.mimeType || "image/png"};base64,${part.data}`);
+
+    if (!prompt) throw new Error("A non-empty prompt is required.");
+
+    const body: Record<string, unknown> = {
+      model: normalizeModelId(model.id),
+      prompt,
+    };
+    // Only send `image` for edits; some backends reject an empty array.
+    if (images.length > 0) body.image = images;
+
+    const response = await fetchImpl(joinUrl(model.baseUrl, "images/generations"), {
+      method: "POST",
+      headers: buildHeaders(apiKey, options?.headers),
+      body: JSON.stringify(body),
+      signal: controller.signal,
+    });
+
+    if (!response.ok) {
+      throw new Error(
+        describeError(response.status, response.statusText, await response.text()),
+      );
+    }
+
+    const payload = (await response.json()) as {
+      data?: RawImageItem[];
+      error?: { message?: string };
+    };
+
+    if (payload.error?.message) throw new Error(payload.error.message);
+
+    for (const item of payload.data ?? []) {
+      const normalized = normalizeImageItem(item);
+      if (!normalized) continue;
+      if ("text" in normalized) {
+        result.output.push({ type: "text", text: normalized.text });
+      } else {
+        result.output.push({
+          type: "image",
+          data: normalized.data,
+          mimeType: normalized.mimeType,
+        });
+      }
+      const revised = asString(item.revised_prompt);
+      if (revised && revised !== prompt) {
+        result.output.push({ type: "text", text: `Revised prompt: ${revised}` });
+      }
+    }
+
+    if (result.output.every((part) => part.type !== "image")) {
+      throw new Error("The provider returned no image data.");
+    }
+
+    return result;
+  } catch (error) {
+    const aborted = options?.signal?.aborted || controller.signal.aborted;
+    result.stopReason = options?.signal?.aborted ? "aborted" : "error";
+    result.errorMessage =
+      aborted && !options?.signal?.aborted
+        ? "Image request timed out."
+        : annotateModelError(
+            error instanceof Error ? error.message : String(error),
+            model,
+          );
+    return result;
+  } finally {
+    clearTimeout(timer);
+    options?.signal?.removeEventListener("abort", onAbort);
+  }
+}