@sagentlab/navarch-runtime 0.1.133 → 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/package.json

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