@vellumai/assistant 0.8.10 → 0.8.11-staging.1

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

@@ -5,6 +5,7 @@ import {
   type CdpResult,
   createCdpInspectBackend,
   createExtensionBackend,
+  createHostBridgeBackend,
   createLocalBackend,
 } from "../../../browser-session/index.js";
 import { getConfig } from "../../../config/loader.js";
@@ -15,13 +16,14 @@ import { getPinnedTab } from "../pinned-tabs.js";
 import { createCdpInspectClient } from "./cdp-inspect-client.js";
 import { CdpError } from "./errors.js";
 import { createExtensionCdpClient } from "./extension-cdp-client.js";
+import { createHostBridgeCdpClient } from "./host-bridge-cdp-client.js";
 import { createLocalCdpClient } from "./local-cdp-client.js";
 import type {
   AttemptDiagnostic,
   BackendCandidate,
-  BrowserMode,
   CdpClient,
   CdpClientKind,
+  InternalBrowserMode,
   ScopedCdpClient,
   TabInfo,
 } from "./types.js";
@@ -52,7 +54,7 @@ let _desktopAutoCooldownSince = 0;
 
 /**
  * Record a cooldown after a desktop-auto cdp-inspect transport failure.
- * Called by {@link maybeRecordDesktopAutoCooldown} in production; also
+ * Called by {@link maybeRecordCandidateCooldown} in production; also
  * exported directly for use in tests.
  */
 export function recordDesktopAutoCooldown(): void {
@@ -83,6 +85,85 @@ export function _getDesktopAutoCooldownSince(): number {
   return _desktopAutoCooldownSince;
 }
 
+// ---------------------------------------------------------------------------
+// Host-bridge cooldown tracker
+// ---------------------------------------------------------------------------
+
+/**
+ * Per-actor timestamps (epoch ms) of the last transport-level failure
+ * for a host-bridge attempt. Mirrors the desktop-auto cdp-inspect
+ * cooldown above — the failure root cause is the same (the user's
+ * Chrome is not exposing a remote-debugging port), just probed through
+ * the desktop SSE bridge instead of directly. While the configured
+ * `desktopAuto.cooldownMs` window has not elapsed, the factory skips
+ * the host-bridge candidate so every browser op doesn't pay an SSE
+ * round-trip for a guaranteed failure.
+ *
+ * **Per-actor scope**: unlike the desktop-auto cooldown (one local
+ * machine, so process-global is correct), the bridge reaches a
+ * different desktop machine per actor on a multi-actor cloud daemon —
+ * one actor's missing debug port must not suppress another actor's
+ * only route to their own Chrome. Callers without a resolved actor
+ * share the `__default__` slot.
+ */
+const _hostBridgeCooldownSince = new Map<string, number>();
+
+/** Entries older than this are swept on record to bound map growth. */
+const HOST_BRIDGE_COOLDOWN_SWEEP_MS = 60 * 60 * 1000;
+
+function hostBridgeCooldownKey(sourceActorPrincipalId?: string): string {
+  return sourceActorPrincipalId ?? "__default__";
+}
+
+/** Record a cooldown after a host-bridge transport failure for this actor. */
+export function recordHostBridgeCooldown(
+  sourceActorPrincipalId?: string,
+): void {
+  const now = Date.now();
+  for (const [key, since] of _hostBridgeCooldownSince) {
+    if (now - since >= HOST_BRIDGE_COOLDOWN_SWEEP_MS) {
+      _hostBridgeCooldownSince.delete(key);
+    }
+  }
+  _hostBridgeCooldownSince.set(
+    hostBridgeCooldownKey(sourceActorPrincipalId),
+    now,
+  );
+}
+
+/**
+ * Whether the host-bridge cooldown is currently active for this actor.
+ * Returns `true` if a failure was recorded and the configured cooldown
+ * window has not yet elapsed.
+ */
+export function isHostBridgeCooldownActive(
+  cooldownMs: number,
+  sourceActorPrincipalId?: string,
+): boolean {
+  if (cooldownMs <= 0) return false;
+  const since = _hostBridgeCooldownSince.get(
+    hostBridgeCooldownKey(sourceActorPrincipalId),
+  );
+  if (since === undefined) return false;
+  return Date.now() - since < cooldownMs;
+}
+
+/** Reset the host-bridge cooldown state. Exported for testing only. */
+export function _resetHostBridgeCooldown(): void {
+  _hostBridgeCooldownSince.clear();
+}
+
+/** Get the raw cooldown-since timestamp for an actor. Exported for testing only. */
+export function _getHostBridgeCooldownSince(
+  sourceActorPrincipalId?: string,
+): number {
+  return (
+    _hostBridgeCooldownSince.get(
+      hostBridgeCooldownKey(sourceActorPrincipalId),
+    ) ?? 0
+  );
+}
+
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
@@ -96,9 +177,10 @@ export interface GetCdpClientOptions {
    * Backend mode preference. When omitted or `"auto"`, the factory
    * uses the existing priority-ordered fallback chain. When set to a
    * specific backend kind, the factory pins to that single backend
-   * and disables failover.
+   * and disables failover. `"host-bridge"` is internal-only (sticky
+   * conversation memo), never user-requestable.
    */
-  mode?: BrowserMode;
+  mode?: InternalBrowserMode;
   /**
    * Explicit target client id. When provided, the extension backend routes
    * to this specific client instead of auto-resolving to the most-recently-
@@ -159,7 +241,7 @@ export function getCdpClient(
   context: ToolContext,
   options?: GetCdpClientOptions,
 ): ScopedCdpClient {
-  const mode: BrowserMode = options?.mode ?? "auto";
+  const mode: InternalBrowserMode = options?.mode ?? "auto";
   const targetClientId = options?.targetClientId;
   const candidates =
     mode === "auto"
@@ -191,7 +273,7 @@ export function getCdpClient(
  */
 export function buildPinnedCandidateList(
   context: ToolContext,
-  mode: Exclude<BrowserMode, "auto">,
+  mode: Exclude<InternalBrowserMode, "auto">,
   targetClientId?: string,
 ): BackendCandidate[] {
   const { conversationId, sourceActorPrincipalId } = context;
@@ -199,7 +281,7 @@ export function buildPinnedCandidateList(
   switch (mode) {
     case "extension": {
         const hostBrowserProxy = HostBrowserProxy.instance;
-        if (!hostBrowserProxy.hasExtensionClient()) {
+        if (!hostBrowserProxy.hasExtensionClient(sourceActorPrincipalId)) {
           throw new CdpError(
             "transport_error",
             `Pinned mode "extension" unavailable: no Chrome Extension connected`,
@@ -267,6 +349,48 @@ export function buildPinnedCandidateList(
         },
       ];
     }
+    case "host-bridge": {
+      // Reached only via the conversation's sticky-backend memo after a
+      // successful bridge send — never via --browser-mode. Throwing when
+      // an extension has since connected (not just when the bridge is
+      // gone) deliberately trips the caller's sticky-fallback retry,
+      // which clears the memo and re-runs auto mode so the conversation
+      // upgrades to the extension candidate with correct kind labeling.
+      const hostBrowserProxy = HostBrowserProxy.instance;
+      if (
+        !hostBrowserProxy.isAvailable(sourceActorPrincipalId) ||
+        hostBrowserProxy.hasExtensionClient(sourceActorPrincipalId)
+      ) {
+        const errorMessage = hostBrowserProxy.hasExtensionClient(
+          sourceActorPrincipalId,
+        )
+          ? "a Chrome Extension is now connected"
+          : "no host_browser bridge client connected";
+        throw new CdpError(
+          "transport_error",
+          `Pinned mode "host-bridge" unavailable: ${errorMessage}`,
+          {
+            attemptDiagnostics: [
+              {
+                candidateKind: "host-bridge",
+                inclusionReason: "pinned mode: host-bridge",
+                stage: "candidate_selection",
+                errorCode: "transport_error",
+                errorMessage,
+              },
+            ],
+          },
+        );
+      }
+      return [
+        makeHostBridgeCandidate(
+          hostBrowserProxy,
+          conversationId,
+          sourceActorPrincipalId,
+          "pinned mode: host-bridge (conversation sticky memo)",
+        ),
+      ];
+    }
     case "local": {
       return [
         {
@@ -315,7 +439,7 @@ export function buildCandidateList(context: ToolContext, targetClientId?: string
   // unavailable, fail loudly rather than silently routing to a different
   // browser.
   if (targetClientId != null) {
-    if (!hostBrowserProxy.hasExtensionClient()) {
+    if (!hostBrowserProxy.hasExtensionClient(sourceActorPrincipalId)) {
       throw new CdpError(
         "transport_error",
         `Cannot reach target_client_id "${targetClientId}": no Chrome Extension connected`,
@@ -360,7 +484,11 @@ export function buildCandidateList(context: ToolContext, targetClientId?: string
   }
 
   // 1. Extension -- preferred when a Chrome Extension client is connected.
-  if (hostBrowserProxy.hasExtensionClient()) {
+  // Availability checks are actor-scoped: on a multi-actor cloud daemon,
+  // another actor's extension must not select extension-labelled
+  // transports for this conversation (the proxy would refuse to
+  // dispatch to it anyway).
+  if (hostBrowserProxy.hasExtensionClient(sourceActorPrincipalId)) {
     candidates.push({
       kind: "extension",
       reason: "Chrome Extension connected via registry singleton",
@@ -385,6 +513,33 @@ export function buildCandidateList(context: ToolContext, targetClientId?: string
         return { client, backend };
       },
     });
+  } else if (hostBrowserProxy.isAvailable(sourceActorPrincipalId)) {
+    // 1b. Host bridge -- a host_browser-capable client (the desktop SSE
+    // bridge) is connected but no Chrome Extension. Raw CDP commands are
+    // proxied to the user's machine and executed against Chrome's local
+    // remote-debugging port. This is the only route to the user's own
+    // Chrome when the daemon runs remotely (cloud), where cdp-inspect
+    // would dial the daemon's localhost instead.
+    const { cooldownMs } = getConfig().hostBrowser.cdpInspect.desktopAuto;
+    if (isHostBridgeCooldownActive(cooldownMs, sourceActorPrincipalId)) {
+      log.debug(
+        {
+          conversationId,
+          cooldownMs,
+          cooldownSince: _getHostBridgeCooldownSince(sourceActorPrincipalId),
+        },
+        "CDP factory: host-bridge skipped (cooldown active)",
+      );
+    } else {
+      candidates.push(
+        makeHostBridgeCandidate(
+          hostBrowserProxy,
+          conversationId,
+          sourceActorPrincipalId,
+          "host_browser bridge connected (no Chrome Extension); raw CDP via desktop SSE bridge",
+        ),
+      );
+    }
   } else {
     log.debug(
       { conversationId },
@@ -473,6 +628,42 @@ export function buildCandidateList(context: ToolContext, targetClientId?: string
   return candidates;
 }
 
+/**
+ * Build the host-bridge backend candidate. Shared between auto mode
+ * (no extension connected, bridge available) and the pinned path that
+ * serves the conversation's sticky-backend memo.
+ *
+ * Unlike the extension candidate, no pinned tab is passed: extension
+ * pins store Chrome tab ids, which never match the CDP target ids the
+ * bridge resolves from /json/list.
+ */
+function makeHostBridgeCandidate(
+  hostBrowserProxy: HostBrowserProxy,
+  conversationId: string,
+  sourceActorPrincipalId: string | undefined,
+  reason: string,
+): BackendCandidate {
+  return {
+    kind: "host-bridge",
+    reason,
+    sourceActorPrincipalId,
+    create() {
+      const client = createHostBridgeCdpClient(
+        hostBrowserProxy,
+        conversationId,
+        sourceActorPrincipalId,
+      );
+      const backend = createHostBridgeBackend({
+        isAvailable: () => true,
+        sendCdp: (command, signal) =>
+          dispatchThroughClient(client, command, signal),
+        dispose: () => client.dispose(),
+      });
+      return { client, backend };
+    },
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Chained client with per-invocation failover
 // ---------------------------------------------------------------------------
@@ -487,7 +678,7 @@ export function buildCandidateList(context: ToolContext, targetClientId?: string
 export function buildChainedClient(
   conversationId: string,
   candidates: BackendCandidate[],
-  mode: BrowserMode = "auto",
+  mode: InternalBrowserMode = "auto",
 ): ScopedCdpClient {
   if (candidates.length === 0) {
     throw new Error("CDP factory: no backend candidates available");
@@ -749,7 +940,7 @@ async function sendWithFailover<T>(
   }) => void,
   isDisposed: () => boolean,
   conversationId: string,
-  mode: BrowserMode,
+  mode: InternalBrowserMode,
 ): Promise<T> {
   let lastError: CdpError | undefined;
   const diagnostics: AttemptDiagnostic[] = [];
@@ -804,7 +995,7 @@ async function sendWithFailover<T>(
         errorCode: "transport_error",
         errorMessage,
       });
-      maybeRecordDesktopAutoCooldown(candidate);
+      maybeRecordCandidateCooldown(candidate);
 
       // Emit production-visible fallback log in auto mode
       if (mode === "auto" && i < candidates.length - 1) {
@@ -856,7 +1047,7 @@ async function sendWithFailover<T>(
         errorMessage,
         discoveryCode: extractDiscoveryCode(err),
       });
-      maybeRecordDesktopAutoCooldown(candidate);
+      maybeRecordCandidateCooldown(candidate);
 
       // Emit production-visible fallback log in auto mode
       if (mode === "auto" && i < candidates.length - 1) {
@@ -903,7 +1094,7 @@ async function sendWithFailover<T>(
           errorMessage: cdpError.message,
           discoveryCode: extractDiscoveryCode(cdpError.underlying),
         });
-        maybeRecordDesktopAutoCooldown(candidate);
+        maybeRecordCandidateCooldown(candidate);
 
         // Emit production-visible fallback log in auto mode
         if (mode === "auto") {
@@ -998,10 +1189,19 @@ async function sendWithFailover<T>(
 }
 
 /**
- * If the failed candidate is a desktop-auto cdp-inspect attempt,
- * record the cooldown so subsequent calls skip the probe.
+ * Record the appropriate cooldown for a failed candidate so subsequent
+ * calls skip the probe: desktop-auto cdp-inspect attempts (matched by
+ * reason prefix, exempting user-pinned cdp-inspect) and host-bridge
+ * attempts (matched by kind alone — the bridge is never user-pinned).
  */
-function maybeRecordDesktopAutoCooldown(candidate: BackendCandidate): void {
+function maybeRecordCandidateCooldown(candidate: BackendCandidate): void {
+  if (candidate.kind === "host-bridge") {
+    log.debug(
+      "CDP factory: recording host-bridge cooldown after transport failure",
+    );
+    recordHostBridgeCooldown(candidate.sourceActorPrincipalId);
+    return;
+  }
   if (
     candidate.kind === "cdp-inspect" &&
     candidate.reason.startsWith("desktopAuto:")

package/src/tools/browser/cdp-client/host-bridge-cdp-client.ts

@@ -0,0 +1,67 @@
+import type { HostBrowserProxy } from "../../../daemon/host-browser-proxy.js";
+import { CdpError } from "./errors.js";
+import { ExtensionCdpClient } from "./extension-cdp-client.js";
+import type { CdpClientKind } from "./types.js";
+
+/**
+ * CdpClient for the desktop host-browser bridge: raw CDP commands are
+ * routed through HostBrowserProxy to the desktop client's SSE bridge,
+ * which executes them against the user's Chrome via its local
+ * remote-debugging port. Reuses ExtensionCdpClient's request/reply and
+ * error-classification plumbing with three deliberate differences:
+ *
+ *  - `kind` is `"host-bridge"`, so transport-aware tool branches
+ *    (e.g. `--new-tab`'s `Vellum.createTab` path) correctly treat the
+ *    bridge as a non-extension backend.
+ *  - No pinned-tab `cdpSessionId` is ever injected: extension pins
+ *    store Chrome tab ids, which never match the CDP target ids the
+ *    bridge resolves from `/json/list` and would guarantee
+ *    `cdp_session_not_found` failures.
+ *  - Tab methods throw locally instead of sending `Vellum.*`
+ *    pseudo-methods the bridge cannot serve (matches the
+ *    local/cdp-inspect client convention).
+ */
+export class HostBridgeCdpClient extends ExtensionCdpClient {
+  override readonly kind: CdpClientKind = "host-bridge";
+
+  constructor(
+    proxy: HostBrowserProxy,
+    conversationId: string,
+    sourceActorPrincipalId?: string,
+  ) {
+    super(
+      proxy,
+      conversationId,
+      /* cdpSessionId */ undefined,
+      sourceActorPrincipalId,
+      /* targetClientId */ undefined,
+    );
+  }
+
+  override async listTabs(): Promise<never> {
+    throw unsupportedTabOperation("listTabs");
+  }
+
+  override async selectTab(_tabId: number): Promise<never> {
+    throw unsupportedTabOperation("selectTab");
+  }
+
+  override async closeTab(_tabId: number): Promise<never> {
+    throw unsupportedTabOperation("closeTab");
+  }
+}
+
+function unsupportedTabOperation(operation: string): CdpError {
+  return new CdpError(
+    "transport_error",
+    `${operation} is not supported by the host-bridge backend (extension backend required)`,
+  );
+}
+
+export function createHostBridgeCdpClient(
+  proxy: HostBrowserProxy,
+  conversationId: string,
+  sourceActorPrincipalId?: string,
+): HostBridgeCdpClient {
+  return new HostBridgeCdpClient(proxy, conversationId, sourceActorPrincipalId);
+}

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

@@ -98,22 +98,36 @@ export interface CdpClient {
  * the sacrificial-profile screencast setup when running against the
  * user's own Chrome via the extension).
  */
-export type CdpClientKind = "local" | "extension" | "cdp-inspect";
+export type CdpClientKind = "local" | "extension" | "cdp-inspect" | "host-bridge";
 
 /**
  * Backend mode preference for the CDP factory. Controls which
  * transport is selected:
  *
  *  - `"auto"` — default, existing priority-ordered fallback
- *    (extension → cdp-inspect → local).
+ *    (extension → host-bridge → cdp-inspect → local).
  *  - `"extension"` — pin to the chrome-extension backend. Fails
  *    immediately if the host browser proxy is unavailable.
  *  - `"cdp-inspect"` — pin to the cdp-inspect backend. Fails
  *    immediately if cdp-inspect cannot connect.
  *  - `"local"` — pin to the local Playwright backend. No fallback.
+ *
+ * The `host-bridge` backend (raw CDP to the user's Chrome via the
+ * desktop client's SSE bridge) is auto-mode only and not listed here —
+ * see {@link InternalBrowserMode}.
  */
 export type BrowserMode = "auto" | "extension" | "cdp-inspect" | "local";
 
+/**
+ * {@link BrowserMode} plus internal-only kinds the factory can pin to.
+ * The conversation's sticky-backend memo records the last successful
+ * {@link CdpClientKind} and re-pins to it on the next tool call; after
+ * a successful host-bridge send that memo is `"host-bridge"`, which is
+ * never user-requestable via `--browser-mode` but must round-trip
+ * through the factory's pinned-candidate path.
+ */
+export type InternalBrowserMode = BrowserMode | "host-bridge";
+
 /**
  * Stage at which a candidate attempt ended. Used in
  * {@link AttemptDiagnostic} to indicate how far the attempt progressed.
@@ -212,6 +226,12 @@ export interface BackendCandidate {
   readonly kind: CdpClientKind;
   /** Human-readable reason this candidate was included. */
   readonly reason: string;
+  /**
+   * Actor the candidate was built for. Set on host-bridge candidates so
+   * a transport failure records the cooldown for the owning actor only
+   * (the bridge reaches a different desktop machine per actor).
+   */
+  readonly sourceActorPrincipalId?: string;
   /**
    * Materialise the backend. Called at most once — the factory caches
    * the result after the first successful CDP command so subsequent

package/src/tools/credential-execution/make-authenticated-request.ts

@@ -16,6 +16,7 @@ import {
 } from "@vellumai/service-contracts/credential-rpc";
 
 import { RiskLevel } from "../../permissions/types.js";
+import { getCesClient } from "../../security/secure-keys.js";
 import { getLogger } from "../../util/logger.js";
 import type {
   ToolContext,
@@ -77,7 +78,7 @@ export const makeAuthenticatedRequestTool = {
     input: Record<string, unknown>,
     context: ToolContext,
   ): Promise<ToolExecutionResult> {
-    const cesClient = context.cesClient;
+    const cesClient = getCesClient();
     if (!cesClient) {
       return {
         content: