@route_33/opencode 0.1.2

package/dist/index.js

@@ -0,0 +1,1786 @@
+// src/auth/auth-json.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+var PROVIDER_ID = "route_33";
+function usable(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed ? trimmed : void 0;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readAuthEntry(env = process.env) {
+  try {
+    const dataHome = usable(env.XDG_DATA_HOME) ?? path.join(os.homedir(), ".local", "share");
+    const authPath = path.join(dataHome, "opencode", "auth.json");
+    const parsed = JSON.parse(fs.readFileSync(authPath, "utf8"));
+    if (!isRecord(parsed)) return {};
+    const entry = parsed[PROVIDER_ID];
+    if (!isRecord(entry) || entry.type !== "api") return {};
+    const result = {};
+    const key = usable(entry.key);
+    if (key !== void 0) result.key = key;
+    const baseURL = isRecord(entry.metadata) ? usable(entry.metadata.baseURL) : void 0;
+    if (baseURL !== void 0) result.baseURL = baseURL;
+    return result;
+  } catch {
+    return {};
+  }
+}
+
+// src/auth/workspace-key-file.ts
+import * as fs2 from "fs";
+import * as path3 from "path";
+
+// src/shared/default-base-url.ts
+var DEFAULT_BASE_URL = "https://api.route33.ai/v1";
+
+// src/shared/default-catalog-ttl-ms.ts
+var DEFAULT_CATALOG_TTL_MS = 36e5;
+
+// src/shared/env-api-key.ts
+var ENV_API_KEY = "ROUTE33_API_KEY";
+
+// src/shared/env-base-url.ts
+var ENV_BASE_URL = "ROUTE33_BASE_URL";
+
+// src/shared/env-cache-dir.ts
+var ENV_CACHE_DIR = "ROUTE33_CACHE_DIR";
+
+// src/shared/env-catalog-ttl-ms.ts
+var ENV_CATALOG_TTL_MS = "ROUTE33_CATALOG_TTL_MS";
+
+// src/shared/env-disable-id-shim.ts
+var ENV_DISABLE_ID_SHIM = "ROUTE33_DISABLE_ID_SHIM";
+
+// src/shared/env-discovery.ts
+var ENV_DISCOVERY = "ROUTE33_DISCOVERY";
+
+// src/shared/env-enrich-caps.ts
+var ENV_ENRICH_CAPS = "ROUTE33_ENRICH_CAPS";
+
+// src/shared/env-strict.ts
+var ENV_STRICT = "ROUTE33_STRICT";
+
+// src/shared/logger.ts
+var logger = {
+  info: (...args) => {
+    console.log("[route_33]", ...args);
+  },
+  warn: (...args) => {
+    console.warn("[route_33]", ...args);
+  },
+  error: (...args) => {
+    console.error("[route_33]", ...args);
+  }
+};
+
+// src/shared/models-dev-ttl-ms.ts
+var MODELS_DEV_TTL_MS = 864e5;
+
+// src/shared/resolve-cache-dir.ts
+import * as os2 from "os";
+import * as path2 from "path";
+function resolveCacheDir(env = process.env) {
+  const override = env[ENV_CACHE_DIR];
+  if (override) return override;
+  const xdgCacheHome = env.XDG_CACHE_HOME;
+  const base = xdgCacheHome ?? path2.join(os2.homedir(), ".cache");
+  return path2.join(base, "opencode-route33");
+}
+
+// src/auth/workspace-key-file.ts
+var WORKSPACE_KEY_RELATIVE_PATH = path3.join(".opencode", "route33.key");
+var WORKSPACE_GITIGNORE_RELATIVE_PATH = path3.join(".opencode", ".gitignore");
+var GITIGNORE_ENTRIES = ["route33.key", "tui.json"];
+function usable2(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed ? trimmed : void 0;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readWorkspaceKey(worktree) {
+  if (worktree === void 0) return void 0;
+  try {
+    const raw = fs2.readFileSync(
+      path3.join(worktree, WORKSPACE_KEY_RELATIVE_PATH),
+      "utf8"
+    );
+    const parsed = JSON.parse(raw);
+    if (!isRecord2(parsed) || parsed.type !== "api") return void 0;
+    return usable2(parsed.key);
+  } catch {
+    return void 0;
+  }
+}
+function ensureWorkspaceKeyGitignore(worktree) {
+  if (worktree === void 0 || worktree.trim() === "") return;
+  if (path3.resolve(worktree) === "/") return;
+  const gitignorePath = path3.join(worktree, WORKSPACE_GITIGNORE_RELATIVE_PATH);
+  try {
+    fs2.mkdirSync(path3.dirname(gitignorePath), { recursive: true });
+    let content = "";
+    try {
+      content = fs2.readFileSync(gitignorePath, "utf8");
+    } catch {
+    }
+    const lines = content.split("\n");
+    const missing = GITIGNORE_ENTRIES.filter(
+      (entry) => !lines.some(
+        (line) => line.trim() === entry || line.trim() === `/${entry}`
+      )
+    );
+    if (missing.length === 0) return;
+    const prefix = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
+    fs2.writeFileSync(gitignorePath, `${content}${prefix}${missing.join("\n")}
+`);
+  } catch (error) {
+    logger.warn(
+      `opencode-route33: could not update ${gitignorePath} (${String(error)}) \u2014 verify route33.key and tui.json are git-ignored before committing`
+    );
+  }
+}
+
+// src/auth/resolve-base-url.ts
+var UNRESOLVED_TEMPLATE_MARKER = "{env:";
+function usable3(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function urlFromConfig(cfg) {
+  const literal = usable3(cfg?.provider?.route_33?.options?.baseURL);
+  if (literal !== void 0 && !literal.includes(UNRESOLVED_TEMPLATE_MARKER))
+    return literal;
+  return void 0;
+}
+function resolveBaseUrl(cfg, env = process.env) {
+  return usable3(env[ENV_BASE_URL]) ?? urlFromConfig(cfg) ?? readAuthEntry(env).baseURL ?? DEFAULT_BASE_URL;
+}
+
+// src/auth/api-key-method.ts
+function buildApiKeyMethod() {
+  return {
+    type: "api",
+    label: "route33.ai API key (sk-r33-\u2026)",
+    prompts: [
+      {
+        type: "text",
+        key: "key",
+        message: "route33.ai API key",
+        placeholder: "sk-r33-\u2026",
+        validate: (value) => value.trim() === "" ? "API key is required" : void 0
+      },
+      {
+        type: "text",
+        key: "baseURL",
+        message: "Gateway URL (Enter for default)",
+        placeholder: DEFAULT_BASE_URL
+      }
+    ],
+    authorize: async (inputs) => {
+      const key = inputs?.key?.trim();
+      if (!key) return { type: "failed" };
+      const url = inputs?.baseURL?.trim();
+      const result = {
+        type: "success",
+        key
+      };
+      if (url && url !== DEFAULT_BASE_URL) result.metadata = { baseURL: url };
+      return result;
+    }
+  };
+}
+
+// src/auth/resolve-key.ts
+var UNRESOLVED_TEMPLATE_MARKER2 = "{env:";
+function usable4(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+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;
+}
+function resolveKey(cfg, env = process.env, worktree) {
+  return usable4(env[ENV_API_KEY]) ?? keyFromConfig(cfg) ?? readWorkspaceKey(worktree) ?? readAuthEntry(env).key;
+}
+
+// src/auth/route33-auth.ts
+var ROUTE33_PROVIDER_ID = "route_33";
+function buildRoute33Auth(env = process.env, worktree) {
+  return {
+    provider: ROUTE33_PROVIDER_ID,
+    methods: [buildApiKeyMethod()],
+    loader: async (_auth, _provider) => {
+      try {
+        const key = resolveKey(void 0, env, worktree);
+        return key ? { apiKey: key, headers: { Authorization: `Bearer ${key}` } } : {};
+      } catch {
+        return {};
+      }
+    }
+  };
+}
+
+// src/bootstrap/ensure-tui-registration.ts
+import * as path7 from "path";
+
+// src/bootstrap/global-context.ts
+import * as os3 from "os";
+import * as path4 from "path";
+import { fileURLToPath } from "url";
+function isGlobalContext(worktree, moduleUrl) {
+  try {
+    if (moduleUrl === void 0) return false;
+    if (worktree === void 0) return true;
+    const root = path4.resolve(worktree);
+    if (root === "/") return true;
+    const modulePath = fileURLToPath(moduleUrl);
+    return !modulePath.startsWith(root + path4.sep);
+  } catch {
+    return false;
+  }
+}
+function usable5(value) {
+  const trimmed = value?.trim();
+  return trimmed === void 0 || trimmed === "" ? void 0 : trimmed;
+}
+function globalTuiJsonPath(env) {
+  const configHome = usable5(env.XDG_CONFIG_HOME) ?? path4.join(os3.homedir(), ".config");
+  return path4.join(configHome, "opencode", "tui.json");
+}
+
+// src/bootstrap/tui-json-upsert.ts
+import * as fs4 from "fs";
+import * as path6 from "path";
+import {
+  applyEdits,
+  modify,
+  parse as parseJsonc
+} from "jsonc-parser";
+
+// src/bootstrap/tui-spec-resolution.ts
+import * as fs3 from "fs";
+import * as os4 from "os";
+import * as path5 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var NPM_TUI_SPEC = "@route_33/opencode/tui";
+var OLD_NPM_TUI_SPEC = "opencode-route33/tui";
+var TUI_BUNDLE_NAME = "route33-tui.js";
+var TUI_SCHEMA = "https://opencode.ai/tui.json";
+var SERVER_BUNDLE_NAME = "route33.js";
+var DIST_TUI_ENTRY_SUFFIX = "/opencode-route33/dist/tui/index.js";
+var SCOPED_DIST_TUI_ENTRY_SUFFIX = "/@route_33/opencode/dist/tui/index.js";
+function fileExists(candidate) {
+  try {
+    return fs3.statSync(candidate).isFile();
+  } catch {
+    return false;
+  }
+}
+function specFromModuleUrl(moduleUrl) {
+  try {
+    if (moduleUrl === void 0) return void 0;
+    const selfPath = fileURLToPath2(moduleUrl);
+    const dir = path5.dirname(selfPath);
+    if (path5.basename(selfPath) === SERVER_BUNDLE_NAME) {
+      const sibling = path5.join(dir, TUI_BUNDLE_NAME);
+      return fileExists(sibling) ? sibling : void 0;
+    }
+    if (path5.basename(selfPath) === "index.js" && path5.basename(dir) === "dist") {
+      const tuiEntry = path5.join(dir, "tui", "index.js");
+      return fileExists(tuiEntry) ? tuiEntry : void 0;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function resolveTuiSpec(worktree, env, moduleUrl) {
+  const fromModule = specFromModuleUrl(moduleUrl);
+  if (fromModule !== void 0) return fromModule;
+  if (worktree !== void 0 && worktree.trim() !== "" && path5.resolve(worktree) !== "/") {
+    const local = path5.join(worktree, ".opencode", "plugins", TUI_BUNDLE_NAME);
+    if (fileExists(local)) return local;
+  }
+  const configHome = env.XDG_CONFIG_HOME?.trim() || path5.join(os4.homedir(), ".config");
+  const global = path5.join(configHome, "opencode", "plugins", TUI_BUNDLE_NAME);
+  if (fileExists(global)) return global;
+  return NPM_TUI_SPEC;
+}
+function isOurEntry(entry) {
+  return typeof entry === "string" && (entry === NPM_TUI_SPEC || entry === OLD_NPM_TUI_SPEC || entry.endsWith(`/${TUI_BUNDLE_NAME}`) || entry.endsWith(DIST_TUI_ENTRY_SUFFIX) || entry.endsWith(SCOPED_DIST_TUI_ENTRY_SUFFIX));
+}
+
+// src/bootstrap/tui-json-upsert.ts
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function fileExists2(candidate) {
+  try {
+    return fs4.statSync(candidate).isFile();
+  } catch {
+    return false;
+  }
+}
+function upsertTuiSpec(file, spec) {
+  try {
+    if (!fileExists2(file)) {
+      fs4.mkdirSync(path6.dirname(file), { recursive: true });
+      fs4.writeFileSync(
+        file,
+        JSON.stringify({ $schema: TUI_SCHEMA, plugin: [spec] }, null, 2) + "\n",
+        "utf8"
+      );
+      return;
+    }
+    const text = fs4.readFileSync(file, "utf8");
+    const errors = [];
+    const parsed = parseJsonc(text, errors, {
+      allowTrailingComma: true,
+      allowEmptyContent: true
+    });
+    if (!isRecord3(parsed)) {
+      logger.warn(
+        `tui.json at ${file} did not parse to an object \u2014 skipping TUI registration`
+      );
+      return;
+    }
+    if (parsed.plugin !== void 0 && !Array.isArray(parsed.plugin)) {
+      logger.warn(
+        `tui.json at ${file} has a non-array "plugin" key \u2014 skipping TUI registration`
+      );
+      return;
+    }
+    const entries = Array.isArray(parsed.plugin) ? parsed.plugin : [];
+    const ourIndices = entries.flatMap(
+      (entry, index) => isOurEntry(entry) ? [index] : []
+    );
+    const firstOurs = ourIndices[0];
+    if (ourIndices.length === 1 && firstOurs !== void 0 && entries[firstOurs] === spec)
+      return;
+    const formattingOptions = { insertSpaces: true, tabSize: 2 };
+    let next = text;
+    if (!Array.isArray(parsed.plugin)) {
+      next = applyEdits(
+        next,
+        modify(next, ["plugin"], [spec], { formattingOptions })
+      );
+    } else if (firstOurs === void 0) {
+      next = applyEdits(
+        next,
+        modify(next, ["plugin", -1], spec, {
+          formattingOptions,
+          isArrayInsertion: true
+        })
+      );
+    } else {
+      if (entries[firstOurs] !== spec) {
+        next = applyEdits(
+          next,
+          modify(next, ["plugin", firstOurs], spec, { formattingOptions })
+        );
+      }
+      for (const index of ourIndices.slice(1).sort((a, b) => b - a)) {
+        next = applyEdits(
+          next,
+          modify(next, ["plugin", index], void 0, { formattingOptions })
+        );
+      }
+    }
+    if (next !== text) fs4.writeFileSync(file, next, "utf8");
+  } catch (error) {
+    logger.warn(
+      `could not register the route33 TUI plugin in tui.json: ${String(error)}`
+    );
+  }
+}
+
+// src/bootstrap/ensure-tui-registration.ts
+function ensureTuiRegistration(deps) {
+  try {
+    const { worktree, env } = deps;
+    if (env.ROUTE33_TUI_PROMPT === "0") return;
+    const usableWorktree = worktree !== void 0 && worktree.trim() !== "" && path7.resolve(worktree) !== "/" ? worktree : void 0;
+    const spec = resolveTuiSpec(usableWorktree, env, deps.moduleUrl);
+    if (usableWorktree !== void 0) {
+      upsertTuiSpec(path7.join(usableWorktree, ".opencode", "tui.json"), spec);
+    }
+    if (isGlobalContext(worktree, deps.moduleUrl)) {
+      upsertTuiSpec(globalTuiJsonPath(env), spec);
+    }
+  } catch (error) {
+    logger.warn(
+      `could not register the route33 TUI plugin in tui.json: ${String(error)}`
+    );
+  }
+}
+
+// src/config/live-auth-fetch.ts
+function buildLiveAuthFetch(resolveKeyNow, innerFetch) {
+  return (input, init) => {
+    const key = resolveKeyNow();
+    if (key === void 0) return innerFetch(input, init);
+    const headers = new Headers(init?.headers);
+    headers.set("Authorization", `Bearer ${key}`);
+    return innerFetch(input, { ...init, headers });
+  };
+}
+
+// src/config/openai-chat-compat-fetch.ts
+function rewriteOpenAiBody(body) {
+  try {
+    const parsed = JSON.parse(body);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+      return void 0;
+    const request = parsed;
+    const model = request["model"];
+    if (typeof model !== "string" || !model.startsWith("openai/"))
+      return void 0;
+    const tools = request["tools"];
+    const dropEffort = "reasoning_effort" in request && Array.isArray(tools) && tools.length > 0;
+    const renameMaxTokens = "max_tokens" in request;
+    if (!renameMaxTokens && !dropEffort) return void 0;
+    const rewritten = { ...request };
+    if (dropEffort) delete rewritten["reasoning_effort"];
+    if (renameMaxTokens) {
+      if (!("max_completion_tokens" in rewritten))
+        rewritten["max_completion_tokens"] = rewritten["max_tokens"];
+      delete rewritten["max_tokens"];
+    }
+    return JSON.stringify(rewritten);
+  } catch {
+    return void 0;
+  }
+}
+function buildOpenAiChatCompatFetch(fetchImpl) {
+  return (input, init) => {
+    const body = init?.body;
+    const rewritten = typeof body === "string" ? rewriteOpenAiBody(body) : void 0;
+    const finalInit = rewritten === void 0 ? init : { ...init, body: rewritten };
+    return (fetchImpl ?? globalThis.fetch)(input, finalInit);
+  };
+}
+
+// src/config/build-options.ts
+function buildOptions(baseURL, apiKey, 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;
+}
+
+// src/config/native-sdk-by-vendor.ts
+var NATIVE_SDK_BY_VENDOR = {
+  anthropic: "@ai-sdk/anthropic",
+  mistralai: "@ai-sdk/mistral",
+  openai: "@ai-sdk/openai"
+};
+
+// src/config/to-model-patch.ts
+function cloneCost(cost) {
+  const copy = { input: cost.input, output: cost.output };
+  if (cost.cache_read !== void 0) copy.cache_read = cost.cache_read;
+  if (cost.cache_write !== void 0) copy.cache_write = cost.cache_write;
+  if (cost.context_over_200k !== void 0)
+    copy.context_over_200k = { ...cost.context_over_200k };
+  return copy;
+}
+function cloneVariants(variants) {
+  return Object.fromEntries(
+    Object.entries(variants).map(([name, options]) => [name, { ...options }])
+  );
+}
+function toModelPatch(meta, routingSlug, forceReasoning, nativeNpm) {
+  const entry = { name: meta.name };
+  if (routingSlug !== void 0) entry.id = routingSlug;
+  if (nativeNpm !== void 0) entry.provider = { npm: nativeNpm };
+  const caps = meta.capabilities;
+  if (caps.attachment !== void 0) entry.attachment = caps.attachment;
+  if (caps.reasoning !== void 0) entry.reasoning = caps.reasoning;
+  if (forceReasoning) entry.reasoning = true;
+  if (caps.temperature !== void 0) entry.temperature = caps.temperature;
+  if (caps.tool_call !== void 0) entry.tool_call = caps.tool_call;
+  if (meta.cost !== void 0) entry.cost = cloneCost(meta.cost);
+  if (meta.limit !== void 0)
+    entry.limit = { context: meta.limit.context, output: meta.limit.output };
+  if (meta.variants !== void 0)
+    entry.variants = cloneVariants(meta.variants);
+  return entry;
+}
+
+// src/config/build-provider-blocks.ts
+var PROVIDER_DISPLAY_NAME = "route_33";
+function vendorOf(slug2) {
+  return slug2.slice(0, slug2.indexOf("/"));
+}
+function buildProviderBlocks(enriched, options) {
+  const { apiKey, baseURL, aliasTargets } = options;
+  const resolveKeyNow = options.resolveKeyNow ?? (() => void 0);
+  const route33Models = {};
+  for (const slug2 of Object.keys(enriched).sort()) {
+    const meta = enriched[slug2];
+    if (meta === void 0) continue;
+    const aliasTarget = aliasTargets?.[slug2];
+    const vendor = vendorOf(slug2);
+    const nativeNpm = NATIVE_SDK_BY_VENDOR[vendor];
+    route33Models[slug2] = toModelPatch(
+      meta,
+      aliasTarget,
+      vendor === "anthropic",
+      nativeNpm
+    );
+  }
+  return {
+    route_33: {
+      npm: "@ai-sdk/openai-compatible",
+      name: PROVIDER_DISPLAY_NAME,
+      options: buildOptions(baseURL, apiKey, resolveKeyNow),
+      models: route33Models
+    }
+  };
+}
+
+// src/catalog/catalog-cache/cache-state.ts
+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);
+}
+
+// src/catalog/catalog-cache/read-disk.ts
+import * as fs5 from "fs";
+
+// src/catalog/catalog-cache/cache-file-path.ts
+import * as path8 from "path";
+function cacheFilePath(keyHash, env) {
+  return path8.join(resolveCacheDir(env), `catalog-${keyHash}.json`);
+}
+
+// src/catalog/catalog-cache/read-disk.ts
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readDisk(keyHash, env) {
+  try {
+    const parsed = JSON.parse(
+      fs5.readFileSync(cacheFilePath(keyHash, env), "utf8")
+    );
+    if (!isRecord4(parsed) || typeof parsed.fetchedAt !== "number" || !isRecord4(parsed.models))
+      return void 0;
+    return {
+      fetchedAt: parsed.fetchedAt,
+      keyHash,
+      models: parsed.models
+    };
+  } catch {
+    return void 0;
+  }
+}
+
+// src/catalog/catalog-cache/read-fresh-catalog.ts
+function catalogTtlMs(env) {
+  const raw = Number(env[ENV_CATALOG_TTL_MS]);
+  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_CATALOG_TTL_MS;
+}
+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 ttl = catalogTtlMs(env);
+  const inMemory = memory.get(keyHash);
+  if (inMemory && isFresh(inMemory, now, ttl)) return inMemory.models;
+  const onDisk = readDisk(keyHash, env);
+  if (onDisk && isFresh(onDisk, now, ttl)) {
+    memory.set(keyHash, onDisk);
+    return onDisk.models;
+  }
+  return void 0;
+}
+
+// src/catalog/catalog-cache/read-stale-catalog.ts
+function readStaleCatalog(opts) {
+  const { key, env = process.env } = opts;
+  const keyHash = hashKey(key);
+  return (memory.get(keyHash) ?? readDisk(keyHash, env))?.models;
+}
+
+// src/catalog/catalog-cache/write-catalog.ts
+import * as fs6 from "fs";
+function writeCatalog(opts) {
+  const { key, models, env = process.env, now = Date.now() } = opts;
+  const keyHash = hashKey(key);
+  const record = { fetchedAt: now, keyHash, models };
+  memory.set(keyHash, record);
+  try {
+    fs6.mkdirSync(resolveCacheDir(env), { recursive: true });
+    fs6.writeFileSync(cacheFilePath(keyHash, env), JSON.stringify(record));
+  } catch (error) {
+    logger.warn(
+      `could not persist catalog cache: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+
+// src/catalog/catalog-fetch-error.ts
+var CatalogFetchError = class extends Error {
+  reason;
+  statusCode;
+  constructor(reason, message, statusCode) {
+    super(`catalog fetch failed (${reason}): ${message}`);
+    this.name = "CatalogFetchError";
+    this.reason = reason;
+    this.statusCode = statusCode;
+  }
+};
+
+// src/catalog/default-fetch-timeout-ms.ts
+var DEFAULT_FETCH_TIMEOUT_MS = 5e3;
+
+// src/catalog/extract-pricing.ts
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var OPENROUTER_KEYS = [
+  "prompt",
+  "completion",
+  "request",
+  "input_cache_read",
+  "input_cache_write"
+];
+var MODELS_DEV_KEYS = [
+  "input",
+  "output",
+  "cache_read",
+  "cache_write"
+];
+function perTokenRate(value) {
+  if (typeof value !== "string" || value.trim() === "") return void 0;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : void 0;
+}
+function toPer1M(perToken) {
+  return Number((perToken * 1e6).toPrecision(12));
+}
+function per1MRate(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function extractOpenRouterPricing(raw) {
+  const input = perTokenRate(raw.prompt);
+  const output = perTokenRate(raw.completion);
+  if (input === void 0 || output === void 0) return void 0;
+  const cost = { input: toPer1M(input), output: toPer1M(output) };
+  for (const [field, target] of [
+    ["input_cache_read", "cache_read"],
+    ["input_cache_write", "cache_write"]
+  ]) {
+    if (raw[field] === void 0) continue;
+    const rate = perTokenRate(raw[field]);
+    if (rate === void 0) return void 0;
+    cost[target] = toPer1M(rate);
+  }
+  return cost;
+}
+function extractModelsDevPricing(raw) {
+  const input = per1MRate(raw.input);
+  const output = per1MRate(raw.output);
+  if (input === void 0 || output === void 0) return void 0;
+  const cost = { input, output };
+  for (const field of ["cache_read", "cache_write"]) {
+    if (raw[field] === void 0) continue;
+    const rate = per1MRate(raw[field]);
+    if (rate === void 0) return void 0;
+    cost[field] = rate;
+  }
+  return cost;
+}
+function extractPricing(raw) {
+  if (!isRecord5(raw)) return void 0;
+  const hasOpenRouterKeys = OPENROUTER_KEYS.some((key) => key in raw);
+  const hasModelsDevKeys = MODELS_DEV_KEYS.some((key) => key in raw);
+  if (hasOpenRouterKeys && hasModelsDevKeys) return void 0;
+  if (hasOpenRouterKeys) return extractOpenRouterPricing(raw);
+  if (hasModelsDevKeys) return extractModelsDevPricing(raw);
+  return void 0;
+}
+
+// src/catalog/normalize-model-id.ts
+var FACADE_ID_PATTERN = /^([^:/]+):global:global:([^:]+):(.+)$/;
+function normalizeId(raw, env = process.env) {
+  const id = raw.trim();
+  if (!id) {
+    logger.warn(
+      `dropping empty model id from catalog (raw: ${JSON.stringify(raw)})`
+    );
+    return void 0;
+  }
+  if (!id.includes(":")) return id;
+  const shimEnabled = env[ENV_DISABLE_ID_SHIM] !== "1";
+  const facade = shimEnabled ? FACADE_ID_PATTERN.exec(id) : null;
+  if (facade?.[2] && facade[3])
+    return `${facade[2]}/${facade[3]}`;
+  logger.warn(
+    shimEnabled ? `dropping unrecognized colon-form model id "${id}" (not facade form, not a canonical slug)` : `dropping colon-form model id "${id}" (facade-id shim disabled via ${ENV_DISABLE_ID_SHIM}=1)`
+  );
+  return void 0;
+}
+
+// src/catalog/fetch-catalog.ts
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseEntries(payload) {
+  if (Array.isArray(payload)) return payload;
+  if (isRecord6(payload) && Array.isArray(payload.data)) return payload.data;
+  throw new CatalogFetchError(
+    "parse",
+    "response is neither {data:[\u2026]} nor a bare array"
+  );
+}
+function toCatalogModels(entries, env) {
+  const models = {};
+  for (const entry of entries) {
+    if (!isRecord6(entry) || typeof entry.id !== "string") continue;
+    const slug2 = normalizeId(entry.id, env);
+    if (!slug2 || models[slug2]) continue;
+    const model = { id: slug2 };
+    const displayName = typeof entry.display_name === "string" ? entry.display_name.trim() : "";
+    if (displayName !== "") model.displayName = displayName;
+    if (isRecord6(entry.pricing) && extractPricing(entry.pricing) !== void 0)
+      model.pricing = entry.pricing;
+    models[slug2] = model;
+  }
+  return models;
+}
+async function fetchCatalog(opts) {
+  const {
+    baseURL,
+    key,
+    env = process.env,
+    timeoutMs = DEFAULT_FETCH_TIMEOUT_MS
+  } = opts;
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const url = `${baseURL.replace(/\/+$/, "")}/models`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    let response;
+    try {
+      response = await fetchImpl(url, {
+        headers: { Authorization: `Bearer ${key}` },
+        signal: controller.signal
+      });
+    } catch (error) {
+      if (controller.signal.aborted)
+        throw new CatalogFetchError(
+          "timeout",
+          `no response within ${timeoutMs}ms`
+        );
+      throw new CatalogFetchError(
+        "network",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+    if (!response.ok) {
+      throw new CatalogFetchError(
+        "http",
+        `${url} responded ${response.status}`,
+        response.status
+      );
+    }
+    let payload;
+    try {
+      payload = await response.json();
+    } catch {
+      if (controller.signal.aborted)
+        throw new CatalogFetchError(
+          "timeout",
+          `body not read within ${timeoutMs}ms`
+        );
+      throw new CatalogFetchError("parse", "response body is not valid JSON");
+    }
+    const models = toCatalogModels(parseEntries(payload), env);
+    logger.info(`fetched ${Object.keys(models).length} model(s) from ${url}`);
+    return models;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/catalog/catalog-service.ts
+function seedResult(seed, why) {
+  const models = {};
+  for (const entry of seed) {
+    models[entry.slug] = { id: entry.slug };
+  }
+  logger.info(`catalog source: seed (${why}; ${seed.length} model(s))`);
+  return { models, source: "seed" };
+}
+async function runLadder(opts) {
+  const { key, baseURL, seed, env = process.env, fetchImpl, now } = opts;
+  if (env[ENV_DISCOVERY] === "0")
+    return seedResult(seed, `discovery disabled via ${ENV_DISCOVERY}=0`);
+  if (!key) return seedResult(seed, "no API key resolved");
+  const fresh = readFreshCatalog({ key, env, now });
+  if (fresh) {
+    logger.info(
+      `catalog source: cache (${Object.keys(fresh).length} model(s))`
+    );
+    return { models: fresh, source: "cache" };
+  }
+  try {
+    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 });
+    logger.info(`catalog source: live (${Object.keys(live).length} model(s))`);
+    return { models: live, source: "live" };
+  } catch (error) {
+    logger.warn(
+      `live catalog fetch failed \u2014 trying stale cache: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const stale = readStaleCatalog({ key, env });
+  if (stale) {
+    logger.info(
+      `catalog source: stale-cache (${Object.keys(stale).length} model(s))`
+    );
+    return { models: stale, source: "stale-cache" };
+  }
+  return seedResult(seed, "live fetch failed and no cache available");
+}
+async function getCatalog(opts) {
+  try {
+    return await runLadder(opts);
+  } catch (error) {
+    logger.error(
+      `unexpected catalog-service failure \u2014 degrading to seed: ${error instanceof Error ? error.message : String(error)}`
+    );
+    try {
+      return seedResult(opts.seed, "unexpected internal failure");
+    } catch {
+      return { models: {}, source: "seed" };
+    }
+  }
+}
+
+// src/catalog/seed/anthropic-gateway-limit.ts
+var ANTHROPIC_GATEWAY_LIMIT = {
+  context: 1e6,
+  output: 32e3
+};
+
+// src/catalog/seed/slug.ts
+var slug = (s) => s;
+
+// src/catalog/seed/claude-opus.ts
+var CLAUDE_OPUS = {
+  slug: slug("anthropic/claude-opus-4.8"),
+  name: "Claude Opus 4.8",
+  cost: {
+    input: 5,
+    // source: models.dev 2026-07-04 (key: anthropic/claude-opus-4-8, dash form)
+    output: 25,
+    // source: models.dev 2026-07-04
+    cache_read: 0.5,
+    // source: models.dev 2026-07-04
+    cache_write: 6.25
+    // source: models.dev 2026-07-04
+  },
+  limit: ANTHROPIC_GATEWAY_LIMIT,
+  capabilities: { reasoning: true }
+};
+
+// src/catalog/seed/claude-sonnet.ts
+var CLAUDE_SONNET = {
+  slug: slug("anthropic/claude-sonnet-4.6"),
+  name: "Claude Sonnet 4.6",
+  cost: {
+    input: 3,
+    // source: models.dev 2026-07-04 (key: anthropic/claude-sonnet-4-6, dash form)
+    output: 15,
+    // source: models.dev 2026-07-04
+    cache_read: 0.3,
+    // source: models.dev 2026-07-04
+    cache_write: 3.75
+    // source: models.dev 2026-07-04
+  },
+  limit: ANTHROPIC_GATEWAY_LIMIT,
+  capabilities: { reasoning: true }
+};
+
+// src/catalog/seed/gemini-3-1-pro-preview.ts
+var GEMINI_3_1_PRO_PREVIEW = {
+  slug: slug("google/gemini-3.1-pro-preview"),
+  name: "Gemini 3.1 Pro Preview",
+  cost: {
+    input: 2,
+    // source: models.dev 2026-07-04
+    output: 12,
+    // source: models.dev 2026-07-04
+    cache_read: 0.2,
+    // source: models.dev 2026-07-04
+    // models.dev's context tier boundary is exactly 200,000 tokens here —
+    // context_over_200k is the lossless encoding (D20 "certainty achieved").
+    context_over_200k: {
+      input: 4,
+      // source: models.dev 2026-07-04
+      output: 18,
+      // source: models.dev 2026-07-04
+      cache_read: 0.4
+      // source: models.dev 2026-07-04
+    }
+  },
+  limit: { context: 1048576, output: 65536 },
+  // source: models.dev 2026-07-04
+  capabilities: {}
+};
+
+// src/catalog/seed/glm-5-2.ts
+var GLM_5_2 = {
+  slug: slug("z-ai/glm-5.2"),
+  name: "GLM-5.2",
+  cost: {
+    input: 1.4,
+    // source: models.dev 2026-07-04 (provider key: zai)
+    output: 4.4,
+    // source: models.dev 2026-07-04
+    cache_read: 0.26
+    // source: models.dev 2026-07-04
+    // cache_write deliberately OMITTED: models.dev lists a literal 0, which
+    // the seed contract forbids as a recorded price. Omission makes opencode
+    // bill cache writes at the input rate — the conservative D20 fallback
+    // (overestimate over a possibly-wrong free write).
+  },
+  limit: { context: 1e6, output: 131072 },
+  // source: models.dev 2026-07-04
+  capabilities: {}
+};
+
+// src/catalog/seed/gpt-4o-mini.ts
+var GPT_4O_MINI = {
+  slug: slug("openai/gpt-4o-mini"),
+  name: "GPT-4o mini",
+  cost: {
+    input: 0.15,
+    // source: models.dev 2026-07-04
+    output: 0.6,
+    // source: models.dev 2026-07-04
+    cache_read: 0.075
+    // source: models.dev 2026-07-04
+  },
+  limit: { context: 128e3, output: 16384 },
+  // source: models.dev 2026-07-04
+  capabilities: {}
+};
+
+// src/catalog/seed/gpt-5-4-mini.ts
+var GPT_5_4_MINI = {
+  slug: slug("openai/gpt-5.4-mini"),
+  name: "GPT-5.4 mini",
+  cost: {
+    input: 0.75,
+    // source: models.dev 2026-07-04
+    output: 4.5,
+    // source: models.dev 2026-07-04
+    cache_read: 0.075
+    // source: models.dev 2026-07-04
+  },
+  limit: { context: 4e5, output: 128e3 },
+  // source: models.dev 2026-07-04
+  // Reasoning model; opencode's variants gate (transform.ts) requires the flag.
+  capabilities: { reasoning: true }
+};
+
+// src/catalog/seed/gpt-5-5.ts
+var GPT_5_5 = {
+  slug: slug("openai/gpt-5.5"),
+  name: "GPT-5.5",
+  cost: {
+    input: 5,
+    // source: models.dev 2026-07-04
+    output: 30,
+    // source: models.dev 2026-07-04
+    cache_read: 0.5,
+    // source: models.dev 2026-07-04
+    // models.dev lists a context tier at 272k tokens (input 10 / output 45 /
+    // cache_read 1) AND ships this pre-computed context_over_200k with the
+    // same rates. The 272k boundary itself is inexpressible in the config
+    // schema; billing the higher tier from 200k instead only ever
+    // OVER-estimates the 200k–272k window — D20's conservative branch,
+    // encoded precisely rather than flattened to a max rate.
+    context_over_200k: {
+      input: 10,
+      // source: models.dev 2026-07-04
+      output: 45,
+      // source: models.dev 2026-07-04
+      cache_read: 1
+      // source: models.dev 2026-07-04
+    }
+  },
+  limit: { context: 105e4, output: 128e3 },
+  // source: models.dev 2026-07-04
+  // Reasoning model; opencode's variants gate (transform.ts) requires the flag.
+  capabilities: { reasoning: true }
+};
+
+// src/catalog/seed/kimi-k2-6.ts
+var KIMI_K2_6 = {
+  slug: slug("moonshotai/kimi-k2.6"),
+  name: "Kimi K2.6",
+  cost: {
+    input: 0.95,
+    // source: models.dev 2026-07-04
+    output: 4,
+    // source: models.dev 2026-07-04
+    cache_read: 0.16
+    // source: models.dev 2026-07-04
+  },
+  limit: { context: 262144, output: 262144 },
+  // source: models.dev 2026-07-04
+  capabilities: {}
+};
+
+// src/catalog/seed/kimi-k2-7-code.ts
+var KIMI_K2_7_CODE = {
+  slug: slug("moonshotai/kimi-k2.7-code"),
+  name: "Kimi K2.7 Code",
+  cost: {
+    input: 0.95,
+    // source: models.dev 2026-07-04
+    output: 4,
+    // source: models.dev 2026-07-04
+    cache_read: 0.19
+    // source: models.dev 2026-07-04
+  },
+  limit: { context: 262144, output: 262144 },
+  // source: models.dev 2026-07-04
+  capabilities: {}
+};
+
+// src/catalog/seed/kimi-k3.ts
+var KIMI_K3 = {
+  slug: slug("moonshotai/kimi-k3"),
+  name: "Kimi K3",
+  cost: {
+    input: 3,
+    // source: models.dev 2026-07-18
+    output: 15,
+    // source: models.dev 2026-07-18
+    cache_read: 0.3
+    // source: models.dev 2026-07-18
+  },
+  limit: { context: 1048576, output: 131072 },
+  // source: models.dev 2026-07-18
+  capabilities: { reasoning: true },
+  // opencode-go parity: the openai-compatible lowerer wires reasoning_effort: "max".
+  variants: { max: { reasoningEffort: "max" } }
+};
+
+// src/catalog/seed/seed.ts
+var SEED = [
+  GPT_5_5,
+  GPT_5_4_MINI,
+  GEMINI_3_1_PRO_PREVIEW,
+  KIMI_K2_6,
+  KIMI_K2_7_CODE,
+  KIMI_K3,
+  GPT_4O_MINI,
+  GLM_5_2,
+  CLAUDE_OPUS,
+  CLAUDE_SONNET,
+  // D10 dash-form aliases — spread from their canonical entries so
+  // cost/limit/capabilities stay identical by construction.
+  {
+    ...CLAUDE_OPUS,
+    slug: slug("anthropic/claude-opus-4-8"),
+    name: `${CLAUDE_OPUS.name} (alias)`,
+    aliasOf: CLAUDE_OPUS.slug
+  },
+  {
+    ...CLAUDE_SONNET,
+    slug: slug("anthropic/claude-sonnet-4-6"),
+    name: `${CLAUDE_SONNET.name} (alias)`,
+    aliasOf: CLAUDE_SONNET.slug
+  }
+];
+
+// src/enrich/static-meta.ts
+var lookupSeed = (slug2) => SEED.find((entry) => entry.slug === slug2) ?? SEED.find((entry) => entry.aliasOf === slug2);
+
+// src/enrich/enrich-model.ts
+function resolveCost(catalogModel, modelsDevLookup, seed) {
+  const r33Cost = catalogModel?.pricing !== void 0 ? extractPricing(catalogModel.pricing) : void 0;
+  return r33Cost ?? modelsDevLookup?.cost ?? seed?.cost;
+}
+function resolveLimit(seed, modelsDevLookup) {
+  return seed?.limit ?? modelsDevLookup?.limit;
+}
+function resolveCapabilities(seed, modelsDevLookup, env) {
+  const base = seed?.capabilities ?? {};
+  if (env[ENV_ENRICH_CAPS] !== "1" || modelsDevLookup === void 0)
+    return base;
+  const result = { ...base };
+  if (result.reasoning === void 0 && modelsDevLookup.reasoning !== void 0)
+    result.reasoning = modelsDevLookup.reasoning;
+  if (result.tool_call === void 0 && modelsDevLookup.tool_call !== void 0)
+    result.tool_call = modelsDevLookup.tool_call;
+  if (result.attachment === void 0 && modelsDevLookup.attachment !== void 0)
+    result.attachment = modelsDevLookup.attachment;
+  if (result.temperature === void 0 && modelsDevLookup.temperature !== void 0) {
+    result.temperature = modelsDevLookup.temperature;
+  }
+  return result;
+}
+function enrichModel(slug2, sources) {
+  const env = sources.env ?? process.env;
+  const seed = lookupSeed(slug2);
+  const modelsDevLookup = sources.modelsDev.lookup(slug2);
+  const capabilities = resolveCapabilities(seed, modelsDevLookup, env);
+  const catalogModel = sources.catalogModel;
+  const name = catalogModel !== void 0 && catalogModel.id === slug2 && catalogModel.displayName !== void 0 ? catalogModel.displayName : slug2;
+  const meta = { name, capabilities };
+  const limit = resolveLimit(seed, modelsDevLookup);
+  if (limit !== void 0) meta.limit = limit;
+  if (seed?.variants !== void 0) meta.variants = seed.variants;
+  const cost = resolveCost(sources.catalogModel, modelsDevLookup, seed);
+  if (cost === void 0) {
+    logger.warn(
+      `cost metadata unavailable for ${slug2} \u2014 reported cost will be $0 until added`
+    );
+    return meta;
+  }
+  meta.cost = cost;
+  return meta;
+}
+
+// src/enrich/models-dev/load-models-dev.ts
+import * as fs7 from "fs";
+import * as path9 from "path";
+
+// src/enrich/models-dev/is-record.ts
+function isRecord7(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/enrich/models-dev/fetch-live.ts
+var MODELS_DEV_API_URL = "https://models.dev/api.json";
+var FETCH_TIMEOUT_MS = 5e3;
+async function fetchLive(fetchImpl) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  try {
+    const response = await fetchImpl(MODELS_DEV_API_URL, {
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      logger.warn(`models.dev responded ${response.status}`);
+      return void 0;
+    }
+    const body = await response.json();
+    return isRecord7(body) ? body : void 0;
+  } catch (error) {
+    logger.warn("models.dev fetch failed:", error);
+    return void 0;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/enrich/models-dev/num.ts
+function num(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+
+// src/enrich/models-dev/normalize-cost.ts
+var EXPRESSIBLE_TIER_SIZE = 2e5;
+function parseRateBlock(value) {
+  if (!isRecord7(value)) return void 0;
+  const input = num(value.input);
+  const output = num(value.output);
+  if (input === void 0 || output === void 0) return void 0;
+  const block = { input, output };
+  const cacheRead = num(value.cache_read);
+  if (cacheRead !== void 0) block.cache_read = cacheRead;
+  const cacheWrite = num(value.cache_write);
+  if (cacheWrite !== void 0) block.cache_write = cacheWrite;
+  return block;
+}
+function isExpressibleContextTier(tier) {
+  const marker = tier.tier;
+  return isRecord7(marker) && marker.type === "context" && marker.size === EXPRESSIBLE_TIER_SIZE;
+}
+function maxRate(current, candidate) {
+  const rate = num(candidate);
+  if (rate === void 0) return current;
+  return current === void 0 || rate > current ? rate : current;
+}
+function normalizeCost(raw) {
+  if (!isRecord7(raw)) return void 0;
+  const input = num(raw.input);
+  const output = num(raw.output);
+  if (input === void 0 || output === void 0) return void 0;
+  const cost = { input, output };
+  const cacheRead = num(raw.cache_read);
+  if (cacheRead !== void 0) cost.cache_read = cacheRead;
+  const cacheWrite = num(raw.cache_write);
+  if (cacheWrite !== void 0) cost.cache_write = cacheWrite;
+  const over200k = parseRateBlock(raw.context_over_200k);
+  if (over200k) cost.context_over_200k = over200k;
+  const tiers = Array.isArray(raw.tiers) ? raw.tiers.filter(isRecord7) : [];
+  for (const tier of tiers) {
+    if (isExpressibleContextTier(tier)) {
+      if (cost.context_over_200k === void 0) {
+        const converted = parseRateBlock(tier);
+        if (converted) cost.context_over_200k = converted;
+      }
+      continue;
+    }
+    cost.input = maxRate(cost.input, tier.input) ?? cost.input;
+    cost.output = maxRate(cost.output, tier.output) ?? cost.output;
+    const collapsedRead = maxRate(cost.cache_read, tier.cache_read);
+    if (collapsedRead !== void 0) cost.cache_read = collapsedRead;
+    const collapsedWrite = maxRate(cost.cache_write, tier.cache_write);
+    if (collapsedWrite !== void 0) cost.cache_write = collapsedWrite;
+  }
+  return cost;
+}
+
+// src/enrich/models-dev/vendor-aliases.ts
+var VENDOR_ALIASES = {
+  "z-ai": "zai"
+};
+
+// src/enrich/models-dev/probe-candidates.ts
+function swapLast(value, from, to) {
+  const index = value.lastIndexOf(from);
+  return index === -1 ? value : `${value.slice(0, index)}${to}${value.slice(index + 1)}`;
+}
+function probeCandidates(slug2) {
+  const sep2 = slug2.indexOf("/");
+  if (sep2 <= 0 || sep2 >= slug2.length - 1) return [];
+  const vendor = slug2.slice(0, sep2);
+  const model = slug2.slice(sep2 + 1);
+  const vendors = [vendor];
+  const alias = VENDOR_ALIASES[vendor];
+  if (alias !== void 0 && alias !== vendor) vendors.push(alias);
+  const swaps = [];
+  for (const candidate of [
+    model.replaceAll(".", "-"),
+    model.replaceAll("-", "."),
+    swapLast(model, ".", "-"),
+    swapLast(model, "-", ".")
+  ]) {
+    if (candidate !== model && !swaps.includes(candidate))
+      swaps.push(candidate);
+  }
+  const candidates = vendors.map(
+    (v) => [v, model]
+  );
+  for (const v of vendors) {
+    for (const swapped of swaps) candidates.push([v, swapped]);
+  }
+  return candidates;
+}
+
+// src/enrich/models-dev/lookup.ts
+function normalizeLimit(raw) {
+  if (!isRecord7(raw)) return void 0;
+  const context = num(raw.context);
+  const output = num(raw.output);
+  if (context === void 0 || output === void 0) return void 0;
+  const limit = { context, output };
+  const input = num(raw.input);
+  if (input !== void 0) limit.input = input;
+  return limit;
+}
+function buildLookup(model) {
+  const result = {};
+  const cost = normalizeCost(model.cost);
+  if (cost) result.cost = cost;
+  const limit = normalizeLimit(model.limit);
+  if (limit) result.limit = limit;
+  for (const field of [
+    "reasoning",
+    "tool_call",
+    "attachment",
+    "temperature"
+  ]) {
+    const value = model[field];
+    if (typeof value === "boolean") result[field] = value;
+  }
+  return result;
+}
+function lookupSlug(data, slug2) {
+  for (const [providerKey, modelKey] of probeCandidates(slug2)) {
+    const provider = data[providerKey];
+    if (!isRecord7(provider) || !isRecord7(provider.models)) continue;
+    const model = provider.models[modelKey];
+    if (isRecord7(model)) return buildLookup(model);
+  }
+  return void 0;
+}
+
+// src/enrich/models-dev/load-models-dev.ts
+var CACHE_FILE = "models-dev.json";
+function readCache(cachePath) {
+  try {
+    const parsed = JSON.parse(fs7.readFileSync(cachePath, "utf8"));
+    if (!isRecord7(parsed)) return void 0;
+    const fetchedAt = num(parsed.fetchedAt);
+    if (fetchedAt === void 0 || !isRecord7(parsed.data)) return void 0;
+    return { fetchedAt, data: parsed.data };
+  } catch {
+    return void 0;
+  }
+}
+function writeCache(cachePath, envelope) {
+  try {
+    fs7.mkdirSync(path9.dirname(cachePath), { recursive: true });
+    fs7.writeFileSync(cachePath, JSON.stringify(envelope), "utf8");
+  } catch (error) {
+    logger.warn("failed to write models.dev cache:", error);
+  }
+}
+function makeSource(source, data) {
+  return { source, lookup: (slug2) => lookupSlug(data, slug2) };
+}
+async function loadModelsDev(options = {}) {
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const cacheDir = options.cacheDir ?? resolveCacheDir();
+  const ttlMs = options.ttlMs ?? MODELS_DEV_TTL_MS;
+  const now = options.now ?? Date.now;
+  const cachePath = path9.join(cacheDir, CACHE_FILE);
+  const cached = readCache(cachePath);
+  if (cached && now() - cached.fetchedAt < ttlMs)
+    return makeSource("cache", cached.data);
+  const live = await fetchLive(fetchImpl);
+  if (live) {
+    writeCache(cachePath, { fetchedAt: now(), data: live });
+    return makeSource("live", live);
+  }
+  if (cached) {
+    logger.warn("models.dev unreachable \u2014 serving stale cache");
+    return makeSource("stale-cache", cached.data);
+  }
+  logger.warn(
+    "models.dev unavailable (no network, no cache) \u2014 enrichment source disabled"
+  );
+  return { source: null, lookup: () => void 0 };
+}
+
+// src/config/build-alias-targets.ts
+var SEED_ALIAS_TARGETS = Object.fromEntries(
+  SEED.flatMap(
+    (entry) => entry.aliasOf === void 0 ? [] : [[entry.slug, entry.aliasOf]]
+  )
+);
+function buildAliasTargets(catalog) {
+  const targets = { ...SEED_ALIAS_TARGETS };
+  if (catalog.source === "seed") return targets;
+  for (const entry of SEED) {
+    if (entry.aliasOf === void 0) continue;
+    const aliasSlug = entry.slug;
+    const canonicalSlug = entry.aliasOf;
+    const aliasPresent = catalog.models[aliasSlug] !== void 0;
+    const canonicalPresent = catalog.models[canonicalSlug] !== void 0;
+    if (aliasPresent && !canonicalPresent) {
+      targets[canonicalSlug] = aliasSlug;
+      delete targets[aliasSlug];
+    } else if (aliasPresent && canonicalPresent) {
+      delete targets[aliasSlug];
+      delete targets[canonicalSlug];
+    }
+  }
+  return targets;
+}
+
+// src/config/enrich-catalog.ts
+function enrichOne(slug2, catalogModel, modelsDev, env) {
+  const sources = { modelsDev, env };
+  if (catalogModel !== void 0) sources.catalogModel = catalogModel;
+  return enrichModel(slug2, sources);
+}
+function enrichCatalog(catalog, modelsDev, env) {
+  const enriched = {};
+  for (const slug2 of Object.keys(catalog.models)) {
+    enriched[slug2] = enrichOne(slug2, catalog.models[slug2], modelsDev, env);
+  }
+  for (const entry of SEED) {
+    if (entry.aliasOf === void 0) continue;
+    const aliasSlug = entry.slug;
+    const canonicalSlug = entry.aliasOf;
+    const aliasPresent = enriched[aliasSlug] !== void 0;
+    const canonicalPresent = enriched[canonicalSlug] !== void 0;
+    if (aliasPresent === canonicalPresent) continue;
+    if (canonicalPresent) {
+      enriched[aliasSlug] = enrichOne(
+        aliasSlug,
+        catalog.models[canonicalSlug],
+        modelsDev,
+        env
+      );
+    } else {
+      enriched[canonicalSlug] = enrichOne(
+        canonicalSlug,
+        catalog.models[aliasSlug],
+        modelsDev,
+        env
+      );
+    }
+  }
+  return enriched;
+}
+
+// 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 (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/merge-provider.ts
+var FORCED_OPTION_FIELDS = /* @__PURE__ */ new Set([
+  "apiKey",
+  "baseURL",
+  "headers"
+]);
+function mergeProvider(target, patch) {
+  if (target.npm === void 0) target.npm = patch.npm;
+  if (target.name === void 0) target.name = patch.name;
+  if (target.options === void 0) {
+    target.options = { ...patch.options };
+  } else {
+    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)
+        options[field] = value;
+    }
+  }
+  mergeModels(target, patch);
+}
+
+// src/config/merge-config.ts
+function mergeConfig(cfg, blocks) {
+  if (cfg.provider === void 0) cfg.provider = {};
+  const provider = cfg.provider;
+  for (const [providerID, patch] of Object.entries(blocks)) {
+    const target = provider[providerID] ?? {};
+    provider[providerID] = target;
+    mergeProvider(target, patch);
+  }
+}
+
+// src/config/collected-ref.ts
+function parseRef(ref, source) {
+  const sep2 = ref.indexOf("/");
+  if (sep2 <= 0 || sep2 >= ref.length - 1) return void 0;
+  const providerId = ref.slice(0, sep2);
+  const suffix = ref.slice(sep2 + 1);
+  if (providerId === "route_33")
+    return { providerId, modelKey: suffix, ref, source };
+  if (providerId !== "route_33_anthropic") return void 0;
+  return {
+    providerId: "route_33",
+    modelKey: `anthropic/${suffix}`,
+    ref,
+    source,
+    legacyReplacement: `route_33/anthropic/${suffix}`
+  };
+}
+function pushRef(refs, value, source) {
+  if (typeof value !== "string") return;
+  const parsed = parseRef(value, source);
+  if (parsed) refs.push(parsed);
+}
+
+// src/config/collect-cfg-refs.ts
+function collectCfgRefs(cfg) {
+  const refs = [];
+  pushRef(refs, cfg.model, 'opencode config "model"');
+  pushRef(refs, cfg.small_model, 'opencode config "small_model"');
+  for (const [name, agent] of Object.entries(cfg.agent ?? {})) {
+    pushRef(refs, agent?.model, `opencode agent "${name}"`);
+  }
+  return refs;
+}
+
+// src/config/collect-flavour-refs.ts
+import * as fs8 from "fs";
+import * as os5 from "os";
+import * as path10 from "path";
+import { parse as parseJsonc2 } from "jsonc-parser";
+function isRecord8(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function findFlavourPath(env, cwd) {
+  const candidates = [];
+  const configDir = env.OPENCODE_CONFIG_DIR?.trim();
+  if (configDir) candidates.push(path10.join(configDir, "oh-my-openagent.jsonc"));
+  candidates.push(path10.join(cwd, ".opencode", "oh-my-openagent.jsonc"));
+  const configHome = env.XDG_CONFIG_HOME?.trim() || path10.join(os5.homedir(), ".config");
+  candidates.push(path10.join(configHome, "opencode", "oh-my-openagent.jsonc"));
+  for (const candidate of candidates) {
+    try {
+      if (fs8.existsSync(candidate)) return candidate;
+    } catch {
+    }
+  }
+  return void 0;
+}
+function collectSectionRefs(refs, section, label) {
+  if (!isRecord8(section)) return;
+  for (const [name, entry] of Object.entries(section)) {
+    if (!isRecord8(entry)) continue;
+    pushRef(refs, entry.model, `flavour ${label} "${name}"`);
+    if (label === "agent" && isRecord8(entry.ultrawork)) {
+      pushRef(
+        refs,
+        entry.ultrawork.model,
+        `flavour ${label} "${name}" (ultrawork)`
+      );
+    }
+  }
+}
+function collectFlavourRefs(env, cwd) {
+  const flavourPath = findFlavourPath(env, cwd);
+  if (flavourPath === void 0) return [];
+  const refs = [];
+  try {
+    const parsed = parseJsonc2(fs8.readFileSync(flavourPath, "utf8"));
+    if (!isRecord8(parsed)) {
+      logger.warn(
+        `flavour file ${flavourPath} did not parse to an object \u2014 skipping flavour ref validation`
+      );
+      return [];
+    }
+    collectSectionRefs(refs, parsed.agents, "agent");
+    collectSectionRefs(refs, parsed.categories, "category");
+  } catch (error) {
+    logger.warn(
+      `flavour file ${flavourPath} could not be read \u2014 skipping flavour ref validation: ${String(error)}`
+    );
+    return [];
+  }
+  return refs;
+}
+
+// src/config/describe-missing.ts
+function availableKeys(cfg, providerId) {
+  return Object.keys(cfg.provider?.[providerId]?.models ?? {});
+}
+function describeMissing(cfg, missing) {
+  const sections = missing.map((entry) => {
+    const available = availableKeys(cfg, entry.providerId).sort().map((key) => `${entry.providerId}/${key}`).join(", ");
+    return [
+      `  ${entry.ref}`,
+      `    referenced by: ${entry.sources.join(", ")}`,
+      ...entry.legacyReplacement === void 0 ? [] : [`    rename to "${entry.legacyReplacement}"`],
+      `    available on ${entry.providerId}: ${available || "(none)"}`
+    ].join("\n");
+  });
+  return `[route_33] ${missing.length} unresolvable model reference(s):
+
+${sections.join("\n\n")}`;
+}
+
+// src/config/find-missing-refs.ts
+function findMissingRefs(cfg, refs) {
+  const byRef = /* @__PURE__ */ new Map();
+  for (const ref of refs) {
+    const models = cfg.provider?.[ref.providerId]?.models;
+    if (ref.legacyReplacement === void 0 && models !== void 0 && models[ref.modelKey] !== void 0)
+      continue;
+    const existing = byRef.get(ref.ref);
+    if (existing === void 0) {
+      const missing = {
+        providerId: ref.providerId,
+        modelKey: ref.modelKey,
+        ref: ref.ref,
+        sources: [ref.source]
+      };
+      if (ref.legacyReplacement !== void 0)
+        missing.legacyReplacement = ref.legacyReplacement;
+      byRef.set(ref.ref, missing);
+    } else if (!existing.sources.includes(ref.source)) {
+      existing.sources.push(ref.source);
+    }
+  }
+  return [...byRef.values()].sort((a, b) => a.ref.localeCompare(b.ref));
+}
+
+// src/config/inject-stubs.ts
+function injectStubs(cfg, missing) {
+  if (cfg.provider === void 0) cfg.provider = {};
+  for (const entry of missing) {
+    const provider = cfg.provider[entry.providerId] ?? {};
+    cfg.provider[entry.providerId] = provider;
+    const models = provider.models ?? {};
+    provider.models = models;
+    models[entry.modelKey] = { name: entry.modelKey };
+  }
+}
+
+// src/config/validation-error.ts
+var Route33ValidationError = class extends Error {
+  missingRefs;
+  constructor(message, missingRefs) {
+    super(message);
+    this.name = "Route33ValidationError";
+    this.missingRefs = missingRefs;
+  }
+};
+
+// src/config/validate-refs.ts
+var REMEDIATION = [
+  "Remediation:",
+  `  1. Set ${ENV_STRICT}=0 to downgrade this error to a warning (missing models get a name-only stub entry).`,
+  '  2. Declare the model explicitly under "provider" in opencode.jsonc.',
+  "  3. Verify the resolved API key has access to this model \u2014 the R33 catalog is key-scoped."
+].join("\n");
+function validateRefs(cfg, options = {}) {
+  const env = options.env ?? process.env;
+  const cwd = options.cwd ?? process.cwd();
+  const refs = [...collectCfgRefs(cfg), ...collectFlavourRefs(env, cwd)];
+  const missing = findMissingRefs(cfg, refs);
+  if (missing.length === 0) return;
+  const details = describeMissing(cfg, missing);
+  const missingIds = missing.map((entry) => entry.ref);
+  if (missing.some((entry) => entry.legacyReplacement !== void 0)) {
+    throw new Route33ValidationError(details, missingIds);
+  }
+  if (env[ENV_STRICT] === "0") {
+    logger.warn(
+      `${details}
+
+(${ENV_STRICT}=0 \u2014 continuing with name-only stub entries)`
+    );
+    injectStubs(cfg, missing);
+    return;
+  }
+  if (options.keyResolved === false) {
+    logger.warn(
+      `no route_33 API key resolved \u2014 catalog is seed-only; ${missing.length} referenced model(s) are unavailable until a key is configured: ${missingIds.join(", ")}. Enter a key via the project-key prompt, \`opencode auth login\`, ${ENV_API_KEY}, or a provider.route_33.options.apiKey literal, then restart. (Continuing with name-only stub entries.)`
+    );
+    injectStubs(cfg, missing);
+    return;
+  }
+  throw new Route33ValidationError(`${details}
+
+${REMEDIATION}`, missingIds);
+}
+
+// src/config/config-hook.ts
+function describeError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function createConfigHook(options = {}) {
+  const env = options.env ?? process.env;
+  const cwd = options.cwd ?? process.cwd();
+  const fetchImpl = options.fetchImpl;
+  return async (cfg) => {
+    let key;
+    try {
+      key = resolveKey(cfg, env, cwd);
+      const baseURL = resolveBaseUrl(cfg, env);
+      const catalog = await getCatalog({
+        key,
+        baseURL,
+        seed: SEED,
+        env,
+        fetchImpl
+      });
+      const modelsDevOptions = {
+        cacheDir: resolveCacheDir(env)
+      };
+      if (fetchImpl !== void 0) modelsDevOptions.fetchImpl = fetchImpl;
+      const modelsDev = await loadModelsDev(modelsDevOptions);
+      const enriched = enrichCatalog(catalog, modelsDev, env);
+      const blocks = buildProviderBlocks(enriched, {
+        apiKey: key,
+        baseURL,
+        aliasTargets: buildAliasTargets(catalog),
+        // 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.
+        resolveKeyNow: () => resolveKey(void 0, env, cwd)
+      });
+      mergeConfig(cfg, blocks);
+    } catch (error) {
+      logger.error(
+        `model discovery/injection failed unexpectedly \u2014 opencode startup continues without injected models: ${describeError(error)}`
+      );
+    }
+    try {
+      validateRefs(cfg, { env, cwd, keyResolved: key !== void 0 });
+    } catch (error) {
+      if (error instanceof Route33ValidationError) {
+        logger.error(error.message);
+        throw error;
+      }
+      logger.error(
+        `ref validation failed unexpectedly \u2014 skipping: ${describeError(error)}`
+      );
+    }
+  };
+}
+
+// src/index.ts
+var Route33Plugin = async (input, _options) => {
+  ensureTuiRegistration({
+    worktree: input?.worktree ?? input?.directory,
+    env: process.env,
+    moduleUrl: import.meta.url
+  });
+  ensureWorkspaceKeyGitignore(input?.worktree ?? input?.directory);
+  return {
+    config: createConfigHook(),
+    auth: buildRoute33Auth(process.env, input?.worktree ?? input?.directory)
+  };
+};
+export {
+  Route33Plugin
+};