@wuyaos/pi-model-config 0.1.3 → 0.1.4

package/README.md

@@ -122,6 +122,12 @@ Chat 写入 Pi 标准 `models.json`。Classifier 和 image 通过 Pi 的原生 m
 支持的 image API：
 
 - `openrouter-images`
+- `openai-images`（OpenAI Images；默认 `https://api.openai.com/v1`）
+- `gemini-images`（Gemini GenerateContent；默认 `https://generativelanguage.googleapis.com`）
+- `xai-images`（xAI Images；默认 `https://api.x.ai/v1`；当前将 base64 结果标为 `image/jpeg`，待真实服务商响应验证）
+- `dashscope-images`（DashScope 同步 multimodal-generation；默认 `https://dashscope.aliyuncs.com/api/v1`）
+
+这四个新增协议由本插件直接实现请求级 `generateImages()`，**不经过宿主图像管线**。模型级 Base URL 优先，其次服务商 Base URL，最后才采用上列协议默认值；`openrouter-images` 与未知/自定义协议没有默认 URL，必须由用户明确填写。图像响应不计算 token/cost usage（保持为空）。DashScope 固定使用同步 `/services/aigc/multimodal-generation/generation`，解析 `output.choices[0].message.content[].image`（URL 字符串或 `{ url }`）；不发送 `X-DashScope-Async`。返回 URL 会经同源重定向、内网地址、30 秒和 10 MiB 限制后下载。
 
 支持的 chat API：
 
@@ -188,6 +194,7 @@ Chat 写入 Pi 标准 `models.json`。Classifier 和 image 通过 Pi 的原生 m
 
 - 行为调研参考了 @indexyz/pi-provider-sub2api（MIT）对 Codex manifest、slug/display_name 和保守失败策略的说明，以及 @router-for-me/pi-cliproxyapi-provider（MIT）公开的 endpoint 约定。
 - 同时查看了 @keywaytech/pi-provider-manager 的发布包行为；其 package 标记 UNLICENSED，因此本项目没有复制或改写其源码，只独立实现了协议 profile、认证头和安全读取逻辑。
+- 图像协议行为还参考本机 `img-research` 中 `@amaster.ai/pi-image-gen` 发布包的 Apache-2.0 `dist/providers/{openai,gemini,dashscope}.js`，以及其依赖 `pi-image-gen-core/src/providers/xai.ts`；仅用于核实公开 endpoint、body 和响应形状，没有复制源码、宿主管线或 UI。
 - 本实现没有照搬上述包的缓存、client_version、名称正则推理、provider 注册或 UI 代码；尤其不会仅凭 CLIProxy 名称添加查询参数。
 
 ## 已知限制
@@ -199,3 +206,4 @@ Chat 写入 Pi 标准 `models.json`。Classifier 和 image 通过 Pi 的原生 m
 - 插件自有 provider 的“复用 Pi auth”仅处理同 ID 的 API-key credential；OAuth 只适用于未被插件接管、继续使用原生认证实现的 provider，不能移植到另一个自定义 provider ID。
 - 第三方 extension provider 若不由本插件接管，只能管理 chat overlay，不能启用本插件代理或匿名 transport。
 - 保存模型配置后需要 `/reload` 才能更新 extension transport 与 classifier/image 注册；仅切换界面语言不需要 reload。
+- 图像 API 只覆盖文本提示词和各协议的最小一图请求；没有接入宿主图像管线、编辑/多图输入或 usage/cost 计费统计。

package/model-config.schema.json

@@ -162,7 +162,13 @@
           "type": "string"
         },
         "imageApi": {
-          "type": "string"
+          "enum": [
+            "openrouter-images",
+            "openai-images",
+            "gemini-images",
+            "xai-images",
+            "dashscope-images"
+          ]
         },
         "defaultType": {
           "enum": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wuyaos/pi-model-config",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "type": "module",
   "description": "Pi provider 连接、远程发现与 chat/classifier/image 模型配置 TUI",
   "keywords": [

package/src/command.ts

@@ -24,6 +24,8 @@ import {
 } from "./panel.ts";
 import { candidateFromExternal, candidateFromInstalled, candidateFromManaged, mergeCandidates, selectModels, type ModelPanelState } from "./selector.ts";
 import { CHAT_APIS, CLASSIFIER_APIS, IMAGE_APIS, PROXY_CHAT_APIS } from "./transport.ts";
+import { resolveImageBaseUrl } from "./image-apis/common.ts";
+import { SELF_IMAGE_APIS } from "./image-apis/index.ts";
 import type {
   CandidateModel,
   ManagedModel,
@@ -102,6 +104,14 @@ function modelTypeLabel(language: UiLanguage, type: ManagedModel["type"]): strin
       : t(language, "selectorTypeChat");
 }
 
+function imageApiLabel(language: UiLanguage, api: string): string {
+  const key = api === "openai-images" ? "imageApiOpenai"
+    : api === "gemini-images" ? "imageApiGemini"
+      : api === "xai-images" ? "imageApiXai"
+        : api === "dashscope-images" ? "imageApiDashscope" : "imageApiOpenrouter";
+  return `${t(language, key)} (${api})`;
+}
+
 export function parseManagedChat(raw: Record<string, unknown>, provider: ModelsJsonProvider, config: ProviderConnectionConfig, applyDefaults = false): ManagedModel | undefined {
   if (typeof raw.id !== "string") return undefined;
   const api = typeof raw.api === "string" ? raw.api : (provider.api ?? config.chatApi ?? "openai-completions");
@@ -286,8 +296,10 @@ async function editConnectionPanel(ctx: ExtensionCommandContext, language: UiLan
           break;
         }
         case "imageApi": {
-          const value = await ctx.ui.select("Image API", [...IMAGE_APIS]);
-          if (value) draft.imageApi = value;
+          const choices = [...IMAGE_APIS].map((api) => ({ api, label: imageApiLabel(language, api) }));
+          const value = await ctx.ui.select("Image API", choices.map((choice) => choice.label));
+          const selected = choices.find((choice) => choice.label === value);
+          if (selected) draft.imageApi = selected.api;
           break;
         }
       }
@@ -326,10 +338,13 @@ function validateSelection(
   if (draft.proxyUrl) validateHttpUrl(draft.proxyUrl, "Provider proxy URL");
   if (draft.owned) {
     const missingExistingUrl = (existingProvider?.models ?? []).some((model) => typeof model.baseUrl !== "string" && !draft.baseUrl);
-    const missingSelectedUrl = selected.some((model) => !model.baseUrl && !draft.baseUrl);
+    const effectiveModelUrl = (model: ManagedModel) => model.type === "image"
+      ? resolveImageBaseUrl(model.api, model.baseUrl, draft.baseUrl)
+      : model.baseUrl ?? draft.baseUrl;
+    const missingSelectedUrl = selected.some((model) => !effectiveModelUrl(model));
     if (missingExistingUrl || missingSelectedUrl) throw mcError("MCFG_E_BASE_URL_REQUIRED");
     for (const model of existingProvider?.models ?? []) validateHttpUrl(String(model.baseUrl ?? draft.baseUrl), `${draft.id}/${String(model.id)} Base URL`);
-    for (const model of selected) validateHttpUrl(model.baseUrl ?? draft.baseUrl!, `${draft.id}/${model.id} Base URL`);
+    for (const model of selected) validateHttpUrl(effectiveModelUrl(model)!, `${draft.id}/${model.id} Base URL`);
   }
   if (!draft.owned && selected.some((model) => model.type !== "chat")) throw mcError("MCFG_E_NOT_OWNED", { provider: draft.id });
   if (!draft.owned && (draft.proxyUrl || draft.authMode === "anonymous") && !new Set<string>(getBuiltinProviders()).has(draft.id)) {
@@ -351,7 +366,8 @@ function validateSelection(
     const supported = model.type === "chat" ? CHAT_APIS : model.type === "classifier" ? CLASSIFIER_APIS : IMAGE_APIS;
     if (!supported.has(model.api)) throw mcError("MCFG_E_UNSUPPORTED_API", { identity: `${draft.id}/${model.type}/${model.id}`, api: model.api });
     if (draft.proxyUrl && model.type === "chat" && !PROXY_CHAT_APIS.has(model.api)) throw mcError("MCFG_E_PROXY_UNSUPPORTED", { identity: `${draft.id}/${model.type}/${model.id}` });
-    if (draft.authMode === "anonymous" && ["pi-messages", "bedrock-converse-stream", "google-generative-ai", "google-vertex"].includes(model.api)) {
+    if (draft.authMode === "anonymous" && (["pi-messages", "bedrock-converse-stream", "google-generative-ai", "google-vertex"].includes(model.api)
+      || model.type === "image" && SELF_IMAGE_APIS.has(model.api))) {
       throw mcError("MCFG_E_ANONYMOUS_UNSUPPORTED", { identity: `${draft.id}/${model.type}/${model.id}` });
     }
   }

package/src/config.ts

@@ -21,6 +21,7 @@ import type {
   ModelsJsonProvider,
   ProviderConnectionConfig,
 } from "./types.ts";
+import { IMAGE_API_NAMES } from "./types.ts";
 
 export const MODELS_SCHEMA = "https://pi.dev/schemas/models.schema.json";
 export const MODEL_CONFIG_SCHEMA = "https://raw.githubusercontent.com/wuyaos/pi-packages/main/pi-model-config/model-config.schema.json";
@@ -68,6 +69,9 @@ export function parseModelConfig(source: ConfigSnapshot): ModelConfigFile {
     if (provider.discoveryAuthHeader !== undefined && !new Set(["auto", "bearer", "x-api-key", "api-key", "x-goog-api-key", "anthropic", "none"]).has(String(provider.discoveryAuthHeader))) {
       throw mcError("MCFG_E_DISCOVERY_AUTH_HEADER", { file: "model-config.json", provider: id });
     }
+    if (provider.imageApi !== undefined && !IMAGE_API_NAMES.includes(String(provider.imageApi) as typeof IMAGE_API_NAMES[number])) {
+      throw mcError("MCFG_E_UNSUPPORTED_API", { identity: `${id}/image`, api: String(provider.imageApi) });
+    }
     if (provider.models !== undefined && !Array.isArray(provider.models)) throw mcError("MCFG_E_MODELS_ARRAY", { file: "model-config.json", provider: id });
     if (Array.isArray(provider.models) && provider.models.some((model) => !isRecord(model))) throw mcError("MCFG_E_MODELS_ARRAY", { file: "model-config.json", provider: id });
     for (const model of Array.isArray(provider.models) ? provider.models : []) {

package/src/i18n.ts

@@ -191,6 +191,11 @@ const ZH = {
   panelDescChatApi: "聊天模型调用协议；API 名保持原文。",
   panelDescClassifierApi: "判定模型调用协议；API 名保持原文。",
   panelDescImageApi: "图像生成模型调用协议；API 名保持原文。",
+  imageApiOpenrouter: "OpenRouter 图像",
+  imageApiOpenai: "OpenAI 图像生成",
+  imageApiGemini: "Gemini 图像生成",
+  imageApiXai: "xAI 图像生成",
+  imageApiDashscope: "DashScope 图像生成",
   panelDescContext: "远程模型缺少 context window 时使用的默认值。",
   panelDescMaxTokens: "远程聊天模型缺少 max tokens 时使用的默认值。",
   panelModelName: "模型名称：{value}",
@@ -523,6 +528,11 @@ const EN = {
   panelDescChatApi: "Chat model protocol; API names remain unchanged.",
   panelDescClassifierApi: "Classification model protocol; API names remain unchanged.",
   panelDescImageApi: "Image generation protocol; API names remain unchanged.",
+  imageApiOpenrouter: "OpenRouter Images",
+  imageApiOpenai: "OpenAI Images",
+  imageApiGemini: "Gemini Images",
+  imageApiXai: "xAI Images",
+  imageApiDashscope: "DashScope Images",
   panelDescContext: "Default used when a remote model omits context window.",
   panelDescMaxTokens: "Default used when a remote chat model omits max tokens.",
   panelModelName: "Model name: {value}",

package/src/image-apis/common.ts

@@ -0,0 +1,219 @@
+import type { AssistantImages, FetchFunction, ImageModel, ImagesContext, ImagesOptions, ProviderHeaders } from "@earendil-works/pi-ai";
+import { sanitizeError, validateHttpUrl } from "../config.ts";
+
+export const IMAGE_API_DEFAULT_BASE_URLS = {
+  "openai-images": "https://api.openai.com/v1",
+  "gemini-images": "https://generativelanguage.googleapis.com",
+  "xai-images": "https://api.x.ai/v1",
+  "dashscope-images": "https://dashscope.aliyuncs.com/api/v1",
+} as const;
+
+export type BuiltinImageApi = keyof typeof IMAGE_API_DEFAULT_BASE_URLS;
+
+const ANONYMOUS_SENTINEL = "pi-model-config-anonymous";
+
+export function imageDefaultBaseUrl(api: string): string | undefined {
+  return IMAGE_API_DEFAULT_BASE_URLS[api as BuiltinImageApi];
+}
+
+/** Model URLs override provider URLs; protocol defaults only apply to the four self-owned APIs. */
+export function resolveImageBaseUrl(api: string, modelBaseUrl?: string, providerBaseUrl?: string): string | undefined {
+  return modelBaseUrl || providerBaseUrl || imageDefaultBaseUrl(api);
+}
+
+export function normalizeBaseUrl(value: string, requiredPath?: string): string {
+  const url = new URL(validateHttpUrl(value, "Image Base URL"));
+  url.search = "";
+  url.hash = "";
+  url.pathname = url.pathname.replace(/\/+$/u, "") || "/";
+  if (requiredPath && !url.pathname.endsWith(requiredPath)) {
+    url.pathname = `${url.pathname === "/" ? "" : url.pathname}${requiredPath}`;
+  }
+  return url.toString().replace(/\/$/u, "");
+}
+
+export function promptFromContext(context: ImagesContext): string {
+  return context.input.filter((item) => item.type === "text").map((item) => item.text).join("\n").trim();
+}
+
+function asHeaders(value: ProviderHeaders | undefined): Record<string, string | null | undefined> {
+  return { ...(value as Record<string, string | null | undefined> | undefined) };
+}
+
+function hasHeader(headers: Record<string, string | null | undefined>, name: string): boolean {
+  return Object.keys(headers).some((key) => key.toLowerCase() === name.toLowerCase());
+}
+
+export function requestHeaders(
+  model: ImageModel<string>,
+  options: ImagesOptions | undefined,
+  authentication: Record<string, string | undefined>,
+): Record<string, string> {
+  const merged = {
+    ...asHeaders(model.headers),
+    ...asHeaders(options?.headers),
+  };
+  for (const [name, value] of Object.entries(authentication)) {
+    if (value && !hasHeader(merged, name)) merged[name] = value;
+  }
+  if (!hasHeader(merged, "content-type")) merged["content-type"] = "application/json";
+  return Object.fromEntries(Object.entries(merged).filter((entry): entry is [string, string] => typeof entry[1] === "string"));
+}
+
+export function apiKey(options: ImagesOptions | undefined): string | undefined {
+  const key = options?.apiKey;
+  return key && key !== ANONYMOUS_SENTINEL ? key : undefined;
+}
+
+export function fetchFor(options: ImagesOptions | undefined): FetchFunction {
+  return options?.fetch ?? (globalThis.fetch as FetchFunction);
+}
+
+export function imageResult(model: ImageModel<string>): AssistantImages {
+  return {
+    api: model.api,
+    provider: model.provider,
+    model: model.id,
+    output: [],
+    stopReason: "stop",
+    timestamp: Date.now(),
+  };
+}
+
+export function activeSecrets(options: ImagesOptions | undefined, extra: readonly string[] = []): string[] {
+  const metadata = options?.metadata as { secrets?: unknown } | undefined;
+  const supplied = Array.isArray(metadata?.secrets) ? metadata.secrets.filter((value): value is string => typeof value === "string") : [];
+  return [...extra, ...supplied, options?.apiKey].filter((value): value is string => !!value && value !== ANONYMOUS_SENTINEL);
+}
+
+export function failedImageResult(
+  model: ImageModel<string>,
+  error: unknown,
+  options: ImagesOptions | undefined,
+  extraSecrets: readonly string[] = [],
+): AssistantImages {
+  const result = imageResult(model);
+  result.stopReason = options?.signal?.aborted ? "aborted" : "error";
+  result.errorMessage = sanitizeError(error, activeSecrets(options, extraSecrets));
+  return result;
+}
+
+export async function responseJson(response: Response, options?: ImagesOptions, extraSecrets: readonly string[] = []): Promise<unknown> {
+  if (!response.ok) {
+    let detail = "";
+    try { detail = (await response.text()).slice(0, 200); } catch { /* status remains useful without a readable body */ }
+    const safeDetail = detail ? `: ${sanitizeError(detail, activeSecrets(options, extraSecrets))}` : "";
+    throw new Error(`Image API request failed: HTTP ${response.status}${safeDetail}`);
+  }
+  try {
+    return await response.json();
+  } catch {
+    throw new Error("Image API returned invalid JSON");
+  }
+}
+
+export function records(value: unknown): Record<string, unknown>[] {
+  return Array.isArray(value) ? value.filter((item): item is Record<string, unknown> => !!item && typeof item === "object" && !Array.isArray(item)) : [];
+}
+
+export function dataUrl(mimeType: string, base64: string): string {
+  return `data:${mimeType};base64,${base64}`;
+}
+
+function privateHostname(hostname: string): boolean {
+  let normalized = hostname.toLowerCase().replace(/^\[|\]$/gu, "");
+  const mappedIpv4 = normalized.match(/^::ffff:(\d{1,3}(?:\.\d{1,3}){3})$/u);
+  const mappedHex = normalized.match(/^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/u);
+  if (mappedIpv4) normalized = mappedIpv4[1]!;
+  else if (mappedHex) {
+    const high = Number.parseInt(mappedHex[1]!, 16);
+    const low = Number.parseInt(mappedHex[2]!, 16);
+    normalized = `${high >>> 8}.${high & 0xff}.${low >>> 8}.${low & 0xff}`;
+  }
+  if (normalized === "localhost" || normalized.endsWith(".localhost") || normalized === "::1" || normalized === "0:0:0:0:0:0:0:1") return true;
+  const ipv4 = normalized.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/u)?.slice(1).map(Number);
+  if (ipv4 && ipv4.every((part) => part >= 0 && part <= 255)) {
+    const [a, b] = ipv4;
+    return a === 0 || a === 10 || a === 127 || a === 100 && b >= 64 && b <= 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168;
+  }
+  return normalized.startsWith("fc") || normalized.startsWith("fd") || normalized.startsWith("fe80:");
+}
+
+export function validatePublicImageUrl(value: string): URL {
+  const normalized = validateHttpUrl(value, "DashScope image URL");
+  const url = new URL(normalized);
+  if (privateHostname(url.hostname)) throw new Error("DashScope image URL targets a private network address");
+  return url;
+}
+
+function redirectStatus(status: number): boolean {
+  return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
+}
+
+function timedSignal(signal: AbortSignal | undefined, timeoutMs: number): { signal: AbortSignal; dispose: () => void } {
+  const controller = new AbortController();
+  const abort = () => controller.abort(signal?.reason);
+  if (signal?.aborted) abort();
+  else signal?.addEventListener("abort", abort, { once: true });
+  const timer = setTimeout(() => controller.abort(new Error("DashScope image download timed out")), timeoutMs);
+  return { signal: controller.signal, dispose: () => { clearTimeout(timer); signal?.removeEventListener("abort", abort); } };
+}
+
+async function readLimitedBody(response: Response, limit: number): Promise<Uint8Array> {
+  const contentLength = Number(response.headers.get("content-length"));
+  if (Number.isFinite(contentLength) && contentLength > limit) throw new Error(`DashScope image exceeds ${limit} byte limit`);
+  if (!response.body) {
+    const bytes = new Uint8Array(await response.arrayBuffer());
+    if (bytes.byteLength > limit) throw new Error(`DashScope image exceeds ${limit} byte limit`);
+    return bytes;
+  }
+  const reader = response.body.getReader();
+  const chunks: Uint8Array[] = [];
+  let size = 0;
+  try {
+    while (true) {
+      const next = await reader.read();
+      if (next.done) break;
+      size += next.value.byteLength;
+      if (size > limit) { await reader.cancel(); throw new Error(`DashScope image exceeds ${limit} byte limit`); }
+      chunks.push(next.value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(size);
+  let offset = 0;
+  for (const chunk of chunks) { bytes.set(chunk, offset); offset += chunk.byteLength; }
+  return bytes;
+}
+
+/** Downloads only public HTTP(S) URLs, preserves origin across at most five manual redirects, and sends no API headers. */
+export async function downloadDashScopeImage(urlValue: string, fetcher: FetchFunction, signal?: AbortSignal): Promise<{ mimeType: string; data: string }> {
+  const initial = validatePublicImageUrl(urlValue);
+  const origin = initial.origin;
+  const timed = timedSignal(signal, 30_000);
+  try {
+    let current = initial;
+    for (let redirects = 0; redirects <= 5; redirects++) {
+      const response = await fetcher(current, { method: "GET", redirect: "manual", signal: timed.signal });
+      if (redirectStatus(response.status)) {
+        if (redirects === 5) throw new Error("DashScope image redirect limit exceeded");
+        const location = response.headers.get("location");
+        if (!location) throw new Error(`DashScope image redirect ${response.status} lacks Location`);
+        const next = validatePublicImageUrl(new URL(location, current).toString());
+        if (next.origin !== origin) throw new Error("DashScope image redirect changed origin");
+        await response.body?.cancel();
+        current = next;
+        continue;
+      }
+      if (!response.ok) throw new Error(`DashScope image download failed: HTTP ${response.status}`);
+      const bytes = await readLimitedBody(response, 10 * 1024 * 1024);
+      const contentType = response.headers.get("content-type")?.split(";", 1)[0]?.trim();
+      const mimeType = contentType?.startsWith("image/") ? contentType : "image/png";
+      return { mimeType, data: dataUrl(mimeType, Buffer.from(bytes).toString("base64")) };
+    }
+    throw new Error("DashScope image redirect limit exceeded");
+  } finally {
+    timed.dispose();
+  }
+}

package/src/image-apis/dashscope.ts

@@ -0,0 +1,42 @@
+import type { AssistantImages, ImageModel, ImagesContext, ImagesOptions } from "@earendil-works/pi-ai";
+import { apiKey, downloadDashScopeImage, failedImageResult, fetchFor, imageResult, normalizeBaseUrl, promptFromContext, records, requestHeaders, resolveImageBaseUrl, responseJson } from "./common.ts";
+
+/** DashScope multimodal-generation synchronous endpoint. Deliberately does not set X-DashScope-Async. */
+export async function generateImages(model: ImageModel<string>, context: ImagesContext, options?: ImagesOptions, activeSecrets: readonly string[] = []): Promise<AssistantImages> {
+  try {
+    const baseUrl = resolveImageBaseUrl(model.api, model.baseUrl);
+    if (!baseUrl) throw new Error("DashScope Images requires a Base URL");
+    const key = apiKey(options);
+    if (!key) throw new Error("DashScope Images requires an API key");
+    const fetcher = fetchFor(options);
+    const response = await fetcher(`${normalizeBaseUrl(baseUrl, "/api/v1")}/services/aigc/multimodal-generation/generation`, {
+      method: "POST",
+      headers: requestHeaders(model, options, { authorization: `Bearer ${key}` }),
+      body: JSON.stringify({
+        model: model.id,
+        input: { messages: [{ role: "user", content: [{ text: promptFromContext(context) }] }] },
+      }),
+      signal: options?.signal,
+    });
+    const json = await responseJson(response, options, activeSecrets) as Record<string, unknown>;
+    const output = json.output as Record<string, unknown> | undefined;
+    const firstChoice = records(output?.choices)[0];
+    const message = firstChoice?.message as Record<string, unknown> | undefined;
+    const result = imageResult(model);
+    for (const part of records(message?.content)) {
+      const imageField = part.image;
+      const url = typeof imageField === "string"
+        ? imageField
+        : imageField && typeof imageField === "object" && !Array.isArray(imageField) && typeof (imageField as Record<string, unknown>).url === "string"
+          ? String((imageField as Record<string, unknown>).url)
+          : undefined;
+      if (!url) continue;
+      const image = await downloadDashScopeImage(url, fetcher, options?.signal);
+      result.output.push({ type: "image", mimeType: image.mimeType, data: image.data });
+    }
+    if (!result.output.length) throw new Error("DashScope Images returned no downloadable image URLs");
+    return result;
+  } catch (error) {
+    return failedImageResult(model, error, options, activeSecrets);
+  }
+}

package/src/image-apis/gemini.ts

@@ -0,0 +1,36 @@
+import type { AssistantImages, ImageModel, ImagesContext, ImagesOptions } from "@earendil-works/pi-ai";
+import { apiKey, dataUrl, failedImageResult, fetchFor, imageResult, normalizeBaseUrl, promptFromContext, records, requestHeaders, resolveImageBaseUrl, responseJson } from "./common.ts";
+
+export async function generateImages(model: ImageModel<string>, context: ImagesContext, options?: ImagesOptions, activeSecrets: readonly string[] = []): Promise<AssistantImages> {
+  try {
+    const baseUrl = resolveImageBaseUrl(model.api, model.baseUrl);
+    if (!baseUrl) throw new Error("Gemini Images requires a Base URL");
+    const key = apiKey(options);
+    if (!key) throw new Error("Gemini Images requires an API key");
+    const response = await fetchFor(options)(`${normalizeBaseUrl(baseUrl, "/v1beta")}/models/${encodeURIComponent(model.id)}:generateContent`, {
+      method: "POST",
+      headers: requestHeaders(model, options, { "x-goog-api-key": key }),
+      body: JSON.stringify({
+        contents: [{ role: "user", parts: [{ text: promptFromContext(context) }] }],
+        generationConfig: { responseModalities: ["IMAGE"], imageConfig: { imageSize: "1K" } },
+      }),
+      signal: options?.signal,
+    });
+    const json = await responseJson(response, options, activeSecrets) as Record<string, unknown>;
+    const result = imageResult(model);
+    for (const candidate of records(json.candidates)) {
+      const content = candidate.content as Record<string, unknown> | undefined;
+      for (const part of records(content?.parts)) {
+        const inline = (part.inline_data ?? part.inlineData) as Record<string, unknown> | undefined;
+        const encoded = typeof inline?.data === "string" ? inline.data : undefined;
+        const mime = inline?.mime_type ?? inline?.mimeType;
+        const mimeType = typeof mime === "string" ? mime : "image/png";
+        if (encoded) result.output.push({ type: "image", data: dataUrl(mimeType, encoded), mimeType });
+      }
+    }
+    if (!result.output.length) throw new Error("Gemini Images returned no inline image data");
+    return result;
+  } catch (error) {
+    return failedImageResult(model, error, options, activeSecrets);
+  }
+}

package/src/image-apis/index.ts

@@ -0,0 +1,15 @@
+import type { ProviderImages } from "@earendil-works/pi-ai";
+import { generateImages as generateDashscopeImages } from "./dashscope.ts";
+import { generateImages as generateGeminiImages } from "./gemini.ts";
+import { generateImages as generateOpenaiImages } from "./openai.ts";
+import { generateImages as generateXaiImages } from "./xai.ts";
+
+/** Extension-owned APIs absent from Pi 1.2.0's host image catalog. */
+export const SELF_IMAGE_IMPLEMENTATIONS: Readonly<Record<string, ProviderImages>> = {
+  "openai-images": { generateImages: generateOpenaiImages },
+  "gemini-images": { generateImages: generateGeminiImages },
+  "xai-images": { generateImages: generateXaiImages },
+  "dashscope-images": { generateImages: generateDashscopeImages },
+};
+
+export const SELF_IMAGE_APIS: ReadonlySet<string> = new Set(Object.keys(SELF_IMAGE_IMPLEMENTATIONS));

package/src/image-apis/openai.ts

@@ -0,0 +1,32 @@
+import type { AssistantImages, ImageModel, ImagesContext, ImagesOptions } from "@earendil-works/pi-ai";
+import { apiKey, dataUrl, failedImageResult, fetchFor, imageResult, normalizeBaseUrl, promptFromContext, records, requestHeaders, resolveImageBaseUrl, responseJson } from "./common.ts";
+
+/** OpenAI Images API; this is a small request-local adapter, not Pi's host image pipeline. */
+export async function generateImages(model: ImageModel<string>, context: ImagesContext, options?: ImagesOptions, activeSecrets: readonly string[] = []): Promise<AssistantImages> {
+  try {
+    const baseUrl = resolveImageBaseUrl(model.api, model.baseUrl);
+    if (!baseUrl) throw new Error("OpenAI Images requires a Base URL");
+    const key = apiKey(options);
+    if (!key) throw new Error("OpenAI Images requires an API key");
+    const isGptImage = model.id.toLowerCase().startsWith("gpt-image");
+    const body: Record<string, unknown> = { model: model.id, prompt: promptFromContext(context), n: 1 };
+    if (isGptImage) body.output_format = "png";
+    else body.response_format = "b64_json";
+    const response = await fetchFor(options)(`${normalizeBaseUrl(baseUrl, "/v1")}/images/generations`, {
+      method: "POST",
+      headers: requestHeaders(model, options, { authorization: `Bearer ${key}` }),
+      body: JSON.stringify(body),
+      signal: options?.signal,
+    });
+    const json = await responseJson(response, options, activeSecrets) as Record<string, unknown>;
+    const result = imageResult(model);
+    for (const item of records(json.data)) {
+      const encoded = typeof item.b64_json === "string" ? item.b64_json : undefined;
+      if (encoded) result.output.push({ type: "image", data: dataUrl("image/png", encoded), mimeType: "image/png" });
+    }
+    if (!result.output.length) throw new Error("OpenAI Images returned no base64 image data");
+    return result;
+  } catch (error) {
+    return failedImageResult(model, error, options, activeSecrets);
+  }
+}

package/src/image-apis/xai.ts

@@ -0,0 +1,27 @@
+import type { AssistantImages, ImageModel, ImagesContext, ImagesOptions } from "@earendil-works/pi-ai";
+import { apiKey, dataUrl, failedImageResult, fetchFor, imageResult, normalizeBaseUrl, promptFromContext, records, requestHeaders, resolveImageBaseUrl, responseJson } from "./common.ts";
+
+export async function generateImages(model: ImageModel<string>, context: ImagesContext, options?: ImagesOptions, activeSecrets: readonly string[] = []): Promise<AssistantImages> {
+  try {
+    const baseUrl = resolveImageBaseUrl(model.api, model.baseUrl);
+    if (!baseUrl) throw new Error("xAI Images requires a Base URL");
+    const key = apiKey(options);
+    if (!key) throw new Error("xAI Images requires an API key");
+    const response = await fetchFor(options)(`${normalizeBaseUrl(baseUrl, "/v1")}/images/generations`, {
+      method: "POST",
+      headers: requestHeaders(model, options, { authorization: `Bearer ${key}` }),
+      body: JSON.stringify({ model: model.id, prompt: promptFromContext(context), n: 1, response_format: "b64_json" }),
+      signal: options?.signal,
+    });
+    const json = await responseJson(response, options, activeSecrets) as Record<string, unknown>;
+    const result = imageResult(model);
+    for (const item of records(json.data)) {
+      const encoded = typeof item.b64_json === "string" ? item.b64_json : undefined;
+      if (encoded) result.output.push({ type: "image", data: dataUrl("image/jpeg", encoded), mimeType: "image/jpeg" });
+    }
+    if (!result.output.length) throw new Error("xAI Images returned no base64 image data");
+    return result;
+  } catch (error) {
+    return failedImageResult(model, error, options, activeSecrets);
+  }
+}

package/src/runtime.ts

@@ -13,6 +13,8 @@ import { builtinProviders } from "@earendil-works/pi-ai/providers/all";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { ModelConfigFile, ModelsJsonFile, ModelsJsonProvider, ProviderConnectionConfig } from "./types.ts";
 import { validateHttpUrl } from "./config.ts";
+import { resolveImageBaseUrl } from "./image-apis/common.ts";
+import { SELF_IMAGE_APIS, SELF_IMAGE_IMPLEMENTATIONS } from "./image-apis/index.ts";
 import { mcError, t, type UiLanguage } from "./i18n.ts";
 import { ANONYMOUS_SENTINEL, applyProviderTransport, CHAT_APIS, CLASSIFIER_APIS, IMAGE_APIS, PROXY_CHAT_APIS, type TransportOptions } from "./transport.ts";
 
@@ -105,7 +107,9 @@ function wrapClassifier(api: string, config: ProviderConnectionConfig): Provider
 }
 
 function wrapImages(api: string, config: ProviderConnectionConfig): ProviderImages {
-  const base = requiredImplementation(HOST_APIS.image, api, "image");
+  // Pi 1.2.0's ImageApi remains open to custom strings, while its host catalog only
+  // knows openrouter-images. The four entries below are extension-owned adapters.
+  const base = SELF_IMAGE_APIS.has(api) ? SELF_IMAGE_IMPLEMENTATIONS[api]! : requiredImplementation(HOST_APIS.image, api, "image");
   return {
     generateImages: (model, context, options) => base.generateImages(model, context, applyProviderTransport(options, {
       proxyUrl: config.proxyUrl,
@@ -174,7 +178,14 @@ function validateRuntimeConfig(providerId: string, config: ProviderConnectionCon
     const supported = model.type === "classifier" ? CLASSIFIER_APIS : model.type === "image" ? IMAGE_APIS : undefined;
     if (!supported) throw mcError("MCFG_E_MODEL_SHAPE", { file: "model-config.json", provider: providerId });
     if (!supported.has(model.api)) throw mcError("MCFG_E_TYPE_API", { identity: `${providerId}/${model.type}/${model.id}`, api: model.api });
-    if (config.owned) validateHttpUrl(model.baseUrl ?? modelsProvider?.baseUrl ?? "", `${providerId}/${model.id} Base URL`);
+    const effectiveBaseUrl = model.type === "image"
+      ? resolveImageBaseUrl(model.api, model.baseUrl, modelsProvider?.baseUrl)
+      : model.baseUrl ?? modelsProvider?.baseUrl;
+    if (config.owned && !effectiveBaseUrl) throw mcError("MCFG_E_BASE_URL_REQUIRED");
+    if (config.owned && effectiveBaseUrl) validateHttpUrl(effectiveBaseUrl, `${providerId}/${model.id} Base URL`);
+    if (config.authMode === "anonymous" && model.type === "image" && SELF_IMAGE_APIS.has(model.api)) {
+      throw mcError("MCFG_E_ANONYMOUS_UNSUPPORTED", { identity: `${providerId}/image/${model.id}` });
+    }
     if (config.owned && model.type === "classifier" && typeof model.contextWindow !== "number") throw mcError("MCFG_E_MODEL_SHAPE", { file: "model-config.json", provider: providerId });
   }
   if (!config.owned && (config.models?.length ?? 0) > 0) {
@@ -192,7 +203,13 @@ function validateRuntimeConfig(providerId: string, config: ProviderConnectionCon
 
 function registerOwnedProvider(pi: ExtensionAPI, providerId: string, config: ProviderConnectionConfig, modelsProvider: ModelsJsonProvider, language: UiLanguage): void {
   const chatModels = normalizeChatModels(providerId, modelsProvider, config);
-  const extraModels = (config.models ?? []).map((model) => ({ ...model, provider: providerId, baseUrl: model.baseUrl ?? modelsProvider.baseUrl ?? "" }));
+  const extraModels = (config.models ?? []).map((model) => ({
+    ...model,
+    provider: providerId,
+    baseUrl: model.type === "image"
+      ? resolveImageBaseUrl(model.api, model.baseUrl, modelsProvider.baseUrl) ?? ""
+      : model.baseUrl ?? modelsProvider.baseUrl ?? "",
+  }));
   const allModels = [...chatModels, ...extraModels];
   if (allModels.length === 0) return;
   const chatApis = new Set(chatModels.map((model) => model.api));

package/src/transport.ts

@@ -1,6 +1,6 @@
 import { ProxyAgent, fetch as undiciFetch } from "undici";
 import type { FetchFunction, ProviderEnv, ProviderHeaders, Transport } from "@earendil-works/pi-ai";
-import type { ProviderDraft } from "./types.ts";
+import { IMAGE_API_NAMES, type ProviderDraft } from "./types.ts";
 import { validateHttpUrl } from "./config.ts";
 import { mcError } from "./i18n.ts";
 
@@ -26,7 +26,7 @@ export const CLASSIFIER_APIS = new Set([
   "cloudflare-workers-ai-system-one",
   "openai-decisions",
 ]);
-export const IMAGE_APIS = new Set(["openrouter-images"]);
+export const IMAGE_APIS = new Set(IMAGE_API_NAMES);
 
 export function assertSupportedProtocol(draft: ProviderDraft, type: "chat" | "classifier" | "image"): void {
   const api = type === "chat" ? draft.chatApi : type === "classifier" ? draft.classifierApi : draft.imageApi;
@@ -87,6 +87,7 @@ export function applyProviderTransport<T extends TransportOptions>(
       ...next.headers,
       authorization: null,
       "x-api-key": null,
+      "x-goog-api-key": null,
       "cf-aig-authorization": null,
     };
   }

package/src/types.ts

@@ -1,7 +1,9 @@
 import type { AnyModel } from "@earendil-works/pi-ai";
 
 export const MODEL_TYPES = ["chat", "classifier", "image"] as const;
+export const IMAGE_API_NAMES = ["openrouter-images", "openai-images", "gemini-images", "xai-images", "dashscope-images"] as const;
 export type ManagedModelType = (typeof MODEL_TYPES)[number];
+export type ImageApiName = (typeof IMAGE_API_NAMES)[number];
 export type ModelIdentity = `${string}\u0000${ManagedModelType}\u0000${string}`;
 
 export type AuthMode = "models-json" | "reuse-pi" | "anonymous";
@@ -64,7 +66,7 @@ export interface ProviderConnectionConfig {
   proxyUrl?: string;
   chatApi?: string;
   classifierApi?: string;
-  imageApi?: string;
+  imageApi?: ImageApiName;
   defaultType?: ManagedModelType;
   defaultContextWindow?: number;
   defaultMaxTokens?: number;
@@ -111,7 +113,7 @@ export interface ProviderDraft {
   proxyUrl?: string;
   chatApi: string;
   classifierApi: string;
-  imageApi: string;
+  imageApi: ImageApiName;
   defaultType: ManagedModelType;
 }