@desplega.ai/agent-swarm 1.100.0 → 1.100.1

package/openapi.json

@@ -2,7 +2,7 @@
   "openapi": "3.1.0",
   "info": {
     "title": "Agent Swarm API",
-    "version": "1.100.0",
+    "version": "1.100.1",
     "description": "Multi-agent orchestration API for Claude Code, Codex, and Gemini CLI. Enables task distribution, agent communication, and service discovery.\n\nMCP tools are documented separately in [MCP.md](./MCP.md)."
   },
   "servers": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@desplega.ai/agent-swarm",
-  "version": "1.100.0",
+  "version": "1.100.1",
   "description": "Multi-agent orchestration for Claude Code, Codex, Gemini CLI, and other AI coding assistants",
   "license": "MIT",
   "author": "desplega.sh <contact@desplega.sh>",

package/src/commands/runner.ts

@@ -1451,7 +1451,7 @@ function setupShutdownHandlers(
         );
         for (const [taskId, task] of state.activeTasks) {
           console.log(`[${role}] Superseding task ${taskId.slice(0, 8)}`);
-          task.session.abort().catch(() => {});
+          task.session.abort("graceful_shutdown").catch(() => {});
           if (apiConfig) {
             const supersede = await supersedeTaskViaAPI(
               apiConfig,
@@ -4706,7 +4706,7 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
               console.log(
                 `[${role}] Task ${taskId.slice(0, 8)} was cancelled — sending SIGTERM to subprocess`,
               );
-              task.session.abort().catch(() => {});
+              task.session.abort("cancelled").catch(() => {});
               cancelledSignaled.add(taskId);
             }
           }

package/src/providers/codex-adapter.ts

@@ -519,9 +519,9 @@ export class CodexSession implements ProviderSession {
     return this.completionPromise;
   }
 
-  async abort(): Promise<void> {
+  async abort(reason?: string): Promise<void> {
     this.aborted = true;
-    this.abortController?.abort();
+    this.abortController?.abort(reason ?? "cancelled");
   }
 
   private emit(event: ProviderEvent): void {
@@ -992,6 +992,14 @@ export class CodexSession implements ProviderSession {
       } catch (err) {
         // AbortError from the SDK propagates here when signal.abort() fires.
         if (this.aborted || (err instanceof Error && err.name === "AbortError")) {
+          // Prefer the abort reason from the signal (set by the caller of
+          // abort()) — this distinguishes tool-loop aborts from cancel-poll
+          // and graceful-shutdown aborts that all used to produce a bare
+          // "cancelled" failureReason.
+          const abortReason =
+            typeof this.abortController?.signal.reason === "string"
+              ? this.abortController.signal.reason
+              : "cancelled";
           const cost = this.buildCostData(this.lastUsage, true);
           this.emit({ type: "result", cost, isError: true, errorCategory: "cancelled" });
           this.settle({
@@ -999,7 +1007,7 @@ export class CodexSession implements ProviderSession {
             sessionId: this._sessionId,
             cost,
             isError: true,
-            failureReason: "cancelled",
+            failureReason: abortReason,
           });
           return;
         }

package/src/providers/swarm-events-shared.ts

@@ -126,7 +126,7 @@ export function createSwarmEventHandler(
           console.log(
             `[swarm-events] aborting task ${taskId}: cancelled via /cancelled-tasks poll`,
           );
-          opts.abortRef.current?.abort();
+          opts.abortRef.current?.abort("cancelled");
           if (opts.onCancel) {
             try {
               await opts.onCancel();
@@ -152,10 +152,9 @@ export function createSwarmEventHandler(
           // was indistinguishable from a /cancelled-tasks abort or a runner
           // SIGTERM. `result.reason` already carries the diagnostic detail
           // ("Tool X called 15 times…", "ping-pong between A and B…").
-          console.log(
-            `[swarm-events] aborting task ${taskId}: tool-loop detected — ${result.reason ?? "unknown reason"}`,
-          );
-          opts.abortRef.current?.abort();
+          const loopReason = `tool-loop: ${result.reason ?? "unknown reason"}`;
+          console.log(`[swarm-events] aborting task ${taskId}: ${loopReason}`);
+          opts.abortRef.current?.abort(loopReason);
         }
       })
       .catch(() => {});

package/src/providers/types.ts

@@ -118,7 +118,7 @@ export interface ProviderSession {
   readonly sessionId: string | undefined;
   onEvent(listener: (event: ProviderEvent) => void): void;
   waitForCompletion(): Promise<ProviderResult>;
-  abort(): Promise<void>;
+  abort(reason?: string): Promise<void>;
 }
 
 /** Result returned when a provider session completes. */

package/src/tests/codex-swarm-events.test.ts

@@ -97,6 +97,30 @@ describe("createCodexSwarmEventHandler", () => {
       expect(controller.signal.aborted).toBe(true);
     });
 
+    test("sets abort signal reason to 'cancelled' on cancel-poll abort", async () => {
+      installFetchStub((url) => {
+        if (url.includes("/cancelled-tasks")) {
+          return new Response(
+            JSON.stringify({ cancelled: [{ id: "task-1", failureReason: "user request" }] }),
+            { status: 200 },
+          );
+        }
+        return new Response("{}", { status: 200 });
+      });
+      const controller = new AbortController();
+      const opts = buildOpts({ abortRef: { current: controller } });
+      const handler = createCodexSwarmEventHandler(opts);
+      handler({
+        type: "tool_start",
+        toolCallId: "call-1",
+        toolName: "bash",
+        args: { command: "sleep 9999" },
+      });
+      await new Promise((resolve) => setTimeout(resolve, 30));
+      expect(controller.signal.aborted).toBe(true);
+      expect(controller.signal.reason).toBe("cancelled");
+    });
+
     test("logs the abort reason when /cancelled-tasks reports the task", async () => {
       installFetchStub((url) => {
         if (url.includes("/cancelled-tasks")) {