@desplega.ai/agent-swarm 1.57.2 → 1.57.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@desplega.ai/agent-swarm",
-  "version": "1.57.2",
+  "version": "1.57.4",
   "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

@@ -128,7 +128,7 @@ async function ensureRepoForTask(
 }
 
 /** API configuration for ping/close */
-interface ApiConfig {
+export interface ApiConfig {
   apiUrl: string;
   apiKey: string;
   agentId: string;
@@ -401,11 +401,18 @@ async function updateProgressViaAPI(
  * - Claude adapter: runs a fallback extraction via `claude -p --json-schema`
  * - Pi-mono adapter: returns an error (no fallback available)
  */
-async function handleStructuredOutputFallback(
+export type FallbackResult =
+  | { kind: "extracted"; output: string }
+  | { kind: "already-has-output" }
+  | { kind: "no-schema"; lastProgress?: string }
+  | { kind: "schema-fail"; failReason: string }
+  | { kind: "fetch-error"; error: string };
+
+export async function handleStructuredOutputFallback(
   config: ApiConfig,
   taskId: string,
   adapterType: string,
-): Promise<{ output?: string; failReason?: string } | null> {
+): Promise<FallbackResult> {
   const headers: Record<string, string> = {
     "Content-Type": "application/json",
   };
@@ -416,23 +423,33 @@ async function handleStructuredOutputFallback(
   try {
     // Fetch the task to check for outputSchema
     const taskRes = await fetch(`${config.apiUrl}/api/tasks/${taskId}`, { headers });
-    if (!taskRes.ok) return null;
+    if (!taskRes.ok) return { kind: "fetch-error", error: `HTTP ${taskRes.status}` };
 
+    // Response is a flat spread of task fields + logs (see src/http/tasks.ts)
     const taskData = (await taskRes.json()) as {
-      task?: {
-        task?: string;
-        output?: string;
-        outputSchema?: Record<string, unknown>;
-      };
+      id?: string;
+      task?: string;
+      status?: string;
+      output?: string;
+      progress?: string;
+      outputSchema?: Record<string, unknown>;
       logs?: Array<{ eventType: string; newValue?: string; createdAt?: string }>;
     };
 
-    const task = taskData.task;
-    if (!task?.outputSchema) return null; // No schema — no fallback needed
-    if (task.output) return null; // Agent already stored valid output
+    if (!taskData.outputSchema) {
+      // No structured output required — extract last progress as context
+      const lastProgressLog = (taskData.logs ?? [])
+        .filter((l) => l.eventType === "task_progress")
+        .sort((a, b) => (b.createdAt ?? "").localeCompare(a.createdAt ?? ""))[0];
+      const lastProgress = lastProgressLog?.newValue ?? taskData.progress;
+      return { kind: "no-schema", lastProgress: lastProgress || undefined };
+    }
+
+    if (taskData.output) return { kind: "already-has-output" };
 
     if (adapterType !== "claude") {
       return {
+        kind: "schema-fail",
         failReason:
           "Structured output required by outputSchema but not provided via store-progress",
       };
@@ -450,36 +467,37 @@ async function handleStructuredOutputFallback(
     const extractionPrompt = `Extract structured data from this task's execution history.
 
 ## Task Description
-${task.task || "(no description)"}
+${taskData.task || "(no description)"}
 
 ## Progress Updates (chronological)
 ${progressEntries || "(no progress recorded)"}
 
 ## Required Output Schema
-${JSON.stringify(task.outputSchema, null, 2)}
+${JSON.stringify(taskData.outputSchema, null, 2)}
 
 Extract the structured data from the progress updates above. Return ONLY valid JSON matching the schema.`;
 
-    const schemaJson = JSON.stringify(task.outputSchema);
+    const schemaJson = JSON.stringify(taskData.outputSchema);
     const result =
       await Bun.$`claude -p ${extractionPrompt} --json-schema ${schemaJson} --output-format json --model sonnet`
         .json()
         .catch(() => null);
 
     if (result && typeof result === "object") {
-      return { output: JSON.stringify(result) };
+      return { kind: "extracted", output: JSON.stringify(result) };
     }
 
     return {
+      kind: "schema-fail",
       failReason: "Structured output extraction fallback failed — could not produce valid JSON",
     };
   } catch (err) {
     console.warn(`[runner] Structured output fallback failed for task ${taskId}: ${err}`);
-    return null;
+    return { kind: "fetch-error", error: String(err) };
   }
 }
 
-async function ensureTaskFinished(
+export async function ensureTaskFinished(
   config: ApiConfig,
   role: string,
   taskId: string,
@@ -506,15 +524,31 @@ async function ensureTaskFinished(
     const adapterType = process.env.HARNESS_PROVIDER || "claude";
     const fallback = await handleStructuredOutputFallback(config, taskId, adapterType);
 
-    if (fallback?.output) {
-      body.output = fallback.output;
-    } else if (fallback?.failReason) {
-      status = "failed";
-      body.status = "failed";
-      body.failureReason = fallback.failReason;
-    } else {
-      body.output =
-        "Process completed (runner wrapper fallback - agent may have provided explicit output)";
+    console.log(`[${role}] Task ${taskId.slice(0, 8)} fallback result: ${fallback.kind}`);
+
+    switch (fallback.kind) {
+      case "extracted":
+        body.output = fallback.output;
+        break;
+      case "already-has-output":
+        body.output = "Process completed successfully";
+        break;
+      case "no-schema": {
+        if (fallback.lastProgress) {
+          body.output = fallback.lastProgress.slice(0, 2000);
+        } else {
+          body.output = "Process completed successfully (no output captured)";
+        }
+        break;
+      }
+      case "schema-fail":
+        status = "failed";
+        body.status = "failed";
+        body.failureReason = fallback.failReason;
+        break;
+      case "fetch-error":
+        body.output = `Process completed (could not verify task state: ${fallback.error})`;
+        break;
     }
   }
 

package/src/tests/runner-fallback-output.test.ts

@@ -0,0 +1,298 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { createServer as createHttpServer, type Server } from "node:http";
+import {
+  type ApiConfig,
+  ensureTaskFinished,
+  type FallbackResult,
+  handleStructuredOutputFallback,
+} from "../commands/runner";
+
+const TEST_PORT = 13099;
+
+// Configurable mock responses per test
+let mockGetTask: Record<string, unknown> | null = null;
+let mockGetTaskStatus = 200;
+let lastFinishBody: Record<string, unknown> | null = null;
+let mockFinishResponse: Record<string, unknown> = { success: true };
+
+function resetMocks() {
+  mockGetTask = null;
+  mockGetTaskStatus = 200;
+  lastFinishBody = null;
+  mockFinishResponse = { success: true };
+}
+
+let server: Server;
+
+function makeConfig(port = TEST_PORT): ApiConfig {
+  return {
+    apiUrl: `http://localhost:${port}`,
+    apiKey: "test-key",
+    agentId: "test-agent-id",
+  };
+}
+
+beforeAll(async () => {
+  server = createHttpServer(async (req, res) => {
+    const chunks: Buffer[] = [];
+    for await (const chunk of req) {
+      chunks.push(chunk);
+    }
+    const body = Buffer.concat(chunks).toString();
+    const url = req.url || "";
+
+    // GET /api/tasks/:id
+    if (req.method === "GET" && /^\/api\/tasks\/[^/]+$/.test(url)) {
+      if (!mockGetTask) {
+        res.writeHead(mockGetTaskStatus);
+        res.end(JSON.stringify({ error: "Not found" }));
+        return;
+      }
+      res.writeHead(mockGetTaskStatus, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(mockGetTask));
+      return;
+    }
+
+    // POST /api/tasks/:id/finish
+    if (req.method === "POST" && /^\/api\/tasks\/[^/]+\/finish$/.test(url)) {
+      lastFinishBody = body ? JSON.parse(body) : null;
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(mockFinishResponse));
+      return;
+    }
+
+    res.writeHead(404);
+    res.end("Not found");
+  });
+
+  await new Promise<void>((resolve) => {
+    server.listen(TEST_PORT, () => resolve());
+  });
+});
+
+afterAll(() => {
+  server.close();
+});
+
+describe("handleStructuredOutputFallback", () => {
+  test("returns no-schema with lastProgress when task has progress logs", async () => {
+    resetMocks();
+    mockGetTask = {
+      id: "task-1",
+      task: "Do something",
+      status: "in_progress",
+      output: null,
+      progress: "older progress",
+      logs: [
+        { eventType: "task_progress", newValue: "first update", createdAt: "2025-01-01T00:00:00Z" },
+        {
+          eventType: "task_progress",
+          newValue: "latest update",
+          createdAt: "2025-01-01T01:00:00Z",
+        },
+        {
+          eventType: "task_status_change",
+          newValue: "in_progress",
+          createdAt: "2025-01-01T00:00:00Z",
+        },
+      ],
+    };
+
+    const result = await handleStructuredOutputFallback(makeConfig(), "task-1", "claude");
+    expect(result).toEqual({ kind: "no-schema", lastProgress: "latest update" });
+  });
+
+  test("returns no-schema with progress field when no progress logs exist", async () => {
+    resetMocks();
+    mockGetTask = {
+      id: "task-2",
+      task: "Do something",
+      status: "in_progress",
+      output: null,
+      progress: "some progress text",
+      logs: [],
+    };
+
+    const result = await handleStructuredOutputFallback(makeConfig(), "task-2", "claude");
+    expect(result).toEqual({ kind: "no-schema", lastProgress: "some progress text" });
+  });
+
+  test("returns no-schema without lastProgress when no progress at all", async () => {
+    resetMocks();
+    mockGetTask = {
+      id: "task-3",
+      task: "Do something",
+      status: "in_progress",
+      output: null,
+      progress: null,
+      logs: [],
+    };
+
+    const result = await handleStructuredOutputFallback(makeConfig(), "task-3", "claude");
+    expect(result).toEqual({ kind: "no-schema", lastProgress: undefined });
+  });
+
+  test("returns already-has-output when task has output and outputSchema", async () => {
+    resetMocks();
+    mockGetTask = {
+      id: "task-4",
+      task: "Do something",
+      status: "completed",
+      output: '{"result": "done"}',
+      outputSchema: { type: "object", properties: { result: { type: "string" } } },
+      logs: [],
+    };
+
+    const result = await handleStructuredOutputFallback(makeConfig(), "task-4", "claude");
+    expect(result).toEqual({ kind: "already-has-output" });
+  });
+
+  test("returns fetch-error when API returns non-200", async () => {
+    resetMocks();
+    mockGetTask = null;
+    mockGetTaskStatus = 500;
+
+    const result = await handleStructuredOutputFallback(makeConfig(), "task-5", "claude");
+    expect(result).toEqual({ kind: "fetch-error", error: "HTTP 500" });
+  });
+
+  test("returns schema-fail for non-claude adapter with outputSchema", async () => {
+    resetMocks();
+    mockGetTask = {
+      id: "task-6",
+      task: "Do something",
+      status: "in_progress",
+      output: null,
+      outputSchema: { type: "object", properties: { result: { type: "string" } } },
+      logs: [],
+    };
+
+    const result = await handleStructuredOutputFallback(makeConfig(), "task-6", "pi-mono");
+    expect(result).toEqual({
+      kind: "schema-fail",
+      failReason: "Structured output required by outputSchema but not provided via store-progress",
+    });
+  });
+
+  test("returns fetch-error on network error", async () => {
+    resetMocks();
+    // Use a port that nothing listens on
+    const badConfig = makeConfig(19999);
+
+    const result = await handleStructuredOutputFallback(badConfig, "task-7", "claude");
+    expect(result.kind).toBe("fetch-error");
+    expect((result as { kind: "fetch-error"; error: string }).error).toBeTruthy();
+  });
+});
+
+describe("ensureTaskFinished", () => {
+  test("sets output to last progress for no-schema fallback", async () => {
+    resetMocks();
+    mockGetTask = {
+      id: "task-10",
+      task: "Do work",
+      status: "in_progress",
+      output: null,
+      progress: null,
+      logs: [
+        {
+          eventType: "task_progress",
+          newValue: "Did some work here",
+          createdAt: "2025-01-01T00:00:00Z",
+        },
+      ],
+    };
+
+    await ensureTaskFinished(makeConfig(), "worker", "task-10", 0);
+
+    expect(lastFinishBody).toBeTruthy();
+    expect(lastFinishBody!.status).toBe("completed");
+    expect(lastFinishBody!.output).toBe("Did some work here");
+  });
+
+  test("sets generic message when no-schema and no progress", async () => {
+    resetMocks();
+    mockGetTask = {
+      id: "task-11",
+      task: "Do work",
+      status: "in_progress",
+      output: null,
+      progress: null,
+      logs: [],
+    };
+
+    await ensureTaskFinished(makeConfig(), "worker", "task-11", 0);
+
+    expect(lastFinishBody).toBeTruthy();
+    expect(lastFinishBody!.status).toBe("completed");
+    expect(lastFinishBody!.output).toBe("Process completed successfully (no output captured)");
+  });
+
+  test("sets failed status for schema-fail fallback", async () => {
+    resetMocks();
+    mockGetTask = {
+      id: "task-12",
+      task: "Do work",
+      status: "in_progress",
+      output: null,
+      outputSchema: { type: "object" },
+      logs: [],
+    };
+    // Force non-claude adapter via env
+    const origProvider = process.env.HARNESS_PROVIDER;
+    process.env.HARNESS_PROVIDER = "pi-mono";
+
+    await ensureTaskFinished(makeConfig(), "worker", "task-12", 0);
+
+    process.env.HARNESS_PROVIDER = origProvider;
+
+    expect(lastFinishBody).toBeTruthy();
+    expect(lastFinishBody!.status).toBe("failed");
+    expect(lastFinishBody!.failureReason).toContain("outputSchema");
+  });
+
+  test("handles alreadyFinished gracefully", async () => {
+    resetMocks();
+    mockGetTask = {
+      id: "task-13",
+      task: "Do work",
+      status: "in_progress",
+      output: null,
+      progress: null,
+      logs: [],
+    };
+    mockFinishResponse = { success: true, alreadyFinished: true, task: { status: "completed" } };
+
+    // Should not throw
+    await ensureTaskFinished(makeConfig(), "worker", "task-13", 0);
+    expect(lastFinishBody).toBeTruthy();
+  });
+
+  test("sends failure reason when exit code is non-zero", async () => {
+    resetMocks();
+
+    await ensureTaskFinished(makeConfig(), "worker", "task-14", 1, "Out of memory");
+
+    expect(lastFinishBody).toBeTruthy();
+    expect(lastFinishBody!.status).toBe("failed");
+    expect(lastFinishBody!.failureReason).toBe("Out of memory");
+  });
+
+  test("truncates long progress to 2000 chars", async () => {
+    resetMocks();
+    const longProgress = "x".repeat(3000);
+    mockGetTask = {
+      id: "task-15",
+      task: "Do work",
+      status: "in_progress",
+      output: null,
+      progress: longProgress,
+      logs: [],
+    };
+
+    await ensureTaskFinished(makeConfig(), "worker", "task-15", 0);
+
+    expect(lastFinishBody).toBeTruthy();
+    expect((lastFinishBody!.output as string).length).toBe(2000);
+  });
+});