Initial commit: omniroute-plugin DSH plugin with docs

.gitignore

@@ -0,0 +1,4 @@
+node_modules/
+*.bak
+*.orig
+.DS_Store

README.md

@@ -0,0 +1,103 @@
+# omniroute-plugin
+
+OmniRoute gateway integration for the DeepSeek Harness (DSH): **model auto-import** (context window, max output, modalities, thinking levels) and **provider quota tracking** under the composer.
+
+## Features
+
+- **Model discovery / import**: pulls models and combos from your OmniRoute gateway into an `llm-pi-ai` provider (default id `omni`, created if missing), with context window, output limit, input modalities and supported thinking levels (`off/minimal/low/medium/high/xhigh/max`).
+- **Periodic re-import** (`syncMin`, default 60 min; 0 = manual only) and an *update existing models only* mode.
+- **Include / exclude filters**: comma-separated glob patterns (`*`, `?`) on model ids, e.g. `claude*, gemini-*`; exclude always wins.
+- **Manage imported models**: search, select and prune models from the provider.
+- **Quota tracking**: provider quotas (5-hour, weekly, monthly, …) shown in the composer dock, refreshed every `pollSec` seconds (default 120); requires a management-scoped API key.
+- English and Chinese UI.
+
+## Files
+
+| File | Role |
+| --- | --- |
+| `index.js` | Host plugin. Injects `webServer`, `connection`, `credentials`, `settings`. |
+| `client.js` | Web client: settings panel (`plugins.bundle.config`) and quota dock (`conversation.composer.dock`). |
+| `locale/*.json` | Plugin title/description (en, zh). |
+| `cordis.patch.yml` | Bundle patch inserting the `omniroute` row. |
+
+### Host routes (relative to the Web origin, behind the connection trust fence)
+
+| Route | Purpose |
+| --- | --- |
+| `GET /omniroute/status` | Effective settings, key presence, last import |
+| `POST /omniroute/config` | Save settings (+ optional write-only API key) |
+| `POST /omniroute/test` | Probe the gateway with given or saved credentials |
+| `GET /omniroute/models` | Models currently imported |
+| `POST /omniroute/prune` | Remove selected imported models |
+| `POST /omniroute/import` | Import models/combos into the `llm-pi-ai` provider |
+| `GET /omniroute/quotas` | Provider quotas (`?model=<id>` narrows to that model's provider) |
+
+## Installation
+
+Requirements: a working DeepSeek Harness (`dsh`) install with the **web** profile (or any profile that includes the Web UI).
+
+### Option A — install from git (recommended)
+
+```bash
+dsh plugin --profile web add git+https://git.rizzy.dev/DSH-Plugins/omniroute-plugin.git
+```
+
+You can also paste `git+https://git.rizzy.dev/DSH-Plugins/omniroute-plugin.git` into **Settings → Plugins → Install** in the Web UI, or ask the agent to install it with its `plugin_manager` tool (`install_bundle`).
+
+The plugin manager adds `@local/omniroute` to `dependencies` and to `dsh.profile.bundles` in `~/.dsh/profiles/web/package.json`.
+
+### Option B — local checkout (for development)
+
+```bash
+git clone https://git.rizzy.dev/DSH-Plugins/omniroute-plugin.git ~/dsh-plugins/omniroute-plugin
+dsh plugin --profile web add link:$HOME/dsh-plugins/omniroute-plugin
+```
+
+With a `link:` install, edits in the checkout are picked up directly (client changes reload on page refresh, Host changes after a DSH restart or HMR reload).
+
+### Enable / verify
+
+1. Make sure `@local/omniroute` is listed in `dsh.profile.bundles` of `~/.dsh/profiles/web/package.json` (the installer does this; add it by hand if you edited `package.json` manually).
+2. Restart DSH (`dsh web`) or reload the page.
+3. Check **Settings → Plugins**: the `@local/omniroute` bundle should be enabled.
+
+### Uninstall
+
+```bash
+dsh plugin --profile web remove @local/omniroute
+```
+
+### Updating
+
+Re-run the `add` command from Option A (or `git pull` in your Option B checkout).
+
+## Setup after install
+
+1. Open **Settings → Plugins → OmniRoute**.
+2. Enter the **Gateway URL** (e.g. `https://omniroute.example.com`) and paste your **API key**.
+   - The key is stored in the DSH credential store under `OMNIROUTE_API_KEY` (`keyRef`) and never leaves the Host.
+   - Use a management-scoped key if you want quota tracking.
+3. Press **Test**, then **Save**, then **Re-discover models**.
+4. Pick an `omni/…` model in the model selector. Quotas appear under the composer.
+
+### Configuration file
+
+Non-secret settings live in `<profile>/omniroute.json` (`$DSH_PROFILE_DIR` or `~/.dsh/profiles/web/omniroute.json`):
+
+```json
+{
+  "url": "https://omniroute.example.com",
+  "keyRef": "OMNIROUTE_API_KEY",
+  "provider": "omni",
+  "discovery": true,
+  "updateOnly": false,
+  "include": "",
+  "exclude": "",
+  "discoverThinking": true,
+  "usage": true,
+  "pollSec": 120,
+  "syncMin": 60
+}
+```
+
+All of these are editable from the settings panel; `imported` and `lastImport` are maintained by the plugin.

client.js

@@ -0,0 +1,543 @@
+window.__ModuleLoader__.load({
+  id: '@local/omniroute',
+  factory(require) {
+    const React = require('react');
+    const h = React.createElement;
+    const NS = 'omniroute';
+    const PKG = '@local/omniroute';
+
+    const en = {
+      'settings.title': 'OmniRoute gateway',
+      'settings.url': 'Gateway URL',
+      'settings.url.hint': 'Base URL of your OmniRoute instance, for example https://omniroute.example.com',
+      'settings.key': 'API key',
+      'settings.key.set': 'A key is stored ({source}). Leave blank to keep it.',
+      'settings.key.unset': 'No key stored yet.',
+      'settings.key.placeholder': 'Paste a new key to replace it',
+      'settings.key.clear': 'Remove stored key',
+      'settings.provider': 'Provider id for imported models',
+      'settings.provider.hint': 'The llm-pi-ai provider that receives the models. It is created if missing.',
+      'settings.discovery': 'Model discovery',
+      'settings.discovery.hint': 'Import models and combos with context window, output limit, modalities and thinking levels.',
+      'settings.syncMin': 'Re-import every (minutes, 0 = manual only)',
+      'settings.updateOnly': 'Update existing entries only',
+      'settings.updateOnly.hint': 'Refresh context window, output limit, modalities and thinking levels of models you already have. Never adds or removes entries.',
+      'settings.thinking': 'Auto-discover thinking levels',
+      'settings.thinking.hint': 'Offer every thinking level OmniRoute reports for each model. When off, existing levels are kept as they are.',
+      'settings.usage': 'Usage tracking',
+      'settings.usage.hint': 'Show provider quotas (5-hour, weekly, monthly, …) under the composer.',
+      'settings.pollSec': 'Refresh quotas every (seconds)',
+      'settings.test': 'Test connection',
+      'settings.save': 'Save',
+      'settings.saved': 'Saved.',
+      'settings.import': 'Re-discover models',
+      'settings.filter.title': 'Import filter',
+      'settings.filter.hint': 'Comma-separated patterns with * and ?, matched against model ids (for example claude*, gemini-*). Include limits what Re-discover may add; exclude always wins. Empty include means everything.',
+      'settings.include': 'Include',
+      'settings.exclude': 'Exclude',
+      'manage.title': 'Manage models',
+      'manage.load': 'Show models',
+      'manage.search': 'Search models',
+      'manage.count': '{shown} shown of {total} ({selected} selected)',
+      'manage.imported': 'imported',
+      'manage.mine': 'yours',
+      'manage.selectShown': 'Select shown',
+      'manage.clear': 'Clear selection',
+      'manage.removeSel': 'Remove selected',
+      'manage.keepSel': 'Keep selected, remove other imported',
+      'manage.confirm': 'Remove {n} models from this provider? Models used as the default or in the subagent list are skipped.',
+      'manage.done': 'Removed {removed}; {remaining} left.{protected}',
+      'manage.protected': ' Skipped (in use): {ids}.',
+      'settings.update': 'Update existing models',
+      'settings.restart': 'Restart DSH to enable this button: the running server is an older version and would add models instead of only updating.',
+      'settings.update.hint': 'Update refreshes only the models you already have. Re-discover also adds new ones and drops ones OmniRoute no longer lists.',
+      'settings.importing': 'Importing…',
+      'settings.testing': 'Testing…',
+      'settings.test.ok': 'Connected in {ms} ms. {models} chat models available.',
+      'settings.test.mgmt': ' Management access OK ({connections} provider connections).',
+      'settings.test.nomgmt': ' This key has no management access, so quotas will not be available.',
+      'settings.import.ok': '{count} models: {added} added, {updated} updated, {removed} removed; {thinking} with thinking levels.',
+      'settings.lastImport': 'Last import: {count} models ({added} added, {updated} updated) at {at}',
+      'settings.lastImport.error': 'Last import failed: {error}',
+      'quota.resets': 'resets {when}',
+      'quota.unlimited': 'unlimited',
+      'quota.left': '{pct}% left',
+      'quota.average': 'Average of {n} accounts',
+      'quota.dialog.accounts': 'Accounts',
+      'quota.dialog.left': 'left',
+      'quota.error.mgmt': 'Quotas need a management-scoped API key',
+    };
+    const zh = {
+      'settings.title': 'OmniRoute 网关',
+      'settings.url': '网关地址',
+      'settings.url.hint': 'OmniRoute 实例的基础地址，例如 https://omniroute.example.com',
+      'settings.key': 'API 密钥',
+      'settings.key.set': '已保存密钥（{source}）。留空则保持不变。',
+      'settings.key.unset': '尚未保存密钥。',
+      'settings.key.placeholder': '粘贴新密钥以替换',
+      'settings.key.clear': '删除已保存的密钥',
+      'settings.provider': '导入模型使用的提供商 ID',
+      'settings.provider.hint': '接收模型的 llm-pi-ai 提供商；不存在时自动创建。',
+      'settings.discovery': '模型发现',
+      'settings.discovery.hint': '导入模型和组合，自动填充上下文窗口、输出上限、模态和思考强度。',
+      'settings.syncMin': '重新导入间隔（分钟，0 为仅手动）',
+      'settings.updateOnly': '仅更新已有条目',
+      'settings.updateOnly.hint': '只刷新已有模型的上下文窗口、输出上限、模态和思考强度，不会新增或删除条目。',
+      'settings.thinking': '自动发现思考强度',
+      'settings.thinking.hint': '为每个模型提供 OmniRoute 报告的全部思考强度。关闭时保持现有强度不变。',
+      'settings.usage': '用量跟踪',
+      'settings.usage.hint': '在输入框下方显示提供商配额（5 小时、每周、每月等）。',
+      'settings.pollSec': '配额刷新间隔（秒）',
+      'settings.test': '测试连接',
+      'settings.save': '保存',
+      'settings.saved': '已保存。',
+      'settings.import': '重新发现模型',
+      'settings.filter.title': '导入过滤',
+      'settings.filter.hint': '以逗号分隔的模式，支持 * 和 ?，匹配模型 ID（例如 claude*, gemini-*）。“包含”限制重新发现可添加的模型，“排除”优先生效。包含为空表示全部。',
+      'settings.include': '包含',
+      'settings.exclude': '排除',
+      'manage.title': '管理模型',
+      'manage.load': '显示模型',
+      'manage.search': '搜索模型',
+      'manage.count': '显示 {shown} / 共 {total}（已选 {selected}）',
+      'manage.imported': '已导入',
+      'manage.mine': '自有',
+      'manage.selectShown': '选择当前显示',
+      'manage.clear': '清除选择',
+      'manage.removeSel': '移除所选',
+      'manage.keepSel': '保留所选，移除其他已导入',
+      'manage.confirm': '从此提供商移除 {n} 个模型？默认模型和子代理列表中使用的模型会被跳过。',
+      'manage.done': '已移除 {removed} 个；剩余 {remaining} 个。{protected}',
+      'manage.protected': ' 已跳过（使用中）：{ids}。',
+      'settings.update': '更新现有模型',
+      'settings.restart': '请重启 DSH 以启用此按钮：当前运行的服务端是旧版本，会新增模型而不是只更新。',
+      'settings.update.hint': '“更新”只刷新已有模型；“重新发现”还会添加新模型，并移除 OmniRoute 不再提供的模型。',
+      'settings.importing': '导入中…',
+      'settings.testing': '测试中…',
+      'settings.test.ok': '已连接，用时 {ms} 毫秒，共 {models} 个对话模型。',
+      'settings.test.mgmt': ' 管理权限正常（{connections} 个提供商连接）。',
+      'settings.test.nomgmt': ' 此密钥没有管理权限，无法读取配额。',
+      'settings.import.ok': '共 {count} 个模型：新增 {added}，更新 {updated}，移除 {removed}；{thinking} 个带思考强度。',
+      'settings.lastImport': '上次导入：{count} 个模型（新增 {added}，更新 {updated}），{at}',
+      'settings.lastImport.error': '上次导入失败：{error}',
+      'quota.resets': '{when}后重置',
+      'quota.unlimited': '无限制',
+      'quota.left': '剩余 {pct}%',
+      'quota.average': '{n} 个账号的平均值',
+      'quota.dialog.accounts': '账号',
+      'quota.dialog.left': '剩余',
+      'quota.error.mgmt': '读取配额需要具有管理权限的 API 密钥',
+    };
+
+    const fill = (s, vars) => String(s).replace(/\{(\w+)\}/g, (_, k) => (vars && vars[k] !== undefined ? vars[k] : ''));
+
+    async function call(path, init) {
+      const res = await fetch('omniroute/' + path, {
+        ...init,
+        headers: { accept: 'application/json', ...(init && init.body ? { 'content-type': 'application/json' } : {}) },
+      });
+      let json;
+      try { json = await res.json(); } catch { json = {}; }
+      if (!res.ok) throw new Error(json.message || res.statusText || String(res.status));
+      return json;
+    }
+    const post = (path, body) => call(path, { method: 'POST', body: JSON.stringify(body || {}) });
+
+    const field = {
+      display: 'flex', flexDirection: 'column', gap: 4, marginBottom: 14,
+    };
+    const labelStyle = { fontSize: 13, fontWeight: 600, color: 'var(--dsw-alias-label-primary, inherit)' };
+    const hintStyle = { fontSize: 12, color: 'var(--dsw-alias-label-secondary, inherit)', opacity: 0.85 };
+    const inputStyle = {
+      padding: '6px 10px', borderRadius: 6, font: 'inherit', fontSize: 13,
+      border: '1px solid var(--dsw-alias-border-l3, rgba(128,128,128,.4))',
+      background: 'var(--dsw-specific-input-major, transparent)',
+      color: 'var(--dsw-alias-label-primary, inherit)', width: '100%', boxSizing: 'border-box',
+    };
+    const btnStyle = (primary, disabled) => ({
+      padding: '6px 14px', borderRadius: 6, font: 'inherit', fontSize: 13, cursor: disabled ? 'default' : 'pointer',
+      border: primary ? 0 : '1px solid var(--dsw-alias-border-l3, rgba(128,128,128,.4))',
+      background: primary ? 'var(--dsw-alias-state-business-primary, #247bbf)' : 'transparent',
+      color: primary ? '#fff' : 'var(--dsw-alias-label-primary, inherit)',
+      opacity: disabled ? 0.55 : 1,
+    });
+
+    function Toggle({ checked, onChange, label, hint }) {
+      return h('label', { style: { ...field, flexDirection: 'row', alignItems: 'flex-start', gap: 10, cursor: 'pointer' } },
+        h('input', { type: 'checkbox', checked, onChange: (e) => onChange(e.target.checked), style: { marginTop: 3 } }),
+        h('span', { style: { display: 'flex', flexDirection: 'column', gap: 2 } },
+          h('span', { style: labelStyle }, label),
+          hint ? h('span', { style: hintStyle }, hint) : null));
+    }
+
+    function ModelManager({ t, onChanged }) {
+      const [data, setData] = React.useState(null);
+      const [q, setQ] = React.useState('');
+      const [sel, setSel] = React.useState(() => new Set());
+      const [busy, setBusy] = React.useState(false);
+      const [msg, setMsg] = React.useState(null);
+      const load = async () => {
+        setBusy(true); setMsg(null);
+        try { setData(await call('models')); } catch (e) { setMsg({ bad: true, text: String(e.message) }); } finally { setBusy(false); }
+      };
+      const shown = data ? data.models.filter((m) => !q.trim() || (m.id + ' ' + m.name).toLowerCase().includes(q.trim().toLowerCase())) : [];
+      const visible = shown.slice(0, 200);
+      const toggle = (id) => setSel((prev) => { const n = new Set(prev); n.has(id) ? n.delete(id) : n.add(id); return n; });
+      const prune = async (body, count) => {
+        if (!window.confirm(fill(t('manage.confirm'), { n: count }))) return;
+        setBusy(true); setMsg(null);
+        try {
+          const r = await post('prune', body);
+          setMsg({ text: fill(t('manage.done'), { removed: r.removed, remaining: r.remaining, protected: r.protected && r.protected.length ? fill(t('manage.protected'), { ids: r.protected.join(', ') }) : '' }) });
+          setSel(new Set());
+          setData(await call('models'));
+          if (onChanged) onChanged();
+        } catch (e) { setMsg({ bad: true, text: String(e.message) }); } finally { setBusy(false); }
+      };
+      const importedCount = data ? data.models.filter((m) => m.imported && !sel.has(m.id)).length : 0;
+      return h('div', { style: { marginTop: 18, paddingTop: 14, borderTop: '1px solid var(--dsw-alias-border-l2, rgba(128,128,128,.3))' } },
+        h('div', { style: { ...labelStyle, marginBottom: 8 } }, t('manage.title')),
+        !data ? h('button', { type: 'button', onClick: load, disabled: busy, style: btnStyle(false, busy) }, t('manage.load')) : h('div', null,
+          h('input', { value: q, placeholder: t('manage.search'), onChange: (e) => setQ(e.target.value), style: { ...inputStyle, marginBottom: 6 } }),
+          h('div', { style: { ...hintStyle, marginBottom: 6 } }, fill(t('manage.count'), { shown: visible.length, total: data.total, selected: sel.size })),
+          h('div', { style: { maxHeight: 240, overflowY: 'auto', border: '1px solid var(--dsw-alias-border-l3, rgba(128,128,128,.4))', borderRadius: 6, padding: 4 } },
+            visible.map((m) => h('label', { key: m.id, style: { display: 'flex', alignItems: 'center', gap: 8, padding: '2px 4px', fontSize: 13, cursor: 'pointer' } },
+              h('input', { type: 'checkbox', checked: sel.has(m.id), onChange: () => toggle(m.id) }),
+              h('span', { style: { flex: 1, overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }, title: m.id }, m.name === m.id ? m.id : m.name + '  ·  ' + m.id),
+              h('span', { style: { ...hintStyle, fontSize: 11 } }, m.imported ? t('manage.imported') : t('manage.mine'))))),
+          h('div', { style: { display: 'flex', gap: 8, flexWrap: 'wrap', marginTop: 8 } },
+            h('button', { type: 'button', onClick: () => setSel((prev) => { const n = new Set(prev); visible.forEach((m) => n.add(m.id)); return n; }), disabled: busy, style: btnStyle(false, busy) }, t('manage.selectShown')),
+            h('button', { type: 'button', onClick: () => setSel(new Set()), disabled: busy || sel.size === 0, style: btnStyle(false, busy || sel.size === 0) }, t('manage.clear')),
+            h('button', { type: 'button', onClick: () => prune({ ids: [...sel] }, sel.size), disabled: busy || sel.size === 0, style: btnStyle(true, busy || sel.size === 0) }, t('manage.removeSel')),
+            h('button', { type: 'button', onClick: () => prune({ keep: [...sel] }, importedCount), disabled: busy || importedCount === 0, style: btnStyle(false, busy || importedCount === 0) }, t('manage.keepSel')))),
+        msg ? h('div', { role: 'status', style: { fontSize: 13, marginTop: 8, color: msg.bad ? 'var(--dsw-alias-state-danger, #d33)' : 'var(--dsw-alias-label-primary, inherit)' } }, msg.text) : null);
+    }
+
+    function Settings({ view, t }) {
+      const [status, setStatus] = React.useState(null);
+      const [form, setForm] = React.useState(null);
+      const [apiKey, setApiKey] = React.useState('');
+      const [busy, setBusy] = React.useState('');
+      const [msg, setMsg] = React.useState(null);
+
+      const refresh = React.useCallback(async () => {
+        try {
+          const s = await call('status');
+          setStatus(s);
+          setForm((f) => f || { url: s.url || s.effectiveUrl || '', provider: s.provider, discovery: s.discovery, updateOnly: !!s.updateOnly, include: s.include || '', exclude: s.exclude || '', discoverThinking: s.discoverThinking !== false, usage: s.usage, pollSec: s.pollSec, syncMin: s.syncMin });
+        } catch (e) { setMsg({ bad: true, text: String(e.message) }); }
+      }, []);
+      React.useEffect(() => { refresh(); }, [refresh]);
+
+      if (view === 'summary') return null;
+      if (!form || !status) return h('div', { style: hintStyle }, '…');
+      const set = (k) => (v) => setForm((f) => ({ ...f, [k]: v }));
+      const run = (name, fn) => async () => {
+        setBusy(name); setMsg(null);
+        try { await fn(); } catch (e) { setMsg({ bad: true, text: String(e.message) }); } finally { setBusy(''); }
+      };
+
+      const save = run('save', async () => {
+        await post('config', { ...form, ...(apiKey ? { apiKey } : {}) });
+        setApiKey('');
+        await refresh();
+        setMsg({ text: t('settings.saved') });
+      });
+      const test = run('test', async () => {
+        const r = await post('test', { url: form.url, ...(apiKey ? { apiKey } : {}) });
+        if (!r.ok) { setMsg({ bad: true, text: r.message }); return; }
+        setMsg({ text: fill(t('settings.test.ok'), r) + (r.management ? fill(t('settings.test.mgmt'), r) : t('settings.test.nomgmt')) });
+      });
+      const importWith = (name, mode) => run(name, async () => {
+        await post('config', { ...form, ...(apiKey ? { apiKey } : {}) });
+        setApiKey('');
+        const r = await post('import', { mode });
+        await refresh();
+        setMsg({ text: fill(t('settings.import.ok'), r) });
+      });
+      const doImport = importWith('import', 'full');
+      const doUpdate = importWith('update', 'update');
+      const canUpdate = status.api >= 2; // an older Host ignores the mode and would add models
+      const clearKey = run('clear', async () => { await post('config', { clearKey: true }); await refresh(); });
+
+      const li = status.lastImport;
+      return h('div', { style: { maxWidth: 560, padding: '4px 0 12px' } },
+        h('div', { style: field },
+          h('label', { style: labelStyle }, t('settings.url')),
+          h('input', { type: 'url', value: form.url, placeholder: 'https://', onChange: (e) => set('url')(e.target.value), style: inputStyle }),
+          h('span', { style: hintStyle }, t('settings.url.hint'))),
+        h('div', { style: field },
+          h('label', { style: labelStyle }, t('settings.key')),
+          h('input', { type: 'password', autoComplete: 'new-password', value: apiKey, placeholder: t('settings.key.placeholder'), onChange: (e) => setApiKey(e.target.value), style: inputStyle }),
+          h('span', { style: hintStyle },
+            status.key.configured ? fill(t('settings.key.set'), { source: status.key.source || status.key.ref }) : t('settings.key.unset'),
+            status.key.configured ? h('button', { type: 'button', onClick: clearKey, disabled: !!busy, style: { ...btnStyle(false, !!busy), marginLeft: 8, padding: '1px 8px', fontSize: 12 } }, t('settings.key.clear')) : null)),
+        h('div', { style: field },
+          h('label', { style: labelStyle }, t('settings.provider')),
+          h('input', { value: form.provider, onChange: (e) => set('provider')(e.target.value), style: { ...inputStyle, maxWidth: 220 } }),
+          h('span', { style: hintStyle }, t('settings.provider.hint'))),
+        h(Toggle, { checked: form.discovery, onChange: set('discovery'), label: t('settings.discovery'), hint: t('settings.discovery.hint') }),
+        form.discovery ? h('div', { style: { marginLeft: 26 } },
+          h(Toggle, { checked: form.updateOnly, onChange: set('updateOnly'), label: t('settings.updateOnly'), hint: t('settings.updateOnly.hint') }),
+          h(Toggle, { checked: form.discoverThinking, onChange: set('discoverThinking'), label: t('settings.thinking'), hint: t('settings.thinking.hint') })) : null,
+        form.discovery ? h('div', { style: { ...field, marginLeft: 26 } },
+          h('label', { style: labelStyle }, t('settings.filter.title')),
+          h('div', { style: { display: 'flex', gap: 8 } },
+            h('input', { value: form.include, placeholder: t('settings.include') + ': claude*, gemini-*', onChange: (e) => set('include')(e.target.value), style: inputStyle }),
+            h('input', { value: form.exclude, placeholder: t('settings.exclude') + ': *mini, *preview', onChange: (e) => set('exclude')(e.target.value), style: inputStyle })),
+          h('span', { style: hintStyle }, t('settings.filter.hint'))) : null,
+        form.discovery ? h('div', { style: { ...field, marginLeft: 26 } },
+          h('label', { style: hintStyle }, t('settings.syncMin')),
+          h('input', { type: 'number', min: 0, max: 1440, value: form.syncMin, onChange: (e) => set('syncMin')(Number(e.target.value)), style: { ...inputStyle, maxWidth: 120 } })) : null,
+        h(Toggle, { checked: form.usage, onChange: set('usage'), label: t('settings.usage'), hint: t('settings.usage.hint') }),
+        form.usage ? h('div', { style: { ...field, marginLeft: 26 } },
+          h('label', { style: hintStyle }, t('settings.pollSec')),
+          h('input', { type: 'number', min: 30, max: 3600, value: form.pollSec, onChange: (e) => set('pollSec')(Number(e.target.value)), style: { ...inputStyle, maxWidth: 120 } })) : null,
+        h('div', { style: { display: 'flex', gap: 8, flexWrap: 'wrap', marginBottom: 10 } },
+          h('button', { type: 'button', onClick: test, disabled: !!busy, style: btnStyle(false, !!busy) }, busy === 'test' ? t('settings.testing') : t('settings.test')),
+          h('button', { type: 'button', onClick: save, disabled: !!busy, style: btnStyle(true, !!busy) }, t('settings.save')),
+          h('button', { type: 'button', onClick: doUpdate, disabled: !!busy || !canUpdate, title: canUpdate ? undefined : t('settings.restart'), style: btnStyle(false, !!busy || !canUpdate) }, busy === 'update' ? t('settings.importing') : t('settings.update')),
+          h('button', { type: 'button', onClick: doImport, disabled: !!busy, style: btnStyle(false, !!busy) }, busy === 'import' ? t('settings.importing') : t('settings.import'))),
+        h('div', { style: { ...hintStyle, marginBottom: 8 } }, canUpdate ? t('settings.update.hint') : t('settings.restart')),
+        msg ? h('div', { role: 'status', style: { fontSize: 13, color: msg.bad ? 'var(--dsw-alias-state-danger, #d33)' : 'var(--dsw-alias-label-primary, inherit)' } }, msg.text) : null,
+        h(ModelManager, { t, onChanged: refresh }),
+        li ? h('div', { style: { ...hintStyle, marginTop: 8 } },
+          li.error ? fill(t('settings.lastImport.error'), { error: li.error }) : fill(t('settings.lastImport'), { count: li.count, added: li.added ?? 0, updated: li.updated ?? 0, at: new Date(li.at).toLocaleString() })) : null);
+    }
+
+    // ---------------------------------------------------------------- quota strip
+
+    function relTime(iso) {
+      const ms = Date.parse(iso) - Date.now();
+      if (!Number.isFinite(ms)) return '';
+      if (ms <= 0) return '0m';
+      const m = Math.round(ms / 60000);
+      if (m < 60) return m + 'm';
+      const hrs = Math.floor(m / 60);
+      if (hrs < 48) return hrs + 'h' + (m % 60 ? (m % 60) + 'm' : '');
+      return Math.round(hrs / 24) + 'd';
+    }
+
+    // Same geometry and tokens as the host's context meter ring.
+    const RADIUS = 5.5;
+    const CIRC = 2 * Math.PI * RADIUS;
+    const LOW = 'var(--dsw-alias-state-danger, #e5484d)';
+
+
+    // Icons sit a little low next to the text in the stats bar. Lift them 1px: the bar's own pills,
+    // the context meter ring, and ours. Only the icon moves; nothing else in the host is restyled.
+    const ICON_LIFT = '-1px';
+    const CENTER_CSS =
+      '[data-omniroute-quotas] > * { align-items: center; justify-content: center; text-align: center; }' +
+      '[data-composer-stats] svg, [data-omniroute-quotas] svg, .omr-title-label svg,' +
+      'button[class*="_trigger"][aria-haspopup="dialog"] > svg[viewBox="0 0 14 14"],' +
+      '[role="dialog"] [class*="_titleLabel"] svg' +
+      ' { flex: none; transform: translateY(' + ICON_LIFT + '); }';
+
+    function Gauge({ pct, unlimited }) {
+      const shown = unlimited || pct === null ? 100 : Math.max(0, Math.min(100, pct));
+      return h('svg', { viewBox: '0 0 14 14', width: 14, height: 14, 'aria-hidden': true, style: { flex: 'none' } },
+        h('circle', { cx: 7, cy: 7, r: RADIUS, fill: 'none', stroke: 'var(--dsw-alias-border-l3)', strokeWidth: 2 }),
+        shown > 0 ? h('circle', {
+          cx: 7, cy: 7, r: RADIUS, fill: 'none', strokeWidth: 2, strokeLinecap: 'round',
+          stroke: !unlimited && pct !== null && pct <= 10 ? LOW : 'currentColor',
+          strokeDasharray: (CIRC * shown / 100) + ' ' + CIRC, transform: 'rotate(-90 7 7)',
+        }) : null);
+    }
+
+    const rootStyle = {
+      boxSizing: 'border-box', minWidth: 0, maxWidth: '100%', display: 'flex', flexWrap: 'wrap', justifyContent: 'center', gap: 12,
+      fontSize: 'calc(var(--dsh-content-font-size-secondary, 13px) - 1px)',
+      lineHeight: 'calc(20px + var(--dsh-content-font-delta-secondary, 0px))',
+    };
+    const pillStyle = (hover) => ({
+      boxSizing: 'border-box', maxWidth: '100%', display: 'inline-flex', alignItems: 'center', justifyContent: 'center', textAlign: 'center', gap: 6, padding: '1px 8px',
+      border: 'none', borderRadius: 999, font: 'inherit', lineHeight: 'inherit', fontVariantNumeric: 'tabular-nums', whiteSpace: 'nowrap',
+      background: hover ? 'var(--dsw-alias-interactive-bg-hover)' : 'transparent',
+      color: hover ? 'var(--dsw-alias-label-secondary)' : 'var(--dsw-alias-label-tertiary)',
+    });
+
+    // Panel styled with the host's own tokens, mirroring its token-usage dialog.
+    const PANEL_CSS =
+      '.omr-panel{z-index:1100;box-sizing:border-box;border-radius:var(--dsw-radius-lg);background:var(--dsw-specific-menu);' +
+      'width:max-content;min-width:min(300px,100vw - 24px);max-width:min(440px,100vw - 24px);backdrop-filter:var(--dsw-menu-backdrop-filter);' +
+      '--dsw-elevation-stroke-color:var(--dsw-alias-border-l1);box-shadow:var(--dsw-elevation-prominent);color:var(--dsw-alias-label-secondary);' +
+      'cursor:default;border:0;padding:16px;font-size:12px;line-height:18px;position:fixed}' +
+      '.omr-title{color:var(--dsw-alias-label-primary);justify-content:space-between;gap:16px;margin-bottom:8px;font-weight:500;display:flex}' +
+      '.omr-title-label{align-items:center;gap:6px;min-width:0;display:inline-flex}' +
+      '.omr-title-value{font-variant-numeric:tabular-nums}' +
+      '.omr-rule{border-top:.5px solid var(--dsw-alias-border-l2);margin-bottom:10px}' +
+      '.omr-details{color:var(--dsw-alias-label-tertiary);grid-template-columns:minmax(76px,auto) minmax(0,1fr);gap:6px 16px;margin:0;display:grid}' +
+      '.omr-details dt,.omr-details dd{min-width:0;margin:0;overflow-wrap:anywhere}' +
+      '.omr-details dd{color:var(--dsw-alias-label-secondary);font-variant-numeric:tabular-nums;text-align:right}';
+
+    const MEASURE = { visibility: 'hidden', left: 0, top: 0 };
+    let primitives;
+    try { primitives = require('@deepseek-ai/dsh-client-ui-primitives'); } catch { primitives = undefined; }
+    const portal = (() => { try { return require('react-dom').createPortal; } catch { return undefined; } })();
+
+    /** The host's anchoring and outside-click hooks when reachable, otherwise equivalent local ones. */
+    function useAnchored(open, anchorRef, panelRef) {
+      const [pos, setPos] = React.useState(null);
+      React.useLayoutEffect(() => {
+        if (!open) { setPos(null); return undefined; }
+        const place = () => {
+          const a = anchorRef.current, p = panelRef.current;
+          if (!a || !p) return;
+          const r = a.getBoundingClientRect(), w = p.offsetWidth, hgt = p.offsetHeight, m = 12, gap = 8;
+          const left = Math.max(m, Math.min(window.innerWidth - w - m, r.left + r.width / 2 - w / 2));
+          const top = Math.max(m, r.top - hgt - gap);
+          setPos({ left, top });
+        };
+        place();
+        window.addEventListener('resize', place);
+        window.addEventListener('scroll', place, true);
+        return () => { window.removeEventListener('resize', place); window.removeEventListener('scroll', place, true); };
+      }, [open]);
+      return pos;
+    }
+    function useDismiss(rootRef, open, setOpen, panelRef) {
+      React.useEffect(() => {
+        if (!open) return undefined;
+        const down = (e) => {
+          const el = e.target;
+          if (rootRef.current && rootRef.current.contains(el)) return;
+          if (panelRef.current && panelRef.current.contains(el)) return;
+          setOpen(false);
+        };
+        const key = (e) => { if (e.key === 'Escape') setOpen(false); };
+        document.addEventListener('pointerdown', down, true);
+        document.addEventListener('keydown', key);
+        return () => { document.removeEventListener('pointerdown', down, true); document.removeEventListener('keydown', key); };
+      }, [open]);
+    }
+
+    // Chosen once at load, so every render calls the same hook in the same order.
+    const useAnchorHook = primitives && primitives.useAnchoredPosition
+      ? (open, anchorRef, panelRef) => primitives.useAnchoredPosition({ open, anchorRef, panelRef, side: 'top', gap: 8, margin: 12 })
+      : useAnchored;
+    const useDismissHook = primitives && primitives.useDismissOnOutsidePointer
+      ? (rootRef, open, setOpen, panelRef) => primitives.useDismissOnOutsidePointer(rootRef, open, setOpen, panelRef)
+      : useDismiss;
+
+    function Pill({ g, multi, t }) {
+      const [open, setOpen] = React.useState(false);
+      const [hover, setHover] = React.useState(false);
+      const rootRef = React.useRef(null);
+      const panelRef = React.useRef(null);
+      const pos = useAnchorHook(open, rootRef, panelRef);
+      useDismissHook(rootRef, open, setOpen, panelRef);
+      // The host's dismiss hook only handles outside clicks; Escape is the dialog's own job (as in the host's stat dialogs).
+      React.useEffect(() => {
+        if (!open) return undefined;
+        const onKey = (e) => { if (e.key === 'Escape') setOpen(false); };
+        document.addEventListener('keydown', onKey);
+        return () => document.removeEventListener('keydown', onKey);
+      }, [open]);
+
+      const pct = g.unlimited ? null : g.remainingPct;
+      const reading = g.unlimited ? '∞' : pct === null ? '—' : Math.round(pct) + '%';
+      const label = (multi ? g.provider + ' ' : '') + g.label;
+      const panel = open ? h('div', {
+        ref: panelRef, className: 'omr-panel', role: 'dialog', 'aria-label': g.provider + ' ' + g.label, style: pos || MEASURE,
+      },
+        h('div', { className: 'omr-title' },
+          h('span', { className: 'omr-title-label' }, h(Gauge, { pct, unlimited: g.unlimited }), g.provider + ' · ' + g.label),
+          h('span', { className: 'omr-title-value' }, reading)),
+        h('div', { className: 'omr-rule' }),
+        h('dl', { className: 'omr-details' },
+          g.accounts > 1 && !g.unlimited ? [h('dt', { key: 'avg-k' }, t('quota.average').replace('{n}', g.accounts)), h('dd', { key: 'avg-v' }, reading)] : null,
+          g.resetAt ? [h('dt', { key: 'rs-k' }, t('quota.resets').replace('{when}', '').trim() || 'resets'), h('dd', { key: 'rs-v' }, relTime(g.resetAt))] : null,
+          g.items.map((i, n) => [
+            h('dt', { key: 'a' + n }, g.accounts > 1 ? i.account : t('quota.dialog.accounts')),
+            h('dd', { key: 'v' + n }, (i.unlimited ? t('quota.unlimited') : i.remainingPct === null ? '—' : Math.round(i.remainingPct) + '%')
+              + (i.resetAt ? ' · ' + relTime(i.resetAt) : '')),
+          ]))) : null;
+
+      return h('span', { ref: rootRef, style: { minWidth: 0, display: 'inline-flex' } },
+        h('button', {
+          type: 'button', 'aria-haspopup': 'dialog', 'aria-expanded': open, 'aria-label': label + ' ' + reading,
+          onClick: () => setOpen(!open),
+          onMouseEnter: () => setHover(true), onMouseLeave: () => setHover(false),
+          style: { ...pillStyle(hover || open), cursor: 'pointer' },
+        },
+          h(Gauge, { pct, unlimited: g.unlimited }),
+          h('span', { style: { overflow: 'hidden', textOverflow: 'ellipsis', minWidth: 0, textAlign: 'center' } },
+            label + ' ' + reading + (g.resetAt ? ' · ' + relTime(g.resetAt) : ''))),
+        panel && portal ? portal(panel, document.body) : panel);
+    }
+
+    function QuotaStrip({ directory, t }) {
+      const state = React.useSyncExternalStore((fn) => directory.subscribe(fn), () => directory.getSnapshot());
+      const providerId = state.current ? state.current.provider : undefined;
+      const modelId = state.current ? state.current.model : undefined;
+      const [data, setData] = React.useState(null);
+      const [pollSec, setPollSec] = React.useState(120);
+      const [enabled, setEnabled] = React.useState(true);
+
+      React.useEffect(() => {
+        let dead = false;
+        let timer;
+        setData(null); // never show the previous model's quotas while the new one loads
+        const tick = async () => {
+          try {
+            const s = await call('status');
+            if (dead) return;
+            setEnabled(!!s.usage);
+            setPollSec(s.pollSec || 120);
+            if (!s.usage) { setData(null); return; }
+            if (!providerId || !modelId || providerId !== s.provider) { setData(null); return; }
+            const q = await call('quotas?provider=' + encodeURIComponent(providerId) + '&model=' + encodeURIComponent(modelId));
+            if (!dead) setData(q);
+          } catch { if (!dead) setData(null); }
+          if (!dead) timer = setTimeout(tick, Math.max(30, pollSec) * 1000);
+        };
+        tick();
+        return () => { dead = true; clearTimeout(timer); };
+      }, [providerId, modelId, pollSec]);
+
+      if (!enabled || !data || !providerId) return null;
+      if (data.error === 'management-auth') {
+        return h('div', { style: { ...rootStyle, color: 'var(--dsw-alias-label-tertiary)' } }, t('quota.error.mgmt'));
+      }
+      // An older Host sends per-account rows only; show nothing rather than three duplicate windows.
+      const groups = Array.isArray(data.merged) ? data.merged : [];
+      if (groups.length === 0) {
+        if (!data.message || data.scope === 'foreign-model') return null;
+        return h('div', { 'data-omniroute-quotas': true, title: data.message, style: { ...rootStyle, color: 'var(--dsw-alias-label-tertiary)', overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' } }, 'OmniRoute quotas: ' + data.message);
+      }
+      const multi = new Set(groups.map((g) => g.provider)).size > 1;
+
+      return h('div', { 'data-omniroute-quotas': true, style: rootStyle },
+        groups.map((g) => h(Pill, { key: g.provider + ':' + g.key, g, multi, t })));
+    }
+
+    return {
+      inject: ['slots', 'locale', 'modelDirectories'],
+      apply(ctx) {
+        ctx.effect(() => ctx.locale.register(NS, { en, zh }), 'omniroute: dictionaries');
+        ctx.effect(() => {
+          const el = document.createElement('style');
+          el.setAttribute('data-omniroute-style', '');
+          el.textContent = CENTER_CSS + PANEL_CSS;
+          document.head.appendChild(el);
+          return () => el.remove();
+        }, 'omniroute: centring style');
+
+        ctx.slots.inject('plugins.bundle.config', () => ctx.slots.register({
+          name: 'plugins.bundle.config',
+          key: PKG,
+          locale: NS,
+        }, Settings));
+
+        ctx.slots.inject('conversation.composer.dock', () => ctx.slots.register({
+          name: 'conversation.composer.dock',
+          id: 'omniroute-quotas',
+          order: 5,
+          locale: NS,
+          inject: (sessionId) => ({ directory: ctx.modelDirectories.directoryFor(sessionId).store }),
+        }, QuotaStrip));
+      },
+    };
+  },
+});

cordis.patch.yml

@@ -0,0 +1,3 @@
+- insert:
+    - id: omniroute
+      name: '@local/omniroute'

index.js

@@ -0,0 +1,821 @@
+/**
+ * OmniRoute Host plugin.
+ *
+ * Routes (all behind the connection trust fence, relative to the web origin):
+ *   GET  /omniroute/status   effective settings, key presence, last import
+ *   POST /omniroute/config   save settings (+ optional write-only API key)
+ *   POST /omniroute/test     probe the gateway with the given or saved credentials
+ *   POST /omniroute/import   import models/combos into the llm-pi-ai route
+ *   GET  /omniroute/quotas   provider quotas (?model=<id> narrows to that model's provider)
+ *
+ * Non-secret settings live in <profile>/omniroute.json; the API key lives in the
+ * credential store under `keyRef` and never leaves the Host.
+ */
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import crypto from 'node:crypto'
+
+export const name = 'omniroute'
+export const inject = ['webServer', 'connection', 'credentials', 'settings']
+
+const LEVELS = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max']
+const LEVEL_ALIASES = { none: 'off', minimum: 'minimal', min: 'minimal', extra_high: 'xhigh', 'x-high': 'xhigh', maximum: 'max' }
+const NON_CHAT_TYPES = new Set(['embedding', 'image', 'rerank', 'audio', 'moderation', 'video', 'music', 'tts', 'stt'])
+const DEFAULTS = {
+  url: '',
+  keyRef: 'OMNIROUTE_API_KEY',
+  provider: 'omni',
+  discovery: true,
+  updateOnly: false,
+  include: '',
+  exclude: '',
+  discoverThinking: true,
+  imported: {},
+  usage: true,
+  pollSec: 120,
+  syncMin: 60,
+  lastImport: null,
+}
+const MAX_BODY = 64 * 1024
+
+const isObj = (v) => v !== null && typeof v === 'object' && !Array.isArray(v)
+const num = (v) => (typeof v === 'number' && Number.isFinite(v) && v > 0 ? Math.floor(v) : undefined)
+
+function stateFile() {
+  const dir = process.env.DSH_PROFILE_DIR || path.join(process.env.DSH_HOME || path.join(os.homedir(), '.dsh'), 'profiles', 'web')
+  return path.join(dir, 'omniroute.json')
+}
+
+function loadState() {
+  try {
+    const raw = JSON.parse(fs.readFileSync(stateFile(), 'utf8'))
+    return { ...DEFAULTS, ...(isObj(raw) ? raw : {}) }
+  } catch {
+    return { ...DEFAULTS }
+  }
+}
+
+function saveState(state) {
+  const file = stateFile()
+  const tmp = `${file}.${process.pid}.tmp`
+  fs.writeFileSync(tmp, JSON.stringify(state, null, 2))
+  fs.renameSync(tmp, file)
+}
+
+/** Gateway root without trailing slashes or a trailing /v1 segment. */
+function normalizeUrl(input) {
+  let url = String(input ?? '').trim().replace(/\/+$/, '')
+  url = url.replace(/\/v1$/i, '')
+  return url
+}
+
+function sendJson(res, status, payload) {
+  res.statusCode = status
+  res.setHeader('content-type', 'application/json; charset=utf-8')
+  res.setHeader('cache-control', 'no-store')
+  res.end(JSON.stringify(payload))
+}
+
+async function readJsonBody(req) {
+  const chunks = []
+  let size = 0
+  for await (const chunk of req) {
+    size += chunk.byteLength
+    if (size > MAX_BODY) { req.resume(); throw new Error('request body too large') }
+    chunks.push(chunk)
+  }
+  if (size === 0) return {}
+  const body = JSON.parse(Buffer.concat(chunks, size).toString('utf8'))
+  if (!isObj(body)) throw new Error('body must be a JSON object')
+  return body
+}
+
+/** Fetch JSON from the gateway; throws an Error carrying `.status`. */
+async function gateway(url, key, pathname, timeoutMs = 20000) {
+  const res = await fetch(`${url}${pathname}`, {
+    headers: { accept: 'application/json', ...(key ? { authorization: `Bearer ${key}` } : {}) },
+    signal: AbortSignal.timeout(timeoutMs),
+  })
+  const text = await res.text()
+  let json
+  try { json = text ? JSON.parse(text) : undefined } catch { json = undefined }
+  if (!res.ok) {
+    const msg = json?.error?.message ?? json?.error ?? json?.message ?? text.slice(0, 200) ?? res.statusText
+    const err = new Error(typeof msg === 'string' ? msg : JSON.stringify(msg))
+    err.status = res.status
+    throw err
+  }
+  return json
+}
+
+// ---------------------------------------------------------------- model mapping
+
+function pickBool(...values) {
+  for (const v of values) if (typeof v === 'boolean') return v
+  return undefined
+}
+
+// What a model offers when OmniRoute says it thinks but publishes no explicit tier list.
+const FALLBACK_TIERS = ['low', 'medium', 'high']
+
+function levelOf(item) {
+  const raw = isObj(item) ? (item.id ?? item.name ?? item.value) : item
+  const level = String(raw ?? '').trim().toLowerCase().replace(/[\s_-]+/g, '')
+  const canon = LEVEL_ALIASES[level] ?? level
+  return LEVELS.includes(canon) ? canon : undefined
+}
+
+/**
+ * Collect every thinking level the gateway publishes for one entry: effort tiers,
+ * supported-effort lists, and per-level capability maps. Order follows escalation order.
+ */
+export function discoverEfforts(entry) {
+  const caps = isObj(entry.capabilities) ? entry.capabilities : {}
+  const found = new Set()
+  const add = (raw) => {
+    if (Array.isArray(raw)) raw.forEach((item) => { const l = levelOf(item); if (l) found.add(l) })
+    else if (isObj(raw)) Object.keys(raw).forEach((k) => { const l = levelOf(k); if (l) found.add(l) })
+  }
+  for (const source of [
+    entry.effort_tiers, entry.supported_thinking_efforts, entry.supportedThinkingEfforts, entry.reasoning_efforts, entry.thinking_levels,
+    caps.effort_tiers, caps.supported_thinking_efforts, caps.supportedThinkingEfforts, caps.reasoning_efforts, caps.thinking_levels,
+  ]) add(source)
+  return LEVELS.filter((l) => found.has(l))
+}
+
+// Claude models accept the two top tiers (`xhigh` = "extra", `max`) even when the gateway
+// only lists low/medium/high, so reasoning-capable Claude models always offer them.
+const CLAUDE_TOP_TIERS = ['xhigh', 'max']
+export function isClaude(entry) {
+  const hay = [entry?.id, entry?.owned_by, entry?.provider].map((v) => String(v ?? '').toLowerCase()).join(' ')
+  return /claude|anthropic/.test(hay)
+}
+function withClaudeTiers(entry, efforts) {
+  if (!efforts || !isClaude(entry)) return efforts
+  const levels = LEVELS.filter((l) => l in efforts || CLAUDE_TOP_TIERS.includes(l))
+  return Object.fromEntries(levels.map((l) => [l, l in efforts ? efforts[l] : l]))
+}
+
+function mapEfforts(entry) {
+  const levels = discoverEfforts(entry)
+  if (levels.length === 0) return undefined
+  const out = {}
+  for (const level of levels) out[level] = level === 'off' ? null : level
+  return out
+}
+
+/** Convert one OmniRoute /v1/models (or /v1/combos) entry into a pi-ai model profile; null to skip. */
+export function toModelProfile(entry) {
+  if (!isObj(entry) || typeof entry.id !== 'string' || entry.id.length === 0) return null
+  if (typeof entry.type === 'string' && NON_CHAT_TYPES.has(entry.type)) return null
+  const caps = isObj(entry.capabilities) ? entry.capabilities : {}
+  const inMods = (Array.isArray(entry.input_modalities) ? entry.input_modalities : []).map((m) => String(m).toLowerCase())
+  const outMods = (Array.isArray(entry.output_modalities) ? entry.output_modalities : []).map((m) => String(m).toLowerCase())
+  if (outMods.length > 0 && !outMods.includes('text')) return null
+
+  const vision = pickBool(entry.vision, caps.vision) ?? (inMods.length > 0 ? inMods.includes('image') : undefined)
+  const input = ['text']
+  if (vision === true || inMods.includes('image')) input.push('image')
+
+  const profile = { id: entry.id, name: String(entry.name ?? entry.display_name ?? entry.id), input }
+  const ctxLen = num(entry.context_length) ?? num(entry.max_input_tokens) ?? num(caps.context_length)
+  const maxOut = num(entry.max_output_tokens) ?? num(caps.max_output_tokens)
+  if (ctxLen) profile.contextWindow = ctxLen
+  if (maxOut) profile.maxTokens = maxOut
+
+  const thinking = pickBool(entry.thinking, entry.supportsThinking, caps.thinking, caps.supportsThinking)
+  const efforts = mapEfforts(entry)
+  if (efforts) profile.reasoningEfforts = withClaudeTiers(entry, efforts)
+  else if (thinking === true || caps.reasoning === true) profile.reasoningEfforts = withClaudeTiers(entry, Object.fromEntries(FALLBACK_TIERS.map((l) => [l, l])))
+  else if (thinking === false) profile.reasoningEfforts = false
+  return profile
+}
+
+export function buildModelList(models, combos) {
+  const byId = new Map()
+  for (const entry of Array.isArray(models) ? models : []) {
+    const p = toModelProfile(entry)
+    if (p) byId.set(p.id, p)
+  }
+  // /v1/combos carries combo capability metadata; fill gaps without overriding catalog data.
+  for (const combo of Array.isArray(combos) ? combos : []) {
+    const id = typeof combo?.id === 'string' ? combo.id : typeof combo?.name === 'string' ? combo.name : undefined
+    if (!id) continue
+    const p = toModelProfile({ ...combo, id })
+    if (!p) continue
+    const prev = byId.get(p.id)
+    byId.set(p.id, prev ? { ...p, ...prev, input: prev.input.length >= p.input.length ? prev.input : p.input } : p)
+  }
+  return [...byId.values()].sort((a, b) => a.id.localeCompare(b.id))
+}
+
+// ---------------------------------------------------------------- filters
+
+/** Turn a comma/space separated pattern list ("claude*, gemini-*") into a matcher; empty list matches everything. */
+export function makeMatcher(spec) {
+  const parts = String(spec ?? '').split(/[\s,]+/).map((x) => x.trim().toLowerCase()).filter(Boolean)
+  if (parts.length === 0) return null
+  const res = parts.map((p) => new RegExp('^' + p.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*').replace(/\?/g, '.') + '$'))
+  return (id) => res.some((re) => re.test(String(id).toLowerCase()))
+}
+
+/** Keep incoming profiles that match `include` (when set) and do not match `exclude`. */
+export function filterIncoming(models, include, exclude) {
+  const inc = makeMatcher(include)
+  const exc = makeMatcher(exclude)
+  return models.filter((m) => (!inc || inc(m.id)) && !(exc && exc(m.id)))
+}
+
+// ---------------------------------------------------------------- merge
+
+/**
+ * Merge freshly discovered profiles into the user's existing model list.
+ *  - A name the user changed is never overwritten (a name still equal to what we imported last time may refresh).
+ *  - Fields we do not manage (compat, headers, ...) survive.
+ *  - updateOnly: only existing ids are touched; nothing is added or removed.
+ *  - Otherwise new ids are added, and ids we imported before that vanished from the gateway are dropped;
+ *    entries the user added by hand are always kept.
+ * @returns {{models: object[], added: number, updated: number, removed: number}}
+ */
+export function mergeModels(existing, incoming, opts) {
+  const { updateOnly, discoverThinking, imported } = opts
+  const prior = Array.isArray(existing) ? existing.filter((m) => isObj(m) && typeof m.id === 'string') : []
+  const byId = new Map(incoming.map((m) => [m.id, m]))
+  let added = 0
+  let updated = 0
+  let removed = 0
+  const out = []
+  for (const old of prior) {
+    const fresh = byId.get(old.id)
+    if (!fresh) {
+      if (!updateOnly && Object.prototype.hasOwnProperty.call(imported, old.id)) { removed++; continue }
+      out.push(old)
+      continue
+    }
+    const keepName = typeof old.name === 'string' && old.name.length > 0 && old.name !== imported[old.id]
+    const next = { ...old, ...fresh, name: keepName ? old.name : fresh.name }
+    if (!discoverThinking) {
+      if (old.reasoningEfforts === undefined) delete next.reasoningEfforts
+      else next.reasoningEfforts = old.reasoningEfforts
+    } else if (fresh.reasoningEfforts === undefined && old.reasoningEfforts !== undefined) {
+      next.reasoningEfforts = old.reasoningEfforts
+    }
+    if (JSON.stringify(next) !== JSON.stringify(old)) updated++
+    out.push(next)
+  }
+  if (!updateOnly) {
+    const known = new Set(prior.map((m) => m.id))
+    for (const m of incoming) {
+      if (known.has(m.id)) continue
+      const fresh = discoverThinking || m.reasoningEfforts === undefined ? m : (({ reasoningEfforts, ...rest }) => rest)(m)
+      out.push(fresh)
+      added++
+    }
+  }
+  return { models: out, added, updated, removed }
+}
+
+// ---------------------------------------------------------------- quota mapping
+
+export function mapQuotas(usage) {
+  const quotas = isObj(usage?.quotas) ? usage.quotas : {}
+  const out = []
+  for (const [key, q] of Object.entries(quotas)) {
+    if (!isObj(q)) continue
+    const total = typeof q.total === 'number' ? q.total : undefined
+    const used = typeof q.used === 'number' ? q.used : undefined
+    let remainingPct = typeof q.remainingPercentage === 'number' ? q.remainingPercentage : undefined
+    if (remainingPct === undefined && total && total > 0) {
+      const remaining = typeof q.remaining === 'number' ? q.remaining : used !== undefined ? total - used : undefined
+      if (remaining !== undefined) remainingPct = (remaining / total) * 100
+    }
+    out.push({
+      key,
+      label: String(q.displayName ?? key),
+      remainingPct: remainingPct === undefined ? null : Math.max(0, Math.min(100, Math.round(remainingPct * 10) / 10)),
+      used: used ?? null,
+      total: total ?? null,
+      unlimited: q.unlimited === true,
+      resetAt: typeof q.resetAt === 'string' ? q.resetAt : null,
+    })
+  }
+  return out
+}
+
+/**
+ * Merge the same quota window across several accounts of one provider into a single entry
+ * with the average percent left. Unlimited accounts do not pull the average; a window is
+ * unlimited only when every account's is. The reset shown is the soonest upcoming one.
+ * @param {Array<{id:string,provider:string,name:string,plan:string|null,quotas:object[]}>} accounts
+ */
+export function mergeQuotas(accounts) {
+  const groups = new Map()
+  for (const acct of accounts) {
+    for (const q of acct.quotas) {
+      const gk = `${String(acct.provider).toLowerCase()}\u0000${String(q.key).trim().toLowerCase()}`
+      let g = groups.get(gk)
+      if (!g) { g = { key: q.key, provider: acct.provider, label: q.label, items: [] }; groups.set(gk, g) }
+      g.items.push({ account: acct.name, plan: acct.plan, ...q })
+    }
+  }
+  const now = Date.now()
+  return [...groups.values()].map((g) => {
+    const finite = g.items.filter((i) => !i.unlimited && typeof i.remainingPct === 'number')
+    const unlimited = g.items.every((i) => i.unlimited)
+    const avg = finite.length > 0 ? finite.reduce((a, i) => a + i.remainingPct, 0) / finite.length : null
+    const resets = g.items.map((i) => Date.parse(i.resetAt)).filter((t) => Number.isFinite(t))
+    const upcoming = resets.filter((t) => t > now)
+    const reset = upcoming.length > 0 ? Math.min(...upcoming) : resets.length > 0 ? Math.max(...resets) : null
+    return {
+      key: g.key,
+      provider: g.provider,
+      label: g.label,
+      accounts: g.items.length,
+      remainingPct: avg === null ? null : Math.round(avg * 10) / 10,
+      unlimited,
+      resetAt: reset === null ? null : new Date(reset).toISOString(),
+      items: g.items.map((i) => ({
+        account: i.account,
+        remainingPct: i.unlimited ? null : i.remainingPct,
+        unlimited: i.unlimited,
+        used: i.used,
+        total: i.total,
+        resetAt: i.resetAt,
+      })),
+    }
+  })
+}
+
+// ---------------------------------------------------------------- plugin
+
+export function apply(ctx) {
+  let state = loadState()
+
+  const persist = (patch) => {
+    state = { ...state, ...patch }
+    saveState(state)
+  }
+
+  /** The llm-pi-ai provider row this plugin imports into (undefined when not configured). */
+  function providerRow() {
+    try {
+      const doc = ctx.settings.describe({ redactSecrets: true }).find((d) => d.ns === 'llm-pi-ai')
+      const row = doc?.value?.providers?.[state.provider]
+      return { revision: doc?.revision, row: isObj(row) ? row : undefined, present: doc !== undefined }
+    } catch {
+      return { present: false }
+    }
+  }
+
+  async function resolveKey(draftKey) {
+    if (draftKey) return draftKey
+    const refs = [state.keyRef, providerRow().row?.apiKeyEnv].filter((r) => typeof r === 'string' && r)
+    for (const ref of refs) {
+      const hit = await ctx.credentials.resolve(ref)
+      if (hit?.value) return hit.value
+    }
+    return undefined
+  }
+
+  function effectiveUrl(draftUrl) {
+    const fromProvider = providerRow().row?.baseURL
+    return normalizeUrl(draftUrl || state.url || fromProvider || '')
+  }
+
+  async function describeKey() {
+    const refs = [state.keyRef, providerRow().row?.apiKeyEnv].filter((r) => typeof r === 'string' && r)
+    for (const ref of refs) {
+      const info = await ctx.credentials.describe(ref)
+      if (info?.configured) return { configured: true, ref, source: info.source }
+    }
+    return { configured: false, ref: state.keyRef }
+  }
+
+  // ---- import ------------------------------------------------------------
+  let importing = null
+  async function importModels(mode) {
+    if (importing) return importing
+    // `mode` is a one-shot override of the saved toggle: 'update' (existing entries only) or 'full'.
+    const updateOnly = mode === 'update' ? true : mode === 'full' ? false : state.updateOnly
+    importing = (async () => {
+      const url = effectiveUrl()
+      const key = await resolveKey()
+      if (!url) throw new Error('OmniRoute URL is not set')
+      try {
+        const modelsJson = await gateway(url, key, '/v1/models', 30000)
+        let combosJson
+        try { combosJson = await gateway(url, key, '/v1/combos', 15000) } catch { combosJson = undefined }
+        const all = buildModelList(modelsJson?.data, combosJson?.data)
+        if (all.length === 0) throw new Error('OmniRoute returned no chat models')
+        // The filter decides what may be ADDED; existing entries are always refreshed by update mode.
+        const models = updateOnly ? all : filterIncoming(all, state.include, state.exclude)
+        if (models.length === 0) throw new Error('The include/exclude filter matches no models')
+
+        const { revision, row, present } = providerRow()
+        if (!present) throw new Error('the llm-pi-ai plugin is not mounted; cannot write models')
+        if (updateOnly && (!row || !Array.isArray(row.models) || row.models.length === 0)) {
+          throw new Error('There are no existing model entries to update yet. Use Re-discover models for the first import.')
+        }
+        const imported = isObj(state.imported) ? state.imported : {}
+        const merged = mergeModels(row?.models, models, { updateOnly, discoverThinking: state.discoverThinking, imported })
+        if (updateOnly && (merged.added > 0 || merged.removed > 0)) throw new Error('internal error: update-only import tried to add or remove models; nothing was written')
+        const changed = merged.added + merged.updated + merged.removed > 0 || !row
+        if (changed) {
+          const ops = row
+            ? [{ op: 'set', path: ['providers', state.provider, 'models'], value: merged.models }]
+            : [{
+                op: 'set',
+                path: ['providers', state.provider],
+                value: {
+                  displayName: 'OmniRoute',
+                  api: 'openai-completions',
+                  baseURL: `${url}/v1`,
+                  apiKeyEnv: state.keyRef,
+                  models: merged.models,
+                },
+              }]
+          await ctx.settings.mutate('llm-pi-ai', ops, revision)
+        }
+        // Remember what we imported (id -> name) so later runs can tell a user rename from our own value.
+        const importedNext = updateOnly ? imported : Object.fromEntries(models.map((m) => [m.id, m.name]))
+        const thinking = models.filter((m) => isObj(m.reasoningEfforts)).length
+        const result = {
+          at: new Date().toISOString(),
+          count: merged.models.length,
+          added: merged.added,
+          updated: merged.updated,
+          removed: merged.removed,
+          thinking,
+          changed,
+          error: null,
+        }
+        persist({ lastImport: result, imported: importedNext })
+        return result
+      } catch (error) {
+        const result = { at: new Date().toISOString(), count: 0, changed: false, error: String(error?.message ?? error) }
+        persist({ lastImport: result })
+        throw error
+      }
+    })().finally(() => { importing = null })
+    return importing
+  }
+
+  // ---- quotas ------------------------------------------------------------
+  const cache = { catalog: { at: 0, owners: new Map(), aliases: new Map() }, combos: { at: 0, list: [] }, usage: new Map() }
+
+  /** id -> owned_by for every model, plus alias -> canonical provider from `alias/model` ids. */
+  async function catalog(url, key) {
+    if (Date.now() - cache.catalog.at < 5 * 60_000) return cache.catalog
+    const json = await gateway(url, key, '/v1/models', 30000)
+    const owners = new Map()
+    const aliases = new Map()
+    for (const m of Array.isArray(json?.data) ? json.data : []) {
+      if (typeof m?.id !== 'string' || typeof m.owned_by !== 'string') continue
+      owners.set(m.id, m.owned_by)
+      const slash = m.id.indexOf('/')
+      if (slash > 0 && m.owned_by !== 'combo') aliases.set(m.id.slice(0, slash).toLowerCase(), m.owned_by)
+    }
+    cache.catalog = { at: Date.now(), owners, aliases }
+    return cache.catalog
+  }
+
+  async function combosList(url, key) {
+    if (Date.now() - cache.combos.at < 5 * 60_000) return cache.combos.list
+    let list = []
+    try {
+      // The management API caps `limit` at 200, so page through it.
+      for (let offset = 0; offset < 5000; offset += 200) {
+        const json = await gateway(url, key, `/api/combos?limit=200&offset=${offset}`, 20000)
+        const page = Array.isArray(json?.combos) ? json.combos : Array.isArray(json) ? json : []
+        list = list.concat(page)
+        if (page.length < 200 || (typeof json?.total === 'number' && list.length >= json.total)) break
+      }
+    } catch (error) {
+      // Fall back to the API-key-safe listing, which may omit some routing detail.
+      const json = await gateway(url, key, '/v1/combos', 20000).catch(() => { throw error })
+      list = Array.isArray(json?.data) ? json.data : []
+    }
+    cache.combos = { at: Date.now(), list }
+    return list
+  }
+
+  /**
+   * Which provider connections can serve `modelId`?
+   * @returns {{providers:Set<string>, connections:Set<string>}} lower-cased provider ids and explicit connection ids
+   */
+  async function servingTargets(url, key, modelId) {
+    const out = { providers: new Set(), connections: new Set(), tokens: new Set(), steps: 0 }
+    const cat = await catalog(url, key)
+    const canon = (raw) => {
+      const p = String(raw ?? '').toLowerCase()
+      return (cat.aliases.get(p) ?? p).toLowerCase()
+    }
+    const addStep = (step, seen) => {
+      out.steps++
+      if (typeof step === 'string') {
+        const i = step.indexOf('/')
+        if (i > 0) out.providers.add(canon(step.slice(0, i)))
+        return
+      }
+      if (!isObj(step)) return
+      if (step.kind === 'combo-ref' || (typeof step.comboName === 'string' && !step.model)) {
+        walk(step.comboName, seen)
+        return
+      }
+      let provider = step.providerId ?? step.provider
+      if (!provider && typeof step.model === 'string' && step.model.includes('/')) provider = step.model.slice(0, step.model.indexOf('/'))
+      if (!provider) return
+      out.tokens.add(String(provider))
+      const scoped = [step.connectionId, ...(Array.isArray(step.allowedConnectionIds) ? step.allowedConnectionIds : [])].filter(Boolean)
+      if (scoped.length > 0) scoped.forEach((id) => out.connections.add(String(id)))
+      else out.providers.add(canon(provider))
+    }
+    let combos = []
+    const walk = async (name, seen = new Set()) => {
+      if (!name || seen.has(name)) return
+      seen.add(name)
+      const combo = combos.find((c) => c?.name === name || c?.id === name)
+      if (!combo) return
+      for (const step of Array.isArray(combo.models) ? combo.models : []) {
+        if (isObj(step) && (step.kind === 'combo-ref' || (typeof step.comboName === 'string' && !step.model))) await walk(step.comboName, seen)
+        else addStep(step, seen)
+      }
+    }
+    const owner = cat.owners.get(modelId)
+    if (owner && owner !== 'combo') {
+      out.providers.add(canon(owner))
+      return out
+    }
+    // A combo (or an unknown id): resolve its steps through the management API.
+    combos = await combosList(url, key)
+    await walk(modelId)
+    return out
+  }
+
+  async function usageFor(url, key, id) {
+    const hit = cache.usage.get(id)
+    if (hit && Date.now() - hit.at < 45_000) return hit.value
+    const value = await gateway(url, key, `/api/usage/${encodeURIComponent(id)}`, 25000)
+    cache.usage.set(id, { at: Date.now(), value })
+    return value
+  }
+
+  /** Quotas for the selected model only; nothing at all unless the model is served by this plugin's provider. */
+  async function quotas(providerId, modelId) {
+    if (!providerId || !modelId || providerId !== state.provider) return { providers: [], scope: 'foreign-model' }
+    const url = effectiveUrl()
+    const key = await resolveKey()
+    if (!url || !key) return { providers: [], error: 'not-configured' }
+    let connections
+    try {
+      const json = await gateway(url, key, '/api/providers?limit=200', 20000)
+      connections = (Array.isArray(json?.connections) ? json.connections : []).filter((c) => c && c.isActive !== false)
+    } catch (error) {
+      if (error.status === 401 || error.status === 403) {
+        return { providers: [], error: 'management-auth', message: 'This API key has no management access, so quotas cannot be read.' }
+      }
+      throw error
+    }
+    let serving
+    try { serving = await servingTargets(url, key, modelId) } catch (error) { return { providers: [], scope: 'unresolved', message: String(error?.message ?? error) } }
+    if (serving.providers.size === 0 && serving.connections.size === 0) {
+      return { providers: [], scope: 'unresolved', message: serving.steps === 0 ? `Could not read the steps of "${modelId}" (is the key allowed to read combos?)` : `No provider found for the steps of "${modelId}"` }
+    }
+    const targets = connections
+      .filter((c) => serving.providers.has(String(c.provider).toLowerCase()) || serving.connections.has(String(c.id)))
+      .slice(0, 16)
+    const settled = await Promise.allSettled(targets.map((c) => usageFor(url, key, c.id)))
+    const connectionNames = new Set(connections.map((c) => String(c.provider).toLowerCase()))
+    const providers = targets.map((c, i) => {
+      const r = settled[i]
+      const usage = r.status === 'fulfilled' ? r.value : undefined
+      return {
+        id: c.id,
+        provider: c.provider,
+        name: c.name ?? c.email ?? c.provider,
+        plan: typeof usage?.plan === 'string' ? usage.plan : null,
+        message: r.status === 'rejected' ? String(r.reason?.message ?? r.reason) : typeof usage?.message === 'string' ? usage.message : null,
+        quotas: usage ? mapQuotas(usage) : [],
+      }
+    }).filter((p) => p.quotas.length > 0)
+    if (providers.length === 0) {
+      const wanted = [...serving.providers].join(', ')
+      const have = [...connectionNames].join(', ')
+      return { providers: [], scope: 'no-quota-data', message: targets.length === 0
+        ? `Combo uses [${wanted}] but no matching active connection exists (connections: ${have}).`
+        : `Providers [${wanted}] report no quota data.` }
+    }
+    return { providers, merged: mergeQuotas(providers) }
+  }
+
+  // ---- routes ------------------------------------------------------------
+  const route = (pathname, methods, handler) => ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: pathname,
+    handler: async (req, res) => {
+      if (ctx.connection.requestRejection(req) !== undefined) {
+        sendJson(res, ctx.connection.requestRejection(req), { code: 'rejected' })
+        return
+      }
+      if (!methods.includes(req.method)) {
+        res.statusCode = 405
+        res.setHeader('allow', methods.join(', '))
+        res.end()
+        return
+      }
+      try {
+        sendJson(res, 200, await handler(req))
+      } catch (error) {
+        sendJson(res, error?.status && error.status < 600 && error.status >= 400 ? 502 : 500, {
+          code: 'error',
+          message: String(error?.message ?? error),
+        })
+      }
+    },
+  }), `omniroute: ${pathname}`)
+
+  route('/omniroute/status', ['GET'], async () => ({
+    api: 4, // 2 = import honours one-shot modes ('update' never adds or removes entries)
+    url: state.url,
+    effectiveUrl: effectiveUrl(),
+    provider: state.provider,
+    discovery: state.discovery,
+    updateOnly: state.updateOnly,
+    include: state.include,
+    exclude: state.exclude,
+    discoverThinking: state.discoverThinking,
+    usage: state.usage,
+    pollSec: state.pollSec,
+    syncMin: state.syncMin,
+    key: await describeKey(),
+    lastImport: state.lastImport,
+  }))
+
+  route('/omniroute/config', ['POST'], async (req) => {
+    const body = await readJsonBody(req)
+    const patch = {}
+    if (typeof body.url === 'string') patch.url = normalizeUrl(body.url)
+    if (typeof body.provider === 'string' && body.provider.trim()) patch.provider = body.provider.trim()
+    if (typeof body.discovery === 'boolean') patch.discovery = body.discovery
+    if (typeof body.usage === 'boolean') patch.usage = body.usage
+    if (typeof body.updateOnly === 'boolean') patch.updateOnly = body.updateOnly
+    if (typeof body.include === 'string') patch.include = body.include.slice(0, 2000)
+    if (typeof body.exclude === 'string') patch.exclude = body.exclude.slice(0, 2000)
+    if (typeof body.discoverThinking === 'boolean') patch.discoverThinking = body.discoverThinking
+    if (typeof body.pollSec === 'number') patch.pollSec = Math.max(30, Math.min(3600, Math.floor(body.pollSec)))
+    if (typeof body.syncMin === 'number') patch.syncMin = Math.max(0, Math.min(1440, Math.floor(body.syncMin)))
+    if (typeof body.apiKey === 'string' && body.apiKey.length > 0) await ctx.credentials.set(state.keyRef, body.apiKey)
+    if (body.clearKey === true) await ctx.credentials.unset(state.keyRef)
+    persist(patch)
+    cache.catalog.at = 0
+    cache.combos.at = 0
+    cache.usage.clear()
+    scheduleSync()
+    return { ok: true }
+  })
+
+  route('/omniroute/test', ['POST'], async (req) => {
+    const body = await readJsonBody(req)
+    const url = effectiveUrl(typeof body.url === 'string' ? normalizeUrl(body.url) : '')
+    const key = await resolveKey(typeof body.apiKey === 'string' ? body.apiKey : '')
+    if (!url) return { ok: false, message: 'Enter the OmniRoute URL first.' }
+    const started = Date.now()
+    let models
+    try {
+      const json = await gateway(url, key, '/v1/models', 20000)
+      models = buildModelList(json?.data, undefined)
+    } catch (error) {
+      const hint = error.status === 401 || error.status === 403 ? ' (check the API key)' : ''
+      return { ok: false, message: `${String(error.message)}${hint}` }
+    }
+    let management = false
+    let connections = 0
+    try {
+      const json = await gateway(url, key, '/api/providers?limit=200', 15000)
+      management = true
+      connections = Array.isArray(json?.connections) ? json.connections.length : 0
+    } catch { management = false }
+    return { ok: true, models: models.length, management, connections, ms: Date.now() - started }
+  })
+
+  /** Models currently in the provider, flagged by whether this plugin imported them. */
+  route('/omniroute/models', ['GET'], async () => {
+    const { row } = providerRow()
+    const imported = isObj(state.imported) ? state.imported : {}
+    const list = Array.isArray(row?.models) ? row.models : []
+    return {
+      provider: state.provider,
+      total: list.length,
+      models: list.filter((m) => isObj(m) && typeof m.id === 'string').map((m) => ({
+        id: m.id,
+        name: typeof m.name === 'string' ? m.name : m.id,
+        imported: Object.prototype.hasOwnProperty.call(imported, m.id),
+      })),
+    }
+  })
+
+  /**
+   * Remove models from the provider.
+   *   { ids: [...] }         remove exactly these ids
+   *   { keep: [...] }        remove every plugin-imported model not listed (hand-added entries are never touched)
+   * Models referenced by the default model or the subagent allow-list are refused.
+   */
+  route('/omniroute/prune', ['POST'], async (req) => {
+    const body = await readJsonBody(req)
+    const { revision, row, present } = providerRow()
+    if (!present || !Array.isArray(row?.models)) throw new Error('the provider has no models to prune')
+    const imported = isObj(state.imported) ? state.imported : {}
+    const isImported = (id) => Object.prototype.hasOwnProperty.call(imported, id)
+    let doomed
+    if (Array.isArray(body.ids)) {
+      const want = new Set(body.ids.map(String))
+      doomed = row.models.filter((m) => want.has(m.id)).map((m) => m.id)
+    } else if (Array.isArray(body.keep)) {
+      const keep = new Set(body.keep.map(String))
+      doomed = row.models.filter((m) => isImported(m.id) && !keep.has(m.id)).map((m) => m.id)
+    } else throw new Error('send { ids: [...] } or { keep: [...] }')
+    // Never remove a model the profile still points at (default model, subagent allow-list).
+    const inUse = new Set()
+    try {
+      for (const d of ctx.settings.describe({ redactSecrets: true })) {
+        const v = d?.value
+        if (d.ns === 'agent-default-model' && v?.provider === state.provider && typeof v.model === 'string') inUse.add(v.model)
+        for (const m of Array.isArray(v?.allowedModels) ? v.allowedModels : []) {
+          if (m?.provider === state.provider && typeof m.model === 'string') inUse.add(m.model)
+        }
+      }
+    } catch { /* settings unavailable: fall through, mutate will still validate */ }
+    const blocked = doomed.filter((id) => inUse.has(id))
+    doomed = doomed.filter((id) => !inUse.has(id))
+    if (doomed.length === 0) return { removed: 0, remaining: row.models.length, protected: blocked }
+    const gone = new Set(doomed)
+    const remaining = row.models.filter((m) => !gone.has(m.id))
+    if (remaining.length === 0) throw new Error('Refusing to remove every model from the provider.')
+    await ctx.settings.mutate('llm-pi-ai', [{ op: 'set', path: ['providers', state.provider, 'models'], value: remaining }], revision)
+    const nextImported = { ...imported }
+    for (const id of doomed) delete nextImported[id]
+    persist({ imported: nextImported })
+    return { removed: doomed.length, remaining: remaining.length, protected: blocked }
+  })
+
+  route('/omniroute/import', ['POST'], async (req) => {
+    const body = await readJsonBody(req)
+    const mode = body.mode === 'update' || body.mode === 'full' ? body.mode : undefined
+    return importModels(mode)
+  })
+
+  route('/omniroute/quotas', ['GET'], async (req) => {
+    if (!state.usage) return { disabled: true, providers: [] }
+    const params = new URL(req.url ?? '/', 'http://x').searchParams
+    return quotas(params.get('provider') || undefined, params.get('model') || undefined)
+  })
+
+  // ---- periodic discovery ------------------------------------------------
+  // settings.mutate runs through the HMR queue, which rejects calls made inside the
+  // async context of a reload. Timers created in apply() inherit that context, so the
+  // scheduler pokes a token-guarded loopback route whose handler runs in a clean one.
+  const token = crypto.randomUUID()
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/omniroute/internal-sync',
+    handler: async (req, res) => {
+      const addr = req.socket.remoteAddress ?? ''
+      const loopback = addr === '127.0.0.1' || addr === '::1' || addr === '::ffff:127.0.0.1'
+      if (!loopback || req.headers['x-omniroute-token'] !== token) { res.statusCode = 404; res.end(); return }
+      try { sendJson(res, 200, await importModels()) } catch (error) { sendJson(res, 500, { message: String(error?.message ?? error) }) }
+    },
+  }), 'omniroute: internal sync')
+
+  const pokeSync = async () => {
+    const host = ctx.webServer.host === '0.0.0.0' ? '127.0.0.1' : ctx.webServer.host
+    const res = await fetch(`http://${host}:${ctx.webServer.port}/omniroute/internal-sync`, {
+      headers: { 'x-omniroute-token': token },
+      signal: AbortSignal.timeout(60_000),
+    })
+    if (!res.ok) throw new Error(`sync failed (${res.status})`)
+  }
+
+  let timer
+  function scheduleSync() {
+    clearInterval(timer)
+    timer = undefined
+    if (state.discovery && state.syncMin > 0) {
+      timer = setInterval(() => { pokeSync().catch(() => {}) }, state.syncMin * 60_000)
+    }
+  }
+  ctx.effect(() => {
+    scheduleSync()
+    let boot
+    let attempt = 0
+    const bootImport = () => {
+      boot = undefined
+      if (!state.discovery || !effectiveUrl()) return
+      pokeSync().catch(() => {
+        if (++attempt < 5) boot = setTimeout(bootImport, 15_000 * attempt)
+      })
+    }
+    boot = setTimeout(bootImport, 8000)
+    return () => { clearTimeout(boot); clearInterval(timer) }
+  }, 'omniroute: discovery scheduler')
+}

locale/en.json

@@ -0,0 +1 @@
+{ "meta": { "title": "OmniRoute", "description": "Connect to an OmniRoute gateway: auto-import models with context window, output limit, modalities and thinking levels, and show provider quotas under the composer." } }

locale/zh.json

@@ -0,0 +1 @@
+{ "meta": { "title": "OmniRoute", "description": "连接 OmniRoute 网关：自动导入模型（上下文窗口、输出上限、模态、思考强度），并在输入框下方显示各提供商配额。" } }

package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@local/omniroute",
+  "version": "1.0.0",
+  "description": "OmniRoute gateway integration: model auto-import (context window, max output, modalities, thinking levels) and provider quota tracking.",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client.js",
+    "./package.json": "./package.json",
+    "./locale/*.json": "./locale/*.json"
+  },
+  "files": ["index.js", "client.js", "cordis.patch.yml", "locale/*.json"],
+  "dsh": {
+    "bundle": { "patch": "./cordis.patch.yml" },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": [
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-conversation",
+        "@deepseek-ai/dsh-client-ui-model-selection",
+        "@deepseek-ai/dsh-client-ui-plugin-manager"
+      ]
+    }
+  }
+}