@vellumai/assistant 0.7.0 → 0.7.1

package/src/__tests__/host-browser-ws-events-e2e.test.ts

@@ -68,22 +68,30 @@ import {
   type ForwardedCdpEvent,
   onCdpEvent,
 } from "../browser-session/index.js";
+import { HostBrowserProxy } from "../daemon/host-browser-proxy.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
+import { assistantEventHub } from "../runtime/assistant-event-hub.js";
+import { mintToken } from "../runtime/auth/token-service.js";
 import {
   mintHostBrowserCapability,
   resetCapabilityTokenSecretForTests,
   setCapabilityTokenSecretForTests,
 } from "../runtime/capability-tokens.js";
-import {
-  __resetChromeExtensionRegistryForTests,
-  getChromeExtensionRegistry,
-} from "../runtime/chrome-extension-registry.js";
 import { RuntimeHttpServer } from "../runtime/http-server.js";
-import * as pendingInteractions from "../runtime/pending-interactions.js";
 
 initializeDb();
 
+function mintSseToken(guardianId: string): string {
+  return mintToken({
+    aud: "vellum-daemon",
+    sub: `actor:self:${guardianId}`,
+    scope_profile: "actor_client_v1",
+    policy_epoch: 1,
+    ttlSeconds: 3600,
+  });
+}
+
 // ── Helpers ─────────────────────────────────────────────────────────
 
 async function waitFor(
@@ -102,11 +110,12 @@ async function waitFor(
 }
 
 async function waitForRegistryEntry(
-  guardianId: string,
+  _guardianId: string,
   timeoutMs = 2000,
 ): Promise<void> {
   await waitFor(
-    () => getChromeExtensionRegistry().get(guardianId) !== undefined,
+    () =>
+      assistantEventHub.getMostRecentClientByCapability("host_browser") != null,
     timeoutMs,
   );
 }
@@ -124,8 +133,7 @@ describe("host_browser WS event + invalidation e2e", () => {
     const db = getDb();
     db.run("DELETE FROM contact_channels");
     db.run("DELETE FROM contacts");
-    pendingInteractions.clear();
-    __resetChromeExtensionRegistryForTests();
+    HostBrowserProxy.reset();
     __resetBrowserSessionEventsForTests();
 
     // Pick a non-colliding port in the same band as the other
@@ -139,8 +147,7 @@ describe("host_browser WS event + invalidation e2e", () => {
 
   afterEach(async () => {
     await server?.stop();
-    pendingInteractions.clear();
-    __resetChromeExtensionRegistryForTests();
+    HostBrowserProxy.reset();
     __resetBrowserSessionEventsForTests();
     resetCapabilityTokenSecretForTests();
   });
@@ -154,6 +161,7 @@ describe("host_browser WS event + invalidation e2e", () => {
     const mockExt = createMockChromeExtension({
       runtimeBaseUrl,
       token,
+      sseToken: mintSseToken(guardianId),
       resultTransport: "ws",
     });
     await mockExt.start();
@@ -195,6 +203,7 @@ describe("host_browser WS event + invalidation e2e", () => {
     const mockExt = createMockChromeExtension({
       runtimeBaseUrl,
       token,
+      sseToken: mintSseToken(guardianId),
       resultTransport: "ws",
     });
     await mockExt.start();
@@ -224,6 +233,7 @@ describe("host_browser WS event + invalidation e2e", () => {
     const mockExt = createMockChromeExtension({
       runtimeBaseUrl,
       token,
+      sseToken: mintSseToken(guardianId),
       resultTransport: "ws",
     });
     await mockExt.start();
@@ -301,37 +311,21 @@ describe("host_browser WS event + invalidation e2e", () => {
     const mockExt = createMockChromeExtension({
       runtimeBaseUrl,
       token,
+      sseToken: mintSseToken(guardianId),
       resultTransport: "ws",
     });
     await mockExt.start();
     await mockExt.waitForConnection();
     await waitForRegistryEntry(guardianId);
 
-    // Grab the initial timestamps so we can verify that keepalive
-    // bumps lastKeepaliveAt but NOT lastActiveAt (routing field).
-    const connBefore = getChromeExtensionRegistry().get(guardianId)!;
-    const lastActiveBefore = connBefore.lastActiveAt;
-
-    // Small delay to ensure Date.now() advances at least 1ms.
-    await new Promise((r) => setTimeout(r, 15));
-
     // Send a keepalive frame (the extension sends these periodically
     // to prevent the runtime from considering the connection stale).
     // The frame may contain extra keys (e.g. timestamp) that the
     // runtime should silently ignore (lenient validation).
     mockExt.sendRaw(JSON.stringify({ type: "keepalive", ts: Date.now() }));
 
-    // Wait for the touch to propagate — touch() updates
-    // lastKeepaliveAt (not lastActiveAt) to avoid routing interference.
-    await waitFor(() => {
-      const conn = getChromeExtensionRegistry().get(guardianId);
-      return conn !== undefined && (conn.lastKeepaliveAt ?? 0) > 0;
-    });
-
-    const connAfter = getChromeExtensionRegistry().get(guardianId)!;
-    expect(connAfter.lastKeepaliveAt).toBeGreaterThan(0);
-    // lastActiveAt must remain unchanged — keepalives must not affect routing.
-    expect(connAfter.lastActiveAt).toBe(lastActiveBefore);
+    // Small delay to let the keepalive frame process.
+    await new Promise((r) => setTimeout(r, 15));
 
     // Verify the socket is still alive by sending a normal host_browser_event
     // frame after the keepalive — if the socket had been torn down, this
@@ -356,6 +350,7 @@ describe("host_browser WS event + invalidation e2e", () => {
     const mockExt = createMockChromeExtension({
       runtimeBaseUrl,
       token,
+      sseToken: mintSseToken(guardianId),
       resultTransport: "ws",
     });
     await mockExt.start();
@@ -404,6 +399,7 @@ describe("host_browser WS event + invalidation e2e", () => {
     const mockExt = createMockChromeExtension({
       runtimeBaseUrl,
       token,
+      sseToken: mintSseToken(guardianId),
       resultTransport: "ws",
     });
     await mockExt.start();

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

@@ -1,22 +1,38 @@
-import { afterEach, describe, expect, jest, test } from "bun:test";
-
-import { HostCuProxy } from "../daemon/host-cu-proxy.js";
+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_cu" && 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 { HostCuProxy } = await import("../daemon/host-cu-proxy.js");
 
 describe("HostCuProxy", () => {
   let proxy: InstanceType<typeof HostCuProxy>;
-  let sentMessages: unknown[];
-  let sendToClient: (msg: unknown) => void;
-  let resolvedRequestIds: string[];
 
   function setup(maxSteps?: number) {
-    sentMessages = [];
-    resolvedRequestIds = [];
-    sendToClient = (msg: unknown) => sentMessages.push(msg);
-    proxy = new HostCuProxy(
-      sendToClient as never,
-      (requestId: string) => resolvedRequestIds.push(requestId),
-      maxSteps,
-    );
+    sentMessages.length = 0;
+    resolvedInteractionIds.length = 0;
+    mockHasClient = false;
+    proxy = new HostCuProxy(maxSteps);
   }
 
   afterEach(() => {
@@ -888,87 +904,54 @@ describe("HostCuProxy", () => {
   });
 
   // -------------------------------------------------------------------------
-  // sender throws synchronously
+  // pendingInteractions.resolve callback
   // -------------------------------------------------------------------------
 
-  describe("sender throws synchronously", () => {
-    test("rejects the promise, clears pending state and timer, invokes onInternalResolve", async () => {
-      sentMessages = [];
-      resolvedRequestIds = [];
-      const throwingSend = () => {
-        throw new Error("transport down");
-      };
-      proxy = new HostCuProxy(throwingSend as never, (requestId: string) =>
-        resolvedRequestIds.push(requestId),
-      );
+  describe("pendingInteractions.resolve callback", () => {
+    test("fires when abort signal fires", async () => {
+      setup();
 
-      // request() synchronously calls sendToClient inside the Promise
-      // executor. A throw there surfaces as a rejected promise.
+      const controller = new AbortController();
       const resultPromise = proxy.request(
         "computer_use_click",
         { element_id: 1 },
         "session-1",
         1,
+        undefined,
+        controller.signal,
       );
 
-      await expect(resultPromise).rejects.toThrow("transport down");
+      const sent = sentMessages[0] as Record<string, unknown>;
+      const requestId = sent.requestId as string;
 
-      // The internal resolve should fire exactly once as part of cleanup.
-      expect(resolvedRequestIds).toHaveLength(1);
+      controller.abort();
 
-      // 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: unknown) => sentMessages.push(msg)) as never,
-        true,
-      );
-      const okPromise = proxy.request(
-        "computer_use_click",
-        { element_id: 2 },
-        "session-1",
-        2,
-      );
-      expect(sentMessages).toHaveLength(1);
-      const okRequestId = (sentMessages[0] as Record<string, unknown>)
-        .requestId as string;
-      expect(proxy.hasPendingRequest(okRequestId)).toBe(true);
-      proxy.resolve(okRequestId, { axTree: "Button [2]" });
-      const okResult = await okPromise;
-      expect(okResult.isError).toBe(false);
-      expect(okResult.content).toContain("Button [2]");
+      await resultPromise;
+      expect(resolvedInteractionIds).toContain(requestId);
     });
-  });
 
-  // -------------------------------------------------------------------------
-  // onInternalResolve callback
-  // -------------------------------------------------------------------------
-
-  describe("onInternalResolve", () => {
-    test("calls onInternalResolve when abort signal fires", async () => {
+    test("fires on dispose", async () => {
       setup();
 
-      const controller = new AbortController();
       const resultPromise = proxy.request(
         "computer_use_click",
         { element_id: 1 },
         "session-1",
         1,
-        undefined,
-        controller.signal,
       );
 
       const sent = sentMessages[0] as Record<string, unknown>;
       const requestId = sent.requestId as string;
 
-      controller.abort();
+      proxy.dispose();
 
-      await resultPromise;
-      expect(resolvedRequestIds).toContain(requestId);
+      // dispose rejects pending requests — catch to avoid unhandled rejection
+      await resultPromise.catch(() => {});
+
+      expect(resolvedInteractionIds).toContain(requestId);
     });
 
-    test("calls onInternalResolve on dispose", async () => {
+    test("does not fire on normal client-initiated resolve", async () => {
       setup();
 
       const resultPromise = proxy.request(
@@ -981,12 +964,10 @@ describe("HostCuProxy", () => {
       const sent = sentMessages[0] as Record<string, unknown>;
       const requestId = sent.requestId as string;
 
-      proxy.dispose();
-
-      // dispose rejects pending requests — catch to avoid unhandled rejection
-      await resultPromise.catch(() => {});
+      proxy.resolve(requestId, { axTree: "Button [1]" });
 
-      expect(resolvedRequestIds).toContain(requestId);
+      await resultPromise;
+      expect(resolvedInteractionIds).toEqual([]);
     });
   });
 
@@ -995,52 +976,16 @@ describe("HostCuProxy", () => {
   // -------------------------------------------------------------------------
 
   describe("isAvailable", () => {
-    test("returns false by default", () => {
+    test("returns false when no client with host_cu 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_cu capability is connected", () => {
       setup();
-      proxy.updateSender(sendToClient as never, true);
+      mockHasClient = true;
       expect(proxy.isAvailable()).toBe(true);
     });
-
-    test("returns false after updateSender with clientConnected=false", () => {
-      setup();
-      proxy.updateSender(sendToClient as never, true);
-      proxy.updateSender(sendToClient as never, false);
-      expect(proxy.isAvailable()).toBe(false);
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // updateSender
-  // -------------------------------------------------------------------------
-
-  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(
-        "computer_use_click",
-        { element_id: 1 },
-        "session-1",
-        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, {
-        axTree: "Button [1]",
-      });
-
-      await resultPromise;
-    });
   });
 });

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(