@deepseek-harness-tui/dsh-tui 0.13.0 → 0.14.0

package/lib/types/dsh-adapter/channel/core/actions.js

@@ -0,0 +1,152 @@
+import { conversationRecapPrompt, parseRecapResponse, sideQuestionPrompt } from '../../../channel/side-prompts.js';
+import { t } from '../../../i18n.js';
+import { createUnavailableActionDelegates } from '../action-readiness.js';
+export function createCapabilityDelegates(deps) {
+    const { notify, unavailable, guarded } = deps;
+    const caps = () => deps.session().capabilities;
+    return {
+        compact: () => {
+            const compact = caps().compact;
+            if (compact === undefined) {
+                unavailable('compact');
+                return;
+            }
+            void compact.run().catch((error) => {
+                notify(t('compact-failed', { err: error instanceof Error ? error.message : String(error) }), { color: 'error' });
+            });
+        },
+        cycleMode: () => guarded('mode', undefined, async () => {
+            const modes = caps().modes;
+            if (modes === undefined) {
+                unavailable('mode');
+                return;
+            }
+            // The reflex key walks the backend's declared cycle surface when it is
+            // narrower than the roster (Claude keeps `bypassPermissions`
+            // picker-only); a backend that declares none cycles the full list.
+            const list = modes.cycle?.() ?? modes.list();
+            if (list.length === 0)
+                return;
+            const index = list.findIndex(mode => mode.id === modes.current());
+            await modes.set(list[(index + 1) % list.length].id);
+        }),
+        listModels: () => guarded('model', [], async () => {
+            const models = caps().models;
+            if (models === undefined) {
+                unavailable('model');
+                return [];
+            }
+            // One provider: the backend itself (the picker drills straight into
+            // its models; `/model <id>` needs no provider segment).
+            const provider = deps.state().provider;
+            return (await models.list()).map(model => ({ provider: model.provider ?? provider, id: model.id, name: model.label, ...(model.description === undefined ? {} : { description: model.description }) }));
+        }),
+        switchModel: (provider, model) => guarded('model', false, async () => {
+            const models = caps().models;
+            if (models === undefined) {
+                unavailable('model');
+                return false;
+            }
+            const state = deps.state();
+            const own = provider === '' || provider === state.backendCapabilities.backendLabel || provider === state.provider;
+            const outcome = await models.set({ ...(own ? {} : { provider }), model });
+            if (outcome.kind === 'refused')
+                notify(outcome.reason, { color: 'warning' });
+            return outcome.kind === 'switched';
+        }),
+        listEfforts: () => {
+            const effort = caps().effort;
+            if (effort === undefined) {
+                unavailable('effort');
+                return Promise.resolve({ efforts: [], defaultEffort: undefined });
+            }
+            const levels = effort.levels();
+            // The slider relies on this call to explain why it cannot open (Chat
+            // returns silently for <= 1 tiers), so a route with zero or one effort
+            // tier gets the same warning the DSH extension shows.
+            if (levels.length === 0)
+                notify(t('effort-unsupported'), { color: 'warning' });
+            else if (levels.length === 1)
+                notify(t('effort-single-tier', { name: levels[0].label }), { color: 'warning' });
+            // levelsFallback is passed on when the backend marks the ladder as the
+            // CLI-standard fallback (the model row declares no tiers of its own), so
+            // the slider can say so instead of presenting them as the model's tiers.
+            return Promise.resolve({ efforts: levels.map(level => ({ id: level.id, name: level.label })), defaultEffort: effort.current(), ...(effort.levelsFallback === true ? { levelsFallback: true } : {}) });
+        },
+        setEffort: id => guarded('effort', false, async () => {
+            const effort = caps().effort;
+            if (effort === undefined || !effort.levels().some(level => level.id === id)) {
+                unavailable('effort');
+                return false;
+            }
+            await effort.set(id);
+            return true;
+        }),
+        // `/btw`: the backend's side call with the shared side-question contract.
+        sideQuestion: async (question, options) => {
+            const side = caps().sideQuery;
+            if (side === undefined) {
+                unavailable('btw');
+                return { answer: null, error: deps.unavailableLines('btw').join(' ') };
+            }
+            try {
+                return { ...await side.ask(sideQuestionPrompt(question), options) };
+            }
+            catch (error) {
+                return { answer: null, error: error instanceof Error ? error.message : String(error) };
+            }
+        },
+        // `/recap`: the same side call over the conversation itself, read back
+        // as a one-line summary plus a proposed title.
+        recapRecent: async (options) => {
+            const side = caps().sideQuery;
+            if (side === undefined) {
+                unavailable('recap');
+                return { summary: null, error: deps.unavailableLines('recap').join(' ') };
+            }
+            try {
+                const outcome = await side.ask(conversationRecapPrompt(), options);
+                if (outcome.answer === null)
+                    return { summary: null, ...(outcome.error === undefined ? {} : { error: outcome.error }) };
+                const parsed = parseRecapResponse(outcome.answer);
+                return { summary: parsed.summary, ...(parsed.title === undefined ? {} : { title: parsed.title }) };
+            }
+            catch (error) {
+                return { summary: null, error: error instanceof Error ? error.message : String(error) };
+            }
+        },
+        renameSession: title => {
+            const rename = caps().rename;
+            if (rename === undefined) {
+                unavailable('rename');
+                return;
+            }
+            void rename.rename(title).catch((error) => {
+                if (deps.owner.current())
+                    notify(t('rename-failed', { err: error instanceof Error ? error.message : String(error) }), { color: 'error', timeoutMs: 8000 });
+            });
+        },
+        setSessionColor: color => {
+            const accent = caps().color;
+            if (accent === undefined) {
+                unavailable('color');
+                return;
+            }
+            try {
+                accent.set(color);
+            }
+            catch (error) {
+                notify(t('capability-failed', { name: 'color', err: error instanceof Error ? error.message : String(error) }), { color: 'error', timeoutMs: 8000 });
+            }
+        },
+    };
+}
+/** Merge the layers and install them once. */
+export function installChannelActions(readiness, layers) {
+    readiness.install({
+        ...createUnavailableActionDelegates(layers.unavailable, layers.unavailableLines),
+        ...layers.capability,
+        ...layers.core,
+        ...layers.extension,
+    });
+}

package/lib/types/dsh-adapter/channel/core/binding-feed.d.ts

@@ -0,0 +1,145 @@
+/**
+ * A channel's transcript feed, for any backend: the shared projector, the
+ * session-batch router that is its only writer, and the bind that follows
+ * the bound session.
+ *
+ * `bind(seed?)` advances the binding generation, resets input convergence,
+ * links the session's prompts to the stores Chat renders, and subscribes the
+ * router to the captured session. By default it also paints the session's
+ * durable history and seeds the session-level facts from the session's
+ * capabilities. The history is the `seed` the caller read before the
+ * adoption (a resume reads `history()` ahead of the synchronous adopt). It
+ * is painted synchronously before the subscription, so no live event can
+ * land ahead of it. Without a seed the history is read once,
+ * asynchronously, and dropped if live rows painted first. An extension that
+ * owns those facts and replays its seed synchronously itself (DSH) sets
+ * `ownsSessionFacts`, and adds its raw per-binding listeners through
+ * `onBind`.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { AgentEvent, AgentEventMeta, AgentEventOf } from '../../../agent/events.js';
+import type { AgentSession } from '../../../agent/session.js';
+import { type ChannelProjection, type ChannelProjectionDeps } from '../../../channel/projection.js';
+import type { BindingCapture, ChannelBinding } from '../binding.js';
+import type { InputConvergence } from '../input-actions.js';
+import type { ChannelOwner } from '../owner.js';
+import type { ChannelLaunchOptions } from '../state.js';
+import type { ChannelState } from '../types.js';
+import type { SessionControls } from './session-controls.js';
+/** What one bind hands an extension's per-binding listeners. */
+export interface BindingScope {
+    readonly capture: BindingCapture;
+    /** Owner live and the binding still the captured one (ABA-safe). */
+    current(): boolean;
+    /** Own a listener for this binding period (released on the next adoption). */
+    register<T extends () => void>(dispose: T): T;
+}
+/** Extension points of the feed (all optional; see the module comment). */
+export interface BindingFeedHooks {
+    /** Right after the generation advances (DSH: owner-level child listeners). */
+    onGeneration?(): void;
+    /** After input convergence resets, before the session subscription. */
+    onBind?(scope: BindingScope): void;
+    /** After the bind returned (outside its rollback). */
+    afterBind?(): void;
+    /** The extension maintains the session-level facts and replays its seed
+     *  synchronously: no history repaint, no capability observer. */
+    readonly ownsSessionFacts?: boolean;
+    /** Forget the bound session's translator state with the projector's. */
+    resetTranslation?(): void;
+}
+/**
+ * The one session-batch writer path, shared by every channel composition:
+ * binding-generation fence over the whole batch, session status and
+ * pending-queue bookkeeping, compaction-progress gating, then the shared
+ * projector and the renderer wake the backend asked for.
+ */
+export declare function createSessionBatchRouter(deps: {
+    state: ChannelState;
+    projector: ChannelProjection;
+    inputConvergence: InputConvergence;
+    /** Drop channel-side context attached to a discarded input (DSH pre-step
+     *  attachments); absent where nothing is ever attached. */
+    retireAttachment?(messageId: string): void;
+    /** The backend reset the conversation in place (`session.reset`, live):
+     *  the events before it in the batch are projected first, those after it
+     *  land on the cleared view. Absent = the event is projected (ignored). */
+    onReset?(event: AgentEventOf<'session.reset'>): void;
+    warn(message: string): void;
+}): {
+    route: (batch: readonly AgentEvent[], meta: AgentEventMeta, current: () => boolean) => void;
+    reconcileRetiredProjection: (status: "idle" | "disposed") => void;
+    turnStarts: () => number;
+};
+/**
+ * The bind that follows the bound session: shared by the channel feed below
+ * and the DSH binding-events owner (which direct regressions drive alone).
+ */
+export declare function createSessionBinder(deps: {
+    owner: ChannelOwner;
+    binding: Pick<ChannelBinding, 'bind' | 'capture' | 'isCurrent' | 'subscribe'>;
+    state: Pick<ChannelState, 'agentBindingGeneration' | 'status'>;
+    inputConvergence: InputConvergence;
+    route(batch: readonly AgentEvent[], meta: AgentEventMeta, current: () => boolean): void;
+    hooks(): BindingFeedHooks;
+    /** Forget the core's trajectory fold before the seed replay paints (a
+     * session swap starts an empty raw-event log, exactly like the rows). */
+    resetTrajectory?(): void;
+    /** The stores a session's prompts park in (`ChannelLaunchOptions.interaction`). */
+    interaction?: ChannelLaunchOptions['interaction'];
+    /** The session-level facts kept unless the extension owns them. */
+    facts?: {
+        observe(batch: readonly AgentEvent[], session: AgentSession, current: () => boolean): void;
+        /** Paint the history read ahead of the bind (before the subscription). */
+        replay(history: readonly AgentEvent[]): void;
+        /** After the subscription: `replayed` = the history was already painted. */
+        seed(capture: BindingCapture, current: () => boolean, replayed: boolean): void;
+    };
+}): {
+    bind: (seed?: readonly AgentEvent[]) => void;
+};
+export declare function createBindingFeed(ctx: Context, deps: {
+    owner: ChannelOwner;
+    binding: ChannelBinding;
+    state: ChannelState;
+    options: Pick<ChannelLaunchOptions, 'interaction'>;
+    inputConvergence: InputConvergence;
+    /** The projector's channel-side dependencies; `jobs` and `pricingWindow`
+     *  stay writable until the channel starts (`configureProjection`). */
+    projection: Omit<ChannelProjectionDeps, 'inputConvergence'>;
+    retireAttachment(messageId: string): void;
+    controls: SessionControls;
+    hooks(): BindingFeedHooks;
+    /** A live `session.reset` (see createSessionBatchRouter). */
+    onReset?(event: AgentEventOf<'session.reset'>): void;
+    /** Passed to the binder: resets the core trajectory fold per bind. */
+    resetTrajectory?(): void;
+}): {
+    projector: {
+        apply: (events: readonly AgentEvent[], meta: AgentEventMeta) => void;
+        reset: () => void;
+        settleStreaming: () => void;
+        updateSpinnerMode: () => void;
+        contextUsage: () => {
+            readonly type: "context.usage";
+            readonly used: number;
+            readonly max?: number;
+            readonly categories?: readonly {
+                readonly name: string;
+                readonly tokens: number;
+                readonly kind: string;
+            }[];
+        } | undefined;
+    };
+    router: {
+        route: (batch: readonly AgentEvent[], meta: AgentEventMeta, current: () => boolean) => void;
+        reconcileRetiredProjection: (status: "idle" | "disposed") => void;
+        turnStarts: () => number;
+    };
+    bind: (seed?: readonly AgentEvent[]) => void;
+    resetProjection: () => void;
+    /** Install the backend's job-registry feed and pricing policy (before start). */
+    configureProjection(update: Partial<Pick<ChannelProjectionDeps, "jobs" | "pricingWindow">>): void;
+};
+export type BindingFeed = ReturnType<typeof createBindingFeed>;
+//# sourceMappingURL=binding-feed.d.ts.map

package/lib/types/dsh-adapter/channel/core/binding-feed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binding-feed.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/channel/core/binding-feed.ts"],"names":[],"mappings":"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"}

package/lib/types/dsh-adapter/channel/core/binding-feed.js

@@ -0,0 +1,289 @@
+import { attachInteraction } from '../../../channel/interaction.js';
+import { createChannelProjection } from '../../../channel/projection.js';
+import { logForDebugging } from '../../../utils/debug.js';
+/**
+ * The one session-batch writer path, shared by every channel composition:
+ * binding-generation fence over the whole batch, session status and
+ * pending-queue bookkeeping, compaction-progress gating, then the shared
+ * projector and the renderer wake the backend asked for.
+ */
+export function createSessionBatchRouter(deps) {
+    const reconcileRetiredProjection = (status) => {
+        if (!deps.state.working)
+            return;
+        deps.warn(`dsh-tui: agent became ${status} while the channel still projected an open turn; releasing volatile UI gates`);
+        deps.inputConvergence.cancelInFlight = false;
+        deps.state.cancelPending = false;
+        deps.state.working = false;
+        deps.state.activeToolCount = 0;
+        deps.projector.settleStreaming();
+        deps.projector.updateSpinnerMode();
+    };
+    /** `session.status` as the backend reports it. */
+    const applyStatus = (status) => {
+        if (status === 'disposed') {
+            deps.state.status = 'disposed';
+            reconcileRetiredProjection('disposed');
+            deps.state.emit();
+            return;
+        }
+        // The channel's status is idle/running only; a parked prompt is mid-turn.
+        deps.state.status = status === 'idle' ? 'idle' : 'running';
+        if (status === 'idle')
+            reconcileRetiredProjection('idle');
+        deps.state.emit();
+    };
+    /**
+     * The backend queue lost inputs. A claim and a discard both retire the
+     * pending preview, but only a discard retires an attached-context entry. A
+     * claim fires while the loop claims the batch, before the resident
+     * `agent/pre-step` listener appends the attachment, so retiring there would
+     * delete the context before it is ever injected.
+     */
+    const applyPending = (event) => {
+        for (const messageId of event.discarded ?? [])
+            deps.retireAttachment?.(messageId);
+        // A discard of a docked preview only drops the backend copy. The dock
+        // (where an interrupt parks inputs on the channel side) owns the row, so
+        // it stays until sent (`deliverDocked`) or retracted. A claim always
+        // retires the row: a fallback backend that kept its queue ran it.
+        const dockedDiscards = new Set(event.discarded ?? []);
+        for (const messageId of [...event.claimed ?? [], ...event.discarded ?? []]) {
+            const before = deps.state.pending.length;
+            deps.state.pending = deps.state.pending.filter(item => item.id !== messageId || (item.docked === true && dockedDiscards.has(messageId)));
+            if (deps.state.pending.length !== before)
+                deps.state.emit();
+        }
+    };
+    /** Monotonic count of live turns that started on a bound session (`/new`
+     *  compares it across its open: a whole turn may come and go meanwhile). */
+    let turnStarts = 0;
+    const route = (batch, meta, current) => {
+        // The generation fence covers the whole batch, whatever it carries. A
+        // callback retained past a rebind (an in-flight dispatch, a compaction
+        // summary stream that outlived the binding it started under) must never
+        // write the replacement session's transcript.
+        if (!current())
+            return;
+        let admitted;
+        let progressOnly = batch.length > 0;
+        for (const [index, event] of batch.entries()) {
+            switch (event.type) {
+                case 'turn.start':
+                    if (!meta.replay)
+                        turnStarts += 1;
+                    break;
+                case 'session.status':
+                    applyStatus(event.status);
+                    break;
+                case 'pending.changed':
+                    applyPending(event);
+                    break;
+                case 'compaction.progress':
+                    // Summary output only advances a compaction row that is open; a
+                    // stale stream after the row closed finds nothing to advance.
+                    if (deps.state.compaction === undefined) {
+                        admitted ??= batch.slice(0, index);
+                        continue;
+                    }
+                    break;
+                default:
+                    break;
+            }
+            if (event.type !== 'compaction.progress')
+                progressOnly = false;
+            admitted?.push(event);
+        }
+        const events = admitted ?? batch;
+        if (progressOnly) {
+            // Pure summary progress: frame-coalesced like the stream it counts.
+            if (events.length === 0)
+                return;
+            deps.projector.apply(events, meta);
+            deps.state.emitStream();
+            return;
+        }
+        // The one writer of the foreground transcript. A live conversation
+        // reset splits the batch: what came before it is projected first.
+        const onReset = meta.replay ? undefined : deps.onReset;
+        if (onReset !== undefined && events.some(event => event.type === 'session.reset')) {
+            let start = 0;
+            events.forEach((event, index) => {
+                if (event.type !== 'session.reset')
+                    return;
+                if (index > start)
+                    deps.projector.apply(events.slice(start, index), meta);
+                onReset(event);
+                start = index + 1;
+            });
+            if (start < events.length)
+                deps.projector.apply(events.slice(start), meta);
+        }
+        else {
+            deps.projector.apply(events, meta);
+        }
+        if (meta.wake === 'frame')
+            deps.state.emitStream();
+        else if (meta.wake !== 'none')
+            deps.state.emit();
+    };
+    return { route, reconcileRetiredProjection, turnStarts: () => turnStarts };
+}
+/**
+ * The bind that follows the bound session: shared by the channel feed below
+ * and the DSH binding-events owner (which direct regressions drive alone).
+ */
+export function createSessionBinder(deps) {
+    const { owner, binding, state, inputConvergence } = deps;
+    /**
+     * Links the bound session's prompts to the stores Chat renders. One link
+     * per binding: a replaced session (or a released channel) withdraws
+     * everything it parked, so no panel outlives its session.
+     */
+    let interactionLink;
+    if (deps.interaction !== undefined)
+        owner.own(() => { interactionLink?.release(); });
+    /** Bind the current session: the one subscription feeding the projector. */
+    const bind = (seed) => {
+        const hooks = deps.hooks();
+        try {
+            state.agentBindingGeneration = binding.bind();
+            deps.resetTrajectory?.();
+            hooks.onGeneration?.();
+            inputConvergence.cancelInFlight = false;
+            inputConvergence.interruptSeq += 1;
+            const capture = binding.capture();
+            const session = capture.session;
+            const current = () => owner.current() && binding.isCurrent(capture);
+            const register = (dispose) => {
+                binding.subscribe(dispose);
+                return dispose;
+            };
+            hooks.onBind?.({ capture, current, register });
+            const interaction = deps.interaction;
+            let link;
+            if (interaction !== undefined) {
+                interactionLink?.release();
+                link = attachInteraction({ ...interaction, debug: logForDebugging }, { sessionId: session.ref.sessionId, capabilities: session.capabilities });
+                interactionLink = link;
+            }
+            const facts = hooks.ownsSessionFacts === true ? undefined : deps.facts;
+            // The history read ahead of the adoption paints first, so every live
+            // event lands after it.
+            if (facts !== undefined && seed !== undefined)
+                facts.replay(seed);
+            if (facts === undefined && link === undefined) {
+                register(session.subscribe((batch, meta) => deps.route(batch, meta, current)));
+            }
+            else {
+                register(session.subscribe((batch, meta) => {
+                    // Prompts first: a batch that also closes the turn must not leave
+                    // a panel behind it; the generation fence applies to both halves.
+                    if (current()) {
+                        link?.apply(batch);
+                        facts?.observe(batch, session, current);
+                    }
+                    deps.route(batch, meta, current);
+                }));
+            }
+            facts?.seed(capture, current, seed !== undefined);
+        }
+        catch (error) {
+            owner.dispose();
+            throw error;
+        }
+        hooks.afterBind?.();
+    };
+    return { bind };
+}
+export function createBindingFeed(ctx, deps) {
+    const { owner, binding, state, inputConvergence, controls } = deps;
+    // The projector reads its deps per use, so an extension can install its
+    // job feed and pricing policy before any event is projected.
+    const projectorDeps = {
+        ...deps.projection, inputConvergence,
+        backendLabel: () => state.backendCapabilities.backendId === 'dsh' ? undefined : state.backendCapabilities.backendLabel,
+    };
+    const projector = createChannelProjection(state, projectorDeps);
+    const router = createSessionBatchRouter({
+        state,
+        projector,
+        inputConvergence,
+        retireAttachment: deps.retireAttachment,
+        ...(deps.onReset === undefined ? {} : { onReset: deps.onReset }),
+        warn: message => ctx.logger.warn(message),
+    });
+    /** Forget every per-session projection ledger: the projector's and the
+     *  bound session translator's, together. */
+    const resetProjection = () => {
+        projector.reset();
+        deps.hooks().resetTranslation?.();
+    };
+    /** Paint a settled history: no live toasts, no open turn left behind. */
+    const paintHistory = (events) => {
+        if (events.length === 0)
+            return;
+        projector.apply(events, { replay: true });
+        projector.settleStreaming();
+        state.working = false;
+        state.cancelPending = false;
+    };
+    /**
+     * Fallback for a bind without a history read ahead of it (an embedder
+     * handing `createChannel` a session whose history it never read): read it
+     * once, asynchronously, and paint it only if nothing live has painted yet.
+     * Painting it after live rows that already arrived would misorder both.
+     * Every core adoption (`/new`, `/resume`, a rewind's fork) and the plugin's
+     * startup session pass the history in instead.
+     */
+    const replayHistory = (capture, current) => {
+        void capture.session.history().then(events => {
+            if (events.length === 0 || !current())
+                return;
+            if (state.rows.length > 0) {
+                logForDebugging('channel: history arrived after live rows; not replayed');
+                return;
+            }
+            paintHistory(events);
+            state.emit();
+        }).catch((error) => {
+            logForDebugging(`channel: history failed (${error instanceof Error ? error.message : String(error)})`);
+        });
+    };
+    const statusOf = (session) => session.status === 'running' || session.status === 'requires-action'
+        ? 'running'
+        : session.status === 'disposed' ? 'disposed' : 'idle';
+    const binder = createSessionBinder({
+        owner,
+        binding,
+        state,
+        inputConvergence,
+        route: router.route,
+        hooks: deps.hooks,
+        ...(deps.resetTrajectory === undefined ? {} : { resetTrajectory: deps.resetTrajectory }),
+        interaction: deps.options.interaction,
+        facts: {
+            observe: controls.observe,
+            replay: paintHistory,
+            seed(capture, current, replayed) {
+                state.status = statusOf(capture.session);
+                if (!replayed)
+                    replayHistory(capture, current);
+                controls.seed(capture.session, current);
+            },
+        },
+    });
+    return {
+        projector,
+        router,
+        bind: binder.bind,
+        resetProjection,
+        /** Install the backend's job-registry feed and pricing policy (before start). */
+        configureProjection(update) {
+            if (update.jobs !== undefined)
+                projectorDeps.jobs = update.jobs;
+            if (update.pricingWindow !== undefined)
+                projectorDeps.pricingWindow = update.pricingWindow;
+        },
+    };
+}