@desplega.ai/agent-swarm 2.7.4 → 2.7.6

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

@@ -145,6 +145,8 @@ class FakeGrok {
   }
   async newSession(params) {
     capture.newSession = { meta: params._meta ?? null, mcpServers: params.mcpServers.map((s) => s.name) };
+    capture.newSessionKeys = Object.keys(params).sort();
+    capture.mcpUrls = params.mcpServers.map((s) => s.url);
     writeFileSync("capture.json", JSON.stringify(capture));
     if (${JSON.stringify(mode)} === "auth-required") throw RequestError.authRequired();
     return { sessionId: "grok-session-1" };
@@ -425,6 +427,40 @@ describe("GrokAdapter", () => {
     }
   });
 
+  test("the opt-in ACP hooks leave grok's session/new payload, MCP URL and steering unchanged", async () => {
+    const dir = makeTempDir();
+    const grok = writeFakeGrok(dir, "ok");
+    const { server, apiUrl } = await startTokenStub();
+    // Reachable but plain-HTTP and non-loopback: a target with requiresSecureMcpUrl would proxy it.
+    const publicStyleUrl = apiUrl.replace("127.0.0.1", "0.0.0.0");
+    try {
+      const config = baseConfig({
+        apiUrl: publicStyleUrl,
+        resumeSessionId: "ignored-without-a-resume-hook",
+        env: {
+          PATH: process.env.PATH ?? "",
+          HOME: makeTempDir(),
+          GROK_BINARY: grok,
+          XAI_API_KEY: "xai-test-key",
+        },
+      });
+      const adapter = new GrokAdapter();
+      const session = await adapter.createSession(config);
+      await session.waitForCompletion();
+      expect(session.deliverSteering).toBeUndefined();
+      expect(await adapter.canResume("grok-session-1")).toBe(false);
+      const capture = JSON.parse(await Bun.file(join(config.cwd, "capture.json")).text());
+      expect(capture.newSession).toEqual({
+        meta: { rules: "You are a swarm worker.", yoloMode: true },
+        mcpServers: ["swarm"],
+      });
+      expect(capture.newSessionKeys).toEqual(["_meta", "cwd", "mcpServers"]);
+      expect(capture.mcpUrls).toEqual([`${publicStyleUrl}/mcp`]);
+    } finally {
+      await new Promise<void>((resolve) => server.close(() => resolve()));
+    }
+  });
+
   test("runs an openrouter/ model as an OpenAI-compatible model on OPENROUTER_API_KEY", async () => {
     const dir = makeTempDir();
     // A BYOK route reports the endpoint's id and no ticks.

package/src/tests/list-total-cache.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { createListTotalCache } from "../http/list-total-cache";
+import { createListTotalCache, LIST_TOTAL_TTL_MS } from "../http/list-total-cache";
 
 function counter(values: number[]) {
   let calls = 0;
@@ -10,7 +10,7 @@ function counter(values: number[]) {
 }
 
 describe("list total cache", () => {
-  test("page 1 always counts; later pages reuse its count", async () => {
+  test("page 1 always counts by default; later pages reuse its count", async () => {
     const cache = createListTotalCache();
     const count = counter([10, 11, 12]);
 
@@ -24,6 +24,31 @@ describe("list total cache", () => {
     expect(count.calls()).toBe(2);
   });
 
+  test("page 1 polls within the first-page TTL share one count", async () => {
+    const cache = createListTotalCache(LIST_TOTAL_TTL_MS, 50);
+    const count = counter([10, 11]);
+    expect(await cache.get({ q: "a" }, 0, count.compute)).toBe(10);
+    expect(await cache.get({ q: "a" }, 0, count.compute)).toBe(10);
+    expect(count.calls()).toBe(1);
+    await Bun.sleep(60);
+    expect(await cache.get({ q: "a" }, 0, count.compute)).toBe(11);
+    expect(count.calls()).toBe(2);
+  });
+
+  test("with a first-page TTL, concurrent page 1 requests share an in-flight count", async () => {
+    const cache = createListTotalCache(LIST_TOTAL_TTL_MS, 1000);
+    let calls = 0;
+    const compute = async () => {
+      calls++;
+      await Bun.sleep(5);
+      return 4;
+    };
+    expect(await Promise.all([cache.get({}, 0, compute), cache.get({}, 0, compute)])).toEqual([
+      4, 4,
+    ]);
+    expect(calls).toBe(1);
+  });
+
   test("a cold later page counts, so total is always set", async () => {
     const cache = createListTotalCache();
     const count = counter([7]);

package/src/tests/mcp-loopback-proxy.test.ts

@@ -0,0 +1,193 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { secureMcpServers } from "../providers/acp-adapter";
+import {
+  type McpLoopbackProxy,
+  needsLoopbackProxy,
+  startMcpLoopbackProxy,
+} from "../providers/mcp-loopback-proxy";
+import { getFreePort } from "./test-net";
+
+type Upstream = ReturnType<typeof Bun.serve>;
+
+const cleanups: Array<() => Promise<void> | void> = [];
+
+afterEach(async () => {
+  for (const cleanup of cleanups.splice(0).reverse()) await cleanup();
+});
+
+function track(proxy: McpLoopbackProxy): McpLoopbackProxy {
+  cleanups.push(() => proxy.stop());
+  return proxy;
+}
+
+/** A stand-in MCP endpoint: JSON echo, a slow SSE stream and a redirect. */
+function startUpstream(): Upstream {
+  const server = Bun.serve({
+    hostname: "127.0.0.1",
+    port: 0,
+    idleTimeout: 0,
+    async fetch(req) {
+      const url = new URL(req.url);
+      if (url.pathname === "/prefix/mcp" && req.method === "POST") {
+        return Response.json({
+          path: url.pathname,
+          search: url.search,
+          method: req.method,
+          body: await req.json(),
+          authorization: req.headers.get("authorization"),
+          agentId: req.headers.get("x-agent-id"),
+          host: req.headers.get("host"),
+        });
+      }
+      if (url.pathname === "/prefix/sse") {
+        const encoder = new TextEncoder();
+        const stream = new ReadableStream<Uint8Array>({
+          async start(controller) {
+            for (const n of [1, 2, 3]) {
+              controller.enqueue(encoder.encode(`event: message\ndata: {"n":${n}}\n\n`));
+              await Bun.sleep(30);
+            }
+            controller.close();
+          },
+        });
+        return new Response(stream, { headers: { "Content-Type": "text/event-stream" } });
+      }
+      if (url.pathname === "/prefix/redirect") {
+        return new Response(null, { status: 302, headers: { Location: "https://example.test/" } });
+      }
+      return new Response("not found", { status: 404 });
+    },
+  });
+  cleanups.push(() => server.stop(true));
+  return server;
+}
+
+describe("needsLoopbackProxy", () => {
+  test("only plain HTTP to a non-loopback host needs the forwarder", () => {
+    expect(needsLoopbackProxy("http://api:3013/mcp")).toBe(true);
+    expect(needsLoopbackProxy("http://10.0.0.5/mcp")).toBe(true);
+    // fx accepts only these loopback names; 127.0.0.2 is rejected (fx 0.0.15).
+    expect(needsLoopbackProxy("http://127.0.0.2:3013/mcp")).toBe(true);
+    expect(needsLoopbackProxy("http://127.0.0.1:3013/mcp")).toBe(false);
+    expect(needsLoopbackProxy("http://localhost:3013/mcp")).toBe(false);
+    expect(needsLoopbackProxy("http://[::1]:3013/mcp")).toBe(false);
+    expect(needsLoopbackProxy("https://swarm.example/mcp")).toBe(false);
+    expect(needsLoopbackProxy("not a url")).toBe(false);
+  });
+});
+
+describe("startMcpLoopbackProxy", () => {
+  test("round-trips a JSON POST with its headers, under the upstream path prefix", async () => {
+    const upstream = startUpstream();
+    const proxy = track(await startMcpLoopbackProxy(`http://127.0.0.1:${upstream.port}/prefix/`));
+    expect(proxy.url).toMatch(/^http:\/\/127\.0\.0\.1:\d+$/);
+
+    const response = await fetch(`${proxy.url}/mcp?session=1`, {
+      method: "POST",
+      headers: {
+        Authorization: "Bearer aseph_proxytest",
+        "X-Agent-ID": "agent-1",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/list" }),
+    });
+    expect(response.status).toBe(200);
+    expect(await response.json()).toEqual({
+      path: "/prefix/mcp",
+      search: "?session=1",
+      method: "POST",
+      body: { jsonrpc: "2.0", id: 1, method: "tools/list" },
+      authorization: "Bearer aseph_proxytest",
+      agentId: "agent-1",
+      // The upstream sees its own host, not the forwarder's.
+      host: `127.0.0.1:${upstream.port}`,
+    });
+  });
+
+  test("streams SSE events in order as they arrive", async () => {
+    const upstream = startUpstream();
+    const proxy = track(await startMcpLoopbackProxy(`http://127.0.0.1:${upstream.port}/prefix`));
+    const response = await fetch(`${proxy.url}/sse`);
+    expect(response.headers.get("content-type")).toContain("text/event-stream");
+    const reader = response.body!.getReader();
+    const decoder = new TextDecoder();
+    let text = "";
+    let reads = 0;
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      reads += 1;
+      text += decoder.decode(value, { stream: true });
+    }
+    expect([...text.matchAll(/"n":(\d)/g)].map((m) => m[1])).toEqual(["1", "2", "3"]);
+    // Delivered incrementally, not buffered into one body.
+    expect(reads).toBeGreaterThan(1);
+  });
+
+  test("passes a redirect through instead of following it", async () => {
+    const upstream = startUpstream();
+    const proxy = track(await startMcpLoopbackProxy(`http://127.0.0.1:${upstream.port}/prefix`));
+    const response = await fetch(`${proxy.url}/redirect`, { redirect: "manual" });
+    expect(response.status).toBe(302);
+    expect(response.headers.get("location")).toBe("https://example.test/");
+  });
+
+  test("answers 502 when the upstream is down", async () => {
+    const port = await getFreePort();
+    const proxy = track(await startMcpLoopbackProxy(`http://127.0.0.1:${port}`));
+    const response = await fetch(`${proxy.url}/mcp`, { method: "POST", body: "{}" });
+    expect(response.status).toBe(502);
+    expect(((await response.json()) as { error: string }).error).toContain(
+      "MCP loopback proxy: upstream failed",
+    );
+  });
+
+  test("stop() frees the port and is idempotent", async () => {
+    const upstream = startUpstream();
+    const proxy = await startMcpLoopbackProxy(`http://127.0.0.1:${upstream.port}/prefix`);
+    await proxy.stop();
+    await proxy.stop();
+    await expect(fetch(`${proxy.url}/sse`)).rejects.toThrow();
+  });
+});
+
+describe("secureMcpServers", () => {
+  test("forwards plain-HTTP non-loopback servers, one forwarder per origin, and drops SSE", async () => {
+    const proxies: McpLoopbackProxy[] = [];
+    cleanups.push(async () => {
+      for (const proxy of proxies) await proxy.stop();
+    });
+    const servers = await secureMcpServers(
+      [
+        { type: "http", name: "swarm", url: "http://api:3013/mcp", headers: [] },
+        { type: "http", name: "same-origin", url: "http://api:3013/other?x=1", headers: [] },
+        { type: "http", name: "secure", url: "https://mcp.example/mcp", headers: [] },
+        { type: "http", name: "local", url: "http://127.0.0.1:9/mcp", headers: [] },
+        { type: "sse", name: "legacy", url: "https://sse.example/sse", headers: [] },
+        { name: "stdio", command: "true", args: [], env: [] },
+      ],
+      false,
+      proxies,
+    );
+    expect(proxies).toHaveLength(1);
+    const forwarded = proxies[0]!.url;
+    expect(servers.map((server) => [server.name, "url" in server ? server.url : null])).toEqual([
+      ["swarm", `${forwarded}/mcp`],
+      ["same-origin", `${forwarded}/other?x=1`],
+      ["secure", "https://mcp.example/mcp"],
+      ["local", "http://127.0.0.1:9/mcp"],
+      ["stdio", null],
+    ]);
+  });
+
+  test("keeps SSE servers when the agent supports them", async () => {
+    const proxies: McpLoopbackProxy[] = [];
+    const servers = await secureMcpServers(
+      [{ type: "sse", name: "legacy", url: "https://sse.example/sse", headers: [] }],
+      true,
+      proxies,
+    );
+    expect(servers.map((server) => server.name)).toEqual(["legacy"]);
+    expect(proxies).toEqual([]);
+  });
+});

package/src/tests/memory-fts-populate.test.ts

@@ -2,8 +2,8 @@ import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { unlink } from "node:fs/promises";
 import { closeDb, createAgent, getDb, getDbClient, initDb } from "../be/db";
 import {
-  FTS_DELETE_EXTRA_SQL,
-  FTS_MISSING_IDS_SQL,
+  FTS_SCAN_BATCH_SQL,
+  MEMORY_ID_BATCH_SQL,
   SqliteMemoryStore,
 } from "../be/memory/providers/sqlite-store";
 
@@ -62,16 +62,18 @@ describe("memory_fts boot backfill", () => {
     // Positive control: the old anti-join scans memory_fts once per memory.
     expect(planOf(QUADRATIC_BACKFILL_SQL).join(" | ")).toContain("CORRELATED");
 
-    for (const sql of [FTS_MISSING_IDS_SQL, FTS_DELETE_EXTRA_SQL]) {
-      const plan = planOf(sql).join(" | ");
-      expect(plan).not.toContain("CORRELATED");
-      // Exactly one pass over memory_fts per statement.
-      expect(plan.match(/SCAN memory_fts/g)?.length).toBe(1);
-    }
+    // Each batch seeks a rowid range of one table. The orphan check is a
+    // lookup on the agent_memory primary key, never a scan of memory_fts.
+    const scan = planOf(FTS_SCAN_BATCH_SQL.replace(/\?/g, "0")).join(" | ");
+    expect(scan).toMatch(/SCAN memory_fts VIRTUAL TABLE INDEX \d+:>/);
+    expect(scan.match(/memory_fts/g)?.length).toBe(1);
+    expect(scan).toContain("SEARCH m USING COVERING INDEX sqlite_autoindex_agent_memory_1 (id=?)");
+    const ids = planOf(MEMORY_ID_BATCH_SQL.replace(/\?/g, "0")).join(" | ");
+    expect(ids).toContain("SEARCH agent_memory USING INTEGER PRIMARY KEY (rowid>?)");
   });
 
   test("a new store backfills missing rows across batches and drops orphans", async () => {
-    const total = 1050; // crosses two 500-row batch boundaries
+    const total = 1050; // crosses two 500-row insert batches and one 1000-row scan batch
     const seed = await store.store({
       agentId,
       scope: "agent",

package/src/tests/memory-retrieval-purge.test.ts

@@ -0,0 +1,80 @@
+import { afterAll, beforeAll, describe, expect, spyOn, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { closeDb, getDb, getDbClient, initDb } from "../be/db";
+import { purgeStaleSearchRetrievals, startMemoryGc, stopMemoryGc } from "../http/memory";
+
+const TEST_DB_PATH = "./test-memory-retrieval-purge.sqlite";
+const DAY = 24 * 60 * 60 * 1000;
+
+async function removeDbFiles(): Promise<void> {
+  for (const suffix of ["", "-wal", "-shm"])
+    await unlink(`${TEST_DB_PATH}${suffix}`).catch(() => undefined);
+}
+
+async function insertRetrieval(id: string, eventType: string, ageDays: number): Promise<void> {
+  await getDbClient().run(
+    `INSERT INTO memory_retrieval (id, agentId, memoryId, retrievedAt, eventType)
+     VALUES (?, 'agent-1', 'memory-1', ?, ?)`,
+    [id, new Date(Date.now() - ageDays * DAY).toISOString(), eventType],
+  );
+}
+
+describe("purgeStaleSearchRetrievals", () => {
+  beforeAll(async () => {
+    await removeDbFiles();
+    initDb(TEST_DB_PATH);
+  });
+
+  afterAll(async () => {
+    closeDb();
+    await removeDbFiles();
+  });
+
+  test("deletes stale search rows in batches and keeps fresh and get rows", async () => {
+    for (let i = 0; i < 5; i++) await insertRetrieval(`stale-search-${i}`, "search", 120);
+    await insertRetrieval("fresh-search", "search", 10);
+    await insertRetrieval("stale-get", "get", 120);
+
+    const run = spyOn(getDbClient(), "run");
+    let purged: number;
+    let calls: (typeof run.mock.calls)[number][];
+    try {
+      purged = await purgeStaleSearchRetrievals(2);
+      calls = [...run.mock.calls];
+    } finally {
+      run.mockRestore();
+    }
+    expect(purged).toBe(5);
+    // Batches of 2: 2 + 2 + 1, and the short batch ends the loop.
+    expect(calls).toHaveLength(3);
+
+    const left = await getDbClient().query<{ id: string }>(
+      "SELECT id FROM memory_retrieval ORDER BY id",
+    );
+    expect(left.map((row) => row.id)).toEqual(["fresh-search", "stale-get"]);
+
+    // Without sqlite_stat1 the plan must stay on the retrievedAt range, not
+    // read every search row through the eventType index.
+    const [sql, params] = calls[0]!;
+    const plan = getDb()
+      .query<{ detail: string }, any[]>(`EXPLAIN QUERY PLAN ${sql}`)
+      .all(...((params ?? []) as any[]))
+      .map((row) => row.detail)
+      .join("\n");
+    expect(plan).toContain("USING INDEX idx_memret_retrieved_at (retrievedAt<?)");
+    expect(plan).not.toContain("idx_memret_event_type");
+  });
+});
+
+describe("startMemoryGc", () => {
+  test("defers the first purge off the boot path", async () => {
+    const timeout = spyOn(globalThis, "setTimeout");
+    try {
+      await startMemoryGc(60 * 60 * 1000, 120_000);
+      expect(timeout.mock.calls.some(([, ms]) => ms === 120_000)).toBe(true);
+    } finally {
+      stopMemoryGc();
+      timeout.mockRestore();
+    }
+  });
+});

package/src/tests/migration-260-runtime-pool-cache.test.ts

@@ -0,0 +1,118 @@
+import { Database } from "bun:sqlite";
+import { expect, test } from "bun:test";
+import { runMigrations } from "../be/migrations/runner";
+import {
+  ControllerClientMessageSchema,
+  ControllerCommandSchema,
+} from "../runtime-providers/controller-protocol";
+
+test("migration 260 adds an optional JSON cache and the release table to a fresh database", () => {
+  const db = new Database(":memory:");
+  try {
+    runMigrations(db);
+    expect(db.query("PRAGMA table_info(runtime_pools)").all()).toContainEqual(
+      expect.objectContaining({ name: "cache", type: "TEXT", notnull: 0 }),
+    );
+    expect(db.query("PRAGMA foreign_key_check").all()).toEqual([]);
+    for (const name of ["runtime_ids", "state", "created_by", "updated_by"])
+      expect(db.query("PRAGMA table_info(runtime_cache_releases)").all()).toContainEqual(
+        expect.objectContaining({ name, type: "TEXT" }),
+      );
+  } finally {
+    db.close();
+  }
+});
+
+test("migration 260 preserves existing pools with caching disabled", async () => {
+  const db = new Database(":memory:");
+  try {
+    db.exec(
+      "CREATE TABLE _migrations (version INTEGER PRIMARY KEY, name TEXT NOT NULL, applied_at TEXT NOT NULL, checksum TEXT NOT NULL)",
+    );
+    for (const file of [...new Bun.Glob("*.sql").scanSync("src/be/migrations")]
+      .sort()
+      .filter((file) => Number(file.split("_")[0]) <= 259)) {
+      const sql = await Bun.file(`src/be/migrations/${file}`).text();
+      db.transaction(() => {
+        db.exec(sql);
+        db.run("INSERT INTO _migrations VALUES (?, ?, ?, ?)", [
+          Number(file.split("_")[0]),
+          file.replace(".sql", ""),
+          new Date().toISOString(),
+          new Bun.CryptoHasher("sha256").update(sql).digest("hex"),
+        ]);
+      }).immediate();
+    }
+    db.run(
+      "INSERT INTO runtime_pools (id, name, kind, placements, image, resources, env, lifecycle) VALUES (?, ?, ?, ?, ?, ?, ?, 'idle')",
+      [
+        "existing-pool",
+        "existing",
+        "docker",
+        '["controller"]',
+        "worker:test",
+        '{"cpu":2}',
+        '{"CUSTOM":"kept"}',
+      ],
+    );
+    runMigrations(db);
+    expect(db.query("SELECT name, image, resources, env, cache FROM runtime_pools").get()).toEqual({
+      name: "existing",
+      image: "worker:test",
+      resources: '{"cpu":2}',
+      env: '{"CUSTOM":"kept"}',
+      cache: null,
+    });
+    expect(() => db.run("UPDATE runtime_pools SET cache = 'invalid json'")).toThrow();
+    expect(db.query("SELECT COUNT(*) AS n FROM runtime_cache_releases").get()).toEqual({ n: 0 });
+  } finally {
+    db.close();
+  }
+});
+
+test("cache release runtime IDs accept arrays and reject other JSON values", () => {
+  const db = new Database(":memory:");
+  try {
+    runMigrations(db);
+    db.run(
+      "INSERT INTO runtime_controllers (id, name, kind, placement) VALUES ('controller', 'controller', 'docker', 'builtin')",
+    );
+    db.run(`INSERT INTO runtime_cache_releases (id, pool_id, controller_id, owner_id, cache_key, runtime_ids)
+      VALUES ('release', 'pool', 'controller', 'owner', 'cache', '[]')`);
+    for (const invalid of ["null", "{}", "42", "true", '"runtime"', "invalid json"])
+      expect(() =>
+        db.run("UPDATE runtime_cache_releases SET runtime_ids = ?", [invalid]),
+      ).toThrow();
+    db.run("UPDATE runtime_cache_releases SET runtime_ids = ?", ['["runtime-a","runtime-b"]']);
+    expect(db.query("SELECT runtime_ids FROM runtime_cache_releases").get()).toEqual({
+      runtime_ids: '["runtime-a","runtime-b"]',
+    });
+  } finally {
+    db.close();
+  }
+});
+
+test("controller protocol accepts legacy hello messages and retains optional cache metadata", () => {
+  const legacy = ControllerClientMessageSchema.parse({
+    type: "hello",
+    controllerId: "controller",
+    kind: "docker",
+    version: 1,
+    traits: { canProvision: true, ephemeralDisk: true, supportsPause: false },
+  });
+  if (legacy.type !== "hello") throw new Error("Expected hello");
+  expect(legacy.traits.persistentCache).toBeUndefined();
+  const payload = {
+    runtimeId: "runtime",
+    agentId: "agent",
+    poolId: "pool",
+    ownerId: "owner",
+    image: "worker:test",
+    env: {},
+    labels: {},
+    cache: { key: "swarm-cache-pool", mountPath: "/cache" },
+  };
+  expect(
+    ControllerCommandSchema.parse({ type: "cmd", id: "command", op: "provision", payload }),
+  ).toMatchObject({ payload: { cache: payload.cache } });
+});

package/src/tests/model-tier-resolution.test.ts

@@ -674,8 +674,8 @@ describe("previewModelTiers", () => {
 
     // acp has no portable tier mapping, so it has nothing to preview.
     expect(rows.some((r) => r.provider === "acp")).toBe(false);
-    expect(new Set(rows.map((r) => r.provider)).size).toBe(10);
-    expect(rows).toHaveLength(40);
+    expect(new Set(rows.map((r) => r.provider)).size).toBe(11);
+    expect(rows).toHaveLength(44);
   });
 
   test("an alias that resolves to nothing reports the default it falls back to", async () => {
@@ -730,7 +730,7 @@ describe("GET /api/models-catalog/tiers", () => {
     expect(handled).toBe(true);
     expect(status).toBe(200);
     const body = JSON.parse(bodyStr) as { tiers: { provider: string; tier: string }[] };
-    expect(body.tiers).toHaveLength(40);
+    expect(body.tiers).toHaveLength(44);
     expect(body.tiers.find((t) => t.provider === "claude" && t.tier === "smart")).toMatchObject({
       key: "MODEL_TIER_CLAUDE_SMART",
       source: "tier-config",

package/src/tests/pricing-refresh.test.ts

@@ -102,14 +102,14 @@ describe("models.dev runtime pricing refresh", () => {
        VALUES ('codex', 'gpt-refresh-test', 'input', 0, 1, 0, 0)`,
     );
 
-    // codex, pi, cursor and amp each project the OpenAI rows: 4 providers x 2 token classes.
+    // codex, pi, cursor, amp and fx each project the OpenAI rows: 5 providers x 2 token classes.
     const first = await refreshPricingFromModelsDev({
       now: 1_000,
       fetchImpl: async () => responseFor(openAiCache(2, 8), '"etag-1"'),
     });
     expect(first.status).toBe("refreshed");
-    expect(first.candidateRows).toBe(8);
-    expect(first.inserted).toBe(8);
+    expect(first.candidateRows).toBe(10);
+    expect(first.inserted).toBe(10);
     expect(first.unchanged).toBe(0);
 
     const activeChanged = await getActivePricingRow("codex", "gpt-refresh-test", "input", 1_000);
@@ -121,7 +121,7 @@ describe("models.dev runtime pricing refresh", () => {
       fetchImpl: async () => responseFor(openAiCache(2, 8), '"etag-2"'),
     });
     expect(second.inserted).toBe(0);
-    expect(second.unchanged).toBe(8);
+    expect(second.unchanged).toBe(10);
 
     const rows = await getDbClient().query<{ effective_from: number }>(
       `SELECT effective_from FROM pricing
@@ -278,7 +278,7 @@ describe("models.dev runtime pricing refresh", () => {
 
     const logs = await getLogsByEventType("pricing.refresh");
     expect(logs).toHaveLength(1);
-    expect(logs[0]?.newValue).toContain("inserted=8");
+    expect(logs[0]?.newValue).toContain("inserted=10");
     expect(logs[0]?.metadata).toContain('"etag":"\\"etag-log\\""');
   });
 });

package/src/tests/prompt-template-session.test.ts

@@ -24,6 +24,7 @@ const SYSTEM_TEMPLATES = [
   "system.agent.compaction.goal_reminder",
   "system.agent.context.bound_note",
   "system.agent.cursor.first_message",
+  "system.agent.fx.system_prompt_file",
   "system.agent.lead",
   "system.agent.lead.docs",
   "system.agent.memory",
@@ -42,6 +43,7 @@ const SYSTEM_TEMPLATES = [
   "system.agent.tool_discovery.search",
   "system.agent.tool_discovery.amp",
   "system.agent.tool_discovery.codex",
+  "system.agent.tool_discovery.fx",
   "system.agent.tool_discovery.opencode",
   "system.agent.tool_discovery.direct",
   "system.agent.tools_skills",
@@ -121,11 +123,11 @@ describe("Session templates: registration", () => {
     expect(sessionSystemEventTypes("session")).toEqual([...SESSION_TEMPLATES].sort());
   });
 
-  test("registers 35 system and session templates in total", () => {
+  test("registers 37 system and session templates in total", () => {
     const all = getAllTemplateDefinitions();
     const sessionSystem = all.filter((d) => d.category === "system" || d.category === "session");
-    // 30 system blocks + 5 session composites.
-    expect(sessionSystem.length).toBe(35);
+    // 32 system blocks + 5 session composites.
+    expect(sessionSystem.length).toBe(37);
   });
 
   test("drops the v1 blocks that prompt v2 deleted", () => {

package/src/tests/provider-registration.test.ts

@@ -235,6 +235,7 @@ const BOOTSTRAP: Record<ProviderName, { expect: string } | { exempt: string }> =
   amp: { expect: "Warning: amp provider has no credentials yet" },
   cursor: { expect: "Warning: cursor provider has no credentials yet" },
   grok: { expect: "Warning: grok provider has no credentials yet" },
+  fx: { expect: "Warning: fx provider has no credentials yet" },
   pi: { expect: "Warning: pi provider has no credentials yet" },
   opencode: { expect: "Warning: opencode provider has no credentials yet" },
   "claude-managed": { expect: "Warning: claude-managed provider missing:" },
@@ -284,7 +285,7 @@ function extractMarkedBlock(name: string): string {
 /** Resolvable no-op stubs for every binary the verify chain may look up. */
 function makeBinaryStubDir(): string {
   const dir = mkdtempSync(join(tmpdir(), "provider-registration-bin-"));
-  for (const name of ["claude", "codex", "opencode", "dsh", "amp", "grok"]) {
+  for (const name of ["claude", "codex", "opencode", "dsh", "amp", "grok", "fx"]) {
     const file = join(dir, name);
     writeFileSync(file, "#!/bin/sh\nexit 0\n");
     chmodSync(file, 0o755);