@desplega.ai/agent-swarm 1.84.0 → 1.85.0

package/src/tests/pi-mono-adapter.test.ts

@@ -1,7 +1,12 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { existsSync, mkdirSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { createPiRuntimeAuth, PiMonoAdapter, resolveModel } from "../providers/pi-mono-adapter";
+import {
+  createPiRuntimeAuth,
+  extractPiAssistantText,
+  PiMonoAdapter,
+  resolveModel,
+} from "../providers/pi-mono-adapter";
 
 describe("PiMonoAdapter", () => {
   test("name is 'pi'", () => {
@@ -198,6 +203,37 @@ describe("createPiRuntimeAuth", () => {
 });
 
 describe("Pi-mono event normalization", () => {
+  test("extractPiAssistantText ignores user messages", () => {
+    const text = extractPiAssistantText({
+      role: "user",
+      content: "/skill:work-on-task task-123\n\nTask: hello",
+    });
+
+    expect(text).toBe("");
+  });
+
+  test("extractPiAssistantText extracts assistant text blocks", () => {
+    const text = extractPiAssistantText({
+      role: "assistant",
+      content: [
+        { type: "text", text: "Hello, " },
+        { type: "thinking", thinking: "hidden" },
+        { type: "text", text: "world!" },
+      ],
+    });
+
+    expect(text).toBe("Hello, world!");
+  });
+
+  test("extractPiAssistantText supports string assistant content", () => {
+    const text = extractPiAssistantText({
+      role: "assistant",
+      content: "Plain assistant output",
+    });
+
+    expect(text).toBe("Plain assistant output");
+  });
+
   test("message_update with text content produces raw_log-style data", () => {
     // Simulates what PiMonoSession.handleAgentEvent does
     const event = {

package/src/tests/prompt-template-session.test.ts

@@ -54,11 +54,12 @@ describe("Session templates — registration", () => {
     await ensureTemplatesRegistered();
   });
 
-  test("all 13 system templates are registered", () => {
+  test("all 14 system templates are registered", () => {
     const systemTemplates = [
       "system.agent.role",
       "system.agent.register",
       "system.agent.lead",
+      "system.agent.slack",
       "system.agent.worker",
       "system.agent.worker.slack",
       "system.agent.filesystem",
@@ -89,10 +90,10 @@ describe("Session templates — registration", () => {
     }
   });
 
-  test("total of 18 session/system templates registered", () => {
+  test("total of 19 session/system templates registered", () => {
     const all = getAllTemplateDefinitions();
     const sessionSystem = all.filter((d) => d.category === "system" || d.category === "session");
-    expect(sessionSystem.length).toBe(18);
+    expect(sessionSystem.length).toBe(19);
   });
 });
 
@@ -150,6 +151,15 @@ describe("Session templates — individual resolution", () => {
     const result = resolveTemplate("system.agent.lead", {});
     expect(result.text).toContain("CRITICAL: You are a coordinator");
     expect(result.text).toContain("coordinator");
+    expect(result.text).not.toContain("slack-reply");
+  });
+
+  test("system.agent.slack contains Slack tool guidance", () => {
+    const result = resolveTemplate("system.agent.slack", {});
+    expect(result.text).toContain("Slack Tools");
+    expect(result.text).toContain("slack-reply");
+    expect(result.text).toContain("slack-read");
+    expect(result.text).toContain("slack-list-channels");
   });
 
   test("system.agent.worker contains worker tools", () => {

package/src/tests/runner-context-preamble.test.ts

@@ -0,0 +1,202 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { createServer, type Server } from "node:http";
+import {
+  buildContextPreamble,
+  CONTEXT_PREAMBLE_MAX_CHARS,
+  CONTEXT_PREAMBLE_MAX_TOKENS,
+  fetchTaskContextForPreamble,
+  type TaskContextForPreamble,
+} from "../commands/context-preamble";
+
+const TEST_PORT = 19091;
+const API_URL = `http://localhost:${TEST_PORT}`;
+const API_KEY = "test-key";
+
+// In-memory task store for the mock server
+const mockTasks: Record<string, TaskContextForPreamble> = {};
+
+let server: Server;
+
+beforeAll(async () => {
+  server = createServer((req, res) => {
+    const url = req.url ?? "";
+    const match = url.match(/^\/api\/tasks\/([^/?]+)/);
+    if (match) {
+      const id = match[1];
+      const task = mockTasks[id];
+      if (task) {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(task));
+      } else {
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "not found" }));
+      }
+      return;
+    }
+    res.writeHead(404);
+    res.end();
+  });
+
+  await new Promise<void>((resolve) => server.listen(TEST_PORT, resolve));
+});
+
+afterAll(() => {
+  server.close();
+  // Clear mocks
+  for (const k of Object.keys(mockTasks)) delete mockTasks[k];
+});
+
+function seedTask(task: TaskContextForPreamble): void {
+  mockTasks[task.id] = task;
+}
+
+describe("fetchTaskContextForPreamble", () => {
+  test("returns null on 404", async () => {
+    const result = await fetchTaskContextForPreamble(API_URL, API_KEY, "missing-id");
+    expect(result).toBeNull();
+  });
+
+  test("fetches task context fields", async () => {
+    seedTask({
+      id: "task-a",
+      task: "Build the widget",
+      output: "Widget built successfully",
+      status: "completed",
+      attachments: [{ kind: "url", name: "Report", url: "https://example.com/report" }],
+    });
+
+    const result = await fetchTaskContextForPreamble(API_URL, API_KEY, "task-a");
+    expect(result).not.toBeNull();
+    expect(result?.id).toBe("task-a");
+    expect(result?.task).toBe("Build the widget");
+    expect(result?.output).toBe("Widget built successfully");
+    expect(result?.attachments).toHaveLength(1);
+    expect(result?.attachments?.[0].name).toBe("Report");
+  });
+});
+
+describe("buildContextPreamble", () => {
+  test("returns null when parent task not found", async () => {
+    const result = await buildContextPreamble(API_URL, API_KEY, "nonexistent-parent");
+    expect(result).toBeNull();
+  });
+
+  test("includes parent task subject and output in preamble", async () => {
+    seedTask({
+      id: "parent-1",
+      task: "Fix the auth bug in login flow",
+      output: "Fixed by patching jwt validation in auth.ts:42",
+      status: "completed",
+    });
+
+    const preamble = await buildContextPreamble(API_URL, API_KEY, "parent-1");
+    expect(preamble).not.toBeNull();
+    expect(preamble).toContain("parent-1");
+    expect(preamble).toContain("Fix the auth bug in login flow");
+    expect(preamble).toContain("Fixed by patching jwt validation");
+    expect(preamble).toContain("get-task-details");
+    expect(preamble).toContain("Prior Conversation Context");
+  });
+
+  test("includes attachment pointers in preamble", async () => {
+    seedTask({
+      id: "parent-2",
+      task: "Generate a report",
+      output: "Report generated",
+      status: "completed",
+      attachments: [
+        { kind: "url", name: "Final Report", url: "https://example.com/report.pdf" },
+        {
+          kind: "agent-fs",
+          name: "Raw Data",
+          path: "thoughts/agent/research/data.md",
+          orgId: "org-123",
+          driveId: "drv-456",
+        },
+      ],
+    });
+
+    const preamble = await buildContextPreamble(API_URL, API_KEY, "parent-2");
+    expect(preamble).toContain("Final Report");
+    expect(preamble).toContain("https://example.com/report.pdf");
+    expect(preamble).toContain("Raw Data");
+    expect(preamble).toContain("live.agent-fs.dev");
+    expect(preamble).toContain("org-123");
+    expect(preamble).toContain("drv-456");
+  });
+
+  test("shows 'no output recorded' when task has no output or progress", async () => {
+    seedTask({
+      id: "parent-no-output",
+      task: "A task with no output yet",
+      status: "in_progress",
+    });
+
+    const preamble = await buildContextPreamble(API_URL, API_KEY, "parent-no-output");
+    expect(preamble).toContain("no output recorded");
+  });
+
+  test("walks ancestor chain and includes older ancestors as pointers", async () => {
+    seedTask({
+      id: "grandparent-1",
+      task: "Initial research task",
+      output: "Research complete",
+      status: "completed",
+    });
+    seedTask({
+      id: "child-of-grandparent",
+      task: "Second task referencing research",
+      output: "Second task done",
+      status: "completed",
+      parentTaskId: "grandparent-1",
+    });
+
+    const preamble = await buildContextPreamble(API_URL, API_KEY, "child-of-grandparent");
+    expect(preamble).not.toBeNull();
+    // Immediate parent (child-of-grandparent) gets inline detail
+    expect(preamble).toContain("child-of-grandparent");
+    expect(preamble).toContain("Second task done");
+    // Grandparent gets pointer-only entry
+    expect(preamble).toContain("grandparent-1");
+    expect(preamble).toContain("Older Ancestor Tasks");
+    expect(preamble).toContain("Initial research task");
+  });
+
+  test("enforces token budget — truncates oversized output", async () => {
+    // Generate output that exceeds the budget
+    const hugeOutput = "x".repeat(CONTEXT_PREAMBLE_MAX_CHARS + 5000);
+    seedTask({
+      id: "parent-big",
+      task: "Task with very large output",
+      output: hugeOutput,
+      status: "completed",
+    });
+
+    const preamble = await buildContextPreamble(API_URL, API_KEY, "parent-big");
+    expect(preamble).not.toBeNull();
+    // Preamble must be within budget (some slack for the truncation suffix)
+    expect(preamble?.length ?? 0).toBeLessThanOrEqual(
+      CONTEXT_PREAMBLE_MAX_CHARS + 300, // 300 chars slack for the truncation message
+    );
+  });
+
+  test("preamble starts with context section and ends with separator", async () => {
+    seedTask({
+      id: "parent-structure",
+      task: "A well-structured task",
+      output: "Done",
+      status: "completed",
+    });
+
+    const preamble = await buildContextPreamble(API_URL, API_KEY, "parent-structure");
+    expect(preamble).toContain("---");
+    expect(preamble).toContain("Prior Conversation Context");
+    // Should end with trailing separator
+    expect(preamble?.trimEnd()).toMatch(/---\s*$/);
+  });
+
+  test("CONTEXT_PREAMBLE_MAX_TOKENS is 2000 by default", () => {
+    expect(CONTEXT_PREAMBLE_MAX_TOKENS).toBe(2000);
+    expect(CONTEXT_PREAMBLE_MAX_CHARS).toBe(8000);
+  });
+});

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

@@ -1,76 +1,70 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import { createServer as createHttpServer, type Server } from "node:http";
 import {
   type ApiConfig,
   ensureTaskFinished,
   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 };
+let mockFetchError: Error | null = null;
+let originalFetch: typeof fetch;
 
 function resetMocks() {
   mockGetTask = null;
   mockGetTaskStatus = 200;
   lastFinishBody = null;
   mockFinishResponse = { success: true };
+  mockFetchError = null;
 }
 
-let server: Server;
-
-function makeConfig(port = TEST_PORT): ApiConfig {
+function makeConfig(): ApiConfig {
   return {
-    apiUrl: `http://localhost:${port}`,
+    apiUrl: "http://runner-fallback.test",
     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 || "";
+beforeAll(() => {
+  originalFetch = globalThis.fetch;
+  globalThis.fetch = (async (input, init) => {
+    if (mockFetchError) throw mockFetchError;
 
-    // GET /api/tasks/:id
-    if (req.method === "GET" && /^\/api\/tasks\/[^/]+$/.test(url)) {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    const parsedUrl = new URL(url);
+    const method = init?.method ?? "GET";
+
+    if (method === "GET" && /^\/api\/tasks\/[^/]+$/.test(parsedUrl.pathname)) {
       if (!mockGetTask) {
-        res.writeHead(mockGetTaskStatus);
-        res.end(JSON.stringify({ error: "Not found" }));
-        return;
+        return new Response(JSON.stringify({ error: "Not found" }), {
+          status: mockGetTaskStatus,
+        });
       }
-      res.writeHead(mockGetTaskStatus, { "Content-Type": "application/json" });
-      res.end(JSON.stringify(mockGetTask));
-      return;
+      return new Response(JSON.stringify(mockGetTask), {
+        status: mockGetTaskStatus,
+        headers: { "Content-Type": "application/json" },
+      });
     }
 
-    // POST /api/tasks/:id/finish
-    if (req.method === "POST" && /^\/api\/tasks\/[^/]+\/finish$/.test(url)) {
+    if (method === "POST" && /^\/api\/tasks\/[^/]+\/finish$/.test(parsedUrl.pathname)) {
+      const body = typeof init?.body === "string" ? init.body : "";
       lastFinishBody = body ? JSON.parse(body) : null;
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify(mockFinishResponse));
-      return;
+      return new Response(JSON.stringify(mockFinishResponse), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
     }
 
-    res.writeHead(404);
-    res.end("Not found");
-  });
-
-  await new Promise<void>((resolve) => {
-    server.listen(TEST_PORT, () => resolve());
-  });
+    return new Response("Not found", { status: 404 });
+  }) as typeof fetch;
 });
 
 afterAll(() => {
-  server.close();
+  globalThis.fetch = originalFetch;
 });
 
 describe("handleStructuredOutputFallback", () => {
@@ -175,10 +169,9 @@ describe("handleStructuredOutputFallback", () => {
 
   test("returns fetch-error on network error", async () => {
     resetMocks();
-    // Use a port that nothing listens on
-    const badConfig = makeConfig(19999);
+    mockFetchError = new Error("network down");
 
-    const result = await handleStructuredOutputFallback(badConfig, "task-7", "claude");
+    const result = await handleStructuredOutputFallback(makeConfig(), "task-7", "claude");
     expect(result.kind).toBe("fetch-error");
     expect((result as { kind: "fetch-error"; error: string }).error).toBeTruthy();
   });
@@ -227,6 +220,92 @@ describe("ensureTaskFinished", () => {
     expect(lastFinishBody!.output).toBe("Process completed successfully (no output captured)");
   });
 
+  test("uses provider output when no outputSchema exists", async () => {
+    resetMocks();
+    mockGetTask = {
+      id: "task-provider-output",
+      task: "Do work",
+      status: "in_progress",
+      output: null,
+      progress: null,
+      logs: [],
+    };
+
+    await ensureTaskFinished(
+      makeConfig(),
+      "worker",
+      "task-provider-output",
+      0,
+      undefined,
+      "Provider final answer",
+      "pi",
+    );
+
+    expect(lastFinishBody).toBeTruthy();
+    expect(lastFinishBody!.status).toBe("completed");
+    expect(lastFinishBody!.output).toBe("Provider final answer");
+  });
+
+  test("accepts provider output that satisfies outputSchema", async () => {
+    resetMocks();
+    mockGetTask = {
+      id: "task-provider-schema-valid",
+      task: "Do work",
+      status: "in_progress",
+      output: null,
+      outputSchema: {
+        type: "object",
+        required: ["result"],
+        properties: { result: { type: "string" } },
+      },
+      logs: [],
+    };
+
+    await ensureTaskFinished(
+      makeConfig(),
+      "worker",
+      "task-provider-schema-valid",
+      0,
+      undefined,
+      '{"result":"ok"}',
+      "pi",
+    );
+
+    expect(lastFinishBody).toBeTruthy();
+    expect(lastFinishBody!.status).toBe("completed");
+    expect(lastFinishBody!.output).toBe('{"result":"ok"}');
+  });
+
+  test("fails provider output that violates outputSchema", async () => {
+    resetMocks();
+    mockGetTask = {
+      id: "task-provider-schema-invalid",
+      task: "Do work",
+      status: "in_progress",
+      output: null,
+      outputSchema: {
+        type: "object",
+        required: ["result"],
+        properties: { result: { type: "string" } },
+      },
+      logs: [],
+    };
+
+    await ensureTaskFinished(
+      makeConfig(),
+      "worker",
+      "task-provider-schema-invalid",
+      0,
+      undefined,
+      "plain text",
+      "pi",
+    );
+
+    expect(lastFinishBody).toBeTruthy();
+    expect(lastFinishBody!.status).toBe("failed");
+    expect(lastFinishBody!.failureReason).toContain("outputSchema");
+  });
+
   test("sets failed status for schema-fail fallback", async () => {
     resetMocks();
     mockGetTask = {

package/src/tests/task-completion-idempotency.test.ts

@@ -13,6 +13,7 @@ import {
   initDb,
   startTask,
 } from "../be/db";
+import { createWorkerTaskFollowUp } from "../tasks/worker-follow-up";
 
 const TEST_DB_PATH = "./test-task-completion-idempotency.sqlite";
 
@@ -318,3 +319,91 @@ describe("store-progress idempotency on terminal status (integration via DB laye
     expect(after!.output).toBe("manually written");
   });
 });
+
+interface FollowUpRow {
+  id: string;
+  agentId: string | null;
+  parentTaskId: string | null;
+  taskType: string | null;
+  task: string;
+  slackChannelId: string | null;
+  slackThreadTs: string | null;
+  slackUserId: string | null;
+}
+
+function listFollowUpTasks(parentTaskId: string): FollowUpRow[] {
+  return getDb()
+    .prepare<FollowUpRow, [string]>(
+      `SELECT id, agentId, parentTaskId, taskType, task, slackChannelId, slackThreadTs, slackUserId
+       FROM agent_tasks
+       WHERE parentTaskId = ? AND taskType = 'follow-up'
+       ORDER BY createdAt ASC`,
+    )
+    .all(parentTaskId);
+}
+
+describe("worker task follow-up creation", () => {
+  test("creates lead follow-up for completed worker task", () => {
+    const lead = createAgent({
+      name: "follow-up-lead-1",
+      isLead: true,
+      status: "idle",
+      capabilities: [],
+    });
+    const worker = createAgent({
+      name: "follow-up-worker-1",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+    const task = createTaskExtended("Worker task", {
+      agentId: worker.id,
+      slackChannelId: "C123",
+      slackThreadTs: "1700000000.000001",
+      slackUserId: "U123",
+    });
+    startTask(task.id, worker.id);
+
+    const completed = completeTask(task.id, "Worker output");
+    expect(completed).not.toBeNull();
+
+    const followUp = createWorkerTaskFollowUp({
+      task: completed!,
+      status: "completed",
+      output: "Worker output",
+    });
+
+    expect(followUp).not.toBeNull();
+    const rows = listFollowUpTasks(task.id);
+    expect(rows).toHaveLength(1);
+    expect(rows[0]!.agentId).toBe(lead.id);
+    expect(rows[0]!.parentTaskId).toBe(task.id);
+    expect(rows[0]!.slackChannelId).toBe("C123");
+    expect(rows[0]!.slackThreadTs).toBe("1700000000.000001");
+    expect(rows[0]!.slackUserId).toBe("U123");
+    expect(rows[0]!.task).toContain("Worker output");
+  });
+
+  test("does not create follow-up for lead-owned task", () => {
+    const lead = createAgent({
+      name: "follow-up-lead-2",
+      isLead: true,
+      status: "idle",
+      capabilities: [],
+    });
+    const task = createTaskExtended("Lead task", { agentId: lead.id });
+    startTask(task.id, lead.id);
+
+    const completed = completeTask(task.id, "Lead output");
+    expect(completed).not.toBeNull();
+
+    const followUp = createWorkerTaskFollowUp({
+      task: completed!,
+      status: "completed",
+      output: "Lead output",
+    });
+
+    expect(followUp).toBeNull();
+    expect(listFollowUpTasks(task.id)).toHaveLength(0);
+  });
+});

package/src/tools/cancel-task.ts

@@ -142,12 +142,20 @@ export async function cancelTaskHandler(
 
   if ("content" in result) return result;
 
+  const structuredContent = {
+    yourAgentId: agentId,
+    ...result,
+  };
+
   return {
-    content: [{ type: "text", text: result.message }],
-    structuredContent: {
-      yourAgentId: agentId,
-      ...result,
-    },
+    content: [
+      { type: "text", text: result.message },
+      {
+        type: "text",
+        text: JSON.stringify(structuredContent),
+      },
+    ],
+    structuredContent,
   };
 }
 

package/src/tools/get-task-details.ts

@@ -65,17 +65,25 @@ export async function getTaskDetailsHandler(
     ? { name: requestedByUser.name, email: requestedByUser.email }
     : undefined;
 
+  const structuredContent = {
+    yourAgentId: agentId,
+    success: true,
+    message: `Task "${taskId}" details retrieved.`,
+    task,
+    requestedBy,
+    logs,
+    attachments,
+  };
+
   return {
-    content: [{ type: "text", text: `Task "${taskId}" details retrieved.` }],
-    structuredContent: {
-      yourAgentId: agentId,
-      success: true,
-      message: `Task "${taskId}" details retrieved.`,
-      task,
-      requestedBy,
-      logs,
-      attachments,
-    },
+    content: [
+      { type: "text", text: `Task "${taskId}" details retrieved.` },
+      {
+        type: "text",
+        text: JSON.stringify(structuredContent),
+      },
+    ],
+    structuredContent,
   };
 }