@vellumai/assistant 0.7.1 → 0.7.3

package/src/tools/browser/cdp-client/__tests__/factory.test.ts

@@ -119,6 +119,7 @@ let mockSingletonProxy: HostBrowserProxy | null = null;
 /** Default proxy that reports unavailable — used when no test override is set. */
 const unavailableFallback: HostBrowserProxy = {
   isAvailable: () => false,
+  hasExtensionClient: () => false,
   request: () => Promise.reject(new Error("no extension")),
   resolve: () => {},
   hasPendingRequest: () => false,
@@ -161,23 +162,38 @@ function makeContext(
 }
 
 /**
- * Create a fake HostBrowserProxy that reports as available.
+ * Create a fake HostBrowserProxy with a Chrome Extension client connected.
+ * Both isAvailable() and hasExtensionClient() return true.
  */
 function makeAvailableProxy(): HostBrowserProxy {
   return {
     request: mock(async () => ({})),
     isAvailable: () => true,
+    hasExtensionClient: () => true,
+  } as unknown as HostBrowserProxy;
+}
+
+/**
+ * Create a fake HostBrowserProxy where only the macOS SSE bridge is connected
+ * (no Chrome Extension). isAvailable() is true but hasExtensionClient() is false.
+ */
+function makeMacosBridgeOnlyProxy(): HostBrowserProxy {
+  return {
+    request: mock(async () => ({})),
+    isAvailable: () => true,
+    hasExtensionClient: () => false,
   } as unknown as HostBrowserProxy;
 }
 
 /**
  * Create a fake HostBrowserProxy that reports as unavailable
- * (proxy exists but client is disconnected).
+ * (proxy exists but no client of any kind is connected).
  */
 function makeUnavailableProxy(): HostBrowserProxy {
   return {
     request: mock(async () => ({})),
     isAvailable: () => false,
+    hasExtensionClient: () => false,
   } as unknown as HostBrowserProxy;
 }
 
@@ -682,6 +698,22 @@ describe("buildCandidateList", () => {
     expect(candidates[0].kind).toBe("local");
   });
 
+  test("excludes extension candidate when only macOS SSE bridge is connected", () => {
+    // isAvailable() = true but hasExtensionClient() = false: only macOS bridge.
+    // The macOS bridge routes through localhost:9222 on the host, so it must
+    // NOT be included under the "extension" candidate kind.
+    const fakeProxy = makeMacosBridgeOnlyProxy();
+    mockSingletonProxy = fakeProxy;
+    const ctx = makeContext({
+      conversationId: "candidates-macos-bridge-only",
+    });
+
+    const candidates = buildCandidateList(ctx);
+
+    expect(candidates.every((c) => c.kind !== "extension")).toBe(true);
+    expect(candidates[candidates.length - 1].kind).toBe("local");
+  });
+
   test("includes cdp-inspect candidate when enabled in config", () => {
     cdpInspectEnabled = true;
     const ctx = makeContext({ conversationId: "candidates-inspect" });
@@ -1435,7 +1467,7 @@ describe("pinned-mode selection", () => {
       const cdpErr = err as CdpError;
       expect(cdpErr.code).toBe("transport_error");
       expect(cdpErr.message).toContain('Pinned mode "extension" unavailable');
-      expect(cdpErr.message).toContain("no active extension connection");
+      expect(cdpErr.message).toContain("no Chrome Extension connected");
       expect(cdpErr.attemptDiagnostics).toBeDefined();
       expect(cdpErr.attemptDiagnostics).toHaveLength(1);
       expect(cdpErr.attemptDiagnostics![0].candidateKind).toBe("extension");
@@ -1457,7 +1489,7 @@ describe("pinned-mode selection", () => {
     } catch (err) {
       const cdpErr = err as CdpError;
       expect(cdpErr.code).toBe("transport_error");
-      expect(cdpErr.message).toContain("no active extension connection");
+      expect(cdpErr.message).toContain("no Chrome Extension connected");
       expect(cdpErr.attemptDiagnostics![0].stage).toBe("candidate_selection");
     }
   });
@@ -1667,6 +1699,25 @@ describe("buildPinnedCandidateList", () => {
       });
     }
   });
+
+  test("extension mode throws when only macOS SSE bridge is connected", () => {
+    // This is the bug case: isAvailable() = true but hasExtensionClient() = false.
+    // Before the fix, this would build an extension candidate that silently
+    // dispatched to the macOS bridge and failed with a misleading localhost:9222 error.
+    const fakeProxy = makeMacosBridgeOnlyProxy();
+    mockSingletonProxy = fakeProxy;
+    const ctx = makeContext({ conversationId: "bpl-ext-macos-bridge-only" });
+
+    try {
+      buildPinnedCandidateList(ctx, "extension");
+      expect(true).toBe(false); // should not reach
+    } catch (err) {
+      expect(err).toBeInstanceOf(CdpError);
+      const cdpErr = err as CdpError;
+      expect(cdpErr.code).toBe("transport_error");
+      expect(cdpErr.message).toContain("no Chrome Extension connected");
+    }
+  });
 });
 
 // ── Attempt diagnostics & fallback log tests ─────────────────────────────

package/src/tools/browser/cdp-client/cdp-inspect/__tests__/ws-transport.test.ts

@@ -511,14 +511,19 @@ describe("connectCdpWsTransport", () => {
   });
 
   test("addEventListener returns an unsubscribe function", async () => {
+    // Use a sentinel request to gate event emission on the server: the
+    // listener is registered before send() runs, so by the time the server
+    // receives the sentinel and starts emitting events the client listener
+    // is guaranteed to be attached. A bare setTimeout-after-open race is
+    // tight enough to flake on busy CI runners.
     const server = startFakeWsServer({
-      onOpen(ws) {
+      onMessage(ws, frame) {
+        if (frame.method !== "Test.startEvents") return;
+        ws.send(JSON.stringify({ id: frame.id, result: {} }));
+        ws.send(JSON.stringify({ method: "Ev.first", params: {} }));
         setTimeout(() => {
-          ws.send(JSON.stringify({ method: "Ev.first", params: {} }));
-          setTimeout(() => {
-            ws.send(JSON.stringify({ method: "Ev.second", params: {} }));
-          }, 10);
-        }, 5);
+          ws.send(JSON.stringify({ method: "Ev.second", params: {} }));
+        }, 10);
       },
     });
     try {
@@ -528,6 +533,7 @@ describe("connectCdpWsTransport", () => {
           received.push(ev.method);
           if (ev.method === "Ev.first") unsub();
         });
+        await transport.send("Test.startEvents");
         await new Promise((r) => setTimeout(r, 60));
         expect(received).toEqual(["Ev.first"]);
       });

package/src/tools/browser/cdp-client/factory.ts

@@ -187,25 +187,25 @@ export function buildPinnedCandidateList(
 
   switch (mode) {
     case "extension": {
-      const hostBrowserProxy = HostBrowserProxy.instance;
-      if (!hostBrowserProxy.isAvailable()) {
-        throw new CdpError(
-          "transport_error",
-          `Pinned mode "extension" unavailable: no active extension connection`,
-          {
-            attemptDiagnostics: [
-              {
-                candidateKind: "extension",
-                inclusionReason: `pinned mode: extension`,
-                stage: "candidate_selection",
-                errorCode: "transport_error",
-                errorMessage: "no active extension connection",
-              },
-            ],
-          },
-        );
-      }
-      return [
+        const hostBrowserProxy = HostBrowserProxy.instance;
+        if (!hostBrowserProxy.hasExtensionClient()) {
+          throw new CdpError(
+            "transport_error",
+            `Pinned mode "extension" unavailable: no Chrome Extension connected`,
+            {
+              attemptDiagnostics: [
+                {
+                  candidateKind: "extension",
+                  inclusionReason: `pinned mode: extension`,
+                  stage: "candidate_selection",
+                  errorCode: "transport_error",
+                  errorMessage: "no Chrome Extension connected",
+                },
+              ],
+            },
+          );
+        }
+        return [
         {
           kind: "extension",
           reason: "pinned mode: extension",
@@ -291,12 +291,11 @@ export function buildCandidateList(context: ToolContext): BackendCandidate[] {
   const candidates: BackendCandidate[] = [];
   const hostBrowserProxy = HostBrowserProxy.instance;
 
-  // 1. Extension -- preferred when the singleton proxy reports an active
-  //    extension connection is available.
-  if (hostBrowserProxy.isAvailable()) {
+  // 1. Extension -- preferred when a Chrome Extension client is connected.
+  if (hostBrowserProxy.hasExtensionClient()) {
     candidates.push({
       kind: "extension",
-      reason: "extension connected via registry singleton",
+      reason: "Chrome Extension connected via registry singleton",
       create() {
         const client = createExtensionCdpClient(
           hostBrowserProxy,
@@ -314,7 +313,7 @@ export function buildCandidateList(context: ToolContext): BackendCandidate[] {
   } else {
     log.debug(
       { conversationId },
-      "CDP factory: no active extension connection, skipping extension candidate",
+      "CDP factory: no Chrome Extension connected, skipping extension candidate",
     );
   }
 

package/src/tools/browser/cdp-client/index.ts

@@ -1,15 +1,2 @@
-export {
-  type CdpInspectClientOptions,
-  type CdpInspectHelpers,
-} from "./cdp-inspect-client.js";
 export { CdpError, type CdpErrorCode } from "./errors.js";
-export { type GetCdpClientOptions } from "./factory.js";
-export type {
-  AttemptDiagnostic,
-  AttemptStage,
-  BackendCandidate,
-  BrowserMode,
-  CdpClient,
-  CdpClientKind,
-  ScopedCdpClient,
-} from "./types.js";
+export type { CdpClient, CdpClientKind, ScopedCdpClient } from "./types.js";

package/src/tools/computer-use/definitions.ts

@@ -21,12 +21,6 @@ function proxyExecute(): Promise<ToolExecutionResult> {
   );
 }
 
-const activityProperty = {
-  type: "string" as const,
-  description:
-    "Brief non-technical explanation of why this tool is being called",
-};
-
 // ---------------------------------------------------------------------------
 // click (unified - click_type selects single / double / right)
 // ---------------------------------------------------------------------------
@@ -69,7 +63,11 @@ export const computerUseClickTool: Tool = {
             description:
               "Explanation of what you see and why you are clicking here",
           },
-          activity: activityProperty,
+          target_client_id: {
+            type: "string",
+            description:
+              "ID of the specific client to target. Required when multiple clients support host_cu; omit when only one is connected. Obtain IDs from `assistant clients list --capability host_cu`.",
+          },
         },
         required: ["reasoning"],
       },
@@ -106,7 +104,11 @@ export const computerUseTypeTextTool: Tool = {
             type: "string",
             description: "Explanation of what you are typing and why",
           },
-          activity: activityProperty,
+          target_client_id: {
+            type: "string",
+            description:
+              "ID of the specific client to target. Required when multiple clients support host_cu; omit when only one is connected. Obtain IDs from `assistant clients list --capability host_cu`.",
+          },
         },
         required: ["text", "reasoning"],
       },
@@ -144,7 +146,11 @@ export const computerUseKeyTool: Tool = {
             type: "string",
             description: "Explanation of why you are pressing this key",
           },
-          activity: activityProperty,
+          target_client_id: {
+            type: "string",
+            description:
+              "ID of the specific client to target. Required when multiple clients support host_cu; omit when only one is connected. Obtain IDs from `assistant clients list --capability host_cu`.",
+          },
         },
         required: ["key", "reasoning"],
       },
@@ -199,7 +205,11 @@ export const computerUseScrollTool: Tool = {
             type: "string",
             description: "Explanation of why you are scrolling",
           },
-          activity: activityProperty,
+          target_client_id: {
+            type: "string",
+            description:
+              "ID of the specific client to target. Required when multiple clients support host_cu; omit when only one is connected. Obtain IDs from `assistant clients list --capability host_cu`.",
+          },
         },
         required: ["direction", "amount", "reasoning"],
       },
@@ -260,7 +270,11 @@ export const computerUseDragTool: Tool = {
             type: "string",
             description: "Explanation of what you are dragging and why",
           },
-          activity: activityProperty,
+          target_client_id: {
+            type: "string",
+            description:
+              "ID of the specific client to target. Required when multiple clients support host_cu; omit when only one is connected. Obtain IDs from `assistant clients list --capability host_cu`.",
+          },
         },
         required: ["reasoning"],
       },
@@ -296,7 +310,11 @@ export const computerUseWaitTool: Tool = {
             type: "string",
             description: "Explanation of what you are waiting for",
           },
-          activity: activityProperty,
+          target_client_id: {
+            type: "string",
+            description:
+              "ID of the specific client to target. Required when multiple clients support host_cu; omit when only one is connected. Obtain IDs from `assistant clients list --capability host_cu`.",
+          },
         },
         required: ["duration_ms", "reasoning"],
       },
@@ -335,7 +353,11 @@ export const computerUseOpenAppTool: Tool = {
             description:
               "Explanation of why you need to open or switch to this app",
           },
-          activity: activityProperty,
+          target_client_id: {
+            type: "string",
+            description:
+              "ID of the specific client to target. Required when multiple clients support host_cu; omit when only one is connected. Obtain IDs from `assistant clients list --capability host_cu`.",
+          },
         },
         required: ["app_name", "reasoning"],
       },
@@ -373,7 +395,11 @@ export const computerUseRunAppleScriptTool: Tool = {
             description:
               "Explanation of what this script does and why AppleScript is better than UI interaction for this step",
           },
-          activity: activityProperty,
+          target_client_id: {
+            type: "string",
+            description:
+              "ID of the specific client to target. Required when multiple clients support host_cu; omit when only one is connected. Obtain IDs from `assistant clients list --capability host_cu`.",
+          },
         },
         required: ["script", "reasoning"],
       },
@@ -406,7 +432,6 @@ export const computerUseDoneTool: Tool = {
             type: "string",
             description: "Human-readable summary of what was accomplished",
           },
-          activity: activityProperty,
         },
         required: ["summary"],
       },
@@ -443,7 +468,6 @@ export const computerUseRespondTool: Tool = {
             type: "string",
             description: "Explanation of how you determined the answer",
           },
-          activity: activityProperty,
         },
         required: ["answer", "reasoning"],
       },
@@ -471,10 +495,8 @@ const computerUseObserveTool: Tool = {
       description: this.description,
       input_schema: {
         type: "object",
-        properties: {
-          activity: activityProperty,
-        },
-        required: ["activity"],
+        properties: {},
+        required: [],
       },
     };
   },

package/src/tools/executor.ts

@@ -406,6 +406,8 @@ export class ToolExecutor {
         requestId: context.requestId,
         riskLevel,
         matchedTrustRuleId: permMatchedTrustRuleId,
+        approvalMode: permApprovalMode,
+        approvalReason: permApprovalReason,
         decision,
         durationMs,
         result: safeResult,

package/src/tools/host-filesystem/edit.test.ts

@@ -0,0 +1,151 @@
+import { mkdtempSync, realpathSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, mock, test } from "bun:test";
+
+import type { ToolContext } from "../types.js";
+
+// ---------------------------------------------------------------------------
+// Singleton mocks — must precede the tool import so bun's module mock applies.
+// ---------------------------------------------------------------------------
+
+let mockProxyAvailable = false;
+
+mock.module("../../daemon/host-file-proxy.js", () => ({
+  HostFileProxy: {
+    get instance() {
+      return {
+        isAvailable: () => mockProxyAvailable,
+        request: () => Promise.resolve({ content: "ok", isError: false }),
+      };
+    },
+  },
+}));
+
+mock.module("../../runtime/assistant-event-hub.js", () => ({
+  assistantEventHub: {
+    listClientsByCapability: () => [],
+  },
+}));
+
+const { hostFileEditTool } = await import("./edit.js");
+
+const testDirs: string[] = [];
+
+afterEach(() => {
+  mockProxyAvailable = false;
+  for (const dir of testDirs.splice(0)) {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+function makeTempDir(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "host-edit-test-")));
+  testDirs.push(dir);
+  return dir;
+}
+
+function makeContext(
+  workingDir: string,
+  transportInterface: ToolContext["transportInterface"],
+): ToolContext {
+  return {
+    workingDir,
+    conversationId: "test-conv",
+    trustClass: "guardian",
+    transportInterface,
+  };
+}
+
+describe("host_file_edit cross-client guards", () => {
+  test("returns 'no client' error on web transport when proxy unavailable and no targetClientId", async () => {
+    const workingDir = makeTempDir();
+    const result = await hostFileEditTool.execute(
+      {
+        path: "/some/host/path.txt",
+        old_string: "foo",
+        new_string: "bar",
+      },
+      makeContext(workingDir, "web"),
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain(
+      "no client with host_file capability is connected",
+    );
+  });
+
+  test("returns 'specified client disconnected' error when targetClientId set but proxy unavailable on web", async () => {
+    const workingDir = makeTempDir();
+    const result = await hostFileEditTool.execute(
+      {
+        path: "/some/host/path.txt",
+        old_string: "foo",
+        new_string: "bar",
+        target_client_id: "abc-123",
+      },
+      makeContext(workingDir, "web"),
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain(
+      'target client "abc-123" is no longer connected',
+    );
+  });
+
+  test("falls through to local fs on macos transport when proxy unavailable", async () => {
+    const workingDir = makeTempDir();
+    const result = await hostFileEditTool.execute(
+      {
+        path: "/nonexistent/x.txt",
+        old_string: "foo",
+        new_string: "bar",
+      },
+      makeContext(workingDir, "macos"),
+    );
+    // Proves the guard did NOT fire on macOS — instead we got the
+    // local FileSystemOps error path (file not found / IO error).
+    expect(result.isError).toBe(true);
+    expect(result.content.toLowerCase()).toMatch(/not found|enoent|editing/);
+  });
+
+  test("does NOT reject on macos transport with a stale target_client_id when proxy unavailable (regression: P2 fix)", async () => {
+    const workingDir = makeTempDir();
+    const result = await hostFileEditTool.execute(
+      {
+        path: "/nonexistent/x.txt",
+        old_string: "foo",
+        new_string: "bar",
+        target_client_id: "stale-mac",
+      },
+      makeContext(workingDir, "macos"),
+    );
+    // The disconnected-target guard is scoped to non-host-proxy transports
+    // (!supportsHostProxy). On macos, a stale target_client_id auto-filled
+    // from a prior cross-client turn must be silently ignored and the call
+    // must fall through to local FileSystemOps, NOT reject with "target
+    // client ... is no longer connected".
+    expect(result.isError).toBe(true);
+    expect(result.content).not.toContain("is no longer connected");
+    expect(result.content.toLowerCase()).toMatch(/not found|enoent|editing/);
+  });
+
+  test("rejects when target_client_id is set but transport metadata is missing (legacy/backwards-compat path)", async () => {
+    const workingDir = makeTempDir();
+    const result = await hostFileEditTool.execute(
+      {
+        path: "/some/host/path.txt",
+        old_string: "foo",
+        new_string: "bar",
+        target_client_id: "abc-123",
+      },
+      // transportInterface intentionally undefined (legacy callers).
+      makeContext(workingDir, undefined),
+    );
+    // Without transport metadata, falling through to local fs would
+    // silently target the daemon container. The guard fires for undefined
+    // transport AND non-host-proxy transports — only macos turns skip it.
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain(
+      'target client "abc-123" is no longer connected',
+    );
+  });
+});

package/src/tools/host-filesystem/edit.ts

@@ -1,6 +1,8 @@
+import { supportsHostProxy } from "../../channels/types.js";
 import { HostFileProxy } from "../../daemon/host-file-proxy.js";
 import { RiskLevel } from "../../permissions/types.js";
 import type { ToolDefinition } from "../../providers/types.js";
+import { assistantEventHub } from "../../runtime/assistant-event-hub.js";
 import { FileSystemOps } from "../shared/filesystem/file-ops-service.js";
 import { formatEditDiff } from "../shared/filesystem/format-diff.js";
 import { hostPolicy } from "../shared/filesystem/path-policy.js";
@@ -37,6 +39,11 @@ class HostFileEditTool implements Tool {
             description:
               "Replace all occurrences instead of requiring a unique match (default: false)",
           },
+          target_client_id: {
+            type: "string",
+            description:
+              "ID of the specific client to execute this on. Required when multiple clients support host_file; omit when only one is connected. Obtain IDs from `assistant clients list --capability host_file`.",
+          },
         },
         required: ["path", "old_string", "new_string"],
       },
@@ -84,6 +91,64 @@ class HostFileEditTool implements Tool {
 
     const replaceAll = input.replace_all === true;
 
+    const targetClientId =
+      typeof input.target_client_id === "string" &&
+      input.target_client_id !== ""
+        ? input.target_client_id
+        : undefined;
+
+    const transportInterface = context.transportInterface;
+    if (
+      targetClientId == null &&
+      transportInterface != null &&
+      !supportsHostProxy(transportInterface) &&
+      assistantEventHub.listClientsByCapability("host_file").length > 1
+    ) {
+      return {
+        content: `Error: multiple clients support host_file. Specify which client to use with \`target_client_id\`. Run \`assistant clients list --capability host_file\` to see client IDs and labels.`,
+        isError: true,
+      };
+    }
+
+    // Guard: non-host-proxy interfaces with no capable clients connected.
+    // Without this guard, the request would fall through to local
+    // FileSystemOps below and read the daemon container's filesystem
+    // instead of the user's host machine.
+    if (
+      targetClientId == null &&
+      transportInterface != null &&
+      !supportsHostProxy(transportInterface) &&
+      !HostFileProxy.instance.isAvailable()
+    ) {
+      return {
+        content:
+          "Error: no client with host_file capability is connected. Connect a macOS client to use host_file from a non-desktop interface.",
+        isError: true,
+      };
+    }
+
+    // Guard: explicit targetClientId provided but proxy is unavailable.
+    // Fires on non-host-proxy transports (web, ios) AND on legacy callers
+    // without transport metadata, where falling through to local fs would
+    // silently target the daemon container's filesystem instead of the
+    // intended host client. Skips only when transport is explicitly
+    // host-proxy-capable (macos), where local-fs fallback IS the intended
+    // offline behavior — a stale target_client_id auto-filled from a prior
+    // cross-client turn is silently ignored on those turns.
+    // Note: this scoping deliberately differs from host_bash
+    // (host-shell.ts:239-247), which rejects unconditionally for any
+    // stale target_client_id regardless of transport.
+    if (
+      targetClientId != null &&
+      !HostFileProxy.instance.isAvailable() &&
+      (transportInterface == null || !supportsHostProxy(transportInterface))
+    ) {
+      return {
+        content: `Error: target client "${targetClientId}" is no longer connected. The specified client may have disconnected since the tool was called. Run \`assistant clients list --capability host_file\` to see currently connected clients.`,
+        isError: true,
+      };
+    }
+
     // Proxy to connected client for execution on the user's machine
     // when a capable client is available (managed/cloud-hosted mode).
     if (HostFileProxy.instance.isAvailable()) {
@@ -94,9 +159,12 @@ class HostFileEditTool implements Tool {
           old_string: oldString as string,
           new_string: newString as string,
           replace_all: replaceAll,
+          targetClientId,
         },
         context.conversationId,
         context.signal,
+        targetClientId,
+        context.sourceActorPrincipalId,
       );
     }