@bitkyc08/opencodex 2.42.0 → 2.43.0

package/src/cli/effort.ts

@@ -0,0 +1,372 @@
+import { loadConfig, saveConfig } from "../config";
+import {
+  CODEX_REASONING_LEVELS,
+  configuredReasoningEfforts,
+  isDeclaredReasoningEffort,
+  mapReasoningEffort,
+  reasoningEffortMapFor,
+} from "../reasoning-effort";
+import { findLiveProxy } from "../server/proxy-liveness";
+import { modelInList, type OcxConfig } from "../types";
+import {
+  CliUsageError,
+  printData,
+  rejectArgs,
+  runCliAction,
+  runtimeRequest,
+  takeFlag,
+  takeOption,
+  type RuntimeApiDeps,
+} from "./runtime-api";
+
+export const EFFORT_USAGE = `Usage:
+  ocx effort [status] [--json]
+  ocx effort <low|medium|high|xhigh|max|ultra|none|minimal|-> [--json]
+  ocx effort set [--main <level|->] [--subagent <level|->] [--injection <level|->] [--json]
+  ocx effort clear [--json]
+  ocx effort model <provider/model|model> [--json]
+
+Note: 'ocx effort clear' resets main and subagent caps but keeps delegation
+injection effort. Use 'ocx effort set --injection -' to clear injection effort.`;
+
+function clearable(value: string | undefined): string | null | undefined {
+  return value === "-" ? null : value;
+}
+
+function validateEffortLevel(level: string | null | undefined, label: string): string | null | undefined {
+  if (level === undefined || level === null) return level;
+  const trimmed = level.trim();
+  if (trimmed === "-" || trimmed === "") return null;
+  if (!isDeclaredReasoningEffort(trimmed)) {
+    throw new CliUsageError(
+      `unknown reasoning effort "${trimmed}" for ${label} (allowed: ${CODEX_REASONING_LEVELS.map(l => l.effort).join(", ")}, none, minimal, -)`,
+      EFFORT_USAGE,
+    );
+  }
+  return trimmed;
+}
+
+interface EffortCapsResponse {
+  effortCap: string | null;
+  subagentEffortCap: string | null;
+  efforts: string[];
+}
+
+interface InjectionResponse {
+  effort?: string | null;
+}
+
+async function getLiveStatus(deps: RuntimeApiDeps): Promise<{
+  effortCap: string | null;
+  subagentEffortCap: string | null;
+  injectionEffort: string | null;
+  efforts: string[];
+  source: "runtime";
+}> {
+  // Propagate API failures once live mode is selected — do not swallow 401/500 into null (#3528 review).
+  const [caps, injection] = await Promise.all([
+    runtimeRequest<EffortCapsResponse>("/api/effort-caps", {}, deps),
+    runtimeRequest<InjectionResponse>("/api/injection-model", {}, deps),
+  ]);
+  return {
+    effortCap: caps.effortCap ?? null,
+    subagentEffortCap: caps.subagentEffortCap ?? null,
+    injectionEffort: injection?.effort ?? null,
+    efforts: caps.efforts ?? CODEX_REASONING_LEVELS.map(l => l.effort),
+    source: "runtime",
+  };
+}
+
+function getOfflineStatus(): {
+  effortCap: string | null;
+  subagentEffortCap: string | null;
+  injectionEffort: string | null;
+  efforts: string[];
+  source: "config";
+} {
+  const config = loadConfig();
+  return {
+    effortCap: config.effortCap ?? null,
+    subagentEffortCap: config.subagentEffortCap ?? null,
+    injectionEffort: config.injectionEffort ?? null,
+    efforts: CODEX_REASONING_LEVELS.map(l => l.effort),
+    source: "config",
+  };
+}
+
+async function status(wantsJson: boolean, deps: RuntimeApiDeps): Promise<void> {
+  let data: {
+    effortCap: string | null;
+    subagentEffortCap: string | null;
+    injectionEffort: string | null;
+    efforts: string[];
+    source: "runtime" | "config";
+  };
+
+  const liveFinder = deps.findLiveProxy ?? findLiveProxy;
+  const live = await liveFinder().catch(() => null);
+  const isLive = Boolean(live || deps.baseUrl);
+
+  if (isLive) {
+    // Once live proxy / baseUrl is selected, propagate API failures; do not silently substitute local config (#3528 review).
+    data = await getLiveStatus(deps);
+  } else {
+    data = getOfflineStatus();
+  }
+
+  const lines = [
+    `Reasoning effort status (${data.source === "runtime" ? "live proxy" : "offline config"}):`,
+    `  Main agent effort cap:     ${data.effortCap ?? "(unset — no cap)"}`,
+    `  Subagent effort cap:       ${data.subagentEffortCap ?? "(unset — no cap)"}`,
+    `  Subagent injection effort: ${data.injectionEffort ?? "(unset — inherits parent session)"}`,
+    "",
+    "Supported Codex reasoning effort ladder:",
+    ...CODEX_REASONING_LEVELS.map(l => `  - ${l.effort.padEnd(8)} ${l.description}`),
+  ];
+
+  printData(data, wantsJson, lines);
+}
+
+async function setEffort(
+  options: {
+    main?: string | null;
+    subagent?: string | null;
+    injection?: string | null;
+  },
+  wantsJson: boolean,
+  deps: RuntimeApiDeps,
+): Promise<void> {
+  const validatedMain = validateEffortLevel(options.main, "--main");
+  const validatedSubagent = validateEffortLevel(options.subagent, "--subagent");
+  const validatedInjection = validateEffortLevel(options.injection, "--injection");
+
+  if (validatedMain === undefined && validatedSubagent === undefined && validatedInjection === undefined) {
+    throw new CliUsageError("at least one effort option (--main, --subagent, or --injection) is required", EFFORT_USAGE);
+  }
+
+  // Probe live proxy BEFORE any mutation attempt
+  const liveFinder = deps.findLiveProxy ?? findLiveProxy;
+  const live = await liveFinder().catch(() => null);
+  const isLive = Boolean(live || deps.baseUrl);
+
+  if (isLive) {
+    // Live update path: once live proxy / baseUrl is selected, HTTP 4xx/5xx or transport
+    // errors must never fall through to silent offline config writes (#3528 review).
+    const capsBody: Record<string, unknown> = {};
+    if (validatedMain !== undefined) capsBody.effortCap = validatedMain;
+    if (validatedSubagent !== undefined) capsBody.subagentEffortCap = validatedSubagent;
+
+    let capsCommitted = false;
+    let injectionCommitted = false;
+
+    if (Object.keys(capsBody).length > 0) {
+      await runtimeRequest<EffortCapsResponse>("/api/effort-caps", {
+        method: "PUT",
+        body: JSON.stringify(capsBody),
+      }, deps);
+      capsCommitted = true;
+    }
+
+    if (validatedInjection !== undefined) {
+      try {
+        await runtimeRequest<InjectionResponse>("/api/injection-model", {
+          method: "PUT",
+          body: JSON.stringify({ effort: validatedInjection }),
+        }, deps);
+        injectionCommitted = true;
+      } catch (err) {
+        if (capsCommitted) {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          throw new Error(`effort caps were updated on live proxy, but injection effort failed: ${errMsg}`);
+        }
+        throw err;
+      }
+    }
+
+    // Accurately reflect live state: query fresh live status so unchanged caps are never serialized as null.
+    // If the read fails after a successful PUT, wrap with explicit partial-application error (#3528 review).
+    let finalStatus: { effortCap: string | null; subagentEffortCap: string | null; injectionEffort: string | null; efforts: string[] };
+    try {
+      finalStatus = await getLiveStatus(deps);
+    } catch (err) {
+      if (capsCommitted || injectionCommitted) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        throw new Error(`live state was updated, but verifying live status failed: ${errMsg}`);
+      }
+      throw err;
+    }
+
+    const result = {
+      ok: true,
+      effortCap: finalStatus.effortCap,
+      subagentEffortCap: finalStatus.subagentEffortCap,
+      injectionEffort: finalStatus.injectionEffort,
+      source: "runtime" as const,
+    };
+
+    printData(result, wantsJson, [
+      "Effort caps updated on live proxy:",
+      ...(validatedMain !== undefined ? [`  Main agent effort cap:     ${validatedMain ?? "(cleared)"}`] : []),
+      ...(validatedSubagent !== undefined ? [`  Subagent effort cap:       ${validatedSubagent ?? "(cleared)"}`] : []),
+      ...(validatedInjection !== undefined ? [`  Subagent injection effort: ${validatedInjection ?? "(cleared)"}`] : []),
+    ]);
+    return;
+  }
+
+  // Offline persistence path: only reached when no live proxy was found before mutation
+  const config = loadConfig();
+  if (validatedMain !== undefined) {
+    if (validatedMain === null) delete config.effortCap;
+    else config.effortCap = validatedMain;
+  }
+  if (validatedSubagent !== undefined) {
+    if (validatedSubagent === null) delete config.subagentEffortCap;
+    else config.subagentEffortCap = validatedSubagent;
+  }
+  if (validatedInjection !== undefined) {
+    if (validatedInjection === null) delete config.injectionEffort;
+    else config.injectionEffort = validatedInjection;
+  }
+  saveConfig(config);
+
+  const result = {
+    ok: true,
+    effortCap: config.effortCap ?? null,
+    subagentEffortCap: config.subagentEffortCap ?? null,
+    injectionEffort: config.injectionEffort ?? null,
+    source: "config" as const,
+  };
+
+  printData(result, wantsJson, [
+    "[offline] Effort caps updated in config.json (proxy is not running; changes will take effect on next start):",
+    ...(validatedMain !== undefined ? [`  Main agent effort cap:     ${validatedMain ?? "(cleared)"}`] : []),
+    ...(validatedSubagent !== undefined ? [`  Subagent effort cap:       ${validatedSubagent ?? "(cleared)"}`] : []),
+    ...(validatedInjection !== undefined ? [`  Subagent injection effort: ${validatedInjection ?? "(cleared)"}`] : []),
+  ]);
+}
+
+function inspectModelEffort(modelTarget: string, wantsJson: boolean): void {
+  // Reject leading or trailing slash selectors before lookup (#3528 review)
+  if (modelTarget.startsWith("/") || modelTarget.endsWith("/")) {
+    throw new CliUsageError(
+      `invalid model selector "${modelTarget}" (must be <provider/model> or <model> without leading or trailing slashes)`,
+      EFFORT_USAGE,
+    );
+  }
+
+  const config = loadConfig();
+  let providerName = "";
+  let modelId = modelTarget;
+
+  const slashIndex = modelTarget.indexOf("/");
+  if (slashIndex > 0) {
+    providerName = modelTarget.slice(0, slashIndex);
+    modelId = modelTarget.slice(slashIndex + 1);
+  } else {
+    providerName = config.defaultProvider || "openai";
+  }
+
+  const provider = config.providers[providerName];
+  if (!provider) {
+    throw new CliUsageError(
+      `Provider "${providerName}" is not configured. Configured providers: ${Object.keys(config.providers).join(", ")}`,
+      EFFORT_USAGE,
+    );
+  }
+
+  const isReasoningDisabled = modelInList(provider.noReasoningModels, modelId);
+  const efforts = configuredReasoningEfforts(provider, modelId);
+  const wireMap = reasoningEffortMapFor(provider, modelId);
+
+  // Derive sample ladder directly from canonical CODEX_REASONING_LEVELS (#3528 review)
+  const mappedExamples: Record<string, string | undefined> = {};
+  for (const { effort } of CODEX_REASONING_LEVELS) {
+    mappedExamples[effort] = mapReasoningEffort(provider, modelId, effort);
+  }
+
+  const result = {
+    provider: providerName,
+    model: modelId,
+    reasoningDisabled: isReasoningDisabled,
+    supportedEfforts: efforts ?? null,
+    wireMap: wireMap ?? null,
+    mappedTiers: mappedExamples,
+  };
+
+  const lines = [
+    `Reasoning effort configuration for ${providerName}/${modelId}:`,
+    `  Reasoning disabled: ${isReasoningDisabled ? "yes (noReasoningModels)" : "no"}`,
+    `  Supported ladder:   ${efforts ? efforts.join(", ") : "(default / unconstrained)"}`,
+    `  Wire mapping overrides: ${wireMap ? JSON.stringify(wireMap) : "(standard provider mapping)"}`,
+    "  Sample wire translations:",
+    ...Object.entries(mappedExamples).map(([req, wire]) => `    ${req.padEnd(8)} -> ${wire ?? "(omitted/unsupported)"}`),
+  ];
+
+  printData(result, wantsJson, lines);
+}
+
+export async function handleEffortCommand(argv: string[], deps: RuntimeApiDeps = {}): Promise<number> {
+  return runCliAction(async () => {
+    const args = [...argv];
+    const wantsJson = takeFlag(args, "--json");
+
+    if (args.length === 0) {
+      await status(wantsJson, deps);
+      return;
+    }
+
+    const rawFirst = args[0]!;
+    const first = rawFirst.toLowerCase();
+
+    if (first === "status") {
+      args.shift();
+      rejectArgs(args, EFFORT_USAGE);
+      await status(wantsJson, deps);
+      return;
+    }
+
+    if (first === "clear" || first === "unset") {
+      args.shift();
+      rejectArgs(args, EFFORT_USAGE);
+      await setEffort({ main: null, subagent: null }, wantsJson, deps);
+      return;
+    }
+
+    if (first === "set") {
+      args.shift();
+      const main = clearable(takeOption(args, "--main"));
+      const subagent = clearable(takeOption(args, "--subagent"));
+      const injection = clearable(takeOption(args, "--injection"));
+      rejectArgs(args, EFFORT_USAGE);
+      await setEffort({ main, subagent, injection }, wantsJson, deps);
+      return;
+    }
+
+    if (first === "model") {
+      args.shift();
+      const target = args.shift();
+      if (!target) throw new CliUsageError("model identifier (<provider/model> or <model>) is required", EFFORT_USAGE);
+      rejectArgs(args, EFFORT_USAGE);
+      inspectModelEffort(target, wantsJson);
+      return;
+    }
+
+    // Shorthand: check if first argument is an effort level or "-"
+    if (first === "-" || isDeclaredReasoningEffort(first)) {
+      args.shift();
+      rejectArgs(args, EFFORT_USAGE);
+      await setEffort({ main: first === "-" ? null : first }, wantsJson, deps);
+      return;
+    }
+
+    // Shorthand model inspection: preserve raw casing and check slash boundaries (#3528 review)
+    if (rawFirst.includes("/")) {
+      args.shift();
+      rejectArgs(args, EFFORT_USAGE);
+      inspectModelEffort(rawFirst, wantsJson);
+      return;
+    }
+
+    throw new CliUsageError(`unknown effort command or level "${rawFirst}"`, EFFORT_USAGE);
+  });
+}

package/src/cli/export-command.ts

@@ -68,13 +68,6 @@ type ExportProxyModelRow = OpencodeProxyModelRow & {
   defaultReasoningEffort?: string;
 };
 
-/** Same authoritativeness rule the serializers apply, for the degraded-count line. */
-function hasContextLimit(model: ExportModel): boolean {
-  return typeof model.contextWindow === "number"
-    && Number.isFinite(model.contextWindow)
-    && model.contextWindow > 0;
-}
-
 /**
  * Export rows from proxy `/api/models` rows.
  *
@@ -106,6 +99,7 @@ export function exportModelsFromProxyRows(
       id: entry.id ?? entry.namespaced,
     };
     if (entry.native) model.native = true;
+    if (entry.fastRowAvailable !== undefined) model.fastRowAvailable = entry.fastRowAvailable;
     if (entry.displayName) model.displayName = entry.displayName;
     if (entry.contextWindow !== undefined) model.contextWindow = entry.contextWindow;
     if (entry.reasoningEfforts && entry.reasoningEfforts.length > 0) {
@@ -195,7 +189,7 @@ export async function handleExportCommand(argv: string[], deps: ExportCommandDep
     // stderr, so `--json` stdout stays a standalone JSON document.
     if (out !== undefined && wantsJson) console.error(`Wrote ${out}`);
 
-    const degraded = models.filter(model => !hasContextLimit(model)).length;
+    const { modelCount, modelsWithoutLimits } = spec.summarize(clientConfig);
     // `--json` keeps emitting the DOCUMENT at the top level as JSON for scripts;
     // `--out` is the path that writes the selected client's native format.
     // Format metadata rides in the human lines below.
@@ -206,7 +200,7 @@ export async function handleExportCommand(argv: string[], deps: ExportCommandDep
       `Destination: ${spec.destination(process.env)}`,
       "Merge this generated configuration into that file; do not replace it.",
       `Before launching: ${spec.exportHint}`,
-      `${models.length} model${models.length === 1 ? "" : "s"}; ${degraded} omit context limits (the client applies its own defaults).`,
+      `${modelCount} model${modelCount === 1 ? "" : "s"}; ${modelsWithoutLimits} omit context limits (the client applies its own defaults).`,
     ]);
   });
 }

package/src/cli/help.ts

@@ -66,6 +66,7 @@ Usage:
   ocx alias <sub>             Short names for providers and models (list, set, rm, defaults)
   ocx combo <sub>             Combo routing strategies and failover
   ocx agent <sub>             Subagents, injection, effort caps, and sidecars
+  ocx effort [sub]            Inspect and configure reasoning effort caps and defaults
   ocx observe <sub>           Logs, usage, storage, memory, and debug data
   ocx inspect <sub>           Effective config, catalog, analytics, pacing, client-config
   ocx route <sub>             Routing features (combo, policy)

package/src/cli/index.ts

@@ -1,5 +1,18 @@
 #!/usr/bin/env bun
 import { spawn } from "node:child_process";
+import { homedir } from "node:os";
+
+// Best-effort recovery for runtime execution and spawned children if launched
+// from an unlinked/deleted working directory (runs after hoisted ESM module imports).
+try {
+  process.cwd();
+} catch {
+  try {
+    process.chdir(homedir());
+  } catch {
+    /* best-effort */
+  }
+}
 import { currentExternalCodexModelProvider, restoreNativeCodex, restoreNativeCodexAsync, shouldInjectApiAuthHeader } from "../codex/inject";
 import { stripGrokConfig } from "../grok/inject";
 import { STOP_HISTORY_INCOMPLETE_EXIT_CODE } from "../update/stop-contract.mjs";

package/src/cli/init.ts

@@ -1,4 +1,6 @@
 import * as readline from "node:readline";
+import { modelSelectionGuidance } from "./model-selection-guidance";
+import { initializeProviderModelSelection } from "../providers/initial-model-selection";
 import { existsSync, readFileSync, unlinkSync } from "node:fs";
 import { injectCodexConfig } from "../codex/inject";
 import { classifyOpenAiTierBackup, getConfigPath, getDefaultConfig, isValidProviderName, preserveOpenAiTierRollbackSnapshot, saveConfig } from "../config";
@@ -160,6 +162,7 @@ export async function runInit(): Promise<void> {
     const portStr = await prompt.ask("\nProxy port [10100]: ");
     const port = parseInt(portStr, 10) || 10100;
 
+    initializeProviderModelSelection(providerName, providerConfig);
     const config: OcxConfig = {
       ...getDefaultConfig(),
       port,
@@ -198,6 +201,7 @@ export async function runInit(): Promise<void> {
     }
 
     console.log(`\n🚀 Setup complete! Run 'ocx start' to start the proxy.`);
+    for (const line of modelSelectionGuidance(providerName)) console.log(line);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     if (/stdin (closed|reached EOF)/i.test(message)) {

package/src/cli/model-selection-guidance.ts

@@ -0,0 +1,30 @@
+/** Existing model-management commands; use the exact ID from `live`, including native IDs. */
+export function modelSelectionNextSteps(provider: string, afterLogin = false) {
+  const name = provider === "codex" || provider === "chatgpt" ? "openai" : provider;
+  return {
+    provider: name,
+    afterLogin,
+    requiresRunningProxy: true,
+    commands: {
+      list: `ocx models live --provider ${name}`,
+      enable: 'ocx models enable "<model-id-from-list>"',
+      disable: 'ocx models disable "<model-id-from-list>"',
+      enableNative: 'ocx models enable "<model-id-from-list>" --native',
+      disableNative: 'ocx models disable "<model-id-from-list>" --native',
+      enableAll: `ocx models provider ${name} on`,
+      disableAll: `ocx models provider ${name} off`,
+    },
+  };
+}
+
+export function modelSelectionGuidance(provider: string, afterLogin = false): string[] {
+  const next = modelSelectionNextSteps(provider, afterLogin);
+  return [
+    afterLogin ? "After login completes, manage model switches with:" : "Manage model switches (the provider stays active):",
+    "  Start the proxy first if needed: ocx start",
+    "  Replace <model-id-from-list> with an exact ID printed by the list command.",
+    "  For rows marked native, use the --native variants (including IDs containing /).",
+    ...Object.values(next.commands).map(command => `  ${command}`),
+    "  If initial discovery is still pending, check the provider connection and retry: ocx sync",
+  ];
+}

package/src/cli/models-runtime.ts

@@ -36,6 +36,7 @@ type ModelRow = {
   namespaced?: string;
   native?: boolean;
   disabled?: boolean;
+  initialSelectionPending?: boolean;
   custom?: boolean;
   customId?: string;
   displayName?: string;
@@ -49,7 +50,7 @@ async function live(argv: string[], deps: RuntimeApiDeps): Promise<void> {
   const rows = await runtimeRequest<ModelRow[]>("/api/models", {}, deps);
   const filtered = provider ? rows.filter(row => row.provider === provider) : rows;
   printData(filtered, wantsJson, filtered.map(row => {
-    const flags = [row.native ? "native" : "routed", row.custom ? "custom" : "", row.disabled ? "disabled" : "enabled"].filter(Boolean);
+    const flags = [row.native ? "native" : "routed", row.custom ? "custom" : "", row.initialSelectionPending ? "initial discovery pending" : row.disabled ? "disabled" : "enabled"].filter(Boolean);
     return `${row.namespaced ?? `${row.provider}/${row.id}`}  [${flags.join(", ")}]`;
   }));
 }
@@ -323,7 +324,7 @@ async function shadow(argv: string[], deps: RuntimeApiDeps): Promise<void> {
 
 export async function handleModelsRuntimeCommand(sub: string, argv: string[], deps: RuntimeApiDeps = {}): Promise<number | null> {
   // The dispatch below and MODELS_RUNTIME_SUBCOMMANDS must name the same set;
-  // tests/cli-models-runtime-dispatch.test.ts fails if they drift (#3094).
+  // tests/cli/cli-models-runtime-dispatch.test.ts fails if they drift (#3094).
   if (!isModelsRuntimeSubcommand(sub)) return null;
   let action: (() => Promise<void>) | undefined;
   if (sub === "live") action = () => live(argv, deps);

package/src/cli/models.ts

@@ -4,6 +4,7 @@
 import { randomUUID } from "node:crypto";
 import { createInterface } from "node:readline/promises";
 import { syncModelsToCodex } from "../codex/sync";
+import { configuredContextWindow } from "../codex/catalog/provider-fetch";
 import { hasOwnProvider, isValidProviderName, loadConfig, saveConfig } from "../config";
 import {
   canonicalizeReasoningEfforts,
@@ -86,6 +87,11 @@ interface ModelEntry {
   reasoningEfforts: string[] | null;
 }
 
+/**
+ * Collect static configured models for all providers or one selected provider.
+ * Keep each provider's default model first and resolve metadata through shared helpers.
+ * Live-discovered models are not fetched by this listing.
+ */
 function collectModels(config: OcxConfig, providerFilter?: string): ModelEntry[] {
   const entries: ModelEntry[] = [];
   const providers = providerFilter
@@ -95,10 +101,9 @@ function collectModels(config: OcxConfig, providerFilter?: string): ModelEntry[]
   for (const [provName, prov] of Object.entries(providers)) {
     if (!prov) continue;
     const seen = new Set<string>();
-    const contextWindows = prov.modelContextWindows ?? {};
     const inputModalities = prov.modelInputModalities ?? {};
-    const globalContext = prov.contextWindow ?? null;
 
+    /** Append one model with resolved metadata, ignoring duplicates within this provider. */
     const addModel = (model: string, isDefault: boolean) => {
       if (seen.has(model)) return;
       seen.add(model);
@@ -124,7 +129,7 @@ function collectModels(config: OcxConfig, providerFilter?: string): ModelEntry[]
         provider: provName,
         model,
         isDefault,
-        contextWindow: modelRecordValue(contextWindows, model) ?? globalContext,
+        contextWindow: configuredContextWindow(prov, model) ?? null,
         inputModalities: modalities,
         reasoningEfforts: efforts,
       });

package/src/cli/opencode.ts

@@ -88,6 +88,8 @@ export interface OpencodeRoutedModel {
 
 /** Row shape from authenticated GET /api/models on the running proxy. */
 export interface OpencodeProxyModelRow {
+  /** Hub-resolved availability, independent of the launcher's local Fast setting. */
+  fastRowAvailable?: boolean;
   provider?: string;
   id?: string;
   namespaced?: string;
@@ -389,6 +391,7 @@ export function opencodeCatalogFromProxyRows(
       id: row.id,
       contextWindow: row.contextWindow,
       displayName: row.displayNameSource === "fallback" ? undefined : row.displayName,
+      ...(typeof row.fastRowAvailable === "boolean" ? { fastRowAvailable: row.fastRowAvailable } : {}),
       ...(Array.isArray(row.reasoningEfforts) && row.reasoningEfforts.length > 0
         ? { reasoningEfforts: [...row.reasoningEfforts] }
         : {}),
@@ -648,7 +651,7 @@ export async function cmdOpencode(args: string[]): Promise<number> {
   const catalog = opencodeCatalogFromProxyRows(proxyModels, config);
   const blocks = buildOpencodeProviderBlocksFromCatalog(live.port, catalog, live.hostname, config);
   const baseUrl = blocks.v1.options.baseURL;
-  const modelCount = catalog.length;
+  const modelCount = Object.keys(blocks.v1.models).length;
   console.error(`✅ opencode wired to ${baseUrl} — ${modelCount} model(s) under provider \`${OPENCODE_PROVIDER_ID}\`.`);
   console.error("   Your existing opencode config files are left untouched; only the runtime provider blocks are injected.");
   const providerOverride = opencodeProviderOverridePath(process.cwd());