@desplega.ai/agent-swarm 2.6.0 → 2.7.1

package/src/tests/pages-frame-ancestors.test.ts

@@ -0,0 +1,162 @@
+/**
+ * `PAGES_FRAME_ANCESTORS` widens `frame-ancestors` on `/p/:id` for PUBLIC
+ * pages only, so an outside site (for example a blog) can iframe a chart.
+ * Authed and password pages keep the app-origin-only header, and an unset
+ * env leaves every header unchanged.
+ */
+import { afterAll, afterEach, beforeAll, describe, expect, test } from "bun:test";
+import crypto from "node:crypto";
+import { unlink } from "node:fs/promises";
+import {
+  createServer as createHttpServer,
+  type IncomingMessage,
+  type Server,
+  type ServerResponse,
+} from "node:http";
+import { closeDb, initDb } from "../be/db";
+import { handlePages } from "../http/pages";
+import { getPageFrameAncestors, handlePagesPublic } from "../http/pages-public";
+import { getPathSegments, parseQueryParams } from "../http/utils";
+import { signPageSession } from "../utils/page-session";
+import { listenOnFreePort } from "./test-net";
+
+const TEST_DB_PATH = "./test-pages-frame-ancestors.sqlite";
+const EMBEDDERS = "https://www.agent-swarm.dev https://agent-swarm.dev";
+let BASE = "";
+
+function createTestServer(): Server {
+  return createHttpServer(async (req: IncomingMessage, res: ServerResponse) => {
+    const pathSegments = getPathSegments(req.url || "");
+    const queryParams = parseQueryParams(req.url || "");
+    const myAgentId = req.headers["x-agent-id"] as string | undefined;
+    if (await handlePagesPublic(req, res, pathSegments, queryParams)) return;
+    if (await handlePages(req, res, pathSegments, queryParams, myAgentId)) return;
+    res.writeHead(404);
+    res.end("not found");
+  });
+}
+
+function frameAncestors(res: Response): string {
+  const csp = res.headers.get("content-security-policy") ?? "";
+  return csp.split(";").find((d) => d.trim().startsWith("frame-ancestors ")) ?? "";
+}
+
+describe("PAGES_FRAME_ANCESTORS on /p/:id", () => {
+  let server: Server;
+  const agentId = crypto.randomUUID();
+  const headers = { "Content-Type": "application/json", "X-Agent-ID": agentId };
+  const ORIG = {
+    PAGES_FRAME_ANCESTORS: process.env.PAGES_FRAME_ANCESTORS,
+    APP_URL: process.env.APP_URL,
+    DASHBOARD_URL: process.env.DASHBOARD_URL,
+    PAGE_SESSION_SECRET: process.env.PAGE_SESSION_SECRET,
+  };
+
+  function restore(key: keyof typeof ORIG): void {
+    if (ORIG[key] === undefined) delete process.env[key];
+    else process.env[key] = ORIG[key];
+  }
+
+  async function createPage(
+    slug: string,
+    authMode: "public" | "authed" | "password",
+  ): Promise<string> {
+    const post = await fetch(`${BASE}/api/pages`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        slug,
+        title: slug,
+        contentType: "text/html",
+        authMode,
+        ...(authMode === "password" ? { password: "swordfish" } : {}),
+        body: "<!doctype html><html><head></head><body><h1>chart</h1></body></html>",
+      }),
+    });
+    expect(post.status).toBe(201);
+    const { id } = (await post.json()) as { id: string };
+    return id;
+  }
+
+  beforeAll(async () => {
+    process.env.PAGE_SESSION_SECRET = "example-test-frame-ancestors-secret";
+    process.env.APP_URL = "https://app.example.test";
+    delete process.env.DASHBOARD_URL;
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(`${TEST_DB_PATH}${suffix}`);
+      } catch {}
+    }
+    initDb(TEST_DB_PATH);
+    server = createTestServer();
+    const port = await listenOnFreePort(server);
+    BASE = `http://localhost:${port}`;
+  });
+
+  afterEach(() => restore("PAGES_FRAME_ANCESTORS"));
+
+  afterAll(async () => {
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+    closeDb();
+    for (const key of Object.keys(ORIG) as (keyof typeof ORIG)[]) restore(key);
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        await unlink(`${TEST_DB_PATH}${suffix}`);
+      } catch {}
+    }
+  });
+
+  test("public page gets the configured origins", async () => {
+    process.env.PAGES_FRAME_ANCESTORS = EMBEDDERS;
+    const id = await createPage("public-embed", "public");
+    const res = await fetch(`${BASE}/p/${id}`);
+    expect(res.status).toBe(200);
+    const fa = frameAncestors(res);
+    expect(fa).toContain("'self'");
+    expect(fa).toContain("https://app.example.test");
+    expect(fa).toContain("https://www.agent-swarm.dev");
+    expect(fa).toContain("https://agent-swarm.dev");
+  });
+
+  test("authed page keeps the app-origin-only header", async () => {
+    const id = await createPage("authed-embed", "authed");
+    const exp = Math.floor(Date.now() / 1000) + 3600;
+    const cookie = `page_session_${id}=${await signPageSession({ pageId: id, exp })}`;
+
+    const before = frameAncestors(await fetch(`${BASE}/p/${id}`, { headers: { cookie } }));
+    process.env.PAGES_FRAME_ANCESTORS = EMBEDDERS;
+    const res = await fetch(`${BASE}/p/${id}`, { headers: { cookie } });
+    expect(res.status).toBe(200);
+    expect(frameAncestors(res)).toBe(before);
+    expect(frameAncestors(res)).not.toContain("agent-swarm.dev");
+  });
+
+  test("password page keeps the app-origin-only header", async () => {
+    process.env.PAGES_FRAME_ANCESTORS = EMBEDDERS;
+    const id = await createPage("password-embed", "password");
+    const res = await fetch(`${BASE}/p/${id}?key=swordfish`);
+    expect(res.status).toBe(200);
+    expect(frameAncestors(res)).not.toContain("agent-swarm.dev");
+  });
+
+  test("unset env leaves the public header unchanged", async () => {
+    const id = await createPage("public-unset", "public");
+    delete process.env.PAGES_FRAME_ANCESTORS;
+    const unset = frameAncestors(await fetch(`${BASE}/p/${id}`));
+    process.env.PAGES_FRAME_ANCESTORS = "";
+    const blank = frameAncestors(await fetch(`${BASE}/p/${id}`));
+    expect(unset).toContain("https://app.example.test");
+    expect(unset).not.toContain("agent-swarm.dev");
+    expect(blank).toBe(unset);
+  });
+
+  test("parser accepts comma or space lists and drops invalid entries", () => {
+    process.env.PAGES_FRAME_ANCESTORS =
+      "https://www.agent-swarm.dev/, https://*.example.com:8443 blog.example.org,* 'none' https://evil.test;script-src javascript:alert(1) https://x.test/path";
+    expect(getPageFrameAncestors()).toEqual([
+      "https://www.agent-swarm.dev",
+      "https://*.example.com:8443",
+      "blog.example.org",
+    ]);
+  });
+});

package/src/tests/pi-codemode.test.ts

@@ -104,7 +104,8 @@ describe("PiMonoAdapter.createSession — codemode", () => {
     process.env.OPENROUTER_BASE_URL = "http://127.0.0.1:9/api/v1";
     delete process.env.PI_CODEMODE;
     delete process.env.PI_CODEMODE_MODELS;
-    delete process.env.PI_TOOL_DEFERRAL;
+    // Deferral off, so every swarm tool shows up as an active tool name.
+    process.env.PI_TOOL_DEFERRAL = "false";
   });
   afterEach(() => {
     for (const key of envKeys) {

package/src/tests/pi-mono-adapter.test.ts

@@ -1859,3 +1859,57 @@ describe("PiMonoSession context-bound note", () => {
     expect(await lateSteers([assistantTurn(usage(5000))])).toEqual([HELD_NOTE_TEXT]);
   });
 });
+
+describe("PiMonoSession — per-call usage line", () => {
+  function assistantEnd(content: unknown[], usage?: unknown): AgentSessionEvent {
+    return {
+      type: "message_end",
+      message: { role: "assistant", content, stopReason: "stop", ...(usage ? { usage } : {}) },
+    } as unknown as AgentSessionEvent;
+  }
+
+  test("one call_usage raw_log line per assistant message_end with usage", async () => {
+    const { events } = await runWithEvents([
+      assistantEnd([{ type: "toolCall", id: "call-1", name: "bash", arguments: {} }], {
+        input: 120,
+        cacheRead: 9_000,
+        cacheWrite: 400,
+        output: 60,
+        reasoning: 12,
+        totalTokens: 9_580,
+      }),
+      {
+        type: "message_end",
+        message: { role: "user", content: [{ type: "text", text: "tool output" }] },
+      } as unknown as AgentSessionEvent,
+      // No usage (some providers omit it): no line.
+      assistantEnd([{ type: "text", text: "thinking out loud" }]),
+      assistantEnd([{ type: "text", text: "Done" }], { input: 5, cacheRead: 9_500, output: 3 }),
+    ]);
+
+    const raw = events.flatMap((e) =>
+      e.type === "raw_log" ? [JSON.parse(e.content) as Record<string, unknown>] : [],
+    );
+    const usageLines = raw.filter((line) => line.type === "call_usage");
+    expect(usageLines).toEqual([
+      {
+        type: "call_usage",
+        harness: "pi",
+        usage: { input: 120, cacheRead: 9_000, cacheWrite: 400, output: 60, reasoning: 12 },
+      },
+      {
+        type: "call_usage",
+        harness: "pi",
+        usage: { input: 5, cacheRead: 9_500, cacheWrite: 0, output: 3, reasoning: 0 },
+      },
+    ]);
+    // The usage line precedes the call's own text line.
+    const done = raw.findIndex(
+      (line) => line.type === "assistant" && JSON.stringify(line).includes('"Done"'),
+    );
+    expect(done).toBeGreaterThan(0);
+    expect(raw[done - 1]).toEqual(usageLines[1]);
+    // Token counts only: no message content rides on the line.
+    expect(JSON.stringify(usageLines)).not.toContain("tool output");
+  });
+});

package/src/tests/pi-mono-session-cost-on-abort.test.ts

@@ -0,0 +1,270 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import type { AgentSession } from "@earendil-works/pi-coding-agent";
+import {
+  type ReconcileActiveTasksOptions,
+  type RunnerState,
+  type RunningTask,
+  reconcileActiveTasks,
+} from "../commands/runner";
+import { PiMonoSession } from "../providers/pi-mono-adapter";
+import type { CostData, ProviderEvent, ProviderSessionConfig } from "../providers/types";
+
+type AgentSessionEvent = Parameters<Parameters<AgentSession["subscribe"]>[0]>[0];
+
+const tmpLogDir = `/tmp/pi-mono-cost-abort-test-${Date.now()}`;
+
+beforeAll(() => {
+  mkdirSync(tmpLogDir, { recursive: true });
+});
+
+afterAll(() => {
+  rmSync(tmpLogDir, { recursive: true, force: true });
+});
+
+function makeSessionConfig(logFile: string): ProviderSessionConfig {
+  return {
+    prompt: "Coordinate sub-agents and complete the lead task",
+    systemPrompt: "",
+    model: "anthropic/claude-opus-4-6",
+    role: "lead",
+    agentId: "lead-agent-id",
+    taskId: "lead-task-id",
+    apiUrl: "http://localhost:3013",
+    apiKey: "example-test-key",
+    cwd: "/tmp",
+    logFile,
+    iteration: 1,
+  };
+}
+
+describe("PiMonoSession & runner — long lead session cost preservation (#2073)", () => {
+  test("abort() unblocks waitForIdle() and preserves cost after terminal store-progress", async () => {
+    const listeners: Array<(event: AgentSessionEvent) => void> = [];
+    const mockSession = {
+      sessionId: "lead-pi-session-1",
+      isStreaming: true,
+      model: { provider: "anthropic", id: "claude-opus-4-6" },
+      subscribe(listener: (event: AgentSessionEvent) => void) {
+        listeners.push(listener);
+        return () => {
+          const idx = listeners.indexOf(listener);
+          if (idx >= 0) listeners.splice(idx, 1);
+        };
+      },
+      async prompt() {
+        for (const l of listeners) {
+          l({
+            type: "tool_execution_start",
+            toolCallId: "sp-1",
+            toolName: "agent-swarm_store-progress",
+            args: { status: "completed", output: "All sub-tasks merged" },
+          } as unknown as AgentSessionEvent);
+          l({
+            type: "tool_execution_end",
+            toolCallId: "sp-1",
+            toolName: "agent-swarm_store-progress",
+            result: { success: true },
+            isError: false,
+          } as unknown as AgentSessionEvent);
+        }
+        // Simulate a streaming turn that never emits agent_end before runner aborts it
+      },
+      getContextUsage: () => null,
+      getSessionStats: () => ({
+        tokens: { input: 42000, output: 3800, cacheRead: 120000, cacheWrite: 15000, total: 180800 },
+        cost: 1.85,
+        userMessages: 1,
+        assistantMessages: 14,
+      }),
+      abort: async () => {},
+      dispose: () => {},
+    } as unknown as AgentSession;
+
+    const logFile = join(tmpLogDir, `lead-abort-idle-${Date.now()}.log`);
+    const session = new PiMonoSession(mockSession, makeSessionConfig(logFile), false);
+    const events: ProviderEvent[] = [];
+    session.onEvent((e) => events.push(e));
+
+    // Allow prompt() to emit store-progress and enter waitForIdle()
+    await Bun.sleep(20);
+
+    // Mid-session result snapshot should already be emitted on terminal store-progress
+    const resultEventsBeforeAbort = events.filter((e) => e.type === "result");
+    expect(resultEventsBeforeAbort.length).toBeGreaterThanOrEqual(1);
+
+    // Runner reconciliation aborts the session because the task is now completed server-side
+    await session.abort();
+
+    const result = await session.waitForCompletion();
+    expect(result.exitCode).toBe(0);
+    expect(result.isError).toBe(false);
+    expect(result.cost).toBeDefined();
+    expect(result.cost?.totalCostUsd).toBe(1.85);
+    expect(result.cost?.inputTokens).toBe(42000);
+    expect(result.cost?.outputTokens).toBe(3800);
+    expect(result.cost?.cacheReadTokens).toBe(120000);
+    expect(result.cost?.cacheWriteTokens).toBe(15000);
+    expect(result.cost?.numTurns).toBe(15);
+    expect(result.cost?.provider).toBe("pi");
+  });
+
+  test("prompt() rejection on abort after terminal store-progress still returns cost and exitCode 0", async () => {
+    const listeners: Array<(event: AgentSessionEvent) => void> = [];
+    let rejectPrompt: (err: Error) => void = () => {};
+    const promptBlocked = new Promise<void>((_, reject) => {
+      rejectPrompt = reject;
+    });
+
+    const mockSession = {
+      sessionId: "lead-pi-session-2",
+      isStreaming: true,
+      model: { provider: "anthropic", id: "claude-opus-4-6" },
+      subscribe(listener: (event: AgentSessionEvent) => void) {
+        listeners.push(listener);
+        return () => {
+          const idx = listeners.indexOf(listener);
+          if (idx >= 0) listeners.splice(idx, 1);
+        };
+      },
+      async prompt() {
+        for (const l of listeners) {
+          l({
+            type: "tool_execution_start",
+            toolCallId: "sp-2",
+            toolName: "store-progress",
+            args: { status: "completed", output: "Done" },
+          } as unknown as AgentSessionEvent);
+          l({
+            type: "tool_execution_end",
+            toolCallId: "sp-2",
+            toolName: "store-progress",
+            result: { ok: true },
+            isError: false,
+          } as unknown as AgentSessionEvent);
+        }
+        await promptBlocked;
+      },
+      getContextUsage: () => null,
+      getSessionStats: () => ({
+        tokens: { input: 18500, output: 2100, cacheRead: 50000, cacheWrite: 6000, total: 76600 },
+        cost: 0.92,
+        userMessages: 1,
+        assistantMessages: 8,
+      }),
+      abort: async () => {
+        rejectPrompt(new Error("Request aborted"));
+      },
+      dispose: () => {},
+    } as unknown as AgentSession;
+
+    const logFile = join(tmpLogDir, `lead-abort-throw-${Date.now()}.log`);
+    const session = new PiMonoSession(mockSession, makeSessionConfig(logFile), false);
+
+    await Bun.sleep(20);
+    await session.abort();
+
+    const result = await session.waitForCompletion();
+    expect(result.exitCode).toBe(0);
+    expect(result.isError).toBe(false);
+    expect(result.cost).toBeDefined();
+    expect(result.cost?.totalCostUsd).toBe(0.92);
+    expect(result.cost?.inputTokens).toBe(18500);
+    expect(result.cost?.outputTokens).toBe(2100);
+  });
+
+  test("unexpected throw in runSession attaches partial session cost with isError: true", async () => {
+    const mockSession = {
+      sessionId: "lead-pi-session-3",
+      isStreaming: false,
+      model: { provider: "anthropic", id: "claude-opus-4-6" },
+      subscribe: () => () => {},
+      async prompt() {
+        throw new Error("MCP transport disconnected after 10 turns");
+      },
+      getContextUsage: () => null,
+      getSessionStats: () => ({
+        tokens: { input: 9000, output: 1100, cacheRead: 4000, cacheWrite: 1000, total: 15100 },
+        cost: 0.41,
+        userMessages: 1,
+        assistantMessages: 5,
+      }),
+      abort: async () => {},
+      dispose: () => {},
+    } as unknown as AgentSession;
+
+    const logFile = join(tmpLogDir, `lead-unexpected-throw-${Date.now()}.log`);
+    const session = new PiMonoSession(mockSession, makeSessionConfig(logFile), false);
+
+    const result = await session.waitForCompletion();
+    expect(result.exitCode).toBe(1);
+    expect(result.isError).toBe(true);
+    expect(result.cost).toBeDefined();
+    expect(result.cost?.isError).toBe(true);
+    expect(result.cost?.totalCostUsd).toBe(0.41);
+    expect(result.cost?.inputTokens).toBe(9000);
+  });
+
+  test("reconcileActiveTasks preserves task.lastCost when settling an unresponsive aborted session", async () => {
+    const snapshotCost: CostData = {
+      sessionId: "runner-session-1",
+      taskId: "task-2073",
+      agentId: "lead-agent-id",
+      totalCostUsd: 2.34,
+      inputTokens: 64000,
+      outputTokens: 5200,
+      cacheReadTokens: 150000,
+      cacheWriteTokens: 20000,
+      durationMs: 1_200_000,
+      numTurns: 22,
+      model: "anthropic/claude-opus-4-6",
+      isError: false,
+      provider: "pi",
+    };
+
+    const task: RunningTask = {
+      taskId: "task-2073",
+      session: {
+        sessionId: "pi-session-2073",
+        onEvent: () => {},
+        waitForCompletion: () => new Promise(() => {}),
+        abort: async () => {},
+      },
+      logFile: "/tmp/task-2073.log",
+      startTime: new Date(1_000),
+      promise: new Promise(() => {}),
+      result: null,
+      harnessProvider: "pi",
+      hasLocalEnvironment: true,
+      abortRequestedAt: 10_000,
+      serverTerminalStatus: "completed",
+      lastCost: { value: snapshotCost },
+    };
+
+    const state: RunnerState = {
+      activeTasks: new Map([["task-2073", task]]),
+      deliveryMode: "poll",
+      maxConcurrent: 2,
+      startedAt: 0,
+      tasksProcessed: 0,
+      harnessProvider: "pi",
+      codexCreditsExhaustedCooldownMs: 60_000,
+      modelWindowBlocks: new Map(),
+    };
+
+    const opts: ReconcileActiveTasksOptions = {
+      cancelledSignaled: new Set(),
+      isCancelled: async () => false,
+      fetchStatus: async () => "completed",
+      intervalMs: 30_000,
+      abortGraceMs: 10_000,
+      now: () => 25_000,
+    };
+
+    await reconcileActiveTasks(state, "lead", opts);
+
+    expect(task.result).not.toBeNull();
+    expect(task.result?.cost).toEqual(snapshotCost);
+  });
+});

package/src/tests/pi-native-mcp.test.ts

@@ -30,6 +30,17 @@ describe("toPiMcpServers", () => {
     });
   });
 
+  test("deferred maps every installed server to deferred exposure", () => {
+    const servers = toPiMcpServers(
+      {
+        local: { command: "context-mode" },
+        remote: { url: "https://mcp.example.com/mcp" },
+      },
+      { deferred: true },
+    );
+    expect(Object.values(servers).map((s) => s.exposure)).toEqual(["deferred", "deferred"]);
+  });
+
   test("no installed servers maps to an empty set", () => {
     expect(toPiMcpServers(null)).toEqual({});
   });
@@ -70,7 +81,8 @@ describe("PiMonoAdapter.createSession — native MCP for installed servers", ()
     process.env.OPENROUTER_API_KEY = "example-test-key";
     // The session prompts on creation; keep that request off the network.
     process.env.OPENROUTER_BASE_URL = "http://127.0.0.1:9/api/v1";
-    delete process.env.PI_TOOL_DEFERRAL;
+    // Direct exposure, so installed tools show up as active tool names.
+    process.env.PI_TOOL_DEFERRAL = "false";
     mkdirSync(join(dir, "agent"), { recursive: true });
   });
   afterEach(() => {

package/src/tests/pi-tool-exposure.test.ts

@@ -176,8 +176,8 @@ describe("pi resource loader trust", () => {
 });
 
 describe("PI_TOOL_DEFERRAL flag", () => {
-  test("defaults off and parses boolean literals", () => {
-    expect(isPiToolDeferralEnabled({})).toBe(false);
+  test("defaults on and parses boolean literals", () => {
+    expect(isPiToolDeferralEnabled({})).toBe(true);
     expect(isPiToolDeferralEnabled({ PI_TOOL_DEFERRAL: "true" })).toBe(true);
     expect(isPiToolDeferralEnabled({ PI_TOOL_DEFERRAL: "1" })).toBe(true);
     expect(isPiToolDeferralEnabled({ PI_TOOL_DEFERRAL: "false" })).toBe(false);
@@ -187,9 +187,9 @@ describe("PI_TOOL_DEFERRAL flag", () => {
     "traits.hasToolSearch follows the flag live",
     withEnv("PI_TOOL_DEFERRAL", undefined, () => {
       const adapter = new PiMonoAdapter();
-      expect(adapter.traits.hasToolSearch).toBe(false);
-      process.env.PI_TOOL_DEFERRAL = "true";
       expect(adapter.traits.hasToolSearch).toBe(true);
+      process.env.PI_TOOL_DEFERRAL = "false";
+      expect(adapter.traits.hasToolSearch).toBe(false);
     }),
   );
 });
@@ -259,8 +259,8 @@ describe("PiMonoAdapter.createSession — tool deferral wiring", () => {
   }
 
   test(
-    "flag on: non-core tools deferred and tool_search enabled by default",
-    withEnv("PI_TOOL_DEFERRAL", "true", async () => {
+    "flag unset: non-core tools deferred and tool_search enabled by default",
+    withEnv("PI_TOOL_DEFERRAL", undefined, async () => {
       const opts = await captureSessionOptions();
       const tools = opts.customTools as ToolDefinition[];
       expect(Object.fromEntries(tools.map((t) => [t.name, t.exposure]))).toEqual({
@@ -274,8 +274,8 @@ describe("PiMonoAdapter.createSession — tool deferral wiring", () => {
   );
 
   test(
-    "flag off: every tool declared and no tool_search",
-    withEnv("PI_TOOL_DEFERRAL", undefined, async () => {
+    "flag false: every tool declared and no tool_search",
+    withEnv("PI_TOOL_DEFERRAL", "false", async () => {
       const opts = await captureSessionOptions();
       const tools = opts.customTools as ToolDefinition[];
       expect(tools.map((t) => t.exposure)).toEqual([undefined, undefined, undefined]);

package/src/tests/preload-env.test.ts

@@ -16,11 +16,15 @@ test(
       "COMB_ENABLED",
       "APP_URL",
       "AGENT_FS_API_URL",
+      "AGENT_FS_PROXY",
       "AGENT_FS_LIVE_URL",
+      "AGENT_FS_LINK_TARGET",
       "AGENT_FS_DEFAULT_ORG_ID",
       "AGENT_FS_DEFAULT_DRIVE_ID",
       "SWARM_ORG_NAME",
       "SWARM_ORG_WEBSITE",
+      "EMBEDDING_QUERY_PREFIX",
+      "EMBEDDING_DOCUMENT_PREFIX",
     ];
     try {
       await Bun.write(

package/src/tests/preload.ts

@@ -32,11 +32,15 @@ for (const key of Object.keys(process.env)) {
       "COMB_ENABLED",
       "APP_URL",
       "AGENT_FS_API_URL",
+      "AGENT_FS_PROXY",
       "AGENT_FS_LIVE_URL",
+      "AGENT_FS_LINK_TARGET",
       "AGENT_FS_DEFAULT_ORG_ID",
       "AGENT_FS_DEFAULT_DRIVE_ID",
       "SWARM_ORG_NAME",
       "SWARM_ORG_WEBSITE",
+      "EMBEDDING_QUERY_PREFIX",
+      "EMBEDDING_DOCUMENT_PREFIX",
     ].includes(key)
   ) {
     delete process.env[key];