@pi-archimedes/subagent 2.7.3 → 2.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-archimedes/subagent",
-  "version": "2.7.3",
+  "version": "2.8.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/danielcherubini/pi-archimedes.git"
@@ -15,8 +15,8 @@
   ],
   "main": "./src/index.ts",
   "dependencies": {
-    "@pi-archimedes/core": "2.7.3",
-    "@pi-archimedes/todo": "2.7.3"
+    "@pi-archimedes/core": "2.8.0",
+    "@pi-archimedes/todo": "2.8.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": ">=0.1.0",

package/src/spawn.test.ts

@@ -0,0 +1,119 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import * as net from "node:net";
+import { getBus, Events } from "@pi-archimedes/core/bus";
+import { startAskSocketServer } from "./spawn.js";
+
+// startAskSocketServer is tested directly (not via spawnSubagent, which would
+// spawn a real `pi` process). The real bus is used — subscriptions are
+// unsubscribed in afterEach so they don't leak into other test files in the
+// same worker (the bus is a globalThis singleton).
+
+const cleanups: Array<() => void> = [];
+const unsubs: Array<() => void> = [];
+
+afterEach(() => {
+  unsubs.splice(0).forEach((u) => u());
+  cleanups.splice(0).forEach((c) => c());
+});
+
+function track(fn: () => void): void {
+  cleanups.push(fn);
+}
+
+function connectClient(socketPath: string): Promise<net.Socket> {
+  return new Promise((resolve, reject) => {
+    const client = net.connect(socketPath, () => resolve(client));
+    client.on("error", (err) => reject(err));
+  });
+}
+
+function writeAskRequest(client: net.Socket, requestId: string, toolCallId?: string): void {
+  client.write(
+    JSON.stringify({
+      type: "ask_request",
+      requestId,
+      toolCallId,
+      questions: [{ id: "q1", question: "Which?", options: [{ label: "A" }] }],
+    }) + "\n",
+  );
+}
+
+describe("startAskSocketServer", () => {
+  it("a child ask_request carrying toolCallId → the bus ASK_REQUEST carries the same toolCallId", async () => {
+    const { socketPath, cleanup } = startAskSocketServer("test-agent");
+    track(cleanup);
+    await new Promise((r) => setTimeout(r, 50)); // let the server listen
+
+    const requests: unknown[] = [];
+    unsubs.push(getBus().on(Events.ASK_REQUEST, (p) => requests.push(p)));
+
+    const client = await connectClient(socketPath);
+    writeAskRequest(client, "req-1", "tool-9");
+
+    await vi.waitFor(() => expect(requests.length).toBe(1));
+    const req = requests[0] as { source: string; requestId: string; toolCallId?: string; questions: unknown[] };
+    expect(req.source).toBe("subagent:test-agent");
+    expect(req.requestId).toBe("req-1");
+    expect(req.toolCallId).toBe("tool-9");
+    expect(req.questions).toEqual([{ id: "q1", question: "Which?", options: [{ label: "A" }] }]);
+
+    // Deliver the response (drains pending) before closing so no ASK_CANCEL
+    // leaks onto the global bus queue for the next test
+    getBus().emit(Events.ASK_RESPONSE, {
+      requestId: "req-1",
+      cancelled: false,
+      results: [{ id: "q1", selectedOptions: ["A"] }],
+    });
+    await new Promise((r) => setTimeout(r, 50));
+    client.destroy();
+    await new Promise((r) => setTimeout(r, 50)); // close handler ran (no-op)
+  });
+
+  it("closing the child socket → ASK_CANCEL for the pending requestId + source", async () => {
+    const { socketPath, cleanup } = startAskSocketServer("test-agent");
+    track(cleanup);
+    await new Promise((r) => setTimeout(r, 50)); // let the server listen
+
+    const cancels: unknown[] = [];
+    unsubs.push(getBus().on(Events.ASK_CANCEL, (p) => cancels.push(p)));
+    const requests: unknown[] = [];
+    unsubs.push(getBus().on(Events.ASK_REQUEST, (p) => requests.push(p)));
+
+    const client = await connectClient(socketPath);
+    writeAskRequest(client, "req-2");
+
+    // Wait until the request is registered (pending) before closing
+    await vi.waitFor(() => expect(requests.length).toBe(1));
+    client.destroy();
+
+    await vi.waitFor(() => expect(cancels.length).toBe(1));
+    expect(cancels[0]).toEqual({ requestId: "req-2", source: "subagent:test-agent" });
+  });
+
+  it("no ASK_CANCEL once the response has already been delivered (pending drained)", async () => {
+    const { socketPath, cleanup } = startAskSocketServer("test-agent");
+    track(cleanup);
+    await new Promise((r) => setTimeout(r, 50)); // let the server listen
+
+    const cancels: unknown[] = [];
+    unsubs.push(getBus().on(Events.ASK_CANCEL, (p) => cancels.push(p)));
+    const requests: unknown[] = [];
+    unsubs.push(getBus().on(Events.ASK_REQUEST, (p) => requests.push(p)));
+
+    const client = await connectClient(socketPath);
+    writeAskRequest(client, "req-3");
+    await vi.waitFor(() => expect(requests.length).toBe(1));
+
+    // Deliver the response (drains pending) before the socket closes
+    getBus().emit(Events.ASK_RESPONSE, {
+      requestId: "req-3",
+      cancelled: false,
+      results: [{ id: "q1", selectedOptions: ["A"] }],
+    });
+    await new Promise((r) => setTimeout(r, 50));
+    client.destroy();
+    await new Promise((r) => setTimeout(r, 50)); // close handler ran
+
+    expect(cancels.length).toBe(0);
+  });
+});

package/src/spawn.ts

@@ -67,17 +67,22 @@ function resolvePiBinary(): string {
  * Start a Unix socket server that bridges the child's ask tool to the parent bus.
  *
  * The child's ask tool (in packages/ask) connects to PI_SUBAGENT_SOCKET and sends:
- *   { type: "ask_request", requestId, questions } as a JSON line
+ *   { type: "ask_request", requestId, questions, toolCallId } as a JSON line
  * and waits for:
  *   { type: "ask_response", requestId, cancelled, results } as a JSON line
  *
- * We forward the request onto the bus (ASK_REQUEST), the ask package shows the
- * parent TUI dialog, then emits ASK_RESPONSE on the bus, and we write it back
- * to the socket connection.
+ * We forward the request onto the bus (ASK_REQUEST, carrying toolCallId), the
+ * ask package (or the bridge, in bridge mode) answers it, then emits
+ * ASK_RESPONSE on the bus, and we write it back to the socket connection.
+ *
+ * When the socket closes (child exit, or the child's own 5-min timeout →
+ * socket.end()) we signal the bridge via ASK_CANCEL for any still-pending ask.
+ * We do NOT emit ASK_RESPONSE ourselves — the bridge is the sole emitter
+ * (no double-decrement of its refcount).
  *
  * Returns the socket path and a cleanup function.
  */
-function startAskSocketServer(agentName: string): { socketPath: string; cleanup: () => void } {
+export function startAskSocketServer(agentName: string): { socketPath: string; cleanup: () => void } {
   // Use named pipes on Windows, Unix domain sockets elsewhere.
   // Linux socket path limit is 108 chars — keep it short.
   const id = randomUUID().slice(0, 8);
@@ -110,6 +115,8 @@ function startAskSocketServer(agentName: string): { socketPath: string; cleanup:
 
   const server = net.createServer((socket) => {
     let buffer = "";
+    // requestIds seen on this socket (for the ASK_CANCEL wiring below)
+    const socketRequestIds = new Set<string>();
 
     socket.on("data", (chunk: Buffer) => {
       buffer += chunk.toString("utf-8");
@@ -124,6 +131,7 @@ function startAskSocketServer(agentName: string): { socketPath: string; cleanup:
             type: string;
             requestId: string;
             questions: unknown[];
+            toolCallId?: string;
           };
           if (msg.type === "ask_request") {
             // Register write-back so ASK_RESPONSE handler can find this socket
@@ -134,11 +142,14 @@ function startAskSocketServer(agentName: string): { socketPath: string; cleanup:
                 // socket already closed
               }
             });
-            // Forward to bus — ask package will show the TUI dialog
+            socketRequestIds.add(msg.requestId);
+            // Forward to bus — the ask package (or the bridge, in bridge mode)
+            // answers it; toolCallId rides along for Client correlation
             getBus().emit(Events.ASK_REQUEST, {
               source: `subagent:${agentName}`,
               requestId: msg.requestId,
               questions: msg.questions,
+              toolCallId: msg.toolCallId,
             });
           }
         } catch {
@@ -147,6 +158,19 @@ function startAskSocketServer(agentName: string): { socketPath: string; cleanup:
       }
     });
 
+    // Child exit (or the child's own 5-min timeout → socket.end()) closes the
+    // socket: signal the bridge via ASK_CANCEL for any still-pending ask so it
+    // can cancel the relayed Client request. We only signal — the bridge is
+    // the sole ASK_RESPONSE emitter (no double-decrement of its refcount).
+    socket.on("close", () => {
+      for (const rid of socketRequestIds) {
+        if (pending.has(rid)) {
+          getBus().emit(Events.ASK_CANCEL, { requestId: rid, source: `subagent:${agentName}` });
+          pending.delete(rid);
+        }
+      }
+    });
+
     socket.on("error", () => { /* connection dropped */ });
   });
 
@@ -245,7 +269,12 @@ export function spawnSubagent(options: SpawnOptions): ChildProcess {
         forceKill.unref();
       }
     };
-    options.signal.addEventListener("abort", abortHandler, { once: true });
+    // A signal that is ALREADY aborted never dispatches its "abort" event (it
+    // fires exactly once, at abort time), so addEventListener alone would never
+    // kill the child — call the handler directly in that case. (kill is
+    // idempotent via the child.killed guard, so both branches coexist safely.)
+    if (options.signal.aborted) abortHandler();
+    else options.signal.addEventListener("abort", abortHandler, { once: true });
     child.on("exit", () => options.signal!.removeEventListener("abort", abortHandler));
   }