dsh-connect 0.8.0 → 0.9.0

package/lib/runner.js

@@ -1,7 +1,11 @@
 /**
  * Per-chat agent driver: serializes inbound messages, creates/resumes the bound
- * DSH agent (with preset composition + model selection), and bridges the live
- * `session/event` stream into the adapter's streaming reply.
+ * DSH agent (with preset composition + model selection), and bridges two live
+ * feeds into the adapter's streaming reply: the durable `session/event` stream
+ * (turn, tool, todo and settlement events) and the transient
+ * `agent/assistant-stream` frames that carry the model's deltas. Since
+ * 0.1.5-rc.2 the deltas are no longer session events — `assistant/chunk` is
+ * gone — so the two subscriptions are separate and both are required.
  * @module dsh-connect/runner
  */
 import { randomUUID } from "node:crypto";
@@ -12,6 +16,7 @@ import { SessionId } from "@deepseek-ai/dsh-session";
 import { createUserMessage, ReasoningEffortId } from "@deepseek-ai/dsh-llm";
 import { createAsyncQueue, applyStreamChunk, applyToolCall, toolCallSummary, questionTextOf, summarizeTurn, classifyError, mapReason, truncate, fmtTokens, textOf, } from "./stream.js";
 import { helpText, parseCommand } from "./commands.js";
+import { resolveStateDir } from "./state-dir.js";
 import { menuTitle, rootMenuSections, reasonLabel, goalPhaseLabel, listWorkspaces, PROGRESS_PRESET_MS } from "./menus.js";
 import { MenuController } from "./menu-controller.js";
 import { messages } from "./i18n.js";
@@ -89,6 +94,19 @@ function sameDir(a, b) {
 }
 /** How often the proactive progress watchdog re-checks whether a status card is due (ms). */
 const PROGRESS_WATCHDOG_CHECK_MS = 15_000;
+/**
+ * Preset composed when the configured one cannot be used.
+ *
+ * `standard` is the roster's general-purpose preset and ships in every build,
+ * so it is the safest thing to fall back to. The roster still gets asked first
+ * — if it disagrees the first mountable row wins, and only a roster with no
+ * usable row at all leaves the agent uncomposted.
+ */
+const FALLBACK_PRESET_ID = "standard";
+/** How a preset id reads in a log line: a quoted id, or the roster's default. */
+function describePreset(id) {
+    return id === undefined || id === "" ? "the roster default" : JSON.stringify(id);
+}
 export class AgentRunner {
     ctx;
     config;
@@ -102,6 +120,8 @@ export class AgentRunner {
     reminders;
     queue = [];
     running = false;
+    /** Set by `dispose()`; makes the runner permanently inert. */
+    disposed = false;
     agent;
     handle;
     turn;
@@ -154,7 +174,31 @@ export class AgentRunner {
         const first = registry?.list?.()[0];
         return first?.path ?? process.cwd();
     }
+    /**
+     * Tear the runner down for good — the counterpoint to `enqueue`.
+     *
+     * Called when the runner's channel adapter is deactivated (a settings change
+     * removed that channel from `channels[]`) or the service shuts down. The
+     * runner is inert afterwards: `enqueue` drops work and the drain loop stops
+     * before its next turn. `ConnectService` deletes its map entry, so a later
+     * message builds a fresh runner instead of reviving this one.
+     *
+     * `queuedMessages` is cleared rather than replayed: those messages belong to
+     * a channel that no longer has an adapter to answer on, so replaying them
+     * would run agent turns whose output has nowhere to go.
+     */
+    async dispose() {
+        this.disposed = true;
+        this.queue.length = 0;
+        await this.disposeAgent();
+        const binding = this.bindings.get(this.channel, this.chatKey);
+        if (binding !== undefined && binding.lockOwner !== undefined) {
+            this.bindings.put({ ...lockRelease(binding), queuedMessages: [] });
+        }
+    }
     enqueue(msg) {
+        if (this.disposed)
+            return;
         const command = parseCommand(msg.text);
         if (command.kind !== "message") {
             // Command handlers touch the adapter directly (no per-call catch) — a
@@ -199,15 +243,6 @@ export class AgentRunner {
                 this.maybeNudgeContext(turn);
             }
         }
-        if (event.type === "assistant/chunk") {
-            const chunk = event.data.chunk;
-            // First reasoning delta = the milestone the proactive progress notice reports.
-            if (chunk.type === "reasoning-delta" && turn.milestone === undefined) {
-                turn.milestone = this.t.progressThinking;
-            }
-            applyStreamChunk(turn, this.t.thinkingHint, chunk, this.notifyLevel);
-            return;
-        }
         if (event.type === "tool/call") {
             const name = event.data.name;
             if (typeof name !== "string" || name === "")
@@ -336,11 +371,11 @@ export class AgentRunner {
         return choice === "confirm:yes";
     }
     async drain() {
-        if (this.running)
+        if (this.running || this.disposed)
             return;
         this.running = true;
         try {
-            while (this.queue.length > 0) {
+            while (this.queue.length > 0 && !this.disposed) {
                 const msg = this.queue.shift();
                 if (msg === undefined)
                     break;
@@ -571,6 +606,10 @@ export class AgentRunner {
      * report it) while the actual LLM requests keep using the old default.
      * The default model still seeds the agent through `agentOptions` in
      * `ensureAgent`, which `buildRequest` uses as its fallback route.
+     *
+     * Preset resolution is best-effort — see {@link resolvePresetId}. This method
+     * never throws for a preset reason, so no configuration id can stop a turn
+     * from composing an agent at all.
      */
     async composeSetup(_selection) {
         const presets = this.ctx.get("agentPresets");
@@ -579,14 +618,86 @@ export class AgentRunner {
                 setup: () => undefined,
             };
         }
-        const resolved = await presets.resolve(this.config.agentPreset);
+        const id = await this.resolvePresetId(presets);
+        if (id === undefined) {
+            return {
+                setup: () => undefined,
+            };
+        }
         return {
-            agentPreset: resolved.id,
+            agentPreset: id,
             setup: async (agentCtx) => {
-                await presets.mount(agentCtx, resolved.id);
+                await presets.mount(agentCtx, id);
             },
         };
     }
+    /**
+     * Resolve the preset to compose, degrading instead of aborting the turn.
+     *
+     * The host looks a preset up by id, so one stale id — `agentPresets.default`
+     * naming a preset this install does not ship, or a preset directory edited
+     * into an unreadable state — used to throw straight out of `composeSetup`.
+     * That happens before an agent exists, so *every* turn of every bound chat
+     * died with the raw host error and nothing in the session log to explain it.
+     * Resolution is therefore best-effort: the configured id is tried, then
+     * {@link FALLBACK_PRESET_ID}, and when neither composes the agent is built
+     * without a preset — the same shape a host with no `agentPresets` service
+     * already produced — so the turn still runs.
+     */
+    async resolvePresetId(presets) {
+        const wanted = this.config.agentPreset;
+        const resolved = await this.tryPreset(presets, wanted);
+        if (resolved !== undefined)
+            return resolved;
+        const recovered = await this.tryPreset(presets, await this.fallbackPresetId(presets));
+        if (recovered !== undefined) {
+            this.log(`connect: falling back to agent preset ${JSON.stringify(recovered)}`);
+            return recovered;
+        }
+        this.log("connect: no usable agent preset; composing the agent without one");
+        return undefined;
+    }
+    /**
+     * Resolve `id`, reporting why it is unusable instead of throwing.
+     *
+     * A preset that resolves but reports `broken` counts as unusable: the host's
+     * mounting paths refuse those, so composing one would only move this failure
+     * to `mount`, after the log line that would have explained it.
+     *
+     * `undefined` id means "the roster default", which is what `resolve` does
+     * with it — the default is as fallible as an explicit id, so it is routed
+     * through the same recovery.
+     */
+    async tryPreset(presets, id) {
+        try {
+            const resolved = await presets.resolve(id);
+            if (resolved.broken !== undefined) {
+                this.log(`connect: agent preset ${describePreset(id)} failed to load: ${resolved.broken}`);
+                return undefined;
+            }
+            return resolved.id;
+        }
+        catch (error) {
+            this.log(`connect: agent preset ${describePreset(id)} is unusable: ${String(error)}`);
+            return undefined;
+        }
+    }
+    /**
+     * The id to retry with: {@link FALLBACK_PRESET_ID} while the roster still
+     * offers it, otherwise the roster's first mountable row.
+     *
+     * Never throws — the caller is already handling a failure, and a roster that
+     * cannot be listed should still leave the hardcoded id to be tried.
+     */
+    async fallbackPresetId(presets) {
+        try {
+            const mountable = ((await presets.list?.()) ?? []).filter((row) => row.broken === undefined);
+            return mountable.find((row) => row.id === FALLBACK_PRESET_ID)?.id ?? mountable[0]?.id ?? FALLBACK_PRESET_ID;
+        }
+        catch {
+            return FALLBACK_PRESET_ID;
+        }
+    }
     /** Agents this runner has already attached a `session/event` listener to. */
     watchedAgents = new WeakSet();
     watchAgent(agent) {
@@ -600,6 +711,28 @@ export class AgentRunner {
         agent.ctx.on("session/event", (session, event) => {
             this.onSessionEvent(session, event);
         });
+        // Live model deltas. Deltas used to arrive as `assistant/chunk` session
+        // events; that type is gone, and a turn's stream is now durable only at
+        // settlement (embedded in `assistant/message` / `assistant/attempt`). The
+        // live feed is this separate agent-scoped event instead — `dsh-scope`
+        // routes it by its `agent` subject, so a listener on `agent.ctx` sees only
+        // this agent's frames, exactly like the `session/event` subscription above
+        // (no id filter needed). Frames carry real `StreamChunk`s, so
+        // `applyStreamChunk` is unchanged.
+        agent.ctx.on("agent/assistant-stream", ({ frame }) => {
+            const turn = this.turn;
+            if (turn === undefined)
+                return;
+            // `start` / `end` only bracket the attempt; the card is driven by chunks.
+            if (frame.type !== "chunk")
+                return;
+            const chunk = frame.chunk;
+            // First reasoning delta = the milestone the proactive progress notice reports.
+            if (chunk.type === "reasoning-delta" && turn.milestone === undefined) {
+                turn.milestone = this.t.progressThinking;
+            }
+            applyStreamChunk(turn, this.t.thinkingHint, chunk, this.notifyLevel);
+        });
     }
     async driveAgent(agent, msg) {
         const firstSeq = agent.session.seq;
@@ -700,7 +833,7 @@ export class AgentRunner {
                 this.log(`connect: deferred compaction failed: ${error instanceof Error ? error.message : String(error)}`);
             });
         }
-        const outcome = summarizeTurn(agent.session.events, firstSeq);
+        const outcome = summarizeTurn(agent.session.snapshotEvents(), firstSeq);
         const text = outcome.text !== "" ? outcome.text : this.turn.lastText;
         this.turn = undefined;
         return { ...outcome, text };
@@ -930,7 +1063,7 @@ export class AgentRunner {
         const agent = this.agent;
         if (agent === undefined)
             return [];
-        const events = agent.session.events;
+        const events = agent.session.snapshotEvents();
         for (let i = events.length - 1; i >= 0; i--) {
             const event = events[i];
             if (event.type === "todo/write")
@@ -1449,7 +1582,7 @@ export class AgentRunner {
     }
     /** Extract the most recent turn's completion info from session events. */
     getLastTurnInfo(agent) {
-        const events = agent.session.events;
+        const events = agent.session.snapshotEvents();
         for (let i = events.length - 1; i >= 0; i--) {
             const event = events[i];
             if (event.type === "turn/end") {
@@ -1492,7 +1625,9 @@ export class AgentRunner {
         lines.push(this.t.progressSetting(this.progressTimeoutMs === 0 ? this.t.progressOff : this.t.progressMinutes(Math.round(this.progressTimeoutMs / 60_000))));
         lines.push(this.t.allowUsersField(this.config.allowUsers.length, this.config.allowUsers.length === 0));
         lines.push(this.t.allowChatsField(this.config.allowChats.length, this.config.allowChats.length === 0));
-        lines.push(this.t.stateDirField(this.config.stateDir ?? ".dsh-connect"));
+        // Show the directory the stores actually resolve to (config → env → default),
+        // not the raw config value, so the status card can't disagree with disk.
+        lines.push(this.t.stateDirField(resolveStateDir(this.config)));
         await this.adapter.sendText(target, lines.join("\n"));
     }
     async setModel(provider, model, msg) {
@@ -1717,7 +1852,7 @@ export class AgentRunner {
             await this.adapter.sendText(target, this.t.historySessions(sessions.length, lines.join("\n")));
             return;
         }
-        const events = agent.session.events;
+        const events = agent.session.snapshotEvents();
         const rows = [];
         for (let i = events.length - 1; i >= 0 && rows.length < limit; i--) {
             const e = events[i];
@@ -1766,7 +1901,7 @@ export class AgentRunner {
     async showSchedule(target) {
         // Agent-level reminders (session `schedule` tool) + persistent chat-level
         // reminders (`/remind`), merged into one list.
-        const agentReminders = this.agent === undefined ? [] : foldReminders(this.agent.session.events);
+        const agentReminders = this.agent === undefined ? [] : foldReminders(this.agent.session.snapshotEvents());
         const persisted = this.reminders?.listFor(this.channel, this.chatKey) ?? [];
         const now = Date.now();
         const locale = this.language === "en" ? "en-US" : "zh-CN";
@@ -1939,7 +2074,7 @@ export class AgentRunner {
      * Generate Markdown representation of the conversation history.
      */
     generateMarkdown(agent) {
-        const events = agent.session.events;
+        const events = agent.session.snapshotEvents();
         const lines = [];
         // Header
         lines.push(`# Conversation History`);