dsh-model-health 0.1.0

package/README.md

@@ -0,0 +1,81 @@
+# dsh-model-health
+
+> DeepSeek Harness (DSH) 插件：在设置页展示「模型健康」面板——列出所有已配置模型，并支持一键批量测试可用性与延迟。
+
+## 功能 / Features
+
+读取 `$DSH_HOME/settings.yaml`（默认 `~/.dsh/settings.yaml`），提供三种使用方式：
+
+| # | 形式 | 入口 | 说明 |
+|---|------|------|------|
+| 1 | 设置页面板「模型健康」 | Web UI → 设置 → 模型健康 | React 表格：Provider / 模型 ID / 名称 / 上下文窗口 / 最大输出 / 输入模态 / API 协议 / BaseURL 等列（可选列可切换显示） |
+| 2 | 一键测试全部 | 面板内「测试全部」按钮 | 并发（上限 6）对每个模型发一次 `max_tokens=1` 的最小 chat completions 请求，10s 超时；逐行显示 可用 / 不可用 / 跳过 / 延迟，失败原因悬停查看，结果持久化到 localStorage |
+| 3 | Tool 插件 `list_models` | 对话中调用 | 返回 Markdown 表格，供模型在对话中查看模型清单 |
+
+支持 `llm-pi-ai`（多协议自定义提供商）与 `llm-deepseek`（官方）两类配置；测试支持 `openai-completions` 与 `deepseek` 协议，其余标记为「跳过」。API Key 通过 DSH credential service 解析，不会输出到浏览器。
+
+## 安装 / Install
+
+一句话安装（npm 包，发布后可用）：
+
+```sh
+dsh plugin --profile my-profile add dsh-model-health
+```
+
+## 源码安装 / Install from source
+
+```sh
+git clone https://github.com/<你的用户名>/dsh-model-health.git
+cd dsh-model-health
+pnpm install
+pnpm run build        # tsc → dist/index.js (pure ESM) + dist/client.js
+
+# 在插件的父目录执行（dsh plugin add 的相对路径锚定调用目录）：
+cd ..
+dsh plugin --profile my-profile add ./dsh-model-health
+dsh --profile my-profile
+# 启动日志应出现：[dsh-model-health] ready — tool "list_models" + routes GET /api/model-health/json, POST /api/model-health/test
+```
+
+无 API key 也可验证加载：
+
+```sh
+dsh --profile my-profile --dump-config | grep dsh-model-health   # 配置层含本行
+```
+
+## Dependencies pinned / 依赖锁定
+
+- `@deepseek-ai/dsh-tools`: `0.1.0-rc.8` (exact — the **`next`**-tag line; npm `latest` is stale).
+- `@deepseek-ai/cordis`: `^4.0.1` (peerDependency — host provides it; types-only in code).
+
+## Pitfalls / 坑（从真实 spike 提炼，防呆）
+
+1. Node version: DSH requires Node ^22.19.0 || >=24.0.0. Older Node (e.g. v22.17) only warns EBADENGINE but may hit runtime issues — upgrade if you can.
+   - Node 版本：DSH 要求 ^22.19.0 || >=24.0.0。旧版本（如 v22.17）只告警 EBADENGINE，不阻断，但建议升级。
+
+2. npm dist-tag trap (the big one): `@deepseek-ai/dsh-tools` `latest` is a STALE 0.0.1-rc.1; the real line is under the `next` tag (0.1.0-rc.x). This scaffold pins the next-tag version for you — never `npm i @deepseek-ai/dsh-tools` over it.
+   - npm dist-tag 坑（最大）：`@deepseek-ai/dsh-tools` 的 latest 是过期的 0.0.1-rc.1，正确版本在 next tag。本脚手架已锁 next 版本，勿再手动 npm i 覆盖。
+
+3. Version-line alignment: keep every `@deepseek-ai/dsh-*` package on the same `0.1.0-rc.x` line so pnpm does not install two module copies.
+   - 版本线对齐：所有 @deepseek-ai/dsh-* 包统一用同一 0.1.0-rc.x 线，避免 pnpm 装两份模块。
+
+4. `@deepseek-ai/cordis` is a peerDependency: import only `type { Context }` (erased at compile). At runtime the host hands you `ctx` — never import cordis values at runtime.
+   - @deepseek-ai/cordis 是 peerDep：只 import type（编译期擦除），运行时 ctx 由宿主传入。
+
+5. Pure ESM: package.json must set `"type": "module"`; build with `module: esnext` + `moduleResolution: bundler` to keep bare specifiers.
+   - 纯 ESM：package.json 必须 "type": "module"；tsc 用 module:esnext + moduleResolution:bundler 保留 bare specifier。
+
+6. `dsh plugin add <dir>` anchors relative paths to the INVOKING directory — run it from the parent directory, not from inside the plugin.
+   - dsh plugin add <dir> 的相对路径锚定调用目录——要在插件的父目录执行。
+
+7. In the bundle `cordis.patch.yml`, `name` is a package name (resolved via node_modules / `$DSH_HOME/profiles/node_modules`), not a relative path.
+   - bundle 的 cordis.patch.yml 里 name 用包名（走 node_modules 解析），不要用相对路径。
+
+8. Registrations are effects: `ctx.tools.register()` / `ctx.on()` auto-dispose on unload. Wrap your OWN resources (timers/connections) in `ctx.effect(() => { acquire; return cleanup })`.
+   - 注册是 effect：ctx.tools.register()/ctx.on() 卸载自动清理；自己的资源（timer/连接）要包 ctx.effect(() => {…; return cleanup})。
+
+9. Load order = service dependencies, never file order: `export const inject = ['tools']` makes the plugin wait until `ctx.tools` is ready.
+   - 加载顺序靠服务依赖（inject），不靠文件顺序。
+
+10. Full end-to-end (model actually calls your tool) needs `DEEPSEEK_API_KEY`; without it `--verify` proves load/list/event, and the model call fails with MISSING_CREDENTIAL.
+    - 端到端（模型真正调工具）需 DEEPSEEK_API_KEY；无 key 时 --verify 只能证明加载/列出/事件，模型调用会 MISSING_CREDENTIAL。

package/cordis.patch.yml

@@ -0,0 +1,9 @@
+# dsh-model-health bundle layer — applied when a profile lists this bundle
+# (package.json declares `dsh.bundle.patch` pointing at this file).
+#
+# PITFALL: `name` is a PACKAGE NAME (resolved through the profile's node_modules
+# or the installation fallback `$DSH_HOME/profiles/node_modules`), NOT a
+# relative path. `dsh-model-health` is this package's main entry (→ dist/index.js).
+- insert:
+    - id: dsh-model-health
+      name: dsh-model-health

package/dist/client.js

@@ -0,0 +1,593 @@
+// dsh-model-health — client 模块：在设置页注入"模型列表"section。
+//
+// 格式：window.__ModuleLoader__.load({ id, factory: (require) => {...} })
+// 这是 DSH 浏览器侧的模块加载器格式，factory 内用 require() 获取依赖。
+//
+// 注册一个 settings.section slot，组件通过 fetch /api/model-health/json 获取
+// 模型列表 JSON，然后用 React 直接渲染表格。
+// 支持"测试全部"：并发 POST /api/model-health/test，逐个更新测试状态。
+//
+window.__ModuleLoader__.load({
+    id: "dsh-model-health",
+    factory: (require) => {
+        var module = { exports: {} };
+        var exports = module.exports;
+
+        const React = require("react");
+        const { useState, useEffect, useCallback } = React;
+
+        // 内联样式（适配 DSH 明暗主题的 CSS 变量）
+        const STYLES = {
+            wrap: {
+                maxWidth: 1100,
+                color: "var(--dsw-alias-label-primary, #333)",
+                display: "flex",
+                flexDirection: "column",
+                gap: 12,
+            },
+            head: {
+                display: "flex",
+                alignItems: "baseline",
+                gap: 8,
+                flexWrap: "wrap",
+            },
+            title: {
+                margin: 0,
+                fontSize: 16,
+                fontWeight: 500,
+                lineHeight: "24px",
+            },
+            count: {
+                display: "inline-block",
+                background: "var(--dsw-alias-button-primary-fill, #4f46e5)",
+                color: "var(--dsw-alias-label-primary-foreground, #fff)",
+                padding: "2px 10px",
+                borderRadius: 12,
+                fontSize: 12,
+            },
+            toolbar: {
+                display: "flex",
+                alignItems: "center",
+                gap: 8,
+                flexWrap: "wrap",
+            },
+            meta: {
+                color: "var(--dsw-alias-label-tertiary, #888)",
+                fontSize: 13,
+                marginRight: "auto",
+            },
+            btn: {
+                boxSizing: "border-box",
+                height: 28,
+                padding: "0 14px",
+                fontSize: 12,
+                lineHeight: "18px",
+                cursor: "pointer",
+                border: "1px solid var(--dsw-alias-border-l2, #ddd)",
+                borderRadius: 14,
+                background: "transparent",
+                color: "var(--dsw-alias-label-primary, #333)",
+            },
+            btnPrimary: {
+                background: "var(--dsw-alias-button-primary-fill, #4f46e5)",
+                color: "var(--dsw-alias-label-primary-foreground, #fff)",
+                border: "none",
+            },
+            btnDisabled: {
+                opacity: 0.5,
+                cursor: "not-allowed",
+            },
+            progress: {
+                fontSize: 12,
+                color: "var(--dsw-alias-label-tertiary, #888)",
+            },
+            tableWrap: {
+                // 圆角/阴影放在外层容器：<table> 上的 overflow/border-radius 不生效，
+                // 且 collapse 模式下圆角无法裁剪单元格背景
+                background: "var(--dsw-alias-bg-module-platform, #fff)",
+                borderRadius: 8,
+                overflow: "hidden",
+                boxShadow: "0 1px 3px rgba(0,0,0,0.08)",
+            },
+            table: {
+                width: "100%",
+                borderCollapse: "collapse",
+                fontSize: 14,
+            },
+            th: {
+                padding: "10px 12px",
+                textAlign: "left",
+                // 四边全边框：collapse 模式下相邻边自动合并，
+                // 整张表（含外框）呈现统一闭合的网格线
+                border: "1px solid var(--dsw-alias-border-l2, #eee)",
+                background: "var(--dsw-alias-bg-layer-2, #fafafa)",
+                fontWeight: 600,
+                whiteSpace: "nowrap",
+            },
+            td: {
+                padding: "10px 12px",
+                textAlign: "left",
+                border: "1px solid var(--dsw-alias-border-l2, #eee)",
+                color: "var(--dsw-alias-label-primary, #333)",
+            },
+            code: {
+                background: "var(--dsw-alias-bg-layer-2, #f0f0f0)",
+                padding: "2px 6px",
+                borderRadius: 3,
+                fontSize: 12,
+                fontFamily: "var(--ds-font-family-code, monospace)",
+            },
+            badge: {
+                display: "inline-block",
+                padding: "2px 8px",
+                borderRadius: 10,
+                fontSize: 12,
+                fontWeight: 500,
+                whiteSpace: "nowrap",
+            },
+            badgeOk: {
+                background: "var(--dsw-alias-state-success-bg, #e6f4ea)",
+                color: "var(--dsw-alias-state-success-primary, #1e8e3e)",
+            },
+            badgeFail: {
+                background: "var(--dsw-alias-state-error-bg, #fce8e6)",
+                color: "var(--dsw-alias-state-error-primary, #d32f2f)",
+            },
+            badgeTesting: {
+                background: "var(--dsw-alias-state-info-bg, #e8f0fe)",
+                color: "var(--dsw-alias-state-info-primary, #1967d2)",
+            },
+            badgeSkip: {
+                background: "var(--dsw-alias-bg-layer-2, #f0f0f0)",
+                color: "var(--dsw-alias-label-tertiary, #888)",
+            },
+            badgeIdle: {
+                background: "var(--dsw-alias-bg-layer-2, #f0f0f0)",
+                color: "var(--dsw-alias-label-tertiary, #999)",
+            },
+            center: {
+                textAlign: "center",
+                color: "var(--dsw-alias-label-tertiary, #999)",
+                padding: "40px 0",
+            },
+            error: {
+                color: "var(--dsw-alias-state-error-primary, #d32f2f)",
+                padding: "16px",
+            },
+            loading: {
+                color: "var(--dsw-alias-label-tertiary, #999)",
+                padding: "24px 0",
+                textAlign: "center",
+            },
+            errorMsg: {
+                color: "var(--dsw-alias-state-error-primary, #d32f2f)",
+                fontSize: 12,
+                maxWidth: 200,
+                overflow: "hidden",
+                textOverflow: "ellipsis",
+                whiteSpace: "nowrap",
+            },
+            colToggleLabel: {
+                display: "inline-flex",
+                alignItems: "center",
+                gap: 4,
+                fontSize: 12,
+                cursor: "pointer",
+                color: "var(--dsw-alias-label-secondary, #555)",
+                userSelect: "none",
+            },
+            colToggleCheckbox: {
+                cursor: "pointer",
+            },
+        };
+
+        // 列定义：optional=true 的列默认不显示，由多选框控制
+        const COLUMNS = [
+            { key: "provider", label: "Provider" },
+            { key: "modelId", label: "模型 ID", code: true, optional: true },
+            { key: "modelName", label: "名称" },
+            { key: "contextWindow", label: "上下文窗口", optional: true },
+            { key: "maxTokens", label: "最大输出", optional: true },
+            { key: "input", label: "输入模态", optional: true },
+            { key: "api", label: "API 协议", optional: true },
+            { key: "baseURL", label: "BaseURL", code: true, optional: true },
+            { key: "_status", label: "状态" },
+            { key: "_latency", label: "延迟" },
+        ];
+
+        // 状态标签映射
+        const STATUS_LABEL = {
+            idle: "未测试",
+            testing: "测试中",
+            ok: "可用",
+            fail: "不可用",
+            skip: "跳过",
+        };
+        const STATUS_STYLE = {
+            idle: STYLES.badgeIdle,
+            testing: STYLES.badgeTesting,
+            ok: STYLES.badgeOk,
+            fail: STYLES.badgeFail,
+            skip: STYLES.badgeSkip,
+        };
+
+        /**
+         * 模型列表 section 组件。
+         * fetch /api/model-health/json 获取数据 → React 渲染表格。
+         * "测试全部" → 并发 POST /api/model-health/test，逐个更新状态。
+         */
+        // localStorage 持久化测试结果的 key
+        const STORAGE_KEY = "dsh-model-health:test-results";
+
+        function loadStoredResults() {
+            try {
+                const raw = localStorage.getItem(STORAGE_KEY);
+                return raw ? JSON.parse(raw) : {};
+            } catch (e) {
+                return {};
+            }
+        }
+
+        function saveStoredResults(results) {
+            try {
+                localStorage.setItem(STORAGE_KEY, JSON.stringify(results));
+            } catch (e) {
+                // ignore quota errors
+            }
+        }
+
+        function ModelListSection() {
+            const [state, setState] = useState({
+                loading: true,
+                error: null,
+                data: null,
+            });
+            // testResults: { [index]: { status, latency?, error? } }
+            // 初始值从 localStorage 读取，实现跨刷新持久化
+            const [testResults, setTestResults] = useState(loadStoredResults);
+            const [testing, setTesting] = useState(false);
+            const [progress, setProgress] = useState({ done: 0, total: 0 });
+            // 可选列显示状态：{ [colKey]: boolean }，默认 false
+            const [optionalCols, setOptionalCols] = useState({});
+            // hover tooltip 状态：{ index, error } | null
+            const [tooltip, setTooltip] = useState(null);
+
+            const loadData = useCallback(async () => {
+                setState((s) => ({ ...s, loading: true, error: null }));
+                try {
+                    const resp = await fetch("/api/model-health/json", { cache: "no-store" });
+                    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+                    const json = await resp.json();
+                    if (!json.ok) throw new Error(json.error || "未知错误");
+                    setState({ loading: false, error: null, data: json });
+                    // 不清空 testResults，保留上次测试结果
+                } catch (e) {
+                    setState({ loading: false, error: e.message, data: null });
+                }
+            }, []);
+
+            useEffect(() => {
+                loadData();
+            }, [loadData]);
+
+            // 测试全部：并发发起所有测试请求，每个完成即更新对应行状态
+            const testAll = useCallback(async () => {
+                const data = state.data;
+                if (!data || !data.models || data.models.length === 0) return;
+                const total = data.models.length;
+                setTesting(true);
+                setProgress({ done: 0, total });
+                // 初始化所有为 testing
+                const init = {};
+                for (let i = 0; i < total; i++) init[i] = { status: "testing" };
+                setTestResults(init);
+                saveStoredResults(init);
+
+                let done = 0;
+                // 并发测试，但限制并发数避免压垮 host/网络
+                const CONCURRENCY = 6;
+                const indices = Array.from({ length: total }, (_, i) => i);
+                const queue = [...indices];
+
+                // 更新单个结果并同步到 localStorage
+                function updateResult(idx, result) {
+                    setTestResults((s) => {
+                        const next = { ...s, [idx]: result };
+                        saveStoredResults(next);
+                        return next;
+                    });
+                }
+
+                async function runOne(idx) {
+                    try {
+                        const resp = await fetch("/api/model-health/test", {
+                            method: "POST",
+                            headers: { "Content-Type": "application/json" },
+                            body: JSON.stringify({ index: idx }),
+                            cache: "no-store",
+                        });
+                        const json = await resp.json();
+                        if (!json.ok) {
+                            updateResult(idx, { status: "fail", error: json.error });
+                        } else {
+                            updateResult(idx, {
+                                status: json.status || "fail",
+                                latency: json.latency,
+                                error: json.error,
+                            });
+                        }
+                    } catch (e) {
+                        updateResult(idx, { status: "fail", error: e.message });
+                    } finally {
+                        done++;
+                        setProgress({ done, total });
+                        if (done >= total) setTesting(false);
+                    }
+                }
+
+                // 限制并发的 worker pool
+                async function worker() {
+                    while (queue.length > 0) {
+                        const idx = queue.shift();
+                        if (idx === undefined) break;
+                        await runOne(idx);
+                    }
+                }
+                const workers = Array.from(
+                    { length: Math.min(CONCURRENCY, total) },
+                    () => worker()
+                );
+                await Promise.all(workers);
+            }, [state.data]);
+
+            const h = React.createElement;
+
+            if (state.loading) {
+                return h("div", { style: STYLES.wrap },
+                    h("div", { style: STYLES.loading }, "加载中...")
+                );
+            }
+
+            if (state.error) {
+                return h("div", { style: STYLES.wrap },
+                    h("div", { style: STYLES.error },
+                        "读取模型列表失败：", state.error
+                    ),
+                    h("button", {
+                        style: STYLES.btn,
+                        onClick: loadData,
+                    }, "重试")
+                );
+            }
+
+            const data = state.data || { models: [], count: 0, source: "", updatedAt: "" };
+            const models = data.models || [];
+            const updatedAt = new Date(data.updatedAt || Date.now()).toLocaleString("zh-CN");
+
+            // 统计测试结果
+            const stats = { ok: 0, fail: 0, skip: 0, testing: 0 };
+            for (const k in testResults) {
+                const s = testResults[k].status;
+                if (s === "ok") stats.ok++;
+                else if (s === "fail") stats.fail++;
+                else if (s === "skip") stats.skip++;
+                else if (s === "testing") stats.testing++;
+            }
+
+            // 可见列：非可选列始终显示；可选列根据 optionalCols 状态
+            const visibleCols = COLUMNS.filter(
+                (col) => !col.optional || optionalCols[col.key]
+            );
+            const optionalColumns = COLUMNS.filter((col) => col.optional);
+
+            const toggleCol = (key) => {
+                setOptionalCols((s) => ({ ...s, [key]: !s[key] }));
+            };
+
+            return h("div", { style: STYLES.wrap },
+                h("div", { style: STYLES.head },
+                    h("h2", { style: STYLES.title }, "已配置模型"),
+                    h("span", { style: STYLES.count }, data.count || models.length)
+                ),
+                h("div", { style: STYLES.toolbar },
+                    h("span", { style: STYLES.meta },
+                        "更新时间：", updatedAt
+                    ),
+                    // 测试统计
+                    (stats.ok + stats.fail + stats.skip > 0) && h("span", { style: STYLES.progress },
+                        `✓ ${stats.ok}  ✗ ${stats.fail}`,
+                        stats.skip > 0 ? `  ⊘ ${stats.skip}` : ""
+                    ),
+                    testing && h("span", { style: STYLES.progress },
+                        `${progress.done}/${progress.total}`
+                    ),
+                    // 测试全部按钮
+                    h("button", {
+                        style: {
+                            ...STYLES.btn,
+                            ...STYLES.btnPrimary,
+                            ...(testing ? STYLES.btnDisabled : {}),
+                        },
+                        disabled: testing || models.length === 0,
+                        onClick: testAll,
+                    }, testing ? "测试中..." : "测试全部")
+                ),
+                // 可选列 toggle 按钮组
+                h("div", { style: { display: "flex", alignItems: "center", gap: 8, flexWrap: "wrap" } },
+                    h("span", { style: { fontSize: 12, color: "var(--dsw-alias-label-tertiary, #888)" } },
+                        "显示列："
+                    ),
+                    optionalColumns.map((col) => {
+                        const active = !!optionalCols[col.key];
+                        return h("button", {
+                            key: col.key,
+                            onClick: () => toggleCol(col.key),
+                            style: {
+                                boxSizing: "border-box",
+                                height: 24,
+                                padding: "0 10px",
+                                fontSize: 12,
+                                cursor: "pointer",
+                                border: active
+                                    ? "1px solid var(--dsw-alias-button-primary-fill, #4f46e5)"
+                                    : "1px solid var(--dsw-alias-border-l2, #ddd)",
+                                borderRadius: 12,
+                                background: active
+                                    ? "var(--dsw-alias-button-primary-fill, #4f46e5)"
+                                    : "transparent",
+                                color: active
+                                    ? "var(--dsw-alias-label-primary-foreground, #fff)"
+                                    : "var(--dsw-alias-label-secondary, #555)",
+                            },
+                        }, col.label);
+                    })
+                ),
+                models.length === 0
+                    ? h("div", { style: STYLES.center },
+                        "未配置任何模型，请在 设置 → 模型 中添加。"
+                    )
+                    : h("div", { style: STYLES.tableWrap },
+                        h("table", { style: STYLES.table },
+                        h("thead", null,
+                            h("tr", null,
+                                visibleCols.map((col) =>
+                                    h("th", {
+                                        key: col.key,
+                                        style: STYLES.th,
+                                    }, col.label)
+                                )
+                            )
+                        ),
+                        h("tbody", null,
+                            // 预计算 provider 连续段的 rowspan：{ [startIdx]: spanLen }
+                            // 相同 provider 的连续行合并为一个单元格
+                            (() => {
+                                const providerSpan = {};
+                                let k = 0;
+                                while (k < models.length) {
+                                    const start = k;
+                                    const p = models[k].provider;
+                                    while (k < models.length && models[k].provider === p) k++;
+                                    providerSpan[start] = k - start;
+                                }
+                                return models.map((row, i) => {
+                                    const tr = testResults[i] || { status: "idle" };
+                                    const statusLabel = STATUS_LABEL[tr.status] || tr.status;
+                                    const statusStyle = STATUS_STYLE[tr.status] || STYLES.badgeIdle;
+                                    const latencyText = tr.latency != null ? `${tr.latency}ms` : "-";
+                                    return h("tr", { key: (row.modelId || "") + i },
+                                        visibleCols.map((col) => {
+                                            if (col.key === "provider") {
+                                                const span = providerSpan[i];
+                                                if (span === undefined) return null; // 被合并，跳过
+                                                return h("td", {
+                                                    key: col.key,
+                                                    rowSpan: span,
+                                                    style: { ...STYLES.td, verticalAlign: "middle", fontWeight: 600 },
+                                                }, row.provider);
+                                            }
+                                            if (col.key === "_status") {
+                                                const hasError = tr.error && tr.status === "fail";
+                                                return h("td", {
+                                                    key: col.key,
+                                                    style: { ...STYLES.td },
+                                                },
+                                                    h("span", {
+                                                        style: {
+                                                            ...STYLES.badge,
+                                                            ...statusStyle,
+                                                            cursor: hasError ? "help" : "default",
+                                                        },
+                                                        onMouseEnter: hasError
+                                                            ? (e) => {
+                                                                const rowEl = e.currentTarget.closest('tr');
+                                                                const tableEl = e.currentTarget.closest('table');
+                                                                if (rowEl && tableEl) {
+                                                                    const rowRect = rowEl.getBoundingClientRect();
+                                                                    const tableRect = tableEl.getBoundingClientRect();
+                                                                    setTooltip({
+                                                                        index: i,
+                                                                        error: tr.error,
+                                                                        left: tableRect.left,
+                                                                        width: tableRect.width,
+                                                                        rowTop: rowRect.top,
+                                                                    });
+                                                                }
+                                                            }
+                                                            : undefined,
+                                                        onMouseLeave: hasError
+                                                            ? () => setTooltip(null)
+                                                            : undefined,
+                                                    }, statusLabel)
+                                                );
+                                            }
+                                            if (col.key === "_latency") {
+                                                return h("td", { key: col.key, style: STYLES.td }, latencyText);
+                                            }
+                                            const value = row[col.key] ?? "-";
+                                            return h("td", {
+                                                key: col.key,
+                                                style: STYLES.td,
+                                            },
+                                                col.code
+                                                    ? h("code", { style: STYLES.code }, String(value))
+                                                    : String(value)
+                                            );
+                                        })
+                                    );
+                                });
+                            })()
+                        )
+                        )
+                    ),
+                // 全宽 hover tooltip：横向占满表格，显示在所悬停行的正上方
+                tooltip ? h("div", {
+                    style: {
+                        position: "fixed",
+                        left: tooltip.left + "px",
+                        width: tooltip.width + "px",
+                        top: tooltip.rowTop + "px",
+                        transform: "translateY(-100%)",
+                        marginTop: -4,
+                        padding: "8px 12px",
+                        background: "var(--dsw-alias-state-error-bg, #2a2a2a)",
+                        color: "var(--dsw-alias-state-error-primary, #ff6b6b)",
+                        fontSize: 12,
+                        lineHeight: "16px",
+                        borderRadius: 6,
+                        whiteSpace: "pre-wrap",
+                        wordBreak: "break-all",
+                        zIndex: 1000,
+                        boxShadow: "0 4px 12px rgba(0,0,0,0.15)",
+                        border: "1px solid var(--dsw-alias-border-l2, #444)",
+                        pointerEvents: "none",
+                    },
+                }, tooltip.error) : null
+            );
+        }
+
+        // client 侧依赖：slots（注册 UI slot 的服务）
+        const inject = ["slots"];
+
+        /**
+         * @param {import('@deepseek-ai/dsh-client-runtime/client').ClientContext} ctx
+         */
+        function apply(ctx) {
+            ctx.slots.inject("settings.section", () =>
+                ctx.slots.register(
+                    {
+                        name: "settings.section",
+                        id: "model-health",
+                        order: 50,
+                        label: "模型健康",
+                    },
+                    ModelListSection
+                )
+            );
+        }
+
+        exports.apply = apply;
+        exports.inject = inject;
+        return module.exports;
+    }
+});

package/dist/index.js

@@ -0,0 +1,275 @@
+import { defineTool } from '@deepseek-ai/dsh-tools';
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { load as parseYaml } from 'js-yaml';
+export const name = 'dsh-model-health';
+// 声明所有用到的服务：
+// - tools：Tool 插件
+// - webServer：HTTP 路由
+// - credentials：通过 apiKeyEnv 名解析实际 API Key（DSH 的 credential seam）
+export const inject = ['tools', 'webServer', 'credentials'];
+/** JSON 输出时去掉 apiKeyEnv（不暴露到浏览器） */
+function toPublicRow(r) {
+    const { apiKeyEnv: _omit, ...public_ } = r;
+    return public_;
+}
+/** 解析 DSH 配置目录：优先 $DSH_HOME，回退到 ~/.dsh。 */
+function dshHome() {
+    return process.env.DSH_HOME || join(homedir(), '.dsh');
+}
+/** 读取并解析 settings.yaml。 */
+function readSettings() {
+    const settingsPath = join(dshHome(), 'settings.yaml');
+    let raw;
+    try {
+        raw = readFileSync(settingsPath, 'utf8');
+    }
+    catch (e) {
+        throw new Error(`无法读取 settings.yaml (${settingsPath})：${e.message}。` +
+            `请在 设置 → 模型 中配置后重试。`);
+    }
+    const cfg = parseYaml(raw);
+    return cfg && typeof cfg === 'object' ? cfg : {};
+}
+/** 从 settings 配置对象中收集所有已配置的模型。 */
+export function collectModels(cfg) {
+    const rows = [];
+    // 1. 通用多协议提供商 llm-pi-ai
+    const piAi = cfg['llm-pi-ai'];
+    if (piAi && typeof piAi === 'object') {
+        const providers = piAi.providers || {};
+        for (const [route, p] of Object.entries(providers)) {
+            if (!p || typeof p !== 'object')
+                continue;
+            const models = Array.isArray(p.models) ? p.models : [];
+            for (const m of models) {
+                rows.push({
+                    provider: route,
+                    displayName: p.displayName || route,
+                    modelId: m.id || '',
+                    modelName: m.name || m.id || '',
+                    contextWindow: m.contextWindow ?? p.defaultContextWindow ?? '-',
+                    maxTokens: m.maxTokens ?? p.defaultMaxTokens ?? '-',
+                    input: Array.isArray(m.input) ? m.input.join('/')
+                        : (p.defaultInput || ['text']).join('/'),
+                    api: p.api || '-',
+                    baseURL: p.baseURL || '-',
+                    apiKeyEnv: p.apiKeyEnv || '',
+                });
+            }
+        }
+    }
+    // 2. 官方 DeepSeek 提供商 llm-deepseek
+    const ds = cfg['llm-deepseek'];
+    if (ds && typeof ds === 'object') {
+        const models = Array.isArray(ds.models) ? ds.models : [];
+        for (const m of models) {
+            rows.push({
+                provider: 'deepseek',
+                displayName: 'DeepSeek',
+                modelId: m.id || '',
+                modelName: m.name || m.id || '',
+                contextWindow: m.contextWindow ?? '-',
+                maxTokens: m.maxTokens ?? '-',
+                input: Array.isArray(m.input) ? m.input.join('/') : 'text',
+                api: 'deepseek',
+                baseURL: 'https://api.deepseek.com',
+                apiKeyEnv: ds.apiKeyEnv || 'DEEPSEEK_API_KEY',
+            });
+        }
+    }
+    return rows;
+}
+/** 渲染为 Markdown 表格。 */
+function renderMarkdownTable(rows) {
+    if (rows.length === 0) {
+        return [
+            '当前 settings.yaml 中未配置任何模型。',
+            '',
+            '请在 Web UI 的 设置 → 模型 中添加 DeepSeek API Key 或自定义提供商。',
+            `配置文件位置：${join(dshHome(), 'settings.yaml')}`,
+        ].join('\n');
+    }
+    const header = '| # | Provider | 模型 ID | 名称 | 上下文窗口 | 最大输出 | 输入模态 | API 协议 | BaseURL |';
+    const sep = '|---|----------|---------|------|-----------|---------|---------|---------|---------|';
+    const lines = rows.map((r, i) => {
+        return `| ${i + 1} | ${r.provider} | ${r.modelId} | ${r.modelName} | ${r.contextWindow} | ${r.maxTokens} | ${r.input} | ${r.api} | ${r.baseURL} |`;
+    });
+    return [
+        `已配置 **${rows.length}** 个模型：`,
+        '',
+        header,
+        sep,
+        ...lines,
+        '',
+        `_来源：${join(dshHome(), 'settings.yaml')}_`,
+    ].join('\n');
+}
+export function apply(ctx) {
+    // ── 1. Tool 插件（对话中调用，返回 Markdown 表格）──────────────────
+    ctx.tools.register(defineTool({
+        name: 'list_models',
+        description: '列出当前 DSH 配置（$DSH_HOME/settings.yaml）中已配置的所有模型，' +
+            '以 Markdown 表格展示。用于在对话中查看当前可用模型清单。',
+        parameters: {},
+        output: {
+            schema: { type: 'string' },
+            render: (_args, value) => [{ type: 'text', text: value }],
+        },
+        async execute() {
+            const cfg = readSettings();
+            return renderMarkdownTable(collectModels(cfg));
+        },
+    }));
+    // ── 2. HTTP 路由（返回 JSON，供 client 侧 React 组件 fetch）─────────
+    //    API: ctx.webServer.register({ kind, path, handler })
+    //    handler 签名: (req: IncomingMessage, res: ServerResponse) => void
+    ctx.webServer.register({
+        kind: 'exact',
+        path: '/api/model-health/json',
+        handler: (_req, res) => {
+            try {
+                const cfg = readSettings();
+                const rows = collectModels(cfg);
+                const payload = JSON.stringify({
+                    ok: true,
+                    count: rows.length,
+                    source: join(dshHome(), 'settings.yaml'),
+                    updatedAt: new Date().toISOString(),
+                    models: rows.map(toPublicRow),
+                });
+                res.setHeader('Content-Type', 'application/json; charset=utf-8');
+                res.end(payload);
+            }
+            catch (e) {
+                const payload = JSON.stringify({
+                    ok: false,
+                    error: `读取模型列表失败：${e.message}`,
+                });
+                res.statusCode = 500;
+                res.setHeader('Content-Type', 'application/json; charset=utf-8');
+                res.end(payload);
+            }
+        },
+    });
+    // ── 3. HTTP 路由（测试单个模型可用性）──────────────────────────────
+    //    POST /api/model-health/test  body: { "index": <number> }
+    //    对该模型发起一次最小 chat completions 请求，返回 { ok, index, status, latency, error? }
+    ctx.webServer.register({
+        kind: 'exact',
+        path: '/api/model-health/test',
+        handler: async (req, res) => {
+            // 读取请求体
+            let body = '';
+            for await (const chunk of req)
+                body += chunk;
+            let index;
+            try {
+                index = JSON.parse(body || '{}').index;
+                if (typeof index !== 'number' || !Number.isInteger(index) || index < 0) {
+                    throw new Error('index 必须是非负整数');
+                }
+            }
+            catch (e) {
+                res.statusCode = 400;
+                res.setHeader('Content-Type', 'application/json; charset=utf-8');
+                res.end(JSON.stringify({ ok: false, error: `参数错误：${e.message}` }));
+                return;
+            }
+            // 查找模型配置
+            let row;
+            try {
+                const cfg = readSettings();
+                const rows = collectModels(cfg);
+                const found = rows[index];
+                if (!found) {
+                    res.statusCode = 404;
+                    res.setHeader('Content-Type', 'application/json; charset=utf-8');
+                    res.end(JSON.stringify({ ok: false, error: `未找到索引为 ${index} 的模型` }));
+                    return;
+                }
+                row = found;
+            }
+            catch (e) {
+                res.statusCode = 500;
+                res.setHeader('Content-Type', 'application/json; charset=utf-8');
+                res.end(JSON.stringify({ ok: false, error: e.message }));
+                return;
+            }
+            // 仅支持 openai-completions 协议
+            if (row.api !== 'openai-completions' && row.api !== 'deepseek') {
+                res.setHeader('Content-Type', 'application/json; charset=utf-8');
+                res.end(JSON.stringify({
+                    ok: true, index, status: 'skip',
+                    error: `不支持 ${row.api} 协议的测试`,
+                }));
+                return;
+            }
+            // 获取 API Key
+            // 通过 DSH credential service 解析 API Key
+            // credentials.resolve(ref) 从 DSH 的 secret store 读取，无需进程环境变量
+            let apiKey = '';
+            if (row.apiKeyEnv) {
+                try {
+                    const hit = await ctx.credentials.resolve(row.apiKeyEnv);
+                    apiKey = hit?.value || '';
+                }
+                catch (e) {
+                    // resolve 可能抛错（如 ref 未配置），按未设置处理
+                }
+            }
+            if (!apiKey) {
+                res.setHeader('Content-Type', 'application/json; charset=utf-8');
+                res.end(JSON.stringify({
+                    ok: true, index, status: 'fail',
+                    error: `未配置 ${row.apiKeyEnv} 的 API Key（请在 设置 → 模型 中添加）`,
+                }));
+                return;
+            }
+            // 发起最小测试请求（max_tokens=1，超时 10s）
+            const url = row.baseURL.replace(/\/$/, '') + '/chat/completions';
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), 10000);
+            const start = Date.now();
+            try {
+                const resp = await fetch(url, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${apiKey}`,
+                    },
+                    body: JSON.stringify({
+                        model: row.modelId,
+                        messages: [{ role: 'user', content: 'hi' }],
+                        max_tokens: 1,
+                        stream: false,
+                    }),
+                    signal: controller.signal,
+                });
+                clearTimeout(timer);
+                const latency = Date.now() - start;
+                if (resp.ok) {
+                    res.setHeader('Content-Type', 'application/json; charset=utf-8');
+                    res.end(JSON.stringify({ ok: true, index, status: 'ok', latency }));
+                }
+                else {
+                    const text = await resp.text().catch(() => '');
+                    res.setHeader('Content-Type', 'application/json; charset=utf-8');
+                    res.end(JSON.stringify({
+                        ok: true, index, status: 'fail', latency,
+                        error: `HTTP ${resp.status}: ${text.slice(0, 300)}`,
+                    }));
+                }
+            }
+            catch (e) {
+                clearTimeout(timer);
+                const latency = Date.now() - start;
+                const msg = e?.name === 'AbortError' ? '超时（10s）' : (e?.message || String(e));
+                res.setHeader('Content-Type', 'application/json; charset=utf-8');
+                res.end(JSON.stringify({ ok: true, index, status: 'fail', latency, error: msg }));
+            }
+        },
+    });
+    console.log(`[dsh-model-health] ready — tool "list_models" + routes GET /api/model-health/json, POST /api/model-health/test`);
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "dsh-model-health",
+  "version": "0.1.0",
+  "description": "DSH plugin that lists all configured models with availability/latency testing, by reading $DSH_HOME/settings.yaml.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": "./dist/index.js",
+    "./client": "./dist/client.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "cordis.patch.yml"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-ui-settings"
+      ],
+      "platform": "web"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node -e \"fs.cpSync('src/client.js', 'dist/client.js')\"",
+    "prepare": "pnpm run build",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "dependencies": {
+    "@deepseek-ai/dsh-tools": "0.1.0-rc.8",
+    "js-yaml": "^4.1.0"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^22.10.0",
+    "typescript": "^5.6.0"
+  }
+}