@vellumai/assistant 0.7.0 → 0.7.2

package/src/__tests__/cu-unified-flow.test.ts

@@ -5,11 +5,31 @@
  * point between the agent loop and the HostCuProxy.
  */
 
-import { afterEach, describe, expect, test } from "bun:test";
-
-import type { SurfaceConversationContext } from "../daemon/conversation-surfaces.js";
-import { surfaceProxyResolver } from "../daemon/conversation-surfaces.js";
-import { HostCuProxy } from "../daemon/host-cu-proxy.js";
+import { afterEach, describe, expect, mock, test } from "bun:test";
+
+const sentMessages: unknown[] = [];
+let mockHasClient = true; // Default to true for CU unified flow tests
+let mockCuClients: Array<{ clientId: string; capabilities: string[] }> = [
+  { clientId: "mock-client-1", capabilities: ["host_cu"] },
+];
+
+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,
+    listClientsByCapability: (cap: string) =>
+      cap === "host_cu" ? mockCuClients : [],
+    getClientById: (id: string) =>
+      mockCuClients.find((c) => c.clientId === id) ?? null,
+  },
+}));
+
+const { surfaceProxyResolver } =
+  await import("../daemon/conversation-surfaces.js");
+const { HostCuProxy } = await import("../daemon/host-cu-proxy.js");
+type SurfaceConversationContext =
+  import("../daemon/conversation-surfaces.js").SurfaceConversationContext;
 
 // ---------------------------------------------------------------------------
 // Test helpers
@@ -20,7 +40,7 @@ import { HostCuProxy } from "../daemon/host-cu-proxy.js";
  * Only the fields required by the CU routing path are populated.
  */
 function buildMockContext(
-  hostCuProxy?: HostCuProxy,
+  hostCuProxy?: InstanceType<typeof HostCuProxy>,
 ): SurfaceConversationContext {
   return {
     conversationId: "test-session",
@@ -47,15 +67,13 @@ function buildMockContext(
 // ---------------------------------------------------------------------------
 
 describe("surfaceProxyResolver — CU tool routing", () => {
-  let sentMessages: unknown[];
-  let proxy: HostCuProxy;
+  let proxy: InstanceType<typeof HostCuProxy>;
 
   function setupProxy(maxSteps?: number): SurfaceConversationContext {
-    sentMessages = [];
-    const sendToClient = (msg: unknown) => sentMessages.push(msg);
-    proxy = new HostCuProxy(sendToClient as never, undefined, maxSteps);
-    // Mark client as connected so requests are sent
-    proxy.updateSender(sendToClient as never, true);
+    sentMessages.length = 0;
+    mockHasClient = true;
+    mockCuClients = [{ clientId: "mock-client-1", capabilities: ["host_cu"] }];
+    proxy = new HostCuProxy(maxSteps);
     return buildMockContext(proxy);
   }
 
@@ -93,9 +111,8 @@ describe("surfaceProxyResolver — CU tool routing", () => {
     });
 
     test("returns error when proxy exists but client not connected", async () => {
-      const sendToClient = () => {};
-      const proxyObj = new HostCuProxy(sendToClient as never);
-      // Default clientConnected is false — do NOT call updateSender with true
+      mockHasClient = false;
+      const proxyObj = new HostCuProxy();
       const ctx = buildMockContext(proxyObj);
       const result = await surfaceProxyResolver(ctx, "computer_use_click", {
         element_id: 1,
@@ -222,7 +239,7 @@ describe("surfaceProxyResolver — CU tool routing", () => {
 
       // Simulate client resolving with observation
       const requestId = sent.requestId as string;
-      proxy.resolve(requestId, {
+      proxy.processObservation(requestId, {
         axTree: "SubmitButton [1]\nTextField [2]",
         executionResult: "Clicked element 42",
       });
@@ -248,7 +265,7 @@ describe("surfaceProxyResolver — CU tool routing", () => {
       expect(sent.type).toBe("host_cu_request");
       expect(sent.toolName).toBe("computer_use_screenshot");
 
-      proxy.resolve(sent.requestId as string, {
+      proxy.processObservation(sent.requestId as string, {
         axTree: "Window [1]",
         screenshot: "base64screenshot",
         screenshotWidthPx: 1920,
@@ -285,7 +302,7 @@ describe("surfaceProxyResolver — CU tool routing", () => {
         reasoning: "Type into search box",
       });
 
-      proxy.resolve(sent.requestId as string, {
+      proxy.processObservation(sent.requestId as string, {
         axTree: "SearchBox [1] value='Hello world'",
         executionResult: "Typed text",
       });
@@ -309,7 +326,7 @@ describe("surfaceProxyResolver — CU tool routing", () => {
         reasoning: "Check what's on screen",
       });
       const sent1 = sentMessages[0] as Record<string, unknown>;
-      proxy.resolve(sent1.requestId as string, {
+      proxy.processObservation(sent1.requestId as string, {
         axTree: "LoginButton [1]\nUsernameField [2]",
       });
       const r1 = await p1;
@@ -323,7 +340,7 @@ describe("surfaceProxyResolver — CU tool routing", () => {
         reasoning: "Click login button",
       });
       const sent2 = sentMessages[1] as Record<string, unknown>;
-      proxy.resolve(sent2.requestId as string, {
+      proxy.processObservation(sent2.requestId as string, {
         axTree: "PasswordField [1]\nSubmitButton [2]",
         axDiff: "+ PasswordField [1]\n+ SubmitButton [2]\n- LoginButton [1]",
         executionResult: "Clicked element 1",
@@ -353,6 +370,168 @@ describe("surfaceProxyResolver — CU tool routing", () => {
   // Step limit enforced through resolver
   // -------------------------------------------------------------------------
 
+  // -------------------------------------------------------------------------
+  // Multi-client ambiguity guard
+  // -------------------------------------------------------------------------
+
+  describe("multi-client ambiguity guard", () => {
+    test("returns error when multiple CU clients connected and no target_client_id given", async () => {
+      const ctx = setupProxy();
+      mockCuClients = [
+        { clientId: "client-a", capabilities: ["host_cu"] },
+        { clientId: "client-b", capabilities: ["host_cu"] },
+      ];
+
+      const result = await surfaceProxyResolver(ctx, "computer_use_click", {
+        element_id: 1,
+        reasoning: "click",
+      });
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain("multiple clients support host_cu");
+      expect(result.content).toContain("target_client_id");
+      // No message should have been dispatched
+      expect(sentMessages).toHaveLength(0);
+    });
+
+    test("proceeds when multiple clients connected and target_client_id is given", async () => {
+      const ctx = setupProxy();
+      mockCuClients = [
+        { clientId: "client-a", capabilities: ["host_cu"] },
+        { clientId: "client-b", capabilities: ["host_cu"] },
+      ];
+
+      const resultPromise = surfaceProxyResolver(ctx, "computer_use_click", {
+        element_id: 1,
+        reasoning: "click",
+        target_client_id: "client-a",
+      });
+
+      // Should have dispatched the request
+      expect(sentMessages).toHaveLength(1);
+      const sent = sentMessages[0] as Record<string, unknown>;
+      expect(sent.type).toBe("host_cu_request");
+      expect(sent.targetClientId).toBe("client-a");
+
+      proxy.processObservation(sent.requestId as string, { axTree: "ok" });
+      const result = await resultPromise;
+      expect(result.isError).toBe(false);
+    });
+
+    test("proceeds normally when exactly one CU client is connected", async () => {
+      const ctx = setupProxy();
+      // mockCuClients already has 1 entry from setupProxy
+
+      const resultPromise = surfaceProxyResolver(ctx, "computer_use_click", {
+        element_id: 2,
+        reasoning: "safe click",
+      });
+
+      expect(sentMessages).toHaveLength(1);
+      const sent = sentMessages[0] as Record<string, unknown>;
+      expect(sent.type).toBe("host_cu_request");
+
+      proxy.processObservation(sent.requestId as string, { axTree: "ok" });
+      const result = await resultPromise;
+      expect(result.isError).toBe(false);
+    });
+
+    test("multi-client guard does not apply to terminal tools (computer_use_done)", async () => {
+      const ctx = setupProxy();
+      mockCuClients = [
+        { clientId: "client-a", capabilities: ["host_cu"] },
+        { clientId: "client-b", capabilities: ["host_cu"] },
+      ];
+
+      // Terminal tools short-circuit before the ambiguity check
+      const result = await surfaceProxyResolver(ctx, "computer_use_done", {
+        summary: "all done",
+      });
+
+      expect(result.isError).toBe(false);
+      expect(result.content).toBe("all done");
+      expect(sentMessages).toHaveLength(0);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // targetClientId validation (lives at resolver layer so step count and
+  // action history are not mutated when validation rejects the request).
+  // -------------------------------------------------------------------------
+
+  describe("targetClientId validation", () => {
+    test("returns fast error when targetClientId does not match any connected client", async () => {
+      const ctx = setupProxy();
+      mockCuClients = [{ clientId: "real-client", capabilities: ["host_cu"] }];
+      const stepCountBefore = proxy.stepCount;
+
+      const result = await surfaceProxyResolver(ctx, "computer_use_click", {
+        element_id: 1,
+        reasoning: "click",
+        target_client_id: "nonexistent-client",
+      });
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain("nonexistent-client");
+      expect(result.content).toContain("host_cu");
+      // Critical: validation must run BEFORE recordAction. stepCount and
+      // actionHistory must be unchanged when rejection fires — otherwise
+      // every invalid target_client_id burns a step and leaves a ghost
+      // entry the LLM can reason about.
+      expect(proxy.stepCount).toBe(stepCountBefore);
+      expect(proxy.actionHistory).toHaveLength(0);
+      expect(sentMessages).toHaveLength(0);
+    });
+
+    test("returns fast error when targetClientId points to a client without host_cu capability", async () => {
+      const ctx = setupProxy();
+      mockCuClients = [
+        { clientId: "no-cu-client", capabilities: ["host_bash"] }, // bash, not cu
+      ];
+      const stepCountBefore = proxy.stepCount;
+
+      const result = await surfaceProxyResolver(ctx, "computer_use_click", {
+        element_id: 1,
+        reasoning: "click",
+        target_client_id: "no-cu-client",
+      });
+
+      expect(result.isError).toBe(true);
+      expect(result.content).toContain("no-cu-client");
+      expect(result.content).toContain("host_cu");
+      // No step burned, no ghost in history.
+      expect(proxy.stepCount).toBe(stepCountBefore);
+      expect(proxy.actionHistory).toHaveLength(0);
+      expect(sentMessages).toHaveLength(0);
+    });
+
+    test("dispatches and records action when targetClientId is valid", async () => {
+      const ctx = setupProxy();
+      mockCuClients = [
+        { clientId: "cu-client", capabilities: ["host_cu"] },
+        { clientId: "client-b", capabilities: ["host_cu"] }, // would otherwise trip ambiguity guard
+      ];
+
+      const resultPromise = surfaceProxyResolver(ctx, "computer_use_click", {
+        element_id: 5,
+        reasoning: "click",
+        target_client_id: "cu-client",
+      });
+
+      expect(sentMessages).toHaveLength(1);
+      const sent = sentMessages[0] as Record<string, unknown>;
+      expect(sent.type).toBe("host_cu_request");
+      expect(sent.targetClientId).toBe("cu-client");
+      // recordAction did fire on the success path.
+      expect(proxy.stepCount).toBe(1);
+      expect(proxy.actionHistory).toHaveLength(1);
+
+      proxy.processObservation(sent.requestId as string, { axTree: "ok" });
+      const result = await resultPromise;
+      expect(result.isError).toBe(false);
+    });
+  });
+
   describe("step limit enforcement through resolver", () => {
     test("rejects action tools when step limit exceeded", async () => {
       const ctx = setupProxy(2); // maxSteps = 2
@@ -406,7 +585,7 @@ describe("surfaceProxyResolver — CU tool routing", () => {
       });
 
       const sent = sentMessages[0] as Record<string, unknown>;
-      proxy.resolve(sent.requestId as string, {
+      proxy.processObservation(sent.requestId as string, {
         executionError: "Element 999 not found in AX tree",
         axTree: "Window [1]",
       });
@@ -435,7 +614,7 @@ describe("surfaceProxyResolver — CU tool routing", () => {
       expect(sent.reasoning).toBe("Submit the form");
 
       // Resolve to avoid unhandled rejection on dispose
-      proxy.resolve(sent.requestId as string, { axTree: "..." });
+      proxy.processObservation(sent.requestId as string, { axTree: "..." });
       await resultPromise;
     });
 
@@ -452,7 +631,7 @@ describe("surfaceProxyResolver — CU tool routing", () => {
 
       // Resolve to avoid hanging
       const sent = sentMessages[0] as Record<string, unknown>;
-      proxy.resolve(sent.requestId as string, { axTree: "..." });
+      proxy.processObservation(sent.requestId as string, { axTree: "..." });
     });
   });
 
@@ -498,7 +677,7 @@ describe("surfaceProxyResolver — CU tool routing", () => {
         reasoning: "first",
       });
       const s1 = sentMessages[0] as Record<string, unknown>;
-      proxy.resolve(s1.requestId as string, { axTree: "A" });
+      proxy.processObservation(s1.requestId as string, { axTree: "A" });
       await p1;
       expect(proxy.stepCount).toBe(1);
 
@@ -508,7 +687,7 @@ describe("surfaceProxyResolver — CU tool routing", () => {
         reasoning: "second",
       });
       const s2 = sentMessages[1] as Record<string, unknown>;
-      proxy.resolve(s2.requestId as string, { axTree: "B" });
+      proxy.processObservation(s2.requestId as string, { axTree: "B" });
       await p2;
       expect(proxy.stepCount).toBe(2);
 
@@ -519,7 +698,7 @@ describe("surfaceProxyResolver — CU tool routing", () => {
         reasoning: "third",
       });
       const s3 = sentMessages[2] as Record<string, unknown>;
-      proxy.resolve(s3.requestId as string, { axTree: "C" });
+      proxy.processObservation(s3.requestId as string, { axTree: "C" });
       await p3;
       expect(proxy.stepCount).toBe(3);
 

package/src/__tests__/daemon-assistant-events.test.ts

@@ -33,11 +33,10 @@ describe("buildAssistantEvent", () => {
       conversationId: "sess_1",
       text: "hi",
     };
-    const event = buildAssistantEvent("ast_1", msg, "sess_1");
+    const event = buildAssistantEvent(msg, "sess_1");
 
     expect(typeof event.id).toBe("string");
     expect(event.id.length).toBeGreaterThan(0);
-    expect(event.assistantId).toBe("ast_1");
     expect(event.conversationId).toBe("sess_1");
     expect(event.message).toBe(msg);
     expect(typeof event.emittedAt).toBe("string");
@@ -46,14 +45,14 @@ describe("buildAssistantEvent", () => {
 
   test("generates unique ids for each call", () => {
     const msg: ServerMessage = { type: "pong" };
-    const a = buildAssistantEvent("ast", msg);
-    const b = buildAssistantEvent("ast", msg);
+    const a = buildAssistantEvent(msg);
+    const b = buildAssistantEvent(msg);
     expect(a.id).not.toBe(b.id);
   });
 
   test("conversationId is undefined when omitted", () => {
     const msg: ServerMessage = { type: "pong" };
-    const event = buildAssistantEvent("ast", msg);
+    const event = buildAssistantEvent(msg);
     expect(event.conversationId).toBeUndefined();
   });
 });
@@ -65,8 +64,11 @@ describe("daemon send → one mirrored assistant event", () => {
     const hub = new AssistantEventHub();
     const received: AssistantEvent[] = [];
 
-    hub.subscribe({ assistantId: "ast_test" }, (e) => {
-      received.push(e);
+    hub.subscribe({
+      type: "process",
+      callback: (e) => {
+        received.push(e);
+      },
     });
 
     const msg: ServerMessage = {
@@ -74,11 +76,10 @@ describe("daemon send → one mirrored assistant event", () => {
       conversationId: "sess_a",
       text: "hello",
     };
-    const event = buildAssistantEvent("ast_test", msg, "sess_a");
+    const event = buildAssistantEvent(msg, "sess_a");
     await hub.publish(event);
 
     expect(received).toHaveLength(1);
-    expect(received[0].assistantId).toBe("ast_test");
     expect(received[0].conversationId).toBe("sess_a");
     expect(received[0].message.type).toBe("assistant_text_delta");
   });
@@ -87,12 +88,15 @@ describe("daemon send → one mirrored assistant event", () => {
     const hub = new AssistantEventHub();
     const received: AssistantEvent[] = [];
 
-    hub.subscribe({ assistantId: "ast_test" }, (e) => {
-      received.push(e);
+    hub.subscribe({
+      type: "process",
+      callback: (e) => {
+        received.push(e);
+      },
     });
 
     const msg: ServerMessage = { type: "pong" }; // no conversationId field
-    const event = buildAssistantEvent("ast_test", msg, "sess_explicit");
+    const event = buildAssistantEvent(msg, "sess_explicit");
 
     await hub.publish(event);
 
@@ -107,11 +111,17 @@ describe("daemon broadcast → one mirrored event per message (not per socket)",
     const received: AssistantEvent[] = [];
 
     // Two subscribers (simulating two wire clients)
-    hub.subscribe({ assistantId: "ast_bc" }, (e) => {
-      received.push(e);
+    hub.subscribe({
+      type: "process",
+      callback: (e) => {
+        received.push(e);
+      },
     });
-    hub.subscribe({ assistantId: "ast_bc" }, (e) => {
-      received.push(e);
+    hub.subscribe({
+      type: "process",
+      callback: (e) => {
+        received.push(e);
+      },
     });
 
     // Simulate broadcast: server calls publishAssistantEvent once
@@ -119,7 +129,7 @@ describe("daemon broadcast → one mirrored event per message (not per socket)",
       type: "message_complete",
       conversationId: "sess_b",
     };
-    const event = buildAssistantEvent("ast_bc", msg, "sess_b");
+    const event = buildAssistantEvent(msg, "sess_b");
     await hub.publish(event);
 
     // Both hub subscribers receive it (fanout), but only ONE event was published
@@ -130,8 +140,11 @@ describe("daemon broadcast → one mirrored event per message (not per socket)",
     const hub = new AssistantEventHub();
     const publishedEvents: AssistantEvent[] = [];
 
-    hub.subscribe({ assistantId: "ast_bc" }, (e) => {
-      publishedEvents.push(e);
+    hub.subscribe({
+      type: "process",
+      callback: (e) => {
+        publishedEvents.push(e);
+      },
     });
 
     const msgA: ServerMessage = {
@@ -145,8 +158,8 @@ describe("daemon broadcast → one mirrored event per message (not per socket)",
     };
 
     // Simulate: one broadcast + one single send
-    await hub.publish(buildAssistantEvent("ast_bc", msgA, "s1"));
-    await hub.publish(buildAssistantEvent("ast_bc", msgB, "s1"));
+    await hub.publish(buildAssistantEvent(msgA, "s1"));
+    await hub.publish(buildAssistantEvent(msgB, "s1"));
 
     expect(publishedEvents).toHaveLength(2);
     expect(publishedEvents[0].message.type).toBe("assistant_text_delta");

package/src/__tests__/daemon-credential-client.test.ts

@@ -1,16 +1,20 @@
 import { describe, expect, mock, test } from "bun:test";
 
 /**
- * Mock only the IPC client (to simulate daemon-unreachable) and the logger.
+ * Mock the IPC client and logger. The IPC mock returns configurable
+ * responses so we can test success, failure, and unreachable paths.
+ *
  * Do NOT mock secure-keys.js — daemon-credential-client falls back to it
  * for writes/deletes when the daemon is unreachable.
  */
 
+let _ipcResponse: { ok: boolean; result?: unknown; error?: string } = {
+  ok: false,
+  error: "Could not connect to assistant daemon. Is it running?",
+};
+
 mock.module("../ipc/cli-client.js", () => ({
-  cliIpcCall: async () => ({
-    ok: false,
-    error: "Could not connect to assistant daemon. Is it running?",
-  }),
+  cliIpcCall: async () => _ipcResponse,
 }));
 
 mock.module("../util/logger.js", () => ({
@@ -20,19 +24,100 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
-import { setSecureKeyViaDaemon } from "../cli/lib/daemon-credential-client.js";
+import {
+  deleteSecureKeyViaDaemon,
+  setSecureKeyViaDaemon,
+} from "../cli/lib/daemon-credential-client.js";
+import { credentialKey } from "../security/credential-key.js";
 import { getSecureKeyAsync } from "../security/secure-keys.js";
 
-describe("daemon credential writes (daemon unreachable)", () => {
-  test("falls back to direct write when daemon is not running", async () => {
-    const result = await setSecureKeyViaDaemon(
-      "api_key",
-      "test-provider",
-      "test-value",
-    );
-    expect(result).toBe(true);
-
-    const readBack = await getSecureKeyAsync("test-provider");
-    expect(readBack).toBe("test-value");
+describe("daemon credential client", () => {
+  describe("set — daemon unreachable", () => {
+    test("falls back to direct write when daemon is not running", async () => {
+      _ipcResponse = {
+        ok: false,
+        error: "Could not connect to assistant daemon. Is it running?",
+      };
+
+      const result = await setSecureKeyViaDaemon(
+        "api_key",
+        "test-provider",
+        "test-value",
+      );
+      expect(result.ok).toBe(true);
+
+      const readBack = await getSecureKeyAsync(
+        credentialKey("test-provider", "api_key"),
+      );
+      expect(readBack).toBe("test-value");
+    });
+  });
+
+  describe("set — daemon error", () => {
+    test("surfaces daemon error message on IPC failure", async () => {
+      _ipcResponse = {
+        ok: false,
+        error:
+          "Failed to store credential in secure storage (backend: ces-rpc)",
+      };
+
+      const result = await setSecureKeyViaDaemon(
+        "credential",
+        "vellum:webhook_secret",
+        "some-value",
+      );
+      expect(result.ok).toBe(false);
+      expect(result.error).toBe(
+        "Failed to store credential in secure storage (backend: ces-rpc)",
+      );
+    });
+
+    test("surfaces validation error from daemon result", async () => {
+      _ipcResponse = {
+        ok: true,
+        result: {
+          success: false,
+          error: "API key validation failed: invalid format",
+        },
+      };
+
+      const result = await setSecureKeyViaDaemon(
+        "api_key",
+        "anthropic",
+        "bad-key",
+      );
+      expect(result.ok).toBe(false);
+      expect(result.error).toBe("API key validation failed: invalid format");
+    });
+  });
+
+  describe("delete — daemon error", () => {
+    test("surfaces daemon error message", async () => {
+      _ipcResponse = {
+        ok: false,
+        error: "Credential store is unreachable",
+      };
+
+      const result = await deleteSecureKeyViaDaemon(
+        "credential",
+        "vellum:temp_cred",
+      );
+      expect(result.result).toBe("error");
+      expect(result.error).toBe("Credential store is unreachable");
+    });
+
+    test("returns not-found for 404 errors", async () => {
+      _ipcResponse = {
+        ok: false,
+        error: "Credential not found (404)",
+      };
+
+      const result = await deleteSecureKeyViaDaemon(
+        "credential",
+        "vellum:missing",
+      );
+      expect(result.result).toBe("not-found");
+      expect(result.error).toBeUndefined();
+    });
   });
 });