@route_33/opencode 0.4.3 → 0.4.4

package/README.md

@@ -24,7 +24,7 @@ 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
 
@@ -41,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:
 
@@ -66,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:
 
@@ -79,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

@@ -376,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
@@ -422,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;
@@ -437,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 {
@@ -696,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))`
@@ -707,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) {
@@ -715,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))`
@@ -1061,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);
 }
@@ -1165,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
@@ -1437,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({
@@ -1466,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.3",
+  "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",