dsh-opencode-go 0.1.2 → 0.1.4

package/README.md

@@ -2,11 +2,12 @@
 
 在 [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) 中使用 OpenCode Go 订阅模型，支持流式回复、工具调用、图片输入和 Web 设置页。
 
-插件自动添加 OpenCode Go 所需的会话请求头，并从网关获取可用模型目录。通过 DSH 插件命令安装，无需修改 DSH 源码。
+插件自动添加 OpenCode Go 所需的会话请求头，并从网关获取可用模型目录，显示套餐剩余额度。通过 DSH 插件命令安装，无需修改 DSH 源码。
+
+无需任何设置，一key开始
 
-## 安装与使用
 
-已验证兼容 **DSH `0.1.6-alpha.1`**。其他版本尚未验证。
+## 安装与使用
 
 ### Web
 
@@ -49,44 +50,34 @@ dsh --profile headless --patch ./headless.patch.yml "你好"
 
 模型 ID 须在当前网关目录中可用。Web 和 Headless 使用各自的 profile，需要分别安装插件。
 
-## 订阅用量
+## 升级插件
 
-Web 中选择 `opencode-go` 提供方的模型后，模型名左侧显示 **Go · 5h 已用百分比 · 周已用百分比**。点击可查看 5 小时、每周、每月用量和本地时区的重置时间。
+更新 Web profile 中的插件到 npm 最新版本：
 
-数据通过 Host 使用已配置的 API Key 查询 `GET /zen/go/v1/usage`，每分钟刷新；浏览器不接收 API Key。切换到其他提供方后隐藏，页面不可见时暂停查询。接口失败或响应缺失时显示“暂不可用”，不会填成 0%。接口返回的是账号订阅额度，不是当前会话 token 数。
+```sh
+dsh plugin --profile web update dsh-opencode-go --latest
+```
 
-这个接口可在 [OpenCode 官方源码](https://github.com/anomalyco/opencode/blob/dev/packages/console/app/src/routes/zen/go/v1/usage.ts) 中查到；当前返回 `rolling`、`weekly`、`monthly` 各窗口的 `status`、`percent` 和 `resetsAt`，不返回缓存命中率。
+完成后重启 `dsh web` 并刷新浏览器。Headless 用户将 `web` 换成 `headless`；如果两个 profile 都安装了插件，需要分别升级。
 
-底部的缓存命中率由每次模型响应的缓存 token 统计计算。插件支持 `prompt_tokens_details.cached_tokens`、`prompt_cache_hit_tokens` 和顶层 `cached_tokens`。上游未返回缓存统计时，当前 pi-ai / Harness 统计链路也可能显示 0；可在 OpenCode 控制台的使用历史中展开对应请求的输入明细进行核对。新会话首次请求出现 0 命中是可能的，同一会话后续有可复用的提示前缀才可能命中。
+如果此前安装的是本地目录或 `.tgz` 文件，用以下命令切换到 npm 最新版：
 
-## 配置
+```sh
+dsh plugin --profile web add dsh-opencode-go@latest
+```
 
-Web 用户可直接在 **设置 → OpenCode Go** 中修改配置。启用开关立即生效；保存其他配置后，后续请求使用新值。
+升级插件无需卸载，也无需重新填写 API Key。模型目录会自动同步，正常新增模型不需要再次升级插件。
 
-需要通过文件配置时，在对应 profile 的 `cordis.patch.yml` 中添加以下内容。所有字段均有默认值，通常只需配置 API Key。
+## 订阅用量显示
 
-```yaml
-- id: opencode-go
-  config:
-    enabled: true
-    apiKeyEnv: OPENCODE_API_KEY
-    baseURL: https://opencode.ai/zen/go/v1
-    refreshMinutes: 60
-    streamIdleTimeoutMs: 300000
-    maxRequestImageBytes: 20971520
-    requestImagePixelBudget: 4194304
-    requestImageMaxBytes: 1048576
-```
+![alt text](image.png)
 
-`apiKeyEnv` 是凭据引用名，不是密钥。插件通过 DSH credentials 服务解析凭据；未挂载该服务时读取进程环境。Web 保存的设置可覆盖文件中的基础配置。
+## 配置
 
-关闭插件开关或移除密钥会撤下提供方路由，设置页仍可访问。
+Web 用户可直接在 **设置 → OpenCode Go** 中修改配置。启用开关立即生效；
 
 ## 常见问题
 
-### 安装提示依赖构建脚本被拦截
-
-按安装器提示，在该 profile 的 `pnpm-workspace.yaml` 中逐项设置 `allowBuilds`。OpenCode Go 已验证的运行路径不需要执行 `@google/genai` 和 `protobufjs` 的安装脚本，可以将这两项设为 `false` 后重试。保留文件中的其他配置，无需全局放开安装脚本。
 
 ### 提示 `opencode-go` 路由已被占用
 
@@ -94,16 +85,22 @@ Web 用户可直接在 **设置 → OpenCode Go** 中修改配置。启用开关
 
 ### 没有出现预期的模型
 
-先确认插件已启用且 API Key 已配置，再刷新设置页中的模型列表。插件仅展示本地适配表与网关实时目录的交集；尚未适配协议的新模型不会自动加入。
+先确认插件已启用且 API Key 已配置，再刷新设置页中的模型列表。插件每次读取模型列表都会请求网关 `/models`，并同步 [models.dev 的 OpenCode Go 配置](https://models.dev/api.json)。模型的协议、上下文长度、输出上限和图片能力来自在线配置，新模型无需等待本插件或 pi-ai 发布新版本。
+
+网关和在线配置已收录、且使用 Anthropic Messages、OpenAI Chat Completions 或 OpenAI Responses 协议的新模型，在下次读取或刷新列表时即可使用。刷新会绕过已有会话的目录缓存；直接请求尚未缓存的新模型也会立即重新同步。设置页显示完整模型列表。
+
+网关已公布 ID 但尚无有效协议/能力配置的模型会在设置页的发现结果中标注配置暂不可用，暂不进入对话模型选择器，避免一个未配置的模型阻断整个列表；直接调用时会说明原因。配置补齐后，刷新列表即可使用。仅凭模型 ID 无法可靠推断调用方式。上游新增全新协议或协议特例时，仍可能需要适配。
+
+模型具有推理能力但没有可调节的推理档位时（如 `union-alpha`），仍可正常选择和使用，只是不显示推理强度选项。
 
-实时目录获取失败时，适配器可使用本地表继续处理请求；设置页中的模型发现会显示失败，便于重新尝试。
+在线配置暂时不可达时，优先复用本次运行中成功获取的配置，以 pi-ai 内置配置作为备用。网关目录不可达时，已有请求可以使用上次目录；设置页刷新会显示失败，避免把旧目录误认为最新结果。`refreshMinutes` 只控制已有模型请求的缓存时长，不阻止主动读取列表获取新模型。
 
 ## 功能说明
 
 - **会话请求头**：每次请求包含 Harness User-Agent 和 `x-opencode-session`。同一会话保持相同 ID，无会话 ID 的请求使用独立随机值。
 - **流式与历史**：支持流式输出、工具调用及历史回放，协议请求由 pi-ai 执行。
 - **图片输入**：支持目录中声明图片能力的模型，需要 DSH attachment 服务。
-- **提示与缓存**：插件不增加隐藏系统提示；会话 ID 用于网关路由，历史前缀及图片编码影响缓存复用。
+- **提示与缓存**：插件不增加隐藏系统提示；会话 ID 用于网关路由；
 
 ## 卸载
 
@@ -115,26 +112,11 @@ dsh plugin --profile web remove dsh-opencode-go
 dsh plugin --profile headless remove dsh-opencode-go
 ```
 
-如果默认模型仍指向 `opencode-go`，请改选其他提供方。凭据和历史会话由 DSH 管理。
-
-## 开发
-
-需要 Node.js `^22.19.0 || >=24.0.0` 和 npm。
-
-```sh
-npm ci
-npm run typecheck
-npm test
-npm pack
-```
 
-`npm test` 会先构建再执行测试；`npm pack` 生成可安装的 `.tgz` 包。依赖均通过 npm 安装，不需要 DSH 源码仓库。
 
-- [验证说明](docs/verification.md)：测试范围、隔离安装与 Headless 验证方法。
-- [架构与依赖](docs/independent-package.md)：Host、Client 构建方式和转换代码的维护方式。
-- [第三方声明](THIRD_PARTY_NOTICES.md)：代码来源与许可。
+## 反馈
 
-自动化测试使用本地模拟网关，不会发起付费模型请求。真实账号、Desktop 和其他操作系统尚未验证。
+遇到bug或有功能建议请提issue
 
 ## 许可证
 

package/docs/verification.md

@@ -51,6 +51,12 @@ The usage tests invoke the actual published Typert Host gateway against a local
 
 The local Web profile was also checked against the real read-only OpenCode Go usage endpoint. The button renders immediately before the model selector, and its details show rolling, weekly, and monthly percentages and local reset times. This check sends no model-generation request. The manual Remote codec supports both the published DSH `schema` shape and the current source build's `create()` shape.
 
+## Dynamic model catalog verification
+
+The dynamic catalog change passes all 140 tests plus the Host/Client build. Its offline regression fixtures cover Union Alpha and an arbitrary future id absent from pi-ai, immediate discovery and picker refresh, metadata arriving after a model id, HTTP ETag revalidation, concurrent refreshes, metadata outages, gateway outages, removal of retired models, malformed metadata, and supported reasoning controls. Real SDK streams against a local HTTP gateway verify Chat Completions, Responses, and Anthropic Messages paths for models with no built-in entry, including the Anthropic SDK's `/v1/messages` suffix.
+
+A read-only check against the live OpenCode Go listing and models.dev resolved 36 of 38 advertised ids, including `union-alpha`; `deepseek-flash` and `hy3-preview` had no metadata. Those ids remain visible with a configuration diagnostic. This check did not send a generation request or establish that every advertised id is currently callable for an account.
+
 ## Remaining limits
 
 Real paid OpenCode Go completions, Desktop, non-macOS platforms, and other DSH releases are not verified. The automated gateway tests preserve the adapter's request and replay semantics but cannot establish account validity or live provider availability.

package/lib/client.js

@@ -40,7 +40,7 @@ if (!document.querySelector("style[data-plugin-css=" + JSON.stringify(id) + "]")
   style.textContent = ".BtKYva_field{flex-direction:column;gap:6px;padding:12px 0;display:flex}.BtKYva_field+.BtKYva_field{border-top:.5px solid var(--dsw-alias-border-l2)}.BtKYva_head{align-items:center;gap:8px;display:flex}.BtKYva_label{min-width:0;color:var(--dsw-alias-label-primary);flex:1;font-size:13px;font-weight:500;line-height:1.5}.BtKYva_badges{align-items:center;gap:8px;display:inline-flex}.BtKYva_reset{font:inherit;color:var(--dsw-alias-label-secondary);cursor:pointer;background:0 0;border:none;padding:0;font-size:12px;line-height:1.5}.BtKYva_reset:hover:not(:disabled){color:var(--dsw-alias-label-primary)}.BtKYva_reset:disabled{cursor:default}.BtKYva_input{border:.5px solid var(--dsw-alias-border-l4);background:var(--dsw-alias-bg-layer-3);height:34px;font:inherit;color:var(--dsw-alias-label-primary);border-radius:8px;padding:0 12px;font-size:13px;line-height:1.5}.BtKYva_input:focus-visible{border-color:var(--dsw-alias-brand-primary);outline:none}.BtKYva_input:disabled{color:var(--dsw-alias-label-tertiary);cursor:default}.BtKYva_inputInvalid{border-color:var(--dsw-alias-label-error);}.BtKYva_invalid{color:var(--dsw-alias-label-error);margin:0;font-size:12px;line-height:1.5}.BtKYva_hint{color:var(--dsw-alias-label-tertiary);margin:0;font-size:12px;line-height:1.5}.BtKYva_intro{color:var(--dsw-alias-label-secondary);margin:0 0 8px;font-size:13px;line-height:1.5}.BtKYva_disclosure{font:inherit;text-align:left;cursor:pointer;background:0 0;border:none;align-items:center;gap:8px;margin:0;padding:0;display:flex}.BtKYva_disclosure:hover .BtKYva_label{color:var(--dsw-alias-brand-primary)}.BtKYva_chevron,.BtKYva_chevronOpen{color:var(--dsw-alias-label-tertiary);flex:none}.BtKYva_chevron{transform:rotate(-90deg)}.BtKYva_advanced{flex-direction:column;gap:4px;padding:4px 0 0 22px;display:flex}.BtKYva_advanced .BtKYva_field+.BtKYva_field{border-top:none}.BtKYva_chips{flex-wrap:wrap;gap:6px;display:flex}.BtKYva_actions{align-items:center;gap:8px;padding-top:12px;display:flex}.BtKYva_failedNote{color:var(--dsw-alias-label-error);margin:0;font-size:12px;line-height:1.5}";
   document.head.appendChild(style);
 }
-var Section_default = { "inputInvalid": "BtKYva_inputInvalid", "failedNote": "BtKYva_failedNote", "chips": "BtKYva_chips", "disclosure": "BtKYva_disclosure", "head": "BtKYva_head", "label": "BtKYva_label", "input": "BtKYva_input", "advanced": "BtKYva_advanced", "invalid": "BtKYva_invalid", "intro": "BtKYva_intro", "chevron": "BtKYva_chevron", "badges": "BtKYva_badges", "reset": "BtKYva_reset", "hint": "BtKYva_hint", "chevronOpen": "BtKYva_chevronOpen", "actions": "BtKYva_actions", "field": "BtKYva_field" };
+var Section_default = { "intro": "BtKYva_intro", "head": "BtKYva_head", "label": "BtKYva_label", "invalid": "BtKYva_invalid", "hint": "BtKYva_hint", "chevron": "BtKYva_chevron", "chips": "BtKYva_chips", "failedNote": "BtKYva_failedNote", "advanced": "BtKYva_advanced", "input": "BtKYva_input", "reset": "BtKYva_reset", "badges": "BtKYva_badges", "actions": "BtKYva_actions", "inputInvalid": "BtKYva_inputInvalid", "disclosure": "BtKYva_disclosure", "chevronOpen": "BtKYva_chevronOpen", "field": "BtKYva_field" };
 
 // src/client/Section.tsx
 var import_jsx_runtime = require("react/jsx-runtime");
@@ -553,7 +553,6 @@ var OPENCODE_GO_NS = "llm-opencode-go";
 var DEFAULT_API_KEY_REF = "OPENCODE_API_KEY";
 var API_KEY_FIELD = "apiKey";
 var OPENCODE_GO_PROVIDER = "opencode-go";
-var MODEL_PREVIEW_LIMIT = 6;
 var OpencodeGoSectionController = class {
   /**
    * @param scope - the bound settings scope for the `llm-opencode-go` namespace.
@@ -646,7 +645,7 @@ var OpencodeGoSectionController = class {
       this.models = response.ok ? {
         status: "ready",
         count: response.value.length,
-        preview: response.value.slice(0, MODEL_PREVIEW_LIMIT).map((model) => model.name ?? model.id)
+        preview: response.value.map((model) => model.name ?? model.id)
       } : { status: "failed", message: response.error.message };
       this.store.set(this.projection());
     }).catch((error) => {
@@ -766,7 +765,7 @@ var en = {
   baseURLLabel: "Gateway URL",
   baseURLHint: "The endpoint that serves requests and the live model list.",
   refreshMinutesLabel: "Catalog refresh (minutes)",
-  refreshMinutesHint: "How long one live model-listing resolution stays authoritative before re-fetching.",
+  refreshMinutesHint: "Cache lifetime for ongoing requests. Reading or refreshing the model list always checks the gateway and online model metadata immediately.",
   streamIdleTimeoutMsLabel: "Stream idle timeout (ms)",
   streamIdleTimeoutMsHint: "Largest quiet gap between stream events before the request fails.",
   maxRequestImageBytesLabel: "Request image payload cap (bytes)",
@@ -821,7 +820,7 @@ var zh = {
   baseURLLabel: "\u7F51\u5173\u5730\u5740",
   baseURLHint: "\u540C\u65F6\u63D0\u4F9B\u6A21\u578B\u8BF7\u6C42\u4E0E\u5B9E\u65F6\u6A21\u578B\u5217\u8868\u7684\u7AEF\u70B9\u3002",
   refreshMinutesLabel: "\u76EE\u5F55\u5237\u65B0\uFF08\u5206\u949F\uFF09",
-  refreshMinutesHint: "\u4E00\u6B21\u5B9E\u65F6\u6A21\u578B\u5217\u8868\u89E3\u6790\u4FDD\u6301\u6709\u6548\u7684\u65F6\u957F\uFF0C\u5230\u671F\u540E\u91CD\u65B0\u62C9\u53D6\u3002",
+  refreshMinutesHint: "\u5DF2\u6709\u8BF7\u6C42\u7684\u76EE\u5F55\u7F13\u5B58\u65F6\u957F\u3002\u8BFB\u53D6\u6216\u5237\u65B0\u6A21\u578B\u5217\u8868\u65F6\uFF0C\u4F1A\u7ACB\u5373\u6838\u5BF9\u7F51\u5173\u4E0E\u5728\u7EBF\u6A21\u578B\u914D\u7F6E\u3002",
   streamIdleTimeoutMsLabel: "\u6D41\u7A7A\u95F2\u8D85\u65F6\uFF08\u6BEB\u79D2\uFF09",
   streamIdleTimeoutMsHint: "\u6D41\u4E8B\u4EF6\u95F4\u5141\u8BB8\u7684\u6700\u5927\u9759\u9ED8\u95F4\u9694\uFF0C\u8D85\u51FA\u540E\u8BF7\u6C42\u5931\u8D25\u3002",
   maxRequestImageBytesLabel: "\u8BF7\u6C42\u56FE\u7247\u8F7D\u8377\u4E0A\u9650\uFF08\u5B57\u8282\uFF09",
@@ -886,7 +885,7 @@ if (!document.querySelector("style[data-plugin-css=" + JSON.stringify(id2) + "]"
   style.textContent = ".dmPm3q_root{min-width:0;display:inline-flex;position:relative}.dmPm3q_trigger{color:inherit;opacity:.75;font:inherit;cursor:pointer;white-space:nowrap;background:0 0;border:0;border-radius:6px;padding:4px 6px;font-size:12px}.dmPm3q_trigger:hover,.dmPm3q_trigger:focus-visible{opacity:1;background:color-mix(in srgb, currentColor 8%, transparent)}.dmPm3q_panel{z-index:100;border:1px solid color-mix(in srgb, currentColor 18%, transparent);width:280px;max-width:calc(100vw - 32px);color:var(--dsw-alias-label-primary,CanvasText);background:var(--dsw-specific-menu,Canvas);border-radius:12px;padding:16px;font-size:12px;position:absolute;bottom:calc(100% + 12px);right:0;box-shadow:0 8px 30px #0002}.dmPm3q_hint{opacity:.65;font-size:11px;line-height:1.6}.dmPm3q_window{margin-top:14px}.dmPm3q_row{justify-content:space-between;margin-bottom:5px;display:flex}.dmPm3q_window progress{accent-color:#39a878;width:100%;height:5px;margin-bottom:5px;display:block}.dmPm3q_window progress::-webkit-progress-bar{background:color-mix(in srgb, currentColor 15%, transparent);border-radius:4px}.dmPm3q_window progress::-webkit-progress-value{background:#39a878;border-radius:4px}.dmPm3q_window progress::-moz-progress-bar{background:#39a878;border-radius:4px}";
   document.head.appendChild(style);
 }
-var UsagePill_default = { "root": "dmPm3q_root", "hint": "dmPm3q_hint", "row": "dmPm3q_row", "panel": "dmPm3q_panel", "window": "dmPm3q_window", "trigger": "dmPm3q_trigger" };
+var UsagePill_default = { "panel": "dmPm3q_panel", "trigger": "dmPm3q_trigger", "hint": "dmPm3q_hint", "root": "dmPm3q_root", "window": "dmPm3q_window", "row": "dmPm3q_row" };
 
 // src/client/UsagePill.tsx
 var import_jsx_runtime2 = require("react/jsx-runtime");

package/lib/index.js

@@ -641,45 +641,117 @@ import { anthropicMessagesApi } from "@earendil-works/pi-ai/api/anthropic-messag
 import { openAICompletionsApi } from "@earendil-works/pi-ai/api/openai-completions.lazy";
 import { openAIResponsesApi } from "@earendil-works/pi-ai/api/openai-responses.lazy";
 import { attributionHeaders, LlmError as LlmError4 } from "@deepseek-ai/dsh-llm";
-var PROVIDER_ID = "opencode-go";
-var DISPLAY_NAME = "OpenCode Go";
-var DEFAULT_BASE_URL = "https://opencode.ai/zen/go/v1";
-var CATALOG_ADDITIONS = [
-  {
-    id: "deepseek-v4.1-flash",
-    siblingId: "deepseek-v4-flash",
-    inputSiblingId: "deepseek-v4-flash-vision-exp",
-    name: "DeepSeek V4.1 Flash"
+
+// src/model-metadata.ts
+var MODEL_METADATA_URL = "https://models.dev/api.json";
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function positiveInteger(value, field) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0) {
+    throw new Error(`missing or invalid ${field}`);
   }
-];
-var MODELS_FETCH_TIMEOUT_MS = 1e4;
-function curatedModels(baseURL) {
-  const models = /* @__PURE__ */ new Map();
-  for (const model of getBuiltinModels("opencode-go")) {
-    models.set(model.id, { ...model, provider: PROVIDER_ID, baseUrl: baseURL });
+  return value;
+}
+function rates(value) {
+  const cost = record(value);
+  const rate = (key) => {
+    const value2 = cost[key];
+    return typeof value2 === "number" && Number.isFinite(value2) && value2 >= 0 ? value2 : 0;
+  };
+  return { input: rate("input"), output: rate("output"), cacheRead: rate("cache_read"), cacheWrite: rate("cache_write") };
+}
+var LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+function thinkingLevels(metadata, known) {
+  if (!Array.isArray(metadata.reasoning_options) && known?.thinkingLevelMap !== void 0) return known.thinkingLevelMap;
+  const map = Object.fromEntries(LEVELS.map((level) => [level, null]));
+  for (const item of Array.isArray(metadata.reasoning_options) ? metadata.reasoning_options : []) {
+    const option = record(item);
+    if (option.type === "toggle" || option.type === "budget_tokens") {
+      map.off = "off";
+      map.high = "high";
+    }
+    if (option.type !== "effort" || !Array.isArray(option.values)) continue;
+    for (const value of option.values) {
+      const level = value === "none" ? "off" : value;
+      if (LEVELS.includes(level)) map[level] = String(value);
+    }
   }
-  for (const addition of CATALOG_ADDITIONS) {
-    if (models.has(addition.id)) continue;
-    const sibling = models.get(addition.siblingId);
-    if (sibling === void 0) continue;
-    const inputSibling = models.get(addition.inputSiblingId);
-    if (inputSibling === void 0) continue;
-    models.set(addition.id, {
-      ...sibling,
-      id: addition.id,
-      name: addition.name,
-      input: [...inputSibling.input],
-      provider: PROVIDER_ID,
-      baseUrl: baseURL
-    });
+  if (known?.reasoning && known.thinkingLevelMap?.off !== null) map.off ??= known.thinkingLevelMap?.off ?? "off";
+  return map;
+}
+function modelBaseURL(api, baseURL) {
+  const base = baseURL.replace(/\/+$/, "");
+  return api === "anthropic-messages" ? base.replace(/\/v1$/, "") : base;
+}
+function readModelMetadata(body, baseURL, builtin) {
+  const provider = record(record(body)["opencode-go"]);
+  if (provider.models === null || typeof provider.models !== "object" || Array.isArray(provider.models)) {
+    throw new Error("models.dev has no opencode-go models object");
   }
-  if (models.size === 0) {
-    throw new LlmError4(
-      "llm-opencode-go: pi-ai's installed catalog describes no opencode-go models; cannot seed the curated table",
-      "INVALID_CONFIG"
-    );
+  const entries = record(provider.models);
+  const models = /* @__PURE__ */ new Map();
+  const errors = /* @__PURE__ */ new Map();
+  for (const [id, value] of Object.entries(entries)) {
+    try {
+      const metadata = record(value);
+      const npm = record(metadata.provider).npm ?? provider.npm;
+      const api = npm === "@ai-sdk/anthropic" ? "anthropic-messages" : npm === "@ai-sdk/openai" ? "openai-responses" : npm === "@ai-sdk/openai-compatible" ? "openai-completions" : void 0;
+      if (api === void 0) throw new Error(`unsupported model protocol ${String(npm)}`);
+      const limit = record(metadata.limit);
+      const input = record(metadata.modalities).input;
+      if (!Array.isArray(input) || !input.includes("text")) throw new Error("missing text input modality");
+      if (typeof metadata.reasoning !== "boolean") throw new Error("missing reasoning capability");
+      const exact = builtin.get(id);
+      const family = typeof metadata.family === "string" ? Object.keys(entries).find((key) => record(entries[key]).family === metadata.family && builtin.get(key)?.api === api) : void 0;
+      const known = exact?.api === api ? exact : family === void 0 ? void 0 : builtin.get(family);
+      const compat = api === "openai-completions" ? {
+        supportsStore: false,
+        supportsDeveloperRole: false,
+        maxTokensField: "max_tokens",
+        ...record(metadata.interleaved).field === "reasoning_content" ? { requiresReasoningContentOnAssistantMessages: true } : {},
+        ...known?.compat
+      } : api === "openai-responses" ? { sessionAffinityFormat: "openai-nosession", ...known?.compat } : { ...known?.compat };
+      const cost = rates(metadata.cost);
+      const tiers = record(metadata.cost).tiers;
+      if (Array.isArray(tiers)) {
+        cost.tiers = tiers.flatMap((item) => {
+          const tier = record(record(item).tier);
+          return tier.type === "context" && typeof tier.size === "number" && Number.isSafeInteger(tier.size) && tier.size > 0 ? [{ ...rates(item), inputTokensAbove: tier.size }] : [];
+        }).sort((a, b) => a.inputTokensAbove - b.inputTokensAbove);
+      }
+      models.set(id, {
+        id,
+        name: typeof metadata.name === "string" && metadata.name.length > 0 ? metadata.name : id,
+        provider: "opencode-go",
+        api,
+        baseUrl: modelBaseURL(api, baseURL),
+        reasoning: metadata.reasoning,
+        thinkingLevelMap: thinkingLevels(metadata, known),
+        input: input.includes("image") ? ["text", "image"] : ["text"],
+        contextWindow: positiveInteger(limit.context, "context limit"),
+        maxTokens: positiveInteger(limit.output, "output limit"),
+        cost,
+        compat
+      });
+    } catch (error) {
+      errors.set(id, error instanceof Error ? error.message : String(error));
+    }
   }
-  return models;
+  return { models, errors };
+}
+
+// src/catalog.ts
+var PROVIDER_ID = "opencode-go";
+var DISPLAY_NAME = "OpenCode Go";
+var DEFAULT_BASE_URL = "https://opencode.ai/zen/go/v1";
+var MODELS_FETCH_TIMEOUT_MS = 1e4;
+function builtinModels(baseURL) {
+  return new Map(getBuiltinModels("opencode-go").map((model) => [model.id, {
+    ...model,
+    provider: PROVIDER_ID,
+    baseUrl: modelBaseURL(model.api, baseURL)
+  }]));
 }
 function readLiveModelIds(body) {
   const data = body?.data;
@@ -689,7 +761,7 @@ function readLiveModelIds(body) {
     const id = entry?.id;
     if (typeof id === "string" && id.length > 0) ids.push(id);
   }
-  return ids;
+  return [...new Set(ids)];
 }
 async function fetchLiveModelIds(baseURL) {
   const url = `${baseURL.replace(/\/+$/, "")}/models`;
@@ -697,25 +769,21 @@ async function fetchLiveModelIds(baseURL) {
   try {
     response = await fetch(url, {
       method: "GET",
+      cache: "no-cache",
       headers: { accept: "application/json", ...attributionHeaders() },
       signal: AbortSignal.timeout(MODELS_FETCH_TIMEOUT_MS)
     });
   } catch (error) {
     throw new LlmError4(`could not reach ${url}`, "DISCOVERY_FAILED", { cause: error });
   }
-  if (!response.ok) {
-    throw new LlmError4(`${url} answered ${response.status}`, "DISCOVERY_FAILED");
-  }
+  if (!response.ok) throw new LlmError4(`${url} answered ${response.status}`, "DISCOVERY_FAILED");
   return readLiveModelIds(await response.json());
 }
 function harnessApiKeyAuth() {
-  return {
-    apiKey: {
-      name: "OpenCode API key",
-      /* v8 ignore next -- pi-ai calls resolve only for a request without an apiKey override, and this adapter always passes one */
-      resolve: () => Promise.resolve({ auth: {}, source: "OpenCode API key" })
-    }
-  };
+  return { apiKey: {
+    name: "OpenCode API key",
+    resolve: () => Promise.resolve({ auth: {}, source: "OpenCode API key" })
+  } };
 }
 function buildProvider(baseURL, models) {
   return createProvider({
@@ -732,13 +800,6 @@ function buildProvider(baseURL, models) {
   });
 }
 var OpencodeGoCatalog = class {
-  /**
-   * @param baseURL - The endpoint the gateway serves; also the listing base.
-   * @param refreshMs - How long one live resolution stays authoritative.
-   * @param onFallback - Observes a failed live listing and how many curated
-   *   models kept serving because of it.
-   * @param onOmitted - Observes live ids the curated table cannot route.
-   */
   constructor(baseURL, refreshMs, onFallback, onOmitted) {
     this.baseURL = baseURL;
     this.refreshMs = refreshMs;
@@ -747,12 +808,10 @@ var OpencodeGoCatalog = class {
   }
   served;
   pending;
-  /**
-   * The current catalog, fetching when expired or never fetched.
-   * @returns the snapshot now serving, shared by concurrent callers.
-   */
-  snapshot() {
-    if (this.served !== void 0 && Date.now() - this.served.fetchedAtMs < this.refreshMs) {
+  metadata;
+  metadataETag;
+  snapshot(force = false) {
+    if (!force && this.served !== void 0 && Date.now() - this.served.fetchedAtMs < this.refreshMs) {
       return Promise.resolve(this.served);
     }
     this.pending ??= this.build().then((snapshot) => {
@@ -763,48 +822,95 @@ var OpencodeGoCatalog = class {
     });
     return this.pending;
   }
-  /** One resolution: intersect the curated table with the live listing. */
+  /** Conditional HTTP requests save bandwidth while still checking for updated metadata. */
+  async refreshMetadata(builtin) {
+    const response = await fetch(MODEL_METADATA_URL, {
+      headers: {
+        accept: "application/json",
+        ...attributionHeaders(),
+        ...this.metadataETag === void 0 ? {} : { "if-none-match": this.metadataETag }
+      },
+      cache: "no-cache",
+      signal: AbortSignal.timeout(MODELS_FETCH_TIMEOUT_MS)
+    });
+    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 response.json(), this.baseURL, builtin);
+    this.metadata = metadata;
+    this.metadataETag = response.headers.get("etag") ?? void 0;
+    return metadata;
+  }
+  /** Gateway ids decide membership; online metadata decides how to call each model. */
   async build() {
-    const curated = curatedModels(this.baseURL);
-    let liveIds;
-    let failure;
-    try {
-      liveIds = await fetchLiveModelIds(this.baseURL);
-    } catch (error) {
-      failure = error;
+    const builtin = builtinModels(this.baseURL);
+    const [listing, metadataResult] = await Promise.allSettled([
+      fetchLiveModelIds(this.baseURL),
+      this.refreshMetadata(builtin)
+    ]);
+    const metadata = metadataResult.status === "fulfilled" ? metadataResult.value : this.metadata;
+    const known = new Map([...builtin, ...this.served?.models ?? [], ...metadata?.models ?? []]);
+    if (metadataResult.status === "rejected") {
+      this.onFallback({ url: MODEL_METADATA_URL, error: metadataResult.reason, kept: known.size });
     }
-    if (liveIds === void 0) {
-      this.onFallback({ url: `${this.baseURL.replace(/\/+$/, "")}/models`, error: failure, kept: curated.size });
+    if (listing.status === "rejected") {
+      const models2 = this.served?.models ?? known;
+      this.onFallback({ url: `${this.baseURL.replace(/\/+$/, "")}/models`, error: listing.reason, kept: models2.size });
       return {
-        models: curated,
-        provider: buildProvider(this.baseURL, [...curated.values()]),
+        models: models2,
+        unavailable: this.served?.unavailable ?? /* @__PURE__ */ new Map(),
+        provider: buildProvider(this.baseURL, [...models2.values()]),
         live: false,
         fetchedAtMs: Date.now()
       };
     }
-    const live = new Set(liveIds);
-    const omitted = liveIds.filter((id) => !curated.has(id));
-    if (omitted.length > 0) this.onOmitted(omitted);
-    const served = [...curated.values()].filter((model) => live.has(model.id));
+    const models = /* @__PURE__ */ new Map();
+    const unavailable = /* @__PURE__ */ new Map();
+    for (const id of listing.value) {
+      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");
+      } else {
+        models.set(id, model);
+      }
+    }
+    if (unavailable.size > 0) this.onOmitted([...unavailable.keys()]);
     return {
-      models: new Map(served.map((model) => [model.id, model])),
-      provider: buildProvider(this.baseURL, served),
+      models,
+      unavailable,
+      provider: buildProvider(this.baseURL, [...models.values()]),
       live: true,
       fetchedAtMs: Date.now()
     };
   }
+  /** New or previously unconfigured ids get a fresh lookup even during the runtime TTL. */
+  async forModel(id) {
+    const cached = this.served;
+    let snapshot = await this.snapshot();
+    if (!snapshot.models.has(id) && snapshot === cached) snapshot = await this.snapshot(true);
+    if (snapshot.unavailable.has(id)) {
+      throw new LlmError4(
+        `opencode-go model "${id}" is advertised but cannot be configured: ${snapshot.unavailable.get(id)}; refresh the model list to retry`,
+        "MODEL_METADATA_UNAVAILABLE"
+      );
+    }
+    return snapshot;
+  }
 };
 async function discoverCatalogModels(catalog) {
-  const snapshot = await catalog.snapshot();
+  const snapshot = await catalog.snapshot(true);
   if (!snapshot.live) {
     throw new LlmError4("llm-opencode-go: the live model listing is unreachable; try again later", "DISCOVERY_FAILED");
   }
-  return [...snapshot.models.values()].map((model) => ({
-    id: model.id,
-    name: model.name,
-    contextWindow: model.contextWindow,
-    maxTokens: model.maxTokens
-  }));
+  return [
+    ...[...snapshot.models.values()].map((model) => ({
+      id: model.id,
+      name: model.name,
+      contextWindow: model.contextWindow,
+      maxTokens: model.maxTokens
+    })),
+    ...[...snapshot.unavailable].map(([id, reason]) => ({ id, name: `${id} (metadata unavailable: ${reason})` }))
+  ];
 }
 
 // src/config.ts
@@ -888,7 +994,7 @@ var OpencodeGoAdapter = class extends LlmAdapter {
     return { id: provider, name: DISPLAY_NAME };
   }
   async listModels(_provider) {
-    const snapshot = await this.catalogOf(this.options.config()).snapshot();
+    const snapshot = await this.catalogOf(this.options.config()).snapshot(true);
     return [...snapshot.models.values()].map((model) => ({
       provider: PROVIDER_ID,
       id: model.id,
@@ -897,7 +1003,7 @@ var OpencodeGoAdapter = class extends LlmAdapter {
     }));
   }
   async resolveModel(_provider, model, _signal) {
-    const snapshot = await this.catalogOf(this.options.config()).snapshot();
+    const snapshot = await this.catalogOf(this.options.config()).forModel(model);
     const resolved = snapshot.models.get(model);
     if (resolved === void 0) {
       throw new LlmError5(`opencode-go has no model "${model}"`, "UNKNOWN_MODEL");
@@ -907,9 +1013,10 @@ var OpencodeGoAdapter = class extends LlmAdapter {
   /** Describe one model: capacities plus the reasoning levels it actually offers. */
   modelInfo(model) {
     const reasoning = {};
-    if (model.reasoning) {
+    const levels = model.reasoning ? getSupportedThinkingLevels(model) : [];
+    if (levels.length > 0) {
       reasoning.reasoning = {
-        efforts: getSupportedThinkingLevels(model).map((level) => ({
+        efforts: levels.map((level) => ({
           id: ReasoningEffortId(level),
           name: `${level.charAt(0).toUpperCase()}${level.slice(1)}`
         }))
@@ -941,7 +1048,7 @@ var OpencodeGoAdapter = class extends LlmAdapter {
         throw new LlmError5("llm-opencode-go does not support GenerateOptions.stop", "UNSUPPORTED_OPTION");
       }
       const config = this.options.config();
-      const snapshot = await this.catalogOf(config).snapshot();
+      const snapshot = await this.catalogOf(config).forModel(options.model);
       const model = snapshot.models.get(options.model);
       if (model === void 0) {
         throw new LlmError5(`opencode-go has no model "${options.model}"`, "UNKNOWN_MODEL");
@@ -1122,11 +1229,11 @@ function apply(ctx, raw) {
   };
   ctx.plugin(GoUsageService, { baseURL: () => current().baseURL, resolveApiKey });
   const logger = {
-    fallback: ({ error }) => {
-      ctx.logger.warn(`llm-opencode-go: live model listing unreachable; serving the curated table until the next refresh (${String(error)})`);
+    fallback: ({ url, error }) => {
+      ctx.logger.warn(`llm-opencode-go: could not refresh ${url}; using last-known model data (${String(error)})`);
     },
     omitted: (ids) => {
-      ctx.logger.info(`llm-opencode-go: live listing carries ids the curated table cannot route; omitted: ${ids.join(", ")}`);
+      ctx.logger.warn(`llm-opencode-go: gateway models awaiting usable online metadata: ${ids.join(", ")}`);
     }
   };
   const adapter = new OpencodeGoAdapter({

package/lib/types/catalog.d.ts

@@ -1,95 +1,43 @@
-/**
- * The OpenCode Go model catalog: a curated table intersected with the gateway's
- * live model list.
- *
- * The curated table is seeded from pi-ai's installed `opencode-go` catalog —
- * its entries carry the wire protocol, compat quirks, thinking-level spellings,
- * and capacities that the gateway's own listing endpoint does not disclose —
- * plus this package's additions for models the installed catalog has not
- * caught up with. The gateway rotates its list faster than either pi-ai or
- * this package releases, so the served catalog is the curated table **minus**
- * models the live listing no longer advertises: a model the gateway retired
- * must disappear rather than error mid-session. Live ids the curated table
- * does not describe are omitted too, because without a protocol mapping they
- * cannot be routed correctly.
- *
- * The live listing at `{baseURL}/models` is public and answers ids only. A
- * fetch failure never takes the route down: the curated table is served as-is
- * and the failure is reported, on the grounds that a network blip should not
- * deny service, while model discovery — whose whole purpose is the live
- * answer — fails loud instead.
- *
- * @module dsh-llm-opencode-go/catalog
- */
 import type { Api, Model, Provider } from '@earendil-works/pi-ai';
 import type { LlmDiscoveredModel } from '@deepseek-ai/dsh-llm';
-/** Provider route key this plugin registers and every materialized model carries. */
 export declare const PROVIDER_ID = "opencode-go";
-/** Display name for selectors and status labels. */
 export declare const DISPLAY_NAME = "OpenCode Go";
-/** Endpoint serving both model requests and the model listing. */
 export declare const DEFAULT_BASE_URL = "https://opencode.ai/zen/go/v1";
-/** One immutable resolution of the served catalog. */
 export interface CatalogSnapshot {
-    /** Served models by id: the curated table minus models absent from the live listing. */
     readonly models: ReadonlyMap<string, Model<Api>>;
-    /** The provider serving exactly these models. */
+    /** Advertised ids with missing/unsupported metadata stay visible with a diagnostic. */
+    readonly unavailable: ReadonlyMap<string, string>;
     readonly provider: Provider;
-    /** Whether the live listing answered this resolution; `false` on the fallback path. */
     readonly live: boolean;
-    /** When this resolution completed, for the refresh interval. */
     readonly fetchedAtMs: number;
 }
-/**
- * Read one live listing reply. The endpoint answers the standard OpenAI
- * `data` array with entries carrying ids only; anything else is a fault the
- * caller treats as "live unavailable" and falls back. An honest empty array
- * is a valid answer: the gateway says it serves nothing.
- * @param body - the decoded JSON reply.
- * @returns the non-empty ids it advertises, in reply order.
- * @throws {Error} when the reply carries no `data` array.
- */
+/** A valid empty listing means the gateway serves nothing; malformed replies are failures. */
 export declare function readLiveModelIds(body: unknown): readonly string[];
-/**
- * TTL-cached resolution of the served catalog. Concurrent callers share one
- * in-flight fetch; a completed snapshot serves unchanged until the refresh
- * interval elapses, so one stream call never observes two catalog generations.
- */
+/** Runtime requests reuse a snapshot; discovery revalidates it. Concurrent reads coalesce. */
 export declare class OpencodeGoCatalog {
     private readonly baseURL;
     private readonly refreshMs;
     private readonly onFallback;
+    /** Kept for API compatibility; now reports unconfigured ids rather than hiding them. */
     private readonly onOmitted;
     private served;
     private pending;
-    /**
-     * @param baseURL - The endpoint the gateway serves; also the listing base.
-     * @param refreshMs - How long one live resolution stays authoritative.
-     * @param onFallback - Observes a failed live listing and how many curated
-     *   models kept serving because of it.
-     * @param onOmitted - Observes live ids the curated table cannot route.
-     */
+    private metadata;
+    private metadataETag;
     constructor(baseURL: string, refreshMs: number, onFallback: (detail: {
         url: string;
         error: unknown;
         kept: number;
-    }) => void, onOmitted: (ids: readonly string[]) => void);
-    /**
-     * The current catalog, fetching when expired or never fetched.
-     * @returns the snapshot now serving, shared by concurrent callers.
-     */
-    snapshot(): Promise<CatalogSnapshot>;
-    /** One resolution: intersect the curated table with the live listing. */
+    }) => void, 
+    /** Kept for API compatibility; now reports unconfigured ids rather than hiding them. */
+    onOmitted: (ids: readonly string[]) => void);
+    snapshot(force?: boolean): Promise<CatalogSnapshot>;
+    /** Conditional HTTP requests save bandwidth while still checking for updated metadata. */
+    private refreshMetadata;
+    /** Gateway ids decide membership; online metadata decides how to call each model. */
     private build;
+    /** New or previously unconfigured ids get a fresh lookup even during the runtime TTL. */
+    forModel(id: string): Promise<CatalogSnapshot>;
 }
-/**
- * Candidate models for the configuration surface's "fetch available models"
- * action: the same live intersection the route would serve, with the curated
- * capacities the listing endpoint does not disclose. Unlike route resolution,
- * discovery fails when the live listing is unreachable: its whole purpose is
- * the live answer, and a stale answer would offer models the gateway retired.
- * @param catalog - The route's catalog resolver.
- * @returns the served models in curated order.
- * @throws LlmError `DISCOVERY_FAILED` when the live listing is unreachable.
- */
+/** Explicit discovery always revalidates both sources, including during the runtime TTL. */
 export declare function discoverCatalogModels(catalog: OpencodeGoCatalog): Promise<readonly LlmDiscoveredModel[]>;

package/lib/types/config.d.ts

@@ -11,7 +11,7 @@
 import z from '@deepseek-ai/schemastery';
 /** Environment variable resolving the OpenCode API key. */
 export declare const DEFAULT_API_KEY_ENV = "OPENCODE_API_KEY";
-/** Default interval between live catalog re-resolutions. */
+/** Runtime request cache lifetime; model listing/discovery always revalidates immediately. */
 export declare const DEFAULT_REFRESH_MINUTES = 60;
 /** Default maximum idle interval while a stream read is outstanding. */
 export declare const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 300000;
@@ -29,7 +29,7 @@ export interface OpencodeGoConfig {
     apiKeyEnv: string;
     /** The gateway endpoint; also the base of the live model listing. */
     baseURL: string;
-    /** How long one live catalog resolution stays authoritative, in minutes. */
+    /** Runtime request cache lifetime in minutes; explicit catalog reads bypass it. */
     refreshMinutes: number;
     /** Largest idle gap between stream events before the request fails. */
     streamIdleTimeoutMs: number;

package/lib/types/model-metadata.d.ts

@@ -0,0 +1,15 @@
+/** Convert OpenCode's online models.dev metadata into the SDK's three wire protocols. */
+import type { Api, Model } from '@earendil-works/pi-ai';
+export declare const MODEL_METADATA_URL = "https://models.dev/api.json";
+export interface ModelMetadata {
+    readonly models: ReadonlyMap<string, Model<Api>>;
+    readonly errors: ReadonlyMap<string, string>;
+}
+/** Anthropic's SDK appends /v1/messages; the OpenAI SDKs append paths below /v1. */
+export declare function modelBaseURL(api: Api, baseURL: string): string;
+/**
+ * Only read the opencode-go record. Online endpoints, headers and credentials
+ * are deliberately ignored: model traffic always stays on the configured gateway.
+ * A bad entry is isolated instead of discarding every other model.
+ */
+export declare function readModelMetadata(body: unknown, baseURL: string, builtin: ReadonlyMap<string, Model<Api>>): ModelMetadata;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-opencode-go",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "OpenCode Go model provider and settings UI for DeepSeek Harness",
   "type": "module",
   "license": "MIT",