@toddzheng024/dscode-bundle 0.7.12 → 0.7.14

package/vendor/tui/types/model-capabilities.d.ts

@@ -1,82 +0,0 @@
-/**
- * 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 type { Context } from '@deepseek-ai/cordis';
-import { type ModelRow } from './models.ts';
-/** A notice sink structurally compatible with the app bridge's `notify`. */
-export type CapabilityNotice = (text: string, tone?: 'info' | 'warning' | 'error') => void;
-/** One pi-ai provider profile as stored in settings, addressed for mutation. */
-export interface CapabilityProfileSource {
-    /** Settings namespace owning the profile (`llm-pi-ai`). */
-    readonly settingsNs: string;
-    /** Path from the section root to this provider's profile. */
-    readonly settingsPath: readonly string[];
-    /** Revision of the owning section at read time. */
-    readonly revision: number;
-    /** Raw model entries, exactly as stored (declaration fields included). */
-    readonly models: readonly Record<string, unknown>[];
-}
-/** One planned per-provider models rewrite. */
-export interface CapabilitySyncPlan {
-    /** Provider route the plan targets. */
-    readonly provider: string;
-    /** Settings namespace owning the profile. */
-    readonly settingsNs: string;
-    /** Path from the section root to the provider profile. */
-    readonly settingsPath: readonly string[];
-    /** Raw model entries, exactly as stored (declaration fields included). */
-    readonly models: readonly Record<string, unknown>[];
-    /** Fingerprint of the source models array this plan was derived from. */
-    readonly sourceFingerprint: string;
-    /** Document revision of the owning section when the plan was derived. */
-    readonly sourceRevision: number;
-    /** Model ids that gained a declaration, notice-facing. */
-    readonly inherited: readonly string[];
-    /** `provider/model` labels the declarations came from, notice-facing. */
-    readonly sources: readonly string[];
-}
-/**
- * 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 declare function planCapabilitySync(input: {
-    readonly rows: readonly ModelRow[];
-    readonly profiles: ReadonlyMap<string, CapabilityProfileSource>;
-}): readonly CapabilitySyncPlan[];
-/**
- * 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 declare function syncModelCapabilities(ctx: Context, notify?: CapabilityNotice): Promise<void>;
-/** Test seam: forget the applied-write fingerprints. */
-export declare function resetCapabilitySyncState(): void;

package/vendor/tui/types/models.d.ts

@@ -1,133 +0,0 @@
-/**
- * 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 type { Context } from '@deepseek-ai/cordis';
-import type { ModelSelection } from '@deepseek-ai/dsh-agent';
-import type { SessionEvent } from '@deepseek-ai/dsh-session';
-import { type LlmCallConfig, type LlmModelReasoningInfo, type ModelModality } from '@deepseek-ai/dsh-llm';
-/** Display metadata for one adapter-owned reasoning effort (mirrors `LlmReasoningEffortInfo`). */
-export interface ModelReasoningEffort {
-    /** Opaque value accepted by the model's `GenerateOptions.reasoningEffort`. */
-    id: string;
-    /** Human-readable effort name for selectors. */
-    name: string;
-    /** Optional user-facing distinction from otherwise similar efforts. */
-    description?: string;
-}
-/** Selectable reasoning efforts for one model (mirrors `LlmModelReasoningInfo`). */
-export interface ModelReasoning {
-    /** Supported efforts in adapter-preferred display order. */
-    efforts: readonly ModelReasoningEffort[];
-    /** Adapter-configured default materialized when callers omit an effort. */
-    defaultEffort?: string;
-}
-/** One selectable row in the `/model` panel. */
-export interface ModelRow {
-    /** Registered provider route. */
-    provider: string;
-    /** Display name of the provider route. */
-    providerName: string;
-    /** Provider-owned model id. */
-    model: string;
-    /** Human-readable model name. */
-    modelName: string;
-    /** Request modalities advertised for this exact route; absent means unknown. */
-    inputModalities?: readonly ModelModality[];
-    /** Adapter-owned selectable reasoning levels when the model exposes any. */
-    reasoning?: ModelReasoning;
-}
-/** The resolved directory: rows plus per-provider discovery failures. */
-export interface ModelDirectory {
-    /** Advisory rows, provider-major in registry order. */
-    rows: readonly ModelRow[];
-    /** Provider ids whose model listing failed; those providers contribute no rows. */
-    failures: readonly string[];
-    /**
-     * `provider/model` labels whose per-model capability lookup failed. Those
-     * rows still appear (advisory degrade, mirroring the web catalog), but
-     * without an effort picker — a picker caller must not misread the absence
-     * as "this model exposes no reasoning" (e.g. deepseek-v4-flash always
-     * advertises off/high/max unless thinking is disabled). Optional for
-     * callers that shape a directory by hand; {@link loadModelDirectory}
-     * always populates it (empty when nothing failed).
-     */
-    reasoningFailures?: readonly string[];
-}
-/** Map an adapter's reasoning capability onto the panel's plain-id shape. */
-export declare function mapReasoning(reasoning: LlmModelReasoningInfo): ModelReasoning;
-/**
- * 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 declare function resolveEffectiveSelection(picked: ModelSelection | undefined, logged: {
-    provider: string;
-    model: string;
-    reasoningEffort?: string;
-} | undefined, defaults: ModelSelection): ModelSelection;
-/**
- * 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 declare function pendingModelSelection(events: readonly SessionEvent[]): ModelSelection | undefined;
-/**
- * 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 declare function buildModelSelection(row: ModelRow, effortId?: string): ModelSelection;
-/** Display label for one applied selection: `provider/model` or `provider/model@effort`. */
-export declare function modelSelectionLabel(selection: ModelSelection): string;
-/**
- * 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 declare function applyModelSelectionToConfig(resolved: LlmCallConfig, selection: ModelSelection): LlmCallConfig;
-/**
- * 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 declare function loadModelDirectory(ctx: Context): Promise<ModelDirectory>;

package/vendor/tui/types/permissions.d.ts

@@ -1,27 +0,0 @@
-/** Permission-preset policy for pending and active TUI sessions. */
-import type { Context } from '@deepseek-ai/cordis';
-import type { PermissionPresetService } from '@deepseek-ai/dsh-permission-presets';
-import type { Session } from '@deepseek-ai/dsh-session';
-/** One selectable permission preset row for the /permission panel. */
-export interface PermissionRow {
-    readonly id: string;
-    readonly description?: string;
-}
-/** Public compatibility alias for the official upstream permission service. */
-export type PermissionPresetsService = PermissionPresetService;
-/** Read the optional Harness service without importing its runtime package. */
-export declare function permissionPresetsFrom(ctx: Context): PermissionPresetsService | undefined;
-/** Effective label for either an active session or the not-yet-created first one. */
-export declare function effectivePermission(service: PermissionPresetsService, session: Session | undefined, pending: string | undefined): string;
-/** Validate a preset and write it only when a durable session already exists. */
-export declare function selectPermission(service: PermissionPresetsService, session: Session | undefined, preset: string): string;
-/** Cycle table order from the active, pending, or configured-default value. */
-export declare function cyclePermission(service: PermissionPresetsService, session: Session | undefined, pending: string | undefined): string;
-/** Materialize a pre-session choice after Harness creates the first session. */
-export declare function applyPendingPermission(service: PermissionPresetsService, session: Session, pending: string | undefined): void;
-/**
- * List every switchable preset for the /permission panel, table order kept.
- * Description lookup failures degrade to an undocumented row, never a failed
- * panel load — `optionOf` rejects names its table no longer knows.
- */
-export declare function listPermissionRows(service: PermissionPresetsService): readonly PermissionRow[];

package/vendor/tui/types/plugin-inventory.d.ts

@@ -1,11 +0,0 @@
-/** Read-only projection of Cordis Loader entries for /plugin. */
-import type { Context } from '@deepseek-ai/cordis';
-export type PluginPhase = 'pending' | 'loading' | 'active' | 'failed' | 'unloading' | null;
-export interface PluginRow {
-    readonly entryId: string;
-    readonly moduleName: string;
-    readonly enabled: boolean;
-    readonly phase: PluginPhase;
-}
-/** Snapshot the live Loader; group-only rows are composition containers, not plugins. */
-export declare function listPluginRows(ctx: Context): PluginRow[];

package/vendor/tui/types/presets.d.ts

@@ -1,22 +0,0 @@
-/** Agent-preset policy kept independent from the Ink surface. */
-import type { Context } from '@deepseek-ai/cordis';
-import type { Agent } from '@deepseek-ai/dsh-agent';
-import type { AgentPreset, AgentPresets } from '@deepseek-ai/dsh-agent-presets';
-import type { Session, SessionEvent } from '@deepseek-ai/dsh-session';
-/** One discoverable agent composition. */
-export type PresetRow = AgentPreset;
-/** Public compatibility alias for the official upstream service type. */
-export type AgentPresetsService = AgentPresets;
-/** Read an optional Cordis service without requiring its package at build time. */
-export declare function agentPresetsFrom(ctx: Context): AgentPresetsService | undefined;
-/** A preset may change only before the first durable turn begins. */
-export declare function isBlankSession(events: readonly SessionEvent[]): boolean;
-/** Translate a preset id recorded before an upstream rename to its current id. */
-export declare function normalizePresetId(id: string): string;
-export declare function normalizePresetId(id: string | undefined): string | undefined;
-/** Latest logged selection wins; legacy sessions deliberately fall back to standard. */
-export declare function resolvePreset(session: Pick<Session, 'header' | 'snapshotEvents'>): string;
-/** Resolve a pre-session choice, or recompose an active blank Agent. */
-export declare function selectPreset(service: AgentPresetsService, agent: Agent | undefined, presetId: string): Promise<PresetRow>;
-/** Recompose atomically from the caller's perspective, logging only success. */
-export declare function switchPreset(service: AgentPresetsService, agent: Agent, presetId: string): Promise<PresetRow>;

package/vendor/tui/types/provider-settings.d.ts

@@ -1,239 +0,0 @@
-/**
- * Provider settings adapter for the TUI `/model` provider-management panel:
- * the same-process equivalent of the web host's Models page join
- * (`packages/client/ui-settings-models`), reading the advisory `ctx.llm`
- * registry, the redacted `ctx.settings` descriptors, and the value-free
- * `ctx.credentials` facts directly. Secrets never cross this module: settings
- * are read with `redactSecrets: true`, credentials are only ever described
- * (never resolved), and every message is single-line without embedding key
- * data.
- *
- * @module @deepseek-ai/dsh-tui/provider-settings
- */
-import type { Context } from '@deepseek-ai/cordis';
-/**
- * The conventional credential reference for a provider route: `<ROUTE>_API_KEY`
- * with the route uppercased and every non-alphanumeric run collapsed to one
- * underscore — the exact derivation the official Models page uses
- * (`deriveKeyRef` in `ui-settings-models`), so a key saved here is found there.
- * @param provider - provider route id (e.g. `pi-ai`, `minimax-cn`).
- * @returns the derived reference name (e.g. `PI_AI_API_KEY`).
- */
-export declare function deriveCredentialRef(provider: string): string;
-/** Value-free facts about one credential reference — never the value. */
-export interface ProviderCredentialFacts {
-    /** Whether the reference currently resolves to a stored value. */
-    readonly configured: boolean;
-    /** Source layer supplying the value; absent while unconfigured. */
-    readonly source?: string;
-    /** Whether a write through this panel would currently succeed. */
-    readonly writable: boolean;
-}
-/**
- * One row's credential state: value-free facts once the reference was
- * described, a bounded error when that describe failed (the row itself is
- * never dropped), or `undefined` when the row names no reference to describe —
- * an unmanaged active provider, a dormant route, or a profile authenticating
- * through the provider's own path.
- */
-export type ProviderCredentialView = ({
-    readonly kind: 'facts';
-} & ProviderCredentialFacts) | {
-    readonly kind: 'error';
-    readonly message: string;
-};
-/** One explicit model enabled for a provider profile. */
-export interface ProviderModelSettings {
-    readonly id: string;
-    readonly name?: string;
-    readonly contextWindow?: number;
-    readonly maxTokens?: number;
-    /**
-     * Remaining entry fields the editor does not model (`reasoningEfforts`,
-     * `compat`, `input`, …), carried verbatim so a save preserves them.
-     * Populated by {@link loadProviderSettings}; never contains the four
-     * modelled keys.
-     */
-    readonly extras?: Readonly<Record<string, unknown>>;
-}
-/** The small, portable subset of a provider profile the terminal edits. */
-export interface ProviderConfiguration {
-    readonly baseURL?: string;
-    /**
-     * Wire protocol the stored profile names (e.g. `openai-responses`), when it
-     * names one. Load-only: the editor never writes it, but endpoint discovery
-     * passes it so the listing speaks the same protocol as real requests.
-     */
-    readonly api?: string;
-    readonly models: readonly ProviderModelSettings[];
-}
-/** One model an endpoint reported about itself (mirrors `LlmDiscoveredModel`). */
-export interface DiscoveredModelView {
-    /** Model id the endpoint accepts. */
-    readonly id: string;
-    /** Human-readable name when the endpoint supplies one. */
-    readonly name?: string;
-    /** Context window when disclosed; adoption still owes it if absent. */
-    readonly contextWindow?: number;
-    /** Output cap when disclosed. */
-    readonly maxTokens?: number;
-}
-/**
- * The seven canonical reasoning levels a reasoningEfforts key may name -
- * pi-ai's THINKING_LEVELS. A pi-ai upgrade that adds or removes one fails
- * upstream's own drift gate; this mirror exists so the terminal editor can
- * validate drafts without importing the pi-ai package.
- */
-export declare const REASONING_EFFORT_LEVELS: readonly ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
-/**
- * One stored reasoningEfforts declaration: a display-level to wire-value map
- * (null sends no reasoning parameter), an explicit false disabling the
- * picker, or undefined leaving the entry to inherit.
- */
-export type ReasoningEffortsValue = Record<string, string | null> | false | undefined;
-/** Whether a raw extras value is a declared efforts dict (non-empty, non-false). */
-export declare function isDeclaredReasoningEfforts(value: unknown): value is Record<string, string | null>;
-/**
- * Parse the setup page's compact efforts draft into a storable declaration.
- * Grammar: empty = clear back to inherit; the single token "false" = disable
- * the picker; otherwise space-separated level:wire pairs where level is one
- * of REASONING_EFFORT_LEVELS and wire is any non-empty string or the literal
- * "null" (send no parameter).
- */
-export declare function parseReasoningEffortsDraft(draft: string): {
-    readonly ok: true;
-    readonly value: ReasoningEffortsValue;
-} | {
-    readonly ok: false;
-    readonly error: string;
-};
-/** Serialize a stored declaration back to the compact draft form (stored key order preserved). */
-export declare function serializeReasoningEfforts(value: unknown): string;
-/**
- * One provider row in the TUI provider-management panel: the configurable
- * directory entry joined with its settings profile and credential facts.
- * Every mutation below addresses this row, and the caller passes the row back
- * after re-loading so the revision/ref facts are current.
- */
-export interface ProviderTargetView {
-    /** Provider route id (`GenerateOptions.provider`). */
-    readonly provider: string;
-    /** Human-readable provider name. */
-    readonly displayName: string;
-    /** Whether an adapter currently serves this route. */
-    readonly active: boolean;
-    /** User-settings namespace whose section configures this provider; '' when unmanaged. */
-    readonly settingsNs: string;
-    /** Path from that section's root to this provider's profile; [] when the whole section is the profile. */
-    readonly settingsPath: readonly string[];
-    /** Revision of the owning settings section at load (0 when no namespace resolved). */
-    readonly settingsRevision: number;
-    /** Whether the resolved profile exists (the whole section, or at `settingsPath`). */
-    readonly configured: boolean;
-    /** Whether only the user settings layer carries the profile, so removal restores the base. */
-    readonly removable: boolean;
-    /** The credential reference the resolved profile names, when one does. */
-    readonly credentialRef?: string;
-    /** The conventional reference a save uses for a dormant or ref-less profile. */
-    readonly suggestedRef: string;
-    /** Credential facts, a bounded describe error, or undefined when there is no ref to describe. */
-    readonly credential: ProviderCredentialView | undefined;
-    /** Endpoint and explicit model overrides visible to the provider editor. */
-    readonly configuration: ProviderConfiguration;
-    /** The owning adapter reports this route as hand-declared (absent when it draws no distinction). */
-    readonly declared?: boolean;
-    /**
-     * Configuration diagnostic the adapter reported for this route (catalog or
-     * profile damage): the row stays listed and repairable instead of the whole
-     * provider vanishing; absent when the route reads clean.
-     */
-    readonly diagnostic?: string;
-}
-/** The resolved provider/settings/credential join. */
-export interface ProviderSettingsDirectory {
-    /** Provider rows: configurable-directory order first, active-unmanaged rows after. */
-    readonly rows: readonly ProviderTargetView[];
-    /** Whether the settings provider accepts writes (mirrors the web page's flag). */
-    readonly writable: boolean;
-    /** Non-fatal join failures (settings/directory reads), for a degradation notice. */
-    readonly failures: readonly string[];
-}
-/** Subscribe to the same provider-directory invalidations as the official Web Models page. */
-export declare function subscribeProviderSettings(ctx: Context, listener: () => void): () => void;
-/** A single-line, bounded error from the provider-management adapter. */
-export declare class ProviderSettingsError extends Error {
-    constructor(message: string);
-}
-/**
- * Join the configurable-provider directory, the redacted settings
- * namespaces, and the referenced credentials into panel rows, web-parity:
- * - directory entries merge with `listProviders()` to mark each live or
- *   dormant, and routes registered without a directory declaration appear as
- *   read-only/unmanaged rows (no settings address);
- * - a whole-section entry is configured whenever its namespace resolves;
- *   a path-addressed one only when the profile resolves there;
- * - a row is removable when the user layer alone carries its profile;
- * - only refs named by resolved profiles are described, and a per-ref failure
- *   degrades to that row's bounded error instead of losing it.
- * Absent `settings`/`credentials` services are tolerated the same way.
- * @param ctx - context carrying the `llm` service (settings/credentials optional).
- * @returns the resolved directory; empty rows when `llm` is unavailable.
- */
-export declare function loadProviderSettings(ctx: Context): Promise<ProviderSettingsDirectory>;
-/**
- * Store a provider API key, web-parity: validate with `normalizeApiKey`
- * (single-line, actionable errors that never echo the key), materialize the
- * profile/`apiKeyEnv` through `settings.mutate` first when the resolved
- * profile names no reference (dormant route or ref-less profile), then store
- * under the trusted named ref or the derived conventional ref. An existing
- * whole-section DeepSeek whose resolved profile already names
- * `DEEPSEEK_API_KEY` needs no settings mutation. Env-supplied read-only keys
- * are refused before any service call.
- * @param ctx - context carrying `settings` (when materializing) and `credentials`.
- * @param target - the joined row to write through.
- * @param rawKey - the key exactly as typed; surrounding whitespace is trimmed.
- * @throws {@link ProviderSettingsError} with a single-line, key-free message.
- */
-export declare function saveProviderCredential(ctx: Context, target: ProviderTargetView, rawKey: string): Promise<void>;
-/** Save the endpoint and an explicit model allow-list without rebuilding the profile. */
-export declare function saveProviderConfiguration(ctx: Context, target: ProviderTargetView, configuration: ProviderConfiguration): Promise<void>;
-/**
- * Interrogate a provider endpoint for the models it really serves, through
- * the model-discovery capability the provider's settings namespace
- * registered — the same pipe the official Web Models page uses. The request
- * is a draft: a typed key forces direct endpoint interrogation (gateway
- * truth), while an empty key lets the harness resolve the route's stored
- * credential; with neither baseURL nor route the adapter answers from its
- * own knowledge.
- * @param ctx - context carrying the `llm` service (optional discovery).
- * @param target - provider row whose settings namespace serves the draft.
- * @param request - typed key and/or endpoint override for this one probe.
- * @param signal - caller cancellation (panel navigation aborts the probe).
- * @returns the advertised models in endpoint order, deduplicated.
- */
-export declare function discoverProviderModels(ctx: Context, target: ProviderTargetView, request: {
-    readonly apiKey?: string;
-    readonly baseURL?: string;
-}, signal?: AbortSignal): Promise<readonly DiscoveredModelView[]>;
-/**
- * Remove the currently named credential without touching the provider
- * profile. Only the resolved profile's own reference is unset; a dormant or
- * ref-less row (nothing to remove), an already-absent key, and an
- * env-supplied read-only key are rejected safely before any service call.
- * @param ctx - context carrying the `credentials` service.
- * @param target - the joined row whose named credential to unset.
- * @throws {@link ProviderSettingsError} with a single-line, key-free message.
- */
-export declare function unsetProviderCredential(ctx: Context, target: ProviderTargetView): Promise<void>;
-/**
- * Remove a user-added provider profile, web-parity: only `removable` rows may
- * be removed; a page-managed credential — the derived ref, configured and
- * writable — is unset first (so a second-step failure leaves the row visible
- * and the operation retryable), then `settings.mutate` unsets
- * `target.settingsPath`. Both steps are idempotent. A hand-named credential
- * ref may be shared elsewhere and is left alone.
- * @param ctx - context carrying `credentials` and `settings`.
- * @param target - the joined row to remove.
- * @throws {@link ProviderSettingsError} with a single-line, key-free message.
- */
-export declare function removeProviderSettings(ctx: Context, target: ProviderTargetView): Promise<void>;

package/vendor/tui/types/questions.d.ts

@@ -1,54 +0,0 @@
-/**
- * The terminal ask_user_question answerer: one `user-questions/request`
- * waterfall listener that drives a FIFO queue — one question request on
- * screen at a time, everything else waiting — then resolves the collected
- * answers back into the waterfall. Mirrors the approval answerer's claim/
- * defer split: only agents this TUI owns are answered, every other request
- * falls through to the next answerer.
- *
- * Plan reviews (`exit_plan_mode`) arrive through the same waterfall with an
- * `intent: { kind: 'plan-review' }` — the renderer highlights the approve
- * option; the answer encoding is identical either way.
- *
- * @module @deepseek-ai/dsh-code/questions
- */
-import type { Context } from '@deepseek-ai/cordis';
-import type { Agent } from '@deepseek-ai/dsh-agent';
-import { type AskUserQuestionAnswer, type AskUserQuestionRequest } from '@deepseek-ai/dsh-user-questions';
-/** One question request waiting on the human, with its settle channels. */
-export interface PendingQuestion {
-    /** The request the renderer walks through question by question. */
-    request: AskUserQuestionRequest;
-    /** Resolve the provider promise with the collected answers. */
-    resolve(answers: AskUserQuestionAnswer): void;
-    /** Reject the provider promise as aborted (also used for Esc cancel). */
-    reject(error: Error): void;
-    /** Detach the request's abort listener once the question settles (internal). */
-    detachAbort?(): void;
-}
-/** The pending-question snapshot the renderer subscribes to. */
-export interface QuestionSnapshot {
-    /** The active request, or undefined when nothing is being asked. */
-    pending: PendingQuestion | undefined;
-}
-/** Store the pending question lands in; the renderer reads, the provider writes. */
-export interface QuestionStore {
-    /** Subscribe to pending-state changes; returns the unsubscribe function. */
-    subscribe(listener: () => void): () => void;
-    /** Read the current snapshot (identity-stable between changes). */
-    getSnapshot(): QuestionSnapshot;
-    /** Submit the collected answers for the active request and advance the queue. */
-    submit(pending: PendingQuestion, answers: AskUserQuestionAnswer): void;
-    /** Cancel the active request (Esc) — rejects ASK_ABORTED and advances the queue. */
-    cancel(pending: PendingQuestion): void;
-}
-/**
- * Mount the `user-questions/request` answerer over a FIFO queue.
- * @param ctx - plugin context whose event bus carries the waterfall.
- * @param owns - agents this terminal answers for; every other request is
- * deferred back into the waterfall (`next()`), so sibling answerers stay
- * usable. Agent-less asks are claimed: this TUI is the only human surface
- * in the process.
- * @returns the store the renderer subscribes to.
- */
-export declare function mountQuestionProvider(ctx: Context, owns: (agent: Agent) => boolean): QuestionStore;

package/vendor/tui/types/rainbow.d.ts

@@ -1,69 +0,0 @@
-/**
- * The rainbow theme's per-launch roll: a seeded shuffle over a twelve-color
- * bright-tier spectrum that fills every palette role, the status-bar tone map
- * (adjacent tones in canonical on-screen order never share a color, the
- * row1/row2 boundary included), the panel accent ring, and full-spectrum
- * flow anchors with a random phase. The roll happens once per launch and
- * stays stable for the whole run; setting RAINBOW_SEED=<uint32> pins it for
- * reproduction (the /theme notification prints the seed of the current roll).
- *
- * All pool colors clear AA body text (≥4.5:1) on a black terminal by a wide
- * margin (11-17:1); diff rows pair a bright hue with its own 22% dark tint
- * so the foreground stays 7.7-10.2:1 on its background.
- *
- * @module @deepseek-ai/dsh-tui/rainbow
- */
-import type { StatusTone } from './render/status.ts';
-import type { RgbTriple, ThemePalette } from './theme.ts';
-/**
- * The bright-tier spectrum: twelve Tailwind *-300 hues covering red through
- * fuchsia, every one ≥11:1 on black. The roll samples this pool by shuffle;
- * nothing outside it is ever painted.
- */
-export declare const RAINBOW_POOL: readonly RgbTriple[];
-/** One per-launch carnival roll: everything the rainbow theme paints from. */
-export interface RainbowRoll {
-    /** The seed this roll came from (print it to reproduce). */
-    readonly seed: number;
-    /** The full 15-token palette for this launch. */
-    readonly palette: ThemePalette;
-    /** The four-color panel ring (random order and start). */
-    readonly ring: readonly RgbTriple[];
-    /** Status-tone → color: adjacent tones in {@link TONE_ORDER} never match. */
-    readonly toneColors: Readonly<Record<StatusTone, RgbTriple>>;
-    /** Full-spectrum flow anchors in hue order (a different subset every launch). */
-    readonly flowAnchors: readonly RgbTriple[];
-    /** Random phase offset into the flow lap, milliseconds. */
-    readonly flowPhaseMs: number;
-}
-/** Parse a RAINBOW_SEED value: a non-negative decimal uint32, else nothing. */
-export declare function parseRainbowSeed(value: string | undefined): number | undefined;
-/**
- * One parsed `/rainbow` argument: empty means a fresh random roll; a
- * decimal uint32 pins that seed; anything else is a usage error.
- * @param argument - the raw text after `/rainbow`.
- * @returns `{ seed }`, `'random'`, or `'usage'`.
- */
-export declare function parseRainbowArgument(argument: string): {
-    seed: number;
-} | 'random' | 'usage';
-/**
- * Build the roll for one seed: pure and deterministic, so tests pin exact
- * outcomes and RAINBOW_SEED reproduces a lucky launch exactly.
- * @param seed - the uint32 seed to roll from.
- * @returns the complete carnival roll.
- */
-export declare function rollRainbow(seed: number): RainbowRoll;
-/** The memoized per-launch roll; computed once, stable for the whole run. */
-export declare function rainbowRoll(): RainbowRoll;
-/**
- * Replace the memoized roll: omit the seed for a fresh random one, or pass
- * a uint32 to pin it. `/rainbow` uses this so a mid-session reroll actually
- * recolors; {@link setTheme}(`'rainbow'`) must run afterwards so the
- * palette accessor picks the new values up.
- * @param seed - the seed to pin, or undefined for a new random roll.
- * @returns the roll now in force.
- */
-export declare function rerollRainbow(seed?: number): RainbowRoll;
-/** The current roll's seed as display copy (also the RAINBOW_SEED value). */
-export declare function rainbowSeedLabel(): string;