@sagentlab/navarch-runtime 0.1.132 → 0.1.133

package/dist/adapters/muse.cjs

@@ -12,7 +12,11 @@ const node_path_1 = __importDefault(require("node:path"));
 const node_crypto_1 = require("node:crypto");
 const kill_agent_cjs_1 = require("../kill-agent.cjs");
 const version_cjs_1 = require("../version.cjs");
-const types_cjs_1 = require("./types.cjs");
+// `interrupt: native` is MSP `turn/cancel` on the live connection, then a new
+// `turn/start` in the same session. It is a protocol request and is not the
+// lease-loss path, which waits CANCEL_GRACE_MS and then kills the host. There
+// is no mid-turn input channel: `steer` is `none` and `queue` waits for the turn.
+const MUSE_STEERING = Object.freeze({ steer: "none", queue: "boundary", interrupt: "native" });
 const CANCEL_GRACE_MS = 2_000;
 const SHUTDOWN_GRACE_MS = 30_000;
 const TERMINATE_GRACE_MS = 2_000;
@@ -82,7 +86,9 @@ async function runMuseProcess(options, mcpServers, sdk) {
     let protocolFailed = false;
     const closed = deferred();
     const stopped = deferred();
-    const completed = deferred();
+    let completed = deferred();
+    let pendingInterrupt;
+    let sawTurn = false; // An earlier turn ended, so the session is resumable even if the next start fails.
     const items = new Map();
     const usage = new Map();
     const pending = [];
@@ -252,19 +258,56 @@ async function runMuseProcess(options, mcpServers, sdk) {
             }
             if (timedOut || killedByLeaseLoss || protocolFailed)
                 return;
-            const ack = await connection.command("turn/start", {
-                sessionId,
-                input: [{ type: "text", text: options.prompt }],
-                ...(options.reasoningEffort ? { reasoningEffort: options.reasoningEffort } : {}),
-            }, { maxAttempts: 1 });
-            if (typeof ack.turnId !== "string" || ack.disposition !== "started")
-                throw new Error("Muse did not start the requested turn.");
-            turnId = ack.turnId;
-            for (const notification of pending.splice(0))
-                consume(notification);
-            await Promise.race([completed.promise, connection.closed]);
-            if (!terminal && !timedOut && !killedByLeaseLoss)
-                throw new Error("Muse closed before the turn completed.");
+            const startTurn = async (text) => {
+                const ack = await connection.command("turn/start", {
+                    sessionId,
+                    input: [{ type: "text", text }],
+                    ...(options.reasoningEffort ? { reasoningEffort: options.reasoningEffort } : {}),
+                }, { maxAttempts: 1 });
+                if (typeof ack.turnId !== "string" || ack.disposition !== "started")
+                    throw new Error("Muse did not start the requested turn.");
+                turnId = ack.turnId;
+                for (const notification of pending.splice(0))
+                    consume(notification);
+            };
+            const channel = {
+                send: () => false,
+                // Native interrupt: cancel the running turn on this connection. The
+                // host stays up; the run loop starts the next turn once this one ends.
+                interrupt: (input) => {
+                    if (!turnId || terminal || pendingInterrupt || cancelling || timedOut || killedByLeaseLoss || protocolFailed)
+                        return false;
+                    pendingInterrupt = input;
+                    void connection.command("turn/cancel", { sessionId, turnId }, { maxAttempts: 1 }).catch(() => undefined);
+                    return true;
+                },
+            };
+            await startTurn(options.prompt);
+            options.liveInput?.attach(channel);
+            for (;;) {
+                await Promise.race([completed.promise, connection.closed]);
+                if (!terminal && !timedOut && !killedByLeaseLoss)
+                    throw new Error("Muse closed before the turn completed.");
+                const next = pendingInterrupt;
+                const endedCleanly = terminal?.terminal === "cancelled" || terminal?.terminal === "completed";
+                if (!next || !endedCleanly || timedOut || killedByLeaseLoss || protocolFailed)
+                    break;
+                // The cancelled turn is the interrupt, not a failure. A turn that
+                // finished before the cancel landed makes this a boundary delivery.
+                const stoppedTurn = terminal?.terminal === "cancelled";
+                pendingInterrupt = undefined;
+                sawTurn = true;
+                terminal = undefined;
+                turnId = undefined;
+                completed = deferred();
+                items.clear();
+                await startTurn(next.text);
+                // Teardown may have run while the ack was in flight; do not re-attach.
+                if (timedOut || killedByLeaseLoss || protocolFailed || cancelling)
+                    return;
+                options.liveInput?.consumed(next.id, !stoppedTurn, stoppedTurn);
+                options.liveInput?.attach(channel);
+            }
         };
         await Promise.race([run(), stopped.promise]);
     }
@@ -276,6 +319,7 @@ async function runMuseProcess(options, mcpServers, sdk) {
             diagnostic(error instanceof Error ? error.message : "Muse protocol request failed.");
     }
     finally {
+        options.liveInput?.attach(null);
         await cancelling;
         // EOF releases Muse's writer lease. A bounded shutdown always reaps the
         // child, including a host that ignores EOF or died during a request.
@@ -312,7 +356,7 @@ async function runMuseProcess(options, mcpServers, sdk) {
         timedOut, killedByLeaseLoss, stdout, stderr,
         ...(reportText ? { reportText } : {}),
         ...(authError ? { authError } : {}),
-        ...(durable && sessionId && terminal ? { agentSessionId: sessionId } : {}),
+        ...(durable && sessionId && (terminal || sawTurn) ? { agentSessionId: sessionId } : {}),
         ...normalizedUsage([...usage.values()], !options.resumeSessionId),
     };
 }
@@ -431,4 +475,4 @@ function spawnMuse(options) {
 }
 // Read-only Navi conversations are deliberately absent: an approval mode is
 // not a filesystem read boundary, and the SDK cannot yet prove that contract.
-exports.museAdapter = { agentType: "muse", run: runMuseAdapter, steering: types_cjs_1.TURN_RESTART_STEERING };
+exports.museAdapter = { agentType: "muse", run: runMuseAdapter, steering: MUSE_STEERING };

package/dist/session.cjs

@@ -914,8 +914,8 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
                         signal: turnAbort.signal,
                         // Native steering: the adapter keeps the agent's input open and
                         // reports each message the agent reads. Absent for every adapter
-                        // whose record says `steer: none`.
-                        liveInput: steering && steeringCapabilities?.steer === "native" ? steering.liveInput : undefined,
+                        // whose record says neither `steer: native` nor `interrupt: native`.
+                        liveInput: steering && (steeringCapabilities?.steer === "native" || steeringCapabilities?.interrupt === "native") ? steering.liveInput : undefined,
                         onProcessStarted: () => {
                             if (steeringTaken.length > 0 && !steeringTurnStarted) {
                                 clearTimeout(steeringStartTimer);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sagentlab/navarch-runtime",
-  "version": "0.1.132",
+  "version": "0.1.133",
   "description": "Navarch machine-side session manager: claims delivery tasks and runs them through local coding agents.",
   "type": "commonjs",
   "license": "MIT",