@route_33/opencode 0.4.2 → 0.4.4

package/README.md

@@ -24,12 +24,14 @@ The installer patches both configs: the server plugin into `opencode.json` and t
 }
 ```
 
-This plugin never writes your `opencode.json` or `opencode.jsonc`: opencode has no TUI-plugin auto-discovery, so without a `tui.json` entry the wizard simply never appears — the server plugin works regardless. The server plugin may write its own `.opencode/route33-generated.json` sidecar to track catalog-generated entries.
+This plugin never writes your `opencode.json` or `opencode.jsonc`: opencode has no TUI-plugin auto-discovery, so without a `tui.json` entry the wizard simply never appears — the server plugin works regardless. The only files the plugin ever writes inside your repo are an optional `.opencode/route33.key` (git-ignored automatically) and your own `.opencode/route33-overrides.json` (yours to commit or ignore).
 
 ## Auth
 
 Run `opencode auth login` and choose `route_33`, or set the `ROUTE33_API_KEY` environment variable. Without a key, the TUI wizard offers to save one: per-project inside a git workspace, global otherwise. A globally stored key applies only outside git workspaces — inside a workspace, keys resolve from the environment, the workspace config, or `.opencode/route33.key` (per-project keys are the metering boundary). Skipping the project-key wizard snoozes it for 7 days — "Skip" for that workspace only, "Skip for all workspaces" everywhere (both live in opencode's TUI kv store; remove `project-key-prompt.dismissed-at*` from `~/.local/state/opencode/kv.json` to re-arm sooner). `ROUTE33_BASE_URL` overrides the default gateway URL; `ROUTE33_TUI_PROMPT=0` disables the wizard.
 
+Your key is never written into the resolved provider configuration: authentication is attached per request at fetch time, so `opencode debug config` output contains no credential material.
+
 ## Model catalog
 
 The catalog is discovered dynamically. The plugin calls `GET {baseURL}/models` with your resolved API key, caches the response on disk, and injects only the models that key can see. The refresh ladder is:
@@ -39,7 +41,7 @@ The catalog is discovered dynamically. The plugin calls `GET {baseURL}/models` w
 3. If the live fetch fails, return the stale cache.
 4. If there is no cache and no live response, preserve existing generated entries and inject no replacement models.
 
-The plugin does not embed or serve a static catalog. Catalog cache envelopes are versioned; cache files from older plugin versions are ignored after an upgrade and repopulated from the gateway.
+The plugin does not embed or serve a static catalog. The on-disk cache is keyed by gateway URL **and** API key, so the same key pointed at a different gateway (`ROUTE33_BASE_URL`, e.g. a local cluster) never shares a cache with production. Catalog cache envelopes are versioned; cache files from older plugin versions are ignored after an upgrade and repopulated from the gateway.
 
 If discovery yields no catalog, the plugin logs exactly one warning:
 
@@ -64,7 +66,7 @@ The normative broadcast contract is [docs/gateway-limits-variants-broadcast.md](
 
 ## Managed model entries
 
-Gateway-discovered `provider.route_33.models` entries are managed and regenerated at startup. On the first 0.4.2 run, existing route_33 model entries are adopted as generated; entries no longer served by the gateway are pruned and a manifest is saved at `.opencode/route33-generated.json`. Later runs only remove keys listed in that manifest, then replace them with the current broadcast.
+Gateway-discovered `provider.route_33.models` entries are fully managed: every startup rebuilds the map from the current broadcast, then deep-merges your overrides on top. The ownership rule is the whole design — *in the broadcast (or in your overrides) ⇒ kept; anything else ⇒ dropped and logged* — so retired gateway models disappear automatically and no bookkeeping file is needed. (Versions ≤0.4.3 kept a `.opencode/route33-generated.json` ledger for this; the plugin deletes that obsolete file on first run.)
 
 Keep customizations in `.opencode/route33-overrides.json`, because the installed OpenCode `ProviderConfig` does not allow unknown provider-level keys such as `modelOverrides`. Overrides deep-merge onto matching generated entries and can add custom models:
 
@@ -77,7 +79,7 @@ Keep customizations in `.opencode/route33-overrides.json`, because the installed
 }
 ```
 
-If the gateway fetch fails with no usable cache, regeneration is skipped: existing entries are never pruned. Sidecar I/O failures also preserve the previous add-only behavior for that run.
+If the gateway fetch fails with no usable cache, regeneration is skipped entirely: existing entries are never pruned on zero information.
 
 `ROUTE33_ENRICH_CAPS` has been removed; capability backfill from `models.dev` is now always on.
 

package/dist/index.js

@@ -289,16 +289,12 @@ function buildOpenAiChatCompatFetch(fetchImpl) {
 }
 
 // src/config/build-options.ts
-function buildOptions(baseURL, apiKey, resolveKeyNow = () => void 0) {
+function buildOptions(baseURL, resolveKeyNow = () => void 0) {
   const options = { baseURL };
   options.fetch = buildLiveAuthFetch(
     resolveKeyNow,
     buildOpenAiChatCompatFetch()
   );
-  if (apiKey !== void 0) {
-    options.apiKey = apiKey;
-    options.headers = { Authorization: `Bearer ${apiKey}` };
-  }
   return options;
 }
 
@@ -350,7 +346,7 @@ function vendorOf(slug) {
   return slug.slice(0, slug.indexOf("/"));
 }
 function buildProviderBlocks(enriched, options) {
-  const { apiKey, baseURL } = options;
+  const { baseURL } = options;
   const resolveKeyNow = options.resolveKeyNow ?? (() => void 0);
   const route33Models = {};
   for (const slug of Object.keys(enriched).sort()) {
@@ -369,7 +365,7 @@ function buildProviderBlocks(enriched, options) {
     route_33: {
       npm: "@ai-sdk/openai-compatible",
       name: PROVIDER_DISPLAY_NAME,
-      options: buildOptions(baseURL, apiKey, resolveKeyNow),
+      options: buildOptions(baseURL, resolveKeyNow),
       models: route33Models
     }
   };
@@ -380,8 +376,9 @@ var memory = /* @__PURE__ */ new Map();
 
 // src/catalog/catalog-cache/hash-key.ts
 import { createHash } from "crypto";
-function hashKey(key) {
-  return createHash("sha256").update(key).digest("hex").slice(0, 12);
+function hashKey(baseURL, key) {
+  return createHash("sha256").update(`${baseURL}
+${key}`).digest("hex").slice(0, 12);
 }
 
 // src/catalog/catalog-cache/read-disk.ts
@@ -426,8 +423,8 @@ function isFresh(record, now, ttl) {
   return now - record.fetchedAt <= ttl;
 }
 function readFreshCatalog(opts) {
-  const { key, env = process.env, now = Date.now() } = opts;
-  const keyHash = hashKey(key);
+  const { baseURL, key, env = process.env, now = Date.now() } = opts;
+  const keyHash = hashKey(baseURL, key);
   const ttl = catalogTtlMs(env);
   const inMemory = memory.get(keyHash);
   if (inMemory && isFresh(inMemory, now, ttl)) return inMemory.models;
@@ -441,16 +438,16 @@ function readFreshCatalog(opts) {
 
 // src/catalog/catalog-cache/read-stale-catalog.ts
 function readStaleCatalog(opts) {
-  const { key, env = process.env } = opts;
-  const keyHash = hashKey(key);
+  const { baseURL, key, env = process.env } = opts;
+  const keyHash = hashKey(baseURL, key);
   return (memory.get(keyHash) ?? readDisk(keyHash, env))?.models;
 }
 
 // src/catalog/catalog-cache/write-catalog.ts
 import * as fs4 from "fs";
 function writeCatalog(opts) {
-  const { key, models, env = process.env, now = Date.now() } = opts;
-  const keyHash = hashKey(key);
+  const { baseURL, key, models, env = process.env, now = Date.now() } = opts;
+  const keyHash = hashKey(baseURL, key);
   const record = { fetchedAt: now, keyHash, models };
   memory.set(keyHash, record);
   try {
@@ -700,7 +697,7 @@ async function runLadder(opts) {
   if (env[ENV_DISCOVERY] === "0")
     return noneResult(`discovery disabled via ${ENV_DISCOVERY}=0`, true);
   if (!key) return noneResult("no API key resolved", false);
-  const fresh = readFreshCatalog({ key, env, now });
+  const fresh = readFreshCatalog({ baseURL, key, env, now });
   if (fresh) {
     logger.info(
       `catalog source: cache (${Object.keys(fresh).length} model(s))`
@@ -711,7 +708,7 @@ async function runLadder(opts) {
     const live = await fetchCatalog({ baseURL, key, env, fetchImpl });
     if (Object.keys(live).length === 0)
       throw new Error("gateway returned an empty catalog");
-    writeCatalog({ key, models: live, env, now });
+    writeCatalog({ baseURL, key, models: live, env, now });
     logger.info(`catalog source: live (${Object.keys(live).length} model(s))`);
     return { models: live, source: "live" };
   } catch (error) {
@@ -719,7 +716,7 @@ async function runLadder(opts) {
       `live catalog fetch failed \u2014 trying stale cache: ${error instanceof Error ? error.message : String(error)}`
     );
   }
-  const stale = readStaleCatalog({ key, env });
+  const stale = readStaleCatalog({ baseURL, key, env });
   if (stale) {
     logger.info(
       `catalog source: stale-cache (${Object.keys(stale).length} model(s))`
@@ -1065,102 +1062,36 @@ function mergeConfig(cfg, blocks) {
   }
 }
 
-// src/config/merge-models.ts
-function cloneEntry(entry) {
-  return { ...entry };
-}
-function cloneModels(patch) {
-  const models = {};
-  for (const [key, entry] of Object.entries(patch.models)) {
-    models[key] = cloneEntry(entry);
-  }
-  return models;
-}
-function fillModelEntry(existing, patchEntry) {
-  for (const [field, value] of Object.entries(patchEntry)) {
-    if (value === void 0) continue;
-    if (field === "limit" || existing[field] === void 0)
-      existing[field] = value;
-  }
-}
-function mergeModels(target, patch) {
-  if (target.models === void 0) {
-    target.models = cloneModels(patch);
-    return;
-  }
-  const models = target.models;
-  for (const [key, patchEntry] of Object.entries(patch.models)) {
-    const existing = models[key];
-    if (existing === void 0) {
-      models[key] = cloneEntry(patchEntry);
-    } else {
-      fillModelEntry(existing, cloneEntry(patchEntry));
-    }
-  }
-}
-
-// src/config/generation-manifest.ts
+// src/config/read-model-overrides.ts
 import * as fs6 from "fs";
 import * as path7 from "path";
 var SIDECAR_DIR = ".opencode";
-var MANIFEST_FILE = "route33-generated.json";
 var OVERRIDES_FILE = "route33-overrides.json";
 function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function generatedPath(root) {
-  return path7.join(root, SIDECAR_DIR, MANIFEST_FILE);
-}
-function overridesPath(root) {
-  return path7.join(root, SIDECAR_DIR, OVERRIDES_FILE);
-}
-function parseManifest(value) {
-  if (!isRecord7(value) || value.version !== 1 || !Array.isArray(value.generatedKeys) || typeof value.lastBroadcastHash !== "string") return void 0;
-  if (!value.generatedKeys.every((key) => typeof key === "string")) return void 0;
-  return { version: 1, generatedKeys: value.generatedKeys, lastBroadcastHash: value.lastBroadcastHash };
-}
 function parseOverrides(value) {
   if (!isRecord7(value) || !isRecord7(value.models) || !Object.values(value.models).every(isRecord7)) return void 0;
   const models = {};
   for (const [key, entry] of Object.entries(value.models)) if (isRecord7(entry)) models[key] = entry;
   return models;
 }
-function readJson(file) {
-  try {
-    if (!fs6.existsSync(file)) return void 0;
-    const parsed = JSON.parse(fs6.readFileSync(file, "utf8"));
-    return parsed;
-  } catch (error) {
-    logger.info(`route_33: unable to read generated-model sidecar: ${error instanceof Error ? error.message : String(error)}`);
-    return void 0;
-  }
-}
-function readGenerationManifest(root) {
-  const file = generatedPath(root);
-  const manifest = parseManifest(readJson(file));
-  if (manifest === void 0 && fs6.existsSync(file)) logger.info("route_33: generated-model manifest is malformed; treating this run as first-run regeneration");
-  return manifest;
-}
 function readModelOverrides(root) {
-  const file = overridesPath(root);
-  const overrides = parseOverrides(readJson(file));
-  if (overrides === void 0 && fs6.existsSync(file)) logger.info("route_33: model overrides sidecar is malformed; ignoring it for this run");
-  return overrides ?? {};
-}
-function writeGenerationManifest(root, manifest) {
+  const file = path7.join(root, SIDECAR_DIR, OVERRIDES_FILE);
+  let parsed;
   try {
-    fs6.mkdirSync(path7.join(root, SIDECAR_DIR), { recursive: true });
-    fs6.writeFileSync(generatedPath(root), `${JSON.stringify(manifest, null, 2)}
-`);
-    return true;
+    if (!fs6.existsSync(file)) return {};
+    parsed = JSON.parse(fs6.readFileSync(file, "utf8"));
   } catch (error) {
-    logger.info(`route_33: unable to write generated-model manifest; using add-only behavior this run: ${error instanceof Error ? error.message : String(error)}`);
-    return false;
+    logger.info(`route_33: unable to read model overrides sidecar: ${error instanceof Error ? error.message : String(error)}`);
+    return {};
   }
+  const overrides = parseOverrides(parsed);
+  if (overrides === void 0) logger.info("route_33: model overrides sidecar is malformed; ignoring it for this run");
+  return overrides ?? {};
 }
 
 // src/config/regenerate-models.ts
-import { createHash as createHash2 } from "crypto";
 function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -1169,49 +1100,46 @@ function clone(value) {
   if (!isRecord8(value)) return value;
   return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, clone(item)]));
 }
-function cloneEntry2(entry) {
+function cloneEntry(entry) {
   const copy = {};
   for (const [key, value] of Object.entries(entry)) copy[key] = clone(value);
   return copy;
 }
 function mergeEntry(base, override) {
-  const result = cloneEntry2(base);
+  const result = cloneEntry(base);
   for (const [key, value] of Object.entries(override)) {
     const existing = result[key];
     result[key] = isRecord8(existing) && isRecord8(value) ? mergeEntry(existing, value) : clone(value);
   }
   return result;
 }
-function stableJson(value) {
-  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
-  if (!isRecord8(value)) return JSON.stringify(value);
-  return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(",")}}`;
-}
-function broadcastHash(models) {
-  return createHash2("sha256").update(stableJson(models)).digest("hex");
-}
 function regenerateModels(input) {
   if (input.source === "none" && input.failedLiveFetch === true) {
     const models2 = {};
     for (const [key, entry] of Object.entries(input.currentModels ?? {}))
-      if (entry !== void 0) models2[key] = cloneEntry2(entry);
+      if (entry !== void 0) models2[key] = cloneEntry(entry);
     return { models: models2, prunedKeys: [], skipped: true };
   }
-  const current = input.currentModels ?? {};
-  const generatedKeys = input.previousManifest?.generatedKeys ?? Object.keys(current);
   const models = {};
-  for (const [key, entry] of Object.entries(current)) {
-    if (!generatedKeys.includes(key) && entry !== void 0) models[key] = cloneEntry2(entry);
-  }
-  for (const [key, entry] of Object.entries(input.freshModels)) models[key] = cloneEntry2(entry);
+  for (const [key, entry] of Object.entries(input.freshModels)) models[key] = cloneEntry(entry);
   for (const [key, override] of Object.entries(input.overrides ?? {}))
     models[key] = mergeEntry(models[key] ?? {}, override);
-  const freshKeys = Object.keys(input.freshModels).sort();
-  return {
-    models,
-    manifest: { version: 1, generatedKeys: freshKeys, lastBroadcastHash: broadcastHash(input.freshModels) },
-    prunedKeys: generatedKeys.filter((key) => input.freshModels[key] === void 0).sort()
-  };
+  const prunedKeys = Object.keys(input.currentModels ?? {}).filter((key) => input.freshModels[key] === void 0 && input.overrides?.[key] === void 0).sort();
+  return { models, prunedKeys };
+}
+
+// src/config/remove-legacy-manifest.ts
+import * as fs7 from "fs";
+import * as path8 from "path";
+function removeLegacyManifest(root) {
+  const file = path8.join(root, ".opencode", "route33-generated.json");
+  try {
+    if (!fs7.existsSync(file)) return;
+    fs7.rmSync(file);
+    logger.info("route_33: removed obsolete route33-generated.json (regeneration is stateless since 0.4.4)");
+  } catch (error) {
+    logger.info(`route_33: unable to remove legacy route33-generated.json: ${error instanceof Error ? error.message : String(error)}`);
+  }
 }
 
 // src/config/collected-ref.ts
@@ -1441,6 +1369,7 @@ function createConfigHook(options = {}) {
     let key;
     let catalogAvailable = false;
     try {
+      removeLegacyManifest(cwd);
       key = resolveKey(cfg, env, cwd);
       const baseURL = resolveBaseUrl(cfg, env, cwd);
       const catalog = await getCatalog({
@@ -1457,11 +1386,10 @@ function createConfigHook(options = {}) {
       const modelsDev = await loadModelsDev(modelsDevOptions);
       const enriched = enrichCatalog(catalog, modelsDev, env);
       const blocks = buildProviderBlocks(enriched, {
-        apiKey: key,
         baseURL,
         // Per-request resolution for the live-auth fetch: a prompt-entered
-        // key applies to the very next request, no restart. The static
-        // apiKey above stays the boot-time/catalog path.
+        // key applies to the very next request, no restart. The block never
+        // carries the key itself, so config dumps stay credential-free.
         resolveKeyNow: () => resolveKey(void 0, env, cwd)
       });
       mergeConfig(cfg, blocks);
@@ -1471,21 +1399,16 @@ function createConfigHook(options = {}) {
         const regeneration = regenerateModels({
           currentModels: provider.models,
           freshModels: blocks.route_33.models,
-          previousManifest: readGenerationManifest(cwd),
           overrides: readModelOverrides(cwd),
           source: catalog.source,
           failedLiveFetch: catalog.liveFetchFailed
         });
         if (regeneration.skipped) {
-          logger.info("route_33: catalog fetch failed without a cache; preserving existing managed model entries");
+          logger.info("route_33: catalog fetch failed without a cache; preserving existing model entries");
         } else {
-          if (regeneration.manifest !== void 0 && !writeGenerationManifest(cwd, regeneration.manifest)) {
-            mergeModels(provider, blocks.route_33);
-          } else {
-            provider.models = regeneration.models;
-          }
-          for (const key2 of regeneration.prunedKeys)
-            logger.info(`route_33: removed stale model entry '${key2}' (no longer in the gateway catalog); move custom entries to route_33 modelOverrides \u2014 see README`);
+          provider.models = regeneration.models;
+          for (const dropped of regeneration.prunedKeys)
+            logger.info(`route_33: dropped model entry '${dropped}' (not in the gateway catalog); custom models belong in .opencode/route33-overrides.json \u2014 see README`);
         }
       }
     } catch (error) {

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@route_33/opencode",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "type": "module",
   "license": "SEE LICENSE IN LICENSE",
-  "description": "opencode provider plugin for the route33.ai AI gateway — key-scoped model discovery, cost/limit enrichment, auth, and the key-setup wizard.",
+  "description": "opencode provider plugin for the route33.ai AI gateway \u2014 key-scoped model discovery, cost/limit enrichment, auth, and the key-setup wizard.",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Cronos-AI-Lab/harness-bench.git",