@desplega.ai/agent-swarm 1.166.0 → 1.167.0

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

@@ -355,6 +355,7 @@ describe("credentialsToAuthJson", () => {
       accountId: "c724a178-abc",
     };
 
+    const before = Date.now();
     const authJson = credentialsToAuthJson(creds);
     expect(authJson.auth_mode).toBe("chatgpt");
     expect(authJson.OPENAI_API_KEY).toBeNull();
@@ -362,7 +363,9 @@ describe("credentialsToAuthJson", () => {
     expect(authJson.tokens.refresh_token).toBe(creds.refresh);
     expect(authJson.tokens.account_id).toBe(creds.accountId);
     expect(authJson.tokens.id_token).toBe(creds.access);
-    expect(authJson.last_refresh).toBe(new Date(creds.expires).toISOString());
+    expect(Date.parse(authJson.last_refresh)).toBeGreaterThanOrEqual(before);
+    expect(Date.parse(authJson.last_refresh)).toBeLessThanOrEqual(Date.now());
+    expect(authJson.expires).toBe(creds.expires);
   });
 });
 

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

@@ -32,9 +32,9 @@ describe("getContextWindowSize", () => {
     expect(getContextWindowSize("sonnet")).toBe(1_000_000);
   });
 
-  test("returns 200K for haiku models", () => {
+  test("returns 200K for Haiku 4.5 and 1M for the haiku shortname (Haiku 5.5)", () => {
     expect(getContextWindowSize("claude-haiku-4-5")).toBe(200_000);
-    expect(getContextWindowSize("haiku")).toBe(200_000);
+    expect(getContextWindowSize("haiku")).toBe(1_000_000);
   });
 
   test("reads OpenAI windows from the catalog", () => {

package/src/tests/credential-check.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, mock, test } from "bun:test";
 import {
   buildCredStatusReport,
+  CREDENTIAL_PROVIDER_CHECKERS,
   checkProviderCredentials,
   isBedrockMode,
   isCredCheckDisabled,
@@ -8,6 +9,7 @@ import {
   shouldRefreshBedrockStatus,
   validateProviderCredentials,
 } from "../commands/provider-credentials";
+import { ACP_TARGET_IDS } from "../providers/acp-target-catalog";
 import { checkClaudeCredentials } from "../providers/claude-adapter";
 import { checkClaudeManagedCredentials } from "../providers/claude-managed-adapter";
 import { checkCodexCredentials } from "../providers/codex-adapter";
@@ -660,6 +662,54 @@ describe("checkOpencodeCredentials", () => {
   });
 });
 
+describe("ACP readiness", () => {
+  test.each(["typo", "", " \t "])("rejects unsupported target %j", async (target) => {
+    const status = await checkProviderCredentials("acp", {
+      ACP_TARGET: target,
+      ACP_TARGET_COMMAND: "custom-acp --stdio",
+    });
+    expect(status.ready).toBe(false);
+    expect(status.missing).toEqual(["ACP_TARGET"]);
+    expect(status.hint).toContain("ACP_TARGET");
+    for (const supported of ACP_TARGET_IDS) expect(status.hint).toContain(supported);
+  });
+
+  test.each([undefined, "custom"])("requires a command for target %s", async (target) => {
+    const status = await CREDENTIAL_PROVIDER_CHECKERS.acp({ ACP_TARGET: target });
+    expect(status.ready).toBe(false);
+    expect(status.missing).toEqual(["ACP_TARGET_COMMAND"]);
+    expect(status.hint).toContain("ACP_TARGET_COMMAND");
+    expect(status.hint).toContain("ACP_COMMAND");
+  });
+
+  test.each(["", " \t "])("rejects a blank custom command %j", async (command) => {
+    const status = await checkProviderCredentials("acp", {
+      ACP_TARGET: "custom",
+      ACP_TARGET_COMMAND: command,
+      ACP_COMMAND: "legacy-acp",
+    });
+    expect(status.ready).toBe(false);
+    expect(status.missing).toEqual(["ACP_TARGET_COMMAND"]);
+  });
+
+  test.each(["ACP_TARGET_COMMAND", "ACP_COMMAND"])("accepts a command from %s", async (key) => {
+    for (const target of [undefined, "custom"]) {
+      const status = await checkProviderCredentials("acp", {
+        ACP_TARGET: target,
+        [key]: "custom-acp --stdio",
+      });
+      expect(status).toEqual({ ready: true, missing: [], satisfiedBy: "sdk-delegated" });
+    }
+  });
+
+  test.each(
+    ACP_TARGET_IDS.filter((target) => target !== "custom"),
+  )("keeps preset %s ready without a custom command", async (target) => {
+    const status = await checkProviderCredentials("acp", { ACP_TARGET: target });
+    expect(status).toEqual({ ready: true, missing: [], satisfiedBy: "sdk-delegated" });
+  });
+});
+
 // ─── dispatcher ──────────────────────────────────────────────────────────────
 
 describe("checkProviderCredentials dispatcher", () => {
@@ -720,7 +770,7 @@ describe("checkProviderCredentials dispatcher", () => {
       ).ready,
     ).toBe(true);
 
-    const acpStatus = await checkProviderCredentials("acp", {});
+    const acpStatus = await checkProviderCredentials("acp", { ACP_TARGET: "opencode" });
     expect(acpStatus.ready).toBe(true);
     expect(acpStatus.satisfiedBy).toBe("sdk-delegated");
   });

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

@@ -9,7 +9,10 @@ import type { ProviderEvent, ProviderSessionConfig } from "../providers/types";
 import { DEFAULT_MODEL_TIER_MAP } from "../types";
 import { getModelAwareCredentialVars } from "../utils/credentials";
 import { resolveHarnessProvider } from "../utils/harness-provider";
-import { DEFAULT_OPENROUTER_BASE_URL } from "../utils/openrouter-base-url";
+import {
+  DEFAULT_OPENROUTER_BASE_URL,
+  OPENROUTER_APP_ATTRIBUTION_HEADERS,
+} from "../utils/openrouter-base-url";
 
 const directories: string[] = [];
 afterEach(async () => {
@@ -166,6 +169,7 @@ describe("dsh harness", () => {
             openrouter: {
               apiKeyEnv: "OPENROUTER_API_KEY",
               baseURL: DEFAULT_OPENROUTER_BASE_URL,
+              headers: OPENROUTER_APP_ATTRIBUTION_HEADERS,
               api: "openai-completions",
               models: [{ id: modelId }],
             },
@@ -316,6 +320,24 @@ describe("dsh harness", () => {
       model: "deepseek/deepseek-v4.1-flash",
     });
     expect(patch[2].config.providers.openrouter.baseURL).toBe("https://gateway.example/proxy/v1");
+    // A gateway gets no OpenRouter app attribution.
+    expect(patch[2].config.providers.openrouter).not.toHaveProperty("headers");
+  });
+
+  test("OPENROUTER_APP_ATTRIBUTION=false drops the attribution headers", async () => {
+    const config = await fixture();
+    config.model = "openrouter/vendor/new-model";
+    config.env = {
+      ...config.env,
+      DEEPSEEK_API_KEY: "",
+      OPENROUTER_API_KEY: "openrouter-test-key",
+      OPENROUTER_APP_ATTRIBUTION: "false",
+    };
+    const session = await new DshAdapter().createSession(config);
+    expect((await session.waitForCompletion()).isError).toBe(false);
+    const { patch } = await Bun.file(join(config.cwd, "invocation.json")).json();
+    expect(patch[2].config.providers.openrouter.baseURL).toBe(DEFAULT_OPENROUTER_BASE_URL);
+    expect(patch[2].config.providers.openrouter).not.toHaveProperty("headers");
   });
 
   test("bare models keep direct DeepSeek when both keys exist", async () => {

package/src/tests/enabled-tools.test.ts

@@ -0,0 +1,269 @@
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  spyOn,
+  test,
+} from "bun:test";
+import { unlink } from "node:fs/promises";
+import {
+  createServer as createHttpServer,
+  type IncomingMessage,
+  type Server,
+  type ServerResponse,
+} from "node:http";
+import type { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { closeDb, createAgent, getDbClient, initDb, upsertSwarmConfig } from "../be/db";
+import { validateConfigValue } from "../be/swarm-config-guard";
+import {
+  _resetAutoReloadForTests,
+  flushPendingIntegrationsReload,
+  loadGlobalConfigsIntoEnv,
+} from "../http/core";
+import { handleMcp } from "../http/mcp";
+import { createServer } from "../server";
+import { parseEnabledTools } from "../utils/enabled-tools";
+import { listenOnFreePort } from "./test-net";
+
+const TEST_DB_PATH = "./test-enabled-tools.sqlite";
+
+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;
+    }
+  }
+}
+
+async function toolNames(opts: Parameters<typeof createServer>[0]): Promise<string[]> {
+  const server = (await createServer(opts)) as unknown as {
+    _registeredTools: Record<string, unknown>;
+  };
+  return Object.keys(server._registeredTools).sort();
+}
+
+function parseMcpPayload(text: string): unknown {
+  const trimmed = text.trim();
+  if (trimmed.startsWith("event:") || trimmed.startsWith("data:")) {
+    return JSON.parse(
+      trimmed
+        .split("\n")
+        .filter((line) => line.startsWith("data:"))
+        .map((line) => line.slice("data:".length).trim())
+        .join("\n"),
+    );
+  }
+  return JSON.parse(trimmed);
+}
+
+let httpServer: Server;
+let baseUrl: string;
+let savedEnv: string | undefined;
+let savedCapabilities: string | undefined;
+
+async function mcpPost(agentId: string, body: Record<string, unknown>, sessionId?: string) {
+  const headers: Record<string, string> = {
+    Accept: "application/json, text/event-stream",
+    "Content-Type": "application/json",
+    "X-Agent-ID": agentId,
+  };
+  if (sessionId) headers["mcp-session-id"] = sessionId;
+  const response = await fetch(`${baseUrl}/mcp`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body),
+  });
+  const text = await response.text();
+  return { response, payload: text ? parseMcpPayload(text) : null };
+}
+
+async function listSessionTools(agentId: string): Promise<string[]> {
+  const init = await mcpPost(agentId, {
+    jsonrpc: "2.0",
+    id: 1,
+    method: "initialize",
+    params: {
+      protocolVersion: "2024-11-05",
+      clientInfo: { name: "enabled-tools", version: "1" },
+      capabilities: {},
+    },
+  });
+  const sessionId = init.response.headers.get("mcp-session-id");
+  if (!sessionId) throw new Error("missing MCP session ID");
+  await mcpPost(agentId, { jsonrpc: "2.0", method: "notifications/initialized" }, sessionId);
+  const listed = await mcpPost(
+    agentId,
+    { jsonrpc: "2.0", id: 2, method: "tools/list", params: {} },
+    sessionId,
+  );
+  return (listed.payload as { result: { tools: Array<{ name: string }> } }).result.tools
+    .map((tool) => tool.name)
+    .sort();
+}
+
+beforeAll(async () => {
+  // Drain any config reload a previous suite left queued (see
+  // scripts-only-gating.test.ts) before touching the global config rows.
+  const originalSlackDisable = process.env.SLACK_DISABLE;
+  process.env.SLACK_DISABLE = "true";
+  await flushPendingIntegrationsReload();
+  _resetAutoReloadForTests();
+  if (originalSlackDisable === undefined) delete process.env.SLACK_DISABLE;
+  else process.env.SLACK_DISABLE = originalSlackDisable;
+
+  await removeDbFiles(TEST_DB_PATH);
+  closeDb();
+  initDb(TEST_DB_PATH);
+
+  const transports: Record<string, StreamableHTTPServerTransport> = {};
+  const sessionAgents: Record<string, string> = {};
+  httpServer = createHttpServer(async (req: IncomingMessage, res: ServerResponse) => {
+    if (await handleMcp(req, res, transports, {}, sessionAgents)) return;
+    res.writeHead(404);
+    res.end("Not Found");
+  });
+  baseUrl = `http://127.0.0.1:${await listenOnFreePort(httpServer, "127.0.0.1")}`;
+});
+
+afterAll(async () => {
+  await new Promise<void>((resolve) => httpServer.close(() => resolve()));
+  closeDb();
+  await removeDbFiles(TEST_DB_PATH);
+});
+
+beforeEach(() => {
+  savedEnv = process.env.SWARM_ENABLED_TOOLS;
+  delete process.env.SWARM_ENABLED_TOOLS;
+  // Pin the default capability set; worker containers export their own.
+  savedCapabilities = process.env.CAPABILITIES;
+  delete process.env.CAPABILITIES;
+});
+
+afterEach(async () => {
+  await getDbClient().run("DELETE FROM swarm_config WHERE key = 'SWARM_ENABLED_TOOLS'");
+  // Un-inject the global row so it cannot leak into later suites.
+  await loadGlobalConfigsIntoEnv(true);
+  if (savedEnv === undefined) delete process.env.SWARM_ENABLED_TOOLS;
+  else process.env.SWARM_ENABLED_TOOLS = savedEnv;
+  if (savedCapabilities === undefined) delete process.env.CAPABILITIES;
+  else process.env.CAPABILITIES = savedCapabilities;
+});
+
+describe("parseEnabledTools", () => {
+  test.each([
+    [undefined, undefined],
+    ["", undefined],
+    ["  ", undefined],
+    [" , ,", undefined],
+    ["[]", undefined],
+    ["get-tasks, store-progress", ["get-tasks", "store-progress"]],
+    ["get-tasks,get-tasks,", ["get-tasks"]],
+    ['["get-tasks", " store-progress "]', ["get-tasks", "store-progress"]],
+  ] as Array<[string | undefined, string[] | undefined]>)("parses %#", (value, expected) => {
+    expect(parseEnabledTools(value)).toEqual(expected);
+  });
+
+  test("rejects a JSON value that is not an array of strings", () => {
+    expect(() => parseEnabledTools("[1, 2]")).toThrow();
+    expect(() => parseEnabledTools("[not json")).toThrow();
+    expect(validateConfigValue("SWARM_ENABLED_TOOLS", "[1]")).toContain("SWARM_ENABLED_TOOLS");
+    expect(validateConfigValue("SWARM_ENABLED_TOOLS", "get-tasks,nope")).toBeNull();
+  });
+});
+
+describe("SWARM_ENABLED_TOOLS on the MCP server", () => {
+  test("unset keeps the capability-driven surface", async () => {
+    const unset = await toolNames({});
+    expect(unset).toContain("send-task");
+    // messaging is a default-disabled capability
+    expect(unset).not.toContain("post-message");
+    expect(await toolNames({ enabledTools: undefined })).toEqual(unset);
+  });
+
+  test("set registers exactly the listed tools, ignoring capabilities", async () => {
+    expect(await toolNames({ enabledTools: "get-tasks, post-message" })).toEqual([
+      "get-tasks",
+      "post-message",
+    ]);
+  });
+
+  test("reads the deployment env when no session value is passed", async () => {
+    process.env.SWARM_ENABLED_TOOLS = "store-progress";
+    expect(await toolNames({})).toEqual(["store-progress"]);
+  });
+
+  test("overrides scripts-only mode", async () => {
+    expect(await toolNames({ scriptsOnly: true, enabledTools: "get-tasks" })).toEqual([
+      "get-tasks",
+    ]);
+  });
+
+  test("does not affect the full-surface bridge server", async () => {
+    const tools = await toolNames({ fullSurface: true, enabledTools: "get-tasks" });
+    expect(tools).toContain("post-message");
+    expect(tools.length).toBeGreaterThan(1);
+  });
+
+  test("warns once on unknown names and keeps the known ones", async () => {
+    const warn = spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      const value = "get-tasks, no-such-tool-a1, no-such-tool-b2";
+      expect(await toolNames({ enabledTools: value })).toEqual(["get-tasks"]);
+      await toolNames({ enabledTools: value });
+      const messages = warn.mock.calls.map((call) => String(call[0]));
+      const unknown = messages.filter((m) => m.includes("unknown tools"));
+      expect(unknown).toEqual([
+        "[MCP] SWARM_ENABLED_TOOLS names unknown tools, ignoring them: no-such-tool-a1, no-such-tool-b2",
+      ]);
+    } finally {
+      warn.mockRestore();
+    }
+  });
+
+  test("an empty value logs and behaves as unset", async () => {
+    const unset = await toolNames({});
+    const warn = spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      expect(await toolNames({ enabledTools: " , " })).toEqual(unset);
+      expect(await toolNames({ enabledTools: "" })).toEqual(unset);
+      expect(
+        warn.mock.calls.some((call) => String(call[0]).includes("lists no tools; ignoring it")),
+      ).toBe(true);
+    } finally {
+      warn.mockRestore();
+    }
+  });
+
+  test("an agent-scoped value beats the swarm-wide one, per session", async () => {
+    const scoped = await createAgent({ name: "allowlist-agent", isLead: false, status: "idle" });
+    const neighbor = await createAgent({
+      name: "allowlist-neighbor",
+      isLead: false,
+      status: "idle",
+    });
+    await upsertSwarmConfig({ scope: "global", key: "SWARM_ENABLED_TOOLS", value: "get-tasks" });
+    await upsertSwarmConfig({
+      scope: "agent",
+      scopeId: scoped.id,
+      key: "SWARM_ENABLED_TOOLS",
+      value: "store-progress,post-message",
+    });
+
+    expect(await listSessionTools(scoped.id)).toEqual(["post-message", "store-progress"]);
+    expect(await listSessionTools(neighbor.id)).toEqual(["get-tasks"]);
+
+    // Reloadable: a config change applies on the next session, no restart.
+    await upsertSwarmConfig({
+      scope: "agent",
+      scopeId: scoped.id,
+      key: "SWARM_ENABLED_TOOLS",
+      value: "store-progress",
+    });
+    expect(await listSessionTools(scoped.id)).toEqual(["store-progress"]);
+  });
+});

package/src/tests/entrypoint-codex-oauth-seed.test.ts

@@ -119,6 +119,7 @@ describe("docker-entrypoint.sh: codex_oauth boot-seed jq transform", () => {
   test(
     "blanks refresh_token for a flat {access,refresh,accountId,expires} input",
     async () => {
+      const before = Math.floor(Date.now() / 1000) * 1000;
       const result = (await runJqFilter(filter, {
         access: "example-access-tok",
         refresh: "example-live-refresh-tok",
@@ -126,6 +127,8 @@ describe("docker-entrypoint.sh: codex_oauth boot-seed jq transform", () => {
         expires: 1_800_000_000_000,
       })) as {
         auth_mode: string;
+        last_refresh: string;
+        expires: number;
         tokens: {
           id_token: string;
           access_token: string;
@@ -139,6 +142,9 @@ describe("docker-entrypoint.sh: codex_oauth boot-seed jq transform", () => {
       expect(result.tokens.id_token).toBe("example-access-tok");
       expect(result.tokens.access_token).toBe("example-access-tok");
       expect(result.tokens.account_id).toBe("acct-456");
+      expect(Date.parse(result.last_refresh)).toBeGreaterThanOrEqual(before);
+      expect(Date.parse(result.last_refresh)).toBeLessThanOrEqual(Date.now());
+      expect(result.expires).toBe(1_800_000_000_000);
     },
     CHILD_PROCESS_TEST_BUDGET_MS,
   );
@@ -182,6 +188,7 @@ describe("docker-entrypoint.sh: codex_oauth boot-seed jq transform", () => {
   test(
     "preserves refresh_token (from the flat `refresh` field) for a flat input on the standalone path",
     async () => {
+      const before = Math.floor(Date.now() / 1000) * 1000;
       const result = (await runJqFilter(
         filter,
         {
@@ -193,9 +200,14 @@ describe("docker-entrypoint.sh: codex_oauth boot-seed jq transform", () => {
         true,
       )) as {
         tokens: { refresh_token: string };
+        last_refresh: string;
+        expires: number;
       };
 
       expect(result.tokens.refresh_token).toBe("example-live-refresh-tok");
+      expect(Date.parse(result.last_refresh)).toBeGreaterThanOrEqual(before);
+      expect(Date.parse(result.last_refresh)).toBeLessThanOrEqual(Date.now());
+      expect(result.expires).toBe(1_800_000_000_000);
     },
     CHILD_PROCESS_TEST_BUDGET_MS,
   );

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

@@ -25,6 +25,7 @@ import {
   buildGrokConfigToml,
   checkGrokCredentials,
   GrokAdapter,
+  grokOpenRouterModel,
   installedClaudePluginNames,
 } from "../providers/grok-adapter";
 import type { ProviderEvent, ProviderSessionConfig } from "../providers/types";
@@ -487,6 +488,7 @@ describe("GrokAdapter", () => {
           'base_url = "https://openrouter.ai/api/v1"',
           'env_key = "OPENROUTER_API_KEY"',
           'api_backend = "chat_completions"',
+          'extra_headers = { "HTTP-Referer" = "https://agent-swarm.dev", "X-OpenRouter-Title" = "Agent Swarm", "X-OpenRouter-Categories" = "personal-agent,cloud-agent" }',
         ].join("\n"),
       );
     } finally {
@@ -495,6 +497,17 @@ describe("GrokAdapter", () => {
     }
   });
 
+  test("OpenRouter app attribution rides only on direct openrouter.ai models", () => {
+    const toml = (env: Record<string, string>) =>
+      buildGrokConfigToml([], grokOpenRouterModel("openrouter/acme/thing", env));
+    expect(toml({})).toContain('extra_headers = { "HTTP-Referer" = "https://agent-swarm.dev"');
+    expect(toml({ OPENROUTER_BASE_URL: "https://gateway.example/v1" })).not.toContain(
+      "extra_headers",
+    );
+    expect(toml({ OPENROUTER_APP_ATTRIBUTION: "false" })).not.toContain("extra_headers");
+    expect(buildGrokConfigToml([], null)).not.toContain("extra_headers");
+  });
+
   test("an xai/-qualified model runs as the bare xAI id", async () => {
     const dir = makeTempDir();
     const grok = writeFakeGrok(dir, "ok");

package/src/tests/haiku-5-5-pricing.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, test } from "bun:test";
+import { loadModelsDevCache } from "../be/modelsdev-cache";
+import { buildModelsDevSeedRows } from "../be/seed-pricing";
+
+function ratesFor(provider: string, model: string) {
+  const cache = loadModelsDevCache();
+  expect(cache).not.toBeNull();
+  return Object.fromEntries(
+    buildModelsDevSeedRows(cache!)
+      .filter((row) => row.provider === provider && row.model === model)
+      .map((row) => [row.tokenClass, row.pricePerMillionUsd]),
+  );
+}
+
+describe("Haiku 5.5 pricing seed", () => {
+  test("seeds Anthropic rates for the claude harnesses, including the 1h cache write", () => {
+    for (const provider of ["claude", "claude-managed"]) {
+      expect(ratesFor(provider, "claude-haiku-5-5")).toEqual({
+        input: 0.1,
+        output: 0.5,
+        cached_input: 0.01,
+        cache_write: 0.125,
+        cache_write_1h: 0.2,
+      });
+    }
+  });
+
+  test("seeds the same rates without a 1h class for amp and cursor", () => {
+    for (const provider of ["amp", "cursor"]) {
+      expect(ratesFor(provider, "claude-haiku-5-5")).toEqual({
+        input: 0.1,
+        output: 0.5,
+        cached_input: 0.01,
+        cache_write: 0.125,
+      });
+    }
+  });
+});