@billjr99/pi-openai-compat 1.1.14 → 1.1.16

package/README.md

@@ -56,8 +56,27 @@ If pi is already running when you install, type `/reload` first.
 | **OpenCode Zen** | `https://opencode.ai/zen/v1` | API key from opencode.ai |
 | **Ollama (local)** | `http://localhost:11434/v1` | Keyless |
 | **Ollama Cloud** | `https://ollama.com/v1` | Ollama Cloud API key from ollama.com |
+| **llmproxy** | `http://localhost:8080/v1` (editable) | Keyless by default; bearer token if your instance requires one |
 | **Custom** | Any URL you supply | Optional bearer token |
 
+> **llmproxy and the `__` model-id rewrite.**
+> [llmproxy](https://github.com/BillJr99/llmproxy) advertises model ids in the
+> `provider__model` form (e.g. `openrouter__gpt-4`) and exposes virtual models
+> such as `llmproxy__free` and `llmproxy__loadbalanced`. pi rejects model ids that
+> contain `__`, so without special handling **every llmproxy model is silently
+> dropped from `/model`**. The llmproxy template therefore sets
+> `rewriteDoubleUnderscore: true`: the extension rewrites the first `__` of each id
+> to `/` (e.g. `openrouter__gpt-4` → `openrouter/gpt-4`, `llmproxy__free` →
+> `llmproxy/free`) before registering with pi. llmproxy canonicalizes that slash
+> form back to `__` on each request, so routing still works.
+>
+> The flag is a per-provider config field (`rewriteDoubleUnderscore`, default
+> **false**) and is enabled automatically only for the llmproxy template — other
+> providers are unaffected. If you added llmproxy as a **Custom** endpoint instead
+> of via the llmproxy template, set `"rewriteDoubleUnderscore": true` on that
+> provider in `~/.config/pi-openai-compat/config.json` (or re-run `/compat-login`
+> and pick **llmproxy (local)**).
+
 > **Providers whose model catalog lives at a non-standard `/models` path (as of June 2026)**
 > Some providers don't return models at `<base_url>/models`. The extension
 > handles them in one of two ways:
@@ -311,17 +330,31 @@ parse error.
 **Cloudflare AI Gateway returns 401 Unauthorized**
 Check both: (1) the API token has `AI Gateway: Run` *and* `Workers AI: Read`
 under "Permissions", scoped to the correct account; and (2) the gateway slug
-in the URL actually exists under that account — list with
-`curl https://api.cloudflare.com/client/v4/accounts/$ACCOUNT_ID/ai-gateway/gateways
--H "Authorization: Bearer $TOKEN"`. An empty `result` array means the gateway
-isn't there (you may need to create it in **dash.cloudflare.com → AI → AI
-Gateway**, or you're querying the wrong account).
+in the URL actually exists under that account — list them with:
+
+```bash
+curl https://api.cloudflare.com/client/v4/accounts/$ACCOUNT_ID/ai-gateway/gateways \
+  -H "Authorization: Bearer $TOKEN"
+```
+
+An empty `result` array means the gateway isn't there (you may need to create it
+in **dash.cloudflare.com → AI → AI Gateway**, or you're querying the wrong
+account).
 
 **No models appear after login**
 For Ollama: pull at least one model first (`ollama pull llama3`).
 For OpenRouter: some keys are restricted to free-tier models only.
 For NIM: confirm your account has inference access enabled.
 
+**`/compat-login` reports N models but far fewer appear in `/model`**
+This is the classic llmproxy symptom: pi drops every model id containing `__`, so
+llmproxy's `provider__model` ids (and `llmproxy__free` / `llmproxy__loadbalanced`)
+never show. Make sure you logged in via the **llmproxy (local)** template (it sets
+`rewriteDoubleUnderscore: true` automatically). If you used **Custom**, add
+`"rewriteDoubleUnderscore": true` to that provider in
+`~/.config/pi-openai-compat/config.json` and re-run `/compat-refresh`. After the
+fix the ids appear in slash form (`openrouter/gpt-4`, `llmproxy/free`).
+
 **Models appear in `/model` but requests fail**
 Check `/compat-login` ran successfully (no error message).
 Verify Ollama is still running if using a local endpoint.

package/index.ts

@@ -44,6 +44,17 @@ interface ProviderConfig {
   modelsUrl?: string;
   modelsIdField?: string;
   modelsKeepTask?: string;
+  // Set once we've warned the user that this provider's saved baseUrl no longer
+  // matches its template and can't be auto-migrated, so the notice is shown
+  // only once rather than on every session_start while the config stays stale.
+  staleNotified?: boolean;
+  // When true, rewrite the FIRST "__" of every model id to "/" before
+  // registering with pi. pi rejects model ids containing "__", so providers like
+  // llmproxy (which uses "provider__model" ids) would otherwise have their entire
+  // catalog dropped from /model. The rewrite is the inverse of llmproxy's own
+  // request-side canonicalization, so requests still round-trip. Defaults false;
+  // the wizard turns it on only for the llmproxy template.
+  rewriteDoubleUnderscore?: boolean;
 }
 
 interface ExtensionConfig {
@@ -93,6 +104,12 @@ const TEMPLATES: Record<string, {
   modelsIdField?: string;
   /** Keep only models whose task.name matches this string (case-insensitive). */
   modelsKeepTask?: string;
+  /**
+   * Rewrite the first "__" of each model id to "/" before registering with pi.
+   * pi drops model ids containing "__", so this is required for llmproxy (whose
+   * ids are "provider__model"). Default false; set true only where pi needs it.
+   */
+  rewriteDoubleUnderscore?: boolean;
 }> = {
   openrouter: {
     displayName: "OpenRouter",
@@ -284,6 +301,10 @@ const TEMPLATES: Record<string, {
     baseUrl: "http://localhost:8080/v1",
     keyless: true,
     promptUrl: true,
+    // llmproxy advertises "provider__model" ids (and virtuals like
+    // "llmproxy__free"). pi rejects "__" in model ids, so rewrite the first
+    // "__" to "/" here; llmproxy canonicalizes the slash form back on requests.
+    rewriteDoubleUnderscore: true,
   },
   vercel: {
     displayName: "Vercel AI Gateway",
@@ -376,19 +397,24 @@ function escapeRegex(s: string): string {
  * treat as "this provider can't be healed automatically".
  */
 function recoverPlaceholders(templateUrl: string, savedUrl: string): Record<string, string> | null {
+  // Tolerate trailing-slash differences the same way the rest of the code does
+  // (e.g. baseUrl.replace(/\/+$/, "")), so a saved URL that differs only by a
+  // trailing slash still heals instead of being marked stale.
+  const tpl = templateUrl.replace(/\/+$/, "");
+  const saved = savedUrl.replace(/\/+$/, "");
   const order: string[] = [];
   const placeholderRe = new RegExp(URL_PLACEHOLDERS.join("|"), "g");
   let source = "^";
   let lastIndex = 0;
   let m: RegExpExecArray | null;
-  while ((m = placeholderRe.exec(templateUrl)) !== null) {
-    source += escapeRegex(templateUrl.slice(lastIndex, m.index)) + "([^/]+)";
+  while ((m = placeholderRe.exec(tpl)) !== null) {
+    source += escapeRegex(tpl.slice(lastIndex, m.index)) + "([^/]+)";
     order.push(m[0]);
     lastIndex = m.index + m[0].length;
   }
-  source += escapeRegex(templateUrl.slice(lastIndex)) + "$";
+  source += escapeRegex(tpl.slice(lastIndex)) + "$";
 
-  const match = new RegExp(source).exec(savedUrl);
+  const match = new RegExp(source).exec(saved);
   if (!match) return null;
   const out: Record<string, string> = {};
   order.forEach((name, i) => { out[name] = match[i + 1]; });
@@ -404,7 +430,8 @@ function applyPlaceholders(url: string, values: Record<string, string>): string
 /**
  * Backfill missing discovery fields on saved providers from their template.
  * Mutates `config` in place; the caller is responsible for persisting when
- * `healed` is non-empty. `stale` lists providers that need a manual re-login.
+ * `healed` is non-empty. `stale` lists the provider *keys* that need a manual
+ * re-login (the caller resolves display names and dedupes notifications).
  */
 function migrateDiscoveryFields(config: ExtensionConfig): { healed: string[]; stale: string[] } {
   const healed: string[] = [];
@@ -416,7 +443,7 @@ function migrateDiscoveryFields(config: ExtensionConfig): { healed: string[]; st
     if (p.modelsUrl) continue;       // already set (fresh login or manual edit) — never clobber
 
     const values = recoverPlaceholders(tpl.baseUrl, p.baseUrl);
-    if (!values) { stale.push(p.displayName); continue; }
+    if (!values) { stale.push(key); continue; }
 
     p.modelsUrl = applyPlaceholders(tpl.modelsUrl, values);
     p.modelsIdField = tpl.modelsIdField;
@@ -493,8 +520,10 @@ async function fetchModels(
     else if (Array.isArray(obj.result)) raw = obj.result as RawModel[];
   }
   if (!raw) {
+    // `url` may be an override (e.g. /catalog/models, /ai/models/search), so
+    // keep the wording generic rather than referring specifically to /models.
     throw new Error(
-      `Unexpected /models payload shape from ${url} ` +
+      `Unexpected model catalog payload shape from ${url} ` +
       `(expected an array or an object with a "data" or "result" array).`
     );
   }
@@ -506,8 +535,14 @@ async function fetchModels(
       return taskName.toLowerCase() === keepTask.toLowerCase();
     })
     .map((m) => {
-      const id = (m as Record<string, unknown>)[idField] as string | undefined;
-      return { id: id ?? "", contextWindow: m.context_window, maxTokens: m.max_tokens };
+      // Coerce the id field defensively: some upstreams expose a numeric id,
+      // and storing a non-string would break the localeCompare sort below.
+      const rawId = (m as Record<string, unknown>)[idField];
+      const id =
+        typeof rawId === "string" ? rawId :
+        typeof rawId === "number" ? String(rawId) :
+        "";
+      return { id, contextWindow: m.context_window, maxTokens: m.max_tokens };
     })
     .filter((m) => Boolean(m.id))
     .sort((a, b) => a.id.localeCompare(b.id));
@@ -517,16 +552,31 @@ async function fetchModels(
 // Provider registration helpers
 // ─────────────────────────────────────────────────────────────────────────────
 
-function buildProviderModels(models: CachedModel[]) {
-  return models.map((m) => ({
-    id: m.id,
-    name: m.id,
-    reasoning: false,
-    input: ["text"] as string[],
-    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-    contextWindow: m.contextWindow ?? 128_000,
-    maxTokens: m.maxTokens ?? 4_096,
-  }));
+/**
+ * Rewrite the FIRST "__" of a model id to "/". Only the first occurrence is
+ * touched: the provider/virtual segment that precedes it never contains "__" or
+ * "/", so this is the exact inverse of the slash→"__" canonicalization llmproxy
+ * applies on the request side, keeping ids round-trippable. Ids without "__" are
+ * returned unchanged.
+ */
+function rewriteFirstDoubleUnderscore(id: string): string {
+  const i = id.indexOf("__");
+  return i === -1 ? id : `${id.slice(0, i)}/${id.slice(i + 2)}`;
+}
+
+function buildProviderModels(models: CachedModel[], rewriteDoubleUnderscore = false) {
+  return models.map((m) => {
+    const id = rewriteDoubleUnderscore ? rewriteFirstDoubleUnderscore(m.id) : m.id;
+    return {
+      id,
+      name: id,
+      reasoning: false,
+      input: ["text"] as string[],
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+      contextWindow: m.contextWindow ?? 128_000,
+      maxTokens: m.maxTokens ?? 4_096,
+    };
+  });
 }
 
 function compatKey(key: string): string {
@@ -534,12 +584,16 @@ function compatKey(key: string): string {
 }
 
 function registerProvider(pi: ExtensionAPI, key: string, p: ProviderConfig): void {
+  // Honor the persisted per-provider flag; fall back to the template default for
+  // this key so providers logged in before the flag existed (e.g. an existing
+  // llmproxy provider) still get the rewrite without a re-login.
+  const rewrite = p.rewriteDoubleUnderscore ?? TEMPLATES[key]?.rewriteDoubleUnderscore ?? false;
   pi.registerProvider(compatKey(key), {
     name: `compat/${key.replace(/_/g, "-")}`,
     baseUrl: p.baseUrl,
     apiKey: p.apiKey ?? (isLocalUrl(p.baseUrl) ? "local" : ""),
     api: "openai-completions" as const,
-    models: buildProviderModels(p.cachedModels),
+    models: buildProviderModels(p.cachedModels, rewrite),
   });
 }
 
@@ -615,12 +669,19 @@ export default async function (pi: ExtensionAPI) {
         "warning"
       );
     }
-    if (stale.length > 0) {
+    // Warn about stale providers only once: re-notifying on every session_start
+    // while the config stays stale would be noise. Persist the flag so the
+    // notice survives restarts.
+    const toNotify = stale.filter((key) => !config.providers[key]?.staleNotified);
+    if (toNotify.length > 0) {
+      const names = toNotify.map((key) => config.providers[key].displayName);
       ctx.ui.notify(
-        `OpenAI-compat: ${stale.join(", ")} ${stale.length === 1 ? "has" : "have"} an out-of-date ` +
+        `OpenAI-compat: ${names.join(", ")} ${names.length === 1 ? "has" : "have"} an out-of-date ` +
         `base URL — run /compat-login to update (its endpoint changed and can't be migrated automatically).`,
         "warning"
       );
+      for (const key of toNotify) config.providers[key].staleNotified = true;
+      saveConfig(config);
     }
   });
 
@@ -775,6 +836,7 @@ export default async function (pi: ExtensionAPI) {
         modelsUrl,
         modelsIdField: tpl.modelsIdField,
         modelsKeepTask: tpl.modelsKeepTask,
+        rewriteDoubleUnderscore: tpl.rewriteDoubleUnderscore,
       };
       saveConfig(config);
       registerProvider(pi, key, config.providers[key]);
@@ -807,10 +869,17 @@ export default async function (pi: ExtensionAPI) {
         keys = providerKeys;
       } else {
         const ALL = "All providers";
-        const labels = [ALL, ...providerKeys.map((k) => config.providers[k].displayName)];
+        // Embed the internal provider key in each label so duplicate
+        // displayNames (or a provider literally named "All providers") can't
+        // collide with each other or the special "All providers" option.
+        const options = providerKeys.map((k) => ({
+          key: k,
+          label: `${config.providers[k].displayName} [${k}]`,
+        }));
+        const labels = [ALL, ...options.map((o) => o.label)];
         const chosen = await ctx.ui.select("Refresh which provider?", labels);
         if (!chosen) { ctx.ui.notify("Cancelled.", "info"); return; }
-        keys = chosen === ALL ? providerKeys : [providerKeys[labels.indexOf(chosen) - 1]];
+        keys = chosen === ALL ? providerKeys : [options[labels.indexOf(chosen) - 1].key];
       }
 
       const refreshed: string[] = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@billjr99/pi-openai-compat",
-  "version": "1.1.14",
+  "version": "1.1.16",
   "description": "pi-coding-agent extension: OpenAI-compatible endpoint support (OpenRouter, NVIDIA NIM, Nous Portal, Ollama, custom)",
   "author": "Bill Mongan <https://github.com/BillJr99>",
   "license": "MIT",