@desplega.ai/agent-swarm 1.158.0 → 1.160.0

package/src/tests/credential-outcome-report.test.ts

@@ -0,0 +1,171 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { reportCredentialOutcomeThenFinish } from "../commands/credential-outcome-report";
+import { type ApiConfig, ensureTaskFinished } from "../commands/runner";
+import type { ProviderResult } from "../providers/types";
+
+/**
+ * Completion-path regression for a `credits_required` seat mismatch. The
+ * runner finishes every task through `reportCredentialOutcomeThenFinish`,
+ * so this drives the same function with the runner's real
+ * `ensureTaskFinished` as the finish step. It asserts that a delayed seat
+ * report lands before `POST /api/tasks/:id/finish`, and that no key-wide
+ * `/api/keys/report-rate-limit` is sent.
+ */
+
+interface RecordedRequest {
+  method: string;
+  path: string;
+  body: Record<string, unknown> | null;
+  at: number;
+}
+
+const SEAT_REPORT_DELAY_MS = 150;
+let requests: RecordedRequest[] = [];
+let seatReportRespondedAt: number | undefined;
+let originalFetch: typeof fetch;
+
+beforeAll(() => {
+  originalFetch = globalThis.fetch;
+  // Records each request when the fetch starts, so a fire-and-forget report
+  // is visible to the assertions even if nobody awaits it.
+  globalThis.fetch = (async (input, init) => {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    const path = new URL(url).pathname;
+    const method = init?.method ?? "GET";
+    const rawBody = typeof init?.body === "string" ? init.body : "";
+    requests.push({ method, path, body: rawBody ? JSON.parse(rawBody) : null, at: Date.now() });
+
+    if (path === "/api/keys/report-seat-mismatch") {
+      await Bun.sleep(SEAT_REPORT_DELAY_MS);
+      seatReportRespondedAt = Date.now();
+      return Response.json({ success: true, message: "recorded" });
+    }
+    if (method === "POST" && /^\/api\/tasks\/[^/]+\/finish$/.test(path)) {
+      return Response.json({ success: true, task: { status: "failed" } });
+    }
+    return Response.json({ success: true });
+  }) as typeof fetch;
+});
+
+afterAll(() => {
+  globalThis.fetch = originalFetch;
+});
+
+beforeEach(() => {
+  requests = [];
+  seatReportRespondedAt = undefined;
+});
+
+const apiConfig: ApiConfig = {
+  apiUrl: "http://credential-outcome-report.test",
+  apiKey: "example-test-key",
+  agentId: "00000000-0000-4000-8000-000000000001",
+};
+
+const credentialInfo = { keyType: "CLAUDE_CODE_OAUTH_TOKEN", keySuffix: "TJAAA", keyIndex: 3 };
+
+async function completeTask(taskId: string, result: ProviderResult, model: string) {
+  const modelWindowBlocks = new Map<string, number>();
+  await reportCredentialOutcomeThenFinish(
+    {
+      apiUrl: apiConfig.apiUrl,
+      apiKey: apiConfig.apiKey,
+      credentialInfo,
+      result,
+      failureReason: result.failureReason,
+      model,
+      codexCreditsExhaustedCooldownMs: 2 * 60 * 60 * 1000,
+      modelWindowBlocks,
+    },
+    () =>
+      ensureTaskFinished(
+        apiConfig,
+        "worker",
+        taskId,
+        result.exitCode,
+        result.failureReason,
+        undefined,
+        "claude",
+      ),
+  );
+  return { modelWindowBlocks };
+}
+
+describe("reportCredentialOutcomeThenFinish — credits_required seat mismatch", () => {
+  const cases: Array<{ name: string; result: Omit<ProviderResult, "exitCode" | "isError"> }> = [
+    {
+      name: "failure text",
+      result: {
+        sessionId: "session-1",
+        failureReason: "Fable 5.1 requires usage credits. Switch to another model to continue.",
+      },
+    },
+    {
+      name: "structured credits_required event",
+      result: {
+        sessionId: "session-2",
+        failureReason: "Claude process exited with code 1",
+        creditsRequired: {
+          observedAt: new Date().toISOString(),
+          overageDisabledReason: "member_zero_credit_limit",
+        },
+      },
+    },
+  ];
+
+  for (const { name, result } of cases) {
+    test(`${name}: seat report lands before /finish and no key-wide report is sent`, async () => {
+      const taskId = "11111111-1111-4111-8111-111111111111";
+      const { modelWindowBlocks } = await completeTask(
+        taskId,
+        { exitCode: 1, isError: true, ...result },
+        "claude-fable-5-1",
+      );
+
+      const seatReports = requests.filter((r) => r.path === "/api/keys/report-seat-mismatch");
+      expect(seatReports).toHaveLength(1);
+      expect(seatReports[0]?.method).toBe("POST");
+      expect(seatReports[0]?.body).toEqual({
+        keyType: "CLAUDE_CODE_OAUTH_TOKEN",
+        keySuffix: "TJAAA",
+        keyIndex: 3,
+        model: "fable",
+      });
+
+      const finish = requests.find((r) => r.path === `/api/tasks/${taskId}/finish`);
+      expect(finish).toBeDefined();
+      expect(seatReportRespondedAt).toBeDefined();
+      expect(finish!.at).toBeGreaterThanOrEqual(seatReportRespondedAt!);
+
+      expect(requests.some((r) => r.path === "/api/keys/report-rate-limit")).toBe(false);
+      expect(modelWindowBlocks.size).toBe(0);
+    });
+  }
+});
+
+describe("reportCredentialOutcomeThenFinish — seat mismatch after a key-wide rejection", () => {
+  test("the earlier key-wide rejection is still reported next to the seat report", async () => {
+    const taskId = "22222222-2222-4222-8222-222222222222";
+    const rateLimitResetAt = new Date(Date.now() + 2 * 60 * 60 * 1000).toISOString();
+    await completeTask(
+      taskId,
+      {
+        exitCode: 1,
+        isError: true,
+        sessionId: "session-3",
+        failureReason: "Claude process exited with code 1",
+        rateLimitResetAt,
+        creditsRequired: {
+          observedAt: new Date().toISOString(),
+          overageDisabledReason: "member_zero_credit_limit",
+        },
+      },
+      "claude-fable-5-1",
+    );
+
+    expect(requests.filter((r) => r.path === "/api/keys/report-seat-mismatch")).toHaveLength(1);
+    const keyReports = requests.filter((r) => r.path === "/api/keys/report-rate-limit");
+    expect(keyReports).toHaveLength(1);
+    expect(keyReports[0]?.body).toMatchObject({ keyIndex: 3, rateLimitedUntil: rateLimitResetAt });
+  });
+});

package/src/tests/credential-status-api.test.ts

@@ -1,8 +1,17 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
 import { createServer as createHttpServer, type Server } from "node:http";
-import { closeDb, createAgent, initDb } from "../be/db";
+import {
+  closeDb,
+  createAgent,
+  getAvailableKeyIndices,
+  getDbClient,
+  initDb,
+  recordKeyUsage,
+  setApiKeyPlan,
+} from "../be/db";
 import { handleAgentsRest } from "../http/agents";
+import { handleApiKeys } from "../http/api-keys";
 import { getPathSegments, parseQueryParams } from "../http/utils";
 import { listenOnFreePort } from "./test-net";
 
@@ -28,7 +37,9 @@ function createTestServer(): Server {
     const pathSegments = getPathSegments(url);
     const queryParams = parseQueryParams(url);
 
-    const handled = await handleAgentsRest(req, res, pathSegments, queryParams, undefined);
+    const handled =
+      (await handleAgentsRest(req, res, pathSegments, queryParams, undefined)) ||
+      (await handleApiKeys(req, res, pathSegments, queryParams));
     if (!handled) {
       res.writeHead(404, { "Content-Type": "application/json" });
       res.end(JSON.stringify({ error: "Not found" }));
@@ -315,4 +326,94 @@ describe("Phase 4 — credential-status HTTP endpoints", () => {
     expect(afterSnapshot.credStatus.acp).toMatchObject({ target: "opencode" });
     expect(afterSnapshot.credStatus.acp?.configOptions).toHaveLength(1);
   });
+
+  describe("POST /api/keys/report-seat-mismatch", () => {
+    const keyType = "CLAUDE_CODE_OAUTH_TOKEN";
+
+    async function reportSeatMismatch(keySuffix: string, keyIndex: number, model = "fable") {
+      const resp = await fetch(`${baseUrl}/api/keys/report-seat-mismatch`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ keyType, keySuffix, keyIndex, model }),
+      });
+      expect(resp.status).toBe(200);
+    }
+
+    async function keyStatus(keySuffix: string) {
+      const resp = await fetch(`${baseUrl}/api/keys/status?keyType=${keyType}`);
+      expect(resp.status).toBe(200);
+      const body = (await resp.json()) as {
+        keys: Array<{
+          keySuffix: string;
+          status: string;
+          plan: string | null;
+          planSource: string | null;
+          lastSeatMismatchAt: string | null;
+          lastSeatMismatchModel: string | null;
+        }>;
+      };
+      return body.keys.find((k) => k.keySuffix === keySuffix);
+    }
+
+    test("an estimated plan becomes claude_team_standard / detected", async () => {
+      await recordKeyUsage(keyType, "EST01", 0, null);
+      await getDbClient().run(
+        "UPDATE api_key_status SET plan = 'claude_max_5x', planSource = 'estimated' WHERE keySuffix = ?",
+        ["EST01"],
+      );
+      await reportSeatMismatch("EST01", 0);
+      const key = await keyStatus("EST01");
+      expect(key?.plan).toBe("claude_team_standard");
+      expect(key?.planSource).toBe("detected");
+      expect(key?.lastSeatMismatchAt).not.toBeNull();
+      expect(key?.lastSeatMismatchModel).toBe("fable");
+      expect(key?.status).toBe("available");
+    });
+
+    test("a manual plan is never changed", async () => {
+      await recordKeyUsage(keyType, "MAN01", 1, null);
+      await setApiKeyPlan(keyType, "MAN01", "claude_team_premium");
+      await reportSeatMismatch("MAN01", 1);
+      const key = await keyStatus("MAN01");
+      expect(key?.plan).toBe("claude_team_premium");
+      expect(key?.planSource).toBe("manual");
+      expect(key?.lastSeatMismatchAt).not.toBeNull();
+      expect(key?.lastSeatMismatchModel).toBe("fable");
+      expect(key?.status).toBe("available");
+    });
+
+    test("a key with no row gets a row with the detected plan", async () => {
+      await reportSeatMismatch("NEW01", 2);
+      const key = await keyStatus("NEW01");
+      expect(key?.plan).toBe("claude_team_standard");
+      expect(key?.planSource).toBe("detected");
+      expect(key?.lastSeatMismatchModel).toBe("fable");
+      expect(key?.status).toBe("available");
+    });
+
+    test("an Opus rejection records the columns but infers no plan", async () => {
+      await recordKeyUsage(keyType, "OPU01", 4, null);
+      await getDbClient().run(
+        "UPDATE api_key_status SET plan = 'claude_max_5x', planSource = 'estimated' WHERE keySuffix = ?",
+        ["OPU01"],
+      );
+      await reportSeatMismatch("OPU01", 4, "opus");
+      const key = await keyStatus("OPU01");
+      expect(key?.plan).toBe("claude_max_5x");
+      expect(key?.planSource).toBe("estimated");
+      expect(key?.lastSeatMismatchModel).toBe("opus");
+      expect(key?.status).toBe("available");
+      // Fable admission for the key does not change.
+      const fable = await getAvailableKeyIndices(keyType, 5, "global", null, "fable");
+      expect(fable.seatBlockedIndices).not.toContain(4);
+      expect(fable.availableIndices).toContain(4);
+    });
+
+    test("GET /api/keys/status returns the seat mismatch columns", async () => {
+      await recordKeyUsage(keyType, "NONE1", 3, null);
+      const key = await keyStatus("NONE1");
+      expect(key).toHaveProperty("lastSeatMismatchAt", null);
+      expect(key).toHaveProperty("lastSeatMismatchModel", null);
+    });
+  });
 });

package/src/tests/db-extraction-contract.test.ts

@@ -14,6 +14,7 @@ test("facade exposes repository bindings without internal exports", () => {
         "rowToAgentTask",
         "rowToAgentTaskSummary",
         "configureTaskReadDependencies",
+        "NEVER_STARTED_TASK_STATUSES",
       ].includes(name)
     ) {
       expect(name in db).toBe(false);

package/src/tests/db-task-read-contract.test.ts

@@ -64,6 +64,7 @@ type:ExistingTrackerContextWorkReason
 type:InboxSummary
 type:InsertPricingRowInput
 type:InsertTaskAttachmentInput
+type:KeyAuthFailureResult
 type:KeyCostSummary
 type:KvJsonFieldEquals
 type:McpServerFilters
@@ -232,6 +233,7 @@ value:getAgentMailInboxMapping
 value:getAgentMailInboxMappingsByAgent
 value:getAgentMcpServers
 value:getAgentSkills
+value:getAgentStatusCounts
 value:getAgentWithTasks
 value:getAgentWorkingOnThread
 value:getAllAgentMailInboxMappings
@@ -386,6 +388,7 @@ value:getStepCountForNode
 value:getStuckApprovalRuns
 value:getStuckWaitRuns
 value:getStuckWorkflowRuns
+value:getSupersededTasksWithUnsettledDependents
 value:getSupersededTasksWithoutResume
 value:getSwarmConfigById
 value:getSwarmConfigLookupById
@@ -409,7 +412,6 @@ value:getUnassignedTaskIdsForAgent
 value:getUnassignedTasksCount
 value:getUnreadInboxMessages
 value:getUnreadMessages
-value:getUsageDataVersion
 value:getUserById
 value:getWaitStateById
 value:getWaitStateByStepId
@@ -442,6 +444,7 @@ value:isExtensionAgent
 value:isPendingSlackMessage
 value:isPoolAffinityEnforcementEnabled
 value:isSettledSlackMessage
+value:isSlackThreadAwaitingHuman
 value:isSqliteVecAvailable
 value:kvPrefixUpperBound
 value:listAgentsWithCredStatusByProvider
@@ -463,6 +466,7 @@ value:listScriptRunJournalSteps
 value:listScriptRuns
 value:listSkillFileManifest
 value:listSkills
+value:listSlackThreadsAwaitingHuman
 value:listTaskTemplates
 value:listUserFavorites
 value:listWorkflowRuns
@@ -496,7 +500,9 @@ value:promoteDraftTask
 value:reassociateSessionLogs
 value:recordBudgetRefusalNotification
 value:recordInlineScriptRun
+value:recordKeyAuthFailure
 value:recordKeyRateLimitWindows
+value:recordKeySeatMismatch
 value:recordKeyUsage
 value:recordSlackMessage
 value:recordTaskPullRequestAttachments
@@ -529,6 +535,7 @@ value:setBudgetRefusalFollowUpTaskId
 value:setFavorite
 value:setSlackMessageTracking
 value:setUserFavorite
+value:settleSupersededTaskDependents
 value:shouldBlockPolling
 value:startTask
 value:supersedeTask
@@ -604,6 +611,7 @@ value:getMostRecentTaskInThread
 value:getPendingSlackRelayTasks
 value:getRecentlyFinishedWorkerTasks
 value:getSlackTasksMissingTree
+value:getSupersededTasksWithUnsettledDependents
 value:getSupersededTasksWithoutResume
 value:getTaskById
 value:getTaskStats
@@ -620,6 +628,7 @@ value:resetTasksNotified`.split("\n");
 const internal = [
   "type:AgentTaskRow",
   "value:configureTaskReadDependencies",
+  "value:NEVER_STARTED_TASK_STATUSES",
   "value:rowToAgentTask",
   "value:rowToAgentTaskSummary",
 ].sort();