dsh-opencode-go 0.1.10 → 0.1.12

package/lib/index.js

@@ -706,6 +706,11 @@ import { openAIResponsesApi } from "@earendil-works/pi-ai/api/openai-responses.l
 import { attributionHeaders, LlmError as LlmError5 } from "@deepseek-ai/dsh-llm";
 
 // src/models-contract.ts
+function isModelEnabled(model, modelVisibility) {
+  if (model.configurationMissing) return false;
+  const enabled = modelVisibility && Object.hasOwn(modelVisibility, model.id) ? modelVisibility[model.id] : void 0;
+  return typeof enabled === "boolean" ? enabled : !model.deprecated;
+}
 function validReleaseDate(value) {
   return typeof value === "string" && /^\d{4}-\d{2}-\d{2}$/.test(value) && Number.isFinite(Date.parse(value)) && new Date(value).toISOString().slice(0, 10) === value;
 }
@@ -730,15 +735,28 @@ function parseGoModels(value) {
       if (typeof row[key] === "number" && Number.isSafeInteger(row[key]) && row[key] > 0) model[key] = row[key];
     }
     if (typeof row.deprecated === "boolean") model.deprecated = row.deprecated;
+    if (typeof row.configurationMissing === "boolean") model.configurationMissing = row.configurationMissing;
     if (validReleaseDate(row.releaseDate)) model.releaseDate = row.releaseDate;
     return model;
   });
 }
+function parseGoModelCatalog(value) {
+  if (!value || typeof value !== "object") throw new Error("Invalid OpenCode Go model catalog");
+  const catalog = value;
+  if (typeof catalog.stale !== "boolean" || catalog.error !== void 0 && typeof catalog.error !== "string") {
+    throw new Error("Invalid OpenCode Go model catalog status");
+  }
+  return {
+    models: parseGoModels(catalog.models),
+    stale: catalog.stale,
+    ...catalog.error === void 0 ? {} : { error: catalog.error }
+  };
+}
 var codec = {
   mode: "strict",
-  typeSymbol: "dsh-opencode-go#GoModels",
-  schema: { parse: parseGoModels },
-  create: () => ({ parse: parseGoModels })
+  typeSymbol: "dsh-opencode-go#GoModelCatalog",
+  schema: { parse: parseGoModelCatalog },
+  create: () => ({ parse: parseGoModelCatalog })
 };
 var modelsRemote = {
   package: "dsh-opencode-go",
@@ -859,13 +877,66 @@ function readModelMetadata(body, baseURL, builtin) {
 }
 
 // src/json-response.ts
-import { promisify } from "node:util";
-import { brotliDecompress, gunzip, inflate } from "node:zlib";
-var decoders = [
-  { name: "Brotli", decode: promisify(brotliDecompress) },
-  { name: "gzip", decode: promisify(gunzip) },
-  { name: "deflate", decode: promisify(inflate) }
-];
+import { setTimeout as delay } from "node:timers/promises";
+var RETRYABLE_CODES = /* @__PURE__ */ new Set(["ECONNRESET", "EPIPE", "UND_ERR_SOCKET", "EAI_AGAIN"]);
+function errorCauses(error) {
+  const causes = [];
+  for (let depth = 0; depth < 5 && error !== null && typeof error === "object"; depth += 1) {
+    causes.push(error);
+    error = "cause" in error ? error.cause : void 0;
+  }
+  return causes;
+}
+function retryableTransportFailure(error) {
+  if (error instanceof SyntaxError || error instanceof RangeError) return false;
+  for (const cause of errorCauses(error)) {
+    if (cause instanceof Error && (cause.name === "TimeoutError" || cause.name === "AbortError")) return false;
+    if ("code" in cause && typeof cause.code === "string") return RETRYABLE_CODES.has(cause.code);
+  }
+  return false;
+}
+function transportFailure(error) {
+  const causes = errorCauses(error);
+  if (causes.some((cause) => cause instanceof Error && (cause.name === "TimeoutError" || cause.name === "AbortError"))) {
+    return "request timed out or was aborted";
+  }
+  for (const cause of causes) {
+    if ("code" in cause && typeof cause.code === "string" && /^[A-Z][A-Z0-9_]+$/.test(cause.code)) {
+      return `network error (${cause.code})`;
+    }
+  }
+  return "network request failed";
+}
+function diagnosticURL(raw) {
+  const url = new URL(raw);
+  url.username = "";
+  url.password = "";
+  url.search = "";
+  url.hash = "";
+  return url.href;
+}
+async function fetchJsonResponse(url, init, maxBytes) {
+  if ((init.method ?? "GET").toUpperCase() !== "GET") throw new TypeError("JSON requests must use GET");
+  const headers = new Headers(init.headers);
+  headers.set("accept-encoding", "identity");
+  const options = { ...init, method: "GET", headers };
+  for (let attempt = 0; ; attempt += 1) {
+    init.signal?.throwIfAborted();
+    try {
+      const response = await fetch(url, options);
+      if (!response.ok) {
+        await response.body?.cancel().catch(() => {
+        });
+        return { response, body: void 0 };
+      }
+      return { response, body: await readJsonResponse(response, maxBytes) };
+    } catch (error) {
+      init.signal?.throwIfAborted();
+      if (attempt > 0 || !retryableTransportFailure(error)) throw error;
+      await delay(150, void 0, { signal: init.signal ?? void 0 });
+    }
+  }
+}
 async function readBoundedBody(response, maxBytes) {
   if (response.body === null) return Buffer.alloc(0);
   const reader = response.body.getReader();
@@ -890,24 +961,11 @@ async function readBoundedBody(response, maxBytes) {
 }
 async function readJsonResponse(response, maxBytes) {
   const bytes = await readBoundedBody(response, maxBytes);
-  const parse = (data) => JSON.parse(new TextDecoder().decode(data));
-  const errors = [];
   try {
-    return parse(bytes);
+    return JSON.parse(new TextDecoder().decode(bytes));
   } catch (error) {
-    errors.push(error);
-  }
-  for (const { name: name2, decode } of decoders) {
-    try {
-      return parse(await decode(bytes, { maxOutputLength: maxBytes }));
-    } catch (error) {
-      if (error instanceof Error && "code" in error && error.code === "ERR_BUFFER_TOO_LARGE") {
-        throw new RangeError(`${name2} decoded response exceeds ${maxBytes} byte limit`, { cause: error });
-      }
-      errors.push(new Error(`${name2} response decoding or JSON parsing failed`, { cause: error }));
-    }
+    throw new SyntaxError("Response is not valid JSON", { cause: error });
   }
-  throw new AggregateError(errors, "Response is not valid JSON, including after Brotli, gzip, or deflate decoding");
 }
 
 // src/catalog.ts
@@ -936,19 +994,27 @@ function readLiveModelIds(body) {
 }
 async function fetchLiveModelIds(baseURL) {
   const url = `${baseURL.replace(/\/+$/, "")}/models`;
-  let response;
+  const endpoint = diagnosticURL(url);
+  let result;
   try {
-    response = await fetch(url, {
+    result = await fetchJsonResponse(url, {
       method: "GET",
       cache: "no-cache",
-      headers: { accept: "application/json", ...attributionHeaders() },
+      headers: { ...attributionHeaders(), accept: "application/json" },
       signal: AbortSignal.timeout(MODELS_FETCH_TIMEOUT_MS)
-    });
+    }, MODEL_LISTING_MAX_BYTES);
+  } catch (error) {
+    const detail = error instanceof SyntaxError ? "invalid JSON response" : error instanceof RangeError ? `response exceeds the ${MODEL_LISTING_MAX_BYTES} byte limit` : transportFailure(error);
+    const action = error instanceof SyntaxError || error instanceof RangeError ? "read" : "reach";
+    throw new LlmError5(`could not ${action} ${endpoint}: ${detail}`, "DISCOVERY_FAILED", { cause: error });
+  }
+  const { response, body } = result;
+  if (!response.ok) throw new LlmError5(`${endpoint} answered HTTP ${response.status}`, "DISCOVERY_FAILED");
+  try {
+    return readLiveModelIds(body);
   } catch (error) {
-    throw new LlmError5(`could not reach ${url}`, "DISCOVERY_FAILED", { cause: error });
+    throw new LlmError5(`${endpoint} returned an invalid model listing: expected a "data" array`, "DISCOVERY_FAILED", { cause: error });
   }
-  if (!response.ok) throw new LlmError5(`${url} answered ${response.status}`, "DISCOVERY_FAILED");
-  return readLiveModelIds(await readJsonResponse(response, MODEL_LISTING_MAX_BYTES));
 }
 function harnessApiKeyAuth() {
   return { apiKey: {
@@ -995,18 +1061,18 @@ var OpencodeGoCatalog = class {
   }
   /** Conditional HTTP requests save bandwidth while still checking for updated metadata. */
   async refreshMetadata(builtin) {
-    const response = await fetch(MODEL_METADATA_URL, {
+    const { response, body } = await fetchJsonResponse(MODEL_METADATA_URL, {
       headers: {
-        accept: "application/json",
         ...attributionHeaders(),
+        accept: "application/json",
         ...this.metadataETag === void 0 ? {} : { "if-none-match": this.metadataETag }
       },
       cache: "no-cache",
       signal: AbortSignal.timeout(MODELS_FETCH_TIMEOUT_MS)
-    });
+    }, MODEL_METADATA_MAX_BYTES);
     if (response.status === 304 && this.metadata !== void 0) return this.metadata;
     if (!response.ok) throw new Error(`models.dev answered ${response.status}`);
-    const metadata = readModelMetadata(await readJsonResponse(response, MODEL_METADATA_MAX_BYTES), this.baseURL, builtin);
+    const metadata = readModelMetadata(body, this.baseURL, builtin);
     this.metadata = metadata;
     this.metadataETag = response.headers.get("etag") ?? void 0;
     return metadata;
@@ -1032,7 +1098,8 @@ var OpencodeGoCatalog = class {
         unavailable: this.served?.unavailable ?? /* @__PURE__ */ new Map(),
         provider: buildProvider(this.baseURL, [...models2.values()]),
         live: false,
-        fetchedAtMs: Date.now()
+        fetchedAtMs: Date.now(),
+        listingFailure: listing.reason
       };
     }
     const models = /* @__PURE__ */ new Map();
@@ -1041,7 +1108,7 @@ var OpencodeGoCatalog = class {
       const error = metadata?.errors.get(id);
       const model = known.get(id);
       if (error !== void 0 || model === void 0) {
-        unavailable.set(id, error ?? "model metadata has not been published on models.dev yet");
+        unavailable.set(id, error ?? "no usable configuration was found for this OpenCode Go model");
       } else {
         models.set(id, model);
       }
@@ -1072,26 +1139,41 @@ var OpencodeGoCatalog = class {
 };
 async function discoverCatalogModels(catalog) {
   const snapshot = await catalog.snapshot(true);
-  if (!snapshot.live) {
-    throw new LlmError5("llm-opencode-go: the live model listing is unreachable; try again later", "DISCOVERY_FAILED");
-  }
+  requireLiveListing(snapshot);
   return describeCatalog(snapshot);
 }
+function requireLiveListing(snapshot) {
+  if (snapshot.live) return;
+  throw listingError(snapshot);
+}
+function listingError(snapshot) {
+  const detail = snapshot.listingFailure instanceof LlmError5 ? snapshot.listingFailure.message : "the live model listing is unreachable";
+  return new LlmError5(`llm-opencode-go: ${detail}; refresh the model list to retry`, "DISCOVERY_FAILED", { cause: snapshot.listingFailure });
+}
+function describeConfiguredModels(snapshot) {
+  return [...snapshot.models.values()].map((model) => ({
+    id: model.id,
+    name: model.name,
+    contextWindow: model.contextWindow,
+    maxTokens: model.maxTokens
+  }));
+}
 function describeCatalog(snapshot) {
   return [
-    ...[...snapshot.models.values()].map((model) => ({
-      id: model.id,
-      name: model.name,
-      contextWindow: model.contextWindow,
-      maxTokens: model.maxTokens
-    })),
+    ...describeConfiguredModels(snapshot),
     ...[...snapshot.unavailable].map(([id, reason]) => ({ id, name: `${id} (metadata unavailable: ${reason})` }))
   ];
 }
 async function discoverSettingsModels(catalog) {
   const snapshot = await catalog.snapshot(true);
-  if (!snapshot.live) throw new LlmError5("llm-opencode-go: the live model listing is unreachable; try again later", "DISCOVERY_FAILED");
-  return sortModels(describeCatalog(snapshot).map((model) => ({ ...model, ...snapshot.details.get(model.id) })));
+  return {
+    models: sortModels([
+      ...describeConfiguredModels(snapshot),
+      ...[...snapshot.unavailable.keys()].map((id) => ({ id, name: id, configurationMissing: true }))
+    ].map((model) => ({ ...model, ...snapshot.details.get(model.id) }))),
+    stale: !snapshot.live,
+    ...snapshot.live ? {} : { error: listingError(snapshot).message }
+  };
 }
 
 // src/config.ts
@@ -1102,7 +1184,7 @@ var DEFAULT_REFRESH_MINUTES = 60;
 var DEFAULT_STREAM_IDLE_TIMEOUT_MS = 3e5;
 var fields = {
   enabled: z.boolean().default(true),
-  showDeprecatedModels: z.boolean().default(false),
+  modelVisibility: z.dict(z.boolean().required()).default({}),
   apiKeyEnv: z.string().role("credential-ref").default(DEFAULT_API_KEY_ENV),
   baseURL: z.string().default(DEFAULT_BASE_URL),
   refreshMinutes: z.number().step(1).min(1).max(7 * 24 * 60).default(DEFAULT_REFRESH_MINUTES),
@@ -1123,7 +1205,7 @@ var Config = z.object(Object.fromEntries(
   Object.entries(fields).map(([key, schema]) => [key, schema.volatile()])
 ));
 function readConfig(config) {
-  return Object.fromEntries(Object.entries(config).map(([key, value]) => [key, value.get()]));
+  return Object.fromEntries(Object.keys(fields).map((key) => [key, config[key].get()]));
 }
 function assertBaseURL(raw) {
   let url;
@@ -1198,8 +1280,8 @@ var OpencodeGoAdapter = class extends LlmAdapter {
   }
   async listModels(_provider) {
     const config = this.options.config();
-    const snapshot = await this.catalogOf(config).snapshot(true);
-    return [...snapshot.models.values()].filter((model) => config.showDeprecatedModels || !snapshot.details.get(model.id)?.deprecated).map((model) => ({
+    const snapshot = await this.catalogOf(config).snapshot();
+    return [...snapshot.models.values()].filter((model) => isModelEnabled({ id: model.id, ...snapshot.details.get(model.id) }, config.modelVisibility)).map((model) => ({
       provider: PROVIDER_ID,
       id: model.id,
       name: model.name,
@@ -1354,7 +1436,8 @@ var OpencodeGoAdapter = class extends LlmAdapter {
 };
 
 // src/usage.ts
-import { TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { RemoteError, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
 import { attributionHeaders as attributionHeaders3 } from "@deepseek-ai/dsh-llm";
 
 // src/usage-contract.ts
@@ -1362,6 +1445,12 @@ function parseGoUsage(value) {
   if (!value || typeof value !== "object") throw new Error("Invalid OpenCode Go usage response");
   const source = value;
   const result = {};
+  if (source.source !== void 0) {
+    if (typeof source.source !== "string" || source.source.length === 0 || source.source.length > 128) {
+      throw new Error("Invalid OpenCode Go usage source");
+    }
+    result.source = source.source;
+  }
   for (const key of ["rolling", "weekly", "monthly"]) {
     const row = source[key];
     if (!row || row.status !== "ok" && row.status !== "rate-limited" || typeof row.percent !== "number" || !Number.isFinite(row.percent) || row.percent < 0 || typeof row.resetsAt !== "string" || !Number.isFinite(Date.parse(row.resetsAt))) {
@@ -1391,23 +1480,73 @@ var usageRemote = {
 };
 
 // src/usage.ts
+var USAGE_MAX_BYTES = 1024 * 1024;
 var GoUsageService = class extends TypertRemoteService {
   constructor(ctx, options) {
     super(ctx, "opencodeGoUsage");
     this.options = options;
   }
+  identity;
   async read() {
     const baseURL = assertBaseURL(this.options.baseURL()).replace(/\/$/, "");
-    const key = await this.options.resolveApiKey();
-    if (!key) throw new Error("OpenCode Go API key is not configured");
-    const response = await fetch(`${baseURL}/usage`, {
-      headers: { ...attributionHeaders3(), Authorization: `Bearer ${key}`, Accept: "application/json" },
-      signal: AbortSignal.timeout(1e4),
-      redirect: "error"
-    });
-    if (!response.ok) throw new Error(`OpenCode Go usage unavailable (HTTP ${response.status})`);
-    const body = await response.json();
-    return parseGoUsage(body && typeof body === "object" ? body.usage : void 0);
+    let key;
+    try {
+      key = await this.options.resolveApiKey();
+    } catch (error) {
+      this.identity = void 0;
+      const missing = error instanceof Error && "code" in error && error.code === "MISSING_CREDENTIAL";
+      throw new RemoteError("opencode-go/usage-unavailable", missing ? "OpenCode Go API key is not configured" : "Could not resolve the OpenCode Go API key", {
+        retryable: !missing,
+        retainPrevious: false
+      }, { cause: error });
+    }
+    if (!key) {
+      this.identity = void 0;
+      throw new RemoteError("opencode-go/usage-unavailable", "OpenCode Go API key is not configured", {
+        retryable: false,
+        retainPrevious: false
+      });
+    }
+    if (this.identity?.baseURL !== baseURL || this.identity.key !== key) {
+      this.identity = { baseURL, key, source: randomUUID2() };
+    }
+    const { source } = this.identity;
+    const endpoint = diagnosticURL(`${baseURL}/usage`);
+    let result;
+    try {
+      result = await fetchJsonResponse(`${baseURL}/usage`, {
+        headers: { ...attributionHeaders3(), Authorization: `Bearer ${key}`, Accept: "application/json" },
+        signal: AbortSignal.timeout(1e4),
+        redirect: "error"
+      }, USAGE_MAX_BYTES);
+    } catch (error) {
+      const invalid = error instanceof SyntaxError || error instanceof RangeError;
+      const detail = error instanceof SyntaxError ? "invalid JSON response" : error instanceof RangeError ? `response exceeds the ${USAGE_MAX_BYTES} byte limit` : transportFailure(error);
+      throw new RemoteError("opencode-go/usage-unavailable", `Could not read ${endpoint}: ${detail}`, {
+        retryable: true,
+        retainPrevious: !invalid,
+        source
+      }, { cause: error });
+    }
+    const { response, body } = result;
+    if (!response.ok) {
+      const temporary = response.status === 408 || response.status === 429 || response.status >= 500;
+      throw new RemoteError("opencode-go/usage-unavailable", `OpenCode Go usage unavailable (HTTP ${response.status})`, {
+        retryable: temporary,
+        retainPrevious: temporary,
+        source
+      });
+    }
+    try {
+      const usage = parseGoUsage(body && typeof body === "object" ? body.usage : void 0);
+      return { ...usage, source };
+    } catch (error) {
+      throw new RemoteError("opencode-go/usage-unavailable", "Invalid OpenCode Go usage response", {
+        retryable: true,
+        retainPrevious: false,
+        source
+      }, { cause: error });
+    }
   }
 };
 
@@ -1418,8 +1557,12 @@ var GoModelsService = class extends TypertRemoteService2 {
     super(ctx, "opencodeGoModels");
     this.options = options;
   }
-  read() {
-    return discoverSettingsModels(this.options.catalog());
+  async read() {
+    try {
+      return await discoverSettingsModels(this.options.catalog());
+    } finally {
+      this.options.onRefresh?.();
+    }
   }
 };
 
@@ -1488,9 +1631,15 @@ function apply(ctx, raw) {
       ctx.logger.warn(`llm-opencode-go: unusable replay state on assistant history; sending provider-neutral content (${reason})`);
     }
   });
-  ctx.plugin(GoModelsService, { catalog: () => adapter.catalogOf(current()) });
-  let pickerVisibility = current().showDeprecatedModels;
   let registration;
+  ctx.plugin(GoModelsService, {
+    catalog: () => adapter.catalogOf(current()),
+    onRefresh: () => {
+      registration?.replace([PROVIDER_ID]);
+    }
+  });
+  const pickerVisibilityOf = () => JSON.stringify(current().modelVisibility ?? {});
+  let pickerVisibility = pickerVisibilityOf();
   const applyRoute = (configured) => {
     if (configured && current().enabled && registration === void 0) {
       try {
@@ -1507,8 +1656,9 @@ function apply(ctx, raw) {
     }
   };
   const syncRoute = () => {
-    if (pickerVisibility !== current().showDeprecatedModels) {
-      pickerVisibility = current().showDeprecatedModels;
+    const visibility = pickerVisibilityOf();
+    if (pickerVisibility !== visibility) {
+      pickerVisibility = visibility;
       registration?.replace([PROVIDER_ID]);
     }
     const credentials = ctx.get("credentials");

package/lib/types/catalog.d.ts

@@ -1,6 +1,6 @@
 import type { Api, Model, Provider } from '@earendil-works/pi-ai';
 import type { LlmDiscoveredModel } from '@deepseek-ai/dsh-llm';
-import { type GoModel } from './models-contract.ts';
+import { type GoModelCatalog } from './models-contract.ts';
 import type { ModelMetadata } from './model-metadata.ts';
 export declare const PROVIDER_ID = "opencode-go";
 export declare const DISPLAY_NAME = "OpenCode Go";
@@ -12,6 +12,8 @@ export interface CatalogSnapshot {
     readonly unavailable: ReadonlyMap<string, string>;
     readonly provider: Provider;
     readonly live: boolean;
+    /** Retained for explicit discovery; runtime callers may still use the last catalog. */
+    readonly listingFailure?: unknown;
     readonly fetchedAtMs: number;
 }
 /** A valid empty listing means the gateway serves nothing; malformed replies are failures. */
@@ -44,5 +46,5 @@ export declare class OpencodeGoCatalog {
 }
 /** Explicit discovery always revalidates both sources, including during the runtime TTL. */
 export declare function discoverCatalogModels(catalog: OpencodeGoCatalog): Promise<readonly LlmDiscoveredModel[]>;
-/** Settings retain deprecated gateway entries regardless of picker visibility. */
-export declare function discoverSettingsModels(catalog: OpencodeGoCatalog): Promise<readonly GoModel[]>;
+/** Settings expose the same retained catalog as requests, with a failed-refresh diagnostic. */
+export declare function discoverSettingsModels(catalog: OpencodeGoCatalog): Promise<GoModelCatalog>;

package/lib/types/client/ModelEditor.d.ts

@@ -2,12 +2,16 @@ import type { OpencodeGoModelLimit, OpencodeGoModelLimits, OpencodeGoModels } fr
 import type { en } from './locales.ts';
 type Translate = (key: keyof typeof en, params?: Record<string, unknown>) => string;
 export declare function hasCapacityOverride(limit: OpencodeGoModelLimit | null | undefined): boolean;
-/** One gateway-backed list and its selected model's staged capacity settings. */
-export declare function ModelEditor({ models, draft, t, disabled, onEdit }: {
+/** Per-model switches apply immediately; capacity edits stay in the staged form. */
+export declare function ModelEditor({ models, draft, modelVisibility, t, locale, disabled, visibilitySaving, onEdit, onModelEnabled }: {
     models: OpencodeGoModels;
     draft: OpencodeGoModelLimits;
+    modelVisibility: Readonly<Record<string, boolean>>;
     t: Translate;
+    locale?: string;
     disabled: boolean;
+    visibilitySaving: boolean;
     onEdit: (next: OpencodeGoModelLimits) => void;
+    onModelEnabled: (id: string, enabled: boolean) => void;
 }): import("react").JSX.Element;
 export {};

package/lib/types/client/Section.d.ts

@@ -15,6 +15,8 @@ type SectionTranslate = (key: keyof typeof en, params?: Record<string, unknown>)
 export interface OpencodeGoSectionInjected extends OpencodeGoSectionFace {
     /** Section copy. */
     t: SectionTranslate;
+    /** Read at render time because the Host caches injected values across locale changes. */
+    getLocale?: () => string;
 }
 /** Props delivered by the slot outlet: the inject face spread flat. */
 export type OpencodeGoSectionProps = Partial<InjectFace<OpencodeGoSectionInjected>>;

package/lib/types/client/UsagePill.d.ts

@@ -5,6 +5,7 @@ export interface UsagePillProps {
     directory: SnapshotStore<ModelDirectoryState>;
     readUsage: () => Promise<GoUsage>;
     t: (key: string) => string;
+    getLocale?: () => string;
 }
 /** Only the selected Go provider mounts a poller, so other models send no usage traffic. */
 export declare function UsagePill({ directory, ...props }: UsagePillProps): import("react").JSX.Element | null;

package/lib/types/client/locales.d.ts

@@ -1,6 +1,7 @@
 /** Copy dictionaries for the OpenCode Go settings page. English is the key-set source of truth. */
 export declare const en: {
     usageTitle: string;
+    usageRollingShort: string;
     usageHint: string;
     usageWeekShort: string;
     usage_rolling: string;
@@ -10,6 +11,12 @@ export declare const en: {
     usageLimited: string;
     usageLoading: string;
     usageUnavailable: string;
+    usageStaleShort: string;
+    usageStaleHint: string;
+    usageRefreshFailed: string;
+    usageLastUpdated: string;
+    usageRetry: string;
+    usageRefreshing: string;
     nav: string;
     title: string;
     intro: string;
@@ -26,6 +33,8 @@ export declare const en: {
     modelsRefresh: string;
     modelsLoading: string;
     modelsFailed: string;
+    modelsStale: string;
+    modelsRefreshing: string;
     modelsEmpty: string;
     modelsCount: string;
     limitsLabel: string;
@@ -38,12 +47,15 @@ export declare const en: {
     limitsOutput: string;
     capacityDefault: string;
     capacityMissing: string;
-    showDeprecatedLabel: string;
-    showDeprecatedHint: string;
+    visibilityHint: string;
+    modelVisibleLabel: string;
+    configurationMissing: string;
+    configurationMissingHint: string;
     pickerFailed: string;
     deprecatedBadge: string;
     deprecatedHint: string;
     newHint: string;
+    newBadge: string;
     releasedOn: string;
     releaseSource: string;
     modelDetails: string;

package/lib/types/client/section-controller.d.ts

@@ -10,7 +10,7 @@
  */
 import type { Context as ClientContext } from '@deepseek-ai/cordis';
 import type { RemoteResult } from '@deepseek-ai/dsh-typert-protocol';
-import type { GoModel } from '../models-contract.ts';
+import type { GoModel, GoModelCatalog } from '../models-contract.ts';
 import type { SnapshotStore } from '@deepseek-ai/dsh-client-store';
 import type { SettingsScope } from './settings.ts';
 import { type FieldState, type FormActions, type FormShell } from './staged-form.ts';
@@ -20,8 +20,8 @@ export declare const OPENCODE_GO_NS = "llm-opencode-go";
 export interface OpencodeGoSettings {
     /** Whether the adapter serves its route; false withdraws it from every picker. */
     enabled?: boolean;
-    /** Include gateway-served deprecated models in conversation pickers. */
-    showDeprecatedModels?: boolean;
+    /** Per-model switches; normal models default on, deprecated models default off. */
+    modelVisibility?: Record<string, boolean>;
     /** Credential reference naming the environment key. */
     apiKeyEnv?: string;
     /** The gateway endpoint; also the live listing base. */
@@ -64,11 +64,14 @@ export type OpencodeGoModels =
     readonly count: number;
     readonly preview: readonly string[];
     readonly entries: readonly GoModel[];
+    readonly stale?: boolean;
+    readonly message?: string;
+    readonly refreshing?: boolean;
 }
 /** The listing could not be read; `message` is the Host's own diagnostic. */
  | {
     readonly status: 'failed';
-    readonly message: string;
+    readonly message?: string;
 };
 /** What the settings page renders. */
 export interface OpencodeGoSectionState extends FormShell {
@@ -78,7 +81,7 @@ export interface OpencodeGoSectionState extends FormShell {
      * a withdrawn route is what the user is trying to observe.
      */
     enabled: boolean;
-    showDeprecatedModels: boolean;
+    modelVisibility: Readonly<Record<string, boolean>>;
     pickerSaving: boolean;
     pickerFailed: boolean;
     /** Credential reference naming the environment key. */
@@ -121,7 +124,7 @@ export interface OpencodeGoSectionFace extends FormActions {
      * @param next - the state the switch asks for.
      */
     setEnabled: (next: boolean) => void;
-    setShowDeprecatedModels: (next: boolean) => void;
+    setModelEnabled: (id: string, next: boolean) => void;
 }
 /** Bridges the `llm-opencode-go` scope and the credentials domain onto the page. */
 export declare class OpencodeGoSectionController {
@@ -142,7 +145,7 @@ export declare class OpencodeGoSectionController {
      * @param ctx - the page plugin's context, whose `remote.credentials` namespace
      *   answers for the credential the section references.
      */
-    constructor(scope: SettingsScope<OpencodeGoSettings>, ctx: ClientContext, readModels?: () => Promise<RemoteResult<readonly GoModel[]>>);
+    constructor(scope: SettingsScope<OpencodeGoSettings>, ctx: ClientContext, readModels?: () => Promise<RemoteResult<GoModelCatalog>>);
     /** Release subscriptions without disposing the host's shared form. */
     dispose(): void;
     private projection;
@@ -161,7 +164,7 @@ export declare class OpencodeGoSectionController {
     /**
      * Flip the switch by writing the field on the click itself.
      *
-     * This is the one control on the page that does not wait for Save: the point
+     * Like the per-model switches, this control does not wait for Save: the point
      * of turning it off is to watch the models leave the pickers, and the point
      * of turning it back on is to use the route again — staging either behind a
      * second gesture would report a state the Host does not hold. The write is
@@ -169,9 +172,11 @@ export declare class OpencodeGoSectionController {
      * failed save through the shared shell rather than a silent revert.
      * @param next - the state the switch asks for.
      */
-    setEnabled(next: boolean): void;
-    /** Visibility is immediate; failed writes leave the committed switch state visible. */
-    setShowDeprecatedModels(next: boolean): Promise<void>;
+    setEnabled(next: boolean): Promise<void>;
+    /** Each model switch has one committed value and takes effect without Save. */
+    setModelEnabled(id: string, next: boolean): Promise<void>;
+    /** Serialize immediate switches with form saves; refused writes retain committed values. */
+    private writePickerSetting;
     /**
      * Read the gateway's model listing through the Host's discovery for this
      * adapter. Called when the page mounts and again from its refresh control.