myapikey 0.28.0 → 0.30.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myapikey",
-  "version": "0.28.0",
+  "version": "0.30.0",
   "type": "module",
   "description": "Personal LLM API gateway & proxy — one address + one API key for all your models. Forwards OpenAI & Anthropic calls to your backends with failover and a circuit breaker. Pure passthrough, no format translation. Self-hosted (CLI + web UI).",
   "keywords": [

package/packages/core/src/server/admin.ts

@@ -76,6 +76,7 @@ function toPublic(p: Provider) {
     apiKey: mask(p.apiKey),
     rpm: p.rpm ?? 0,
     discoveredModels: p.discoveredModels ?? [],
+    extraModels: p.extraModels ?? [],
     discoveredAt: p.discoveredAt ?? null,
     createdAt: p.createdAt,
   };
@@ -323,6 +324,33 @@ export function adminApi(store: Store, auth: MiddlewareHandler, openai: Hono, an
     }
   });
 
+  // Manual supplement to discovery: upstream model ids a backend's /models list
+  // doesn't include but that still work (delisted, unlisted, behind a different
+  // endpoint). Wholesale replace — same one-shot-save convention as PUT
+  // /admin/models/:name. Discovery refreshes only ever rewrite
+  // `discoveredModels`, so anything stored here survives every re-scan.
+  app.put("/providers/:id/extra-models", async (c) => {
+    const id = c.req.param("id");
+    const body = await readJson<{ models?: unknown }>(c.req.raw);
+    if (!body || !Array.isArray(body.models) || body.models.some((m) => typeof m !== "string")) {
+      return c.json({ error: { message: "models (string[]) is required" } }, 400);
+    }
+    // Canonical form: trimmed, deduped, case-insensitively sorted for scanning.
+    const models = [...new Set((body.models as string[]).map((m) => m.trim()).filter(Boolean))].sort((a, b) =>
+      a.toLowerCase().localeCompare(b.toLowerCase()),
+    );
+    let found = false;
+    await store.update((d) => {
+      const p = d.providers.find((x) => x.id === id);
+      if (!p) return;
+      found = true;
+      if (models.length) p.extraModels = models;
+      else delete p.extraModels;
+    });
+    if (!found) return c.json({ error: { message: "provider not found" } }, 404);
+    return c.json({ provider: toPublic(store.get().providers.find((x) => x.id === id)!) });
+  });
+
   // Test a SOURCE directly: one minimal ping per selected protocol, straight to
   // the upstream with this source's own key + base URL. Unlike the model tests
   // (which loop back through dispatch) this needs no routing config, so an
@@ -381,21 +409,26 @@ export function adminApi(store: Store, auth: MiddlewareHandler, openai: Hono, an
     // successful call per (model, format) from the log tail (newest first,
     // so the first hit wins). The UI shows this as the model's in-use slot —
     // after a failover the chip follows the source that really served.
+    // Companion map for FAILURES (latest 4xx/5xx per model+format) so the
+    // chain popover can flag the slots that recently errored.
     // Legacy rows carry only the provider NAME; resolve it to the stable id
     // so they can still match a slot.
     const byName = new Map(d.providers.map((p) => [p.name, p.id]));
-    const last = new Map<string, Map<string, LogEntry>>();
+    const okLog = new Map<string, Map<string, LogEntry>>();
+    const badLog = new Map<string, Map<string, LogEntry>>();
     for (const row of store.getLogs()) {
-      if (row.status < 200 || row.status >= 400) continue;
       const pid = row.providerId ?? (row.provider ? byName.get(row.provider) : undefined);
       if (!pid) continue;
-      let perFmt = last.get(row.model);
-      if (!perFmt) last.set(row.model, (perFmt = new Map()));
+      const target = row.status >= 200 && row.status < 400 ? okLog : badLog;
+      let perFmt = target.get(row.model);
+      if (!perFmt) target.set(row.model, (perFmt = new Map()));
       if (!perFmt.has(row.format)) perFmt.set(row.format, row);
     }
+    const lastEntries = (src: Map<string, Map<string, LogEntry>>, name: string) =>
+      [...src.get(name)?.entries() ?? []];
     const models = Object.entries(d.models).map(([name, e]) => ({
       ...projectModel(name, e, byId),
-      lastRoute: [...last.get(name)?.entries() ?? []].map(([format, row]) => ({
+      lastRoute: lastEntries(okLog, name).map(([format, row]) => ({
         format,
         providerId: row.providerId ?? byName.get(row.provider) ?? "",
         // The upstream name that was actually forwarded (a per-slot rewrite,
@@ -403,6 +436,14 @@ export function adminApi(store: Store, auth: MiddlewareHandler, openai: Hono, an
         model: row.upstreamModel ?? row.model,
         ts: row.ts,
       })),
+      lastFail: lastEntries(badLog, name).map(([format, row]) => ({
+        format,
+        providerId: row.providerId ?? byName.get(row.provider) ?? "",
+        model: row.upstreamModel ?? row.model,
+        status: row.status,
+        error: row.error,
+        ts: row.ts,
+      })),
     }));
     return c.json({ models });
   });

package/packages/core/src/shared/types.ts

@@ -31,6 +31,11 @@ export interface Provider {
   supportsResponses?: boolean;
   /** Model ids this provider offered at last discovery (cached, may be stale). */
   discoveredModels?: string[];
+  /** Manually supplemented upstream model ids — names a backend's /models list
+   *  doesn't include but that still work (delisted, unlisted, behind a
+   *  different endpoint). Merged with `discoveredModels` for editor suggestions
+   *  and the UI's staleness check; discovery refreshes never touch this list. */
+  extraModels?: string[];
   /** Epoch ms of the last successful/attempted discovery. */
   discoveredAt?: number;
   createdAt: number;