@pi-unipi/unipi 2.2.1 → 2.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/unipi",
-  "version": "2.2.1",
+  "version": "2.2.2",
   "description": "All-in-one extension suite for Pi coding agent",
   "type": "module",
   "license": "MIT",

package/packages/image/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/image",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "description": "Image generation and image recognition tools for the Pi coding agent",
   "type": "module",
   "main": "src/index.ts",

package/packages/image/src/models.ts

@@ -72,10 +72,20 @@ let imagesModelsAttempted = false;
 /**
  * Load pi-ai's built-in images collection.
  *
- * `getImageModels`/`generateImages` are not re-exported from the pi-ai package
- * root, but `providers/all` exports `builtinImagesModels()`, which is the
- * supported entry point and also resolves auth. A failure is not fatal: it
- * degrades to null and callers report that no models are available.
+ * ⚠️ Do NOT reach for `getImageModels`/`getImageProviders`/`generateImages`:
+ *
+ *   - They are NOT re-exported from the pi-ai package root. Importing
+ *     `@earendil-works/pi-ai` and calling `getImageModels("openrouter")`
+ *     returns an EMPTY ARRAY rather than throwing, so the mistake looks like
+ *     "no models are installed" and costs a long debugging session.
+ *   - The file that defines them, `dist/image-models.js`, is not a permitted
+ *     subpath in pi-ai's `exports` map, so importing it directly throws
+ *     ERR_PACKAGE_PATH_NOT_EXPORTED.
+ *
+ * The supported entry point is `@earendil-works/pi-ai/providers/all` →
+ * `builtinImagesModels()`, which returns the catalog AND resolves auth.
+ * A failure is not fatal: it degrades to null and callers report that no
+ * models are available.
  */
 export async function getImagesModels(): Promise<ImagesModelsLike | null> {
   if (cachedImagesModels || imagesModelsAttempted) return cachedImagesModels;
@@ -106,6 +116,111 @@ export async function listImageGenModels(): Promise<ImageGenModel[]> {
   }
 }
 
+/**
+ * Heuristic: does a chat-registry model look like an image generator?
+ *
+ * Third-party providers registered by other extensions (pi-omniroute-bridge,
+ * for example) surface text-to-image endpoints as ordinary chat models. They
+ * declare no `output` modality at all, so a strict `output.includes("image")`
+ * check finds nothing and the user sees only pi-ai's built-in OpenRouter
+ * catalog. We therefore accept an explicit image output when present, and
+ * otherwise fall back to well-known generator naming.
+ */
+const GENERATOR_NAME_HINTS = [
+  "text-to-image",
+  "flux",
+  "dall-e",
+  "dalle",
+  "imagen",
+  "recraft",
+  "seedream",
+  "riverflow",
+  "grok-imagine",
+  "stable-diffusion",
+  "sdxl",
+  "midjourney",
+  "ideogram",
+  "nano-banana",
+];
+
+export function looksLikeImageGenerator(model: {
+  id: string;
+  name?: string;
+  output?: string[];
+}): boolean {
+  // An explicit declaration always wins.
+  if (Array.isArray(model.output)) {
+    if (model.output.includes("image")) return true;
+    // Declared, but text-only — trust it and do not guess from the name.
+    if (model.output.length > 0) return false;
+  }
+
+  const haystack = `${model.id} ${model.name ?? ""}`.toLowerCase();
+  // Match "image" as a delimited segment ("gpt-5-image", "gemini-3-pro-image"),
+  // not the bare word anywhere — which would wrongly catch vision models such
+  // as "claude-image-understanding". \b handles the whitespace between id and
+  // name; a character class alone missed ids ending the id portion.
+  if (/(^|[/\-_\s])image\b/.test(haystack) && !haystack.includes("understand")) {
+    return true;
+  }
+  return GENERATOR_NAME_HINTS.some((hint) => haystack.includes(hint));
+}
+
+/**
+ * Image-generation models discovered from the chat registry — i.e. providers
+ * registered by other extensions, which pi-ai's built-in catalog knows nothing
+ * about.
+ */
+export function listRegistryImageGenModels(
+  registry: ChatModelRegistry,
+): ImageGenModel[] {
+  let models: unknown[];
+  try {
+    models = registry.getAvailable?.() ?? registry.getAll();
+  } catch {
+    return [];
+  }
+
+  const out: ImageGenModel[] = [];
+  for (const model of models) {
+    if (model === null || typeof model !== "object") continue;
+    const candidate = model as Partial<ImageGenModel>;
+    if (typeof candidate.id !== "string" || typeof candidate.provider !== "string") {
+      continue;
+    }
+    if (!looksLikeImageGenerator(candidate as ImageGenModel)) continue;
+    out.push({
+      id: candidate.id,
+      provider: candidate.provider,
+      name: candidate.name,
+      api: candidate.api ?? "",
+      ...(candidate.output ? { output: candidate.output } : {}),
+    });
+  }
+  return out;
+}
+
+/**
+ * Every selectable generation model: pi-ai's built-in catalog plus anything
+ * contributed by registered providers, de-duplicated by "provider/id".
+ */
+export async function listAllImageGenModels(
+  registry?: ChatModelRegistry | null,
+): Promise<ImageGenModel[]> {
+  const builtin = await listImageGenModels();
+  const fromRegistry = registry ? listRegistryImageGenModels(registry) : [];
+
+  const seen = new Set(builtin.map((m) => formatModelRef(m).toLowerCase()));
+  const merged = [...builtin];
+  for (const model of fromRegistry) {
+    const key = formatModelRef(model).toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    merged.push(model);
+  }
+  return merged;
+}
+
 /** Inject a stub images collection. Test-only. */
 export function __setImagesModelsForTests(models: ImagesModelsLike | null): void {
   cachedImagesModels = models;

package/packages/image/src/tools.ts

@@ -14,7 +14,7 @@ import { generateImage } from "./generate.js";
 import { loadImage } from "./image-source.js";
 import {
   formatModelRef,
-  listImageGenModels,
+  listAllImageGenModels,
   resolveImageGenModel,
   resolveVisionModel,
   splitModelRef,
@@ -108,7 +108,10 @@ function registerGenerateTool(pi: ExtensionAPI): void {
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
       try {
         const config = loadConfig();
-        const models = await listImageGenModels();
+        const registry = getRegistry(ctx);
+        // Include image models contributed by registered providers, so the
+        // tool can resolve anything the settings picker offers.
+        const models = await listAllImageGenModels(registry);
 
         const requested = params.model?.trim() || config.generate.model;
         const resolved = resolveImageGenModel(requested, models);
@@ -116,7 +119,6 @@ function registerGenerateTool(pi: ExtensionAPI): void {
 
         // pi-ai resolves image auth from its own credential store; only fall
         // back to pi's chat-provider key when that comes up empty.
-        const registry = getRegistry(ctx);
         const fallbackKey = await resolveApiKey(registry, resolved.provider);
 
         const result = await generateImage({

package/packages/image/src/tui/model-selector.ts

@@ -56,6 +56,13 @@ export class ImageModelSelectorOverlay implements Component {
   invalidate(): void {}
 
   handleInput(data: string): void {
+    // Ctrl+C must always escape, even mid-filter. Without this the overlay traps
+    // the user with no way out.
+    if (data === "\x03") {
+      this.onClose?.();
+      return;
+    }
+
     if (this.filterMode) {
       this.handleFilterInput(data);
       return;
@@ -137,7 +144,9 @@ export class ImageModelSelectorOverlay implements Component {
     this.onSelect?.(`${model.provider}/${model.id}`);
     this.saved = true;
     this.error = null;
-    setTimeout(() => this.onClose?.(), 500);
+    // Close immediately. A deferred close leaves the overlay focused while the
+    // caller resumes, which is what let input reach two components at once.
+    this.onClose?.();
   }
 
   // ─── Theme helpers ───────────────────────────────────────────────────

package/packages/image/src/tui/settings-dialog.ts

@@ -17,7 +17,7 @@ import {
 } from "../settings.js";
 import {
   formatModelRef,
-  listImageGenModels,
+  listAllImageGenModels,
   listVisionModels,
   type ChatModelRegistry,
 } from "../models.js";
@@ -168,7 +168,7 @@ async function pickModel(
   if (models.length === 0) {
     ctx.ui.notify(
       kind === "generate"
-        ? "No image models available. Image generation is served through OpenRouter — add a key with /login."
+        ? "No image models available. Add an OpenRouter key with /login, or register a provider that exposes image models."
         : "No vision-capable models configured. Add a model that accepts image input.",
       "warning",
     );
@@ -183,18 +183,22 @@ async function pickModel(
   const current =
     kind === "generate" ? config.generate.model : config.recognize.model;
 
-  await new Promise<void>((resolve) => {
-    ctx.ui.custom(
+  // `ctx.ui.custom` resolves only when the factory calls `done()`. It MUST be
+  // awaited: returning early leaves the overlay on screen while the settings
+  // loop mounts the next `ctx.ui.select`, so two focused components fight over
+  // the same keystrokes and neither can be closed.
+  let picked: string | undefined;
+
+  try {
+    picked = await ctx.ui.custom<string | undefined>(
       (tui, theme, _keybindings, done) => {
         const overlay = new ImageModelSelectorOverlay(kind, models, current);
         overlay.setTheme(theme);
+        overlay.requestRender = () => tui.requestRender();
         overlay.onSelect = (modelRef) => {
-          const next = loadConfig();
-          if (kind === "generate") next.generate.model = modelRef;
-          else next.recognize.model = modelRef;
-          saveConfig(next);
+          picked = modelRef;
         };
-        overlay.onClose = () => done(undefined);
+        overlay.onClose = () => done(picked);
         return {
           render: (width: number) => overlay.render(width),
           invalidate: () => overlay.invalidate(),
@@ -209,21 +213,36 @@ async function pickModel(
         overlayOptions: { width: "80%", minWidth: 50, anchor: "center", margin: 2 },
       },
     );
-    resolve();
-  });
+  } catch (err) {
+    ctx.ui.notify(`Model selector error: ${err}`, "error");
+    return;
+  }
+
+  // Persist only after the overlay has fully closed, so a cancel leaves the
+  // existing config untouched.
+  if (!picked) return;
+
+  const next = loadConfig();
+  if (kind === "generate") next.generate.model = picked;
+  else next.recognize.model = picked;
+  saveConfig(next);
+  ctx.ui.notify(`${kind === "generate" ? "Generation" : "Recognition"} model set to ${picked}`, "info");
 }
 
 async function collectModels(
   ctx: ExtensionCommandContext,
   kind: "generate" | "recognize",
 ): Promise<SelectableModel[]> {
+  const registry = (ctx as unknown as { modelRegistry?: ChatModelRegistry })
+    .modelRegistry;
+
   if (kind === "generate") {
-    const models = await listImageGenModels();
+    // Include models from providers registered by other extensions, not just
+    // pi-ai's built-in OpenRouter catalog.
+    const models = await listAllImageGenModels(registry);
     return models.map((m) => ({ provider: m.provider, id: m.id, name: m.name }));
   }
 
-  const registry = (ctx as unknown as { modelRegistry?: ChatModelRegistry })
-    .modelRegistry;
   if (!registry) return [];
 
   return listVisionModels(registry).map((m) => ({