@desplega.ai/agent-swarm 1.20.0 → 1.51.2

package/src/tests/session-costs.test.ts

@@ -7,8 +7,11 @@ import {
   createSessionCost,
   createTaskExtended,
   getAllSessionCosts,
+  getDashboardCostSummary,
+  getSessionCostSummary,
   getSessionCostsByAgentId,
   getSessionCostsByTaskId,
+  getSessionCostsFiltered,
   initDb,
 } from "../be/db";
 import type { SessionCost } from "../types";
@@ -77,6 +80,43 @@ async function handleRequest(
     }
   }
 
+  // GET /api/session-costs/summary - Aggregated usage summary
+  if (
+    req.method === "GET" &&
+    pathSegments[0] === "api" &&
+    pathSegments[1] === "session-costs" &&
+    pathSegments[2] === "summary"
+  ) {
+    const rawGroupBy = queryParams.get("groupBy");
+    const validGroupBy = ["day", "agent", "both"] as const;
+    if (rawGroupBy && !validGroupBy.includes(rawGroupBy as (typeof validGroupBy)[number])) {
+      return {
+        status: 400,
+        body: {
+          error: `Invalid groupBy value '${rawGroupBy}'. Must be one of: ${validGroupBy.join(", ")}`,
+        },
+      };
+    }
+    const summary = getSessionCostSummary({
+      startDate: queryParams.get("startDate") || undefined,
+      endDate: queryParams.get("endDate") || undefined,
+      agentId: queryParams.get("agentId") || undefined,
+      groupBy: (rawGroupBy as "day" | "agent" | "both") || "both",
+    });
+    return { status: 200, body: summary };
+  }
+
+  // GET /api/session-costs/dashboard - Cost today and MTD
+  if (
+    req.method === "GET" &&
+    pathSegments[0] === "api" &&
+    pathSegments[1] === "session-costs" &&
+    pathSegments[2] === "dashboard"
+  ) {
+    const dashboardCosts = getDashboardCostSummary();
+    return { status: 200, body: dashboardCosts };
+  }
+
   // GET /api/session-costs - Query session costs with filters
   if (
     req.method === "GET" &&
@@ -86,12 +126,21 @@ async function handleRequest(
   ) {
     const agentId = queryParams.get("agentId");
     const taskId = queryParams.get("taskId");
+    const startDate = queryParams.get("startDate");
+    const endDate = queryParams.get("endDate");
     const limitParam = queryParams.get("limit");
     const limit = limitParam ? parseInt(limitParam, 10) : 100;
 
     let costs: SessionCost[];
     if (taskId) {
-      costs = getSessionCostsByTaskId(taskId);
+      costs = getSessionCostsByTaskId(taskId, limit);
+    } else if (startDate || endDate) {
+      costs = getSessionCostsFiltered({
+        agentId: agentId || undefined,
+        startDate: startDate || undefined,
+        endDate: endDate || undefined,
+        limit,
+      });
     } else if (agentId) {
       costs = getSessionCostsByAgentId(agentId, limit);
     } else {
@@ -722,4 +771,221 @@ describe("Session Costs API", () => {
       expect(data.cost.outputTokens).toBe(50000);
     });
   });
+
+  describe("Database: getSessionCostsFiltered", () => {
+    test("should filter by date range", () => {
+      const agent = createAgent({ name: "Filter DB Agent", isLead: false, status: "idle" });
+
+      createSessionCost({
+        sessionId: "filtered-db-1",
+        agentId: agent.id,
+        totalCostUsd: 0.1,
+        durationMs: 1000,
+        numTurns: 1,
+        model: "opus",
+      });
+
+      // All records created today, so filtering with today's date should return them
+      const today = new Date().toISOString().slice(0, 10);
+      const results = getSessionCostsFiltered({
+        agentId: agent.id,
+        startDate: today,
+      });
+
+      expect(results.length).toBeGreaterThanOrEqual(1);
+      expect(results.every((r) => r.agentId === agent.id)).toBe(true);
+    });
+
+    test("should return empty for future date range", () => {
+      const results = getSessionCostsFiltered({
+        startDate: "2099-01-01",
+      });
+
+      expect(results.length).toBe(0);
+    });
+
+    test("should respect limit parameter", () => {
+      const agent = createAgent({ name: "Filter Limit Agent", isLead: false, status: "idle" });
+
+      for (let i = 0; i < 5; i++) {
+        createSessionCost({
+          sessionId: `filter-limit-${i}`,
+          agentId: agent.id,
+          totalCostUsd: 0.01,
+          durationMs: 1000,
+          numTurns: 1,
+          model: "opus",
+        });
+      }
+
+      const results = getSessionCostsFiltered({ agentId: agent.id, limit: 2 });
+      expect(results.length).toBe(2);
+    });
+  });
+
+  describe("Database: getSessionCostSummary", () => {
+    test("should return totals, daily, and byAgent", () => {
+      const agent = createAgent({ name: "Summary DB Agent", isLead: false, status: "idle" });
+
+      createSessionCost({
+        sessionId: "summary-db-1",
+        agentId: agent.id,
+        totalCostUsd: 0.5,
+        inputTokens: 1000,
+        outputTokens: 500,
+        cacheReadTokens: 100,
+        cacheWriteTokens: 50,
+        durationMs: 5000,
+        numTurns: 3,
+        model: "opus",
+      });
+
+      const today = new Date().toISOString().slice(0, 10);
+      const summary = getSessionCostSummary({
+        agentId: agent.id,
+        startDate: today,
+        groupBy: "both",
+      });
+
+      expect(summary.totals.totalCostUsd).toBeGreaterThanOrEqual(0.5);
+      expect(summary.totals.totalSessions).toBeGreaterThanOrEqual(1);
+      expect(summary.totals.totalInputTokens).toBeGreaterThanOrEqual(1000);
+      expect(summary.totals.avgCostPerSession).toBeGreaterThan(0);
+      expect(summary.daily.length).toBeGreaterThanOrEqual(1);
+      expect(summary.byAgent.length).toBeGreaterThanOrEqual(1);
+    });
+
+    test("should return only daily when groupBy=day", () => {
+      const summary = getSessionCostSummary({ groupBy: "day" });
+
+      expect(summary.totals).toBeDefined();
+      expect(summary.daily.length).toBeGreaterThanOrEqual(1);
+      expect(summary.byAgent.length).toBe(0);
+    });
+
+    test("should return only byAgent when groupBy=agent", () => {
+      const summary = getSessionCostSummary({ groupBy: "agent" });
+
+      expect(summary.totals).toBeDefined();
+      expect(summary.daily.length).toBe(0);
+      expect(summary.byAgent.length).toBeGreaterThanOrEqual(1);
+    });
+
+    test("should return empty results for future date range", () => {
+      const summary = getSessionCostSummary({
+        startDate: "2099-01-01",
+        groupBy: "both",
+      });
+
+      expect(summary.totals.totalSessions).toBe(0);
+      expect(summary.totals.totalCostUsd).toBe(0);
+      expect(summary.daily.length).toBe(0);
+      expect(summary.byAgent.length).toBe(0);
+    });
+  });
+
+  describe("Database: getDashboardCostSummary", () => {
+    test("should return costToday and costMtd", () => {
+      const result = getDashboardCostSummary();
+
+      expect(typeof result.costToday).toBe("number");
+      expect(typeof result.costMtd).toBe("number");
+      // costMtd should be >= costToday since MTD includes today
+      expect(result.costMtd).toBeGreaterThanOrEqual(result.costToday);
+    });
+  });
+
+  describe("GET /api/session-costs with date filtering", () => {
+    test("should filter by startDate", async () => {
+      const agent = createAgent({ name: "Date Filter Agent", isLead: false, status: "idle" });
+
+      createSessionCost({
+        sessionId: "date-filter-1",
+        agentId: agent.id,
+        totalCostUsd: 0.05,
+        durationMs: 1000,
+        numTurns: 1,
+        model: "opus",
+      });
+
+      const today = new Date().toISOString().slice(0, 10);
+      const response = await fetch(
+        `${baseUrl}/api/session-costs?agentId=${agent.id}&startDate=${today}`,
+      );
+
+      expect(response.status).toBe(200);
+      const data = (await response.json()) as { costs: SessionCost[] };
+      expect(data.costs.length).toBeGreaterThanOrEqual(1);
+    });
+
+    test("should return empty for future startDate", async () => {
+      const response = await fetch(`${baseUrl}/api/session-costs?startDate=2099-01-01`);
+
+      expect(response.status).toBe(200);
+      const data = (await response.json()) as { costs: SessionCost[] };
+      expect(data.costs.length).toBe(0);
+    });
+  });
+
+  describe("GET /api/session-costs/summary", () => {
+    test("should return aggregated summary", async () => {
+      const response = await fetch(`${baseUrl}/api/session-costs/summary`);
+
+      expect(response.status).toBe(200);
+      const data = (await response.json()) as {
+        totals: { totalCostUsd: number; totalSessions: number };
+        daily: unknown[];
+        byAgent: unknown[];
+      };
+      expect(data.totals).toBeDefined();
+      expect(data.totals.totalSessions).toBeGreaterThan(0);
+      expect(data.daily.length).toBeGreaterThan(0);
+      expect(data.byAgent.length).toBeGreaterThan(0);
+    });
+
+    test("should filter by startDate and endDate", async () => {
+      const today = new Date().toISOString().slice(0, 10);
+      const response = await fetch(
+        `${baseUrl}/api/session-costs/summary?startDate=${today}&endDate=${today}`,
+      );
+
+      expect(response.status).toBe(200);
+      const data = (await response.json()) as {
+        totals: { totalSessions: number };
+      };
+      expect(data.totals.totalSessions).toBeGreaterThanOrEqual(0);
+    });
+
+    test("should respect groupBy=day", async () => {
+      const response = await fetch(`${baseUrl}/api/session-costs/summary?groupBy=day`);
+
+      expect(response.status).toBe(200);
+      const data = (await response.json()) as {
+        daily: unknown[];
+        byAgent: unknown[];
+      };
+      expect(data.daily.length).toBeGreaterThan(0);
+      expect(data.byAgent.length).toBe(0);
+    });
+
+    test("should reject invalid groupBy", async () => {
+      const response = await fetch(`${baseUrl}/api/session-costs/summary?groupBy=invalid`);
+
+      expect(response.status).toBe(400);
+      const data = (await response.json()) as { error: string };
+      expect(data.error).toContain("Invalid groupBy");
+    });
+  });
+
+  describe("GET /api/session-costs/dashboard", () => {
+    test("should return costToday and costMtd", async () => {
+      const response = await fetch(`${baseUrl}/api/session-costs/dashboard`);
+
+      expect(response.status).toBe(200);
+      const data = (await response.json()) as { costToday: number; costMtd: number };
+      expect(typeof data.costToday).toBe("number");
+      expect(typeof data.costMtd).toBe("number");
+      expect(data.costMtd).toBeGreaterThanOrEqual(data.costToday);
+    });
+  });
 });

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

@@ -0,0 +1,133 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlinkSync } from "node:fs";
+import {
+  cancelTask,
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  getLeadAgent,
+  getTaskById,
+  initDb,
+} from "../be/db";
+import { buildCancelledBlocks, getTaskLink } from "../slack/blocks";
+
+const TEST_DB_PATH = "./test-slack-actions.sqlite";
+
+let leadAgent: ReturnType<typeof createAgent>;
+let slackTask: ReturnType<typeof createTaskExtended>;
+
+beforeAll(() => {
+  initDb(TEST_DB_PATH);
+  leadAgent = createAgent({ name: "ActionLead", isLead: true, status: "idle" });
+  slackTask = createTaskExtended("original task for actions test", {
+    agentId: leadAgent.id,
+    source: "slack",
+    slackChannelId: "C_ACTIONS",
+    slackThreadTs: "3333333333.000001",
+    slackUserId: "U_ACTIONS",
+  });
+});
+
+afterAll(() => {
+  closeDb();
+  try {
+    unlinkSync(TEST_DB_PATH);
+    unlinkSync(`${TEST_DB_PATH}-wal`);
+    unlinkSync(`${TEST_DB_PATH}-shm`);
+  } catch {
+    // ignore
+  }
+});
+
+describe("follow_up_task action logic", () => {
+  test("getTaskById retrieves the original task", () => {
+    const task = getTaskById(slackTask.id);
+    expect(task).toBeDefined();
+    expect(task!.task).toBe("original task for actions test");
+    expect(task!.slackChannelId).toBe("C_ACTIONS");
+  });
+
+  test("getLeadAgent returns the lead", () => {
+    const lead = getLeadAgent();
+    expect(lead).toBeDefined();
+    expect(lead!.name).toBe("ActionLead");
+  });
+
+  test("creates follow-up task with parentTaskId and custom description", () => {
+    const lead = getLeadAgent()!;
+    const followUpTask = createTaskExtended("Please also check the logs", {
+      agentId: lead.id,
+      source: "slack",
+      parentTaskId: slackTask.id,
+      slackChannelId: "C_ACTIONS",
+      slackThreadTs: "3333333333.000001",
+      slackUserId: "U_ACTIONS",
+    });
+
+    expect(followUpTask).toBeDefined();
+    expect(followUpTask.task).toBe("Please also check the logs");
+    expect(followUpTask.parentTaskId).toBe(slackTask.id);
+
+    const fetched = getTaskById(followUpTask.id);
+    expect(fetched).toBeDefined();
+    expect(fetched!.parentTaskId).toBe(slackTask.id);
+    expect(fetched!.slackChannelId).toBe("C_ACTIONS");
+  });
+
+  test("getTaskLink produces a link for the task", () => {
+    const link = getTaskLink(slackTask.id);
+    expect(link).toBeTruthy();
+    expect(link).toContain(slackTask.id.slice(0, 8));
+  });
+});
+
+describe("cancel_task action logic", () => {
+  test("cancelTask returns task object for a pending task", () => {
+    const agent = createAgent({ name: "CancelAgent", isLead: false, status: "idle" });
+    const task = createTaskExtended("task to cancel", {
+      agentId: agent.id,
+      source: "slack",
+      slackChannelId: "C_CANCEL",
+      slackThreadTs: "4444444444.000001",
+      slackUserId: "U_CANCEL",
+    });
+
+    const result = cancelTask(task.id, "Cancelled via Slack");
+    expect(result).toBeTruthy();
+
+    // Verify task is now cancelled
+    const fetched = getTaskById(task.id);
+    expect(fetched).toBeDefined();
+    expect(fetched!.status).toBe("cancelled");
+  });
+
+  test("cancelTask returns null for already-cancelled task", () => {
+    const agent = createAgent({ name: "CompletedAgent", isLead: false, status: "idle" });
+    const task = createTaskExtended("task to double-cancel", {
+      agentId: agent.id,
+      source: "slack",
+      slackChannelId: "C_DONE",
+      slackThreadTs: "5555555555.000001",
+      slackUserId: "U_DONE",
+    });
+
+    // First cancel succeeds
+    const first = cancelTask(task.id, "First cancel");
+    expect(first).toBeTruthy();
+
+    // Second cancel returns null — already in terminal state
+    const second = cancelTask(task.id, "Second cancel");
+    expect(second).toBeNull();
+  });
+
+  test("buildCancelledBlocks produces correct blocks for cancelled task", () => {
+    const blocks = buildCancelledBlocks({
+      agentName: "Alpha",
+      taskId: slackTask.id,
+    });
+
+    expect(blocks.length).toBe(1);
+    expect(blocks[0].type).toBe("section");
+    expect(blocks[0].text.text).toContain("Cancelled");
+  });
+});

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

@@ -0,0 +1,136 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlinkSync } from "node:fs";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  getAgentWorkingOnThread,
+  getLeadAgent,
+  getTaskById,
+  initDb,
+} from "../be/db";
+
+const TEST_DB_PATH = "./test-slack-assistant.sqlite";
+
+let _leadAgent: ReturnType<typeof createAgent>;
+
+beforeAll(() => {
+  initDb(TEST_DB_PATH);
+  _leadAgent = createAgent({ name: "AssistantLead", isLead: true, status: "idle" });
+});
+
+afterAll(() => {
+  closeDb();
+  try {
+    unlinkSync(TEST_DB_PATH);
+    unlinkSync(`${TEST_DB_PATH}-wal`);
+    unlinkSync(`${TEST_DB_PATH}-shm`);
+  } catch {
+    // ignore
+  }
+});
+
+describe("assistant userMessage routing — new thread (no working agent)", () => {
+  test("getAgentWorkingOnThread returns null when no tasks exist for thread", () => {
+    const result = getAgentWorkingOnThread("D_ASSISTANT", "6666666666.000001");
+    expect(result).toBeNull();
+  });
+
+  test("getLeadAgent returns the lead agent for task assignment", () => {
+    const lead = getLeadAgent();
+    expect(lead).toBeDefined();
+    expect(lead!.name).toBe("AssistantLead");
+    expect(lead!.isLead).toBe(true);
+  });
+
+  test("creates task with slack context for new assistant thread message", () => {
+    const lead = getLeadAgent()!;
+    const task = createTaskExtended("What's the status of all agents?", {
+      agentId: lead.id,
+      source: "slack",
+      slackChannelId: "D_ASSISTANT",
+      slackThreadTs: "7777777777.000001",
+      slackUserId: "U_ASSISTANT",
+    });
+
+    expect(task).toBeDefined();
+    expect(task.task).toBe("What's the status of all agents?");
+    expect(task.source).toBe("slack");
+
+    const fetched = getTaskById(task.id);
+    expect(fetched).toBeDefined();
+    expect(fetched!.slackChannelId).toBe("D_ASSISTANT");
+    expect(fetched!.slackThreadTs).toBe("7777777777.000001");
+    expect(fetched!.slackUserId).toBe("U_ASSISTANT");
+  });
+
+  test("queues task without agentId when no lead is available", () => {
+    // Create a task without agentId (simulates no lead scenario)
+    const task = createTaskExtended("queued task, no lead", {
+      source: "slack",
+      slackChannelId: "D_NOHEAD",
+      slackThreadTs: "8888888888.000001",
+      slackUserId: "U_NOHEAD",
+    });
+
+    expect(task).toBeDefined();
+    const fetched = getTaskById(task.id);
+    expect(fetched).toBeDefined();
+    // Task should be created but unassigned (pending or similar status)
+    expect(fetched!.agentId).toBeNull();
+  });
+});
+
+describe("assistant userMessage routing — follow-up (working agent exists)", () => {
+  test("getAgentWorkingOnThread returns the agent working on an active thread task", () => {
+    const worker = createAgent({ name: "ThreadWorker", isLead: false, status: "idle" });
+    createTaskExtended("initial task in thread", {
+      agentId: worker.id,
+      source: "slack",
+      slackChannelId: "D_FOLLOWUP",
+      slackThreadTs: "9999999999.000001",
+      slackUserId: "U_FOLLOWUP",
+    });
+
+    const result = getAgentWorkingOnThread("D_FOLLOWUP", "9999999999.000001");
+    expect(result).toBeDefined();
+    expect(result!.name).toBe("ThreadWorker");
+  });
+
+  test("creates follow-up task assigned to the working agent", () => {
+    const workingAgent = getAgentWorkingOnThread("D_FOLLOWUP", "9999999999.000001");
+    expect(workingAgent).toBeDefined();
+
+    const followUp = createTaskExtended("follow-up message in assistant thread", {
+      agentId: workingAgent!.id,
+      source: "slack",
+      slackChannelId: "D_FOLLOWUP",
+      slackThreadTs: "9999999999.000001",
+      slackUserId: "U_FOLLOWUP",
+    });
+
+    expect(followUp).toBeDefined();
+    expect(followUp.agentId).toBe(workingAgent!.id);
+
+    const fetched = getTaskById(followUp.id);
+    expect(fetched).toBeDefined();
+    expect(fetched!.slackChannelId).toBe("D_FOLLOWUP");
+    expect(fetched!.slackThreadTs).toBe("9999999999.000001");
+  });
+});
+
+describe("assistant thread title truncation", () => {
+  test("short messages stay as-is", () => {
+    const text = "Check agent status";
+    const title = text.length > 50 ? `${text.slice(0, 47)}...` : text;
+    expect(title).toBe("Check agent status");
+  });
+
+  test("long messages get truncated to 50 chars", () => {
+    const text =
+      "This is a very long message that definitely exceeds the fifty character limit for thread titles";
+    const title = text.length > 50 ? `${text.slice(0, 47)}...` : text;
+    expect(title).toBe("This is a very long message that definitely exc...");
+    expect(title.length).toBe(50);
+  });
+});