@desplega.ai/agent-swarm 1.156.0 → 1.158.0

package/src/tests/apps-sync-engine.test.ts

@@ -26,7 +26,12 @@ import {
   withMutationLock,
 } from "../apps/row-store";
 import { createApp, getApp, updateApp } from "../apps/store";
-import { getAppSyncStatus, runAppSync, type SyncPassResult } from "../apps/sync";
+import {
+  getAppSyncStatus,
+  RECONCILE_CHUNK_SIZE,
+  runAppSync,
+  type SyncPassResult,
+} from "../apps/sync";
 import {
   closeDb,
   createAgent,
@@ -1277,17 +1282,20 @@ spawnDescribe("concurrency", () => {
   });
 
   test("a mid-pass write failure reports the committed churn instead of zero counts", async () => {
-    // Row writes are independent KV upserts, not a transaction: fail the
-    // SECOND create after the first already committed and the pass counts
-    // must say so instead of reporting the zero-count base.
-    const script = await fixtureScript("partial", [ghRecord(1), ghRecord(2)]);
+    // Rows are written in chunked transactions: fail the second create of the
+    // SECOND chunk after the first chunk committed. The pass counts must say
+    // so instead of reporting the zero-count base, and the failing chunk must
+    // roll back without leaving partial rows.
+    const total = RECONCILE_CHUNK_SIZE + 2;
+    const records = Array.from({ length: total }, (_, index) => ghRecord(index + 1));
+    const script = await fixtureScript("partial", records);
     const appId = await createSyncApp(issueDefinition(script.id));
 
     const realCreate = rowStore.createAppRowUnlocked;
     let creates = 0;
     const spy = spyOn(rowStore, "createAppRowUnlocked").mockImplementation((...callArgs) => {
       creates += 1;
-      if (creates === 2) throw new Error("kv write failed (injected)");
+      if (creates === RECONCILE_CHUNK_SIZE + 2) throw new Error("kv write failed (injected)");
       return realCreate(...callArgs);
     });
     try {
@@ -1296,9 +1304,12 @@ spawnDescribe("concurrency", () => {
 
       expect(result.ok).toBe(false);
       expect(pass.error).toContain("kv write failed (injected)");
-      expect(pass).toMatchObject({ pulled: 2, created: 1 });
-      expect((await rowsOf(appId)).map((row) => row.issueKey)).toEqual(["1"]);
-      expect(await getAppSyncStatus(appId, "issue", "gh")).toMatchObject({ ok: false, created: 1 });
+      expect(pass).toMatchObject({ pulled: total, created: RECONCILE_CHUNK_SIZE });
+      expect(await rowsOf(appId)).toHaveLength(RECONCILE_CHUNK_SIZE);
+      expect(await getAppSyncStatus(appId, "issue", "gh")).toMatchObject({
+        ok: false,
+        created: RECONCILE_CHUNK_SIZE,
+      });
     } finally {
       spy.mockRestore();
     }

package/src/tests/boot-seeds.test.ts

@@ -0,0 +1,170 @@
+import { afterAll, afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtemp, rm, unlink, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { ensurePricingSeeded, ensureRbacSeeded } from "../be/boot-seeds";
+import { closeDb, getDbClient, initDb } from "../be/db";
+import { loadModelsDevCache } from "../be/modelsdev-cache";
+import { BUILTIN_ROLES } from "../be/rbac-roles";
+import { createServer } from "../server";
+
+const TEST_DB_PATH = "./test-boot-seeds.sqlite";
+const BUILTIN_ROLE_ID = "rbac-role-requester";
+
+async function removeDbFiles(): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(TEST_DB_PATH + suffix);
+    } catch {
+      // File does not exist.
+    }
+  }
+}
+
+async function countPricingSeedRows(): Promise<number> {
+  const row = await getDbClient().get<{ n: number }>(
+    "SELECT COUNT(*) AS n FROM pricing WHERE effective_from = 0",
+  );
+  return row?.n ?? 0;
+}
+
+async function countBuiltinPermissions(): Promise<number> {
+  const row = await getDbClient().get<{ n: number }>(
+    "SELECT COUNT(*) AS n FROM role_permissions WHERE roleId = ?",
+    [BUILTIN_ROLE_ID],
+  );
+  return row?.n ?? 0;
+}
+
+// Fresh DB handle per test: the guards are keyed on the live handle.
+beforeEach(async () => {
+  closeDb();
+  await removeDbFiles();
+  initDb(TEST_DB_PATH);
+});
+
+afterEach(() => {
+  closeDb();
+});
+
+afterAll(async () => {
+  await removeDbFiles();
+});
+
+describe("ensurePricingSeeded", () => {
+  test("seeds once per database handle, and again for a new handle", async () => {
+    ensurePricingSeeded();
+    const seeded = await countPricingSeedRows();
+    expect(seeded).toBeGreaterThan(0);
+
+    // A second call must not touch the table: wipe it and confirm it stays empty.
+    await getDbClient().run("DELETE FROM pricing WHERE effective_from = 0");
+    ensurePricingSeeded();
+    expect(await countPricingSeedRows()).toBe(0);
+
+    // Reopening the same file gives a new handle, which is seeded again.
+    closeDb();
+    initDb(TEST_DB_PATH);
+    ensurePricingSeeded();
+    expect(await countPricingSeedRows()).toBe(seeded);
+  });
+});
+
+describe("ensureRbacSeeded", () => {
+  test("syncs once per database handle, and again for a new handle", async () => {
+    ensureRbacSeeded();
+    const seeded = await countBuiltinPermissions();
+    expect(seeded).toBeGreaterThan(0);
+
+    await getDbClient().run("DELETE FROM role_permissions WHERE roleId = ?", [BUILTIN_ROLE_ID]);
+    ensureRbacSeeded();
+    expect(await countBuiltinPermissions()).toBe(0);
+
+    closeDb();
+    initDb(TEST_DB_PATH);
+    ensureRbacSeeded();
+    expect(await countBuiltinPermissions()).toBe(seeded);
+  });
+
+  test("a failed sync does not mark the handle done", async () => {
+    // Make the built-in role unrecoverable: its name is taken by another role id.
+    const builtin = BUILTIN_ROLES.find((role) => role.id === BUILTIN_ROLE_ID);
+    if (!builtin) throw new Error("test fixture: built-in role missing");
+    const client = getDbClient();
+    await client.run("PRAGMA foreign_keys = OFF");
+    await client.run("DELETE FROM roles WHERE id = ?", [BUILTIN_ROLE_ID]);
+    await client.run("PRAGMA foreign_keys = ON");
+    await client.run(
+      "INSERT INTO roles (id, name, description, isBuiltin, grantsAll) VALUES ('rbac-role-collision', ?, 'x', 0, 0)",
+      [builtin.name],
+    );
+
+    expect(() => ensureRbacSeeded()).toThrow(/already uses that name/);
+    // Not cached as done: the next caller retries and sees the same error.
+    expect(() => ensureRbacSeeded()).toThrow(/already uses that name/);
+
+    await client.run("DELETE FROM roles WHERE id = 'rbac-role-collision'");
+    ensureRbacSeeded();
+    expect(await countBuiltinPermissions()).toBeGreaterThan(0);
+  });
+});
+
+describe("createServer (one call per MCP session)", () => {
+  let savedDatabasePath: string | undefined;
+
+  beforeEach(() => {
+    savedDatabasePath = process.env.DATABASE_PATH;
+    process.env.DATABASE_PATH = TEST_DB_PATH;
+  });
+
+  afterEach(() => {
+    if (savedDatabasePath === undefined) delete process.env.DATABASE_PATH;
+    else process.env.DATABASE_PATH = savedDatabasePath;
+  });
+
+  test("seeds pricing and RBAC on the first session only", async () => {
+    await createServer();
+    expect(await countPricingSeedRows()).toBeGreaterThan(0);
+    expect(await countBuiltinPermissions()).toBeGreaterThan(0);
+
+    await getDbClient().run("DELETE FROM pricing WHERE effective_from = 0");
+    await getDbClient().run("DELETE FROM role_permissions WHERE roleId = ?", [BUILTIN_ROLE_ID]);
+
+    // A later session re-registers tools but must not re-run the seeds.
+    const second = await createServer();
+    expect(second).toBeDefined();
+    expect(await countPricingSeedRows()).toBe(0);
+    expect(await countBuiltinPermissions()).toBe(0);
+  });
+});
+
+describe("loadModelsDevCache", () => {
+  const saved = process.env.MODELSDEV_CACHE_PATH;
+  let dir: string | undefined;
+
+  afterEach(async () => {
+    if (saved === undefined) delete process.env.MODELSDEV_CACHE_PATH;
+    else process.env.MODELSDEV_CACHE_PATH = saved;
+    if (dir) await rm(dir, { recursive: true, force: true });
+    dir = undefined;
+  });
+
+  test("returns the same parsed object while it is alive", () => {
+    const first = loadModelsDevCache();
+    expect(first).not.toBeNull();
+    expect(loadModelsDevCache()).toBe(first);
+  });
+
+  test("keys the memo on the resolved path", async () => {
+    dir = await mkdtemp(path.join(tmpdir(), "modelsdev-cache-"));
+    const alt = path.join(dir, "cache.json");
+    await writeFile(alt, JSON.stringify({ anthropic: { id: "anthropic-alt", models: {} } }));
+
+    const bundled = loadModelsDevCache();
+    process.env.MODELSDEV_CACHE_PATH = alt;
+    const overridden = loadModelsDevCache();
+
+    expect(overridden?.anthropic?.id).toBe("anthropic-alt");
+    expect(overridden).not.toBe(bundled);
+  });
+});

package/src/tests/cancel-approval-request-tool.test.ts

@@ -0,0 +1,115 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import {
+  closeDb,
+  createAgent,
+  createApprovalRequest,
+  createTaskExtended,
+  getApprovalRequestById,
+  getDbClient,
+  initDb,
+} from "../be/db";
+import { registerCancelApprovalRequestTool } from "../tools/cancel-approval-request";
+
+const TEST_DB_PATH = "./test-cancel-approval-request-tool.sqlite";
+
+type ToolResult = {
+  isError?: boolean;
+  structuredContent: { success: boolean; alreadyCancelled?: boolean; runCancelled?: boolean };
+};
+
+let callTool: (args: unknown, agentId: string) => Promise<ToolResult>;
+let leadId = "";
+let ownerId = "";
+let workerId = "";
+
+async function makeRequest() {
+  const sourceTask = await createTaskExtended("source", { agentId: ownerId, source: "mcp" });
+  const id = crypto.randomUUID();
+  await createApprovalRequest({
+    id,
+    title: "Tool cancel",
+    questions: [{ id: "q1", type: "approval", label: "Approve?", required: true }],
+    approvers: { policy: "any" },
+    sourceTaskId: sourceTask.id,
+  });
+  return id;
+}
+
+describe("cancel-approval-request tool", () => {
+  beforeAll(async () => {
+    initDb(TEST_DB_PATH);
+    leadId = (await createAgent({ name: "tool-lead", isLead: true, status: "idle" })).id;
+    ownerId = (await createAgent({ name: "tool-owner", isLead: false, status: "idle" })).id;
+    workerId = (await createAgent({ name: "tool-worker", isLead: false, status: "idle" })).id;
+    const server = new McpServer({ name: "cancel-approval-request-test", version: "1.0.0" });
+    registerCancelApprovalRequestTool(server);
+    const tool = (
+      server as unknown as {
+        _registeredTools: Record<
+          string,
+          { handler: (args: unknown, extra: unknown) => Promise<unknown> }
+        >;
+      }
+    )._registeredTools["cancel-approval-request"];
+    if (!tool) throw new Error("cancel-approval-request tool was not registered");
+    callTool = async (args, agentId) =>
+      (await tool.handler(args, {
+        sessionId: "cancel-approval-request-test",
+        requestInfo: { headers: { "x-agent-id": agentId } },
+      })) as ToolResult;
+  });
+
+  afterAll(async () => {
+    closeDb();
+    for (const suffix of ["", "-wal", "-shm"]) {
+      await unlink(`${TEST_DB_PATH}${suffix}`).catch(() => {});
+    }
+  });
+
+  test("a lead cancels a pending request, then a second call is a no-op", async () => {
+    const requestId = await makeRequest();
+
+    const first = await callTool({ requestId, reason: "not needed" }, leadId);
+    expect(first.isError).toBeFalsy();
+    expect(first.structuredContent.alreadyCancelled).toBe(false);
+    const row = await getApprovalRequestById(requestId);
+    expect(row!.status).toBe("cancelled");
+    expect(row!.resolvedBy).toBe(leadId);
+    expect(row!.resolutionReason).toBe("not needed");
+
+    const second = await callTool({ requestId }, leadId);
+    expect(second.isError).toBeFalsy();
+    expect(second.structuredContent.alreadyCancelled).toBe(true);
+  });
+
+  test("a worker that does not own the source task gets a tool error", async () => {
+    const requestId = await makeRequest();
+
+    const result = await callTool({ requestId }, workerId);
+
+    expect(result.isError).toBe(true);
+    expect((await getApprovalRequestById(requestId))!.status).toBe("pending");
+  });
+
+  test("the owner agent may cancel", async () => {
+    const requestId = await makeRequest();
+    const result = await callTool({ requestId }, ownerId);
+    expect(result.isError).toBeFalsy();
+    expect((await getApprovalRequestById(requestId))!.status).toBe("cancelled");
+  });
+
+  test("an expired pending request gets a tool error and becomes timeout", async () => {
+    const requestId = await makeRequest();
+    await getDbClient().run("UPDATE approval_requests SET expiresAt = ? WHERE id = ?", [
+      new Date(Date.now() - 60_000).toISOString(),
+      requestId,
+    ]);
+
+    const result = await callTool({ requestId }, leadId);
+
+    expect(result.isError).toBe(true);
+    expect((await getApprovalRequestById(requestId))!.status).toBe("timeout");
+  });
+});

package/src/tests/claude-managed-adapter.test.ts

@@ -922,6 +922,12 @@ describe("ClaudeManagedAdapter (Phase 4) — repo provisioning + cost data", ()
       cacheReadPerMillion: 1.0,
       cacheWritePerMillion: 12.5,
     });
+    expect(CLAUDE_MANAGED_MODEL_PRICING["claude-sonnet-5-5"]).toEqual({
+      inputPerMillion: 2.0,
+      outputPerMillion: 10.0,
+      cacheReadPerMillion: 0.2,
+      cacheWritePerMillion: 2.5,
+    });
     expect(CLAUDE_MANAGED_MODEL_PRICING["claude-sonnet-5"]).toEqual({
       inputPerMillion: 2.0,
       outputPerMillion: 10.0,

package/src/tests/codex-adapter.test.ts

@@ -7,7 +7,7 @@
  */
 
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, test } from "bun:test";
-import { mkdirSync, rmSync } from "node:fs";
+import { lstatSync, mkdirSync, readFileSync, readlinkSync, rmSync, symlinkSync } from "node:fs";
 import { join } from "node:path";
 import type {
   AgentMessageItem,
@@ -1130,6 +1130,8 @@ describe("CodexAdapter.canResume", () => {
 
 describe("writeCodexAgentsMd round-trip", () => {
   const tmpDir = `/tmp/codex-agents-md-test-${Date.now()}`;
+  // Crash-recovery records live outside every per-test repo dir.
+  const stateDir = join(tmpDir, ".state");
 
   beforeAll(() => {
     mkdirSync(tmpDir, { recursive: true });
@@ -1239,6 +1241,129 @@ stale
     expect(after).not.toContain("<swarm_system_prompt>");
     expect(after).toContain("# Project instructions");
   });
+
+  test("cleanup restores a plain AGENTS.md byte-identically", async () => {
+    const dir = join(tmpDir, "byte-identical");
+    mkdirSync(dir, { recursive: true });
+    const original = "# Project instructions\n\nDo things.\n";
+    await Bun.write(join(dir, "AGENTS.md"), original);
+
+    const handle = await writeCodexAgentsMd(dir, "swarm prompt");
+    await handle.cleanup();
+
+    expect(readFileSync(join(dir, "AGENTS.md"), "utf8")).toBe(original);
+  });
+
+  test("never writes through an AGENTS.md -> CLAUDE.md symlink", async () => {
+    const dir = join(tmpDir, "symlink");
+    mkdirSync(dir, { recursive: true });
+    const original = "# Repo rules\n\nDo things.\n";
+    const claudeMd = join(dir, "CLAUDE.md");
+    const agentsMd = join(dir, "AGENTS.md");
+    await Bun.write(claudeMd, original);
+    symlinkSync("CLAUDE.md", agentsMd);
+
+    const handle = await writeCodexAgentsMd(dir, "swarm prompt", { stateDir });
+
+    // During the session: AGENTS.md is a real file, CLAUDE.md is untouched.
+    expect(lstatSync(agentsMd).isSymbolicLink()).toBe(false);
+    const during = readFileSync(agentsMd, "utf8");
+    expect(during).toContain("swarm prompt");
+    expect(during).toContain("# Repo rules");
+    expect(readFileSync(claudeMd, "utf8")).toBe(original);
+
+    await handle.cleanup();
+
+    expect(lstatSync(agentsMd).isSymbolicLink()).toBe(true);
+    expect(readlinkSync(agentsMd)).toBe("CLAUDE.md");
+    expect(readFileSync(claudeMd, "utf8")).toBe(original);
+  });
+
+  test("carries agent edits to a symlinked AGENTS.md over to the link target", async () => {
+    const dir = join(tmpDir, "symlink-edit");
+    mkdirSync(dir, { recursive: true });
+    const claudeMd = join(dir, "CLAUDE.md");
+    const agentsMd = join(dir, "AGENTS.md");
+    await Bun.write(claudeMd, "# Repo rules\n");
+    symlinkSync("CLAUDE.md", agentsMd);
+
+    const handle = await writeCodexAgentsMd(dir, "swarm prompt", { stateDir });
+    await Bun.write(agentsMd, `${readFileSync(agentsMd, "utf8")}- new rule\n`);
+    await handle.cleanup();
+
+    expect(lstatSync(agentsMd).isSymbolicLink()).toBe(true);
+    expect(readFileSync(claudeMd, "utf8")).toBe("# Repo rules\n- new rule\n");
+  });
+
+  test("restores a symlink left swapped out by a crashed session", async () => {
+    const dir = join(tmpDir, "symlink-crash");
+    mkdirSync(dir, { recursive: true });
+    const original = "# Repo rules\n";
+    const claudeMd = join(dir, "CLAUDE.md");
+    const agentsMd = join(dir, "AGENTS.md");
+    await Bun.write(claudeMd, original);
+    symlinkSync("CLAUDE.md", agentsMd);
+
+    // First session never runs cleanup (crash).
+    await writeCodexAgentsMd(dir, "first prompt", { stateDir });
+    expect(lstatSync(agentsMd).isSymbolicLink()).toBe(false);
+
+    const handle = await writeCodexAgentsMd(dir, "second prompt", { stateDir });
+    const during = readFileSync(agentsMd, "utf8");
+    expect(during).toContain("second prompt");
+    expect(during).not.toContain("first prompt");
+    expect(readFileSync(claudeMd, "utf8")).toBe(original);
+
+    await handle.cleanup();
+    expect(lstatSync(agentsMd).isSymbolicLink()).toBe(true);
+    expect(readFileSync(claudeMd, "utf8")).toBe(original);
+  });
+
+  test("ignores a forged symlink marker pointing out of the repo", async () => {
+    const dir = join(tmpDir, "forged-marker");
+    mkdirSync(dir, { recursive: true });
+    const secretPath = join(tmpDir, "outside-secret.txt");
+    const secret = "TOP-SECRET-CONTENTS\n";
+    await Bun.write(secretPath, secret);
+    const agentsMd = join(dir, "AGENTS.md");
+
+    for (const forged of ["../outside-secret.txt", secretPath]) {
+      const original = `<swarm_system_prompt symlink="${encodeURIComponent(forged)}">\nold\n</swarm_system_prompt>\n# Rules\n`;
+      await Bun.write(agentsMd, original);
+
+      const handle = await writeCodexAgentsMd(dir, "swarm prompt", { stateDir });
+      expect(lstatSync(agentsMd).isSymbolicLink()).toBe(false);
+      expect(readFileSync(agentsMd, "utf8")).not.toContain("TOP-SECRET");
+      expect(readFileSync(secretPath, "utf8")).toBe(secret);
+
+      await handle.cleanup();
+      expect(lstatSync(agentsMd).isSymbolicLink()).toBe(false);
+      expect(readFileSync(agentsMd, "utf8")).toBe(original);
+      expect(readFileSync(secretPath, "utf8")).toBe(secret);
+    }
+  });
+
+  test("never reads or writes an out-of-tree symlink target", async () => {
+    const dir = join(tmpDir, "symlink-out-of-tree");
+    mkdirSync(dir, { recursive: true });
+    const secretPath = join(tmpDir, "outside-target.txt");
+    const secret = "OUT-OF-TREE\n";
+    await Bun.write(secretPath, secret);
+    const agentsMd = join(dir, "AGENTS.md");
+    symlinkSync("../outside-target.txt", agentsMd);
+
+    const handle = await writeCodexAgentsMd(dir, "swarm prompt", { stateDir });
+    expect(lstatSync(agentsMd).isSymbolicLink()).toBe(false);
+    const during = readFileSync(agentsMd, "utf8");
+    expect(during).toContain("swarm prompt");
+    expect(during).not.toContain("OUT-OF-TREE");
+
+    await Bun.write(agentsMd, `${during}- agent edit\n`);
+    await handle.cleanup();
+
+    expect(readlinkSync(agentsMd)).toBe("../outside-target.txt");
+    expect(readFileSync(secretPath, "utf8")).toBe(secret);
+  });
 });
 
 // ─── Phase 3: model catalogue ────────────────────────────────────────────────

package/src/tests/config-key-filter.test.ts

@@ -0,0 +1,80 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { createServer, type Server } from "node:http";
+import { closeDb, initDb, upsertSwarmConfig } from "../be/db";
+import { handleConfig } from "../http/config";
+import { handleCore } from "../http/core";
+import { getPathSegments, parseQueryParams } from "../http/utils";
+import { listenOnFreePort } from "./test-net";
+
+// ctx.swarm.config_get / config_list send `key` to these routes. Both used to
+// ignore it and return every row, so a script asking for one secret got all.
+
+const API_KEY = "example-config-key-filter-test-key";
+
+let server: Server;
+let baseUrl: string;
+
+beforeAll(async () => {
+  initDb(":memory:");
+  await upsertSwarmConfig({ scope: "global", key: "WANTED_KEY", value: "wanted" });
+  await upsertSwarmConfig({
+    scope: "global",
+    key: "OTHER_SECRET",
+    value: "other-secret-value",
+    isSecret: true,
+  });
+  await upsertSwarmConfig({ scope: "global", key: "PLAIN_KEY", value: "plain" });
+
+  server = createServer(async (req, res) => {
+    if (await handleCore(req, res, req.headers["x-agent-id"] as string | undefined, API_KEY)) {
+      return;
+    }
+    const segments = getPathSegments(req.url || "");
+    const query = parseQueryParams(req.url || "");
+    if (await handleConfig(req, res, segments, query)) return;
+    res.writeHead(404).end();
+  });
+  baseUrl = `http://127.0.0.1:${await listenOnFreePort(server)}`;
+});
+
+afterAll(async () => {
+  await new Promise<void>((resolve) => server.close(() => resolve()));
+  closeDb();
+});
+
+async function getKeys(path: string): Promise<string[]> {
+  const response = await fetch(`${baseUrl}${path}`, {
+    headers: { Authorization: `Bearer ${API_KEY}` },
+  });
+  expect(response.status).toBe(200);
+  const body = (await response.json()) as { configs: Array<{ key: string }> };
+  return body.configs.map((config) => config.key);
+}
+
+const ALL_KEYS = ["OTHER_SECRET", "PLAIN_KEY", "WANTED_KEY"];
+
+describe.each([
+  ["/api/config/resolved", "?"],
+  ["/api/config", "?scope=global&"],
+])("GET %s key filter", (path, prefix) => {
+  test("?key=<existing> returns exactly that row", async () => {
+    expect(await getKeys(`${path}${prefix}key=WANTED_KEY&includeSecrets=true`)).toEqual([
+      "WANTED_KEY",
+    ]);
+  });
+
+  test("?key=<unknown> returns an empty list", async () => {
+    expect(await getKeys(`${path}${prefix}key=NO_SUCH_KEY&includeSecrets=true`)).toEqual([]);
+  });
+
+  test("no key returns every row", async () => {
+    expect((await getKeys(`${path}${prefix}includeSecrets=true`)).sort()).toEqual(ALL_KEYS);
+  });
+
+  test("an empty key is rejected instead of returning every row", async () => {
+    const response = await fetch(`${baseUrl}${path}${prefix}key=`, {
+      headers: { Authorization: `Bearer ${API_KEY}` },
+    });
+    expect(response.status).toBe(400);
+  });
+});

package/src/tests/context-window.test.ts

@@ -27,6 +27,7 @@ describe("getContextWindowSize", () => {
   });
 
   test("returns 1M for sonnet models", () => {
+    expect(getContextWindowSize("claude-sonnet-5-5")).toBe(1_000_000);
     expect(getContextWindowSize("claude-sonnet-5")).toBe(1_000_000);
     expect(getContextWindowSize("claude-sonnet-4-6")).toBe(1_000_000);
     expect(getContextWindowSize("sonnet")).toBe(1_000_000);