@pi-unipi/unipi 2.3.0 → 2.4.0

package/packages/unipi/bundled.js

@@ -36307,11 +36307,25 @@ function listRegistryImageGenModels(registry3) {
       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;
 }
+function findProviderBaseUrl(registry3, provider) {
+  if (!registry3) return void 0;
+  try {
+    const models = registry3.getAvailable?.() ?? registry3.getAll();
+    return models.find((m) => m?.provider === provider && m.baseUrl)?.baseUrl;
+  } catch {
+    return void 0;
+  }
+}
 async function listAllImageGenModels(registry3) {
   const builtin = await listImageGenModels();
   const fromRegistry = registry3 ? listRegistryImageGenModels(registry3) : [];
@@ -36745,6 +36759,240 @@ var ImageModelSelectorOverlay = class {
   }
 };
 
+// packages/image/src/openai-images-api.ts
+var openai_images_api_exports = {};
+__export(openai_images_api_exports, {
+  generateImages: () => generateImages,
+  normalizeImageItem: () => normalizeImageItem,
+  normalizeModelId: () => normalizeModelId
+});
+var DEFAULT_TIMEOUT_MS2 = 24e4;
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function normalizeImageItem(item) {
+  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;
+  const dataUrl = /^data:([^;,]+)(?:;[^,]*)*,(.*)$/s.exec(url);
+  if (dataUrl) {
+    const [, mime, payload] = dataUrl;
+    if (payload) return { data: payload, mimeType: declared ?? mime ?? "image/png" };
+    return null;
+  }
+  return { text: `Image available at: ${url}` };
+}
+function joinUrl(baseUrl, suffix) {
+  return `${baseUrl.replace(/\/+$/, "")}/${suffix.replace(/^\/+/, "")}`;
+}
+function normalizeModelId(id) {
+  return id;
+}
+function buildHeaders(apiKey, extra) {
+  const headers = {
+    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;
+}
+function describeError(status2, statusText, body) {
+  let detail = body.slice(0, 300);
+  try {
+    const parsed = JSON.parse(body);
+    if (typeof parsed.error === "string") detail = parsed.error;
+    else if (parsed.error?.message) detail = parsed.error.message;
+  } catch {
+  }
+  return `${status2} ${statusText}${detail ? `: ${detail}` : ""}`;
+}
+function annotateModelError(message, model) {
+  if (/invalid image model|not found|unknown model/i.test(message)) {
+    return `${message}
+\u2192 Model id sent: "${model.id}" (provider "${model.provider}").
+\u2192 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;
+}
+async function generateImages(model, context, options) {
+  const result = {
+    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_MS2
+  );
+  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}`);
+    }
+    const prompt = context.input.filter((part) => part.type === "text" && part.text).map((part) => part.text).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 = {
+      model: normalizeModelId(model.id),
+      prompt
+    };
+    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();
+    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);
+  }
+}
+
+// packages/image/src/register-providers.ts
+var registered = false;
+function groupModelsByProvider(models, baseUrlFor) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const model of models) {
+    const baseUrl = model.baseUrl ?? baseUrlFor(model.provider);
+    if (!baseUrl) continue;
+    let entry = grouped.get(model.provider);
+    if (!entry) {
+      entry = { baseUrl, models: [] };
+      grouped.set(model.provider, entry);
+    }
+    entry.models.push({ ...model, baseUrl });
+  }
+  return grouped;
+}
+function providerBaseUrlLookup(registry3) {
+  const cache = /* @__PURE__ */ new Map();
+  return (provider) => {
+    if (cache.has(provider)) return cache.get(provider);
+    let baseUrl;
+    try {
+      const models = registry3.getAvailable?.() ?? registry3.getAll();
+      baseUrl = models.find((m) => m?.provider === provider && m.baseUrl)?.baseUrl;
+    } catch {
+      baseUrl = void 0;
+    }
+    cache.set(provider, baseUrl);
+    return baseUrl;
+  };
+}
+async function registerRegistryImageProviders(registry3, options) {
+  if (!registry3) return [];
+  if (registered && !options?.force) return [];
+  const images = await getImagesModels();
+  if (!images) return [];
+  const mutable = images;
+  if (typeof mutable.setProvider !== "function") return [];
+  let createImagesProvider;
+  try {
+    const mod = await import("@earendil-works/pi-ai");
+    if (typeof mod.createImagesProvider !== "function") return [];
+    createImagesProvider = mod.createImagesProvider;
+  } catch {
+    return [];
+  }
+  const discovered = listRegistryImageGenModels(registry3);
+  if (discovered.length === 0) {
+    registered = true;
+    return [];
+  }
+  const grouped = groupModelsByProvider(discovered, providerBaseUrlLookup(registry3));
+  const added = [];
+  for (const [providerId, { models }] of grouped) {
+    try {
+      if (mutable.getProvider?.(providerId)) continue;
+    } catch {
+    }
+    try {
+      const provider = createImagesProvider({
+        id: providerId,
+        name: providerId,
+        models,
+        api: openai_images_api_exports,
+        auth: {
+          apiKey: {
+            name: `${providerId} API key`,
+            // Resolve through pi's own auth storage so the user never logs in
+            // twice. `resolve` MUST return an AuthResult (`{ auth: {...} }`);
+            // returning a bare key fails silently at request time.
+            resolve: async () => {
+              const key = await resolveProviderKey(registry3, providerId);
+              return key ? { auth: { apiKey: key }, source: `pi:${providerId}` } : void 0;
+            }
+          }
+        }
+      });
+      mutable.setProvider(provider);
+      added.push(providerId);
+    } catch {
+    }
+  }
+  registered = true;
+  return added;
+}
+async function resolveProviderKey(registry3, provider) {
+  try {
+    const key = await registry3.getApiKeyForProvider?.(provider);
+    if (key) return key;
+  } catch {
+  }
+  const envName = `${provider.toUpperCase().replace(/[^A-Z0-9]/g, "_")}_API_KEY`;
+  return process.env[envName] || void 0;
+}
+
 // packages/image/src/tui/settings-dialog.ts
 var EXIT = "__exit__";
 function describe(config) {
@@ -36911,6 +37159,7 @@ async function pickModel(ctx, kind, config) {
 async function collectModels(ctx, kind) {
   const registry3 = ctx.modelRegistry;
   if (kind === "generate") {
+    await registerRegistryImageProviders(registry3);
     const models = await listAllImageGenModels(registry3);
     const generating = await getGeneratingProviders();
     return models.map((m) => ({
@@ -36920,7 +37169,7 @@ async function collectModels(ctx, kind) {
       // pi-ai's images collection has its own provider set. A chat provider's
       // image models are listed for reference but cannot actually generate,
       // so flag them rather than letting the user pick a dead option.
-      unavailable: generating.length > 0 && !generating.includes(m.provider) ? "cannot generate" : void 0
+      unavailable: generating.length > 0 && !generating.includes(m.provider) ? "no image route" : void 0
     }));
   }
   if (!registry3) return [];
@@ -36996,7 +37245,7 @@ function providerCanGenerate(imagesApi, provider) {
   return providers.includes(provider);
 }
 async function generateImage(options) {
-  const { prompt, model, signal, outputDir, now: now2 } = options;
+  const { prompt, model, signal, outputDir, now: now2, inputImage } = options;
   if (!prompt.trim()) {
     throw new Error("A non-empty prompt is required.");
   }
@@ -37009,28 +37258,37 @@ async function generateImage(options) {
   if (!providerCanGenerate(imagesApi, model.provider)) {
     const supported = supportedProviders(imagesApi);
     throw new Error(
-      `Provider "${model.provider}" cannot generate images.
-\u2192 Image generation is served by: ${supported.join(", ") || "openrouter"}.
-\u2192 "${model.provider}" is a chat provider; its image models are listed for recognition and reference, but generation must go through a supported provider.
-\u2192 Pick one with /unipi:image-settings.`
+      `Provider "${model.provider}" has no image-generation route.
+\u2192 Available: ${supported.join(", ") || "openrouter"}.
+\u2192 Providers are bridged from pi automatically; one without a baseUrl or an API key cannot be used.
+\u2192 Pick another with /unipi:image-settings.`
     );
   }
   let apiKey;
   try {
-    apiKey = (await imagesApi.getAuth(model))?.apiKey;
+    const resolvedAuth = await imagesApi.getAuth(model);
+    apiKey = resolvedAuth?.auth?.apiKey ?? resolvedAuth?.apiKey;
   } catch {
   }
   apiKey ||= options.apiKey;
   if (!apiKey) {
     throw new Error(
       `No API key for provider "${model.provider}".
-\u2192 Add one with /login, or set the provider's API key environment variable.
-\u2192 Image models are served through OpenRouter: https://openrouter.ai/keys`
+\u2192 Sign in with /login, or set the provider's API key environment variable.
+\u2192 Expected environment variable: ${model.provider.toUpperCase().replace(/[^A-Z0-9]/g, "_")}_API_KEY`
     );
   }
+  const input = [{ 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 },
     { apiKey, ...signal ? { signal } : {} }
   );
   if (result.stopReason === "error") {
@@ -37194,7 +37452,7 @@ function truncate(value, max = 60) {
 }
 
 // packages/image/src/recognize.ts
-var DEFAULT_TIMEOUT_MS2 = 12e4;
+var DEFAULT_TIMEOUT_MS3 = 12e4;
 var DEFAULT_MAX_TOKENS = 2048;
 function createSignal(timeoutMs, external) {
   const controller = new AbortController();
@@ -37233,7 +37491,7 @@ async function callAnthropic2(options) {
     apiKey,
     baseUrl,
     modelId,
-    timeoutMs = DEFAULT_TIMEOUT_MS2,
+    timeoutMs = DEFAULT_TIMEOUT_MS3,
     maxTokens = DEFAULT_MAX_TOKENS,
     signal: external,
     fetchImpl = fetch
@@ -37340,7 +37598,7 @@ async function callOpenAICompatible2(options) {
     apiKey,
     baseUrl,
     modelId,
-    timeoutMs = DEFAULT_TIMEOUT_MS2,
+    timeoutMs = DEFAULT_TIMEOUT_MS3,
     maxTokens = DEFAULT_MAX_TOKENS,
     signal: external,
     fetchImpl = fetch
@@ -37447,11 +37705,14 @@ function registerGenerateTool(pi) {
   pi.registerTool({
     name: IMAGE_TOOLS.GENERATE,
     label: "Generate Image",
-    description: "Generate an image from a text prompt using an image model. The image is returned inline and, when enabled, saved to disk.",
+    description: "Generate an image from a text prompt, or edit an existing image by passing `image`. The result is returned inline and, when enabled, saved to disk.",
     promptSnippet: "Generate an image from a text prompt.",
     promptGuidelines: [
       "Use image_generate to create images from a text description.",
       "Write a detailed prompt \u2014 subject, style, composition and lighting all help.",
+      "Pass `image` to edit an existing image instead of generating a new one.",
+      "Editing regenerates the whole image, so unmentioned details may change.",
+      "Describe what you DO want; negation is unreliable in image models.",
       "Omit model to use the one configured in /unipi:image-settings.",
       "Generated images cost money per call; do not regenerate without being asked."
     ],
@@ -37459,6 +37720,11 @@ function registerGenerateTool(pi) {
       prompt: Type9.String({
         description: "Description of the image to generate. Be specific."
       }),
+      image: Type9.Optional(
+        Type9.String({
+          description: "Source image to edit: a local file path, data: URL, or base64 data. When set, the model edits this image instead of generating from scratch."
+        })
+      ),
       model: Type9.Optional(
         Type9.String({
           description: 'Image model override, e.g. "flux.2-pro" or "openrouter/google/gemini-3-pro-image". Omit to use the configured default.'
@@ -37469,21 +37735,26 @@ function registerGenerateTool(pi) {
       try {
         const config = loadConfig7();
         const registry3 = getRegistry2(ctx);
+        await registerRegistryImageProviders(registry3);
         const models = await listAllImageGenModels(registry3);
         const requested = params.model?.trim() || config.generate.model;
-        const resolved = resolveImageGenModel(requested, models);
-        if (typeof resolved === "string") return errorResult(resolved);
+        const maybeResolved = resolveImageGenModel(requested, models);
+        if (typeof maybeResolved === "string") return errorResult(maybeResolved);
+        const registryBaseUrl = maybeResolved.baseUrl ? void 0 : findProviderBaseUrl(registry3, maybeResolved.provider);
+        const resolved = registryBaseUrl ? { ...maybeResolved, baseUrl: registryBaseUrl } : maybeResolved;
         const fallbackKey = await resolveApiKey(registry3, resolved.provider);
+        const sourceImage = params.image?.trim() ? loadImage(params.image, ctx.cwd ?? process.cwd()) : void 0;
         const result = await generateImage({
           prompt: params.prompt,
           model: resolved,
           ...fallbackKey ? { apiKey: fallbackKey } : {},
+          ...sourceImage ? { inputImage: sourceImage } : {},
           signal,
           outputDir: config.generate.saveToDisk ? getOutputDir(config) : void 0
         });
         const saved = result.images.map((image) => image.path).filter((path28) => Boolean(path28));
         const summary = [
-          `Generated ${result.images.length} image${result.images.length === 1 ? "" : "s"} with ${formatModelRef(resolved)}.`,
+          `${sourceImage ? "Edited" : "Generated"} ${result.images.length} image${result.images.length === 1 ? "" : "s"} with ${formatModelRef(resolved)}.`,
           saved.length > 0 ? `Saved to:
 ${saved.map((p) => `  ${p}`).join("\n")}` : "",
           config.generate.saveToDisk && saved.length === 0 ? "Could not write to the output directory \u2014 returning the image inline only." : "",
@@ -37625,6 +37896,9 @@ function src_default5(pi) {
   registerImageCommands(pi);
   pi.on("session_start", async (_event, ctx) => {
     const config = loadConfig7();
+    void registerRegistryImageProviders(
+      ctx.modelRegistry
+    ).catch(() => void 0);
     const tools = [];
     if (config.generate.enabled) tools.push(IMAGE_TOOLS.GENERATE);
     if (config.recognize.enabled) tools.push(IMAGE_TOOLS.RECOGNIZE);

package/packages/updater/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/updater",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "Auto-updater, changelog browser, and readme browser for Unipi — checks npm registry, renders CHANGELOG.md and README.md files in TUI overlays",
   "type": "module",
   "main": "src/index.ts",
@@ -33,7 +33,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/utility/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/utility",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "Utility commands and tools for Pi coding agent — lifecycle, diagnostics, cache, analytics, display, batch execution",
   "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",
     "diff": "^7.0.0",
     "@shikijs/cli": "^4.0.2"
   },

package/packages/web-api/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/web-api",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "Web search, read, and summarize tools with provider-based backend selection for Pi coding agent",
   "type": "module",
   "main": "src/index.ts",
@@ -31,7 +31,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@pi-unipi/core": "2.3.0",
+    "@pi-unipi/core": "2.4.0",
     "defuddle": "^0.18.1",
     "linkedom": "^0.18.12",
     "lodash": "^4.17.21",

package/packages/workflow/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/workflow",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "Structured development workflow commands for Pi coding agent",
   "type": "module",
   "main": "index.ts",
@@ -26,7 +26,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.3.0"
+    "@pi-unipi/core": "2.4.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "^0.80.0",