@sagentlab/navarch-runtime 0.1.132 → 0.1.134

package/dist/adapters/acp.cjs

@@ -1,9 +1,14 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.acpAdapter = void 0;
 exports.runAcpAdapter = runAcpAdapter;
+exports.probeAcpSteering = probeAcpSteering;
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
+const node_os_1 = __importDefault(require("node:os"));
 const node_stream_1 = require("node:stream");
 const kill_agent_cjs_1 = require("../kill-agent.cjs");
 const types_cjs_1 = require("./types.cjs");
@@ -16,6 +21,21 @@ const types_cjs_1 = require("./types.cjs");
  * gets no chance to release what it is holding.
  */
 const CANCEL_GRACE_MS = 2_000;
+/** How long the steering probe waits for the agent to answer `initialize`. */
+const PROBE_TIMEOUT_MS = 10_000;
+/**
+ * What an ACP agent that answered the probe's `initialize` with protocol v1
+ * can do: `session/cancel` and a further `session/prompt` on the same session
+ * are core v1 methods, so an interrupt stops the running prompt and starts the
+ * next one on the held connection. ACP has no input into a running prompt, so
+ * steer stays `none`, and a queued message still waits for the session loop's
+ * turn boundary.
+ */
+const ACP_NATIVE_STEERING = Object.freeze({
+    steer: "none",
+    queue: "boundary",
+    interrupt: "native",
+});
 /**
  * Generic Agent Client Protocol v1 adapter. DeepSeek Harness is the default
  * implementation (`dsh --profile acp`), while NAVARCH_ACP_BIN and
@@ -36,19 +56,33 @@ async function runAcpAdapter(options) {
     const rawStdout = [];
     const stderr = [];
     const protocolInput = new node_stream_1.PassThrough();
-    const messages = [];
+    // Agent messages of the current prompt only: after an interrupt, the report
+    // is what the last prompt produced, not the text of the turn it cut short.
+    let messages = [];
     const thoughts = [];
     let costUsd;
     let timedOut = false;
     let killedByLeaseLoss = false;
     let sessionId;
     let stopReason;
-    // Resolved once the in-flight prompt request settles, however it settles, so
+    // Settles once the in-flight prompt request settles, however it settles, so
     // cancellation can wait for the agent instead of racing the kill.
-    let settlePrompt = () => undefined;
-    const promptSettled = new Promise((resolve) => {
-        settlePrompt = resolve;
-    });
+    let promptSettled = Promise.resolve();
+    // Native interrupt (docs/navarch/live-steering.md section 5.3, row `acp`).
+    const live = options.liveInput;
+    let attached = false;
+    let promptRunning = false;
+    // This adapter sent `session/cancel` to stop the running prompt for an interrupt.
+    let interruptCancelSent = false;
+    // Interrupt inputs that wait for the running prompt to return, in the order they were sent.
+    const held = [];
+    const detach = () => {
+        if (!attached)
+            return;
+        attached = false;
+        held.length = 0;
+        live?.attach(null);
+    };
     child.stdout.on("data", (chunk) => {
         options.onActivity?.();
         rawStdout.push(chunk);
@@ -86,6 +120,9 @@ async function runAcpAdapter(options) {
     const controller = new AbortController();
     let abortProtocol = Promise.resolve();
     controller.signal.addEventListener("abort", () => {
+        // A timeout, lease loss or task cancel ends the session: no interrupt may
+        // start another prompt, and the session takes back what was not sent.
+        detach();
         abortProtocol = (async () => {
             if (sessionId) {
                 await connection.agent.notify(acp.methods.agent.session.cancel, { sessionId }).catch(() => undefined);
@@ -110,7 +147,7 @@ async function runAcpAdapter(options) {
         onAbort();
     try {
         const context = connection.agent;
-        await context.request(acp.methods.agent.initialize, {
+        const initialized = await context.request(acp.methods.agent.initialize, {
             protocolVersion: acp.PROTOCOL_VERSION,
             clientCapabilities: {},
         });
@@ -122,17 +159,68 @@ async function runAcpAdapter(options) {
         let configOptions = created.configOptions ?? [];
         configOptions = await setConfigOption(context, acp.methods.agent.session.setConfigOption, sessionId, configOptions, "model", options.model === "default" ? undefined : options.model);
         await setConfigOption(context, acp.methods.agent.session.setConfigOption, sessionId, configOptions, "reasoning_effort", options.reasoningEffort);
-        let response;
-        try {
-            response = await context.request(acp.methods.agent.session.prompt, {
-                sessionId,
-                prompt: [{ type: "text", text: options.prompt }],
+        // The probe saw protocol v1; an agent that now answers another version
+        // takes no interrupt, which then waits for the turn boundary.
+        if (live && initialized.protocolVersion === acp.PROTOCOL_VERSION && !controller.signal.aborted) {
+            const activeSessionId = sessionId;
+            attached = true;
+            live.attach({
+                // ACP has no input into a running prompt.
+                send: () => false,
+                interrupt: (input) => {
+                    if (!attached)
+                        return false;
+                    held.push(input);
+                    if (promptRunning && !interruptCancelSent) {
+                        interruptCancelSent = true;
+                        void connection.agent.notify(acp.methods.agent.session.cancel, { sessionId: activeSessionId })
+                            .catch(() => undefined);
+                    }
+                    return true;
+                },
             });
         }
-        finally {
-            settlePrompt();
+        let prompt = [{ type: "text", text: options.prompt }];
+        // The interrupt inputs `prompt` carries, and whether the first one stopped a prompt.
+        let carried = null;
+        for (;;) {
+            messages = [];
+            promptRunning = true;
+            interruptCancelSent = false;
+            const request = context.request(acp.methods.agent.session.prompt, { sessionId, prompt });
+            promptSettled = request.then(() => undefined, () => undefined);
+            // An interrupt that was waiting when the channel attached (steering hands
+            // it over at once) arrived before the first prompt ran: stop that prompt.
+            if (held.length > 0 && !interruptCancelSent) {
+                interruptCancelSent = true;
+                void context.notify(acp.methods.agent.session.cancel, { sessionId }).catch(() => undefined);
+            }
+            if (carried) {
+                // The agent reads it as the next prompt on the same session. ACP has no
+                // read receipt, and the ack cannot wait for the whole prompt, so the
+                // message counts as taken once its prompt is sent. The first input owns
+                // the stop; the rest were sent while it was pending.
+                carried.inputs.forEach((input, index) => live?.consumed(input.id, true, index === 0 && carried.stoppedTurn));
+                carried = null;
+            }
+            let response;
+            try {
+                response = await request;
+            }
+            finally {
+                promptRunning = false;
+            }
+            stopReason = response.stopReason;
+            // A `cancelled` prompt that an interrupt asked for is not the end of the
+            // session: the interrupt's prompt follows. One that a timeout, lease loss
+            // or task cancel asked for is.
+            if (controller.signal.aborted || held.length === 0)
+                break;
+            const inputs = held.splice(0);
+            carried = { inputs, stoppedTurn: interruptCancelSent && stopReason === "cancelled" };
+            prompt = inputs.map((input) => ({ type: "text", text: input.text }));
         }
-        stopReason = response.stopReason;
+        detach();
         await Promise.race([
             context.request(acp.methods.agent.session.close, { sessionId }).catch(() => undefined),
             new Promise((resolve) => setTimeout(resolve, options.timeoutMs > 0 ? Math.min(5_000, options.timeoutMs) : 5_000)),
@@ -143,6 +231,7 @@ async function runAcpAdapter(options) {
             stderr.push(`\n${describeError(error)}`);
     }
     finally {
+        detach();
         clearTimeout(timer);
         options.signal?.removeEventListener("abort", onAbort);
         await abortProtocol;
@@ -274,8 +363,87 @@ async function terminateChild(child, options, forceContainerKill) {
 function describeError(error) {
     return error instanceof Error ? `${error.name}: ${error.message}` : String(error);
 }
+/**
+ * Probe results by command line. A pass is kept for the life of the runtime. A
+ * failure is kept for a while only, because the agent may be installed or fixed
+ * later, and probing it again for every claim would delay each session by up
+ * to the probe timeout.
+ */
+const acpProbeCache = new Map();
+const PROBE_FAILURE_TTL_MS = 10 * 60_000;
+/**
+ * Native interrupt needs an agent that speaks ACP v1, where `session/cancel`
+ * and a further `session/prompt` on the same session are core methods. The
+ * probe starts the agent, sends `initialize`, and stops it. Only the host is
+ * probed: the probe has no sandbox container to reach the Docker agent, so
+ * Docker keeps `interrupt: restart`, as does an agent that fails to start,
+ * answers late, or reports another protocol version.
+ */
+async function probeAcpSteering(context) {
+    if (context.sandboxMode !== "host")
+        return null;
+    const key = JSON.stringify([context.bin, ...context.extraArgs]);
+    let probe = acpProbeCache.get(key);
+    if (!probe) {
+        probe = speaksAcpV1(context).catch(() => false);
+        acpProbeCache.set(key, probe);
+        const cached = probe;
+        void cached.then((passed) => {
+            if (passed)
+                return;
+            setTimeout(() => {
+                if (acpProbeCache.get(key) === cached)
+                    acpProbeCache.delete(key);
+            }, PROBE_FAILURE_TTL_MS).unref();
+        });
+    }
+    return (await probe) ? ACP_NATIVE_STEERING : null;
+}
+async function speaksAcpV1(context) {
+    const acp = await import("@agentclientprotocol/sdk");
+    const child = (0, node_child_process_1.spawn)(context.bin, context.extraArgs, {
+        detached: process.platform !== "win32",
+        // No session exists yet, so an agent that writes state at startup writes it
+        // in the temporary directory, not in the runtime's working directory.
+        cwd: node_os_1.default.tmpdir(),
+        env: { ...process.env, ...context.env },
+        stdio: ["pipe", "pipe", "ignore"],
+    });
+    const exited = new Promise((resolve) => {
+        child.once("error", () => resolve());
+        child.once("close", () => resolve());
+    });
+    child.stdin.on("error", () => undefined);
+    const connection = acp.client({ name: "navarch-runtime" }).connect(acp.ndJsonStream(node_stream_1.Writable.toWeb(child.stdin), node_stream_1.Readable.toWeb(child.stdout)));
+    let timer;
+    try {
+        return await Promise.race([
+            connection.agent.request(acp.methods.agent.initialize, {
+                protocolVersion: acp.PROTOCOL_VERSION,
+                clientCapabilities: {},
+            }).then((response) => response.protocolVersion === acp.PROTOCOL_VERSION, () => false),
+            exited.then(() => false),
+            new Promise((resolve) => {
+                timer = setTimeout(() => resolve(false), PROBE_TIMEOUT_MS);
+            }),
+        ]);
+    }
+    finally {
+        clearTimeout(timer);
+        connection.close();
+        if (child.exitCode === null && child.signalCode === null) {
+            (0, kill_agent_cjs_1.killAgent)(child, "SIGTERM");
+            await Promise.race([exited, new Promise((resolve) => setTimeout(resolve, 1_000))]);
+            if (child.exitCode === null && child.signalCode === null)
+                (0, kill_agent_cjs_1.killAgent)(child);
+        }
+    }
+}
 exports.acpAdapter = {
     agentType: "acp",
     run: runAcpAdapter,
+    // The claim's baseline record. The probe upgrades it to ACP_NATIVE_STEERING
+    // on a host whose agent speaks ACP v1.
     steering: types_cjs_1.TURN_RESTART_STEERING,
+    probeSteering: probeAcpSteering,
 };

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.134",
   "description": "Navarch machine-side session manager: claims delivery tasks and runs them through local coding agents.",
   "type": "commonjs",
   "license": "MIT",