@telsoncc/opencode-commandcode 1.1.0 → 1.2.0

package/CHANGELOG.md

@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.2.0] - 2026-09-25
+
 ## [1.1.0] - 2026-09-25
 
 ## [1.0.6] - 2026-09-24

package/README.md

@@ -24,6 +24,9 @@ Forked and currently maintained by **[telsoncc](https://github.com/telsoncc)** (
 - Vision vs text-only comes from the Command Code CLI catalog (`inputModalities` on every SKU). [models.dev](https://models.dev) only adds extra inputs (video/audio/pdf) when it matches.
 - Reasoning effort **variants** on models that declare `reasoningEfforts`.
 - Quiet OpenCode startup (diagnostics go to `startup.json`, not stdout).
+- Live catalog refresh on the 2.0 entrypoint: retired models are pruned and
+  new ones are published with [models.dev](https://models.dev) estimates
+  (marked `(est.)`) until the next catalog sync replaces them.
 - Native **OpenCode 2.x** entrypoint (`plugin/opencode2`, also served as `server`):
   in-memory provider inventory via `ctx.provider.transform` (no config writes)
   plus a `commandcode` integration for `/connect`. See `docs/opencode-2.md`.
@@ -100,6 +103,22 @@ Run `/connect` in opencode, search for **Command Code**, and enter your API key,
 On 2.x the catalog carries no release dates, so filter the picker by provider
 **Command Code** if the global list looks empty.
 
+## Live catalog refresh (2.x)
+
+The 2.0 entrypoint re-checks the Provider API (`/models`, no auth) on setup
+and every 6h on a process-shared timer:
+
+- ids the API retired are pruned from the inventory;
+- ids missing locally are published immediately with
+  [models.dev](https://models.dev) cost/capability estimates, named
+  `"<model> (est.)"`, and replaced by exact data on the next catalog sync;
+- ids with no estimable data stay reported (not published) until the sync.
+
+Estimates are list prices, close to but not equal to Command Code billing.
+`startup.json` records `catalogSource: "remote"`, `pendingNewCount`, and
+`estimatedCount`. Opt out with `disableModelSync: true` in
+`~/.config/opencode/opencode-commandcode.json`.
+
 ## Optional local CLI override
 
 Maintainers only. OpenCode will scrape a local `command-code` install when `COMMANDCODE_PACKAGE_PATH` or `commandCodePackagePath` in `~/.config/opencode/opencode-commandcode.json` is set.

package/manifest.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "generatedAt": "2026-09-24T21:10:50.082Z",
-  "pluginVersion": "1.1.0",
+  "pluginVersion": "1.2.0",
   "commandCodeVersion": "1.65.2",
   "commandCodeTarball": "https://registry.npmjs.org/command-code/-/command-code-1.65.2.tgz",
   "modelCount": 81,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telsoncc/opencode-commandcode",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Command Code API provider for opencode — use Claude, GPT, Gemini, DeepSeek, Qwen, Kimi, GLM, MiniMax, and Step models via Command Code",
   "keywords": [
     "ai",

package/plugin-opencode2.ts

@@ -71,10 +71,10 @@ export async function setup(ctx: V2SetupContext): Promise<() => Promise<void>> {
     // Keep the last-good inventory when the reload fails.
   }
 
-  // Live availability refresh: prune ids the API retired and surface new
-  // ones without waiting for an npm publish. The bundled catalog stays as
-  // the offline fallback; models unknown locally are reported, not
-  // published, until a catalog sync extracts their cost data.
+  // Live availability refresh: prune ids the API retired and publish new
+  // ones with models.dev cost estimates until a catalog sync replaces them.
+  // The bundled catalog stays as the offline fallback; ids with no
+  // estimable data stay reported as pending.
   const sameInventory = (next: ModelEntry[]): boolean =>
     next.length === inventory.length && next.every((m, i) => m.id === inventory[i]?.id);
 

package/src/catalog.ts

@@ -17,6 +17,8 @@ export interface ModelEntry {
   limit: { context: number; output: number };
   attachment?: boolean;
   modalities?: { input: string[]; output: string[] };
+  /** Runtime estimate from models.dev — replaced on the next catalog sync. */
+  estimated?: boolean;
 }
 
 export interface CostEntry {

package/src/costs-models-dev.ts

@@ -1,6 +1,14 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { pluginStateDir } from "./startup.js";
 import type { ModelEntry } from "./catalog.js";
 
 export const MODELS_DEV_URL = "https://models.dev/api.json";
+export const MODELS_DEV_TIMEOUT_MS = 30_000;
+export const MODELS_DEV_CACHE_TTL_MS = 24 * 3600_000;
+export const MODELS_DEV_CACHE_FILE = "models-dev-cache.json";
+export const ESTIMATED_CONTEXT_TOKENS = 200000;
+export const ESTIMATED_OUTPUT_TOKENS = 65536;
 export const FREE_COST = { input: 0, output: 0 } as const;
 export const TEXT_ONLY_MODALITIES = { input: ["text"], output: ["text"] } as const;
 
@@ -10,6 +18,15 @@ export type ModelsDevRow = {
   cost: { input: number; output: number; cache_read?: number; cache_write?: number };
   attachment?: boolean;
   modalities?: { input: string[]; output: string[] };
+  reasoning?: boolean;
+  reasoningEfforts?: string[];
+  toolCall?: boolean;
+  limit?: { context: number; output: number };
+};
+
+type ReasoningOption = {
+  type?: string;
+  values?: unknown;
 };
 
 type ModelsDevModel = {
@@ -18,6 +35,10 @@ type ModelsDevModel = {
   cost?: { input?: number; output?: number; cache_read?: number; cache_write?: number };
   attachment?: boolean;
   modalities?: { input?: string[]; output?: string[] };
+  reasoning?: boolean;
+  reasoning_options?: ReasoningOption[];
+  tool_call?: boolean;
+  limit?: { context?: number; output?: number };
 };
 
 type ModelsDevProvider = { models?: Record<string, ModelsDevModel> };
@@ -49,6 +70,12 @@ export function parseModelsDev(json: string): ModelsDevRow[] {
       if (model.cost.cache_write !== undefined) cost.cache_write = model.cost.cache_write;
       const row: ModelsDevRow = { id: model.id, name: model.name ?? model.id, cost };
       if (typeof model.attachment === "boolean") row.attachment = model.attachment;
+      if (typeof model.reasoning === "boolean") row.reasoning = model.reasoning;
+      const efforts = extractEffortValues(model.reasoning_options);
+      if (efforts) row.reasoningEfforts = efforts;
+      if (typeof model.tool_call === "boolean") row.toolCall = model.tool_call;
+      const limit = extractLimit(model.limit);
+      if (limit) row.limit = limit;
       const input = model.modalities?.input?.filter((x) => typeof x === "string");
       const output = model.modalities?.output?.filter((x) => typeof x === "string");
       if (input?.length || output?.length) {
@@ -105,6 +132,162 @@ function textOnly(): { input: string[]; output: string[] } {
   return { input: [...TEXT_ONLY_MODALITIES.input], output: [...TEXT_ONLY_MODALITIES.output] };
 }
 
+function extractEffortValues(options: ReasoningOption[] | undefined): string[] | undefined {
+  if (!Array.isArray(options)) return undefined;
+  const values = options.flatMap((o) =>
+    o?.type === "effort" && Array.isArray(o.values) ? o.values : [],
+  );
+  const unique = [
+    ...new Set(values.filter((v): v is string => typeof v === "string" && v.length > 0)),
+  ];
+  return unique.length > 0 ? unique : undefined;
+}
+
+function extractLimit(
+  limit: { context?: number; output?: number } | undefined,
+): { context: number; output: number } | undefined {
+  if (!limit || typeof limit.context !== "number" || typeof limit.output !== "number") {
+    return undefined;
+  }
+  if (!(limit.context > 0) || !(limit.output > 0)) return undefined;
+  return { context: limit.context, output: limit.output };
+}
+
+function prettifyModelId(id: string): string {
+  return lastSegment(id)
+    .replace(/[-_]+/g, " ")
+    .replace(/\s+/g, " ")
+    .trim()
+    .replace(/\b\w/g, (c) => c.toUpperCase());
+}
+
+/** Match a models.dev row by exact id, last path segment, or display name. */
+export function findModelsDevRow(
+  rows: ModelsDevRow[],
+  id: string,
+  name?: string,
+): ModelsDevRow | undefined {
+  const index = indexRows(rows);
+  return (
+    index.byId.get(id.toLowerCase()) ??
+    index.bySegment.get(lastSegment(id).toLowerCase()) ??
+    (name ? index.byName.get(name.toLowerCase()) : undefined)
+  );
+}
+
+/**
+ * Build a provisional catalog entry for a remote id missing locally.
+ * Costs/capabilities come from models.dev (list prices, close to but not
+ * equal to Command Code billing); the entry is replaced on the next catalog
+ * sync. Returns null when nothing can ground an estimate.
+ */
+export function buildEstimatedEntry(id: string, rows: ModelsDevRow[]): ModelEntry | null {
+  const displayName = prettifyModelId(id);
+  if (isFreeSku({ id, name: displayName })) {
+    return {
+      id,
+      name: `${displayName} (est.)`,
+      tier: "open-source",
+      reasoning: false,
+      tool_call: true,
+      cost: { ...FREE_COST },
+      limit: { context: ESTIMATED_CONTEXT_TOKENS, output: ESTIMATED_OUTPUT_TOKENS },
+      attachment: false,
+      modalities: textOnly(),
+      estimated: true,
+    };
+  }
+  const row = findModelsDevRow(rows, id);
+  if (!row) return null;
+  const cost: ModelEntry["cost"] = { input: row.cost.input, output: row.cost.output };
+  if (row.cost.cache_read !== undefined) cost.cache_read = row.cost.cache_read;
+  if (row.cost.cache_write !== undefined) cost.cache_write = row.cost.cache_write;
+  const modalities = row.modalities
+    ? { input: [...row.modalities.input], output: [...row.modalities.output] }
+    : textOnly();
+  return {
+    id,
+    name: `${row.name} (est.)`,
+    tier: "open-source",
+    reasoning: row.reasoning ?? (row.reasoningEfforts?.length ?? 0) > 0,
+    ...(row.reasoningEfforts ? { reasoningEfforts: [...row.reasoningEfforts] } : {}),
+    tool_call: row.toolCall ?? true,
+    cost,
+    limit: row.limit ?? {
+      context: ESTIMATED_CONTEXT_TOKENS,
+      output: ESTIMATED_OUTPUT_TOKENS,
+    },
+    attachment: row.attachment ?? modalities.input.includes("image"),
+    modalities,
+    estimated: true,
+  };
+}
+
+export interface ModelsDevCache {
+  fetchedAt: number;
+  json: string;
+}
+
+function readModelsDevCache(cacheDir: string): ModelsDevCache | null {
+  const path = join(cacheDir, MODELS_DEV_CACHE_FILE);
+  if (!existsSync(path)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf-8")) as Partial<ModelsDevCache>;
+    if (typeof parsed.json !== "string" || typeof parsed.fetchedAt !== "number") return null;
+    return { fetchedAt: parsed.fetchedAt, json: parsed.json };
+  } catch {
+    return null;
+  }
+}
+
+function writeModelsDevCache(cacheDir: string, json: string): void {
+  try {
+    mkdirSync(cacheDir, { recursive: true });
+    writeFileSync(
+      join(cacheDir, MODELS_DEV_CACHE_FILE),
+      JSON.stringify({ fetchedAt: Date.now(), json }),
+      "utf-8",
+    );
+  } catch {
+    // ignore cache write
+  }
+}
+
+/**
+ * Load models.dev rows, cached on disk for a day. Falls back to stale cache
+ * when the network fails; returns [] only when nothing is available.
+ */
+export async function loadModelsDevRows(
+  options: { timeoutMs?: number; maxAgeMs?: number; cacheDir?: string } = {},
+): Promise<ModelsDevRow[]> {
+  const cacheDir = options.cacheDir ?? pluginStateDir();
+  const maxAgeMs = options.maxAgeMs ?? MODELS_DEV_CACHE_TTL_MS;
+  const cached = readModelsDevCache(cacheDir);
+  if (cached && Date.now() - cached.fetchedAt < maxAgeMs) {
+    try {
+      return parseModelsDev(cached.json);
+    } catch {
+      // fall through to refetch
+    }
+  }
+  try {
+    const json = await fetchModelsDevJson(
+      AbortSignal.timeout(options.timeoutMs ?? MODELS_DEV_TIMEOUT_MS),
+    );
+    writeModelsDevCache(cacheDir, json);
+    return parseModelsDev(json);
+  } catch {
+    if (cached) {
+      try {
+        return parseModelsDev(cached.json);
+      } catch {
+        // fall through to []
+      }
+    }
+    return [];
+  }
+}
+
 export function applyModelsDevModalities(models: ModelEntry[], rows: ModelsDevRow[]): number {
   const index = indexRows(rows);
   let filled = 0;
@@ -159,7 +342,7 @@ export function applyModelsDevCosts(
   return filled;
 }
 
-export async function fetchModelsDevJson(): Promise<string> {
+export async function fetchModelsDevJson(signal?: AbortSignal): Promise<string> {
   const resp = await fetch(MODELS_DEV_URL, {
     headers: {
       // ponytail: models.dev returns 403 without a browser-like UA; upgrade if they add a real API token
@@ -167,6 +350,7 @@ export async function fetchModelsDevJson(): Promise<string> {
         "Mozilla/5.0 (compatible; opencode-commandcode/0.5; +https://github.com/telsoncc/opencode-commandcode)",
       Accept: "application/json",
     },
+    ...(signal ? { signal } : {}),
   });
   if (!resp.ok) throw new Error(`models.dev returned ${resp.status}`);
   return resp.text();

package/src/opencode2.ts

@@ -10,6 +10,7 @@ import {
   loadCatalogFromLocalCommandCode,
   type ModelEntry,
 } from "./catalog.js";
+import { buildEstimatedEntry, loadModelsDevRows, type ModelsDevRow } from "./costs-models-dev.js";
 import {
   readCatalogCache,
   writeCatalogCache,
@@ -350,6 +351,8 @@ export interface RemoteRefreshResult {
   unavailable: string[];
   pendingNew: string[];
   remoteCount: number;
+  /** Provisional entries published with models.dev estimates. */
+  estimated: ModelEntry[];
 }
 
 /** Live availability ids from the Provider API. No auth required. */
@@ -369,8 +372,8 @@ export async function fetchRemoteAvailability(
 /**
  * Reconcile a local catalog with live availability: keep the ids the API
  * still serves, report retired ones, and list remote ids missing locally.
- * Missing ids are *not* published — they carry no cost/limit data until a
- * catalog sync extracts them.
+ * Missing ids stay pending here — refreshCatalogFromRemote tries to publish
+ * them with models.dev estimates first.
  */
 export function applyRemoteAvailability(
   base: ModelEntry[],
@@ -379,14 +382,52 @@ export function applyRemoteAvailability(
   const { retained, unavailable } = filterCatalogByAvailability(base, remoteIds);
   const known = new Set(base.map((m) => m.id));
   const pendingNew = [...new Set(remoteIds)].filter((id) => !known.has(id)).sort();
-  return { models: retained, unavailable, pendingNew, remoteCount: remoteIds.length };
+  return {
+    models: retained,
+    unavailable,
+    pendingNew,
+    remoteCount: remoteIds.length,
+    estimated: [],
+  };
 }
 
 export async function refreshCatalogFromRemote(
   base: ModelEntry[],
   timeoutMs = REMOTE_SYNC_TIMEOUT_MS,
 ): Promise<RemoteRefreshResult> {
-  return applyRemoteAvailability(base, await fetchRemoteAvailability(timeoutMs));
+  const result = applyRemoteAvailability(base, await fetchRemoteAvailability(timeoutMs));
+  if (result.pendingNew.length === 0) return result;
+  let rows: ModelsDevRow[] = [];
+  try {
+    rows = await loadModelsDevRows();
+  } catch {
+    return result;
+  }
+  if (rows.length === 0) return result;
+  const usedKeys = new Set(base.map((m) => toConfigKey(m.id)));
+  const estimated: ModelEntry[] = [];
+  const stillPending: string[] = [];
+  for (const id of result.pendingNew) {
+    const key = toConfigKey(id);
+    if (usedKeys.has(key)) {
+      stillPending.push(id);
+      continue;
+    }
+    const entry = buildEstimatedEntry(id, rows);
+    if (!entry) {
+      stillPending.push(id);
+      continue;
+    }
+    usedKeys.add(key);
+    estimated.push(entry);
+  }
+  return {
+    models: [...result.models, ...estimated],
+    unavailable: result.unavailable,
+    pendingNew: stillPending,
+    remoteCount: result.remoteCount,
+    estimated,
+  };
 }
 
 export function isRemoteSyncDisabled(): boolean {
@@ -416,6 +457,7 @@ export function writeRemoteRefreshSummary(
     degradedReason:
       result.models.length === 0 ? "remote availability matched no local models" : null,
     pendingNewCount: result.pendingNew.length,
+    estimatedCount: result.estimated.length,
   };
   try {
     writeStartupSummary(pluginStateDir(), summary);

package/src/startup.ts

@@ -14,6 +14,8 @@ export type StartupSummary = {
   degradedReason: string | null;
   /** Remote ids with no local cost data yet — next catalog sync picks them up. */
   pendingNewCount?: number;
+  /** Provisional entries published with models.dev estimates. */
+  estimatedCount?: number;
 };
 
 export function pluginStateDir(): string {