@xinizai/pi-image-gen 0.1.2 → 0.1.4

package/src/index.ts

@@ -4,7 +4,7 @@ import { configErrorText, configText, createService, deleteProvider, discoverPro
 import { GlobalConfigStore } from "./core/global-config.js";
 import { maskApiKey, ImageGenError } from "./core/errors.js";
 import { ModelRegistry } from "./core/model-registry.js";
-import type { DiscoveryResult, StoredProviderConfig } from "./core/types.js";
+import type { DiscoveryResult, ModelCapability, ModelInfo, StoredProviderConfig } from "./core/types.js";
 
 const OutputFormat = Type.Union([Type.Literal("png"), Type.Literal("jpeg"), Type.Literal("jpg"), Type.Literal("webp")]);
 
@@ -181,13 +181,17 @@ async function interactiveAddProvider(ctx: ExtensionCommandContext): Promise<voi
     const discovery = await discoverProviderCandidate({ name, baseUrl, apiKey }, ctx.signal);
     ctx.ui.notify(renderDiscoveryChoiceText(discovery), "info");
     const defaultModel = await selectDefaultImageModel(ctx, discovery);
-    if (!defaultModel) { ctx.ui.notify("已取消添加：未选择默认图片模型。", "info"); return; }
+    if (!defaultModel) { ctx.ui.notify("已取消添加：未选择默认生图模型。", "info"); return; }
+    const defaultEditModel = await selectOptionalOperationModel(ctx, discovery, "image_edit", defaultModel);
+    const defaultVariationModel = await selectOptionalOperationModel(ctx, discovery, "image_variation", defaultModel);
     let setDefault = before.providers.length === 0;
     if (!setDefault && before.defaultProviderId) setDefault = await ctx.ui.confirm("设置默认提供商", `是否将 ${name} 设置为默认图片提供商？`);
     const responseFormat = await chooseResponseFormat(ctx, "自动兼容（推荐）");
     if (!responseFormat) return;
-    const input: { name: string; baseUrl: string; apiKey: string; defaultModel?: string; responseFormat?: "auto" | "url" | "b64_json"; setDefault?: boolean } = { name, baseUrl, apiKey, responseFormat, setDefault };
+    const input: { name: string; baseUrl: string; apiKey: string; defaultModel?: string; defaultEditModel?: string; defaultVariationModel?: string; responseFormat?: "auto" | "url" | "b64_json"; setDefault?: boolean } = { name, baseUrl, apiKey, responseFormat, setDefault };
     if (defaultModel) input.defaultModel = defaultModel;
+    if (defaultEditModel) input.defaultEditModel = defaultEditModel;
+    if (defaultVariationModel) input.defaultVariationModel = defaultVariationModel;
     ctx.ui.notify(await saveProviderWithDiscovery(input, discovery, store), "info");
     ctx.ui.notify(await configText(ctx.signal), "info");
   } catch (e) {
@@ -249,10 +253,12 @@ async function interactiveEditProvider(ctx: ExtensionCommandContext, id: string)
       : await (await createService(provider.id)).discover(false, ctx.signal);
     ctx.ui.notify(renderDiscoveryChoiceText(discovery), "info");
     const defaultModel = await selectDefaultImageModel(ctx, discovery, modelInput || provider.defaultModel);
-    if (!defaultModel) { ctx.ui.notify("已取消编辑：未选择默认图片模型。", "info"); return; }
+    if (!defaultModel) { ctx.ui.notify("已取消编辑：未选择默认生图模型。", "info"); return; }
+    const defaultEditModel = await selectOptionalOperationModel(ctx, discovery, "image_edit", defaultModel, provider.defaultEditModel);
+    const defaultVariationModel = await selectOptionalOperationModel(ctx, discovery, "image_variation", defaultModel, provider.defaultVariationModel);
     const responseFormat = await chooseResponseFormat(ctx, responseFormatLabel(provider.responseFormat ?? "auto"));
     if (!responseFormat) return;
-    const input: { id: string; name?: string; baseUrl?: string; apiKey?: string; defaultModel?: string; responseFormat?: "auto" | "url" | "b64_json" } = { id: provider.id, responseFormat };
+    const input: { id: string; name?: string; baseUrl?: string; apiKey?: string; defaultModel?: string; defaultEditModel?: string | undefined; defaultVariationModel?: string | undefined; responseFormat?: "auto" | "url" | "b64_json" } = { id: provider.id, responseFormat, defaultEditModel, defaultVariationModel };
     if (nextName !== provider.name) input.name = nextName;
     if (nextBaseUrl !== provider.baseUrl) input.baseUrl = nextBaseUrl;
     if (nextApiKey !== provider.apiKey) input.apiKey = nextApiKey;
@@ -285,16 +291,16 @@ async function chooseProviderModel(ctx: ExtensionCommandContext, id: string): Pr
   try {
     ctx.ui.notify("正在测试连接并获取模型，请稍候……", "info");
     const discovery = await discoverProviderCandidate({ name: provider.name, baseUrl: provider.baseUrl, apiKey: provider.apiKey }, ctx.signal);
-    const model = await selectDefaultImageModel(ctx, discovery, provider.defaultModel, () => discoverProviderCandidate({ name: provider.name, baseUrl: provider.baseUrl, apiKey: provider.apiKey }, ctx.signal));
-    if (model && model !== provider.defaultModel) ctx.ui.notify(await updateProvider({ id: provider.id, defaultModel: model }, ctx.signal, store, false), "info");
+    const refresh = () => discoverProviderCandidate({ name: provider.name, baseUrl: provider.baseUrl, apiKey: provider.apiKey }, ctx.signal);
+    const defaultModel = await selectDefaultImageModel(ctx, discovery, provider.defaultModel, refresh);
+    if (!defaultModel) return;
+    const defaultEditModel = await selectOptionalOperationModel(ctx, discovery, "image_edit", defaultModel, provider.defaultEditModel, refresh);
+    const defaultVariationModel = await selectOptionalOperationModel(ctx, discovery, "image_variation", defaultModel, provider.defaultVariationModel, refresh);
+    const changed = defaultModel !== provider.defaultModel || defaultEditModel !== provider.defaultEditModel || defaultVariationModel !== provider.defaultVariationModel;
+    if (changed) ctx.ui.notify(await updateProvider({ id: provider.id, defaultModel, defaultEditModel, defaultVariationModel }, ctx.signal, store, false), "info");
     else ctx.ui.notify("默认图片模型未改变。", "info");
   } catch (error) {
     ctx.ui.notify(configErrorText(error), "error");
-    const fallback = await ctx.ui.select("无法自动获取模型", ["手动输入模型 ID", "返回"]);
-    if (fallback === "手动输入模型 ID") {
-      const model = await prefilledInput(ctx, "手动输入默认图片模型 ID", provider.defaultModel ?? "");
-      if (model) ctx.ui.notify(await updateProvider({ id: provider.id, defaultModel: model }, ctx.signal, store, false), "info");
-    }
   }
 }
 
@@ -323,13 +329,13 @@ async function selectDefaultImageModel(ctx: ExtensionCommandContext, discovery:
   let query = "";
   let page = 0;
   while (true) {
-    const models = new ModelRegistry(activeDiscovery.models).byCapability("image_generation").map((model) => model.id);
-    const filtered = query ? models.filter((model) => model.toLowerCase().includes(query.toLowerCase())) : models;
+    const models = new ModelRegistry(activeDiscovery.models).byCapability("image_generation");
+    const filtered = query ? models.filter((model) => model.id.toLowerCase().includes(query.toLowerCase())) : models;
     const pageCount = Math.max(1, Math.ceil(filtered.length / MODEL_PAGE_SIZE));
     page = Math.min(page, pageCount - 1);
     const visible = filtered.slice(page * MODEL_PAGE_SIZE, (page + 1) * MODEL_PAGE_SIZE);
-    const options = visible.map((model, index) => `${model === current ? "●" : "○"} ${modelLabel(model)} [#${index + 1}]`);
-    if (current && !filtered.includes(current)) options.unshift(`● 当前模型：${modelLabel(current)}${models.includes(current) ? "（被筛选隐藏）" : "（API 未返回）"}`);
+    const options = visible.map((model, index) => `${model.id === current ? "●" : "○"} ${modelDisplayLabel(model)} [#${index + 1}]`);
+    if (current && !filtered.some((model) => model.id === current)) options.unshift(`● 当前模型：${modelLabel(current)}${models.some((model) => model.id === current) ? "（被筛选隐藏）" : "（API 未返回）"}`);
     if (page > 0) options.push("‹ 上一页模型");
     if (page + 1 < pageCount) options.push("下一页模型 ›");
     options.push("⌕ 搜索/过滤模型", "↻ 重新获取模型", "取消");
@@ -350,12 +356,59 @@ async function selectDefaultImageModel(ctx: ExtensionCommandContext, discovery:
       continue;
     }
     if (picked.startsWith("● 当前模型：")) return current;
-    const match = picked.match(/\[#(\d+)\]$/);
-    const selected = match ? visible[Number(match[1]) - 1] : undefined;
-    if (selected) return selected;
+    const model = picked.replace(/^[●○] /, "").replace(/ \[#\d+\]$/, "").replace(/ \[.*\]$/, "");
+    if (visible.some((item) => item.id === model)) return model;
   }
 }
 
+async function selectOptionalOperationModel(
+  ctx: ExtensionCommandContext,
+  discovery: DiscoveryResult,
+  capability: "image_edit" | "image_variation",
+  _generationModel: string,
+  current?: string,
+  refresh?: () => Promise<DiscoveryResult>,
+): Promise<string | undefined> {
+  const title = capability === "image_edit" ? "默认图片编辑模型" : "默认图片变体模型";
+  const useGeneration = "自动使用生图模型（推荐）";
+  const configure = "选择专用模型";
+  const picked = await ctx.ui.select(`选择${title}`, [useGeneration, configure]);
+  if (picked !== configure) return undefined;
+
+  let activeDiscovery = discovery;
+  while (true) {
+    const models = new ModelRegistry(activeDiscovery.models).byCapability(capability);
+    if (models.length === 0) {
+      ctx.ui.notify(`未发现可确认支持${title.replace("默认", "")}的模型；将使用生图模型。`, "warning");
+      return undefined;
+    }
+    const options = models.map((model) => `${model.id === current ? "●" : "○"} ${modelDisplayLabel(model)}`);
+    options.push(useGeneration, "↻ 重新获取模型", "返回");
+    const selected = await ctx.ui.select(`${title}（仅显示检测到支持该操作的模型）`, options);
+    if (!selected || selected === "返回") return undefined;
+    if (selected === useGeneration) return undefined;
+    if (selected === "↻ 重新获取模型") {
+      if (!refresh) { ctx.ui.notify("当前流程无法重新获取模型，请返回后再试。", "info"); continue; }
+      ctx.ui.notify("正在重新获取模型，请稍候……", "info");
+      try { activeDiscovery = await refresh(); }
+      catch (error) { ctx.ui.notify(configErrorText(error), "error"); }
+      continue;
+    }
+    const model = selected.replace(/^[●○] /, "").replace(/ \[.*\]$/, "");
+    if (models.some((item) => item.id === model)) return model;
+  }
+}
+
+function modelDisplayLabel(model: ModelInfo): string {
+  return `${modelLabel(model.id)} [${modelCapabilitiesLabel(model)}]`;
+}
+
+function modelCapabilitiesLabel(model: ModelInfo): string {
+  const labels: Record<ModelCapability, string> = { image_generation: "生图", image_edit: "编辑", image_variation: "变体", vision: "视觉", text: "文本", unknown: "未知" };
+  const source: Record<ModelInfo["capabilitySource"], string> = { metadata: "服务端声明", heuristic: "名称推测", manual: "手动配置", unknown: "无法判断" };
+  return `${model.capabilities.map((capability) => labels[capability]).join("、")}；${source[model.capabilitySource]}`;
+}
+
 function modelLabel(model: string): string {
   return model.length > MODEL_LABEL_LIMIT ? `${model.slice(0, MODEL_LABEL_LIMIT - 3)}...` : model;
 }
@@ -387,7 +440,7 @@ function normalizeEditedApiKey(input: string | undefined, current: string): stri
   return input;
 }
 
-async function saveProviderWithoutDiscovery(input: { name: string; baseUrl: string; apiKey: string; defaultModel: string; setDefault: boolean }, store: GlobalConfigStore): Promise<string> {
+async function saveProviderWithoutDiscovery(input: { name: string; baseUrl: string; apiKey: string; defaultModel: string; defaultEditModel?: string; defaultVariationModel?: string; setDefault: boolean }, store: GlobalConfigStore): Promise<string> {
   const provider = await store.addProvider(input);
   if (input.setDefault) await store.setDefaultProvider(provider.id);
   return [`提供商已保存：${provider.name} (${provider.id})`, `默认模型：${provider.defaultModel ?? "未设置"}`, "模型发现：未执行，已手动指定模型。"].join("\n");

package/src/tools/shared.ts

@@ -6,7 +6,7 @@ import { normalizeBaseUrl } from "../utils/config.js";
 import { GlobalConfigStore, PROVIDERS_FILE, resolveRuntimeConfig } from "../core/global-config.js";
 import { ImageGenError, maskApiKey } from "../core/errors.js";
 import { DEFAULT_MODEL_LIMIT, renderModelBrowser, renderRefreshSummary } from "../core/model-browser.js";
-import type { DiscoveryResult, ImageOperationResult, ModelBrowserOptions, ModelCapability, StoredProviderConfig } from "../core/types.js";
+import type { DiscoveryResult, ImageOperationResult, ModelBrowserOptions, ModelCapability, ModelInfo, StoredProviderConfig } from "../core/types.js";
 
 export async function createService(providerId?: string, env = process.env): Promise<ImageService> {
   const config = await resolveRuntimeConfig(providerId, env);
@@ -62,11 +62,11 @@ export async function configText(signal?: AbortSignal, store = new GlobalConfigS
     lines.push(`${index}. ${provider.name} (${provider.id})${global.defaultProviderId === provider.id ? " [默认]" : ""}`);
     lines.push(`   状态：${snapshot.status}${snapshot.reason ? `，原因：${snapshot.reason}` : ""}`);
     lines.push(`   模型来源：${provider.defaultModel && snapshot.totalModels === 1 && snapshot.summary.image_generation[0] === provider.defaultModel ? "手动指定或缓存 fallback" : "API 发现/缓存"}`);
-    lines.push(`   模型总数：${snapshot.totalModels}`);
-    lines.push(`   生图模型：${snapshot.summary.image_generation.length}`);
-    lines.push(`   图片编辑：${snapshot.summary.image_edit.length}`);
-    lines.push(`   图片变体：${snapshot.summary.image_variation.length}`);
-    lines.push(`   视觉理解：${snapshot.summary.vision.length}`);
+    lines.push(`   默认生图模型：${provider.defaultModel ?? "未设置"}`);
+    lines.push(`   默认编辑模型：${provider.defaultEditModel ?? "跟随生图模型（该模型需支持编辑）"}`);
+    lines.push(`   默认变体模型：${provider.defaultVariationModel ?? "跟随生图模型（该模型需支持变体）"}`);
+    lines.push(`   可用模型：生图 ${snapshot.summary.image_generation.length} / 编辑 ${snapshot.summary.image_edit.length} / 变体 ${snapshot.summary.image_variation.length} / 视觉 ${snapshot.summary.vision.length}（共 ${snapshot.totalModels}）`);
+    lines.push("   详细模型：运行 image_models，或在 /image-config 中选择模型。");
     lines.push("");
     index += 1;
   }
@@ -101,7 +101,7 @@ export async function discoverProviderCandidate(input: { name: string; baseUrl:
   return { providerId: config.providerId, providerName: config.providerName, providerType: provider.type, baseUrl: config.baseUrl, models: await provider.discoverModels(signal), discoveredAt: new Date().toISOString(), apiKeyFingerprint: cache.apiKeyFingerprint(config) };
 }
 
-export async function saveProviderWithDiscovery(input: { name: string; baseUrl: string; apiKey: string; defaultModel?: string; responseFormat?: "auto" | "url" | "b64_json"; setDefault?: boolean }, discovery: DiscoveryResult, store = new GlobalConfigStore()): Promise<string> {
+export async function saveProviderWithDiscovery(input: { name: string; baseUrl: string; apiKey: string; defaultModel?: string; defaultEditModel?: string; defaultVariationModel?: string; responseFormat?: "auto" | "url" | "b64_json"; setDefault?: boolean }, discovery: DiscoveryResult, store = new GlobalConfigStore()): Promise<string> {
   const existing = await store.read();
   const provider = await store.addProvider(input);
   const shouldSetDefault = existing.providers.length === 0 || Boolean(input.setDefault);
@@ -141,12 +141,14 @@ export async function addProvider(input: { name: string; baseUrl: string; apiKey
   return lines.join("\n");
 }
 
-export async function updateProvider(input: { id: string; name?: string; baseUrl?: string; apiKey?: string; defaultModel?: string; responseFormat?: "auto" | "url" | "b64_json" }, signal?: AbortSignal, store = new GlobalConfigStore(), refresh = true): Promise<string> {
+export async function updateProvider(input: { id: string; name?: string; baseUrl?: string; apiKey?: string; defaultModel?: string; defaultEditModel?: string | undefined; defaultVariationModel?: string | undefined; responseFormat?: "auto" | "url" | "b64_json" }, signal?: AbortSignal, store = new GlobalConfigStore(), refresh = true): Promise<string> {
   const patch: Partial<StoredProviderConfig> = {};
   if (input.name) patch.name = input.name;
   if (input.baseUrl) patch.baseUrl = input.baseUrl;
   if (input.apiKey) patch.apiKey = input.apiKey;
   if (input.defaultModel) patch.defaultModel = input.defaultModel;
+  if ("defaultEditModel" in input) patch.defaultEditModel = input.defaultEditModel;
+  if ("defaultVariationModel" in input) patch.defaultVariationModel = input.defaultVariationModel;
   if (input.responseFormat) patch.responseFormat = input.responseFormat;
   const provider = await store.updateProvider(input.id, patch);
   const snapshot = await inspectProvider(provider.id, store, signal, refresh).catch((error) => ({ status: statusFromError(error), reason: reasonFromError(error), totalModels: 0, summary: emptySummary() }));
@@ -194,16 +196,16 @@ async function refreshProvider(id: string, store: GlobalConfigStore, signal?: Ab
   return service.discover(true, signal);
 }
 
-async function inspectProvider(id: string, store: GlobalConfigStore, signal?: AbortSignal, refresh = false): Promise<{ provider: StoredProviderConfig; status: string; reason?: string; totalModels: number; summary: Record<ModelCapability, string[]> }> {
+async function inspectProvider(id: string, store: GlobalConfigStore, signal?: AbortSignal, refresh = false): Promise<{ provider: StoredProviderConfig; status: string; reason?: string; totalModels: number; models: ModelInfo[]; summary: Record<ModelCapability, string[]> }> {
   const provider = await store.resolveProvider(id);
   if (!provider) throw new ImageGenError("missing_config", `提供商 ${id} 不存在。`, "请在 /image-config 中重新添加或选择其他提供商。");
   const runtime = await store.toRuntimeConfig(provider);
   const service = new ImageService(runtime, resolveProvider(runtime));
   try {
     const registry = await service.registry(refresh, signal);
-    return { provider, status: "已连接", totalModels: registry.all().length, summary: registry.summary() };
+    return { provider, status: "已连接", totalModels: registry.all().length, models: registry.all(), summary: registry.summary() };
   } catch (error) {
-    return { provider, status: statusFromError(error), reason: reasonFromError(error), totalModels: 0, summary: emptySummary() };
+    return { provider, status: statusFromError(error), reason: reasonFromError(error), totalModels: 0, models: [], summary: emptySummary() };
   }
 }
 

package/src/utils/files.ts

@@ -70,9 +70,11 @@ function validateImageSignature(buffer: Buffer, ext: string): void {
 
 export function decodeBase64Image(data: string): { buffer: Buffer; mimeType: string; ext: string } {
   const match = data.match(/^data:(image\/(png|jpeg|jpg|webp));base64,(.+)$/i);
-  const mimeType = match?.[1] ?? "image/png";
   const payload = match?.[3] ?? data;
   const buffer = Buffer.from(payload, "base64");
   if (buffer.length === 0) throw new ImageGenError("invalid_image", "API 返回了空 base64 图片。", "检查服务商响应。 ");
-  return { buffer, mimeType, ext: extensionForMime(mimeType) };
+  const detected = detectImageFormat(buffer);
+  const mimeType = match?.[1] ?? detected?.mimeType ?? "image/png";
+  const ext = match?.[1] ? extensionForMime(mimeType) : detected?.ext ?? "png";
+  return { buffer, mimeType, ext };
 }