@desplega.ai/agent-swarm 1.79.4 → 1.80.1

package/src/tests/session-costs-model-key-normalize.test.ts

@@ -0,0 +1,271 @@
+// Phase 2 fix — adapter-emitted model ids carry harness-specific routing
+// prefixes (`openrouter/`, `github-copilot/`, …) that the pricing seed does
+// not. Before the fix every opencode + pi-via-copilot run fell through to
+// `costSource='unpriced'` even when a seeded rate row existed. This suite
+// regresses the drift cases observed in real-harness E2E.
+
+import { afterAll, afterEach, 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, getDb, initDb, insertPricingRow } from "../be/db";
+import { normalizeModelKey } from "../be/pricing-normalize";
+import { handleCore } from "../http/core";
+import { handleSessionData } from "../http/session-data";
+import { getPathSegments, parseQueryParams } from "../http/utils";
+
+const TEST_DB_PATH = "./test-model-key-normalize.sqlite";
+const API_KEY = "test-model-key-normalize";
+
+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 listen(server: Server): Promise<number> {
+  await new Promise<void>((resolve) => server.listen(0, resolve));
+  const addr = server.address();
+  if (!addr || typeof addr === "string") throw new Error("no port");
+  return addr.port;
+}
+
+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 handleSessionData(req, res, pathSegments, queryParams, myAgentId);
+    if (!ok) {
+      res.writeHead(404);
+      res.end("Not Found");
+    }
+  });
+}
+
+let server: Server;
+let port: number;
+let testAgent: { id: string };
+
+beforeAll(async () => {
+  await removeDbFiles(TEST_DB_PATH);
+  initDb(TEST_DB_PATH);
+  testAgent = createAgent({ name: "model-key-normalize-test", isLead: false, status: "idle" });
+  server = createTestServer(API_KEY);
+  port = await listen(server);
+});
+
+afterAll(async () => {
+  await new Promise<void>((resolve) => server.close(() => resolve()));
+  closeDb();
+  await removeDbFiles(TEST_DB_PATH);
+});
+
+afterEach(() => {
+  const db = getDb();
+  db.prepare("DELETE FROM session_costs").run();
+  db.prepare("DELETE FROM pricing WHERE effective_from > 0").run();
+});
+
+function authedFetch(path: string, init: RequestInit = {}): Promise<Response> {
+  return fetch(`http://localhost:${port}${path}`, {
+    ...init,
+    headers: {
+      Authorization: `Bearer ${API_KEY}`,
+      "Content-Type": "application/json",
+      ...(init.headers ?? {}),
+    },
+  });
+}
+
+interface CostResponse {
+  success: boolean;
+  cost: {
+    totalCostUsd: number;
+    model: string;
+    costSource: "harness" | "pricing-table" | "unpriced";
+  };
+}
+
+describe("normalizeModelKey()", () => {
+  test("strips opencode routing prefix `openrouter/`", () => {
+    expect(normalizeModelKey("opencode", "openrouter/anthropic/claude-sonnet-4.5")).toBe(
+      "anthropic/claude-sonnet-4.5",
+    );
+  });
+
+  test("strips pi routing prefix `github-copilot/`", () => {
+    expect(normalizeModelKey("pi", "github-copilot/gpt-5.4")).toBe("gpt-5.4");
+  });
+
+  test("strips pi routing prefix `openrouter/`", () => {
+    expect(normalizeModelKey("pi", "openrouter/anthropic/claude-sonnet-4.5")).toBe(
+      "anthropic/claude-sonnet-4.5",
+    );
+  });
+
+  test("strips pi routing prefix `openrouter/` for deepseek (Phase 3 fix regression)", () => {
+    // The exact case from today's E2E (2026-05-18): pi-mono emits
+    // `openrouter/deepseek/deepseek-v4-flash`, the pricing seed keys the row
+    // under bare `deepseek/deepseek-v4-flash`. Drift collapsed before this
+    // assertion exists; keep it as an explicit regression guard.
+    expect(normalizeModelKey("pi", "openrouter/deepseek/deepseek-v4-flash")).toBe(
+      "deepseek/deepseek-v4-flash",
+    );
+  });
+
+  test("strips opencode routing prefix `openrouter/` for deepseek (Phase 3 fix regression)", () => {
+    // Same model, different harness — opencode-adapter wraps the underlying
+    // model id under the same `openrouter/` proxy prefix.
+    expect(normalizeModelKey("opencode", "openrouter/deepseek/deepseek-v4-flash")).toBe(
+      "deepseek/deepseek-v4-flash",
+    );
+  });
+
+  test("is a no-op for canonical claude ids", () => {
+    expect(normalizeModelKey("claude", "claude-opus-4-7")).toBe("claude-opus-4-7");
+  });
+
+  test("is idempotent", () => {
+    const once = normalizeModelKey("opencode", "openrouter/anthropic/claude-sonnet-4.5");
+    const twice = normalizeModelKey("opencode", once);
+    expect(twice).toBe(once);
+  });
+
+  test("lowercases mixed-case input", () => {
+    expect(normalizeModelKey("opencode", "OpenRouter/Anthropic/Claude-Sonnet-4.5")).toBe(
+      "anthropic/claude-sonnet-4.5",
+    );
+  });
+});
+
+describe("Phase 2 fix — POST /api/session-costs normalizes routing prefixes", () => {
+  test("opencode `openrouter/anthropic/claude-sonnet-4.5` resolves the seeded `anthropic/claude-sonnet-4.5` row", async () => {
+    // Seed mirrors what models.dev → seed-pricing.ts produces for the
+    // openrouter section: bare `anthropic/<id>` under the `opencode` provider.
+    insertPricingRow({
+      provider: "opencode",
+      model: "anthropic/claude-sonnet-4.5",
+      tokenClass: "input",
+      effectiveFrom: 1,
+      pricePerMillionUsd: 3,
+    });
+    insertPricingRow({
+      provider: "opencode",
+      model: "anthropic/claude-sonnet-4.5",
+      tokenClass: "output",
+      effectiveFrom: 1,
+      pricePerMillionUsd: 15,
+    });
+
+    const res = await authedFetch(`/api/session-costs`, {
+      method: "POST",
+      body: JSON.stringify({
+        sessionId: "opencode-normalize-1",
+        agentId: testAgent.id,
+        totalCostUsd: 0.42, // harness-reported, expected to be overwritten
+        inputTokens: 1_000_000,
+        outputTokens: 100_000,
+        // The exact string the opencode adapter emits today.
+        model: "openrouter/anthropic/claude-sonnet-4.5",
+        provider: "opencode",
+        durationMs: 1_000,
+        numTurns: 1,
+      }),
+    });
+    expect(res.status).toBe(201);
+    const body = (await res.json()) as CostResponse;
+    // 1M @ $3 + 100k @ $15 = $3 + $1.50 = $4.50
+    expect(body.cost.costSource).toBe("pricing-table");
+    expect(body.cost.totalCostUsd).toBeCloseTo(4.5, 5);
+    // Original adapter-emitted string is preserved on the row for debugging.
+    expect(body.cost.model).toBe("openrouter/anthropic/claude-sonnet-4.5");
+  });
+
+  test("pi `github-copilot/gpt-5.4` resolves the seeded bare `gpt-5.4` row", async () => {
+    insertPricingRow({
+      provider: "pi",
+      model: "gpt-5.4",
+      tokenClass: "input",
+      effectiveFrom: 1,
+      pricePerMillionUsd: 2,
+    });
+    insertPricingRow({
+      provider: "pi",
+      model: "gpt-5.4",
+      tokenClass: "output",
+      effectiveFrom: 1,
+      pricePerMillionUsd: 8,
+    });
+
+    const res = await authedFetch(`/api/session-costs`, {
+      method: "POST",
+      body: JSON.stringify({
+        sessionId: "pi-copilot-normalize-1",
+        agentId: testAgent.id,
+        totalCostUsd: 9.99,
+        inputTokens: 500_000,
+        outputTokens: 250_000,
+        model: "github-copilot/gpt-5.4",
+        provider: "pi",
+        durationMs: 1_000,
+        numTurns: 1,
+      }),
+    });
+    expect(res.status).toBe(201);
+    const body = (await res.json()) as CostResponse;
+    // 500k @ $2 + 250k @ $8 = $1 + $2 = $3
+    expect(body.cost.costSource).toBe("pricing-table");
+    expect(body.cost.totalCostUsd).toBeCloseTo(3.0, 5);
+    expect(body.cost.model).toBe("github-copilot/gpt-5.4");
+  });
+
+  test("claude `claude-opus-4-7` (no prefix) still resolves — regression guard", async () => {
+    // The bug report flagged claude-adapter as already-working. Make sure
+    // we did not regress its bare-id lookup.
+    insertPricingRow({
+      provider: "claude",
+      model: "claude-opus-4-7",
+      tokenClass: "input",
+      effectiveFrom: 1,
+      pricePerMillionUsd: 15,
+    });
+    insertPricingRow({
+      provider: "claude",
+      model: "claude-opus-4-7",
+      tokenClass: "output",
+      effectiveFrom: 1,
+      pricePerMillionUsd: 75,
+    });
+
+    const res = await authedFetch(`/api/session-costs`, {
+      method: "POST",
+      body: JSON.stringify({
+        sessionId: "claude-bare-1",
+        agentId: testAgent.id,
+        totalCostUsd: 1.23,
+        inputTokens: 1_000_000,
+        outputTokens: 100_000,
+        model: "claude-opus-4-7",
+        provider: "claude",
+        durationMs: 1_000,
+        numTurns: 1,
+      }),
+    });
+    expect(res.status).toBe(201);
+    const body = (await res.json()) as CostResponse;
+    // 1M @ $15 + 100k @ $75 = $15 + $7.50 = $22.50
+    expect(body.cost.costSource).toBe("pricing-table");
+    expect(body.cost.totalCostUsd).toBeCloseTo(22.5, 5);
+  });
+});

package/src/tests/session-costs-recompute-all-providers.test.ts

@@ -0,0 +1,170 @@
+// Phase 2: POST /api/session-costs recompute fires for every provider with
+// seeded pricing rows — not just codex. Unknown (provider, model) pairs are
+// tagged `costSource='unpriced'`.
+
+import { afterAll, afterEach, 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, getDb, initDb, insertPricingRow } from "../be/db";
+import { handleCore } from "../http/core";
+import { handleSessionData } from "../http/session-data";
+import { getPathSegments, parseQueryParams } from "../http/utils";
+
+const TEST_DB_PATH = "./test-recompute-all-providers.sqlite";
+const API_KEY = "test-recompute-all";
+
+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 listen(server: Server): Promise<number> {
+  await new Promise<void>((resolve) => server.listen(0, resolve));
+  const addr = server.address();
+  if (!addr || typeof addr === "string") throw new Error("no port");
+  return addr.port;
+}
+
+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 handleSessionData(req, res, pathSegments, queryParams, myAgentId);
+    if (!ok) {
+      res.writeHead(404);
+      res.end("Not Found");
+    }
+  });
+}
+
+let server: Server;
+let port: number;
+let testAgent: { id: string };
+
+beforeAll(async () => {
+  await removeDbFiles(TEST_DB_PATH);
+  initDb(TEST_DB_PATH);
+  testAgent = createAgent({ name: "recompute-all-test", isLead: false, status: "idle" });
+  server = createTestServer(API_KEY);
+  port = await listen(server);
+});
+
+afterAll(async () => {
+  await new Promise<void>((resolve) => server.close(() => resolve()));
+  closeDb();
+  await removeDbFiles(TEST_DB_PATH);
+});
+
+afterEach(() => {
+  const db = getDb();
+  db.prepare("DELETE FROM session_costs").run();
+  // Wipe everything we explicitly inserted (effective_from > 0); leave the
+  // migration-046 codex seeds alone.
+  db.prepare("DELETE FROM pricing WHERE effective_from > 0").run();
+});
+
+function authedFetch(path: string, init: RequestInit = {}): Promise<Response> {
+  return fetch(`http://localhost:${port}${path}`, {
+    ...init,
+    headers: {
+      Authorization: `Bearer ${API_KEY}`,
+      "Content-Type": "application/json",
+      ...(init.headers ?? {}),
+    },
+  });
+}
+
+interface CostResponse {
+  success: boolean;
+  cost: {
+    totalCostUsd: number;
+    costSource: "harness" | "pricing-table" | "unpriced";
+  };
+}
+
+function seedTwoClassRates(provider: string, model: string, inputRate = 1, outputRate = 10) {
+  insertPricingRow({
+    provider: provider as Parameters<typeof insertPricingRow>[0]["provider"],
+    model,
+    tokenClass: "input",
+    effectiveFrom: 1,
+    pricePerMillionUsd: inputRate,
+  });
+  insertPricingRow({
+    provider: provider as Parameters<typeof insertPricingRow>[0]["provider"],
+    model,
+    tokenClass: "output",
+    effectiveFrom: 1,
+    pricePerMillionUsd: outputRate,
+  });
+}
+
+describe("Phase 2 — POST /api/session-costs recompute fires for every provider", () => {
+  for (const provider of [
+    "claude",
+    "claude-managed",
+    "codex",
+    "pi",
+    "opencode",
+    "devin",
+    "gemini",
+  ] as const) {
+    test(`provider=${provider} with seeded rows → costSource='pricing-table'`, async () => {
+      seedTwoClassRates(provider, `${provider}-test-model`, 2, 10);
+
+      const res = await authedFetch(`/api/session-costs`, {
+        method: "POST",
+        body: JSON.stringify({
+          sessionId: `${provider}-recompute-1`,
+          agentId: testAgent.id,
+          totalCostUsd: 999.99, // worker-reported; expected to be overwritten
+          inputTokens: 1_000_000, // 1M input
+          outputTokens: 500_000, // 500k output
+          model: `${provider}-test-model`,
+          provider,
+          durationMs: 1_000,
+          numTurns: 1,
+        }),
+      });
+      expect(res.status).toBe(201);
+      const body = (await res.json()) as CostResponse;
+      expect(body.cost.costSource).toBe("pricing-table");
+      // 1M @ 2 + 0.5M @ 10 = $2 + $5 = $7
+      expect(body.cost.totalCostUsd).toBeCloseTo(7.0, 5);
+    });
+  }
+
+  test("unknown (provider, model) pair → costSource='unpriced', worker value preserved", async () => {
+    const res = await authedFetch(`/api/session-costs`, {
+      method: "POST",
+      body: JSON.stringify({
+        sessionId: "unpriced-1",
+        agentId: testAgent.id,
+        totalCostUsd: 1.23,
+        inputTokens: 100,
+        outputTokens: 50,
+        model: "gpt-future-2027",
+        provider: "codex",
+        durationMs: 1_000,
+        numTurns: 1,
+      }),
+    });
+    expect(res.status).toBe(201);
+    const body = (await res.json()) as CostResponse;
+    expect(body.cost.costSource).toBe("unpriced");
+    expect(body.cost.totalCostUsd).toBe(1.23);
+  });
+});

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

@@ -24,7 +24,12 @@ type TestCostData = {
   model?: string;
 };
 
-describe("store-progress with cost data", () => {
+// Phase 11 NOTE: the `store-progress` MCP tool no longer accepts a `costData`
+// field — adapters are the sole writers of `session_costs`. These tests now
+// exercise the lower-level `createSessionCost` API directly, which the runner
+// still calls via `POST /api/session-costs`. They verify the DB write path
+// hasn't regressed, NOT the tool's input schema.
+describe("createSessionCost direct API (was: store-progress with cost data)", () => {
   let agentId: string;
   let taskId: string;
 

package/src/tests/swarm-config.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, test } from "bun:test";
+import type { SwarmConfigPayload } from "../scripts-runtime/executors/types";
+import { Redacted } from "../scripts-runtime/redacted";
+import { SwarmConfig } from "../scripts-runtime/swarm-config";
+
+const payload: SwarmConfigPayload = {
+  system: {
+    apiKey: { value: "test-api-key", isSecret: true },
+    agentId: { value: "agent-1", isSecret: false },
+    mcpBaseUrl: { value: "http://localhost:3013", isSecret: false },
+  },
+  user: {
+    "user-key": { value: "user-value", isSecret: true },
+  },
+};
+
+describe("SwarmConfig", () => {
+  test("hydrates system values as Redacted values with metadata", () => {
+    const config = new SwarmConfig(payload);
+    expect(Redacted.value(config.apiKey)).toBe("test-api-key");
+    expect(Redacted.meta(config.apiKey)).toEqual({ type: "system", isSecret: true });
+    expect(Redacted.value(config.agentId)).toBe("agent-1");
+    expect(Redacted.meta(config.mcpBaseUrl)).toEqual({ type: "system", isSecret: false });
+  });
+
+  test("returns user-set config values", () => {
+    const config = new SwarmConfig(payload);
+    const value = config.get("user-key");
+    expect(value).toBeDefined();
+    expect(Redacted.value(value!)).toBe("user-value");
+    expect(Redacted.meta(value!)).toEqual({ type: "user", isSecret: true });
+  });
+
+  test("missing user keys return undefined", () => {
+    const config = new SwarmConfig(payload);
+    expect(config.get("missing")).toBeUndefined();
+  });
+});

package/src/tests/tool-annotations.test.ts

@@ -323,9 +323,9 @@ describe("Tool Annotations & Classification", () => {
   test("registered tool count matches expected total", () => {
     const count = Object.keys(tools).length;
     // We expect all tools to be registered when all capabilities are enabled (default)
-    // Includes 11 skill tools and 7 MCP server tools
+    // Includes 11 skill tools, 7 MCP server tools, and reusable script tools
     expect(count).toBeGreaterThanOrEqual(45);
-    expect(count).toBeLessThanOrEqual(95);
+    expect(count).toBeLessThanOrEqual(100);
   });
 
   test("core tools are fewer than deferred tools", () => {

package/src/tests/tool-call-progress.test.ts

@@ -151,6 +151,31 @@ describe("toolCallToProgress", () => {
     expect(result).toBe("💬 Posting to Slack");
   });
 
+  test("agent-swarm:script-search has pretty label", () => {
+    const result = toolCallToProgress("mcp__agent-swarm__script-search", {});
+    expect(result).toBe("📜 Searching scripts");
+  });
+
+  test("agent-swarm:script-run has pretty label", () => {
+    const result = toolCallToProgress("mcp__agent-swarm__script-run", {});
+    expect(result).toBe("📜 Running script");
+  });
+
+  test("agent-swarm:script-upsert has pretty label", () => {
+    const result = toolCallToProgress("mcp__agent-swarm__script-upsert", {});
+    expect(result).toBe("📜 Saving script");
+  });
+
+  test("agent-swarm:script-delete has pretty label", () => {
+    const result = toolCallToProgress("mcp__agent-swarm__script-delete", {});
+    expect(result).toBe("📜 Deleting script");
+  });
+
+  test("agent-swarm:script-query-types has pretty label", () => {
+    const result = toolCallToProgress("mcp__agent-swarm__script-query-types", {});
+    expect(result).toBe("📜 Reading script types");
+  });
+
   // --- Agent-swarm MCP tool NOT in lookup (humanized fallback) ---
 
   test("unknown agent-swarm tool gets humanized fallback", () => {
@@ -191,6 +216,11 @@ describe("toolCallToProgress", () => {
     expect(result).toBe("🗃️ Querying database");
   });
 
+  test("bare agent-swarm script-run has pretty label", () => {
+    const result = toolCallToProgress("script-run", {});
+    expect(result).toBe("📜 Running script");
+  });
+
   test("codex MCP args with agent-swarm server use pretty labels", () => {
     const result = toolCallToProgress("send-task", {
       server: "agent-swarm",