chainlesschain 0.45.66 → 0.45.67

package/src/lib/abort-utils.js

@@ -0,0 +1,20 @@
+export function createAbortError(message = "Agent loop interrupted") {
+  const error = new Error(message);
+  error.name = "AbortError";
+  return error;
+}
+
+export function isAbortError(error) {
+  return (
+    error?.name === "AbortError" ||
+    error?.code === "ABORT_ERR" ||
+    (typeof error?.message === "string" &&
+      /aborted|interrupted/i.test(error.message))
+  );
+}
+
+export function throwIfAborted(signal, message = "Agent loop interrupted") {
+  if (signal?.aborted) {
+    throw signal.reason || createAbortError(message);
+  }
+}

package/src/lib/agent-core.js

@@ -33,6 +33,7 @@ import {
 import { createToolContext } from "../tools/tool-context.js";
 import { createToolTelemetryRecord } from "../tools/tool-telemetry.js";
 import { DEFAULT_TOOL_DESCRIPTORS } from "../tools/registry.js";
+import { isAbortError, throwIfAborted } from "./abort-utils.js";
 
 const { isReadOnlyGitCommand, normalizeGitCommand } = sharedCodingAgentPolicy;
 const { evaluateShellCommandPolicy } = sharedShellPolicy;
@@ -719,6 +720,7 @@ export async function executeTool(name, args, context = {}) {
       cwd,
       parentMessages: context.parentMessages,
       interaction: context.interaction,
+      sessionId: context.sessionId || null,
       hostManagedToolPolicy: context.hostManagedToolPolicy || null,
       externalToolDescriptors: context.externalToolDescriptors || null,
       externalToolExecutors: context.externalToolExecutors || null,
@@ -784,6 +786,7 @@ async function executeToolInner(
     cwd,
     parentMessages,
     interaction,
+    sessionId,
     hostManagedToolPolicy,
     externalToolDescriptors,
     externalToolExecutors,
@@ -957,7 +960,13 @@ async function executeToolInner(
 
     case "spawn_sub_agent": {
       return attachDescriptor(
-        await _executeSpawnSubAgent(args, { skillLoader, cwd, parentMessages }),
+        await _executeSpawnSubAgent(args, {
+          skillLoader,
+          cwd,
+          parentMessages,
+          interaction,
+          sessionId,
+        }),
       );
     }
 
@@ -1393,7 +1402,7 @@ async function _executeRunCode(args, cwd) {
  * Creates an isolated SubAgentContext, runs it, and returns only the summary.
  *
  * @param {object} args - { role, task, context?, tools? }
- * @param {object} ctx - { skillLoader, cwd }
+ * @param {object} ctx - { skillLoader, cwd, parentMessages, interaction, sessionId }
  * @returns {Promise<object>}
  */
 async function _executeSpawnSubAgent(args, ctx) {
@@ -1415,14 +1424,35 @@ async function _executeSpawnSubAgent(args, ctx) {
     }
   }
 
+  // Link child to parent session so registry-scoped queries and
+  // session-close cascade cleanup can find it.
+  const parentSessionId = ctx.sessionId || null;
+  const interaction = ctx.interaction || null;
+
   const subCtx = SubAgentContext.create({
     role,
     task,
+    parentId: parentSessionId,
     inheritedContext: resolvedContext,
     allowedTools: allowedTools || null,
     cwd: ctx.cwd,
   });
 
+  const emit = (type, payload) => {
+    if (!interaction || typeof interaction.emit !== "function") return;
+    try {
+      interaction.emit(type, {
+        sessionId: parentSessionId,
+        subAgentId: subCtx.id,
+        parentSessionId,
+        role: subCtx.role,
+        ...payload,
+      });
+    } catch (_err) {
+      // Event emission is best-effort — never break the tool call
+    }
+  };
+
   try {
     // Notify registry if available
     const { SubAgentRegistry } = await import("./sub-agent-registry.js").catch(
@@ -1436,6 +1466,13 @@ async function _executeSpawnSubAgent(args, ctx) {
       }
     }
 
+    emit("sub-agent.started", {
+      task: subCtx.task,
+      allowedTools: allowedTools || null,
+      maxIterations: subCtx.maxIterations,
+      createdAt: subCtx.createdAt,
+    });
+
     const result = await subCtx.run(task);
 
     // Complete in registry
@@ -1447,10 +1484,21 @@ async function _executeSpawnSubAgent(args, ctx) {
       }
     }
 
+    emit("sub-agent.completed", {
+      status: subCtx.status,
+      summary: result.summary,
+      toolsUsed: result.toolsUsed,
+      iterationCount: result.iterationCount,
+      tokenCount: result.tokenCount,
+      artifactCount: result.artifacts.length,
+      completedAt: subCtx.completedAt,
+    });
+
     return {
       success: true,
       subAgentId: subCtx.id,
       role: subCtx.role,
+      parentSessionId,
       summary: result.summary,
       toolsUsed: result.toolsUsed,
       iterationCount: result.iterationCount,
@@ -1458,10 +1506,18 @@ async function _executeSpawnSubAgent(args, ctx) {
     };
   } catch (err) {
     subCtx.forceComplete(err.message);
+
+    emit("sub-agent.failed", {
+      status: subCtx.status,
+      error: err.message,
+      completedAt: subCtx.completedAt,
+    });
+
     return {
       error: `Sub-agent failed: ${err.message}`,
       subAgentId: subCtx.id,
       role: subCtx.role,
+      parentSessionId,
     };
   }
 }
@@ -1477,7 +1533,14 @@ async function _executeSpawnSubAgent(args, ctx) {
  * @returns {Promise<object>} response with .message
  */
 export async function chatWithTools(rawMessages, options) {
-  const { provider, model, baseUrl, apiKey, contextEngine: ce } = options;
+  const {
+    provider,
+    model,
+    baseUrl,
+    apiKey,
+    contextEngine: ce,
+    signal,
+  } = options;
 
   const persona = _loadProjectPersona(options.cwd);
   const tools = getAgentToolDefinitions({
@@ -1496,10 +1559,13 @@ export async function chatWithTools(rawMessages, options) {
       })
     : rawMessages;
 
+  throwIfAborted(signal);
+
   if (provider === "ollama") {
     const response = await fetch(`${baseUrl}/api/chat`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
+      signal,
       body: JSON.stringify({
         model,
         messages,
@@ -1548,6 +1614,7 @@ export async function chatWithTools(rawMessages, options) {
         "x-api-key": key,
         "anthropic-version": "2023-06-01",
       },
+      signal,
       body: JSON.stringify(body),
     });
 
@@ -1608,6 +1675,7 @@ export async function chatWithTools(rawMessages, options) {
       "Content-Type": "application/json",
       Authorization: `Bearer ${key}`,
     },
+    signal,
     body: JSON.stringify({
       model: model || defaultModels[provider] || "gpt-4o-mini",
       messages,
@@ -1667,6 +1735,7 @@ function _normalizeAnthropicResponse(data) {
  */
 export async function* agentLoop(messages, options) {
   const MAX_ITERATIONS = 15;
+  const signal = options.signal || null;
   const toolContext = {
     hookDb: options.hookDb || null,
     skillLoader: options.skillLoader || _defaultSkillLoader,
@@ -1681,6 +1750,8 @@ export async function* agentLoop(messages, options) {
     interaction: options.interaction || null,
   };
 
+  throwIfAborted(signal);
+
   // ── Slot-filling phase ──────────────────────────────────────────────
   // Before calling the LLM, check if the user's message matches a known
   // intent with missing required parameters. If so, interactively fill them
@@ -1721,14 +1792,19 @@ export async function* agentLoop(messages, options) {
             }
           }
         }
-      } catch (_err) {
+      } catch (error) {
+        if (isAbortError(error) || signal?.aborted) {
+          throw error;
+        }
         // Slot-filling failure is non-critical — proceed to LLM
       }
     }
   }
 
   for (let i = 0; i < MAX_ITERATIONS; i++) {
+    throwIfAborted(signal);
     const result = await chatWithTools(messages, options);
+    throwIfAborted(signal);
     const msg = result?.message;
 
     if (!msg) {
@@ -1747,6 +1823,7 @@ export async function* agentLoop(messages, options) {
     messages.push(msg);
 
     for (const call of toolCalls) {
+      throwIfAborted(signal);
       const fn = call.function;
       const toolName = fn.name;
       let toolArgs;
@@ -1771,6 +1848,8 @@ export async function* agentLoop(messages, options) {
         toolError = err.message;
       }
 
+      throwIfAborted(signal);
+
       yield {
         type: "tool-result",
         tool: toolName,

package/src/lib/interaction-adapter.js

@@ -13,6 +13,7 @@ import {
   CODING_AGENT_EVENT_TYPES,
   LEGACY_TO_UNIFIED_TYPE,
 } from "../runtime/runtime-events.js";
+import { createAbortError } from "./abort-utils.js";
 
 // Whitelist of event types the CLI runtime should emit as unified envelopes
 // (with source: "cli-runtime"). Anything not in this set keeps the legacy
@@ -104,7 +105,7 @@ export class WebSocketInteractionAdapter extends InteractionAdapter {
     super();
     this.ws = ws;
     this.sessionId = sessionId;
-    /** @type {Map<string, {resolve: Function, reject: Function}>} */
+    /** @type {Map<string, {resolve: Function, reject: Function, timeoutId: ReturnType<typeof setTimeout>|null}>} */
     this._pending = new Map();
     // Per-instance sequence tracker so monotonic sequences are scoped to
     // this WS session instead of leaking across sessions via the process-
@@ -127,24 +128,24 @@ export class WebSocketInteractionAdapter extends InteractionAdapter {
   _request(message, options = {}) {
     return new Promise((resolve, reject) => {
       const requestId = this._requestId();
-      this._pending.set(requestId, { resolve, reject });
+      const timeoutId = setTimeout(
+        () => {
+          const pending = this._pending.get(requestId);
+          if (!pending) {
+            return;
+          }
+          this._pending.delete(requestId);
+          reject(new Error("Question timed out"));
+        },
+        options.timeoutMs || 5 * 60 * 1000,
+      );
+      this._pending.set(requestId, { resolve, reject, timeoutId });
 
       this._sendWs({
         ...message,
         sessionId: this.sessionId,
         requestId,
       });
-
-      // Timeout after 5 minutes
-      setTimeout(
-        () => {
-          if (this._pending.has(requestId)) {
-            this._pending.delete(requestId);
-            reject(new Error("Question timed out"));
-          }
-        },
-        options.timeoutMs || 5 * 60 * 1000,
-      );
     });
   }
 
@@ -179,11 +180,7 @@ export class WebSocketInteractionAdapter extends InteractionAdapter {
    * Resolves the corresponding pending promise.
    */
   resolveAnswer(requestId, answer) {
-    const pending = this._pending.get(requestId);
-    if (pending) {
-      this._pending.delete(requestId);
-      pending.resolve(answer);
-    }
+    this._resolvePending(requestId, answer);
   }
 
   async requestHostTool(toolName, args = {}, extra = {}) {
@@ -199,10 +196,19 @@ export class WebSocketInteractionAdapter extends InteractionAdapter {
   }
 
   resolveHostTool(requestId, payload) {
-    const pending = this._pending.get(requestId);
-    if (pending) {
+    this._resolvePending(requestId, payload);
+  }
+
+  rejectAllPending(reason = createAbortError("Interaction interrupted")) {
+    const error =
+      reason instanceof Error ? reason : createAbortError(String(reason));
+
+    for (const [requestId, pending] of this._pending.entries()) {
       this._pending.delete(requestId);
-      pending.resolve(payload);
+      if (pending.timeoutId) {
+        clearTimeout(pending.timeoutId);
+      }
+      pending.reject(error);
     }
   }
 
@@ -245,4 +251,17 @@ export class WebSocketInteractionAdapter extends InteractionAdapter {
       }
     }
   }
+
+  _resolvePending(requestId, payload) {
+    const pending = this._pending.get(requestId);
+    if (!pending) {
+      return;
+    }
+
+    this._pending.delete(requestId);
+    if (pending.timeoutId) {
+      clearTimeout(pending.timeoutId);
+    }
+    pending.resolve(payload);
+  }
 }

package/src/lib/sub-agent-registry.js

@@ -131,6 +131,40 @@ export class SubAgentRegistry {
     return [...this._active.values()].map((ctx) => ctx.toJSON());
   }
 
+  /**
+   * Get a single sub-agent snapshot by id — checks active first, then history.
+   * @param {string} id
+   * @returns {object|null}
+   */
+  getById(id) {
+    if (!id) return null;
+    const active = this._active.get(id);
+    if (active) return active.toJSON();
+    const historyEntry = this._completed
+      .toArray()
+      .find((record) => record.id === id);
+    return historyEntry || null;
+  }
+
+  /**
+   * Get active + recent sub-agents belonging to a parent session.
+   * Used by the WS sub-agent-list query and by UI consumers that need to
+   * render only the child agents spawned from a specific parent turn.
+   *
+   * @param {string} parentId
+   * @returns {{ active: Array<object>, history: Array<object> }}
+   */
+  getByParent(parentId) {
+    if (!parentId) return { active: [], history: [] };
+    const active = [...this._active.values()]
+      .filter((ctx) => ctx.parentId === parentId)
+      .map((ctx) => ctx.toJSON());
+    const history = this._completed
+      .toArray()
+      .filter((record) => record.parentId === parentId);
+    return { active, history };
+  }
+
   /**
    * Get completion history (most recent last).
    * @returns {Array<object>}

package/src/lib/ws-agent-handler.js

@@ -10,6 +10,7 @@ import { agentLoop, formatToolArgs } from "./agent-core.js";
 import { detectTaskType, selectModelForTask } from "./task-model-selector.js";
 import { PlanState } from "./plan-mode.js";
 import { CLISlotFiller } from "./slot-filler.js";
+import { createAbortError, isAbortError } from "./abort-utils.js";
 
 export class WSAgentHandler {
   /**
@@ -23,6 +24,8 @@ export class WSAgentHandler {
     this.interaction = interaction;
     this.db = db || null;
     this._processing = false;
+    this._abortController = null;
+    this._activeRequestId = null;
   }
 
   /**
@@ -42,6 +45,9 @@ export class WSAgentHandler {
     }
 
     this._processing = true;
+    const abortController = new AbortController();
+    this._abortController = abortController;
+    this._activeRequestId = requestId || null;
 
     try {
       const { session } = this;
@@ -93,6 +99,7 @@ export class WSAgentHandler {
         mcpClient: session.mcpClient || null,
         slotFiller,
         interaction: this.interaction,
+        signal: abortController.signal,
       };
 
       for await (const event of agentLoop(session.messages, loopOptions)) {
@@ -141,6 +148,10 @@ export class WSAgentHandler {
       // Update last activity
       session.lastActivity = new Date().toISOString();
     } catch (err) {
+      if (isAbortError(err) || abortController.signal.aborted) {
+        return;
+      }
+
       this.interaction.emit("error", {
         requestId,
         code: "AGENT_ERROR",
@@ -156,6 +167,43 @@ export class WSAgentHandler {
       }
     } finally {
       this._processing = false;
+      if (this._abortController === abortController) {
+        this._abortController = null;
+      }
+      if (this._activeRequestId === requestId) {
+        this._activeRequestId = null;
+      }
+    }
+  }
+
+  async interrupt() {
+    const wasProcessing = this._processing;
+    const interruptedRequestId = this._activeRequestId || null;
+    const reason = createAbortError("Session interrupted by client");
+
+    if (this._abortController && !this._abortController.signal.aborted) {
+      this._abortController.abort(reason);
+    }
+
+    if (typeof this.interaction?.rejectAllPending === "function") {
+      this.interaction.rejectAllPending(reason);
+    }
+
+    return {
+      sessionId: this.session?.id || null,
+      interrupted: true,
+      wasProcessing,
+      interruptedRequestId,
+    };
+  }
+
+  destroy() {
+    const reason = createAbortError("Session closed");
+    if (this._abortController && !this._abortController.signal.aborted) {
+      this._abortController.abort(reason);
+    }
+    if (typeof this.interaction?.rejectAllPending === "function") {
+      this.interaction.rejectAllPending(reason);
     }
   }
 

package/src/lib/ws-server.js

@@ -28,8 +28,19 @@ import {
   handleSessionPolicyUpdate,
   handleSessionList,
   handleSessionClose,
+  handleSessionInterrupt,
   handleSessionAnswer,
   handleHostToolResult,
+  handleSubAgentList,
+  handleSubAgentGet,
+  handleReviewEnter,
+  handleReviewSubmit,
+  handleReviewResolve,
+  handleReviewStatus,
+  handlePatchPropose,
+  handlePatchApply,
+  handlePatchReject,
+  handlePatchSummary,
 } from "../gateways/ws/session-protocol.js";
 import {
   handleSlashCommand,
@@ -599,6 +610,11 @@ export class ChainlessChainWSServer extends EventEmitter {
     return handleSessionClose(this, id, ws, message);
   }
 
+  /** @private */
+  _handleSessionInterrupt(id, ws, message) {
+    return handleSessionInterrupt(this, id, ws, message);
+  }
+
   /** @private */
   _handleSlashCommand(id, ws, message) {
     return handleSlashCommand(this, id, ws, message);
@@ -613,6 +629,56 @@ export class ChainlessChainWSServer extends EventEmitter {
     return handleHostToolResult(this, id, ws, message);
   }
 
+  /** @private */
+  _handleSubAgentList(id, ws, message) {
+    return handleSubAgentList(this, id, ws, message);
+  }
+
+  /** @private */
+  _handleSubAgentGet(id, ws, message) {
+    return handleSubAgentGet(this, id, ws, message);
+  }
+
+  /** @private */
+  _handleReviewEnter(id, ws, message) {
+    return handleReviewEnter(this, id, ws, message);
+  }
+
+  /** @private */
+  _handleReviewSubmit(id, ws, message) {
+    return handleReviewSubmit(this, id, ws, message);
+  }
+
+  /** @private */
+  _handleReviewResolve(id, ws, message) {
+    return handleReviewResolve(this, id, ws, message);
+  }
+
+  /** @private */
+  _handleReviewStatus(id, ws, message) {
+    return handleReviewStatus(this, id, ws, message);
+  }
+
+  /** @private */
+  _handlePatchPropose(id, ws, message) {
+    return handlePatchPropose(this, id, ws, message);
+  }
+
+  /** @private */
+  _handlePatchApply(id, ws, message) {
+    return handlePatchApply(this, id, ws, message);
+  }
+
+  /** @private */
+  _handlePatchReject(id, ws, message) {
+    return handlePatchReject(this, id, ws, message);
+  }
+
+  /** @private */
+  _handlePatchSummary(id, ws, message) {
+    return handlePatchSummary(this, id, ws, message);
+  }
+
   /** @private — ping/pong heartbeat to detect dead connections */
   async _ensureTaskManager() {
     if (this._taskManager) return this._taskManager;