@wuyaos/pi-model-config 0.1.2 → 0.1.4

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));