@vellumai/assistant 0.7.0 → 0.7.2

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

@@ -1,5 +1,23 @@
-import { afterEach, describe, expect, jest, test } from "bun:test";
-
+import { afterEach, describe, expect, jest, mock, test } from "bun:test";
+
+const sentMessages: unknown[] = [];
+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,
+    listClientsByCapability: (cap: string) =>
+      cap === "host_file" && mockHasClient
+        ? [{ clientId: "mock-client", capabilities: ["host_file"] }]
+        : [],
+    getClientById: (_id: string) => undefined,
+  },
+}));
+
+// Use the REAL pending-interactions module — the proxy self-registers here.
+const pendingInteractions = await import("../runtime/pending-interactions.js");
 const { HostFileProxy } = await import("../daemon/host-file-proxy.js");
 
 // Minimal PNG header
@@ -10,17 +28,18 @@ 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;
+    mockHasClient = false;
+    pendingInteractions.clear();
+    proxy = new (HostFileProxy as any)();
   }
 
   afterEach(() => {
     proxy?.dispose();
+    HostFileProxy.reset();
+    pendingInteractions.clear();
   });
 
   describe("request/resolve lifecycle (happy path)", () => {
@@ -45,7 +64,7 @@ describe("HostFileProxy", () => {
       expect(typeof sent.requestId).toBe("string");
 
       const requestId = sent.requestId as string;
-      expect(proxy.hasPendingRequest(requestId)).toBe(true);
+      expect(pendingInteractions.get(requestId)).toBeDefined();
 
       // Simulate client response
       proxy.resolve(requestId, {
@@ -56,7 +75,7 @@ describe("HostFileProxy", () => {
       const result = await resultPromise;
       expect(result.content).toBe("file contents here");
       expect(result.isError).toBe(false);
-      expect(proxy.hasPendingRequest(requestId)).toBe(false);
+      expect(pendingInteractions.get(requestId)).toBeUndefined();
     });
 
     test("resolves error responses correctly", async () => {
@@ -185,7 +204,7 @@ describe("HostFileProxy", () => {
 
       const sent = sentMessages[0] as Record<string, unknown>;
       const requestId = sent.requestId as string;
-      expect(proxy.hasPendingRequest(requestId)).toBe(true);
+      expect(pendingInteractions.get(requestId)).toBeDefined();
 
       // Resolve to avoid test hanging (actual 30s timeout too long for test)
       proxy.resolve(requestId, {
@@ -213,14 +232,14 @@ describe("HostFileProxy", () => {
 
       const sent = sentMessages[0] as Record<string, unknown>;
       const requestId = sent.requestId as string;
-      expect(proxy.hasPendingRequest(requestId)).toBe(true);
+      expect(pendingInteractions.get(requestId)).toBeDefined();
 
       controller.abort();
 
       const result = await resultPromise;
       expect(result.content).toBe("Aborted");
       expect(result.isError).toBe(true);
-      expect(proxy.hasPendingRequest(requestId)).toBe(false);
+      expect(pendingInteractions.get(requestId)).toBeUndefined();
     });
 
     test("sends host_file_cancel to client on abort", async () => {
@@ -271,24 +290,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", () => {
@@ -305,11 +317,11 @@ describe("HostFileProxy", () => {
 
       const sent = sentMessages[0] as Record<string, unknown>;
       const requestId = sent.requestId as string;
-      expect(proxy.hasPendingRequest(requestId)).toBe(true);
+      expect(pendingInteractions.get(requestId)).toBeDefined();
 
       proxy.dispose();
 
-      expect(proxy.hasPendingRequest(requestId)).toBe(false);
+      expect(pendingInteractions.get(requestId)).toBeUndefined();
       expect(resultPromise).rejects.toThrow("Host file proxy disposed");
     });
 
@@ -373,35 +385,7 @@ describe("HostFileProxy", () => {
         isError: false,
       });
 
-      expect(proxy.hasPendingRequest(requestId)).toBe(false);
-    });
-  });
-
-  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;
+      expect(pendingInteractions.get(requestId)).toBeUndefined();
     });
   });
 
@@ -469,7 +453,10 @@ describe("HostFileProxy", () => {
 
       const requestId = (sentMessages[0] as Record<string, unknown>)
         .requestId as string;
-      proxy.resolve(requestId, { content: "file contents", isError: false });
+      proxy.resolve(requestId, {
+        content: "file contents",
+        isError: false,
+      });
       await resultPromise;
 
       // Listener is detached after normal completion.
@@ -500,7 +487,7 @@ describe("HostFileProxy", () => {
 
         const requestId = (sentMessages[0] as Record<string, unknown>)
           .requestId as string;
-        expect(proxy.hasPendingRequest(requestId)).toBe(true);
+        expect(pendingInteractions.get(requestId)).toBeDefined();
 
         // Advance past the 30s internal timeout.
         jest.advanceTimersByTime(31 * 1000);
@@ -508,7 +495,7 @@ describe("HostFileProxy", () => {
         const result = await resultPromise;
         expect(result.isError).toBe(true);
         expect(result.content).toContain("Host file proxy timed out");
-        expect(proxy.hasPendingRequest(requestId)).toBe(false);
+        expect(pendingInteractions.get(requestId)).toBeUndefined();
 
         // Listener is detached after the timer fires.
         expect(spy.removeCalls).toEqual(["abort"]);
@@ -522,49 +509,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", () => {
-    test("fires on abort", async () => {
-      const resolvedIds: string[] = [];
-      setup((id) => resolvedIds.push(id));
+  describe("pendingInteractions cleanup", () => {
+    test("cleans up on abort", async () => {
+      setup();
 
       const controller = new AbortController();
       const resultPromise = proxy.request(
@@ -578,30 +525,23 @@ describe("HostFileProxy", () => {
 
       const sent = sentMessages[0] as Record<string, unknown>;
       const requestId = sent.requestId as string;
+      expect(pendingInteractions.get(requestId)).toBeDefined();
 
       controller.abort();
       await resultPromise;
 
-      expect(resolvedIds).toEqual([requestId]);
+      expect(pendingInteractions.get(requestId)).toBeUndefined();
     });
 
-    test("fires for each pending request on dispose", () => {
-      const resolvedIds: string[] = [];
-      setup((id) => resolvedIds.push(id));
+    test("cleans up for each pending request on dispose", () => {
+      setup();
 
-      // Create two pending requests and catch rejections from dispose
       const p1 = proxy.request(
-        {
-          operation: "read",
-          path: "/tmp/a.txt",
-        },
+        { operation: "read", path: "/tmp/a.txt" },
         "session-1",
       );
       const p2 = proxy.request(
-        {
-          operation: "read",
-          path: "/tmp/b.txt",
-        },
+        { operation: "read", path: "/tmp/b.txt" },
         "session-1",
       );
       p1.catch(() => {}); // Expected rejection on dispose
@@ -611,17 +551,17 @@ describe("HostFileProxy", () => {
         (m) => m.requestId as string,
       );
       expect(ids).toHaveLength(2);
+      expect(pendingInteractions.get(ids[0])).toBeDefined();
+      expect(pendingInteractions.get(ids[1])).toBeDefined();
 
       proxy.dispose();
 
-      expect(resolvedIds).toHaveLength(2);
-      expect(resolvedIds).toContain(ids[0]);
-      expect(resolvedIds).toContain(ids[1]);
+      expect(pendingInteractions.get(ids[0])).toBeUndefined();
+      expect(pendingInteractions.get(ids[1])).toBeUndefined();
     });
 
-    test("does not fire on normal client-initiated resolve", async () => {
-      const resolvedIds: string[] = [];
-      setup((id) => resolvedIds.push(id));
+    test("cleans up on normal client-initiated resolveResult", async () => {
+      setup();
 
       const resultPromise = proxy.request(
         {
@@ -633,15 +573,15 @@ describe("HostFileProxy", () => {
 
       const sent = sentMessages[0] as Record<string, unknown>;
       const requestId = sent.requestId as string;
+      expect(pendingInteractions.get(requestId)).toBeDefined();
 
-      // Normal resolve from client — should NOT trigger onInternalResolve
       proxy.resolve(requestId, {
         content: "file contents",
         isError: false,
       });
 
       await resultPromise;
-      expect(resolvedIds).toEqual([]);
+      expect(pendingInteractions.get(requestId)).toBeUndefined();
     });
   });
 });

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(
@@ -283,4 +304,21 @@ describe("host_file_read image support", () => {
     expect(result.content).toContain("2  second line");
     expect((result as any).contentBlocks).toBeUndefined();
   });
+
+  test("passes target_client_id to HostFileProxy.instance.request", async () => {
+    const capturedInputs: HostFileInput[] = [];
+    mockFileProxyAvailable = true;
+    mockFileProxyRequestFn = async (input) => {
+      capturedInputs.push(input);
+      return { content: "proxied", isError: false };
+    };
+
+    await hostFileReadTool.execute(
+      { path: "/host/notes.txt", target_client_id: "client-x" },
+      makeContext(),
+    );
+
+    expect(capturedInputs).toHaveLength(1);
+    expect(capturedInputs[0].targetClientId).toBe("client-x");
+  });
 });