@simonepri/refined-antigravity-acp 0.1.0

package/server/history.test.ts

@@ -0,0 +1,139 @@
+import { describe, expect, it } from "vitest";
+import { extractUserMessage, readConversationHistory } from "./history.js";
+import { formatSystemContext } from "./sanitize.js";
+import { DatabaseSync } from "node:sqlite";
+import { unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+describe("readConversationHistory", () => {
+  it("returns empty array for non-existent session", () => {
+    const history = readConversationHistory("non-existent-session-id");
+    expect(history).toEqual([]);
+  });
+
+  it("can read existing session if available", () => {
+    const history = readConversationHistory("bb2bf99a-ec9e-4d4a-9924-6aec7b7291cf");
+    if (history.length > 0) {
+      expect(history[0].item.type).toBe("user_message");
+      if (history[0].item.type === "user_message") {
+        expect(history[0].item.text).toContain("We are building");
+      }
+    }
+  });
+  it("sanitizes assistant messages and does not leak task_notification", () => {
+    const history = readConversationHistory("528dc461-72a0-4c97-a5d5-d24b66eb6d6c");
+    for (const entry of history) {
+      if (entry.item.type === "assistant_message") {
+        expect(entry.item.text).not.toContain("<task_notification>");
+        expect(entry.item.text).not.toContain("</task_notification>");
+      }
+    }
+  });
+});
+
+function encodeVarint(val: number): Buffer {
+  const bytes: number[] = [];
+  let v = val;
+  while (v >= 0x80) {
+    bytes.push((v & 0x7f) | 0x80);
+    v >>>= 7;
+  }
+  bytes.push(v);
+  return Buffer.from(bytes);
+}
+
+function encodeLengthDelimited(fieldNum: number, data: Uint8Array): Buffer {
+  const tag = (fieldNum << 3) | 2;
+  return Buffer.concat([encodeVarint(tag), encodeVarint(data.length), Buffer.from(data)]);
+}
+
+function makeUserPayload(text: string): Uint8Array {
+  const f2 = encodeLengthDelimited(2, Buffer.from(text, "utf-8"));
+  const f19 = encodeLengthDelimited(19, f2);
+  return new Uint8Array(f19);
+}
+
+describe("user message replay system context stripping", () => {
+  it("extractUserMessage strips injected system context and formatting guidance", () => {
+    const raw = `${formatSystemContext("Act as an SRE.")}\n\nInspect deployment health`;
+    const payload = makeUserPayload(raw);
+    const item = extractUserMessage(payload, 1);
+    expect(item).not.toBeNull();
+    expect(item?.type).toBe("user_message");
+    expect((item as { text: string }).text).toBe("Inspect deployment health");
+    expect((item as { text: string }).text).not.toContain("[System Context]");
+    expect((item as { text: string }).text).not.toContain("[Formatting Guidance]");
+  });
+
+  it("extractUserMessage strips formatting guidance when no system prompt was present", () => {
+    const raw = `${formatSystemContext(undefined)}\n\nShow me the pods`;
+    const payload = makeUserPayload(raw);
+    const item = extractUserMessage(payload, 2);
+    expect(item).not.toBeNull();
+    expect((item as { text: string }).text).toBe("Show me the pods");
+    expect((item as { text: string }).text).not.toContain("[Formatting Guidance]");
+  });
+
+  it("readConversationHistory strips injected system context on SQLite replay", () => {
+    const tempDbPath = join(
+      tmpdir(),
+      `test-history-${Date.now()}-${Math.random().toString(36).slice(2)}.db`,
+    );
+    try {
+      const db = new DatabaseSync(tempDbPath);
+      db.exec(
+        "CREATE TABLE steps (idx INTEGER PRIMARY KEY, step_type INTEGER, step_payload BLOB);",
+      );
+      const stmt = db.prepare("INSERT INTO steps (idx, step_type, step_payload) VALUES (?, ?, ?)");
+
+      const raw = `${formatSystemContext("Act as an SRE.")}\n\nInspect deployment health`;
+      stmt.run(1, 14, makeUserPayload(raw));
+      db.close();
+
+      const events = readConversationHistory("test-session", tempDbPath);
+      expect(events).toHaveLength(1);
+      expect(events[0].item.type).toBe("user_message");
+      expect((events[0].item as { text: string }).text).toBe("Inspect deployment health");
+      expect((events[0].item as { text: string }).text).not.toContain("[System Context]");
+      expect((events[0].item as { text: string }).text).not.toContain("[Formatting Guidance]");
+    } finally {
+      try {
+        unlinkSync(tempDbPath);
+      } catch {
+        // ignore
+      }
+    }
+  });
+
+  it("readConversationHistory strips both mid-turn steering prefix and injected system context", () => {
+    const tempDbPath = join(
+      tmpdir(),
+      `test-history-${Date.now()}-${Math.random().toString(36).slice(2)}.db`,
+    );
+    try {
+      const db = new DatabaseSync(tempDbPath);
+      db.exec(
+        "CREATE TABLE steps (idx INTEGER PRIMARY KEY, step_type INTEGER, step_payload BLOB);",
+      );
+      const stmt = db.prepare("INSERT INTO steps (idx, step_type, step_payload) VALUES (?, ?, ?)");
+
+      const raw = `[Mid-turn update]: ${formatSystemContext("Act as an SRE.")}\n\nUpdate: stop and check logs`;
+      stmt.run(1, 14, makeUserPayload(raw));
+      db.close();
+
+      const events = readConversationHistory("test-session", tempDbPath);
+      expect(events).toHaveLength(1);
+      expect(events[0].item.type).toBe("user_message");
+      expect((events[0].item as { text: string }).text).toBe("Update: stop and check logs");
+      expect((events[0].item as { text: string }).text).not.toContain("[Mid-turn update]");
+      expect((events[0].item as { text: string }).text).not.toContain("[System Context]");
+    } finally {
+      try {
+        unlinkSync(tempDbPath);
+      } catch {
+        // ignore
+      }
+    }
+  });
+});

package/server/history.ts

@@ -0,0 +1,157 @@
+import { sanitizeAssistantText, stripSteeringPrefix, stripSystemContext } from "./sanitize.js";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import type { ProviderTimelineItem } from "@getpaseo/plugin/server/provider";
+
+export interface ReplayedTimelineEvent {
+  readonly item: ProviderTimelineItem;
+  readonly timestamp?: string;
+}
+
+interface StepRow {
+  readonly idx: number;
+  readonly step_type: number;
+  readonly step_payload: Uint8Array | null;
+}
+
+function decodeVarint(buffer: Uint8Array, start: number): [number, number] {
+  let res = 0;
+  let shift = 0;
+  let offset = start;
+  while (offset < buffer.length) {
+    const b = buffer[offset++];
+    res |= (b & 0x7f) << shift;
+    shift += 7;
+    if (!(b & 0x80)) break;
+  }
+  return [res, offset];
+}
+
+function getField(buffer: Uint8Array, targetField: number): Uint8Array | null {
+  let offset = 0;
+  while (offset < buffer.length) {
+    let tag = 0;
+    let nextOffset = 0;
+    try {
+      [tag, nextOffset] = decodeVarint(buffer, offset);
+    } catch {
+      break;
+    }
+    offset = nextOffset;
+    const fieldNum = tag >> 3;
+    const wireType = tag & 0x7;
+    if (wireType === 2) {
+      const [len, afterLen] = decodeVarint(buffer, offset);
+      offset = afterLen;
+      const slice = buffer.subarray(offset, offset + len);
+      offset += len;
+      if (fieldNum === targetField) return slice;
+    } else if (wireType === 0) {
+      const [, afterVal] = decodeVarint(buffer, offset);
+      offset = afterVal;
+    } else if (wireType === 1) {
+      offset += 8;
+    } else if (wireType === 5) {
+      offset += 4;
+    } else {
+      break;
+    }
+  }
+  return null;
+}
+
+function extractTimestamp(payload: Uint8Array): string | undefined {
+  const f5 = getField(payload, 5);
+  if (!f5) return undefined;
+  const f1 = getField(f5, 1);
+  if (!f1) return undefined;
+  let offset = 0;
+  let seconds = 0;
+  let nanos = 0;
+  while (offset < f1.length) {
+    const [tag, nextOffset] = decodeVarint(f1, offset);
+    offset = nextOffset;
+    const fieldNum = tag >> 3;
+    const [val, afterVal] = decodeVarint(f1, offset);
+    offset = afterVal;
+    if (fieldNum === 1) seconds = val;
+    else if (fieldNum === 2) nanos = val;
+  }
+  if (!seconds) return undefined;
+  return new Date(seconds * 1000 + Math.floor(nanos / 1_000_000)).toISOString();
+}
+
+export function extractUserMessage(payload: Uint8Array, idx: number): ProviderTimelineItem | null {
+  const f19 = getField(payload, 19);
+  if (!f19) return null;
+  const textBytes = getField(f19, 2);
+  if (!textBytes || textBytes.length === 0) return null;
+  // Steered turns are persisted with the mid-turn marker baked into the user message,
+  // so replay has to strip it back out before the text reaches the Paseo timeline.
+  const rawText = Buffer.from(textBytes).toString("utf-8");
+  const text = stripSystemContext(stripSteeringPrefix(rawText)).trim();
+  if (!text) return null;
+  return { id: `hist-user-${idx}`, type: "user_message", text };
+}
+
+function extractAssistantMessage(payload: Uint8Array, idx: number): ProviderTimelineItem | null {
+  const f20 = getField(payload, 20);
+  if (!f20) return null;
+  const textBytes = getField(f20, 1);
+  if (!textBytes || textBytes.length === 0) return null;
+  const rawText = Buffer.from(textBytes).toString("utf-8");
+  const text = sanitizeAssistantText(rawText);
+  if (!text) return null;
+  return { id: `hist-asst-${idx}`, type: "assistant_message", text };
+}
+
+function extractTimelineItem(
+  stepType: number,
+  payload: Uint8Array,
+  idx: number,
+): ProviderTimelineItem | null {
+  if (stepType === 14) return extractUserMessage(payload, idx);
+  if (stepType === 15) return extractAssistantMessage(payload, idx);
+  return null;
+}
+
+/**
+ * Reads and replays historic conversation events from Antigravity SQLite DB.
+ * Database is located at ~/.gemini/antigravity-acp/conversations/<sessionId>.db.
+ */
+export function readConversationHistory(
+  sessionId: string,
+  customDbPath?: string,
+): ReplayedTimelineEvent[] {
+  const dbPath =
+    customDbPath ??
+    join(homedir(), ".gemini", "antigravity-acp", "conversations", `${sessionId}.db`);
+  if (!existsSync(dbPath)) return [];
+
+  let db: DatabaseSync | null = null;
+  try {
+    db = new DatabaseSync(dbPath, { readOnly: true });
+    const stmt = db.prepare(
+      "SELECT idx, step_type, step_payload FROM steps WHERE step_type IN (14, 15) ORDER BY idx ASC;",
+    );
+    const rows = stmt.all() as unknown as StepRow[];
+    const events: ReplayedTimelineEvent[] = [];
+
+    for (const row of rows) {
+      if (!row.step_payload) continue;
+      const payload = new Uint8Array(row.step_payload);
+      const item = extractTimelineItem(row.step_type, payload, row.idx);
+      if (!item) continue;
+      const timestamp = extractTimestamp(payload);
+      events.push({ item, timestamp });
+    }
+    return events;
+  } catch (err) {
+    console.error(`[paseo-antigravity] Failed to read conversation history for ${sessionId}:`, err);
+    return [];
+  } finally {
+    db?.close();
+  }
+}

package/server/mcp-proxy.test.ts

@@ -0,0 +1,368 @@
+import fs from "node:fs";
+import http from "node:http";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { McpProxy, McpProxyPool } from "./mcp-proxy.js";
+
+interface Received {
+  method: string;
+  url: string;
+  protocolVersion?: string;
+  authorization?: string;
+  accept?: string;
+  contentType?: string;
+  body: string;
+}
+
+describe("McpProxy", () => {
+  const started: Array<McpProxy | McpProxyPool> = [];
+  let upstream: http.Server | null = null;
+  const received: Received[] = [];
+  const tempFiles: string[] = [];
+
+  afterEach(async () => {
+    for (const s of started.splice(0)) {
+      await (s instanceof McpProxy ? s.stop() : s.stopAll());
+    }
+    if (upstream) {
+      await new Promise<void>((resolve) => upstream!.close(() => resolve()));
+      upstream = null;
+    }
+    received.length = 0;
+    for (const f of tempFiles.splice(0)) fs.rmSync(f, { force: true });
+  });
+
+  async function startUpstream(
+    handler?: (req: http.IncomingMessage, res: http.ServerResponse, body: string) => boolean | void,
+  ): Promise<string> {
+    upstream = http.createServer((req, res) => {
+      let body = "";
+      req.on("data", (chunk) => (body += chunk.toString()));
+      req.on("end", () => {
+        received.push({
+          method: req.method ?? "",
+          url: req.url ?? "",
+          protocolVersion: req.headers["mcp-protocol-version"] as string | undefined,
+          authorization: req.headers.authorization as string | undefined,
+          accept: req.headers.accept as string | undefined,
+          contentType: req.headers["content-type"] as string | undefined,
+          body,
+        });
+        if (handler && handler(req, res, body)) return;
+        // Mirror Paseo: only the MCP endpoint exists, everything else is a 404.
+        if (!req.url?.startsWith("/mcp/agents")) {
+          res.writeHead(404);
+          res.end("not found");
+          return;
+        }
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ status: "ok" }));
+      });
+    });
+    const port = await new Promise<number>((resolve) => {
+      upstream!.listen(0, "127.0.0.1", () => {
+        resolve((upstream!.address() as { port: number }).port);
+      });
+    });
+    return `http://127.0.0.1:${port}`;
+  }
+
+  function track<T extends McpProxy | McpProxyPool>(value: T): T {
+    started.push(value);
+    return value;
+  }
+
+  it("starts and assigns a port", async () => {
+    const proxy = track(new McpProxy("http://127.0.0.1:6767", { portFile: null }));
+    const port = await proxy.start();
+    expect(port).toBeGreaterThan(0);
+    expect(proxy.getPort()).toBe(port);
+  });
+
+  it("downgrades an unsupported protocol version and preserves path, query and body", async () => {
+    const origin = await startUpstream();
+    const proxy = track(new McpProxy(origin, { portFile: null }));
+    await proxy.start();
+
+    const response = await fetch(proxy.rewriteUrl(`${origin}/mcp/agents?callerAgentId=abc123`), {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: "Bearer token",
+        "mcp-protocol-version": "2026-07-28",
+      },
+      body: JSON.stringify({ hello: "world" }),
+    });
+
+    expect(response.status).toBe(200);
+    expect(received).toHaveLength(1);
+    expect(received[0].protocolVersion).toBe("2025-11-25");
+    expect(received[0].url).toBe("/mcp/agents?callerAgentId=abc123");
+    expect(received[0].authorization).toBe("Bearer token");
+    expect(received[0].body).toBe(JSON.stringify({ hello: "world" }));
+  });
+
+  it("leaves a supported protocol version untouched", async () => {
+    const origin = await startUpstream();
+    const proxy = track(new McpProxy(origin, { portFile: null }));
+    await proxy.start();
+
+    await fetch(proxy.rewriteUrl(`${origin}/mcp/agents`), {
+      headers: { "mcp-protocol-version": "2024-11-05" },
+    });
+
+    expect(received[0].protocolVersion).toBe("2024-11-05");
+  });
+
+  it("forwards unrelated paths to the upstream path rather than the MCP endpoint", async () => {
+    // agy probes OAuth discovery before using an MCP server. Collapsing that onto the
+    // MCP endpoint would answer 200 where the client must see a 404 to conclude that
+    // the resource is not OAuth-protected.
+    const origin = await startUpstream();
+    const proxy = track(new McpProxy(origin, { portFile: null }));
+    const port = await proxy.start();
+
+    const response = await fetch(
+      `http://127.0.0.1:${port}/.well-known/oauth-protected-resource/mcp/agents`,
+    );
+
+    expect(response.status).toBe(404);
+    expect(received[0].url).toBe("/.well-known/oauth-protected-resource/mcp/agents");
+  });
+
+  it("absorbs upstream 4xx on notification (no id) and responds with 202, logging method and status", async () => {
+    const spy = vi.spyOn(console, "error").mockImplementation(() => {});
+    try {
+      const origin = await startUpstream((_req, res) => {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            error: { code: -32600, message: "Bad Request" },
+            id: null,
+          }),
+        );
+        return true;
+      });
+      const proxy = track(new McpProxy(origin, { portFile: null }));
+      await proxy.start();
+
+      const notificationPayload = {
+        jsonrpc: "2.0",
+        method: "notifications/cancelled",
+      };
+
+      const response = await fetch(proxy.rewriteUrl(`${origin}/mcp/agents`), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(notificationPayload),
+      });
+
+      expect(response.status).toBe(202);
+      expect(await response.text()).toBe("");
+      expect(received).toHaveLength(1);
+      expect(JSON.parse(received[0].body)).toEqual(notificationPayload);
+      expect(spy).toHaveBeenCalledWith(
+        '[paseo-antigravity][mcp-proxy] Absorbed upstream 400 on notification "notifications/cancelled"; replied 202 so go-sdk does not tear the session down',
+      );
+    } finally {
+      spy.mockRestore();
+    }
+  });
+
+  it("absorbs upstream 4xx on non-cancelled notification and logs investigation warning", async () => {
+    const spy = vi.spyOn(console, "error").mockImplementation(() => {});
+    try {
+      const origin = await startUpstream((_req, res) => {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            error: { code: -32600, message: "Bad Request" },
+            id: null,
+          }),
+        );
+        return true;
+      });
+      const proxy = track(new McpProxy(origin, { portFile: null }));
+      await proxy.start();
+
+      const notificationPayload = {
+        jsonrpc: "2.0",
+        method: "notifications/initialized",
+      };
+
+      const response = await fetch(proxy.rewriteUrl(`${origin}/mcp/agents`), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(notificationPayload),
+      });
+
+      expect(response.status).toBe(202);
+      expect(await response.text()).toBe("");
+      expect(received).toHaveLength(1);
+      expect(JSON.parse(received[0].body)).toEqual(notificationPayload);
+      expect(spy).toHaveBeenCalledWith(
+        '[paseo-antigravity][mcp-proxy] Absorbed upstream 400 on notification "notifications/initialized"; replied 202 so go-sdk does not tear the session down (indicates proxy normalization bug; investigate)',
+      );
+    } finally {
+      spy.mockRestore();
+    }
+  });
+
+  it("passes through upstream 4xx unchanged on call (with id)", async () => {
+    const upstreamErrorBody = {
+      jsonrpc: "2.0",
+      id: 42,
+      error: { code: -32602, message: "Invalid params" },
+    };
+    const origin = await startUpstream((_req, res) => {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(upstreamErrorBody));
+      return true;
+    });
+    const proxy = track(new McpProxy(origin, { portFile: null }));
+    await proxy.start();
+
+    const callPayload = {
+      jsonrpc: "2.0",
+      id: 42,
+      method: "tools/call",
+      params: { name: "test_tool" },
+    };
+
+    const response = await fetch(proxy.rewriteUrl(`${origin}/mcp/agents`), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(callPayload),
+    });
+
+    expect(response.status).toBe(400);
+    expect(await response.json()).toEqual(upstreamErrorBody);
+    expect(received).toHaveLength(1);
+    expect(JSON.parse(received[0].body)).toEqual(callPayload);
+  });
+
+  it("injects Accept header when missing or incomplete and sets Content-Type for request body", async () => {
+    const origin = await startUpstream();
+    const proxy = track(new McpProxy(origin, { portFile: null }));
+    await proxy.start();
+
+    // 1. Missing Accept header and missing Content-Type with body
+    await fetch(proxy.rewriteUrl(`${origin}/mcp/agents`), {
+      method: "POST",
+      body: Buffer.from(JSON.stringify({ ping: 1 })),
+    });
+    expect(received[0].accept).toBe("application/json, text/event-stream");
+    expect(received[0].contentType).toBe("application/json");
+
+    // 2. Incomplete Accept header (only application/json)
+    await fetch(proxy.rewriteUrl(`${origin}/mcp/agents`), {
+      method: "POST",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ ping: 2 }),
+    });
+    expect(received[1].accept).toBe("application/json, text/event-stream");
+
+    // 3. Incomplete Accept header (only text/event-stream)
+    await fetch(proxy.rewriteUrl(`${origin}/mcp/agents`), {
+      method: "POST",
+      headers: {
+        Accept: "text/event-stream",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ ping: 3 }),
+    });
+    expect(received[2].accept).toBe("application/json, text/event-stream");
+
+    // 4. Complete Accept header containing both is preserved
+    await fetch(proxy.rewriteUrl(`${origin}/mcp/agents`), {
+      method: "POST",
+      headers: {
+        Accept: "text/event-stream, application/json",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ ping: 4 }),
+    });
+    expect(received[3].accept).toBe("text/event-stream, application/json");
+  });
+
+  it("formats proxy connection errors as JSON-RPC error body with application/json", async () => {
+    const deadServer = http.createServer();
+    await new Promise<void>((resolve) => deadServer.listen(0, "127.0.0.1", () => resolve()));
+    const deadPort = (deadServer.address() as { port: number }).port;
+    await new Promise<void>((resolve) => deadServer.close(() => resolve()));
+
+    const deadOrigin = `http://127.0.0.1:${deadPort}`;
+    const proxy = track(new McpProxy(deadOrigin, { portFile: null }));
+    await proxy.start();
+
+    const response = await fetch(proxy.rewriteUrl(`${deadOrigin}/mcp/agents`));
+
+    expect(response.status).toBe(502);
+    expect(response.headers.get("content-type")).toContain("application/json");
+    const json = await response.json();
+    expect(json).toEqual({
+      jsonrpc: "2.0",
+      error: {
+        code: -32603,
+        message: expect.stringContaining("MCP proxy error:"),
+      },
+      id: null,
+    });
+  });
+
+  it("throws instead of returning an un-normalized URL when not running", async () => {
+    const proxy = track(new McpProxy("http://127.0.0.1:6767", { portFile: null }));
+    const original = "http://127.0.0.1:6767/mcp/agents?callerAgentId=a1";
+
+    expect(() => proxy.rewriteUrl(original)).toThrow(/not running/);
+
+    await proxy.start();
+    expect(proxy.rewriteUrl(original)).not.toBe(original);
+
+    await proxy.stop();
+    expect(() => proxy.rewriteUrl(original)).toThrow(/not running/);
+  });
+
+  it("reuses the port remembered from a previous run", async () => {
+    const portFile = path.join(
+      fs.mkdtempSync(path.join(os.tmpdir(), "paseo-agy-proxy-")),
+      "ports.json",
+    );
+    tempFiles.push(portFile);
+
+    const first = track(new McpProxy("http://127.0.0.1:6767", { portFile }));
+    const port = await first.start();
+    await first.stop();
+
+    const second = track(new McpProxy("http://127.0.0.1:6767", { portFile }));
+    expect(await second.start()).toBe(port);
+  });
+});
+
+describe("McpProxyPool", () => {
+  const pools: McpProxyPool[] = [];
+
+  afterEach(async () => {
+    for (const pool of pools.splice(0)) await pool.stopAll();
+  });
+
+  it("shares one proxy per upstream origin", async () => {
+    const pool = new McpProxyPool({ portFile: null });
+    pools.push(pool);
+
+    const a = await pool.rewriteUrl("http://127.0.0.1:6767/mcp/agents?callerAgentId=a");
+    const b = await pool.rewriteUrl("http://127.0.0.1:6767/mcp/agents?callerAgentId=b");
+    const other = await pool.rewriteUrl("http://127.0.0.1:6868/mcp/agents");
+
+    expect(new URL(a).port).toBe(new URL(b).port);
+    expect(new URL(a).port).not.toBe(new URL(other).port);
+    expect(new URL(a).pathname + new URL(a).search).toBe("/mcp/agents?callerAgentId=a");
+    expect(new URL(b).pathname + new URL(b).search).toBe("/mcp/agents?callerAgentId=b");
+  });
+});