@toddzheng024/dscode-bundle 0.7.12 → 0.7.13

package/vendor/tui/lib/mentions.mjs

@@ -0,0 +1,150 @@
+/**
+ * Workspace @mention support: file and directory candidates from the
+ * `fileReferences` service (dsh-file-reference-local), session candidates
+ * from the opt-in `sessionReferenceResolver` service, and submission
+ * preparation through its `prepare()` API. Picked session mentions land as
+ * canonical `@[label](dsh-session:…)` tokens; on submit the text is parsed
+ * back into readable `@label` text plus structured references, snapshots are
+ * injected via `agent.inject()` before the readable message wakes the driver
+ * (`followup`, which queues the next turn whether or not one is running) —
+ * exactly the upstream README's wiring. Steering the current turn is a
+ * deliberate user action through the `/queue` panel, never an implicit
+ * consequence of submitting while busy.
+ *
+ * File discovery lives entirely in the Harness service (per-agent bounded
+ * index, `@dir/` listing, symlink guards, tool/result invalidation); this
+ * module only maps candidates to menu rows and never re-implements scanning.
+ * The service is agent-scoped (the agent supplies the session cwd and the
+ * cache key), so before the first session creates an agent the SAME official
+ * search class runs against the launch cwd — @ file completion works on a
+ * bare launch, model- and session-independent, and the agent-scoped service
+ * takes over once a session exists.
+ *
+ * @module @deepseek-ai/dsh-code/mentions
+ */
+import { isAbsolute, resolve } from 'node:path';
+import { DEFAULT_FILE_SEARCH_EXCLUDED_DIRECTORIES, DEFAULT_FILE_SEARCH_MAX_ENTRIES, DEFAULT_FILE_SEARCH_MAX_RESULTS, WorkspaceFileSearch, } from '@deepseek-ai/dsh-file-reference-local';
+import { formatSessionReferenceMention, parseSessionReferenceText, } from '@deepseek-ai/dsh-session-reference';
+/** Menu cap on file rows; the service owns ranking and default rows. */
+const MAX_FILE_ROWS = 20;
+/** Whether a mention token is already navigating a filesystem path. */
+export function isPathLikeMentionQuery(query) {
+    return /[\\/]/u.test(query);
+}
+/**
+ * Create the mention API for one agent's workspace. A missing
+ * `fileReferences` service (with an agent present) or `sessionReferenceResolver`
+ * degrades that half to empty rows; `prepare` passes text through untouched
+ * without references. An undefined agent (a bare launch before any session
+ * exists) runs the official WorkspaceFileSearch over the launch cwd — the
+ * same class the mounted service uses per agent — so `@` file completion
+ * works from the first keystroke; session references wait for the session.
+ *
+ * `candidates` never reaches for `this` — the runner hands it to the input
+ * editor as a detached callback, and a `this`-bound method would throw on
+ * every `@` key.
+ * @param ctx - context carrying the optional `fileReferences` and
+ * `sessionReferenceResolver` services.
+ * @param agent - the session owner; excluded from its own session candidates.
+ * @param cwd - launch working directory; bounds the pre-session search.
+ */
+export function createMentions(ctx, agent, cwd) {
+    const resolver = ctx.get('sessionReferenceResolver');
+    const fileReferences = ctx.get('fileReferences');
+    const sessionCapable = agent !== undefined && resolver !== undefined;
+    // Pre-session fallback: one lazily built search over the launch cwd with
+    // the official defaults — pure in-memory index, no handles to release.
+    // The mounted service invalidates its per-agent index after every tool
+    // result; nothing drives that for this bare instance, so a time window
+    // refreshes it instead — without it, files created or deleted before the
+    // first session never appear in (or never leave) the fuzzy @ menu.
+    const PRE_SESSION_INDEX_TTL_MS = 30_000;
+    let preSessionSearch;
+    let preSessionIndexedAt = 0;
+    const preSessionFiles = (query, signal) => {
+        if (preSessionSearch === undefined || Date.now() - preSessionIndexedAt > PRE_SESSION_INDEX_TTL_MS) {
+            preSessionSearch?.invalidate();
+            preSessionSearch = new WorkspaceFileSearch(cwd, {
+                maxResults: DEFAULT_FILE_SEARCH_MAX_RESULTS,
+                maxEntries: DEFAULT_FILE_SEARCH_MAX_ENTRIES,
+                excludedDirectories: [...DEFAULT_FILE_SEARCH_EXCLUDED_DIRECTORIES],
+            });
+            preSessionIndexedAt = Date.now();
+        }
+        return preSessionSearch.list(query, signal ?? new AbortController().signal);
+    };
+    return {
+        async candidates(query, signal) {
+            const needle = query.trim();
+            // A failed discovery half is remembered, never masked: when NOTHING came
+            // back the rejection tells the menu "search unavailable" instead of a
+            // silent empty list that reads as "no matches". A half that still
+            // returned rows shows them — partial results beat an error wall.
+            let fileFailure;
+            let sessionFailure;
+            const [files, sessions] = await Promise.all([
+                agent !== undefined && fileReferences !== undefined
+                    ? fileReferences
+                        .list(agent, needle, signal ?? new AbortController().signal)
+                        .catch((error) => {
+                        fileFailure = error;
+                        return [];
+                    })
+                    : agent === undefined
+                        ? preSessionFiles(needle, signal).catch((error) => {
+                            fileFailure = error;
+                            return [];
+                        })
+                        : Promise.resolve([]),
+                sessionCapable && needle !== '' && !isPathLikeMentionQuery(needle) && agent !== undefined
+                    ? resolver.listCandidates(agent, needle, 10, signal).catch((error) => {
+                        sessionFailure = error;
+                        return [];
+                    })
+                    : Promise.resolve([]),
+            ]);
+            // The service owns ranking (and the bare-@ default rows); the menu caps
+            // file rows and always places sessions after files — `@` is a file
+            // mention first (Codex's semantics), session references second.
+            const fileRows = files.slice(0, MAX_FILE_ROWS).map(candidate => ({
+                label: candidate.path,
+                description: candidate.kind === 'directory' ? 'Folder' : 'File',
+                kind: candidate.kind,
+                ...candidate.kind === 'file'
+                    ? { path: isAbsolute(candidate.path) ? candidate.path : resolve(cwd, candidate.path) }
+                    : {},
+            }));
+            const sessionRows = sessions.map(candidate => ({
+                label: formatSessionReferenceMention(candidate),
+                description: `Session · ${candidate.cwd ?? '(no cwd)'}`,
+                kind: 'session',
+            }));
+            const rows = [...fileRows, ...sessionRows];
+            if (rows.length === 0 && (fileFailure !== undefined || sessionFailure !== undefined)) {
+                throw fileFailure instanceof Error
+                    ? fileFailure
+                    : sessionFailure instanceof Error
+                        ? sessionFailure
+                        : new Error(String(fileFailure ?? sessionFailure));
+            }
+            return rows;
+        },
+        parse(text) {
+            return parseSessionReferenceText(text);
+        },
+        async prepare(parsed, signal) {
+            if (parsed.references.length === 0 || resolver === undefined || agent === undefined) {
+                return { text: parsed.text, references: parsed.references };
+            }
+            const prepared = await resolver.prepare(agent, [{ type: 'text', text: parsed.text }], parsed.references, signal);
+            return {
+                text: prepared.content.filter(block => block.type === 'text').map(block => block.text).join(''),
+                references: parsed.references,
+                additionalContext: prepared.additionalContext,
+            };
+        },
+        sessionMention(candidate) {
+            return formatSessionReferenceMention({ sessionId: candidate.sessionId, label: candidate.label });
+        },
+    };
+}

package/vendor/tui/lib/model-capabilities.mjs

@@ -0,0 +1,245 @@
+/**
+ * Same-id reasoning-capability inheritance for hand-declared pi-ai routes:
+ * the model catalog inherits capabilities by route key, not by model id, so a
+ * relay route listing `gpt-5.5` reads nothing from the installed `openai`
+ * catalog entry and materializes as `reasoning: false` until its settings
+ * entry declares `reasoningEfforts`. This adapter closes that gap without
+ * touching upstream: whenever a pi-ai profile's model entry carries no
+ * declaration and its live row advertises no efforts, but the same model id
+ * is declared (in a sibling settings entry) or advertised (on another route)
+ * elsewhere, the declaration is materialized into settings — verbatim from a
+ * sibling declaration when one exists, otherwise as an identity level map
+ * (`off` maps to null, every other level to its own name), which is the
+ * correct wire spelling for OpenAI-compatible relays. Writes ride the same
+ * `settings.mutate` path as the provider panel, so the upstream
+ * `assertServiceable` gate still rejects anything invalid atomically.
+ *
+ * @module @deepseek-ai/dsh-tui/model-capabilities
+ */
+import { loadModelDirectory } from './models.mjs';
+/** The settings namespace the llm-pi-ai plugin owns (identity via `settingsNamespace`). */
+const PI_AI_SETTINGS_NS = 'llm-pi-ai';
+/** The effort level that means "send no reasoning parameter"; its wire value is always null. */
+const OFF_LEVEL = 'off';
+/** Single-line a misbehaving error for the notice channel. */
+function singleLine(message) {
+    const spaced = [...message].map(ch => { const code = ch.charCodeAt(0); return code < 32 || code === 127 ? ' ' : ch; }).join('');
+    return spaced.split(' ').filter(part => part !== '').join(' ');
+}
+/** Human text for a rejection value. */
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/** Read the value at a path through plain objects; undefined when any segment misses. */
+function getPath(value, path) {
+    let current = value;
+    for (const segment of path) {
+        if (typeof current !== 'object' || current === null)
+            return undefined;
+        current = current[segment];
+    }
+    return current;
+}
+/** Whether a raw settings value is a usable `reasoningEfforts` dict (non-empty, non-false). */
+function isDeclaredEfforts(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value) && Object.keys(value).length > 0;
+}
+/**
+ * The identity level map for an advertised effort list: `off` sends no
+ * parameter, every other level keeps its own name — the wire spelling
+ * OpenAI-compatible relays accept as-is.
+ */
+function identityEfforts(levels) {
+    const dict = {};
+    for (const level of levels)
+        dict[level] = level === OFF_LEVEL ? null : level;
+    return dict;
+}
+/**
+ * Plan the reasoning declarations to materialize. A model entry inherits
+ * when it declares nothing (`reasoningEfforts` absent — a dict or `false` is
+ * an explicit choice and is never touched) and its live row advertises no
+ * efforts; the donor is the first sibling settings declaration for the same
+ * id, copied verbatim so dialect wire spellings survive, otherwise the first
+ * other-route row advertising efforts for that id, mapped by identity.
+ * Entries never lose fields and keep their key order; a provider appears in
+ * the result only when at least one entry changes.
+ * @param input - the live model rows and the raw pi-ai profiles from settings.
+ * @returns one plan per provider with at least one inheritance.
+ */
+export function planCapabilitySync(input) {
+    // Sibling declarations, first profile order wins: { id -> { dict, provider } }.
+    const declared = new Map();
+    for (const [provider, profile] of input.profiles) {
+        for (const entry of profile.models) {
+            const efforts = entry.reasoningEfforts;
+            if (!isDeclaredEfforts(efforts))
+                continue;
+            if (!declared.has(String(entry.id)))
+                declared.set(String(entry.id), { dict: efforts, provider });
+        }
+    }
+    // Advertised donors, first row order wins: { id -> { levels, provider } }.
+    // A row whose only level is `off` advertises nothing usable and is skipped.
+    const advertised = new Map();
+    for (const row of input.rows) {
+        const levels = row.reasoning?.efforts.map(effort => effort.id) ?? [];
+        if (levels.filter(level => level !== OFF_LEVEL).length === 0)
+            continue;
+        if (!advertised.has(row.model))
+            advertised.set(row.model, { levels, provider: row.provider });
+    }
+    const plans = [];
+    for (const [provider, profile] of input.profiles) {
+        const inherited = [];
+        const sources = [];
+        const models = profile.models.map((entry) => {
+            if (entry.reasoningEfforts !== undefined)
+                return entry;
+            const id = String(entry.id);
+            const sibling = declared.get(id);
+            if (sibling !== undefined && sibling.provider !== provider) {
+                inherited.push(id);
+                if (!sources.includes(`${sibling.provider}/${id}`))
+                    sources.push(`${sibling.provider}/${id}`);
+                return { ...entry, reasoningEfforts: sibling.dict };
+            }
+            const donor = advertised.get(id);
+            if (donor !== undefined && donor.provider !== provider) {
+                inherited.push(id);
+                if (!sources.includes(`${donor.provider}/${id}`))
+                    sources.push(`${donor.provider}/${id}`);
+                return { ...entry, reasoningEfforts: identityEfforts(donor.levels) };
+            }
+            return entry;
+        });
+        if (inherited.length > 0) {
+            plans.push({
+                provider,
+                settingsNs: profile.settingsNs,
+                settingsPath: profile.settingsPath,
+                models,
+                sourceFingerprint: JSON.stringify(profile.models),
+                sourceRevision: profile.revision,
+                inherited,
+                sources,
+            });
+        }
+    }
+    return plans;
+}
+/* ------------------------------------------------------------------ *
+ * Application.
+ * ------------------------------------------------------------------ */
+/** Provider -> the source snapshot and document revision its last write landed against. */
+const lastApplied = new Map();
+/** Fresh revision of one namespace, or undefined when it does not resolve. */
+function revisionOf(settings, ns) {
+    try {
+        for (const descriptor of settings.describe({ redactSecrets: true })) {
+            if (descriptor.ns === ns)
+                return descriptor.revision;
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+/**
+ * Materialize same-id reasoning declarations once per provider. Reads the
+ * configurable directory, the redacted settings document, and the live model
+ * rows; plans; then writes each provider's merged models array through
+ * `settings.mutate` under a fresh revision (writes bump the section
+ * revision, so per-plan revisions are re-read). Every failure converges to a
+ * single-line notice — the caller's promise never rejects and the session
+ * keeps running on the previous configuration.
+ * @param ctx - context carrying the `llm` and `settings` services (optional).
+ * @param notify - the app bridge's notice sink, when one is live.
+ */
+export async function syncModelCapabilities(ctx, notify) {
+    try {
+        const llm = ctx.get('llm');
+        if (llm?.listConfigurableProviders === undefined)
+            return;
+        const settings = ctx.get('settings');
+        if (settings === undefined)
+            return;
+        let entries;
+        try {
+            entries = llm.listConfigurableProviders();
+        }
+        catch {
+            return;
+        }
+        const routed = entries.filter(entry => entry.settingsNs === PI_AI_SETTINGS_NS);
+        if (routed.length === 0)
+            return;
+        let descriptors;
+        try {
+            descriptors = settings.describe({ redactSecrets: true });
+        }
+        catch {
+            return;
+        }
+        const namespaces = new Map(descriptors.map(descriptor => [descriptor.ns, descriptor]));
+        const profiles = new Map();
+        for (const entry of routed) {
+            const namespace = namespaces.get(entry.settingsNs);
+            if (namespace === undefined)
+                continue;
+            const profile = entry.settingsPath.length === 0
+                ? namespace.value
+                : getPath(namespace.value, entry.settingsPath);
+            const models = Array.isArray(profile?.models)
+                ? profile.models
+                : undefined;
+            // An absent models list is a dormant or unconfigured route: nothing to
+            // inherit into (and the empty allow-list there is deliberate upstream).
+            if (models === undefined)
+                continue;
+            profiles.set(entry.provider, {
+                settingsNs: entry.settingsNs,
+                settingsPath: entry.settingsPath,
+                revision: namespace.revision,
+                models,
+            });
+        }
+        if (profiles.size === 0)
+            return;
+        const directory = await loadModelDirectory(ctx);
+        for (const plan of planCapabilitySync({ rows: directory.rows, profiles })) {
+            // Skip only a provable echo of our own write: the same source
+            // snapshot at the same document revision we already wrote against
+            // (our write re-triggers the document event before the re-read
+            // catches up). An external edit that removes a materialized
+            // declaration bumps the revision, so identical source content
+            // re-plans and re-writes instead of being skipped forever.
+            const applied = lastApplied.get(plan.provider);
+            if (applied !== undefined && applied.fingerprint === plan.sourceFingerprint && applied.revision === plan.sourceRevision)
+                continue;
+            // Writes bump the section revision; re-read per plan so the second
+            // provider's optimistic revision is not already stale.
+            const revision = revisionOf(settings, plan.settingsNs);
+            if (revision === undefined)
+                continue;
+            try {
+                await settings.mutate(plan.settingsNs, [{ op: 'set', path: [...plan.settingsPath, 'models'], value: plan.models }], revision);
+                lastApplied.set(plan.provider, { fingerprint: plan.sourceFingerprint, revision: plan.sourceRevision });
+                const shown = plan.sources.slice(0, 3).join(', ');
+                const more = plan.sources.length > 3 ? `, +${plan.sources.length - 3}` : '';
+                notify?.(`inherited reasoning levels for ${plan.inherited.length} model${plan.inherited.length === 1 ? '' : 's'} on ${plan.provider} (from ${shown}${more})`, 'info');
+            }
+            catch (error) {
+                notify?.(`capability inheritance failed on ${plan.provider}: ${singleLine(messageOf(error))}`, 'warning');
+            }
+        }
+    }
+    catch {
+        // A background sync must never surface as an unhandled rejection.
+    }
+}
+/** Test seam: forget the applied-write fingerprints. */
+export function resetCapabilitySyncState() {
+    lastApplied.clear();
+}

package/vendor/tui/lib/models.mjs

@@ -0,0 +1,215 @@
+/**
+ * Model directory for the `/model` panel: the in-process equivalent of the
+ * web host's model catalog (`buildModelCatalog`), reading the advisory
+ * `ctx.llm` registry directly. Catalog membership is advisory — a route
+ * serving a model it stopped advertising stays usable — so selection never
+ * fails on catalog absence alone.
+ *
+ * @module @deepseek-ai/dsh-tui/models
+ */
+import { ReasoningEffortId, } from '@deepseek-ai/dsh-llm';
+/** Map an adapter's reasoning capability onto the panel's plain-id shape. */
+export function mapReasoning(reasoning) {
+    return {
+        efforts: reasoning.efforts.map(effort => ({
+            id: effort.id,
+            name: effort.name,
+            ...effort.description === undefined ? {} : { description: effort.description },
+        })),
+        ...reasoning.defaultEffort === undefined ? {} : { defaultEffort: reasoning.defaultEffort },
+    };
+}
+/**
+ * Resolve the effective model selection for one live session, in the
+ * documented precedence: the in-process explicit pick, then the session's
+ * last `request/header` config, then the deployment default.
+ * @param picked - the explicit selection made in this process, when any.
+ * @param logged - the last logged request header config, when any.
+ * @param defaults - the deployment default selection.
+ * @returns the effective selection, carrying a reasoning effort when one is in force.
+ */
+export function resolveEffectiveSelection(picked, logged, defaults) {
+    if (picked !== undefined)
+        return picked;
+    if (logged !== undefined) {
+        return {
+            provider: logged.provider,
+            model: logged.model,
+            ...logged.reasoningEffort === undefined
+                ? {}
+                : { reasoningEffort: ReasoningEffortId(logged.reasoningEffort) },
+        };
+    }
+    return defaults;
+}
+/** Structural equality of two selections (upstream `sameSelection`). */
+function sameModelSelection(left, right) {
+    return left.provider === right.provider
+        && left.model === right.model
+        && left.reasoningEffort === right.reasoningEffort;
+}
+/**
+ * The session log's unconsumed explicit model selection (the resume layer of
+ * the documented precedence). `model/selection` events are log-only facts the
+ * web host's session-controller appends when its user picks a model for the
+ * NEXT request; a request header assembling exactly that selection retires
+ * it, while a header for different values (another route forced the request)
+ * leaves it armed. Seeding the resumed pick from here restores a selection
+ * that was made but never sent — the request header alone would answer with
+ * the older model.
+ * @param events - the full persisted event list of the resumed session.
+ * @returns the still-pending selection, when one exists.
+ */
+export function pendingModelSelection(events) {
+    let pending;
+    for (const event of events) {
+        // The event map merge lives in @deepseek-ai/dsh-api-session-controller,
+        // which this bundle does not depend on; the string guard keeps the fold
+        // decoupled while matching the typed upstream projection exactly.
+        if (event.type === 'model/selection') {
+            const data = event.data;
+            if (typeof data.provider === 'string' && typeof data.model === 'string') {
+                const selection = {
+                    provider: data.provider,
+                    model: data.model,
+                    ...data.reasoningEffort === undefined ? {} : { reasoningEffort: data.reasoningEffort },
+                };
+                if (pending === undefined || !sameModelSelection(pending, selection))
+                    pending = selection;
+            }
+            continue;
+        }
+        if (event.type === 'request/header') {
+            const config = event.data.header.config;
+            if (pending !== undefined && sameModelSelection(pending, {
+                provider: config.provider,
+                model: config.model,
+                ...config.reasoningEffort === undefined ? {} : { reasoningEffort: config.reasoningEffort },
+            })) {
+                pending = undefined;
+            }
+        }
+    }
+    return pending;
+}
+/**
+ * Build the selection one `/model` pick applies, rejecting an effort the
+ * row does not advertise. The row is the picker's source of truth, so a
+ * stale directory cannot smuggle an unsupported effort into the next step
+ * (the request pipeline would reject it before network I/O regardless). The
+ * empty string is the picker's "provider default" sentinel — an explicit
+ * choice to leave the effort to the model's own default, exactly like an
+ * absent effort.
+ * @param row - the picked model row.
+ * @param effortId - the chosen advertised effort, '' or undefined for the model default.
+ * @returns the selection the runner records for the next assembled step.
+ */
+export function buildModelSelection(row, effortId) {
+    const selected = effortId === undefined || effortId === '' ? undefined : effortId;
+    if (selected !== undefined
+        && (row.reasoning === undefined || !row.reasoning.efforts.some(effort => effort.id === selected))) {
+        throw new Error(`model ${row.provider}/${row.model} does not support reasoning effort "${selected}"`);
+    }
+    return {
+        provider: row.provider,
+        model: row.model,
+        ...selected === undefined ? {} : { reasoningEffort: ReasoningEffortId(selected) },
+    };
+}
+/** Display label for one applied selection: `provider/model` or `provider/model@effort`. */
+export function modelSelectionLabel(selection) {
+    return selection.reasoningEffort === undefined
+        ? `${selection.provider}/${selection.model}`
+        : `${selection.provider}/${selection.model}@${selection.reasoningEffort}`;
+}
+/**
+ * Apply one model selection onto a resolved request config — the exact
+ * semantics of the kernel's `installModelSelection` request listener,
+ * extracted so the TUI can mirror it for subagent-origin requests: children
+ * spawned by the subagent tool inherit the parent's CREATE-TIME AgentOptions,
+ * which a mid-session /model switch never touches, so delegated work would
+ * otherwise keep running on the launch-time route. An absent effort strips
+ * any inherited effort (restoring the selected model's provider default),
+ * matching the kernel listener field-for-field.
+ * @param resolved - the config the inner chain produced.
+ * @param selection - the selection to enforce.
+ * @returns the overridden config.
+ */
+export function applyModelSelectionToConfig(resolved, selection) {
+    const { reasoningEffort: _inheritedEffort, ...withoutInheritedEffort } = resolved;
+    return {
+        ...withoutInheritedEffort,
+        provider: selection.provider,
+        model: selection.model,
+        ...selection.reasoningEffort === undefined
+            ? {}
+            : { reasoningEffort: selection.reasoningEffort },
+    };
+}
+/**
+ * Load the selectable model directory from the live `ctx.llm` registry.
+ * Providers are listed synchronously; each provider's models are discovered
+ * with a bounded parallel fan-out whose failures degrade to that provider
+ * contributing no rows (mirrors the web catalog's per-provider failures).
+ * Each row's reasoning levels are resolved per exact model like the web
+ * catalog (`buildModelCatalog`); a single model's capability lookup failure
+ * degrades to that row having no effort picker rather than hiding the model,
+ * and the failure rides `reasoningFailures` so the caller can tell "no
+ * advertised reasoning" from "capability lookup failed".
+ * @param ctx - context carrying the `llm` service.
+ * @returns the resolved directory; empty rows when `llm` is unavailable.
+ */
+export async function loadModelDirectory(ctx) {
+    const llm = ctx.get('llm');
+    if (llm === undefined)
+        return { rows: [], failures: [], reasoningFailures: [] };
+    // Call resolveModelInfo AS A METHOD (llm.resolveModelInfo(...)): destructured
+    // off the service it loses `this` — this.registration() then throws on the
+    // first provider, the catch swallows it, and every row lands in
+    // reasoningFailures ("capability lookup failed") even though the adapter
+    // itself never fails.
+    const llmResolve = llm;
+    const providers = llm.listProviders();
+    const listed = await Promise.all(providers.map(async (provider) => {
+        try {
+            const models = await llm.listModels(provider.id);
+            const reasoningFailures = [];
+            const rows = await Promise.all(models.map(async (model) => {
+                const row = {
+                    provider: provider.id,
+                    providerName: provider.name,
+                    model: model.id,
+                    modelName: model.name,
+                    ...model.inputModalities === undefined ? {} : { inputModalities: [...model.inputModalities] },
+                };
+                if (llmResolve.resolveModelInfo === undefined)
+                    return row;
+                try {
+                    const resolved = await llmResolve.resolveModelInfo(provider.id, model.id);
+                    return {
+                        ...row,
+                        ...resolved.inputModalities === undefined ? {} : { inputModalities: [...resolved.inputModalities] },
+                        ...resolved.reasoning === undefined ? {} : { reasoning: mapReasoning(resolved.reasoning) },
+                    };
+                }
+                catch {
+                    reasoningFailures.push(`${provider.id}/${model.id}`);
+                    return row;
+                }
+            }));
+            return {
+                provider: provider.id,
+                providerName: provider.name,
+                models: rows,
+                reasoningFailures,
+            };
+        }
+        catch {
+            return { provider: provider.id, providerName: provider.name, models: [], failed: true };
+        }
+    }));
+    const rows = listed.flatMap(entry => entry.models);
+    const failures = listed.filter(entry => 'failed' in entry && entry.failed === true).map(entry => entry.provider);
+    const reasoningFailures = listed.flatMap(entry => 'failed' in entry ? [] : entry.reasoningFailures);
+    return { rows, failures, reasoningFailures };
+}

package/vendor/tui/{types/panel-accent.d.ts → lib/panel-accent.mjs}

@@ -10,12 +10,9 @@
  *
  * @module @deepseek-ai/dsh-tui/panel-accent
  */
-import { type RgbTriple } from './theme.ts';
-/** One panel's resolved accent pair (border and title share the ring color in prismatic). */
-export interface PanelAccent {
-    readonly border: RgbTriple;
-    readonly title: RgbTriple;
-}
+import { surfaceAccent } from './theme.mjs';
+/** First-seen slot per panel id; stable for the process lifetime. */
+const panelSlots = new Map();
 /**
  * The accent pair for one panel: in prismatic both entries are the panel's
  * ring color (border and title match, per the design); in every other theme
@@ -25,4 +22,11 @@ export interface PanelAccent {
  * @param title - the title color used outside prismatic (defaults to border).
  * @returns the resolved accent pair for this panel.
  */
-export declare function panelAccent(id: string, border: RgbTriple, title?: RgbTriple): PanelAccent;
+export function panelAccent(id, border, title = border) {
+    let slot = panelSlots.get(id);
+    if (slot === undefined) {
+        slot = panelSlots.size;
+        panelSlots.set(id, slot);
+    }
+    return { border: surfaceAccent(slot, border), title: surfaceAccent(slot, title) };
+}