@vellumai/assistant 0.6.6 → 0.7.1

package/src/__tests__/host-file-proxy.test.ts

@@ -1,4 +1,27 @@
-import { afterEach, describe, expect, jest, test } from "bun:test";
+import { afterEach, describe, expect, jest, mock, test } from "bun:test";
+
+const sentMessages: unknown[] = [];
+const resolvedInteractionIds: string[] = [];
+let mockHasClient = false;
+
+mock.module("../runtime/assistant-event-hub.js", () => ({
+  broadcastMessage: (msg: unknown) => sentMessages.push(msg),
+  assistantEventHub: {
+    getMostRecentClientByCapability: (cap: string) =>
+      cap === "host_file" && mockHasClient ? { id: "mock-client" } : null,
+  },
+}));
+
+mock.module("../runtime/pending-interactions.js", () => ({
+  resolve: (requestId: string) => {
+    resolvedInteractionIds.push(requestId);
+    return undefined;
+  },
+  get: () => undefined,
+  getByKind: () => [],
+  getByConversation: () => [],
+  removeByConversation: () => {},
+}));
 
 const { HostFileProxy } = await import("../daemon/host-file-proxy.js");
 
@@ -10,17 +33,17 @@ const PNG_HEADER = Buffer.from([
 
 describe("HostFileProxy", () => {
   let proxy: InstanceType<typeof HostFileProxy>;
-  let sentMessages: unknown[];
-  let sendToClient: (msg: unknown) => void;
 
-  function setup(onInternalResolve?: (requestId: string) => void) {
-    sentMessages = [];
-    sendToClient = (msg: unknown) => sentMessages.push(msg);
-    proxy = new HostFileProxy(sendToClient, onInternalResolve);
+  function setup() {
+    sentMessages.length = 0;
+    resolvedInteractionIds.length = 0;
+    mockHasClient = false;
+    proxy = new (HostFileProxy as any)();
   }
 
   afterEach(() => {
     proxy?.dispose();
+    HostFileProxy.reset();
   });
 
   describe("request/resolve lifecycle (happy path)", () => {
@@ -271,24 +294,17 @@ describe("HostFileProxy", () => {
   });
 
   describe("isAvailable", () => {
-    test("returns false by default (no client connected)", () => {
+    test("returns false when no client with host_file capability is connected", () => {
       setup();
+      mockHasClient = false;
       expect(proxy.isAvailable()).toBe(false);
     });
 
-    test("returns true after updateSender with clientConnected=true", () => {
+    test("returns true when a client with host_file capability is connected", () => {
       setup();
-      proxy.updateSender(sendToClient, true);
+      mockHasClient = true;
       expect(proxy.isAvailable()).toBe(true);
     });
-
-    test("returns false after updateSender with clientConnected=false", () => {
-      setup();
-      proxy.updateSender(sendToClient, true);
-      expect(proxy.isAvailable()).toBe(true);
-      proxy.updateSender(sendToClient, false);
-      expect(proxy.isAvailable()).toBe(false);
-    });
   });
 
   describe("dispose", () => {
@@ -377,34 +393,6 @@ describe("HostFileProxy", () => {
     });
   });
 
-  describe("updateSender", () => {
-    test("uses updated sender for new requests", async () => {
-      setup();
-
-      const newMessages: unknown[] = [];
-      proxy.updateSender((msg) => newMessages.push(msg), true);
-
-      const resultPromise = proxy.request(
-        {
-          operation: "read",
-          path: "/tmp/test.txt",
-        },
-        "session-1",
-      );
-
-      expect(sentMessages).toHaveLength(0); // Old sender not used
-      expect(newMessages).toHaveLength(1); // New sender used
-
-      const sent = newMessages[0] as Record<string, unknown>;
-      proxy.resolve(sent.requestId as string, {
-        content: "updated content",
-        isError: false,
-      });
-
-      await resultPromise;
-    });
-  });
-
   describe("resolve with unknown requestId", () => {
     test("silently ignores unknown requestId", () => {
       setup();
@@ -522,49 +510,9 @@ describe("HostFileProxy", () => {
     });
   });
 
-  describe("sender throws synchronously", () => {
-    test("rejects the promise, clears pending state and timer, invokes onInternalResolve", async () => {
-      const resolvedIds: string[] = [];
-      sentMessages = [];
-      sendToClient = () => {
-        throw new Error("transport down");
-      };
-      proxy = new HostFileProxy(sendToClient, (id) => resolvedIds.push(id));
-
-      const resultPromise = proxy.request(
-        { operation: "read", path: "/tmp/test.txt" },
-        "session-1",
-      );
-
-      await expect(resultPromise).rejects.toThrow("transport down");
-
-      // The internal resolve should fire exactly once as part of cleanup.
-      expect(resolvedIds).toHaveLength(1);
-
-      // Issue a new request on a fresh (non-throwing) sender and verify
-      // the proxy is still functional — no stale timers or bookkeeping
-      // from the failed request.
-      sentMessages = [];
-      proxy.updateSender((msg) => sentMessages.push(msg), true);
-      const okPromise = proxy.request(
-        { operation: "read", path: "/tmp/ok.txt" },
-        "session-1",
-      );
-      expect(sentMessages).toHaveLength(1);
-      const okRequestId = (sentMessages[0] as Record<string, unknown>)
-        .requestId as string;
-      expect(proxy.hasPendingRequest(okRequestId)).toBe(true);
-      proxy.resolve(okRequestId, { content: "ok", isError: false });
-      const okResult = await okPromise;
-      expect(okResult.content).toBe("ok");
-      expect(okResult.isError).toBe(false);
-    });
-  });
-
-  describe("onInternalResolve callback", () => {
+  describe("pendingInteractions.resolve callback", () => {
     test("fires on abort", async () => {
-      const resolvedIds: string[] = [];
-      setup((id) => resolvedIds.push(id));
+      setup();
 
       const controller = new AbortController();
       const resultPromise = proxy.request(
@@ -582,12 +530,11 @@ describe("HostFileProxy", () => {
       controller.abort();
       await resultPromise;
 
-      expect(resolvedIds).toEqual([requestId]);
+      expect(resolvedInteractionIds).toContain(requestId);
     });
 
     test("fires for each pending request on dispose", () => {
-      const resolvedIds: string[] = [];
-      setup((id) => resolvedIds.push(id));
+      setup();
 
       // Create two pending requests and catch rejections from dispose
       const p1 = proxy.request(
@@ -614,14 +561,13 @@ describe("HostFileProxy", () => {
 
       proxy.dispose();
 
-      expect(resolvedIds).toHaveLength(2);
-      expect(resolvedIds).toContain(ids[0]);
-      expect(resolvedIds).toContain(ids[1]);
+      expect(resolvedInteractionIds).toHaveLength(2);
+      expect(resolvedInteractionIds).toContain(ids[0]);
+      expect(resolvedInteractionIds).toContain(ids[1]);
     });
 
     test("does not fire on normal client-initiated resolve", async () => {
-      const resolvedIds: string[] = [];
-      setup((id) => resolvedIds.push(id));
+      setup();
 
       const resultPromise = proxy.request(
         {
@@ -634,14 +580,14 @@ describe("HostFileProxy", () => {
       const sent = sentMessages[0] as Record<string, unknown>;
       const requestId = sent.requestId as string;
 
-      // Normal resolve from client — should NOT trigger onInternalResolve
+      // Normal resolve from client — should NOT trigger pendingInteractions.resolve
       proxy.resolve(requestId, {
         content: "file contents",
         isError: false,
       });
 
       await resultPromise;
-      expect(resolvedIds).toEqual([]);
+      expect(resolvedInteractionIds).toEqual([]);
     });
   });
 });

package/src/__tests__/host-file-read-tool.test.ts

@@ -1,9 +1,30 @@
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { afterEach, describe, expect, test } from "bun:test";
+import { afterEach, describe, expect, mock, test } from "bun:test";
 
 import type { HostFileInput } from "../daemon/host-file-proxy.js";
+import type { ToolExecutionResult } from "../tools/types.js";
+
+// Mock HostFileProxy singleton so proxy delegation tests can control it.
+let mockFileProxyAvailable = false;
+let mockFileProxyRequestFn: (
+  input: HostFileInput,
+  conversationId: string,
+  signal?: AbortSignal,
+) => Promise<ToolExecutionResult> = () => Promise.resolve({ content: "", isError: false });
+
+mock.module("../daemon/host-file-proxy.js", () => ({
+  HostFileProxy: {
+    get instance() {
+      return {
+        isAvailable: () => mockFileProxyAvailable,
+        request: mockFileProxyRequestFn,
+      };
+    },
+  },
+}));
+
 import { hostFileReadTool } from "../tools/host-filesystem/read.js";
 import type { ToolContext } from "../tools/types.js";
 
@@ -27,6 +48,8 @@ afterEach(() => {
   for (const dir of testDirs.splice(0)) {
     rmSync(dir, { recursive: true, force: true });
   }
+  mockFileProxyAvailable = false;
+  mockFileProxyRequestFn = () => Promise.resolve({ content: "", isError: false });
 });
 
 // Minimal valid JPEG: FF D8 FF E0 header
@@ -172,28 +195,26 @@ describe("host_file_read image support", () => {
       conversationId: string;
       signal?: AbortSignal;
     }> = [];
+    mockFileProxyAvailable = true;
+    mockFileProxyRequestFn = async (input, conversationId, signal) => {
+      requests.push({ input, conversationId, signal });
+      return {
+        content: "Image loaded: /host/screenshot.png",
+        isError: false,
+        contentBlocks: [
+          {
+            type: "image",
+            source: {
+              type: "base64",
+              media_type: "image/png",
+              data: PNG_HEADER.toString("base64"),
+            },
+          },
+        ],
+      };
+    };
     const proxyContext: ToolContext = {
       ...makeContext(),
-      hostFileProxy: {
-        isAvailable: () => true,
-        request: async (input, conversationId, signal) => {
-          requests.push({ input, conversationId, signal });
-          return {
-            content: "Image loaded: /host/screenshot.png",
-            isError: false,
-            contentBlocks: [
-              {
-                type: "image",
-                source: {
-                  type: "base64",
-                  media_type: "image/png",
-                  data: PNG_HEADER.toString("base64"),
-                },
-              },
-            ],
-          };
-        },
-      } as ToolContext["hostFileProxy"],
     };
 
     const result = await hostFileReadTool.execute(

package/src/__tests__/host-proxy-interface.test.ts

@@ -24,7 +24,7 @@ describe("supportsHostProxy (runtime)", () => {
       "cli",
       "telegram",
       "phone",
-      "vellum",
+      "web",
       "whatsapp",
       "slack",
       "email",
@@ -141,7 +141,7 @@ describe("isHostProxyTransport", () => {
       "cli",
       "telegram",
       "phone",
-      "vellum",
+      "web",
       "whatsapp",
       "slack",
       "email",
@@ -187,7 +187,7 @@ describe("macOS host_browser capability", () => {
       "cli",
       "telegram",
       "phone",
-      "vellum",
+      "web",
       "whatsapp",
       "slack",
       "email",

package/src/__tests__/host-shell-tool.test.ts

@@ -32,15 +32,10 @@ const mockConfig = {
   rateLimit: { maxRequestsPerMinute: 0 },
   secretDetection: {
     enabled: true,
-    action: "warn" as const,
-    entropyThreshold: 4.0,
   },
   auditLog: { retentionDays: 0 },
 };
 
-// Track whether wrapCommand was ever called — host_bash must never invoke it
-let wrapCommandCallCount = 0;
-
 mock.module("../config/loader.js", () => ({
   getConfig: () => mockConfig,
   loadConfig: () => mockConfig,
@@ -59,10 +54,22 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
-mock.module("../tools/terminal/sandbox.js", () => ({
-  wrapCommand: (...args: unknown[]) => {
-    wrapCommandCallCount++;
-    return { command: "bash", args: ["-c", "--", args[0]], sandboxed: false };
+// Mock the host-bash-proxy singleton so proxy delegation tests can control it.
+let mockProxyAvailable = false;
+let mockProxyRequestFn: (
+  input: { command: string; working_dir?: string; timeout_seconds?: number; env?: Record<string, string> },
+  conversationId: string,
+  signal?: AbortSignal,
+) => Promise<ToolExecutionResult> = () => Promise.resolve({ content: "", isError: false });
+
+mock.module("../daemon/host-bash-proxy.js", () => ({
+  HostBashProxy: {
+    get instance() {
+      return {
+        isAvailable: () => mockProxyAvailable,
+        request: mockProxyRequestFn,
+      };
+    },
   },
 }));
 
@@ -83,6 +90,8 @@ afterEach(() => {
   for (const dir of testDirs.splice(0)) {
     rmSync(dir, { recursive: true, force: true });
   }
+  mockProxyAvailable = false;
+  mockProxyRequestFn = () => Promise.resolve({ content: "", isError: false });
 });
 
 describe("host_bash tool", () => {
@@ -125,8 +134,6 @@ describe("host_bash tool", () => {
   });
 
   test("does not route through sandbox wrapCommand", async () => {
-    wrapCommandCallCount = 0;
-
     const dir = mkdtempSync(join(tmpdir(), "host-shell-nosandbox-"));
     testDirs.push(dir);
 
@@ -140,8 +147,6 @@ describe("host_bash tool", () => {
 
     expect(result.isError).toBe(false);
     expect(result.content.trim()).toBe("isolation-test");
-    // The sandbox wrapCommand must never be called for host_bash
-    expect(wrapCommandCallCount).toBe(0);
   });
 
   test("spawns plain bash without sandbox-exec or bwrap", async () => {
@@ -236,7 +241,6 @@ describe("host_bash — baseline: no sandbox isolation", () => {
     testDirs.push(dir);
 
     spawnCalls.length = 0;
-    wrapCommandCallCount = 0;
 
     const result = await hostShellTool.execute(
       {
@@ -247,7 +251,6 @@ describe("host_bash — baseline: no sandbox isolation", () => {
     );
 
     expect(result.isError).toBe(false);
-    expect(wrapCommandCallCount).toBe(0);
     expect(spawnCalls[0].command).toBe("bash");
   });
 });
@@ -273,10 +276,11 @@ describe("host_bash — regression: no proxied-mode additions", () => {
     expect(schemaProps).not.toHaveProperty("credential_ids");
   });
 
-  test("schema only contains the expected properties (command, working_dir, timeout_seconds, activity)", () => {
+  test("schema only contains the expected properties (command, working_dir, timeout_seconds, activity, background)", () => {
     const propertyNames = Object.keys(schemaProps).sort();
     expect(propertyNames).toEqual([
       "activity",
+      "background",
       "command",
       "timeout_seconds",
       "working_dir",
@@ -288,7 +292,6 @@ describe("host_bash — regression: no proxied-mode additions", () => {
     testDirs.push(dir);
 
     spawnCalls.length = 0;
-    wrapCommandCallCount = 0;
 
     // Pass network_mode as if the model hallucinated the parameter —
     // host_bash must ignore it and run the command normally.
@@ -307,7 +310,6 @@ describe("host_bash — regression: no proxied-mode additions", () => {
     expect(spawnCalls.length).toBe(1);
     expect(spawnCalls[0].command).toBe("bash");
     // Must never route through sandbox wrapCommand, even with proxied-mode input
-    expect(wrapCommandCallCount).toBe(0);
   });
 
   test("execute ignores credential_ids even if supplied in input", async () => {
@@ -315,7 +317,6 @@ describe("host_bash — regression: no proxied-mode additions", () => {
     testDirs.push(dir);
 
     spawnCalls.length = 0;
-    wrapCommandCallCount = 0;
 
     const result = await hostShellTool.execute(
       {
@@ -331,7 +332,6 @@ describe("host_bash — regression: no proxied-mode additions", () => {
     expect(spawnCalls.length).toBe(1);
     expect(spawnCalls[0].command).toBe("bash");
     // Must never route through sandbox wrapCommand, even with credential inputs
-    expect(wrapCommandCallCount).toBe(0);
   });
 
   test("tool name is host_bash (not bash)", () => {
@@ -694,7 +694,6 @@ describe("host_bash — spawn error handling", () => {
 
 describe("host_bash — proxy delegation", () => {
   const ROUTING_ENV_KEYS = [
-    "BASE_DATA_DIR",
     "VELLUM_WORKSPACE_DIR",
     "VELLUM_DATA_DIR",
     "VELLUM_ENVIRONMENT",
@@ -721,7 +720,7 @@ describe("host_bash — proxy delegation", () => {
     }
   }
 
-  function makeMockProxy(result: ToolExecutionResult) {
+  function setupMockProxy(result: ToolExecutionResult) {
     const calls: Array<{
       input: {
         command: string;
@@ -732,41 +731,24 @@ describe("host_bash — proxy delegation", () => {
       conversationId: string;
     }> = [];
 
-    return {
-      proxy: {
-        isAvailable: () => true,
-        request: async (
-          input: {
-            command: string;
-            working_dir?: string;
-            timeout_seconds?: number;
-            env?: Record<string, string>;
-          },
-          conversationId: string,
-          _signal?: AbortSignal,
-        ) => {
-          calls.push({ input, conversationId });
-          return result;
-        },
-        updateSender: () => {},
-        dispose: () => {},
-        resolve: () => {},
-        hasPendingRequest: () => false,
-      },
-      calls,
+    mockProxyAvailable = true;
+    mockProxyRequestFn = async (input, conversationId) => {
+      calls.push({ input, conversationId });
+      return result;
     };
+
+    return calls;
   }
 
-  test("delegates to proxy when hostBashProxy is available", async () => {
+  test("delegates to proxy when proxy is available", async () => {
     const proxyResult: ToolExecutionResult = {
       content: "proxied output",
       isError: false,
     };
-    const { proxy, calls } = makeMockProxy(proxyResult);
+    const calls = setupMockProxy(proxyResult);
 
     const ctx: ToolContext = {
       ...makeContext(),
-      hostBashProxy: proxy as unknown as ToolContext["hostBashProxy"],
     };
 
     spawnCalls.length = 0;
@@ -790,11 +772,10 @@ describe("host_bash — proxy delegation", () => {
       content: "proxied",
       isError: false,
     };
-    const { proxy, calls } = makeMockProxy(proxyResult);
+    const calls = setupMockProxy(proxyResult);
 
     const ctx: ToolContext = {
       ...makeContext(),
-      hostBashProxy: proxy as unknown as ToolContext["hostBashProxy"],
     };
 
     const result = await hostShellTool.execute({ command: "echo \0evil" }, ctx);
@@ -810,11 +791,10 @@ describe("host_bash — proxy delegation", () => {
       content: "proxied",
       isError: false,
     };
-    const { proxy, calls } = makeMockProxy(proxyResult);
+    const calls = setupMockProxy(proxyResult);
 
     const ctx: ToolContext = {
       ...makeContext(),
-      hostBashProxy: proxy as unknown as ToolContext["hostBashProxy"],
     };
 
     const result = await hostShellTool.execute(
@@ -828,24 +808,12 @@ describe("host_bash — proxy delegation", () => {
   });
 
   test("falls back to local execution when proxy is not available", async () => {
-    const unavailableProxy = {
-      isAvailable: () => false,
-      request: async () => {
-        throw new Error("should not be called");
-      },
-      updateSender: () => {},
-      dispose: () => {},
-      resolve: () => {},
-      hasPendingRequest: () => false,
-    };
-
+    // mockProxyAvailable defaults to false, so isAvailable() returns false
     const dir = mkdtempSync(join(tmpdir(), "host-shell-proxy-fallback-"));
     testDirs.push(dir);
 
     const ctx: ToolContext = {
       ...makeContext(),
-      hostBashProxy:
-        unavailableProxy as unknown as ToolContext["hostBashProxy"],
     };
 
     spawnCalls.length = 0;
@@ -894,12 +862,11 @@ describe("host_bash — proxy delegation", () => {
         content: "proxied",
         isError: false,
       };
-      const { proxy, calls } = makeMockProxy(proxyResult);
+      const calls = setupMockProxy(proxyResult);
 
       const ctx: ToolContext = {
         ...makeContext(),
         trustClass: "trusted_contact", // untrusted actor
-        hostBashProxy: proxy as unknown as ToolContext["hostBashProxy"],
       };
 
       const result = await hostShellTool.execute(
@@ -930,12 +897,11 @@ describe("host_bash — proxy delegation", () => {
         content: "proxied",
         isError: false,
       };
-      const { proxy, calls } = makeMockProxy(proxyResult);
+      const calls = setupMockProxy(proxyResult);
 
       const ctx: ToolContext = {
         ...makeContext(),
         trustClass: "guardian", // trusted actor — no lockdown
-        hostBashProxy: proxy as unknown as ToolContext["hostBashProxy"],
       };
 
       const result = await hostShellTool.execute(
@@ -958,7 +924,6 @@ describe("host_bash — proxy delegation", () => {
       ...ROUTING_ENV_KEYS,
       "VELLUM_UNTRUSTED_SHELL",
     ]);
-    process.env.BASE_DATA_DIR = "/tmp/vellum-instance";
     process.env.VELLUM_WORKSPACE_DIR = "/tmp/vellum-instance/.vellum/workspace";
     process.env.VELLUM_DATA_DIR = "/tmp/vellum-instance/.vellum/workspace/data";
     process.env.VELLUM_ENVIRONMENT = "local";
@@ -970,12 +935,11 @@ describe("host_bash — proxy delegation", () => {
         content: "proxied",
         isError: false,
       };
-      const { proxy, calls } = makeMockProxy(proxyResult);
+      const calls = setupMockProxy(proxyResult);
 
       const ctx: ToolContext = {
         ...makeContext(),
         trustClass: "guardian", // trusted actor — no lockdown
-        hostBashProxy: proxy as unknown as ToolContext["hostBashProxy"],
       };
 
       const result = await hostShellTool.execute(
@@ -986,7 +950,6 @@ describe("host_bash — proxy delegation", () => {
       expect(result).toBe(proxyResult);
       expect(calls.length).toBe(1);
       expect(calls[0].input.env).toEqual({
-        BASE_DATA_DIR: "/tmp/vellum-instance",
         VELLUM_WORKSPACE_DIR: "/tmp/vellum-instance/.vellum/workspace",
         VELLUM_DATA_DIR: "/tmp/vellum-instance/.vellum/workspace/data",
         VELLUM_ENVIRONMENT: "local",