@route_33/opencode 0.4.3 → 0.4.5

package/README.md

@@ -24,13 +24,13 @@ 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.
+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. One inert exception: the options carry the non-secret marker `__route33_fetch_shim_auth__` as `apiKey`, because the native per-model SDKs used for `anthropic/`, `openai/`, and `mistralai/` models (`@ai-sdk/anthropic`, `@ai-sdk/openai`, `@ai-sdk/mistral`) refuse to construct a request without one — the marker satisfies that null check, never authenticates anything (the gateway reads only the request-time `Authorization` header, which the fetch shim injects), and no vendor env var (`ANTHROPIC_API_KEY` etc.) is needed or consulted. The marker is skipped by key resolution and never overrides an `apiKey` you authored yourself; it is visible in config dumps precisely because it is not a secret.
 
 ## Model catalog
 
@@ -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

@@ -94,6 +94,9 @@ var logger = {
 // src/shared/models-dev-ttl-ms.ts
 var MODELS_DEV_TTL_MS = 864e5;
 
+// src/shared/native-sdk-api-key-placeholder.ts
+var NATIVE_SDK_API_KEY_PLACEHOLDER = "__route33_fetch_shim_auth__";
+
 // src/shared/resolve-cache-dir.ts
 import * as os2 from "os";
 import * as path3 from "path";
@@ -217,9 +220,10 @@ function usable4(value) {
 }
 function keyFromConfig(cfg) {
   const literal = usable4(cfg?.provider?.route_33?.options?.apiKey);
-  if (literal !== void 0 && !literal.includes(UNRESOLVED_TEMPLATE_MARKER2))
-    return literal;
-  return void 0;
+  if (literal === void 0) return void 0;
+  if (literal.includes(UNRESOLVED_TEMPLATE_MARKER2)) return void 0;
+  if (literal === NATIVE_SDK_API_KEY_PLACEHOLDER) return void 0;
+  return literal;
 }
 function resolveKey(cfg, env = process.env, worktree) {
   return usable4(env[ENV_API_KEY]) ?? keyFromConfig(cfg) ?? readWorkspaceKey(worktree) ?? (worktree !== void 0 && isInsideGitWorktree(worktree) ? void 0 : readAuthEntry(env).key);
@@ -290,7 +294,10 @@ function buildOpenAiChatCompatFetch(fetchImpl) {
 
 // src/config/build-options.ts
 function buildOptions(baseURL, resolveKeyNow = () => void 0) {
-  const options = { baseURL };
+  const options = {
+    baseURL,
+    apiKey: NATIVE_SDK_API_KEY_PLACEHOLDER
+  };
   options.fetch = buildLiveAuthFetch(
     resolveKeyNow,
     buildOpenAiChatCompatFetch()
@@ -376,8 +383,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 +430,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 +445,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 {
@@ -622,6 +630,7 @@ function toCatalogModels(entries, env) {
     if (capabilities !== void 0) model.capabilities = capabilities;
     const variants = parseVariants(entry.variants);
     if (variants !== void 0) model.variants = variants;
+    if (typeof entry.hasZdrLane === "boolean") model.hasZdrLane = entry.hasZdrLane;
     const modalities = parseModalities(entry.modalities);
     if (modalities !== void 0) model.modalities = modalities;
     if (typeof entry.attachment === "boolean") model.attachment = entry.attachment;
@@ -696,7 +705,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 +716,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 +724,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))`
@@ -1035,6 +1044,11 @@ var FORCED_OPTION_FIELDS = /* @__PURE__ */ new Set([
   "baseURL",
   "headers"
 ]);
+function isForcedValue(field, value) {
+  if (field === "apiKey" && value === NATIVE_SDK_API_KEY_PLACEHOLDER)
+    return false;
+  return FORCED_OPTION_FIELDS.has(field);
+}
 function mergeProvider(target, patch) {
   if (target.npm === void 0) target.npm = patch.npm;
   if (target.name === void 0) target.name = patch.name;
@@ -1044,7 +1058,7 @@ function mergeProvider(target, patch) {
     const options = target.options;
     for (const [field, value] of Object.entries(patch.options)) {
       if (value === void 0) continue;
-      if (FORCED_OPTION_FIELDS.has(field) || options[field] === void 0)
+      if (isForcedValue(field, value) || options[field] === void 0)
         options[field] = value;
     }
   }
@@ -1061,102 +1075,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 +1113,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 +1382,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 +1412,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/dist/tui/index.js

@@ -31,6 +31,9 @@ var logger = {
   }
 };
 
+// src/shared/native-sdk-api-key-placeholder.ts
+var NATIVE_SDK_API_KEY_PLACEHOLDER = "__route33_fetch_shim_auth__";
+
 // src/shared/resolve-cache-dir.ts
 import * as os from "os";
 import * as path2 from "path";
@@ -142,9 +145,10 @@ function usable3(value) {
 }
 function keyFromConfig(cfg) {
   const literal = usable3(cfg?.provider?.route_33?.options?.apiKey);
-  if (literal !== void 0 && !literal.includes(UNRESOLVED_TEMPLATE_MARKER))
-    return literal;
-  return void 0;
+  if (literal === void 0) return void 0;
+  if (literal.includes(UNRESOLVED_TEMPLATE_MARKER)) return void 0;
+  if (literal === NATIVE_SDK_API_KEY_PLACEHOLDER) return void 0;
+  return literal;
 }
 function resolveKey(cfg, env = process.env, worktree) {
   return usable3(env[ENV_API_KEY]) ?? keyFromConfig(cfg) ?? readWorkspaceKey(worktree) ?? (worktree !== void 0 && isInsideGitWorktree(worktree) ? void 0 : readAuthEntry(env).key);

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@route_33/opencode",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "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",