dsh-model 0.0.1 → 0.14.0

package/dist/engine/client.js

@@ -0,0 +1,104 @@
+// engine/client.ts — 调本机引擎的 HTTP 端点
+export function baseUrl(port) {
+    return `http://127.0.0.1:${port}`;
+}
+async function get(url, key, timeoutMs = 3000) {
+    return fetch(url, { headers: key ? { Authorization: `Bearer ${key}` } : {}, signal: AbortSignal.timeout(timeoutMs) });
+}
+export async function healthy(port) {
+    try {
+        return (await get(`${baseUrl(port)}/healthz`)).ok;
+    }
+    catch {
+        return false;
+    }
+}
+export async function waitHealthy(port, timeoutMs = 10_000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (await healthy(port))
+            return true;
+        await new Promise((r) => setTimeout(r, 300));
+    }
+    return false;
+}
+/** 不带 key 访问 /v1/models 的状态码（期望 401：说明鉴权生效） */
+export async function unauthStatus(port) {
+    try {
+        return (await get(`${baseUrl(port)}/v1/models`)).status;
+    }
+    catch {
+        return null;
+    }
+}
+export async function listModels(port, key) {
+    const res = await get(`${baseUrl(port)}/v1/models`, key);
+    if (!res.ok)
+        throw new Error(`GET /v1/models: HTTP ${res.status}`);
+    const body = (await res.json());
+    return (body.data ?? []).filter((m) => typeof m.id === 'string' && m.id);
+}
+/** 等引擎热重载后模型列表变化（login/logout 之后），最多 timeoutMs；返回最后一次结果 */
+export async function waitModelsChange(port, key, before, timeoutMs = 4000) {
+    const deadline = Date.now() + timeoutMs;
+    const sig = (ms) => ms.map((m) => m.id).sort().join('\n');
+    const prev = [...before].sort().join('\n');
+    let last = [];
+    while (Date.now() < deadline) {
+        try {
+            last = await listModels(port, key);
+            if (sig(last) !== prev)
+                return last;
+        }
+        catch {
+            // 引擎重载中
+        }
+        await new Promise((r) => setTimeout(r, 400));
+    }
+    return last;
+}
+/** e2e：流式请求，期望收到内容并以 [DONE] 收尾 */
+export async function probeStream(port, key, model) {
+    try {
+        const res = await fetch(`${baseUrl(port)}/v1/chat/completions`, {
+            method: 'POST',
+            headers: { Authorization: `Bearer ${key}`, 'Content-Type': 'application/json' },
+            body: JSON.stringify({ model, stream: true, max_tokens: 16, messages: [{ role: 'user', content: 'Reply with: ok' }] }),
+            signal: AbortSignal.timeout(60_000),
+        });
+        if (!res.ok)
+            return { ok: false, detail: `HTTP ${res.status} ${(await res.text()).slice(0, 160)}` };
+        const text = await res.text();
+        const gotContent = /"content"\s*:\s*"[^"]/.test(text) || /"reasoning(_content)?"\s*:\s*"[^"]/.test(text);
+        const done = text.includes('[DONE]');
+        return { ok: gotContent && done, detail: gotContent ? (done ? 'ok' : 'no [DONE]') : 'no content' };
+    }
+    catch (error) {
+        return { ok: false, detail: String(error.message) };
+    }
+}
+/** e2e：工具调用，期望返回 get_time 的 tool_call */
+export async function probeToolCall(port, key, model) {
+    try {
+        const res = await fetch(`${baseUrl(port)}/v1/chat/completions`, {
+            method: 'POST',
+            headers: { Authorization: `Bearer ${key}`, 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                model,
+                stream: false,
+                messages: [{ role: 'user', content: 'What time is it now? Use the get_time tool.' }],
+                tools: [{ type: 'function', function: { name: 'get_time', description: 'Get the current time', parameters: { type: 'object', properties: {} } } }],
+                tool_choice: 'required',
+            }),
+            signal: AbortSignal.timeout(90_000),
+        });
+        if (!res.ok)
+            return { ok: false, detail: `HTTP ${res.status} ${(await res.text()).slice(0, 160)}` };
+        const body = (await res.json());
+        const name = body.choices?.[0]?.message?.tool_calls?.[0]?.function?.name;
+        return { ok: name === 'get_time', detail: name ? `tool_call ${name}` : 'no tool_call' };
+    }
+    catch (error) {
+        return { ok: false, detail: String(error.message) };
+    }
+}

package/dist/engine/compat.js

@@ -0,0 +1,94 @@
+// engine/compat.ts — 挂到引擎的 openai-compatibility 上游：OpenCode Zen 与 WorkBuddy bridge
+//
+// 客户端看到的模型名带前缀（alias = <prefix>/<上游 id>），和订阅模型分开，也方便 dsh 里分组。
+// bridge 在本机回环：强制 proxy-url: direct，否则全局代理会把对 127.0.0.1 的请求也转走。
+import { join } from 'node:path';
+import { bridgeConfigPath, loadCatalogs } from '../bridge/runtime.js';
+import { loadSecrets } from '../secrets.js';
+import { readJson } from '../util/fs.js';
+export const OPENCODE_BASE = 'https://opencode.ai/zen/v1';
+export const OPENCODE_PREFIX = 'opencode';
+export function opencodeModelsPath(ctx) {
+    return join(ctx.paths.home, 'opencode-models.json');
+}
+export async function loadCompatUpstreams(ctx) {
+    const out = [];
+    const secrets = await loadSecrets(ctx);
+    const disabled = new Set((await readJson(join(ctx.paths.home, 'config.json')))?.disabledSources ?? []);
+    if (secrets.opencode?.key && !disabled.has('opencode')) {
+        const list = await readJson(opencodeModelsPath(ctx));
+        const models = (list?.models ?? []).map((m) => ({
+            name: m.id,
+            alias: `${OPENCODE_PREFIX}/${m.id}`,
+            displayName: `OpenCode · ${m.id}`,
+            dshName: /-free$|^big-pickle$/.test(m.id) ? `${m.id} · Free` : m.id,
+            group: 'opencode',
+            groupLabel: 'OpenCode Zen',
+        }));
+        if (models.length)
+            out.push({ name: 'opencode', label: 'OpenCode Zen', baseUrl: OPENCODE_BASE, apiKey: secrets.opencode.key, models });
+    }
+    const bridge = await readJson(bridgeConfigPath(ctx.paths.home));
+    if (bridge) {
+        for (const c of await loadCatalogs(ctx.paths.home)) {
+            if (!c.signedIn || !c.models.length || disabled.has(c.prefix))
+                continue;
+            out.push({
+                name: c.prefix,
+                label: c.label,
+                baseUrl: `http://127.0.0.1:${bridge.port}/${c.key}/v1`,
+                apiKey: bridge.secret,
+                direct: true,
+                models: (() => {
+                    // 同组里重名（如 hy3 与 hy3-x 都叫 Hy3）就在名字后加上 id 区分
+                    const count = new Map();
+                    for (const m of c.models)
+                        count.set(m.name || m.id, (count.get(m.name || m.id) ?? 0) + 1);
+                    return c.models.map((m) => {
+                        const base = m.name || m.id;
+                        const name = (count.get(base) ?? 0) > 1 ? `${base} (${m.id})` : base;
+                        const billing = m.billing;
+                        const rate = billing?.credits?.replace(/\s*credits?$/i, '').trim();
+                        const tags = [rate, ...(billing?.badges ?? [])].filter((x) => Boolean(x));
+                        return {
+                            name: m.id,
+                            alias: `${c.prefix}/${m.id}`,
+                            displayName: `${c.label} · ${base}`,
+                            dshName: [name, ...tags].join(' · '),
+                            ...(rate && /^x?\d+(\.\d+)?$/i.test(rate) ? { rate: Number(rate.replace(/^x/i, '')) } : {}),
+                            group: c.prefix,
+                            groupLabel: c.label,
+                            contextWindow: m.contextWindow,
+                            maxTokens: m.maxTokens,
+                            image: m.supportsImages,
+                        };
+                    });
+                })(),
+            });
+        }
+    }
+    return out;
+}
+/** 渲染成引擎 v8 的 api-keys.openai-compatibility 段 */
+export function renderCompat(upstreams) {
+    return upstreams.map((u) => ({
+        name: u.name,
+        'base-url': u.baseUrl,
+        keys: [{ 'api-key': u.apiKey, ...(u.direct ? { 'proxy-url': 'direct' } : {}) }],
+        models: u.models.map((m) => ({
+            name: m.name,
+            alias: m.alias,
+            ...(m.displayName ? { 'display-name': m.displayName } : {}),
+            ...(m.contextWindow ? { 'max-context-length': m.contextWindow } : {}),
+            'input-modalities': m.image ? ['text', 'image'] : ['text'],
+        })),
+    }));
+}
+/** 给 dsh 的模型清单补元数据（名字、上下文、图片） */
+export function compatModelIndex(upstreams) {
+    const map = new Map();
+    for (const u of upstreams)
+        for (const m of u.models)
+            map.set(m.alias, m);
+    return map;
+}

package/dist/engine/config.js

@@ -0,0 +1,47 @@
+// engine/config.ts — 由 config.json + keys.json 生成 engine.yaml（CLIProxyAPI v8 格式）
+//
+// 安全底线：api-keys 为空时引擎完全不鉴权（实测），所以没有可用 key 就拒绝生成。
+import YAML from 'yaml';
+import { DshModelError } from '../errors.js';
+import { L } from '../i18n.js';
+import { activeKeys } from '../keys.js';
+import { readText, writeInPlace } from '../util/fs.js';
+import { loadCompatUpstreams, renderCompat } from './compat.js';
+import { ensureMgmt } from './mgmt.js';
+const HEADER = [
+    '# GENERATED BY dsh-model — DO NOT EDIT. Run `dsh-model setup` to regenerate.',
+    '# 由 dsh-model 生成，请勿手改。需要重新生成请执行 `dsh-model setup`。',
+].join('\n');
+export function renderEngineConfig(ctx, config, keys, port = config.port, compat = [], mgmtSecret = '') {
+    const apiKeys = activeKeys(keys).map((k) => k.key);
+    if (apiKeys.length === 0) {
+        throw new DshModelError('no_api_keys', L('没有可用的 key，拒绝生成引擎配置（空 key 列表会让引擎不做鉴权）', 'No active keys; refusing to write engine config (an empty key list disables engine auth)'));
+    }
+    const doc = {
+        'config-version': 8,
+        server: { host: '127.0.0.1', port },
+        // 管理接口：有密钥才打开（只监听本机、不开网页控制台），给 dsh-model 自己做登录 / 开关 / 用量统计（设计 §14.4）
+        management: { 'allow-remote': false, 'secret-key': mgmtSecret, 'disable-control-panel': true },
+        access: { 'api-keys': apiKeys },
+        oauth: { 'auth-dir': ctx.paths.auth },
+        routing: { strategy: 'fill-first' },
+        ...(config.proxy ? { requests: { 'proxy-url': config.proxy } } : {}),
+        ...(compat.length ? { 'api-keys': { 'openai-compatibility': renderCompat(compat) } } : {}),
+        observability: {
+            logs: { 'logging-to-file': true, 'logs-max-total-size-mb': 50, 'request-log': false },
+            // 用量记录给守护进程统计 key / 来源 / 模型的速度与稳定性；它每 5 秒取一次，保留 10 分钟足够兜住停顿
+            ...(mgmtSecret ? { usage: { 'usage-statistics-enabled': true, 'redis-usage-queue-retention-seconds': 600 } } : {}),
+        },
+    };
+    return `${HEADER}\n${YAML.stringify(doc)}`;
+}
+/** 写 engine.yaml；内容没变就不动（避免引擎无谓的热重载）。返回是否写了 */
+export async function writeEngineConfig(ctx, config, keys) {
+    const mgmt = await ensureMgmt(ctx);
+    const text = renderEngineConfig(ctx, config, keys, config.port, await loadCompatUpstreams(ctx), mgmt.secret);
+    if ((await readText(ctx.paths.engineYaml)) === text)
+        return false;
+    // 原地写：保留 inode，让引擎（含 Linux）的 fsnotify 能收到变化并热重载，谁写都行、不用重启
+    await writeInPlace(ctx.paths.engineYaml, text, { owner: ctx.owner });
+    return true;
+}

package/dist/engine/install.js

@@ -0,0 +1,118 @@
+// engine/install.ts — 下载、校验、解压、切换引擎版本
+//
+// 只信任仓库里 engine-manifest.json 的 sha256；校验不过直接失败。
+// 版本目录 engine/versions/<v>/，current 软链指向在用版本，升级与回滚只切软链。
+import { createWriteStream } from 'node:fs';
+import { chmod, mkdir, readFile, readlink, rename, rm, symlink } from 'node:fs/promises';
+import { join } from 'node:path';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { DshModelError } from '../errors.js';
+import { L } from '../i18n.js';
+import { run } from '../util/exec.js';
+import { ensureDir, exists, sha256 } from '../util/fs.js';
+import { PKG_ROOT } from '../util/pkg.js';
+export const ENGINE_BIN = 'cli-proxy-api';
+export async function loadManifest() {
+    return JSON.parse(await readFile(join(PKG_ROOT, 'engine-manifest.json'), 'utf8'));
+}
+/** darwin-aarch64 / linux-amd64 …（与上游发布包命名一致） */
+export function platformTarget(platform = process.platform, arch = process.arch) {
+    const a = arch === 'arm64' ? 'aarch64' : arch === 'x64' ? 'amd64' : arch;
+    return `${platform}-${a}`;
+}
+export function versionBinary(ctx, version) {
+    return join(ctx.paths.versionsDir, version, ENGINE_BIN);
+}
+export function currentBinary(ctx) {
+    return join(ctx.paths.current, ENGINE_BIN);
+}
+export async function currentVersion(ctx) {
+    try {
+        const target = await readlink(ctx.paths.current);
+        return target.split('/').filter(Boolean).pop() ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/** 从上游发布的 checksums.txt 取某版本的资产（engine upgrade <ver> 指定了清单外版本时用） */
+export async function fetchUpstreamAsset(manifest, version, target) {
+    const [os, arch] = target.split('-');
+    const base = `https://github.com/${manifest.repo}/releases/download/v${version}`;
+    const file = `CLIProxyAPI_${version}_${os}_${arch}.tar.gz`;
+    const res = await fetch(`${base}/checksums.txt`);
+    if (!res.ok)
+        throw new DshModelError('engine_version_not_found', L(`找不到引擎版本 v${version}（HTTP ${res.status}）`, `Engine version v${version} not found (HTTP ${res.status})`));
+    const line = (await res.text()).split('\n').find((l) => l.trim().endsWith(file));
+    const sha = line?.trim().split(/\s+/)[0];
+    if (!sha || !/^[0-9a-f]{64}$/.test(sha))
+        throw new DshModelError('engine_checksum_missing', L(`v${version} 的 checksums.txt 里没有 ${file}`, `${file} is missing from v${version} checksums.txt`));
+    return { file, url: `${base}/${file}`, sha256: sha };
+}
+/**
+ * 安装某版本到 versions/<v>/（已装就跳过）。返回是否真的装了。
+ * DSH_MODEL_ENGINE_ARCHIVE 可指向本地 tar.gz（离线 / 测试），同样要过 sha256 校验。
+ */
+export async function installVersion(ctx, version, asset) {
+    const bin = versionBinary(ctx, version);
+    if (await exists(bin))
+        return false;
+    await ensureDir(ctx.paths.tmp, { owner: ctx.owner });
+    await mkdir(ctx.paths.versionsDir, { recursive: true });
+    const archive = join(ctx.paths.tmp, asset.file);
+    const partial = join(ctx.paths.versionsDir, `${version}.partial`);
+    try {
+        const local = ctx.env.DSH_MODEL_ENGINE_ARCHIVE;
+        let data;
+        if (local) {
+            data = await readFile(local);
+        }
+        else {
+            const res = await fetch(asset.url);
+            if (!res.ok || !res.body)
+                throw new DshModelError('engine_download_failed', L(`下载引擎失败：HTTP ${res.status}`, `Engine download failed: HTTP ${res.status}`), asset.url);
+            await pipeline(Readable.fromWeb(res.body), createWriteStream(archive, { mode: 0o600 }));
+            data = await readFile(archive);
+        }
+        const actual = sha256(data);
+        if (actual !== asset.sha256) {
+            throw new DshModelError('engine_checksum_mismatch', L(`引擎文件校验失败：期望 ${asset.sha256}，实际 ${actual}`, `Engine checksum mismatch: expected ${asset.sha256}, got ${actual}`), L('文件可能被篡改或下载不完整，已中止。', 'The file may be tampered with or incomplete; aborted.'));
+        }
+        if (local) {
+            const { writeFile } = await import('node:fs/promises');
+            await writeFile(archive, data, { mode: 0o600 });
+        }
+        await rm(partial, { recursive: true, force: true });
+        await mkdir(partial, { recursive: true });
+        const tar = await run('tar', ['-xzf', archive, '-C', partial]);
+        if (tar.code !== 0)
+            throw new DshModelError('engine_extract_failed', L(`解压引擎失败：${tar.stderr.trim()}`, `Failed to extract engine: ${tar.stderr.trim()}`));
+        if (!(await exists(join(partial, ENGINE_BIN))))
+            throw new DshModelError('engine_extract_failed', L(`压缩包里没有 ${ENGINE_BIN}`, `${ENGINE_BIN} not found in archive`));
+        await chmod(join(partial, ENGINE_BIN), 0o755);
+        await rename(partial, join(ctx.paths.versionsDir, version));
+        if (ctx.owner)
+            await run('chown', ['-R', `${ctx.owner.uid}:${ctx.owner.gid}`, ctx.paths.engineDir]);
+        return true;
+    }
+    finally {
+        await rm(archive, { force: true });
+        await rm(partial, { recursive: true, force: true });
+    }
+}
+/** 原子切换 current 软链：先建临时软链再 rename 覆盖 */
+export async function activateVersion(ctx, version) {
+    const tmp = `${ctx.paths.current}.tmp`;
+    await rm(tmp, { force: true });
+    await symlink(join('versions', version), tmp);
+    if (ctx.owner)
+        await run('chown', ['-h', `${ctx.owner.uid}:${ctx.owner.gid}`, tmp]);
+    await rename(tmp, ctx.paths.current);
+}
+/** 跑一下二进制读版本号（首行 "CLIProxyAPI Version: 8.0.13, Commit: …"） */
+export async function probeBinaryVersion(bin) {
+    const r = await run(bin, ['-h'], { timeoutMs: 10_000 });
+    const m = (r.stdout + r.stderr).match(/Version:\s*v?(\d+\.\d+\.\d+)/);
+    return m?.[1] ?? null;
+}

package/dist/engine/mgmt.js

@@ -0,0 +1,99 @@
+// engine/mgmt.ts — 引擎管理接口（v8）的客户端
+//
+// 管理接口只监听本机，用随机强密钥（mgmt.json，0600），只有 dsh-model 自己（CLI 与守护进程）使用；
+// 浏览器永远拿不到它。用途：来源登录（OAuth）、停用 / 启用 / 删除凭据、读取用量记录。
+// 接口格式对照 v8.0.13 实测（2026-10-09）：
+//   GET  /oauth/auth-url?provider=  → {status,url,state,flow?:"device",user_code?,expires_in?}
+//   GET  /oauth/status?state=       → {status:"wait"|"ok"|"error", error?}
+//   POST /oauth/callback            ← {provider, redirect_url}（回调式登录：用户把跳转地址贴回来）
+//   DELETE /oauth/session?state=
+//   GET  /credentials               → {files:[...]}
+//   PATCH /credentials/status       ← {name, disabled}
+//   DELETE /credentials?name=
+//   GET  /observability/usage/queue?count=  → 用量记录数组（取走即删）
+import { randomBytes } from 'node:crypto';
+import { join } from 'node:path';
+import { DshModelError } from '../errors.js';
+import { L } from '../i18n.js';
+import { readJson, writeJson } from '../util/fs.js';
+export function mgmtPath(ctx) {
+    return join(ctx.paths.home, 'mgmt.json');
+}
+export async function loadMgmt(ctx) {
+    return readJson(mgmtPath(ctx));
+}
+/** 没有就生成；引擎配置据此打开管理接口 */
+export async function ensureMgmt(ctx) {
+    const existing = await loadMgmt(ctx);
+    if (existing?.secret)
+        return existing;
+    const cfg = { secret: `dshg_${randomBytes(32).toString('base64url')}` };
+    await writeJson(mgmtPath(ctx), cfg, { owner: ctx.owner });
+    return cfg;
+}
+export class Mgmt {
+    port;
+    secret;
+    constructor(port, secret) {
+        this.port = port;
+        this.secret = secret;
+    }
+    static async forCtx(ctx, port) {
+        const cfg = await loadMgmt(ctx);
+        if (!cfg)
+            throw new DshModelError('mgmt_not_configured', L('引擎管理接口还没配置（dsh-model setup）', 'Engine management API not configured (dsh-model setup)'));
+        return new Mgmt(port, cfg.secret);
+    }
+    async call(method, path, body, timeoutMs = 15_000) {
+        const res = await fetch(`http://127.0.0.1:${this.port}/v8/management${path}`, {
+            method,
+            headers: { Authorization: `Bearer ${this.secret}`, ...(body !== undefined ? { 'Content-Type': 'application/json' } : {}) },
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+        const text = await res.text();
+        let data = undefined;
+        try {
+            data = text ? JSON.parse(text) : undefined;
+        }
+        catch {
+            // 非 JSON
+        }
+        if (!res.ok) {
+            const msg = data?.error ?? text.slice(0, 200);
+            throw new DshModelError('mgmt_error', L(`引擎管理接口 ${method} ${path} 失败（HTTP ${res.status}）：${msg}`, `Engine management ${method} ${path} failed (HTTP ${res.status}): ${msg}`));
+        }
+        return data;
+    }
+    authUrl(provider) {
+        return this.call('GET', `/oauth/auth-url?provider=${encodeURIComponent(provider)}`);
+    }
+    oauthStatus(state) {
+        // 未知 state 也返回 200 + {status:"error"}，不当异常
+        return this.call('GET', `/oauth/status?state=${encodeURIComponent(state)}`);
+    }
+    oauthCallback(provider, redirectUrl) {
+        return this.call('POST', '/oauth/callback', { provider, redirect_url: redirectUrl });
+    }
+    cancel(state) {
+        return this.call('DELETE', `/oauth/session?state=${encodeURIComponent(state)}`);
+    }
+    async credentials() {
+        const r = await this.call('GET', '/credentials');
+        return r.files ?? [];
+    }
+    async credentialModels(name) {
+        const r = await this.call('GET', `/credentials/models?name=${encodeURIComponent(name)}`);
+        return r.models ?? [];
+    }
+    setDisabled(name, disabled) {
+        return this.call('PATCH', '/credentials/status', { name, disabled });
+    }
+    deleteCredential(name) {
+        return this.call('DELETE', `/credentials?name=${encodeURIComponent(name)}`);
+    }
+    async usageQueue(count = 1000) {
+        const r = await this.call('GET', `/observability/usage/queue?count=${count}`);
+        return Array.isArray(r) ? r : [];
+    }
+}

package/dist/engine/sourcemap.js

@@ -0,0 +1,48 @@
+// engine/sourcemap.ts — 引擎原生（订阅）模型属于哪个来源
+//
+// /v1/models 里订阅模型没有前缀（如 kimi-k2.6，owned_by=moonshot），靠管理接口
+// GET /credentials/models?name= 逐个凭据取它能服务的模型，映射回来源（kimi / codex / claude …）。
+// 同时给出"没有可用订阅"的来源：用量接口判定的 noAccess，或引擎记录的 payment_required 冷却。
+import { usageFilePath } from '../daemon/usage.js';
+import { SOURCES, credsFor, paymentRequired } from '../sources.js';
+import { readJson } from '../util/fs.js';
+import { Mgmt } from './mgmt.js';
+export async function subscriptionMap(ctx, port) {
+    const models = new Map();
+    const noAccess = new Set();
+    const usage = (await readJson(usageFilePath(ctx.paths.home)).catch(() => null)) ?? [];
+    for (const u of usage)
+        if (u.noAccess)
+            noAccess.add(u.source);
+    let mgmt;
+    try {
+        mgmt = await Mgmt.forCtx(ctx, port);
+    }
+    catch {
+        return { models, noAccess };
+    }
+    let creds = [];
+    try {
+        creds = await mgmt.credentials();
+    }
+    catch {
+        return { models, noAccess };
+    }
+    for (const def of SOURCES.filter((s) => s.kind === 'engine')) {
+        const mine = credsFor(creds, def).filter((c) => !c.disabled);
+        if (mine.length && mine.every(paymentRequired))
+            noAccess.add(def.id);
+        for (const c of mine) {
+            try {
+                for (const m of await mgmt.credentialModels(c.name)) {
+                    if (!models.has(m.id))
+                        models.set(m.id, { source: def.id, label: def.label, ...(m.display_name ? { displayName: m.display_name } : {}) });
+                }
+            }
+            catch {
+                // 单个凭据取不到就跳过
+            }
+        }
+    }
+    return { models, noAccess };
+}

package/dist/errors.js

@@ -0,0 +1,14 @@
+// errors.ts — 带稳定错误码的错误。code 不随语言变化（--json 输出与测试依赖它），message 跟随语言
+export class DshModelError extends Error {
+    code;
+    hint;
+    constructor(code, message, hint) {
+        super(message);
+        this.name = 'DshModelError';
+        this.code = code;
+        this.hint = hint;
+    }
+}
+export function isDshModelError(error) {
+    return error instanceof DshModelError;
+}

package/dist/i18n.js

@@ -0,0 +1,39 @@
+// i18n.ts — 中英双语输出
+//
+// 写法：L('中文', 'English')，两种文字挨着写，改一处时另一处就在眼前（与 dsh-vps 一致）。
+// 语言优先级：--lang > DSH_MODEL_LANG > LC_ALL / LC_MESSAGES / LANG > Intl > zh
+let current = '';
+/** 'zh' / 'en'；认不出来返回 '' */
+export function normalizeLang(value) {
+    const s = String(value ?? '').trim().toLowerCase();
+    if (!s)
+        return '';
+    return s === 'zh' || s.startsWith('zh-') || s.startsWith('zh_') ? 'zh' : 'en';
+}
+/** 系统语言（LANG 之类，或 Intl 给的） */
+export function systemLang(env = process.env) {
+    const fromEnv = env.LC_ALL || env.LC_MESSAGES || env.LANG || '';
+    if (fromEnv && !/^(C|POSIX)(\.|$)/i.test(fromEnv))
+        return normalizeLang(fromEnv) || 'zh';
+    // 服务器上常见 LANG=C / C.UTF-8 或干脆没设：本项目以中文为主，这时默认中文（英文用 --lang en 或 DSH_MODEL_LANG=en）
+    if (fromEnv || process.platform !== 'darwin')
+        return 'zh';
+    try {
+        return normalizeLang(Intl.DateTimeFormat().resolvedOptions().locale) || 'zh';
+    }
+    catch {
+        return 'zh';
+    }
+}
+/** 在命令行解析完后调用一次；flag 为 --lang 的值 */
+export function initLang(flag, env = process.env) {
+    current = normalizeLang(flag) || normalizeLang(env.DSH_MODEL_LANG) || systemLang(env);
+    return current;
+}
+export function lang() {
+    return current || initLang();
+}
+/** 中英两份文字，按当前语言挑一份 */
+export function L(zh, en) {
+    return lang() === 'en' ? en : zh;
+}

package/dist/integrations/dshplugin.js

@@ -0,0 +1,42 @@
+// integrations/dshplugin.ts — 把 dsh-model 自己装进 dsh 当插件（设置 → dsh-model 页面，设计 §14.5）
+//
+// 用 dsh 自己的插件管理：dsh plugin --profile <p> add <本包目录>。pnpm 对目录用 link:，
+// 所以以后 npm 更新 dsh-model，插件跟着更新，不用重装。卸载时只移除 dsh-model 装的那份。
+import { dshPlugin, profileHasDependency } from '../dsh/cli.js';
+import { resolveProfile } from '../dsh/locate.js';
+import { DshModelError } from '../errors.js';
+import { L } from '../i18n.js';
+import { PKG_ROOT } from '../util/pkg.js';
+import { ok, skip } from '../util/output.js';
+export const PLUGIN_NAME = 'dsh-model';
+export async function installDshPlugin(ctx, all) {
+    const profile = await resolveProfile(ctx, all.config.dsh.profile);
+    const existing = await profileHasDependency(ctx, profile, PLUGIN_NAME);
+    if (existing) {
+        skip(L(`dsh 插件已安装（${existing}）`, `dsh plugin already installed (${existing})`));
+        if (!all.state.plugins?.some((p) => p.name === PLUGIN_NAME)) {
+            all.state.plugins = [...(all.state.plugins ?? []), { name: PLUGIN_NAME, version: existing, installedByUs: existing.startsWith('link:'), installedAt: new Date().toISOString() }];
+        }
+        return;
+    }
+    const code = await dshPlugin(ctx, profile, ['add', PKG_ROOT, '--config.strict-dep-builds=false'], all.config.proxy);
+    const installed = await profileHasDependency(ctx, profile, PLUGIN_NAME);
+    if (code !== 0 || !installed) {
+        throw new DshModelError('plugin_install_failed', L(`把 dsh-model 装进 dsh 失败（退出码 ${code}）`, `Failed to install dsh-model into dsh (exit code ${code})`), L('可以在 dsh 的插件页手动安装', 'You can install it from the dsh Plugins page'));
+    }
+    all.state.plugins = [...(all.state.plugins ?? []).filter((p) => p.name !== PLUGIN_NAME), { name: PLUGIN_NAME, version: installed, installedByUs: true, installedAt: new Date().toISOString() }];
+    ok(L('dsh 插件已安装：在 dsh「设置 → dsh-model」里管理来源、用量和 key（刷新一下页面）', 'dsh plugin installed: manage sources, usage and keys in dsh Settings → dsh-model (reload the page)'));
+}
+export async function removeDshPlugin(ctx, all) {
+    const rec = all.state.plugins?.find((p) => p.name === PLUGIN_NAME);
+    if (!rec?.installedByUs)
+        return false;
+    const profile = await resolveProfile(ctx, all.config.dsh.profile);
+    if (await profileHasDependency(ctx, profile, PLUGIN_NAME)) {
+        const code = await dshPlugin(ctx, profile, ['remove', PLUGIN_NAME], all.config.proxy);
+        if (code !== 0)
+            throw new DshModelError('plugin_remove_failed', L(`从 dsh 移除 dsh-model 插件失败（退出码 ${code}）`, `Failed to remove the dsh-model plugin from dsh (exit code ${code})`));
+    }
+    all.state.plugins = (all.state.plugins ?? []).filter((p) => p.name !== PLUGIN_NAME);
+    return true;
+}