@vellumai/assistant 0.6.4 → 0.6.6

package/src/__tests__/host-browser-e2e-cloud.test.ts

@@ -568,6 +568,313 @@ describe("macOS message ingress with connected extension", () => {
   });
 });
 
+// ── macOS SSE bridge ingress (no extension registry) ────────────────
+//
+// Exercises the cloud-hosted + desktop SSE bridge path for macOS turns
+// WITHOUT relying on the ChromeExtensionRegistry. This validates the
+// native macOS host-browser proxy path where `host_browser_request`
+// frames travel through `assistantEventHub` (SSE) rather than the
+// extension WebSocket.
+//
+// In production, this path is used when:
+//   - The macOS desktop client is connected to the assistant via SSE
+//   - The user does NOT have the Chrome extension installed
+//   - The desktop client receives `host_browser_request` frames via SSE,
+//     executes CDP commands against the local Chrome, and POSTs results
+//     back to `/v1/host-browser-result`
+//
+// The test constructs a HostBrowserProxy wired to a mock SSE sender
+// (simulating the `onEvent` hub publisher) and a mock macOS client that
+// observes the sent frames and returns results via POST.
+
+describe("macOS SSE bridge ingress (no extension registry)", () => {
+  let server: RuntimeHttpServer;
+  let port: number;
+  let runtimeBaseUrl: string;
+
+  beforeEach(async () => {
+    const db = getDb();
+    db.run("DELETE FROM contact_channels");
+    db.run("DELETE FROM contacts");
+    pendingInteractions.clear();
+    __resetChromeExtensionRegistryForTests();
+
+    port = 20200 + Math.floor(Math.random() * 200);
+    runtimeBaseUrl = `http://127.0.0.1:${port}`;
+    server = new RuntimeHttpServer({ port });
+    await server.start();
+  });
+
+  afterEach(async () => {
+    await server?.stop();
+    pendingInteractions.clear();
+    __resetChromeExtensionRegistryForTests();
+  });
+
+  /**
+   * Create a HostBrowserProxy wired to a mock SSE sender. The sender
+   * captures `host_browser_request` frames and simulates what the macOS
+   * desktop client does: execute the CDP command locally and POST the
+   * result back to `/v1/host-browser-result`.
+   *
+   * Unlike `createBoundProxy` (which routes through the extension
+   * registry), this helper routes through a direct function call —
+   * simulating the `onEvent` SSE hub publisher path.
+   */
+  function createSseBoundProxy(
+    conversationId: string,
+    token: string,
+  ): {
+    proxy: HostBrowserProxy;
+    conversation: Conversation;
+    sentFrames: Array<{ type: string; [key: string]: unknown }>;
+  } {
+    let proxyRef: HostBrowserProxy | null = null;
+    const conversation = {
+      resolveHostBrowser(
+        requestId: string,
+        response: { content: string; isError: boolean },
+      ) {
+        proxyRef?.resolve(requestId, response);
+      },
+    } as unknown as Conversation;
+
+    const sentFrames: Array<{ type: string; [key: string]: unknown }> = [];
+
+    // The SSE sender simulates what `assistantEventHub.publish` does in
+    // production: it delivers the message to the connected SSE client.
+    // Here we capture the frame and immediately simulate the macOS client
+    // handling it — executing a mock CDP command and POSTing the result
+    // back to the runtime.
+    const sseSender = (msg: ServerMessage) => {
+      const frame = msg as { type: string; [key: string]: unknown };
+      sentFrames.push(frame);
+
+      if (frame.type === "host_browser_request") {
+        const requestId = frame.requestId as string;
+
+        // Register the pending interaction (in production this happens
+        // in makeHubPublisher inside conversation-routes.ts).
+        pendingInteractions.register(requestId, {
+          conversation,
+          conversationId,
+          kind: "host_browser",
+        });
+
+        // Simulate the macOS desktop client processing the CDP command
+        // and POSTing the result back to the runtime.
+        const cdpMethod = frame.cdpMethod as string;
+        let content: string;
+        let isError = false;
+        if (cdpMethod === "Browser.getVersion") {
+          content = JSON.stringify({
+            product: "Chrome/macOS-SSE-Test",
+            protocolVersion: "1.3",
+            revision: "@macos-sse",
+            userAgent: "Mozilla/5.0 (macOS SSE bridge e2e fixture)",
+            jsVersion: "0.0.0-macos-sse",
+          });
+        } else if (cdpMethod === "Runtime.evaluate") {
+          content = JSON.stringify({ result: { value: "complete" } });
+        } else {
+          content = `mock macOS client: unsupported cdpMethod "${cdpMethod}"`;
+          isError = true;
+        }
+
+        // POST result asynchronously (simulating the real macOS client).
+        void fetch(`${runtimeBaseUrl}/v1/host-browser-result`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`,
+          },
+          body: JSON.stringify({ requestId, content, isError }),
+        })
+          .then((res) => res.body?.cancel())
+          .catch(() => {});
+      }
+    };
+
+    const proxy = new HostBrowserProxy(sseSender);
+    proxyRef = proxy;
+    return { proxy, conversation, sentFrames };
+  }
+
+  test("happy path: Browser.getVersion round-trips through the SSE bridge without extension registry", async () => {
+    const guardianId = `test-guardian-macos-sse-${crypto.randomUUID()}`;
+    const token = mintActorToken(guardianId);
+
+    const { proxy, sentFrames } = createSseBoundProxy(
+      "conv-macos-sse-happy",
+      token,
+    );
+
+    const result = await proxy.request(
+      { cdpMethod: "Browser.getVersion" },
+      "conv-macos-sse-happy",
+    );
+
+    // The request completed via the SSE bridge path, not the extension registry.
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Chrome/macOS-SSE-Test");
+
+    // The SSE sender received exactly one host_browser_request frame.
+    const requests = sentFrames.filter(
+      (f) => f.type === "host_browser_request",
+    );
+    expect(requests).toHaveLength(1);
+    expect(requests[0].cdpMethod).toBe("Browser.getVersion");
+    expect(requests[0].conversationId).toBe("conv-macos-sse-happy");
+
+    // The extension registry should NOT have been involved — no entries exist.
+    expect(getChromeExtensionRegistry().get(guardianId)).toBeUndefined();
+
+    proxy.dispose();
+  });
+
+  test("abort: SSE-bridged request resolves to 'Aborted' when signal fires", async () => {
+    const guardianId = `test-guardian-macos-sse-abort-${crypto.randomUUID()}`;
+    const _token = mintActorToken(guardianId);
+
+    // Use a CDP handler that hangs forever so we can abort mid-flight.
+    const sentFrames: Array<{ type: string; [key: string]: unknown }> = [];
+    let proxyRef: HostBrowserProxy | null = null;
+    const conversation = {
+      resolveHostBrowser(
+        requestId: string,
+        response: { content: string; isError: boolean },
+      ) {
+        proxyRef?.resolve(requestId, response);
+      },
+    } as unknown as Conversation;
+
+    const hangingSender = (msg: ServerMessage) => {
+      const frame = msg as { type: string; [key: string]: unknown };
+      sentFrames.push(frame);
+      if (frame.type === "host_browser_request") {
+        const requestId = frame.requestId as string;
+        pendingInteractions.register(requestId, {
+          conversation,
+          conversationId: "conv-macos-sse-abort",
+          kind: "host_browser",
+        });
+        // Simulate a macOS client that never responds (hangs).
+      }
+    };
+
+    const proxy = new HostBrowserProxy(hangingSender);
+    proxyRef = proxy;
+
+    const controller = new AbortController();
+    const resultPromise = proxy.request(
+      { cdpMethod: "Browser.getVersion" },
+      "conv-macos-sse-abort",
+      controller.signal,
+    );
+
+    // Wait for the SSE sender to observe the request.
+    await waitFor(() => sentFrames.length === 1);
+
+    controller.abort();
+    const result = await resultPromise;
+
+    expect(result.content).toBe("Aborted");
+    expect(result.isError).toBe(true);
+
+    // The cancel frame should have been sent through the SSE sender.
+    const cancels = sentFrames.filter((f) => f.type === "host_browser_cancel");
+    expect(cancels).toHaveLength(1);
+
+    proxy.dispose();
+  });
+
+  test("timeout: SSE-bridged request surfaces timeout when macOS client never responds", async () => {
+    const guardianId = `test-guardian-macos-sse-timeout-${crypto.randomUUID()}`;
+    const _token = mintActorToken(guardianId);
+
+    const sentFrames: Array<{ type: string; [key: string]: unknown }> = [];
+    let proxyRef: HostBrowserProxy | null = null;
+    const conversation = {
+      resolveHostBrowser(
+        requestId: string,
+        response: { content: string; isError: boolean },
+      ) {
+        proxyRef?.resolve(requestId, response);
+      },
+    } as unknown as Conversation;
+
+    const hangingSender = (msg: ServerMessage) => {
+      const frame = msg as { type: string; [key: string]: unknown };
+      sentFrames.push(frame);
+      if (frame.type === "host_browser_request") {
+        const requestId = frame.requestId as string;
+        pendingInteractions.register(requestId, {
+          conversation,
+          conversationId: "conv-macos-sse-timeout",
+          kind: "host_browser",
+        });
+        // Never respond — simulate unresponsive macOS client.
+      }
+    };
+
+    const proxy = new HostBrowserProxy(hangingSender);
+    proxyRef = proxy;
+
+    const result = await proxy.request(
+      { cdpMethod: "Browser.getVersion", timeout_seconds: 0.05 },
+      "conv-macos-sse-timeout",
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("timed out");
+
+    // The SSE sender received the request frame (confirming the timeout
+    // is from the proxy timer, not a send failure).
+    const requests = sentFrames.filter(
+      (f) => f.type === "host_browser_request",
+    );
+    expect(requests).toHaveLength(1);
+    expect(requests[0].cdpMethod).toBe("Browser.getVersion");
+
+    proxy.dispose();
+  });
+
+  test("multiple sequential commands round-trip through the SSE bridge", async () => {
+    const guardianId = `test-guardian-macos-sse-seq-${crypto.randomUUID()}`;
+    const token = mintActorToken(guardianId);
+
+    const { proxy, sentFrames } = createSseBoundProxy(
+      "conv-macos-sse-seq",
+      token,
+    );
+
+    // First command: Browser.getVersion
+    const result1 = await proxy.request(
+      { cdpMethod: "Browser.getVersion" },
+      "conv-macos-sse-seq",
+    );
+    expect(result1.isError).toBe(false);
+    expect(result1.content).toContain("Chrome/macOS-SSE-Test");
+
+    // Second command: Runtime.evaluate
+    const result2 = await proxy.request(
+      { cdpMethod: "Runtime.evaluate", cdpParams: { expression: "1+1" } },
+      "conv-macos-sse-seq",
+    );
+    expect(result2.isError).toBe(false);
+
+    // Both requests went through the SSE sender.
+    const requests = sentFrames.filter(
+      (f) => f.type === "host_browser_request",
+    );
+    expect(requests).toHaveLength(2);
+    expect(requests[0].cdpMethod).toBe("Browser.getVersion");
+    expect(requests[1].cdpMethod).toBe("Runtime.evaluate");
+
+    proxy.dispose();
+  });
+});
+
 // ── Local wait helpers ──────────────────────────────────────────────
 
 async function waitFor(

package/src/__tests__/host-browser-e2e-self-hosted.test.ts

@@ -46,7 +46,7 @@ import {
   verifyHostBrowserCapability,
 } from "../runtime/capability-tokens.js";
 import {
-  ALLOWED_EXTENSION_ORIGINS,
+  getAllowedExtensionOrigins,
   handleBrowserExtensionPair,
 } from "../runtime/routes/browser-extension-pair-routes.js";
 
@@ -81,10 +81,10 @@ const HELPER_BINARY = resolveHelperBinary();
 const HELPER_EXISTS = existsSync(HELPER_BINARY);
 
 const ALLOWED_ORIGIN = (() => {
-  const first = Array.from(ALLOWED_EXTENSION_ORIGINS)[0];
+  const first = Array.from(getAllowedExtensionOrigins())[0];
   if (!first) {
     throw new Error(
-      "ALLOWED_EXTENSION_ORIGINS must contain at least one extension origin for tests",
+      "getAllowedExtensionOrigins() must contain at least one extension origin for tests",
     );
   }
   return first;

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

@@ -42,11 +42,11 @@ describe("supportsHostProxy (runtime)", () => {
     expect(supportsHostProxy("chrome-extension", "host_cu")).toBe(false);
   });
 
-  test("capability form grants host_bash/file/cu to macOS but not host_browser", () => {
+  test("capability form grants all four capabilities to macOS including host_browser", () => {
     expect(supportsHostProxy("macos", "host_bash")).toBe(true);
     expect(supportsHostProxy("macos", "host_file")).toBe(true);
     expect(supportsHostProxy("macos", "host_cu")).toBe(true);
-    expect(supportsHostProxy("macos", "host_browser")).toBe(false);
+    expect(supportsHostProxy("macos", "host_browser")).toBe(true);
   });
 
   test("capability form rejects everything for non-host-proxy interfaces", () => {
@@ -163,3 +163,37 @@ describe("isHostProxyTransport", () => {
     expect(isHostProxyTransport(transport)).toBe(false);
   });
 });
+
+// ---------------------------------------------------------------------------
+// macOS host_browser capability — regression guards
+// ---------------------------------------------------------------------------
+
+describe("macOS host_browser capability", () => {
+  test("macOS supports host_browser via supportsHostProxy capability check", () => {
+    // macOS is now host-browser-capable, enabling host_browser_request
+    // frames to be sent to the desktop client via SSE or extension registry.
+    expect(supportsHostProxy("macos", "host_browser")).toBe(true);
+  });
+
+  test("macOS still passes the no-arg host-proxy check (full desktop proxy)", () => {
+    // The no-arg form gates computer-use preactivation and full proxy restore.
+    // macOS must still pass this check.
+    expect(supportsHostProxy("macos")).toBe(true);
+  });
+
+  test("non-macOS non-extension interfaces remain host_browser-ineligible", () => {
+    const ineligible: InterfaceId[] = [
+      "ios",
+      "cli",
+      "telegram",
+      "phone",
+      "vellum",
+      "whatsapp",
+      "slack",
+      "email",
+    ];
+    for (const id of ineligible) {
+      expect(supportsHostProxy(id, "host_browser")).toBe(false);
+    }
+  });
+});

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

@@ -674,6 +674,18 @@ describe("host_bash — spawn error handling", () => {
     expect(result.isError).toBe(false);
     expect(result.content).toContain("<command_completed />");
   });
+
+  test("injects __CONVERSATION_ID for local host_bash execution", async () => {
+    const result = await hostShellTool.execute(
+      {
+        command: 'echo "$__CONVERSATION_ID"',
+      },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content.trim()).toBe("test-conversation");
+  });
 });
 
 // ---------------------------------------------------------------------------
@@ -681,6 +693,34 @@ 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",
+    "INTERNAL_GATEWAY_BASE_URL",
+  ] as const;
+
+  function captureEnv(
+    keys: readonly string[],
+  ): Record<string, string | undefined> {
+    const snapshot: Record<string, string | undefined> = {};
+    for (const key of keys) {
+      snapshot[key] = process.env[key];
+    }
+    return snapshot;
+  }
+
+  function restoreEnv(snapshot: Record<string, string | undefined>): void {
+    for (const [key, value] of Object.entries(snapshot)) {
+      if (value === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  }
+
   function makeMockProxy(result: ToolExecutionResult) {
     const calls: Array<{
       input: {
@@ -843,6 +883,12 @@ describe("host_bash — proxy delegation", () => {
       "ces-shell-lockdown": true,
     });
 
+    const envSnapshot = captureEnv(ROUTING_ENV_KEYS);
+    // Keep this test focused on lockdown propagation behavior only.
+    for (const key of ROUTING_ENV_KEYS) {
+      delete process.env[key];
+    }
+
     try {
       const proxyResult: ToolExecutionResult = {
         content: "proxied",
@@ -863,32 +909,92 @@ describe("host_bash — proxy delegation", () => {
 
       expect(result).toBe(proxyResult);
       expect(calls.length).toBe(1);
-      expect(calls[0].input.env).toEqual({ VELLUM_UNTRUSTED_SHELL: "1" });
+      expect(calls[0].input.env).toEqual({
+        VELLUM_UNTRUSTED_SHELL: "1",
+        __CONVERSATION_ID: "test-conversation",
+      });
     } finally {
       _setOverridesForTesting({});
+      restoreEnv(envSnapshot);
     }
   });
 
   test("does not propagate env to proxy when CES lockdown is inactive", async () => {
-    const proxyResult: ToolExecutionResult = {
-      content: "proxied",
-      isError: false,
-    };
-    const { proxy, calls } = makeMockProxy(proxyResult);
+    const envSnapshot = captureEnv(ROUTING_ENV_KEYS);
+    for (const key of ROUTING_ENV_KEYS) {
+      delete process.env[key];
+    }
 
-    const ctx: ToolContext = {
-      ...makeContext(),
-      trustClass: "guardian", // trusted actor — no lockdown
-      hostBashProxy: proxy as unknown as ToolContext["hostBashProxy"],
-    };
+    try {
+      const proxyResult: ToolExecutionResult = {
+        content: "proxied",
+        isError: false,
+      };
+      const { proxy, calls } = makeMockProxy(proxyResult);
 
-    const result = await hostShellTool.execute(
-      { command: "echo no-lockdown" },
-      ctx,
-    );
+      const ctx: ToolContext = {
+        ...makeContext(),
+        trustClass: "guardian", // trusted actor — no lockdown
+        hostBashProxy: proxy as unknown as ToolContext["hostBashProxy"],
+      };
 
-    expect(result).toBe(proxyResult);
-    expect(calls.length).toBe(1);
-    expect(calls[0].input.env).toBeUndefined();
+      const result = await hostShellTool.execute(
+        { command: "echo no-lockdown" },
+        ctx,
+      );
+
+      expect(result).toBe(proxyResult);
+      expect(calls.length).toBe(1);
+      expect(calls[0].input.env).toEqual({
+        __CONVERSATION_ID: "test-conversation",
+      });
+    } finally {
+      restoreEnv(envSnapshot);
+    }
+  });
+
+  test("propagates daemon routing env vars to proxy for nested assistant CLI calls", async () => {
+    const envSnapshot = captureEnv([
+      ...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";
+    process.env.INTERNAL_GATEWAY_BASE_URL = "http://127.0.0.1:7830";
+    delete process.env.VELLUM_UNTRUSTED_SHELL;
+
+    try {
+      const proxyResult: ToolExecutionResult = {
+        content: "proxied",
+        isError: false,
+      };
+      const { proxy, calls } = makeMockProxy(proxyResult);
+
+      const ctx: ToolContext = {
+        ...makeContext(),
+        trustClass: "guardian", // trusted actor — no lockdown
+        hostBashProxy: proxy as unknown as ToolContext["hostBashProxy"],
+      };
+
+      const result = await hostShellTool.execute(
+        { command: "assistant browser status --json" },
+        ctx,
+      );
+
+      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",
+        INTERNAL_GATEWAY_BASE_URL: "http://127.0.0.1:7830",
+        __CONVERSATION_ID: "test-conversation",
+      });
+    } finally {
+      restoreEnv(envSnapshot);
+    }
   });
 });

package/src/__tests__/http-user-message-parity.test.ts

@@ -130,11 +130,39 @@ mock.module("../config/loader.js", () => ({
     model: "test",
     provider: "test",
     contextWindow: { maxInputTokens: 200000 },
+    llm: {
+      default: {
+        provider: "anthropic",
+        model: "claude-opus-4-7",
+        maxTokens: 64000,
+        effort: "max" as const,
+        speed: "standard" as const,
+        temperature: null,
+        thinking: { enabled: true, streamThinking: true },
+        contextWindow: {
+          enabled: true,
+          maxInputTokens: 200000,
+          targetBudgetRatio: 0.3,
+          compactThreshold: 0.8,
+          summaryBudgetRatio: 0.05,
+          overflowRecovery: {
+            enabled: true,
+            safetyMarginRatio: 0.05,
+            maxAttempts: 3,
+            interactiveLatestTurnCompression: "summarize",
+            nonInteractiveLatestTurnCompression: "truncate",
+          },
+        },
+      },
+      profiles: {},
+      callSites: {},
+      pricingOverrides: [],
+    },
     services: {
       inference: {
         mode: "your-own",
         provider: "anthropic",
-        model: "claude-opus-4-6",
+        model: "claude-opus-4-7",
       },
       "image-generation": {
         mode: "your-own",