@desplega.ai/agent-swarm 1.20.0 → 1.51.2

package/src/tests/slack-thread-followups.test.ts

@@ -0,0 +1,298 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlinkSync } from "node:fs";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  getCompletedSlackTasks,
+  getInProgressSlackTasks,
+  getMostRecentTaskInThread,
+  initDb,
+} from "../be/db";
+import { routeMessage } from "../slack/router";
+
+const TEST_DB_PATH = "./test-slack-thread-followups.sqlite";
+
+beforeAll(() => {
+  initDb(TEST_DB_PATH);
+});
+
+afterAll(() => {
+  closeDb();
+  try {
+    unlinkSync(TEST_DB_PATH);
+    unlinkSync(`${TEST_DB_PATH}-wal`);
+    unlinkSync(`${TEST_DB_PATH}-shm`);
+  } catch {
+    // ignore if files don't exist
+  }
+});
+
+describe("getMostRecentTaskInThread", () => {
+  test("returns null when no tasks exist for thread", () => {
+    const result = getMostRecentTaskInThread("C_EMPTY", "9999.0001");
+    expect(result).toBeNull();
+  });
+
+  test("returns a task regardless of source (slack, system, etc.)", () => {
+    const agent = createAgent({
+      name: "source-test-agent",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    // Create tasks with different sources
+    const slackTask = createTaskExtended("slack source task", {
+      agentId: agent.id,
+      source: "slack",
+      slackChannelId: "C_SOURCE",
+      slackThreadTs: "1000.0001",
+    });
+
+    const systemTask = createTaskExtended("system source task", {
+      agentId: agent.id,
+      source: "system",
+      slackChannelId: "C_SOURCE",
+      slackThreadTs: "1000.0001",
+    });
+
+    const result = getMostRecentTaskInThread("C_SOURCE", "1000.0001");
+    expect(result).not.toBeNull();
+    // Should return one of the tasks — importantly, it doesn't filter by source
+    expect([slackTask.id, systemTask.id]).toContain(result!.id);
+  });
+
+  test("returns a task regardless of status (completed, pending, etc.)", () => {
+    const agent = createAgent({
+      name: "status-test-agent",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    const task1 = createTaskExtended("completed task", {
+      agentId: agent.id,
+      source: "slack",
+      slackChannelId: "C_STATUS",
+      slackThreadTs: "2000.0001",
+    });
+
+    const task2 = createTaskExtended("in progress task", {
+      agentId: agent.id,
+      source: "slack",
+      slackChannelId: "C_STATUS",
+      slackThreadTs: "2000.0001",
+    });
+
+    const result = getMostRecentTaskInThread("C_STATUS", "2000.0001");
+    expect(result).not.toBeNull();
+    // Returns one of the tasks — importantly, it doesn't filter by status
+    expect([task1.id, task2.id]).toContain(result!.id);
+  });
+
+  test("returns task with source=null (worker tasks via send-task)", () => {
+    const agent = createAgent({
+      name: "null-source-agent",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    // Worker tasks created via send-task default to source=null — simulate with no source
+    const workerTask = createTaskExtended("worker task", {
+      agentId: agent.id,
+      slackChannelId: "C_WORKER",
+      slackThreadTs: "3000.0001",
+    });
+
+    const result = getMostRecentTaskInThread("C_WORKER", "3000.0001");
+    expect(result).not.toBeNull();
+    expect(result!.id).toBe(workerTask.id);
+  });
+});
+
+describe("routeMessage — thread follow-up with offline agent", () => {
+  let leadAgent: ReturnType<typeof createAgent>;
+  let workerAgent: ReturnType<typeof createAgent>;
+
+  beforeAll(() => {
+    leadAgent = createAgent({ name: "route-lead", isLead: true, status: "idle", capabilities: [] });
+    workerAgent = createAgent({
+      name: "route-worker",
+      isLead: false,
+      status: "offline",
+      capabilities: [],
+    });
+
+    // Create a task in the thread so getAgentWorkingOnThread finds the offline worker
+    createTaskExtended("original task", {
+      agentId: workerAgent.id,
+      source: "slack",
+      slackChannelId: "C_ROUTE",
+      slackThreadTs: "4000.0001",
+    });
+  });
+
+  test("routes to lead when thread agent is offline and bot NOT mentioned", () => {
+    const matches = routeMessage("follow up question", "B_BOT", false, {
+      channelId: "C_ROUTE",
+      threadTs: "4000.0001",
+    });
+
+    expect(matches.length).toBe(1);
+    expect(matches[0].agent.id).toBe(leadAgent.id);
+    expect(matches[0].matchedText).toBe("thread follow-up (lead fallback)");
+  });
+
+  test("routes to lead when thread agent is offline and bot IS mentioned", () => {
+    // With botMentioned=true and thread context, the thread follow-up path should still fire
+    // because it checks before the botMentioned fallback
+    const matches = routeMessage("follow up question", "B_BOT", true, {
+      channelId: "C_ROUTE",
+      threadTs: "4000.0001",
+    });
+
+    expect(matches.length).toBe(1);
+    expect(matches[0].agent.id).toBe(leadAgent.id);
+    expect(matches[0].matchedText).toBe("thread follow-up (lead fallback)");
+  });
+
+  test("still routes to working agent when agent is online (no regression)", () => {
+    const onlineWorker = createAgent({
+      name: "route-online-worker",
+      isLead: false,
+      status: "busy",
+      capabilities: [],
+    });
+
+    createTaskExtended("online task", {
+      agentId: onlineWorker.id,
+      source: "slack",
+      slackChannelId: "C_ROUTE_ONLINE",
+      slackThreadTs: "5000.0001",
+    });
+
+    const matches = routeMessage("follow up", "B_BOT", false, {
+      channelId: "C_ROUTE_ONLINE",
+      threadTs: "5000.0001",
+    });
+
+    expect(matches.length).toBe(1);
+    expect(matches[0].agent.id).toBe(onlineWorker.id);
+    expect(matches[0].matchedText).toBe("thread follow-up");
+  });
+});
+
+describe("follow-up task creation includes parentTaskId", () => {
+  test("parentTaskId is null when thread has no previous tasks (new thread)", () => {
+    const result = getMostRecentTaskInThread("C_NEW_THREAD", "8000.0001");
+    expect(result).toBeNull();
+  });
+
+  test("parentTaskId links to most recent task even if that task is completed", () => {
+    const agent = createAgent({
+      name: "parent-test-agent",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    const firstTask = createTaskExtended("first task", {
+      agentId: agent.id,
+      source: "slack",
+      slackChannelId: "C_PARENT",
+      slackThreadTs: "6000.0001",
+    });
+
+    // The most recent task should be returned for parentTaskId linking
+    const result = getMostRecentTaskInThread("C_PARENT", "6000.0001");
+    expect(result).not.toBeNull();
+    expect(result!.id).toBe(firstTask.id);
+
+    // Create a follow-up with parentTaskId
+    const followUp = createTaskExtended("follow up task", {
+      agentId: agent.id,
+      source: "slack",
+      slackChannelId: "C_PARENT",
+      slackThreadTs: "6000.0001",
+      parentTaskId: result!.id,
+    });
+
+    expect(followUp.parentTaskId).toBe(firstTask.id);
+  });
+});
+
+describe("watcher query scope — getCompletedSlackTasks / getInProgressSlackTasks", () => {
+  test("includes tasks with source='slack' and slackChannelId set", () => {
+    const agent = createAgent({
+      name: "watcher-slack-agent",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    createTaskExtended("slack completed task", {
+      agentId: agent.id,
+      source: "slack",
+      slackChannelId: "C_WATCHER",
+      slackThreadTs: "7000.0001",
+      status: "unassigned",
+    });
+
+    const completed = getCompletedSlackTasks();
+    const inProgress = getInProgressSlackTasks();
+    // Just verify the query doesn't error — specific status filtering tested below
+    expect(Array.isArray(completed)).toBe(true);
+    expect(Array.isArray(inProgress)).toBe(true);
+  });
+
+  test("includes tasks with source=null (worker tasks) that have slackChannelId set", () => {
+    const agent = createAgent({
+      name: "watcher-null-agent",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    // Worker task with no source but has Slack metadata (inherited via parentTaskId)
+    const _workerTask = createTaskExtended("worker completed", {
+      agentId: agent.id,
+      slackChannelId: "C_WATCHER_NULL",
+      slackThreadTs: "7100.0001",
+    });
+
+    // All tasks with slackChannelId should be visible regardless of source
+    const allCompleted = getCompletedSlackTasks();
+    const allInProgress = getInProgressSlackTasks();
+    // Task is pending, not completed or in_progress, so it won't appear in either
+    // But the queries shouldn't filter by source anymore
+    expect(Array.isArray(allCompleted)).toBe(true);
+    expect(Array.isArray(allInProgress)).toBe(true);
+  });
+
+  test("excludes tasks without slackChannelId (non-Slack tasks)", () => {
+    const agent = createAgent({
+      name: "watcher-no-slack-agent",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+
+    createTaskExtended("non-slack task", {
+      agentId: agent.id,
+      source: "mcp",
+    });
+
+    const completed = getCompletedSlackTasks();
+    const inProgress = getInProgressSlackTasks();
+
+    // None of the returned tasks should have null slackChannelId
+    for (const task of completed) {
+      expect(task.slackChannelId).not.toBeNull();
+    }
+    for (const task of inProgress) {
+      expect(task.slackChannelId).not.toBeNull();
+    }
+  });
+});

package/src/tests/slack-watcher.test.ts

@@ -0,0 +1,101 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlinkSync } from "node:fs";
+import {
+  cancelTask,
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  getCompletedSlackTasks,
+  getInProgressSlackTasks,
+  initDb,
+} from "../be/db";
+import { startTaskWatcher, stopTaskWatcher } from "../slack/watcher";
+
+const TEST_DB_PATH = "./test-slack-watcher.sqlite";
+
+beforeAll(() => {
+  initDb(TEST_DB_PATH);
+});
+
+afterAll(() => {
+  stopTaskWatcher();
+  closeDb();
+  try {
+    unlinkSync(TEST_DB_PATH);
+    unlinkSync(`${TEST_DB_PATH}-wal`);
+    unlinkSync(`${TEST_DB_PATH}-shm`);
+  } catch {
+    // ignore if files don't exist
+  }
+});
+
+describe("startTaskWatcher / stopTaskWatcher", () => {
+  test("starts and stops without error", () => {
+    startTaskWatcher(60000); // Long interval so it doesn't fire during test
+    stopTaskWatcher();
+  });
+
+  test("is idempotent — starting twice does not error", () => {
+    startTaskWatcher(60000);
+    startTaskWatcher(60000); // Should log "already running", not throw
+    stopTaskWatcher();
+  });
+
+  test("stopping when not running does not error", () => {
+    stopTaskWatcher();
+    stopTaskWatcher();
+  });
+});
+
+describe("watcher DB queries", () => {
+  test("getInProgressSlackTasks excludes pending tasks (only in_progress)", () => {
+    // createTaskExtended creates tasks as 'pending', not 'in_progress'
+    const agent = createAgent({ name: "WatcherTestAgent", isLead: false, status: "idle" });
+    const task = createTaskExtended("watcher pending test", {
+      agentId: agent.id,
+      source: "slack",
+      slackChannelId: "C_WATCHER",
+      slackThreadTs: "1111111111.000001",
+      slackUserId: "U_WATCHER",
+    });
+
+    const inProgress = getInProgressSlackTasks();
+    const found = inProgress.find((t) => t.id === task.id);
+    // Task is 'pending', not 'in_progress', so it should NOT appear
+    expect(found).toBeUndefined();
+  });
+
+  test("getInProgressSlackTasks returns array", () => {
+    const inProgress = getInProgressSlackTasks();
+    expect(Array.isArray(inProgress)).toBe(true);
+  });
+
+  test("getCompletedSlackTasks excludes cancelled tasks (only completed/failed)", () => {
+    const agent = createAgent({ name: "WatcherCompAgent", isLead: false, status: "idle" });
+    const task = createTaskExtended("watcher cancel test", {
+      agentId: agent.id,
+      source: "slack",
+      slackChannelId: "C_WATCHER2",
+      slackThreadTs: "2222222222.000001",
+      slackUserId: "U_WATCHER2",
+    });
+
+    cancelTask(task.id, "test cancel");
+
+    const completed = getCompletedSlackTasks();
+    const found = completed.find((t) => t.id === task.id);
+    // Cancelled tasks are NOT included in getCompletedSlackTasks (only completed/failed)
+    expect(found).toBeUndefined();
+  });
+
+  test("getCompletedSlackTasks returns array", () => {
+    const completed = getCompletedSlackTasks();
+    expect(Array.isArray(completed)).toBe(true);
+  });
+
+  test("initializes notifiedCompletions on start to skip existing completed tasks", () => {
+    // Starting the watcher with existing data should not crash
+    startTaskWatcher(60000);
+    stopTaskWatcher();
+  });
+});

package/src/tests/structured-output.test.ts

@@ -0,0 +1,307 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  closeDb,
+  createTaskExtended,
+  createWorkflow,
+  createWorkflowRun,
+  createWorkflowRunStep,
+  getTaskById,
+  initDb,
+} from "../be/db";
+import { validateJsonSchema } from "../workflows/json-schema-validator";
+
+const TEST_DB_PATH = "./test-structured-output.sqlite";
+
+// ─── Setup / Teardown ────────────────────────────────────────
+
+beforeAll(async () => {
+  try {
+    await unlink(TEST_DB_PATH);
+  } catch {}
+  initDb(TEST_DB_PATH);
+});
+
+afterAll(async () => {
+  closeDb();
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(`${TEST_DB_PATH}${suffix}`);
+    } catch {}
+  }
+});
+
+// ─── JSON Schema Validator Tests ─────────────────────────────
+
+describe("validateJsonSchema — enum and const extensions", () => {
+  test("enum: valid value passes", () => {
+    const schema = { type: "string", enum: ["red", "green", "blue"] };
+    const errors = validateJsonSchema(schema, "red");
+    expect(errors).toEqual([]);
+  });
+
+  test("enum: invalid value fails", () => {
+    const schema = { type: "string", enum: ["red", "green", "blue"] };
+    const errors = validateJsonSchema(schema, "yellow");
+    expect(errors.length).toBe(1);
+    expect(errors[0]).toContain("not in enum");
+  });
+
+  test("enum: numeric enum works", () => {
+    const schema = { type: "number", enum: [1, 2, 3] };
+    expect(validateJsonSchema(schema, 2)).toEqual([]);
+    expect(validateJsonSchema(schema, 5).length).toBe(1);
+  });
+
+  test("const: matching value passes", () => {
+    const schema = { const: "fixed-value" };
+    expect(validateJsonSchema(schema, "fixed-value")).toEqual([]);
+  });
+
+  test("const: mismatched value fails", () => {
+    const schema = { const: 42 };
+    const errors = validateJsonSchema(schema, 43);
+    expect(errors.length).toBe(1);
+    expect(errors[0]).toContain("does not match const");
+  });
+
+  test("items: validates array items", () => {
+    const schema = {
+      type: "array",
+      items: { type: "number" },
+    };
+    expect(validateJsonSchema(schema, [1, 2, 3])).toEqual([]);
+    const errors = validateJsonSchema(schema, [1, "two", 3]);
+    expect(errors.length).toBe(1);
+    expect(errors[0]).toContain("root[1]");
+  });
+
+  test("nested object with enum property", () => {
+    const schema = {
+      type: "object",
+      properties: {
+        status: { type: "string", enum: ["active", "inactive"] },
+        count: { type: "number" },
+      },
+      required: ["status"],
+    };
+    expect(validateJsonSchema(schema, { status: "active", count: 5 })).toEqual([]);
+    expect(validateJsonSchema(schema, { status: "unknown" }).length).toBe(1);
+  });
+});
+
+// ─── DB: outputSchema storage ────────────────────────────────
+
+describe("Task outputSchema storage", () => {
+  test("createTaskExtended stores outputSchema", () => {
+    const schema = {
+      type: "object",
+      properties: { fileCount: { type: "number" } },
+      required: ["fileCount"],
+    };
+    const task = createTaskExtended("Count files", {
+      source: "api",
+      outputSchema: schema,
+    });
+
+    const fetched = getTaskById(task.id);
+    expect(fetched).toBeDefined();
+    expect(fetched!.outputSchema).toBeDefined();
+    expect(fetched!.outputSchema).toEqual(schema);
+  });
+
+  test("createTaskExtended without outputSchema returns undefined", () => {
+    const task = createTaskExtended("Simple task", { source: "api" });
+    const fetched = getTaskById(task.id);
+    expect(fetched).toBeDefined();
+    expect(fetched!.outputSchema).toBeUndefined();
+  });
+});
+
+// ─── Store-progress validation logic (unit-level) ────────────
+
+describe("Structured output validation logic", () => {
+  test("valid JSON matching schema passes validation", () => {
+    const schema = {
+      type: "object",
+      properties: {
+        fileCount: { type: "number" },
+        files: { type: "array", items: { type: "string" } },
+      },
+      required: ["fileCount"],
+    };
+    const output = JSON.stringify({ fileCount: 42, files: ["a.txt", "b.txt"] });
+    const parsed = JSON.parse(output);
+    const errors = validateJsonSchema(schema, parsed);
+    expect(errors).toEqual([]);
+  });
+
+  test("valid JSON not matching schema produces errors", () => {
+    const schema = {
+      type: "object",
+      properties: {
+        fileCount: { type: "number" },
+      },
+      required: ["fileCount"],
+    };
+    const parsed = { name: "test" }; // Missing fileCount
+    const errors = validateJsonSchema(schema, parsed);
+    expect(errors.length).toBeGreaterThan(0);
+    expect(errors[0]).toContain("fileCount");
+  });
+
+  test("wrong type produces error", () => {
+    const schema = {
+      type: "object",
+      properties: {
+        count: { type: "number" },
+      },
+    };
+    const parsed = { count: "not-a-number" };
+    const errors = validateJsonSchema(schema, parsed);
+    expect(errors.length).toBe(1);
+    expect(errors[0]).toContain("expected type");
+  });
+});
+
+// ─── Resume: JSON-parse structured output ────────────────────
+
+describe("Resume — structured output JSON parsing", () => {
+  test("JSON string output gets parsed to object", () => {
+    const output = JSON.stringify({ fileCount: 42, path: "/tmp" });
+    let taskOutput: unknown = output;
+    try {
+      const parsed = JSON.parse(output);
+      if (typeof parsed === "object" && parsed !== null) {
+        taskOutput = parsed;
+      }
+    } catch {
+      // keep as string
+    }
+    expect(typeof taskOutput).toBe("object");
+    expect((taskOutput as { fileCount: number }).fileCount).toBe(42);
+  });
+
+  test("plain text output stays as string", () => {
+    const output = "Just a plain text result";
+    let taskOutput: unknown = output;
+    try {
+      const parsed = JSON.parse(output);
+      if (typeof parsed === "object" && parsed !== null) {
+        taskOutput = parsed;
+      }
+    } catch {
+      // keep as string
+    }
+    expect(typeof taskOutput).toBe("string");
+    expect(taskOutput).toBe("Just a plain text result");
+  });
+
+  test("JSON number stays as string (not object)", () => {
+    const output = "42";
+    let taskOutput: unknown = output;
+    try {
+      const parsed = JSON.parse(output);
+      if (typeof parsed === "object" && parsed !== null) {
+        taskOutput = parsed;
+      }
+    } catch {
+      // keep as string
+    }
+    // 42 parses but is not an object, so stays as string
+    expect(typeof taskOutput).toBe("string");
+  });
+
+  test("JSON array gets parsed", () => {
+    const output = JSON.stringify([1, 2, 3]);
+    let taskOutput: unknown = output;
+    try {
+      const parsed = JSON.parse(output);
+      if (typeof parsed === "object" && parsed !== null) {
+        taskOutput = parsed;
+      }
+    } catch {
+      // keep as string
+    }
+    expect(Array.isArray(taskOutput)).toBe(true);
+  });
+});
+
+// ─── AgentTask executor config schema ────────────────────────
+
+describe("AgentTaskConfigSchema — outputSchema", () => {
+  test("accepts outputSchema in config", async () => {
+    const { AgentTaskExecutor } = await import("../workflows/executors/agent-task");
+    const executor = new AgentTaskExecutor({
+      db: {} as any,
+      eventBus: { emit: () => {}, on: () => {}, off: () => {} },
+      interpolate: (t: string) => t,
+    });
+
+    const config = {
+      template: "Count files",
+      outputSchema: {
+        type: "object",
+        properties: { fileCount: { type: "number" } },
+        required: ["fileCount"],
+      },
+    };
+    const parsed = executor.configSchema.safeParse(config);
+    expect(parsed.success).toBe(true);
+    if (parsed.success) {
+      expect(parsed.data.outputSchema).toEqual(config.outputSchema);
+    }
+  });
+});
+
+// ─── Workflow agent-task → DB with outputSchema ──────────────
+
+describe("Workflow agent-task creates task with outputSchema", () => {
+  test("outputSchema flows from executor config to created task", async () => {
+    const { AgentTaskExecutor } = await import("../workflows/executors/agent-task");
+    const db = await import("../be/db");
+
+    const executor = new AgentTaskExecutor({
+      db: db as typeof import("../be/db"),
+      eventBus: { emit: () => {}, on: () => {}, off: () => {} },
+      interpolate: (t: string) => t,
+    });
+
+    // Create prerequisites for FK constraints
+    const wf = createWorkflow({ name: "test-output-schema", definition: { nodes: [], edges: [] } });
+    const run = createWorkflowRun({ id: crypto.randomUUID(), workflowId: wf.id });
+    const step = createWorkflowRunStep({
+      id: crypto.randomUUID(),
+      runId: run.id,
+      nodeId: "n1",
+      nodeType: "agent-task",
+    });
+
+    const schema = {
+      type: "object",
+      properties: { summary: { type: "string" } },
+      required: ["summary"],
+    };
+
+    const result = await executor.run({
+      config: {
+        template: "Summarize the document",
+        outputSchema: schema,
+      },
+      context: {},
+      meta: {
+        runId: run.id,
+        stepId: step.id,
+        nodeId: "n1",
+        workflowId: wf.id,
+        dryRun: false,
+      },
+    });
+
+    expect(result.status).toBe("success");
+    const taskId = (result as { correlationId?: string }).correlationId!;
+    const task = getTaskById(taskId);
+    expect(task).toBeDefined();
+    expect(task!.outputSchema).toEqual(schema);
+  });
+});