@desplega.ai/agent-swarm 2.5.4 → 2.7.0

package/src/tests/status.test.ts

@@ -864,30 +864,30 @@ describe("validateProviderCredentials — error scrubbing", () => {
     expect(result.error).toContain("ANTHROPIC_API_KEY");
   });
 
-  test("claude with CLAUDE_CODE_OAUTH_TOKEN passes via presence check (no upstream call)", async () => {
+  test("claude with CLAUDE_CODE_OAUTH_TOKEN checks the token against the OAuth profile", async () => {
     delete process.env.ANTHROPIC_API_KEY;
     process.env.CLAUDE_CODE_OAUTH_TOKEN = "sk-ant-oat01-fake-oauth-token";
-    let fetchCalled = false;
-    globalThis.fetch = (async () => {
-      fetchCalled = true;
+    const urls: string[] = [];
+    globalThis.fetch = (async (url: string | URL | Request) => {
+      urls.push(String(url));
       return new Response("{}", { status: 200 });
     }) as typeof fetch;
     const result = await validateProviderCredentials("claude");
     expect(result.ok).toBe(true);
-    expect(fetchCalled).toBe(false);
+    expect(urls).toEqual(["https://api.anthropic.com/api/oauth/profile"]);
   });
 
-  test("claude prefers OAuth presence check over API-key live call when both are set", async () => {
+  test("claude prefers the OAuth check over the API-key check when both are set", async () => {
     process.env.ANTHROPIC_API_KEY = "sk-ant-api-fake-1234";
     process.env.CLAUDE_CODE_OAUTH_TOKEN = "sk-ant-oat01-fake-oauth";
-    let fetchCalled = false;
-    globalThis.fetch = (async () => {
-      fetchCalled = true;
+    const urls: string[] = [];
+    globalThis.fetch = (async (url: string | URL | Request) => {
+      urls.push(String(url));
       return new Response("{}", { status: 200 });
     }) as typeof fetch;
     const result = await validateProviderCredentials("claude");
     expect(result.ok).toBe(true);
-    expect(fetchCalled).toBe(false);
+    expect(urls).toEqual(["https://api.anthropic.com/api/oauth/profile"]);
   });
 
   test("codex with valid CODEX_OAUTH JSON passes via presence check (no upstream call)", async () => {
@@ -1212,10 +1212,10 @@ describe("computeHealth (Phase 2)", () => {
     expect((harness.providers ?? []).map((p) => p.provider)).toEqual(["claude"]);
   });
 
-  test("`ok` when workers are `configured` (heartbeat drift is a runtime concern, not setup health)", async () => {
+  test("`ok` when workers are `configured` and the seeded lead is `idle`", async () => {
     // Workers in `configured` state means agents exist but haven't posted a
-    // heartbeat in the last 5 minutes. This is surfaced on /agents and the
-    // dashboard canvas — it should NOT degrade the header health dot.
+    // heartbeat in the last 5 minutes. Health reads the lead's status, not
+    // its heartbeat: this lead is `idle`, so it can take work.
     const lead = await createAgent({
       name: "lead-d",
       isLead: true,
@@ -1229,9 +1229,92 @@ describe("computeHealth (Phase 2)", () => {
     });
     const payload = await buildStatusPayload();
     expect(getMilestone(payload, "workers").state).toBe("configured");
+    expect(payload.activity.leads_ready).toBe(1);
+    expect(payload.health).toBe("ok");
+  });
+
+  test("`ok` for an idle lead with a stale heartbeat and no worker heartbeat", async () => {
+    const lead = await createAgent({
+      name: "lead-idle",
+      isLead: true,
+      status: "idle",
+      capabilities: [],
+    });
+    const worker = await createAgent({
+      name: "worker-quiet",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+    // The lead last ran a session an hour ago. The worker never heartbeated.
+    const hourAgo = new Date(Date.now() - 3_600_000).toISOString();
+    await getDbClient().run(`UPDATE agents SET lastActivityAt = ? WHERE id = ?`, [
+      hourAgo,
+      lead.id,
+    ]);
+    const pass = { ok: true, error: null, latency_ms: 12, testedAt: Date.now() };
+    await seedCredStatus(lead.id, "claude", { ready: true, satisfiedBy: "env", liveTest: pass });
+    await seedCredStatus(worker.id, "claude", { ready: true, satisfiedBy: "env", liveTest: pass });
+
+    const payload = await buildStatusPayload();
+    expect(payload.activity.leads_online).toBe(0);
+    expect(payload.activity.leads_ready).toBe(1);
     expect(payload.health).toBe("ok");
   });
 
+  test("`degraded` when no lead row exists", async () => {
+    const worker = await createAgent({
+      name: "worker-alone",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+    await updateAgentActivity(worker.id);
+    await seedCredStatus(worker.id, "claude", {
+      ready: true,
+      satisfiedBy: "env",
+      liveTest: { ok: true, error: null, latency_ms: 12, testedAt: Date.now() },
+    });
+
+    const payload = await buildStatusPayload();
+    expect(getMilestone(payload, "harness").state).toBe("verified");
+    expect(payload.activity.leads_ready).toBe(0);
+    expect(payload.health).toBe("degraded");
+  });
+
+  test("`degraded` when the only lead is offline", async () => {
+    const lead = await createAgent({
+      name: "lead-gone",
+      isLead: true,
+      status: "offline",
+      capabilities: [],
+    });
+    const worker = await createAgent({
+      name: "worker-left",
+      isLead: false,
+      status: "idle",
+      capabilities: [],
+    });
+    await updateAgentActivity(worker.id);
+    const pass = { ok: true, error: null, latency_ms: 12, testedAt: Date.now() };
+    await seedCredStatus(lead.id, "claude", { ready: true, satisfiedBy: "env", liveTest: pass });
+    await seedCredStatus(worker.id, "claude", { ready: true, satisfiedBy: "env", liveTest: pass });
+
+    const payload = await buildStatusPayload();
+    expect(getMilestone(payload, "harness").state).toBe("verified");
+    expect(payload.activity.leads_ready).toBe(0);
+    expect(payload.health).toBe("degraded");
+  });
+
+  test("no ready lead degrades an otherwise `ok` rollup", () => {
+    const synthetic: SetupMilestone[] = [
+      { id: "harness", label: "Harness", state: "verified" },
+      { id: "workers", label: "Workers", state: "verified" },
+    ];
+    expect(computeHealth(synthetic, 1)).toBe("ok");
+    expect(computeHealth(synthetic, 0)).toBe("degraded");
+  });
+
   test("`ok` when harness verified and workers verified (no other integration is `configured`)", () => {
     // We can't reach the in-memory cache from here, so simulate by directly
     // checking the helper: build a synthetic milestone array.
@@ -1245,7 +1328,7 @@ describe("computeHealth (Phase 2)", () => {
       { id: "workers", label: "Workers", state: "verified" },
       { id: "first_task", label: "First task", state: "verified" },
     ];
-    expect(computeHealth(synthetic)).toBe("ok");
+    expect(computeHealth(synthetic, 1)).toBe("ok");
   });
 
   test("`degraded` when an integration is `configured`", () => {
@@ -1258,7 +1341,7 @@ describe("computeHealth (Phase 2)", () => {
       { id: "workers", label: "Workers", state: "verified" },
       { id: "first_task", label: "First task", state: "verified" },
     ];
-    expect(computeHealth(synthetic)).toBe("degraded");
+    expect(computeHealth(synthetic, 1)).toBe("degraded");
   });
 
   test("`ok` when a connected Slack reports `verified` next to other connected integrations", () => {
@@ -1271,7 +1354,7 @@ describe("computeHealth (Phase 2)", () => {
       { id: "workers", label: "Workers", state: "verified" },
       { id: "first_task", label: "First task", state: "verified" },
     ];
-    expect(computeHealth(synthetic)).toBe("ok");
+    expect(computeHealth(synthetic, 1)).toBe("ok");
   });
 
   test("integrations in `unverified` alone do NOT degrade health", () => {
@@ -1286,7 +1369,7 @@ describe("computeHealth (Phase 2)", () => {
       { id: "workers", label: "Workers", state: "verified" },
       { id: "first_task", label: "First task", state: "unverified" },
     ];
-    expect(computeHealth(synthetic)).toBe("ok");
+    expect(computeHealth(synthetic, 1)).toBe("ok");
   });
 
   test("an unverified embedding key never blocks boot or degrades health", () => {
@@ -1295,7 +1378,7 @@ describe("computeHealth (Phase 2)", () => {
       { id: "embeddings", label: "Memory search", state: "unverified" },
       { id: "workers", label: "Workers", state: "verified" },
     ];
-    expect(computeHealth(synthetic)).toBe("ok");
+    expect(computeHealth(synthetic, 1)).toBe("ok");
   });
 });
 

package/src/tests/store-progress-learning.test.ts

@@ -0,0 +1,288 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { ZodType } from "zod";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  getDb,
+  getTaskById,
+  initDb,
+  startTask,
+} from "../be/db";
+import { registerStoreProgressTool } from "../tools/store-progress";
+
+interface ToolResult {
+  isError?: boolean;
+  structuredContent?: Record<string, unknown>;
+}
+
+const agentId = "dddd0000-0000-4000-8000-000000000b01";
+
+const server = new McpServer({ name: "store-progress-learning", version: "1.0.0" });
+registerStoreProgressTool(server);
+const tool = (
+  server as unknown as {
+    _registeredTools: Record<
+      string,
+      {
+        inputSchema: ZodType;
+        handler: (args: unknown, meta: unknown) => Promise<ToolResult>;
+      }
+    >;
+  }
+)._registeredTools["store-progress"]!;
+
+async function call(args: Record<string, unknown>) {
+  return tool.handler(tool.inputSchema.parse(args), {
+    sessionId: "store-progress-learning-session",
+    requestInfo: { headers: { "x-agent-id": agentId } },
+  });
+}
+
+async function task(vcsRepo?: string) {
+  const row = await createTaskExtended("learning capture", {
+    agentId,
+    source: "system",
+    followUpConfig: { disabled: true },
+    ...(vcsRepo ? { vcsRepo } : {}),
+  });
+  await startTask(row.id);
+  return row;
+}
+
+interface MemoryRow {
+  id: string;
+  agentId: string | null;
+  key: string;
+  name: string;
+  scope: string;
+  source: string;
+  sourceTaskId: string;
+  tags: string;
+  content: string;
+}
+
+function learningRows(taskId: string): MemoryRow[] {
+  return getDb()
+    .query<MemoryRow, [string]>(
+      "SELECT id, agentId, key, name, scope, source, sourceTaskId, tags, content FROM agent_memory WHERE sourceTaskId = ? AND key LIKE '/learnings/%' ORDER BY createdAt",
+    )
+    .all(taskId);
+}
+
+function learningData(result: ToolResult) {
+  return result.structuredContent?.learning as
+    | { status: string; key?: string; error?: string }
+    | undefined;
+}
+
+function message(result: ToolResult) {
+  return String(result.structuredContent?.message);
+}
+
+const originalEmbeddingKey = process.env.EMBEDDING_API_KEY;
+const originalOpenAiKey = process.env.OPENAI_API_KEY;
+beforeAll(async () => {
+  process.env.EMBEDDING_API_KEY = "";
+  process.env.OPENAI_API_KEY = "";
+  initDb(":memory:");
+  await createAgent({ id: agentId, name: "Learner", isLead: false, status: "idle" });
+});
+afterAll(() => {
+  closeDb();
+  if (originalEmbeddingKey === undefined) delete process.env.EMBEDDING_API_KEY;
+  else process.env.EMBEDDING_API_KEY = originalEmbeddingKey;
+  if (originalOpenAiKey === undefined) delete process.env.OPENAI_API_KEY;
+  else process.env.OPENAI_API_KEY = originalOpenAiKey;
+});
+
+describe("store-progress learning", () => {
+  test("stores a swarm manual memory under the explicit workstream", async () => {
+    const t = await task("desplega-ai/agent-swarm");
+    const result = await call({
+      taskId: t.id,
+      progress: "found the cause",
+      learning: {
+        text: "SQLite BUSY needs BEGIN IMMEDIATE\nA deferred BEGIN that reads first fails with BUSY_SNAPSHOT.",
+        workstream: "DB Runtime",
+        tags: ["SQLite", "gotcha", "learning"],
+      },
+    });
+
+    expect(result.isError).toBeFalsy();
+    expect(learningData(result)?.status).toBe("stored");
+    expect(message(result)).toContain(
+      "Learning stored at /learnings/db-runtime/sqlite-busy-needs-begin-immediate.",
+    );
+    const [row, ...rest] = learningRows(t.id);
+    expect(rest).toHaveLength(0);
+    expect(row).toMatchObject({
+      agentId,
+      key: "/learnings/db-runtime/sqlite-busy-needs-begin-immediate",
+      name: "SQLite BUSY needs BEGIN IMMEDIATE",
+      scope: "swarm",
+      source: "manual",
+      sourceTaskId: t.id,
+    });
+    expect(JSON.parse(row!.tags)).toEqual(["learning", "sqlite", "gotcha"]);
+    expect((await getTaskById(t.id))?.progress).toBe("found the cause");
+  });
+
+  test("string form falls back to the repo name, then to general", async () => {
+    const withRepo = await task("desplega-ai/agent-swarm");
+    await call({ taskId: withRepo.id, learning: "Run lint before tsc" });
+    expect(learningRows(withRepo.id)[0]?.key).toBe("/learnings/agent-swarm/run-lint-before-tsc");
+
+    const withoutRepo = await task();
+    const result = await call({ taskId: withoutRepo.id, learning: { text: "Prefer scripts" } });
+    expect(learningData(result)).toMatchObject({ status: "stored", workstream: "general" });
+    expect(learningRows(withoutRepo.id)[0]?.key).toBe("/learnings/general/prefer-scripts");
+  });
+
+  test("a taken key gets a short suffix instead of failing", async () => {
+    const first = await task();
+    const second = await task();
+    await call({ taskId: first.id, learning: "Same title\nfirst body" });
+    const result = await call({ taskId: second.id, learning: "Same title\nsecond body" });
+
+    expect(learningData(result)?.status).toBe("stored");
+    expect(learningRows(first.id)[0]?.key).toBe("/learnings/general/same-title");
+    expect(learningRows(second.id)[0]?.key).toMatch(
+      /^\/learnings\/general\/same-title-[0-9a-f]{6}$/,
+    );
+  });
+
+  test("an exact replay on the same task is skipped", async () => {
+    const t = await task();
+    await call({ taskId: t.id, learning: "Replay me" });
+    const replay = await call({ taskId: t.id, progress: "again", learning: "Replay me" });
+
+    expect(learningData(replay)).toMatchObject({
+      status: "replayed",
+      key: "/learnings/general/replay-me",
+    });
+    expect(learningRows(t.id)).toHaveLength(1);
+  });
+
+  test("overlapping calls with the same learning store it once", async () => {
+    const t = await task();
+    const learning = "Concurrent replay\nKeep exactly one copy of this lesson.";
+    const results = await Promise.all([
+      call({ taskId: t.id, learning }),
+      call({ taskId: t.id, learning }),
+    ]);
+
+    expect(learningRows(t.id)).toHaveLength(1);
+    expect(results.map((result) => learningData(result)?.status).sort()).toEqual([
+      "replayed",
+      "stored",
+    ]);
+  });
+
+  // Synthetic token, built at runtime so no literal credential sits in the repo.
+  const token = `ghp_${"abcd1234".repeat(5)}`;
+  const kebabToken = token.replace("_", "-");
+
+  test("a secret in the title, workstream or tags never reaches the key or tags", async () => {
+    const t = await task();
+    const result = await call({
+      taskId: t.id,
+      learning: {
+        text: `${token}\nKeep credentials out of memory.`,
+        workstream: token,
+        tags: [token],
+      },
+    });
+
+    expect(learningData(result)?.status).toBe("stored");
+    const [row] = learningRows(t.id);
+    for (const field of [row!.key, row!.name, row!.tags, row!.content, learningData(result)?.key]) {
+      expect(field).not.toContain(token);
+      expect(field).not.toContain(kebabToken);
+    }
+    expect(row!.content).toContain("[REDACTED:");
+  });
+
+  test("a replay of a secret-bearing learning is still detected", async () => {
+    const t = await task();
+    const learning = `Redact diagnostic tokens\nExample token: ${token}`;
+    await call({ taskId: t.id, learning });
+    const replay = await call({ taskId: t.id, learning });
+
+    expect(learningData(replay)?.status).toBe("replayed");
+    expect(learningRows(t.id)).toHaveLength(1);
+  });
+
+  test("a failed learning write leaves the progress write intact", async () => {
+    const t = await task();
+    getDb().run(
+      "CREATE TEMP TRIGGER fail_learning BEFORE INSERT ON agent_memory WHEN NEW.key LIKE '/learnings/%' BEGIN SELECT RAISE(ABORT, 'learning insert refused'); END",
+    );
+    try {
+      const result = await call({
+        taskId: t.id,
+        progress: "progress survives",
+        status: "completed",
+        output: "done",
+        learning: "This write fails",
+      });
+      expect(result.isError).toBeFalsy();
+      expect(learningData(result)).toMatchObject({ status: "failed" });
+      expect(learningData(result)?.error).toContain("learning insert refused");
+      expect(message(result)).toContain("Learning not stored:");
+    } finally {
+      getDb().run("DROP TRIGGER fail_learning");
+    }
+    const stored = await getTaskById(t.id);
+    expect(stored?.progress).toBe("progress survives");
+    expect(stored?.status).toBe("completed");
+    expect(learningRows(t.id)).toHaveLength(0);
+  });
+
+  test("invalid learnings are reported without blocking progress", async () => {
+    const t = await task();
+    const tooManyTags = await call({
+      taskId: t.id,
+      progress: "still stored",
+      learning: { text: "Tagged", tags: ["a", "b", "c", "d", "e", "f"] },
+    });
+    expect(learningData(tooManyTags)).toMatchObject({
+      status: "failed",
+      error: "learning takes at most 5 tags",
+    });
+    const tooLong = await call({ taskId: t.id, learning: "x".repeat(2001) });
+    expect(learningData(tooLong)?.status).toBe("failed");
+    expect((await getTaskById(t.id))?.progress).toBe("still stored");
+    expect(learningRows(t.id)).toHaveLength(0);
+  });
+
+  test("a learning on the completing call is stored", async () => {
+    const t = await task();
+    const result = await call({
+      taskId: t.id,
+      status: "completed",
+      output: "done",
+      learning: "Ship on the completing call",
+    });
+    expect(learningData(result)?.status).toBe("stored");
+    expect((await getTaskById(t.id))?.status).toBe("completed");
+  });
+
+  test("a call on a finished task stores nothing", async () => {
+    const t = await task();
+    await call({ taskId: t.id, status: "completed", output: "done" });
+    const late = await call({
+      taskId: t.id,
+      status: "completed",
+      output: "done",
+      learning: "Too late",
+    });
+    expect(late.structuredContent).toMatchObject({ wasNoOp: true });
+    expect(learningData(late)?.status).toBe("failed");
+
+    const progressOnly = await call({ taskId: t.id, learning: "Still too late" });
+    expect(learningData(progressOnly)?.status).toBe("failed");
+    expect(learningRows(t.id)).toHaveLength(0);
+  });
+});

package/src/tests/tasks-workflow-run-filter.test.ts

@@ -0,0 +1,146 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  createServer as createHttpServer,
+  type IncomingMessage,
+  type Server,
+  type ServerResponse,
+} from "node:http";
+import {
+  closeDb,
+  createAgent,
+  createTaskExtended,
+  createWorkflow,
+  createWorkflowRun,
+  getAllTasks,
+  getTasksCount,
+  initDb,
+} from "../be/db";
+import { handleCore } from "../http/core";
+import { handleTasks } from "../http/tasks";
+import { getPathSegments, parseQueryParams } from "../http/utils";
+import { listenOnFreePort } from "./test-net";
+
+const TEST_DB_PATH = "./test-tasks-workflow-run-filter.sqlite";
+const API_KEY = "test-tasks-workflow-run-filter";
+
+async function removeDbFiles(path: string): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(path + suffix);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+  }
+}
+
+function createTestServer(apiKey: string): Server {
+  return createHttpServer(async (req: IncomingMessage, res: ServerResponse) => {
+    const myAgentId = req.headers["x-agent-id"] as string | undefined;
+    const handled = await handleCore(req, res, myAgentId, apiKey);
+    if (handled) return;
+    const pathSegments = getPathSegments(req.url || "");
+    const queryParams = parseQueryParams(req.url || "");
+    const ok = await handleTasks(req, res, pathSegments, queryParams, myAgentId);
+    if (!ok) {
+      res.writeHead(404);
+      res.end("Not Found");
+    }
+  });
+}
+
+describe("workflowRunId task filter", () => {
+  let server: Server;
+  let port: number;
+  let agentId: string;
+  let runAId: string;
+  let runATaskIds: string[];
+  let runBTaskId: string;
+  let noRunTaskId: string;
+
+  beforeAll(async () => {
+    await removeDbFiles(TEST_DB_PATH);
+    initDb(TEST_DB_PATH);
+    agentId = (
+      await createAgent({ name: "workflow-run-filter-agent", isLead: false, status: "idle" })
+    ).id;
+    const workflow = await createWorkflow({
+      name: `workflow-run-filter-${crypto.randomUUID()}`,
+      definition: { nodes: [] },
+    });
+    const runA = await createWorkflowRun({ id: crypto.randomUUID(), workflowId: workflow.id });
+    const runB = await createWorkflowRun({ id: crypto.randomUUID(), workflowId: workflow.id });
+    runAId = runA.id;
+    runATaskIds = [
+      (
+        await createTaskExtended("run A — step 1", {
+          agentId,
+          source: "workflow",
+          workflowRunId: runA.id,
+        })
+      ).id,
+      (
+        await createTaskExtended("run A — step 2", {
+          agentId,
+          source: "workflow",
+          workflowRunId: runA.id,
+        })
+      ).id,
+    ];
+    runBTaskId = (
+      await createTaskExtended("run B — step 1", {
+        agentId,
+        source: "workflow",
+        workflowRunId: runB.id,
+      })
+    ).id;
+    noRunTaskId = (await createTaskExtended("task outside any run", { agentId })).id;
+
+    server = createTestServer(API_KEY);
+    port = await listenOnFreePort(server);
+  });
+
+  afterAll(async () => {
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+    closeDb();
+    await removeDbFiles(TEST_DB_PATH);
+  });
+
+  function listTasks(query: string): Promise<Response> {
+    return fetch(`http://localhost:${port}/api/tasks?${query}`, {
+      headers: { Authorization: `Bearer ${API_KEY}`, "X-Agent-ID": agentId },
+    });
+  }
+
+  test("getAllTasks and getTasksCount return only the run's tasks", async () => {
+    const tasks = await getAllTasks({ workflowRunId: runAId });
+    expect(tasks.map((t) => t.id).sort()).toEqual([...runATaskIds].sort());
+    expect(await getTasksCount({ workflowRunId: runAId })).toBe(2);
+  });
+
+  for (const fields of ["slim", "full", "timeline"] as const) {
+    test(`GET /api/tasks?workflowRunId with fields=${fields} returns only the run's tasks`, async () => {
+      const res = await listTasks(`workflowRunId=${runAId}&fields=${fields}&includeTotal=true`);
+      expect(res.status).toBe(200);
+      const body = (await res.json()) as { tasks: { id: string }[]; total: number };
+      const ids = body.tasks.map((t) => t.id);
+      expect(ids.sort()).toEqual([...runATaskIds].sort());
+      expect(ids).not.toContain(runBTaskId);
+      expect(ids).not.toContain(noRunTaskId);
+      expect(body.total).toBe(2);
+    });
+  }
+
+  test("an unknown run returns an empty list and zero total", async () => {
+    const res = await listTasks(`workflowRunId=${crypto.randomUUID()}&includeTotal=true`);
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as { tasks: unknown[]; total: number };
+    expect(body.tasks).toEqual([]);
+    expect(body.total).toBe(0);
+  });
+
+  test("a non-UUID workflowRunId is rejected", async () => {
+    const res = await listTasks("workflowRunId=not-a-uuid");
+    expect(res.status).toBe(400);
+  });
+});

package/src/tests/test-net.ts

@@ -6,6 +6,8 @@
  * Always bind an OS-assigned port: `listenOnFreePort(server)` for an
  * in-process `node:http` server, `getFreePort()` for a port that must be known
  * before the server exists (spawned `src/http.ts` children take it via `PORT`).
+ * A spawned child can lose that port before it binds; `startOnFreePort` retries
+ * it on a new one.
  */
 import { createServer, type Server } from "node:net";
 
@@ -27,6 +29,35 @@ export function getFreePort(): Promise<number> {
   });
 }
 
+/** Matches the boot error a server prints when its port is already bound. */
+export const PORT_IN_USE_LOG = /EADDRINUSE|Is port \d+ in use\?/;
+
+/** Thrown by a `startOnFreePort` callback when the server lost its port to another process. */
+export class PortInUseError extends Error {}
+
+/**
+ * Start a server on a getFreePort() port, and on a new port when `start`
+ * throws PortInUseError. getFreePort() releases the port before the spawned
+ * server binds it, and under `bun test --parallel` another process can take
+ * it during the server's boot. Any other error, or the last attempt's
+ * PortInUseError, propagates unchanged.
+ */
+export async function startOnFreePort<T>(
+  start: (port: number) => Promise<T>,
+  opts: { attempts?: number; getPort?: () => Promise<number> } = {},
+): Promise<T> {
+  const attempts = opts.attempts ?? 3;
+  const getPort = opts.getPort ?? getFreePort;
+  for (let attempt = 1; ; attempt++) {
+    const port = await getPort();
+    try {
+      return await start(port);
+    } catch (error) {
+      if (!(error instanceof PortInUseError) || attempt >= attempts) throw error;
+    }
+  }
+}
+
 /**
  * Bind `server` to port 0 and return the assigned port. Binds all interfaces
  * unless `host` is given, matching a bare `server.listen(0)`, so

package/src/tests/transcription.test.ts

@@ -207,6 +207,14 @@ describe("provider key fallback", () => {
     });
   });
 
+  test("a pooled OPENAI_API_KEY sends one member", async () => {
+    process.env.OPENAI_API_KEY = `${OPENAI_FAKE}-a,${OPENAI_FAKE}-b`;
+    const apiKey = resolveTranscriptionConfig()?.apiKey;
+    expect([`${OPENAI_FAKE}-a`, `${OPENAI_FAKE}-b`]).toContain(apiKey);
+    await transcribeAudio(audio);
+    expect(captured[0]?.authorization).toMatch(new RegExp(`^Bearer ${OPENAI_FAKE}-[ab]$`));
+  });
+
   test("GROQ_API_KEY alone uses Groq's OpenAI-compatible endpoint and whisper model", async () => {
     process.env.GROQ_API_KEY = GROQ_FAKE;
     expect(resolveTranscriptionConfig()).toMatchObject({