@desplega.ai/agent-swarm 1.173.0 → 2.1.0

package/src/tests/opencode-helmcode-sdk.test.ts

@@ -0,0 +1,201 @@
+/**
+ * The provider key splice and the `helmcode` block, run through the real
+ * `@opencode/sdk` embedded host against a fake OpenAI-compatible server.
+ *
+ * `applyProviderKeySplice` builds the provider entry; the test only repoints
+ * `options.baseURL` at a local `Bun.serve({ port: 0 })` that answers
+ * `/v1/chat/completions`, then checks the request OpenCode sent: the picked
+ * pool member as the bearer (not the comma pool sitting in `process.env`) and
+ * the bare model id. The model catalog is bundled in the SDK, and no request
+ * leaves the machine. The control test pins why `env: []` is needed: without
+ * it, the pool in `process.env` beats `options.apiKey`.
+ */
+
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { OpenCode, type OpenCodeEvent } from "@opencode/sdk";
+import { applyProviderKeySplice, type OpencodeConfig } from "../providers/opencode-adapter";
+
+const TEST_TIMEOUT_MS = 60_000;
+
+const PICKED = "sk-helmcode-picked-live-0123456789";
+const POOL_IN_PROCESS_ENV = "sk-helmcode-wrong-aaaaaaaaaa,sk-helmcode-wrong-bbbbbbbbbb";
+
+type SeenRequest = { path: string; authorization: string | null; model?: string };
+
+let server: ReturnType<typeof Bun.serve>;
+let directory: string;
+const seen: SeenRequest[] = [];
+let prevHelmcodeKey: string | undefined;
+
+/** One streamed (or plain) assistant turn that says "pong". */
+function completion(model: string, stream: boolean): Response {
+  const base = { id: "chatcmpl-test", created: 0, model };
+  const usage = { prompt_tokens: 5, completion_tokens: 1, total_tokens: 6 };
+  if (!stream) {
+    return Response.json({
+      ...base,
+      object: "chat.completion",
+      choices: [
+        {
+          index: 0,
+          message: { role: "assistant", content: "pong" },
+          finish_reason: "stop",
+        },
+      ],
+      usage,
+    });
+  }
+  const chunk = (body: Record<string, unknown>) =>
+    `data: ${JSON.stringify({ ...base, object: "chat.completion.chunk", ...body })}\n\n`;
+  const sse =
+    chunk({
+      choices: [{ index: 0, delta: { role: "assistant", content: "pong" }, finish_reason: null }],
+    }) +
+    chunk({ choices: [{ index: 0, delta: {}, finish_reason: "stop" }], usage }) +
+    "data: [DONE]\n\n";
+  return new Response(sse, { headers: { "content-type": "text/event-stream" } });
+}
+
+beforeAll(() => {
+  directory = mkdtempSync(join(tmpdir(), "opencode-helmcode-sdk-"));
+  server = Bun.serve({
+    port: 0,
+    async fetch(req) {
+      const url = new URL(req.url);
+      const body = req.method === "POST" ? ((await req.json().catch(() => ({}))) as any) : {};
+      seen.push({
+        path: url.pathname,
+        authorization: req.headers.get("authorization"),
+        model: body?.model,
+      });
+      if (url.pathname.endsWith("/chat/completions")) {
+        return completion(String(body?.model ?? ""), body?.stream === true);
+      }
+      return new Response("not found", { status: 404 });
+    },
+  });
+  // The pool a production entrypoint exports raw; the splice must beat it.
+  prevHelmcodeKey = process.env.HELMCODE_API_KEY;
+  process.env.HELMCODE_API_KEY = POOL_IN_PROCESS_ENV;
+});
+
+afterAll(() => {
+  server.stop(true);
+  rmSync(directory, { recursive: true, force: true });
+  if (prevHelmcodeKey === undefined) delete process.env.HELMCODE_API_KEY;
+  else process.env.HELMCODE_API_KEY = prevHelmcodeKey;
+});
+
+async function runOnePrompt(config: OpencodeConfig): Promise<string> {
+  const host = await OpenCode.create({
+    config: { content: JSON.stringify(config) },
+    plugins: [],
+    log: { level: "error", emit: () => {} },
+  });
+  try {
+    const session = await host.sessions.create({ location: { directory } });
+    const done = (async () => {
+      for await (const event of host.events.subscribe() as AsyncIterable<OpenCodeEvent>) {
+        const data = (event as { data?: { sessionID?: string; error?: unknown } }).data;
+        if (data?.sessionID !== session.id) continue;
+        if (event.type === "session.execution.succeeded") return "succeeded";
+        if (event.type === "session.execution.failed") {
+          return `failed: ${JSON.stringify(data.error)}`;
+        }
+      }
+      return "stream ended";
+    })();
+    await host.sessions.prompt({ sessionID: session.id, text: "say pong", delivery: "queue" });
+    return await done;
+  } finally {
+    await host.close();
+  }
+}
+
+describe("provider key splice through the real OpenCode host", () => {
+  test(
+    "sends the picked key and the bare model id to the provider's baseURL",
+    async () => {
+      seen.length = 0;
+      const model = "helmcode/glm5.3";
+      const config: OpencodeConfig = { model };
+      const spliced = applyProviderKeySplice(config, model, { HELMCODE_API_KEY: PICKED });
+      expect(spliced?.name).toBe("HELMCODE_API_KEY");
+      const helmcode = config.provider?.helmcode;
+      if (!helmcode?.options) throw new Error("helmcode block missing");
+      helmcode.options.baseURL = `http://127.0.0.1:${server.port}/v1`;
+
+      const outcome = await runOnePrompt(config);
+
+      const chats = seen.filter((r) => r.path === "/v1/chat/completions");
+      expect(chats.length).toBeGreaterThan(0);
+      for (const chat of chats) {
+        expect(chat.authorization).toBe(`Bearer ${PICKED}`);
+        expect(chat.model).toBe("glm5.3");
+      }
+      expect(outcome).toBe("succeeded");
+    },
+    TEST_TIMEOUT_MS,
+  );
+
+  test(
+    "nan (built-in provider): env [] plus the picked key beats a pool in process.env",
+    async () => {
+      const prevNan = process.env.NAN_API_KEY;
+      process.env.NAN_API_KEY = POOL_IN_PROCESS_ENV;
+      seen.length = 0;
+      try {
+        const model = "nan/glm5.3-flash";
+        const config: OpencodeConfig = { model };
+        const spliced = applyProviderKeySplice(config, model, { NAN_API_KEY: PICKED });
+        expect(spliced?.name).toBe("NAN_API_KEY");
+        const nan = config.provider?.nan;
+        if (!nan?.options) throw new Error("nan block missing");
+        nan.options.baseURL = `http://127.0.0.1:${server.port}/v1`;
+
+        const outcome = await runOnePrompt(config);
+
+        const chats = seen.filter((r) => r.path === "/v1/chat/completions");
+        expect(chats.length).toBeGreaterThan(0);
+        for (const chat of chats) {
+          expect(chat.authorization).toBe(`Bearer ${PICKED}`);
+          expect(chat.model).toBe("glm5.3-flash");
+        }
+        expect(outcome).toBe("succeeded");
+      } finally {
+        if (prevNan === undefined) delete process.env.NAN_API_KEY;
+        else process.env.NAN_API_KEY = prevNan;
+      }
+    },
+    TEST_TIMEOUT_MS,
+  );
+
+  test(
+    "nan control: without the splice the pool in process.env reaches the provider",
+    async () => {
+      const prevNan = process.env.NAN_API_KEY;
+      process.env.NAN_API_KEY = POOL_IN_PROCESS_ENV;
+      seen.length = 0;
+      try {
+        const model = "nan/glm5.3-flash";
+        const config: OpencodeConfig = {
+          model,
+          provider: {
+            nan: { options: { apiKey: PICKED, baseURL: `http://127.0.0.1:${server.port}/v1` } },
+          },
+        };
+        await runOnePrompt(config);
+        const chats = seen.filter((r) => r.path === "/v1/chat/completions");
+        expect(chats.length).toBeGreaterThan(0);
+        expect(chats[0]?.authorization).not.toBe(`Bearer ${PICKED}`);
+      } finally {
+        if (prevNan === undefined) delete process.env.NAN_API_KEY;
+        else process.env.NAN_API_KEY = prevNan;
+      }
+    },
+    TEST_TIMEOUT_MS,
+  );
+});

package/src/tests/opencode-shell-env.test.ts

@@ -0,0 +1,145 @@
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  spyOn,
+  test,
+} from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { OpenCode } from "@opencode/sdk";
+import { fetchResolvedEnv } from "../commands/runner";
+import { createOpencodeSwarmPlugin } from "../providers/opencode-swarm-plugin";
+
+/**
+ * OpenCode runs in-process, so its shell tool would spawn with the worker's
+ * process.env. The swarm plugin swaps in the env the runner resolved for the
+ * task: a row admitted after boot (exportToEnv flipped on) must reach the
+ * shell, and a row revoked after boot (flipped off) must leave it, even though
+ * process.env still holds the boot value.
+ */
+
+type ConfigRow = { key: string; value: string; isSecret: boolean; exportToEnv: boolean };
+
+const SHELL_TIMEOUT_MS = 15_000;
+
+let server: ReturnType<typeof Bun.serve>;
+let apiUrl = "";
+let rows: ConfigRow[] = [];
+let directory = "";
+
+beforeAll(() => {
+  server = Bun.serve({
+    port: 0,
+    fetch: () => Response.json({ configs: rows }),
+  });
+  apiUrl = `http://localhost:${server.port}`;
+  directory = mkdtempSync(join(tmpdir(), "opencode-shell-env-"));
+});
+
+afterAll(() => {
+  server.stop(true);
+  rmSync(directory, { recursive: true, force: true });
+});
+
+type Host = Awaited<ReturnType<typeof OpenCode.create>>;
+
+async function hostWithEnv(env: Record<string, string | undefined>): Promise<Host> {
+  const plugin = createOpencodeSwarmPlugin({
+    apiUrl: "http://127.0.0.1:9",
+    apiKey: "",
+    agentId: "agent-1",
+    taskId: "",
+    isLead: false,
+    env,
+  });
+  return OpenCode.create({ plugins: [plugin], log: { level: "error", emit: () => {} } });
+}
+
+/**
+ * Runs one command as a session shell call, the path the agent's shell tool
+ * takes (`host.shell.create` skips plugin hooks), and returns its output.
+ */
+async function shell(host: Host, command: string): Promise<string> {
+  const session = await host.sessions.create({ location: { directory } });
+  const outFile = join(directory, `out-${crypto.randomUUID()}.txt`);
+  await host.sessions.shell({
+    sessionID: session.id,
+    command: `{ ${command}; } > ${outFile}.tmp 2>&1; mv ${outFile}.tmp ${outFile}`,
+  });
+  const deadline = Date.now() + SHELL_TIMEOUT_MS;
+  while (!(await Bun.file(outFile).exists())) {
+    if (Date.now() > deadline) throw new Error("shell did not exit");
+    await Bun.sleep(25);
+  }
+  return (await Bun.file(outFile).text()).trim();
+}
+
+describe("OpenCode shell env (real OpenCode host)", () => {
+  const envKeys = ["SHELL_REVOKED_CANARY", "SHELL_ADMITTED_CANARY"] as const;
+  const saved: Record<string, string | undefined> = {};
+  let log: ReturnType<typeof spyOn>;
+
+  beforeEach(() => {
+    for (const key of envKeys) saved[key] = process.env[key];
+    log = spyOn(console, "log").mockImplementation(() => {});
+  });
+  afterEach(() => {
+    log.mockRestore();
+    for (const key of envKeys) {
+      if (saved[key] === undefined) delete process.env[key];
+      else process.env[key] = saved[key];
+    }
+  });
+
+  test(
+    "admission and revocation after boot reach the shell",
+    async () => {
+      process.env.SHELL_REVOKED_CANARY = "boot-revoked";
+      delete process.env.SHELL_ADMITTED_CANARY;
+      rows = [
+        { key: "SHELL_REVOKED_CANARY", value: "row-revoked", isSecret: true, exportToEnv: false },
+        { key: "SHELL_ADMITTED_CANARY", value: "row-admitted", isSecret: true, exportToEnv: true },
+      ];
+      const { env } = await fetchResolvedEnv(apiUrl, "key", "agent-1", process.env);
+      const host = await hostWithEnv(env);
+      try {
+        const out = await shell(
+          host,
+          'echo "admitted=$SHELL_ADMITTED_CANARY revoked=$SHELL_REVOKED_CANARY term=$OPENCODE_TERMINAL."; tr "\\0" "\\n" < /proc/$$/environ | grep -c "^SHELL_REVOKED_CANARY=" || true',
+        );
+        expect(out).toContain("admitted=row-admitted revoked= term=1.");
+        expect(out.split("\n").at(-1)).toBe("0");
+      } finally {
+        await host.close();
+      }
+    },
+    SHELL_TIMEOUT_MS * 2,
+  );
+
+  test(
+    "concurrent hosts keep their own env",
+    async () => {
+      const [first, second] = await Promise.all([
+        hostWithEnv({ ...process.env, SHELL_ADMITTED_CANARY: "first" }),
+        hostWithEnv({ ...process.env, SHELL_ADMITTED_CANARY: undefined }),
+      ]);
+      try {
+        const [a, b] = await Promise.all([
+          shell(first, 'echo "v=$SHELL_ADMITTED_CANARY"'),
+          shell(second, 'echo "v=$SHELL_ADMITTED_CANARY"'),
+        ]);
+        expect(a).toBe("v=first");
+        expect(b).toBe("v=");
+        expect(process.env.SHELL_ADMITTED_CANARY).toBeUndefined();
+      } finally {
+        await Promise.all([first.close(), second.close()]);
+      }
+    },
+    SHELL_TIMEOUT_MS * 2,
+  );
+});

package/src/tests/openrouter-base-url.test.ts

@@ -2,16 +2,17 @@
  * OPENROUTER_BASE_URL gateway routing — unit tests.
  *
  * Covers the shared resolver (`src/utils/openrouter-base-url.ts`), the pi
- * models.json override writer (`ensureOpenRouterModelsOverride`) including
- * its composition through pi-coding-agent's ModelRuntime, and attribution host gating.
+ * per-session models.json composer (`writeSessionModelsJson`) for every shared
+ * starting state, its composition through pi-coding-agent's ModelRuntime, and
+ * attribution host gating.
  */
 
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import { mkdtempSync, rmSync } from "node:fs";
+import { describe, expect, test } from "bun:test";
+import { mkdtempSync, readdirSync, readFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { ModelRuntime } from "@earendil-works/pi-coding-agent";
-import { ensureOpenRouterModelsOverride } from "../providers/pi-mono-adapter";
+import { writeSessionModelsJson } from "../providers/pi-mono-adapter";
 import {
   DEFAULT_OPENROUTER_BASE_URL,
   getOpenRouterAttributionHeaders,
@@ -47,162 +48,111 @@ describe("getOpenRouterBaseUrl", () => {
   });
 });
 
-describe("ensureOpenRouterModelsOverride (pi)", () => {
-  let agentDir: string;
-
-  beforeAll(() => {
-    agentDir = mkdtempSync(join(tmpdir(), "pi-or-override-"));
-  });
-
-  afterAll(() => {
-    rmSync(agentDir, { recursive: true, force: true });
-  });
-
-  test("no-op when OPENROUTER_BASE_URL is unset", async () => {
-    const dir = mkdtempSync(join(tmpdir(), "pi-or-noop-"));
-    try {
-      await ensureOpenRouterModelsOverride(dir, {});
-      expect(await Bun.file(join(dir, "models.json")).exists()).toBe(false);
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  test("writes providers.openrouter.baseUrl when the env is set", async () => {
-    await ensureOpenRouterModelsOverride(agentDir, { OPENROUTER_BASE_URL: GATEWAY });
-    const written = JSON.parse(await Bun.file(join(agentDir, "models.json")).text());
-    expect(written).toEqual({ providers: { openrouter: { baseUrl: GATEWAY } } });
-  });
-
-  test("reverts a written override when the env returns to default (file we created is removed)", async () => {
-    const dir = mkdtempSync(join(tmpdir(), "pi-or-revert-"));
-    try {
-      await ensureOpenRouterModelsOverride(dir, { OPENROUTER_BASE_URL: GATEWAY });
-      expect(await Bun.file(join(dir, "models.json")).exists()).toBe(true);
-      await ensureOpenRouterModelsOverride(dir, {});
-      // The override was ALL the file contained — both it and the marker go.
-      expect(await Bun.file(join(dir, "models.json")).exists()).toBe(false);
-      expect(await Bun.file(join(dir, ".agent-swarm-openrouter-override.json")).exists()).toBe(
-        false,
-      );
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  test("revert restores a displaced user baseUrl and keeps sibling keys", async () => {
-    const dir = mkdtempSync(join(tmpdir(), "pi-or-restore-"));
-    try {
-      await Bun.write(
-        join(dir, "models.json"),
-        JSON.stringify({
-          providers: {
-            openrouter: { baseUrl: "https://user.example/v1", compat: { supportsTools: true } },
-            custom: { baseUrl: "https://custom.example/v1", api: "openai-completions" },
-          },
-        }),
-      );
-      await ensureOpenRouterModelsOverride(dir, { OPENROUTER_BASE_URL: GATEWAY });
-      // Re-run with the gateway still set — displaced value must survive.
-      await ensureOpenRouterModelsOverride(dir, { OPENROUTER_BASE_URL: GATEWAY });
-      await ensureOpenRouterModelsOverride(dir, {});
-      const restored = JSON.parse(await Bun.file(join(dir, "models.json")).text());
-      expect(restored.providers.openrouter).toEqual({
-        baseUrl: "https://user.example/v1",
-        compat: { supportsTools: true },
-      });
-      expect(restored.providers.custom).toEqual({
-        baseUrl: "https://custom.example/v1",
-        api: "openai-completions",
+describe("writeSessionModelsJson — OpenRouter gateway (pi)", () => {
+  const MARKER = ".agent-swarm-openrouter-override.json";
+  const LEGACY = "https://legacy-gateway.example/v1";
+  const USER = "https://user.example/v1";
+  const userOpenRouter = { baseUrl: USER, compat: { supportsTools: true } };
+  const custom = { baseUrl: "https://custom.example/v1", api: "openai-completions" };
+
+  /** Starting states of the shared agent dir; the marker ones are left by earlier versions. */
+  const states: Record<string, Record<string, string>> = {
+    "no models.json": {},
+    "hand-authored baseUrl": {
+      "models.json": JSON.stringify({ providers: { openrouter: userOpenRouter, custom } }),
+    },
+    "legacy override over a user baseUrl": {
+      "models.json": JSON.stringify({
+        providers: { openrouter: { ...userOpenRouter, baseUrl: LEGACY }, custom },
+      }),
+      [MARKER]: JSON.stringify({ baseUrl: LEGACY, previous: USER }),
+    },
+    "legacy override alone": {
+      "models.json": JSON.stringify({ providers: { openrouter: { baseUrl: LEGACY } } }),
+      [MARKER]: JSON.stringify({ baseUrl: LEGACY }),
+    },
+    "legacy marker, baseUrl edited by hand since": {
+      "models.json": JSON.stringify({ providers: { openrouter: { baseUrl: USER } } }),
+      [MARKER]: JSON.stringify({ baseUrl: LEGACY }),
+    },
+    "corrupt models.json": { "models.json": "{not json" },
+  };
+
+  // The openrouter block the session's runtime loads, per state, for the
+  // default gateway and for OPENROUTER_BASE_URL=GATEWAY. `null`: no copy, and
+  // the session loads the shared file as it is.
+  const expected: Record<string, [defaultGateway: unknown, gateway: unknown]> = {
+    "no models.json": [null, { baseUrl: GATEWAY }],
+    "hand-authored baseUrl": [null, { ...userOpenRouter, baseUrl: GATEWAY }],
+    "legacy override over a user baseUrl": [
+      userOpenRouter,
+      { ...userOpenRouter, baseUrl: GATEWAY },
+    ],
+    "legacy override alone": [undefined, { baseUrl: GATEWAY }],
+    "legacy marker, baseUrl edited by hand since": [{ baseUrl: USER }, { baseUrl: GATEWAY }],
+    "corrupt models.json": [null, { baseUrl: GATEWAY }],
+  };
+
+  function snapshot(dir: string): Record<string, string> {
+    return Object.fromEntries(
+      readdirSync(dir)
+        .sort()
+        .map((name) => [name, readFileSync(join(dir, name), "utf-8")]),
+    );
+  }
+
+  for (const [state, files] of Object.entries(states)) {
+    for (const [i, env] of [{}, { OPENROUTER_BASE_URL: GATEWAY }].entries()) {
+      const label = i === 0 ? "default gateway" : "session gateway";
+      test(`${state}, ${label}: composed privately, shared dir untouched`, async () => {
+        const dir = mkdtempSync(join(tmpdir(), "pi-or-session-"));
+        try {
+          for (const [name, text] of Object.entries(files)) await Bun.write(join(dir, name), text);
+          const before = snapshot(dir);
+          const session = await writeSessionModelsJson(dir, env);
+          try {
+            const want = expected[state]?.[i];
+            if (want === null) {
+              expect(session.modelsPath).toBeUndefined();
+            } else {
+              expect(session.modelsPath).toBeDefined();
+              expect(session.modelsPath?.startsWith(dir)).toBe(false);
+              const copy = JSON.parse(readFileSync(session.modelsPath as string, "utf-8"));
+              expect(copy.providers?.openrouter).toEqual(want);
+              if (files["models.json"]?.includes("custom.example")) {
+                expect(copy.providers.custom).toEqual(custom);
+              }
+            }
+          } finally {
+            await session.dispose();
+          }
+          expect(snapshot(dir)).toEqual(before);
+        } finally {
+          rmSync(dir, { recursive: true, force: true });
+        }
       });
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  test("revert leaves a user-edited baseUrl alone (marker mismatch) and drops the marker", async () => {
-    const dir = mkdtempSync(join(tmpdir(), "pi-or-user-edit-"));
-    try {
-      await ensureOpenRouterModelsOverride(dir, { OPENROUTER_BASE_URL: GATEWAY });
-      // User hand-edits the file after we wrote it.
-      await Bun.write(
-        join(dir, "models.json"),
-        JSON.stringify({ providers: { openrouter: { baseUrl: "https://mine.example/v1" } } }),
-      );
-      await ensureOpenRouterModelsOverride(dir, {});
-      const kept = JSON.parse(await Bun.file(join(dir, "models.json")).text());
-      expect(kept.providers.openrouter.baseUrl).toBe("https://mine.example/v1");
-      expect(await Bun.file(join(dir, ".agent-swarm-openrouter-override.json")).exists()).toBe(
-        false,
-      );
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  test("default env never touches a hand-authored models.json (no marker)", async () => {
-    const dir = mkdtempSync(join(tmpdir(), "pi-or-hands-off-"));
-    try {
-      const userConfig = {
-        providers: { openrouter: { baseUrl: "https://mine.example/v1" } },
-      };
-      await Bun.write(join(dir, "models.json"), JSON.stringify(userConfig));
-      await ensureOpenRouterModelsOverride(dir, {});
-      expect(JSON.parse(await Bun.file(join(dir, "models.json")).text())).toEqual(userConfig);
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
     }
-  });
+  }
 
-  test("merge-preserves existing providers and openrouter keys", async () => {
-    const dir = mkdtempSync(join(tmpdir(), "pi-or-merge-"));
+  test("ModelRuntime composes the override onto built-in OpenRouter models", async () => {
+    // The whole point of the lever: built-in model IDs resolved through the
+    // runtime's composed store carry the gateway baseUrl.
+    const dir = mkdtempSync(join(tmpdir(), "pi-or-runtime-"));
+    const session = await writeSessionModelsJson(dir, { OPENROUTER_BASE_URL: GATEWAY });
     try {
-      await Bun.write(
-        join(dir, "models.json"),
-        JSON.stringify({
-          providers: {
-            openrouter: { baseUrl: "https://old.example/v1", compat: { supportsTools: true } },
-            custom: { baseUrl: "https://custom.example/v1", api: "openai-completions" },
-          },
-        }),
-      );
-      await ensureOpenRouterModelsOverride(dir, { OPENROUTER_BASE_URL: GATEWAY });
-      const written = JSON.parse(await Bun.file(join(dir, "models.json")).text());
-      expect(written.providers.openrouter.baseUrl).toBe(GATEWAY);
-      expect(written.providers.openrouter.compat).toEqual({ supportsTools: true });
-      expect(written.providers.custom).toEqual({
-        baseUrl: "https://custom.example/v1",
-        api: "openai-completions",
+      const runtime = await ModelRuntime.create({
+        authPath: join(dir, "auth.json"),
+        modelsPath: session.modelsPath,
       });
+      expect(runtime.getError()).toBeUndefined();
+      const model = runtime.getModel("openrouter", "anthropic/claude-sonnet-5");
+      expect(model?.baseUrl).toBe(GATEWAY);
     } finally {
+      await session.dispose();
       rmSync(dir, { recursive: true, force: true });
     }
   });
 
-  test("overwrites a corrupt models.json with just the override", async () => {
-    const dir = mkdtempSync(join(tmpdir(), "pi-or-corrupt-"));
-    try {
-      await Bun.write(join(dir, "models.json"), "{not json");
-      await ensureOpenRouterModelsOverride(dir, { OPENROUTER_BASE_URL: GATEWAY });
-      const written = JSON.parse(await Bun.file(join(dir, "models.json")).text());
-      expect(written).toEqual({ providers: { openrouter: { baseUrl: GATEWAY } } });
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  test("ModelRuntime composes the override onto built-in OpenRouter models", async () => {
-    // The whole point of the lever: built-in model IDs resolved through the
-    // runtime's composed store carry the gateway baseUrl.
-    const runtime = await ModelRuntime.create({
-      authPath: join(agentDir, "auth.json"),
-      modelsPath: join(agentDir, "models.json"),
-    });
-    expect(runtime.getError()).toBeUndefined();
-    const model = runtime.getModel("openrouter", "anthropic/claude-sonnet-5");
-    expect(model?.baseUrl).toBe(GATEWAY);
-  });
-
   test("ModelRuntime keeps the default baseUrl when no models.json exists", async () => {
     const dir = mkdtempSync(join(tmpdir(), "pi-or-default-"));
     try {

package/src/tests/page-proxy.test.ts

@@ -15,7 +15,7 @@ import { unlink } from "node:fs/promises";
 import net from "node:net";
 import { runInNewContext } from "node:vm";
 import type { Subprocess } from "bun";
-import { BROWSER_SDK_JS } from "../artifact-sdk/browser-sdk";
+import { BROWSER_SDK_JS } from "../pages/browser-sdk";
 import { signPageSession, verifyPageSession } from "../utils/page-session";
 import { getFreePort, SERVER_BOOT_HOOK_TIMEOUT_MS, waitForServer } from "./test-net";