zames_pro 2.72.9 → 2.73.1

package/dist/index.js

@@ -6,6 +6,8 @@ import { existsSync, statSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { theme } from './theme.js';
 import { DeepSeekBrowser, headlessUACacheReady } from './browser.js';
+import { QwenBrowser } from './qwen-browser.js';
+import { isProviderId, asProviderId, providerChatUrlPrefix, providerLabel, } from './providers.js';
 import { createTools, mergeTools, filterToolsForReadOnly, filterToolsByAllowList, } from './tools.js';
 import { createTodoStore, getTodos, setTodos, resetTodos, renderTodos, } from './extraTools.js';
 import { runAgentLoop } from './agent-loop.js';
@@ -14,7 +16,7 @@ import { createSpinner } from './spinner.js';
 import { LineEditor } from './input.js';
 import { promptOnce } from './prompt.js';
 import { parseImagePaste, extForMime, saveToTemp, guessMime, formatSize, readClipboardImageDetailed, sniffMime, readWindowsClipboardFiles, hasClipboardTool, writeClipboardText, contentHash, } from './attachments.js';
-import { loadConfig, DEFAULTS, CONFIG_PATHS, ZAMES_HOME, CONFIG_SCHEMA, getByPath, validateConfigValue, writeConfigValue, resetConfigValue, } from './config.js';
+import { loadConfig, DEFAULTS, CONFIG_PATHS, ZAMES_HOME, CONFIG_SCHEMA, getByPath, validateConfigValue, writeConfigValue, resetConfigValue, providerAskDeadlineMs, } from './config.js';
 import { runConfigMenu } from './config-menu.js';
 import { formatConfigList } from './config-commands.js';
 import { handleConfigCommand as runConfigCommand } from './config-command.js';
@@ -24,6 +26,7 @@ import { UndoStore } from './undo.js';
 import { CheckpointStore, pickRecord as pickCheckpoint } from './checkpoint.js';
 import { selfReview, selfDiff, selfApply, selfList } from './self-review.js';
 import { performCompact } from './compact.js';
+import { buildHandoffText, saveProviderHandoff, readProviderHandoff, clearProviderHandoff, } from './provider-handoff.js';
 import { Scheduler, parseInterval, formatInterval, formatJobLine, parseCron, } from './scheduler.js';
 import { createCliArgs } from './cli-args.js';
 import { renderMarkdown, setAnswerWidth } from './markdown.js';
@@ -121,10 +124,14 @@ if (jsonMode) {
 function saveLastChat(id, workdir = '', title = '') {
     if (!id)
         return;
-    saveSession({ id, workdir, title });
+    // Tag the session with the ACTIVE provider: a chat id is only meaningful to
+    // the backend that created it, so a later resume must open it in the same
+    // one (or refuse). Without this a /provider switch made /resume try to open a
+    // qwen id in DeepSeek (and vice versa).
+    saveSession({ id, workdir, title, provider: config.provider });
 }
 function loadLastChat(workdir = '') {
-    const s = loadLastSession(workdir);
+    const s = loadLastSession(workdir, config.provider);
     return s ? s.id : null;
 }
 // Persistent per-project session goal (set by /goal). Kept OUT of the session
@@ -591,6 +598,61 @@ async function resolveWorkdir() {
     return dir;
 }
 // ---------- restored dialogue ----------
+/**
+ * The answer timeout for a one-off provider call (compact summary, etc.).
+ * Qwen's cold guest turns are far slower than DeepSeek's, so using
+ * config.browser.answerTimeoutMs there cut them off; pick the active
+ * provider's own value.
+ */
+function providerAnswerTimeoutMs() {
+    return config.provider === 'qwen'
+        ? config.qwen.answerTimeoutMs
+        : config.browser.answerTimeoutMs;
+}
+/** The provider's base chat URL, used by /chat to build the right link. */
+function browserProviderUrl() {
+    return providerChatUrlPrefix(config.provider);
+}
+/**
+ * Build the browser for a provider. Called at startup AND on a live
+ * `/provider` switch, so both paths construct the class the same way. The
+ * two backends differ in every layer (selectors, SSE format, chat-id scheme),
+ * so the choice is a class, not a flag; the shared timings live in
+ * config.browser and only Qwen-only knobs are overridden.
+ */
+function createProviderBrowser(provider) {
+    const persistAuth = (username, password) => {
+        config.browser.auth.username = username;
+        config.browser.auth.password = password;
+        try {
+            writeConfigValue('home', 'browser.auth.username', username);
+            writeConfigValue('home', 'browser.auth.password', password);
+        }
+        catch { }
+    };
+    return provider === 'qwen'
+        ? new QwenBrowser({
+            headless,
+            debug,
+            channel: config.browserChannel,
+            ...config.browser,
+            // Qwen-specific overrides (see config.qwen): no 15s DeepSeek
+            // throttle, a longer cold-start answer timeout.
+            minSendIntervalMs: config.qwen.minSendIntervalMs,
+            answerTimeoutMs: config.qwen.answerTimeoutMs,
+            model: config.qwen.model,
+            locale: currentLocale,
+            onAuthSave: persistAuth,
+        })
+        : new DeepSeekBrowser({
+            headless,
+            debug,
+            channel: config.browserChannel,
+            ...config.browser,
+            locale: currentLocale,
+            onAuthSave: persistAuth,
+        });
+}
 /**
  * Print the dialogue of the just-opened chat into the terminal. Called by
  * /resume, /resume-id and on startup when a previous session is restored, so
@@ -757,24 +819,15 @@ async function main() {
     catch (e) {
         console.error(theme.warn(t('mcp.load_failed', { v: e.message })));
     }
-    const browser = new DeepSeekBrowser({
-        headless,
-        debug,
-        channel: config.browserChannel,
-        ...config.browser,
-        locale: currentLocale,
-        // Persist credentials the operator typed in the terminal so the next
-        // launch can re-login silently after a logout.
-        onAuthSave: (username, password) => {
-            config.browser.auth.username = username;
-            config.browser.auth.password = password;
-            try {
-                writeConfigValue('home', 'browser.auth.username', username);
-                writeConfigValue('home', 'browser.auth.password', password);
-            }
-            catch { }
-        },
-    });
+    // Build the browser for the ACTIVE provider. The two backends differ in
+    // every layer (selectors, SSE format, chat-id scheme), so the switch is a
+    // class choice, not a flag. The shared timings live in config.browser; only
+    // the model is provider-specific. A provider switch takes effect on the
+    // next launch (the operator is told to restart).
+    // `let`, not `const`: a live /provider switch disposes this instance and
+    // builds the other one IN PLACE (see the /provider block in the main loop),
+    // so the URL changes without restarting zames.
+    let browser = createProviderBrowser(asProviderId(config.provider));
     const bootSpinner = mod.createSpinner(currentLocale);
     bootSpinner.thinking();
     try {
@@ -821,7 +874,7 @@ async function main() {
         // explicitly: --chat <id> or --resume-last.
         let resumeId = chatIdArg;
         if (!resumeId && resumeLastFlag && !newChatFlag) {
-            const last = loadLastSession(currentWorkdir);
+            const last = loadLastSession(currentWorkdir, config.provider);
             if (last && last.id) {
                 resumeId = last.id;
                 console.log(theme.system(t('msg.resuming', { id: resumeId })));
@@ -937,7 +990,7 @@ async function main() {
             },
             transcript,
             maxSubagents: config.browser.maxSubagents,
-            askDeadlineMs: config.browser.askDeadlineMs,
+            askDeadlineMs: providerAskDeadlineMs(config),
             maxAfterToolRetries: config.browser.maxAfterToolRetries,
             // An `ask` permission rule must also gate the subagent: otherwise a
             // guarded tool (e.g. a dangerous Bash command) would run inside the
@@ -1075,7 +1128,7 @@ async function main() {
     //   --new-chat      kept for compatibility (this is the default behavior)
     let resumeId = chatIdArg;
     if (!resumeId && resumeLastFlag && !newChatFlag) {
-        const last = loadLastSession(currentWorkdir);
+        const last = loadLastSession(currentWorkdir, config.provider);
         if (last && last.id) {
             resumeId = last.id;
             console.log(theme.system(t('msg.resuming', {
@@ -1137,6 +1190,8 @@ async function main() {
         });
         editor = ed;
         ed.setTmpDir(TMP_DIR);
+        // Provider badge: show which backend is answering ([Qwen]/[DeepSeek]).
+        ed.setProvider(providerLabel(config.provider));
         // Restore the input history from the previous runs and persist every new
         // entry, so Ctrl+R / arrows can recall older messages after a restart.
         ed.history = loadHistory();
@@ -1983,10 +2038,199 @@ async function main() {
             }
             continue;
         }
+        if (lower === '/provider' || lower.startsWith('/provider ')) {
+            const arg = trimmed.slice('/provider'.length).trim().toLowerCase();
+            if (!arg || arg === 'status') {
+                const model = config.provider === 'qwen' ? config.qwen.model || '(default)' : 'n/a';
+                console.log(theme.system(t('provider.status', {
+                    v: config.provider,
+                    m: model,
+                    auth: authMarkerExists() ? 'yes' : 'no',
+                })));
+                continue;
+            }
+            if (arg === 'login') {
+                try {
+                    await browser.waitForLogin();
+                    console.log(theme.system(t('provider.login_done')));
+                }
+                catch (e) {
+                    console.error(theme.warn(e.message));
+                }
+                continue;
+            }
+            if (isProviderId(arg)) {
+                const from = config.provider;
+                if (arg === from) {
+                    console.log(theme.system(t('provider.switched', { v: arg })));
+                    continue;
+                }
+                // Is there anything worth carrying over? A FRESH/EMPTY chat has no
+                // context to summarize, so switching it is a pure URL/backend change:
+                // summarizing an empty chat used to post a useless "please compact"
+                // request into a brand-new chat (a real complaint). We only build a
+                // handoff when the chat actually has messages.
+                let chatHasMessages = false;
+                if (browser.fetchChatMessages) {
+                    const cid = await browser.getCurrentChatId().catch(() => null);
+                    if (cid) {
+                        const all = await browser.fetchChatMessages(cid).catch(() => []);
+                        chatHasMessages =
+                            mod.commands.trimRestoredMessages(all, 0).length > 0;
+                    }
+                }
+                if (chatHasMessages) {
+                    // CARRY-OVER: a chat id only exists on its own backend, so switching
+                    // providers loses the conversation. Summarize the CURRENT chat (still
+                    // on the OLD browser object) and persist a handoff for the target; it
+                    // is posted as the first message once the new provider is live.
+                    if (editor)
+                        editor.lock(t('msg.input_locked'));
+                    try {
+                        const spin = editor || mod.createSpinner(currentLocale);
+                        spin.thinking();
+                        let summary = '';
+                        try {
+                            const answer = await browser.ask(mod.commands.buildCompactPrompt(currentLocale), {
+                                agent: true,
+                                timeout: providerAnswerTimeoutMs(),
+                            });
+                            const trimmed = String(answer || '').trim();
+                            if (mod.commands.isUsableCompactSummary(trimmed))
+                                summary = trimmed;
+                        }
+                        catch (e) {
+                            if (debug)
+                                console.error('handoff summary failed:', e.message);
+                        }
+                        // Fall back to the LOCAL history when the model summary is unusable.
+                        if (!summary && browser.fetchChatMessages) {
+                            const cid = await browser.getCurrentChatId().catch(() => null);
+                            const all = cid
+                                ? await browser.fetchChatMessages(cid).catch(() => [])
+                                : [];
+                            const msgs = mod.commands.trimRestoredMessages(all, 0);
+                            if (msgs.length) {
+                                summary = mod.commands.formatRestoredHistory(msgs, {
+                                    limit: 40,
+                                });
+                            }
+                        }
+                        spin.stop();
+                        if (summary) {
+                            saveProviderHandoff({
+                                provider: arg,
+                                workdir: currentWorkdir,
+                                summary,
+                                task: lastTaskText || undefined,
+                                createdAt: new Date().toISOString(),
+                            });
+                            console.log(theme.system(t('provider.handoff_saved', { v: arg })));
+                        }
+                        else {
+                            console.log(theme.warn(t('provider.handoff_empty')));
+                        }
+                    }
+                    finally {
+                        if (editor)
+                            editor.unlock();
+                    }
+                }
+                // Tag the current session with the OLD provider before switching.
+                if (currentChatId)
+                    saveLastChat(currentChatId, currentWorkdir);
+                // Persist the choice FIRST so a crash mid-switch still remembers it.
+                config.provider = arg;
+                config.qwen.enabled = arg === 'qwen';
+                try {
+                    writeConfigValue('home', 'provider', arg);
+                }
+                catch { }
+                // LIVE SWITCH: dispose the old backend and open the new one in place,
+                // so the operator does not have to restart zames. The chat is NOT
+                // resumable across providers (different chat ids), so the new backend
+                // starts a FRESH chat and the handoff (if any) is posted with the next
+                // task.
+                if (editor)
+                    editor.lock(t('msg.input_locked'));
+                try {
+                    console.log(theme.system(t('provider.switching', { v: arg })));
+                    // Launch the NEW backend FIRST; only close the old one once it is up.
+                    // If we closed the old browser before the new one launched and the
+                    // launch failed, `browser` would point at a dead instance and every
+                    // later command would break.
+                    const nextBrowser = createProviderBrowser(arg);
+                    await nextBrowser.launch();
+                    await nextBrowser.waitForLogin();
+                    const oldBrowser = browser;
+                    browser = nextBrowser;
+                    await oldBrowser.close().catch(() => { });
+                    // The new backend has no chat yet.
+                    currentChatId = await browser.getCurrentChatId().catch(() => null);
+                    if (editor) {
+                        editor.setProvider(providerLabel(arg));
+                    }
+                    try {
+                        warnUiHealth(await browser.probeUiHealth());
+                    }
+                    catch { }
+                    console.log(theme.system(t('provider.switched', { v: arg })));
+                }
+                catch (e) {
+                    // The new backend did not come up: keep the OLD one active so the
+                    // session keeps working, and roll the persisted choice back.
+                    config.provider = from;
+                    config.qwen.enabled = from === 'qwen';
+                    try {
+                        writeConfigValue('home', 'provider', from);
+                    }
+                    catch { }
+                    console.error(theme.warn(t('provider.switch_failed', {
+                        v: arg,
+                        error: e.message,
+                    })));
+                }
+                finally {
+                    if (editor)
+                        editor.unlock();
+                }
+                continue;
+            }
+            console.error(theme.warn(t('provider.usage')));
+            continue;
+        }
+        if (lower === '/model' || lower.startsWith('/model ')) {
+            const arg = trimmed.slice('/model'.length).trim();
+            if (config.provider !== 'qwen') {
+                console.log(theme.system(t('provider.usage')));
+                continue;
+            }
+            const qb = browser;
+            if (!arg) {
+                const models = qb.listModels ? await qb.listModels() : [];
+                if (!models.length) {
+                    console.log(theme.system(t('qwen.model_list', { v: '(none)' })));
+                }
+                else {
+                    const lines = models.map((m) => `  ${m.id}  —  ${m.name}`).join(NL);
+                    console.log(theme.system(t('qwen.model_list', { v: lines })));
+                }
+                continue;
+            }
+            config.qwen.model = arg;
+            if (typeof qb.model === 'string')
+                qb.model = arg;
+            try {
+                writeConfigValue('home', 'qwen.model', arg);
+            }
+            catch { }
+            console.log(theme.system(t('qwen.model_set', { v: arg })));
+            continue;
+        }
         if (lower === '/chat') {
             if (currentChatId) {
                 console.log(theme.system(t('chats.current_id', { v: currentChatId })));
-                console.log(theme.system(`URL: https://chat.deepseek.com/a/chat/s/${currentChatId}`));
+                console.log(theme.system(`URL: ${browserProviderUrl()}/${currentChatId}`));
             }
             else {
                 const id = await browser.getCurrentChatId();
@@ -2028,7 +2272,7 @@ async function main() {
         if (lower === '/last') {
             // Quick resume of the last chat for THIS working directory — otherwise
             // finding it meant /chats (a network fetch) or copying the id.
-            const last = loadLastSession(currentWorkdir);
+            const last = loadLastSession(currentWorkdir, config.provider);
             if (!last || !last.id) {
                 console.error(theme.error(t('sessions.none')));
                 continue;
@@ -2721,6 +2965,8 @@ async function main() {
                 uiPresent: uiHealth?.present,
                 uiMissing: uiHealth?.missing,
                 uiMissingCritical: uiHealth?.missingCritical,
+                provider: config.provider,
+                providerModel: config.provider === 'qwen' ? config.qwen.model : undefined,
             }, t)));
             continue;
         }
@@ -2755,7 +3001,7 @@ async function main() {
                 ui: editor,
                 buildSystemPrompt: mod.buildSystemPrompt,
                 tools: mod.createTools(currentWorkdir, { undo, todos: todoStore }),
-                answerTimeoutMs: config.browser.answerTimeoutMs,
+                answerTimeoutMs: providerAnswerTimeoutMs(),
                 fallbackLimit: COMPACT_FALLBACK_LIMIT,
                 selfImprovement: devMode,
             });
@@ -3112,6 +3358,27 @@ async function main() {
             }
         }
         lastTaskText = finalTaskText;
+        // Provider handoff: if the operator switched providers, the new backend
+        // has NO chat history. Post the carried-over summary as a preface so the
+        // model continues instead of starting cold. Consumed once.
+        {
+            const handoff = readProviderHandoff(config.provider, currentWorkdir);
+            if (handoff) {
+                finalTaskText =
+                    buildHandoffText({
+                        from: handoff.provider === 'qwen' ? 'DeepSeek' : 'Qwen',
+                        to: providerLabel(config.provider),
+                        summary: handoff.summary,
+                        task: handoff.task,
+                    }) +
+                        String.fromCharCode(10, 10) +
+                        'Now continue with this task:' +
+                        String.fromCharCode(10) +
+                        finalTaskText;
+                clearProviderHandoff();
+                console.log(theme.system(t('provider.handoff_used')));
+            }
+        }
         // Dev mode: pick up fresh logic modules before the task.
         await autoReload();
         // Re-scan skills/custom commands before every task: a SKILL.md or a
@@ -3185,7 +3452,7 @@ async function main() {
                                 undo,
                                 todos: todoStore,
                             }),
-                            answerTimeoutMs: config.browser.answerTimeoutMs,
+                            answerTimeoutMs: providerAnswerTimeoutMs(),
                             quiet: true,
                             skipUiLock: true,
                             selfImprovement: devMode,

package/dist/input.js

@@ -171,6 +171,10 @@ export class LineEditor {
     // plain field because the CALLER runs the command on its own timer (a
     // per-render spawn would block typing).
     statusLine;
+    // Active chat provider label (e.g. "Qwen", "DeepSeek") shown as a small
+    // badge in the status line, so the operator always knows which backend is
+    // answering. Empty hides it. Set via setProvider().
+    providerBadge;
     // Whether the DeepSeek "Deep thinking" / "Smart search" toggles are ON.
     // Shown as two colored icons before the context counter: a dim gray icon
     // means off, a teal-green icon means on.
@@ -265,6 +269,7 @@ export class LineEditor {
         this.onContextQuery = null;
         this.queueLength = 0;
         this.statusLine = '';
+        this.providerBadge = '';
         this.onQueueQuery = null;
         this.onTasksQuery = null;
     }
@@ -353,6 +358,14 @@ export class LineEditor {
     _statusLineBadge() {
         return this.statusLine ? theme.system(this.statusLine) + ' ' : '';
     }
+    // A small badge with the ACTIVE provider (e.g. "Qwen"), shown before the
+    // toggles so the operator always knows which backend is answering (a
+    // multi-provider session can otherwise be ambiguous). Empty hides it.
+    _providerBadge() {
+        return this.providerBadge
+            ? theme.system('[' + this.providerBadge + ']') + ' '
+            : '';
+    }
     // Icons for the DeepSeek toggles: 🧠 "Deep thinking" and 🌐 "Smart search",
     // shown before the context counter. Only the ENABLED toggles are shown, so
     // the state is unambiguous WITHOUT relying on the terminal coloring the
@@ -593,6 +606,15 @@ export class LineEditor {
         this.statusLine = t;
         this._render();
     }
+    // Set the provider badge (e.g. "Qwen"). An empty string hides it. Repaints
+    // only when the value actually changes.
+    setProvider(text) {
+        const t = String(text || '').trim();
+        if (t === this.providerBadge)
+            return;
+        this.providerBadge = t;
+        this._render();
+    }
     setContextLimit(limit) {
         if (typeof limit === 'number' && Number.isFinite(limit) && limit > 0) {
             this.contextLimit = limit;
@@ -692,6 +714,7 @@ export class LineEditor {
         const ctxRaw = this._contextText();
         this._refreshToggles();
         const ctxText = this._statusLineBadge() +
+            this._providerBadge() +
             this._queueBadge() +
             this._tasksBadge() +
             this._toggleIcons() +

package/dist/provider-handoff.js

@@ -0,0 +1,73 @@
+// Provider-switch HANDOFF: when the operator changes `/provider` in the middle
+// of a session, the current chat does NOT exist on the new backend (a chat id
+// is meaningful only to the provider that created it), so the conversation
+// would be lost. Instead we summarize the current chat on the OLD provider and
+// persist a HANDOFF for the target provider; on the next launch the new
+// provider opens a fresh chat and posts the summary as its first message.
+//
+// This mirrors /compact's carryover, but the summary crosses a provider
+// boundary and survives a restart, so it is written to disk.
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { writeJsonAtomic } from './fsutil.js';
+const ZAMES_HOME = path.join(os.homedir(), '.zames');
+const HANDOFF_FILE = path.join(ZAMES_HOME, 'provider-handoff.json');
+const NL = String.fromCharCode(10);
+/**
+ * Wrap a cross-provider summary into the first message of the new provider's
+ * chat. PURE (unit-tested): the wording must make clear this is carried-over
+ * context from ANOTHER assistant, so the model treats it as history, not as a
+ * fresh instruction to redo the work.
+ */
+export function buildHandoffText(h) {
+    const body = String(h.summary ?? '').trim();
+    const goal = String(h.task ?? '').trim();
+    let out = `Context carried over from a previous session with another assistant ` +
+        `(${h.from} -> ${h.to}). Treat it as the history of the work so far and ` +
+        `continue from the current state. Do NOT redo what is already done.`;
+    out += NL + NL + body;
+    if (goal)
+        out += NL + NL + 'Original task: ' + goal;
+    return out;
+}
+/** Persist a handoff for a provider. Best-effort (never throws to the caller). */
+export function saveProviderHandoff(h) {
+    try {
+        fs.mkdirSync(ZAMES_HOME, { recursive: true });
+        writeJsonAtomic(HANDOFF_FILE, h);
+    }
+    catch { }
+}
+/**
+ * Read the pending handoff, but ONLY when it targets `provider` and `workdir`:
+ * a handoff for a different provider or project must not be posted into the
+ * wrong chat. Returns null when there is none / it does not match.
+ */
+export function readProviderHandoff(provider, workdir) {
+    try {
+        const raw = JSON.parse(fs.readFileSync(HANDOFF_FILE, 'utf-8'));
+        if (!raw || typeof raw.summary !== 'string' || !raw.summary.trim()) {
+            return null;
+        }
+        if (raw.provider !== provider)
+            return null;
+        if ((raw.workdir || '') !== (workdir || ''))
+            return null;
+        return raw;
+    }
+    catch {
+        return null;
+    }
+}
+/** Remove the handoff once it has been posted (or is stale). Best-effort. */
+export function clearProviderHandoff() {
+    try {
+        fs.unlinkSync(HANDOFF_FILE);
+    }
+    catch { }
+}
+/** For tests: the file the handoff lives in. */
+export function providerHandoffFile() {
+    return HANDOFF_FILE;
+}

package/dist/providers.js

@@ -0,0 +1,50 @@
+// Provider registry — the SINGLE source of truth for the chat backends zames
+// can drive. Adding a new backend (ChatGPT, Gemini, …) means:
+//   1. add an entry here (id, label, chat URL prefix, extra config section);
+//   2. add the provider's `<name>-ui.ts` + `<name>-net-capture.ts` +
+//      `<name>-browser.ts` (implementing ChatProvider, see types.ts);
+//   3. register the class in `createProviderBrowser()` in index.ts.
+// Everything else (config enum, /provider validation, sessions tagging, the
+// /doctor row, the {provider} label in operator messages, /chat URL) reads
+// from HERE, so nothing else has to be touched.
+//
+// This module is PURE (no imports, no side effects) so it can be imported from
+// anywhere without pulling in Playwright.
+export const PROVIDERS = {
+    deepseek: {
+        id: 'deepseek',
+        label: 'DeepSeek',
+        chatUrlPrefix: 'https://chat.deepseek.com/a/chat/s',
+        isDefault: true,
+    },
+    qwen: {
+        id: 'qwen',
+        label: 'Qwen',
+        chatUrlPrefix: 'https://chat.qwen.ai/c',
+        isDefault: false,
+    },
+};
+/** All provider ids, in a stable order (default first). */
+export const PROVIDER_IDS = Object.keys(PROVIDERS).sort((a, b) => PROVIDERS[a].isDefault === PROVIDERS[b].isDefault
+    ? a.localeCompare(b)
+    : PROVIDERS[a].isDefault
+        ? -1
+        : 1);
+/** True when `v` is a known provider id. Narrows the type for callers. */
+export function isProviderId(v) {
+    return (typeof v === 'string' && Object.prototype.hasOwnProperty.call(PROVIDERS, v));
+}
+/** Resolve an unknown value to a provider id, falling back to the default. */
+export function asProviderId(v) {
+    if (isProviderId(v))
+        return v;
+    return PROVIDER_IDS.find((id) => PROVIDERS[id].isDefault) || PROVIDER_IDS[0];
+}
+/** The human label of a provider ('Qwen', 'DeepSeek'). */
+export function providerLabel(id) {
+    return isProviderId(id) ? PROVIDERS[id].label : String(id);
+}
+/** The base chat URL of a provider, used by /chat. */
+export function providerChatUrlPrefix(id) {
+    return isProviderId(id) ? PROVIDERS[id].chatUrlPrefix : '';
+}