@vellumai/assistant 0.8.4 → 0.8.6

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

@@ -710,6 +710,18 @@ export class CdpInspectClient implements ScopedCdpClient {
     // no-op
   }
 
+  async listTabs(): Promise<never> {
+    throw new CdpError("transport_error", "listTabs is not supported by the cdp-inspect backend (extension backend required)");
+  }
+
+  async selectTab(_tabId: number): Promise<never> {
+    throw new CdpError("transport_error", "selectTab is not supported by the cdp-inspect backend (extension backend required)");
+  }
+
+  async closeTab(_tabId: number): Promise<never> {
+    throw new CdpError("transport_error", "closeTab is not supported by the cdp-inspect backend (extension backend required)");
+  }
+
   dispose(): void {
     if (this.disposed) return;
     this.disposed = true;

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

@@ -2,7 +2,7 @@ import type { HostBrowserProxy } from "../../../daemon/host-browser-proxy.js";
 import { getLogger } from "../../../util/logger.js";
 import type { CdpErrorCode } from "./errors.js";
 import { CdpError } from "./errors.js";
-import type { CdpClientKind, ScopedCdpClient } from "./types.js";
+import type { CdpClientKind, ScopedCdpClient, TabInfo } from "./types.js";
 
 const log = getLogger("extension-cdp-client");
 
@@ -196,6 +196,32 @@ export class ExtensionCdpClient implements ScopedCdpClient {
   setCdpSessionId(cdpSessionId: string | undefined): void {
     this.cdpSessionId = cdpSessionId;
   }
+
+  /** List all open browser tabs via `Vellum.listTabs`. */
+  async listTabs(): Promise<TabInfo[]> {
+    const result = await this.send<{ tabs: TabInfo[] }>("Vellum.listTabs", {});
+    return Array.isArray(result?.tabs) ? result.tabs : [];
+  }
+
+  /** Select (activate) an existing tab via `Vellum.selectTab`. */
+  async selectTab(tabId: number): Promise<{
+    tabId?: number;
+    windowId?: number;
+    url?: string;
+    title?: string;
+    clientId?: string;
+  }> {
+    return this.send("Vellum.selectTab", { tabId });
+  }
+
+  /** Close a browser tab via `Vellum.closeTab`. */
+  async closeTab(tabId: number): Promise<{
+    closed: boolean;
+    tabId: number;
+    clientId?: string;
+  }> {
+    return this.send("Vellum.closeTab", { tabId });
+  }
 }
 
 /**

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

@@ -23,6 +23,7 @@ import type {
   CdpClient,
   CdpClientKind,
   ScopedCdpClient,
+  TabInfo,
 } from "./types.js";
 
 const log = getLogger("cdp-factory");
@@ -223,14 +224,12 @@ export function buildPinnedCandidateList(
             const client = createExtensionCdpClient(
               hostBrowserProxy,
               conversationId,
-              // Conversation pins are scoped to "default routing on
-              // this conversation". When `target_client_id` is an
-              // explicit override, the caller is taking over routing
-              // and the pin (which may point at a tab on a different
-              // host client) must not be applied — otherwise we'd
-              // send tabId from host A to host B and get
-              // cdp_session_not_found.
-              targetClientId ? undefined : getPinnedTab(conversationId),
+              // Pass clientId to scope the pin lookup to this specific
+              // extension install. When a targetClientId is provided
+              // the pin is fetched for that client; otherwise falls back
+              // to the __default__ slot which is set by older callers
+              // without clientId awareness.
+              getPinnedTab(conversationId, targetClientId),
               sourceActorPrincipalId,
               targetClientId,
             );
@@ -338,15 +337,13 @@ export function buildCandidateList(context: ToolContext, targetClientId?: string
         kind: "extension",
         reason: `target_client_id override: ${targetClientId}`,
         create() {
-          // Explicit target_client_id override → ignore the
-          // conversation's pinned tab. Pins are conversation-scoped
-          // (not host-client-scoped) and would route a tabId from
-          // a different host to this one, producing
-          // cdp_session_not_found.
+          // Explicit target_client_id override → look up the pin scoped
+          // to this specific client. This is safe because targetClientId
+          // and the pin were both recorded for the same extension install.
           const client = createExtensionCdpClient(
             hostBrowserProxy,
             conversationId,
-            undefined,
+            getPinnedTab(conversationId, targetClientId),
             sourceActorPrincipalId,
             targetClientId,
           );
@@ -371,9 +368,11 @@ export function buildCandidateList(context: ToolContext, targetClientId?: string
         const client = createExtensionCdpClient(
           hostBrowserProxy,
           conversationId,
-          // See comment above the pinned-mode call site for why pins
-          // are skipped under explicit target_client_id override.
-          targetClientId ? undefined : getPinnedTab(conversationId),
+          // targetClientId is always undefined here — this code path
+          // only runs when targetClientId is null (the early-return
+          // above handles the non-null case). Use the no-clientId
+          // lookup which returns the first pin for auto-routing.
+          getPinnedTab(conversationId),
           sourceActorPrincipalId,
           targetClientId,
         );
@@ -632,6 +631,90 @@ export function buildChainedClient(
       }
       pendingCdpSessionId = cdpSessionId;
     },
+
+    async listTabs(): Promise<TabInfo[]> {
+      if (sticky && active?.client.listTabs) {
+        return active.client.listTabs();
+      }
+      if (sticky) {
+        throw new CdpError(
+          "transport_error",
+          "listTabs is not supported by the current backend (extension backend required)",
+        );
+      }
+      // Fresh client: route through the failover walk so the extension
+      // backend is selected automatically. The Vellum.listTabs pseudo-method
+      // is handled by the extension dispatcher before chrome.debugger.sendCommand.
+      const result = await scopedClient.send<{ tabs?: TabInfo[] }>("Vellum.listTabs", {});
+      if (!active?.client.listTabs) {
+        // Backend became sticky but isn't an extension client — not supported.
+        throw new CdpError(
+          "transport_error",
+          "listTabs is not supported by the current backend (extension backend required)",
+        );
+      }
+      return Array.isArray(result?.tabs) ? result.tabs : [];
+    },
+
+    async selectTab(tabId: number): Promise<{
+      tabId?: number;
+      windowId?: number;
+      url?: string;
+      title?: string;
+      clientId?: string;
+    }> {
+      if (sticky && active?.client.selectTab) {
+        return active.client.selectTab(tabId);
+      }
+      if (sticky) {
+        throw new CdpError(
+          "transport_error",
+          "selectTab is not supported by the current backend (extension backend required)",
+        );
+      }
+      const result = await scopedClient.send<{
+        tabId?: number;
+        windowId?: number;
+        url?: string;
+        title?: string;
+        clientId?: string;
+      }>("Vellum.selectTab", { tabId });
+      if (!active?.client.selectTab) {
+        throw new CdpError(
+          "transport_error",
+          "selectTab is not supported by the current backend (extension backend required)",
+        );
+      }
+      return result;
+    },
+
+    async closeTab(tabId: number): Promise<{
+      closed: boolean;
+      tabId: number;
+      clientId?: string;
+    }> {
+      if (sticky && active?.client.closeTab) {
+        return active.client.closeTab(tabId);
+      }
+      if (sticky) {
+        throw new CdpError(
+          "transport_error",
+          "closeTab is not supported by the current backend (extension backend required)",
+        );
+      }
+      const result = await scopedClient.send<{
+        closed: boolean;
+        tabId: number;
+        clientId?: string;
+      }>("Vellum.closeTab", { tabId });
+      if (!active?.client.closeTab) {
+        throw new CdpError(
+          "transport_error",
+          "closeTab is not supported by the current backend (extension backend required)",
+        );
+      }
+      return result;
+    },
   };
 
   return scopedClient;

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

@@ -165,6 +165,18 @@ export class LocalCdpClient implements ScopedCdpClient {
     // no-op
   }
 
+  async listTabs(): Promise<never> {
+    throw new CdpError("transport_error", "listTabs is not supported by the local backend (extension backend required)");
+  }
+
+  async selectTab(_tabId: number): Promise<never> {
+    throw new CdpError("transport_error", "selectTab is not supported by the local backend (extension backend required)");
+  }
+
+  async closeTab(_tabId: number): Promise<never> {
+    throw new CdpError("transport_error", "closeTab is not supported by the local backend (extension backend required)");
+  }
+
   dispose(): void {
     if (this.disposed) return;
     this.disposed = true;

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

@@ -10,6 +10,16 @@
 
 import type { BrowserBackend } from "../../../browser-session/types.js";
 
+/** Shape of a single Chrome tab as returned by Vellum.listTabs. */
+export interface TabInfo {
+  tabId?: number;
+  windowId?: number;
+  url?: string;
+  title?: string;
+  active: boolean;
+  pinned: boolean;
+}
+
 export interface CdpClient {
   /**
    * Send a CDP command and await the result. `method` must be a
@@ -53,6 +63,33 @@ export interface CdpClient {
    * Optional — callers should null-check before invoking.
    */
   setCdpSessionId?(cdpSessionId: string | undefined): void;
+
+  /**
+   * List all open browser tabs. Extension backend only — returns
+   * `{ tabId, windowId, url, title, active, pinned }[]`.
+   * Optional — callers must null-check before invoking.
+   */
+  listTabs?(): Promise<TabInfo[]>;
+
+  /**
+   * Select (activate) an existing tab. Extension backend only. Optional.
+   */
+  selectTab?(tabId: number): Promise<{
+    tabId?: number;
+    windowId?: number;
+    url?: string;
+    title?: string;
+    clientId?: string;
+  }>;
+
+  /**
+   * Close a browser tab by ID. Extension backend only. Optional.
+   */
+  closeTab?(tabId: number): Promise<{
+    closed: boolean;
+    tabId: number;
+    clientId?: string;
+  }>;
 }
 
 /**
@@ -133,6 +170,34 @@ export interface ScopedCdpClient extends CdpClient {
    * chaining.
    */
   setCdpSessionId(cdpSessionId: string | undefined): void;
+
+  /**
+   * List all open browser tabs. Throws with code "transport_error" if
+   * the current backend does not support tab listing.
+   */
+  listTabs(): Promise<TabInfo[]>;
+
+  /**
+   * Select (activate) an existing tab. Throws if backend doesn't support it.
+   */
+  selectTab(tabId: number): Promise<{
+    tabId?: number;
+    windowId?: number;
+    url?: string;
+    title?: string;
+    clientId?: string;
+  }>;
+
+  /**
+   * Close a browser tab by ID. Throws if backend doesn't support it.
+   * The optional `clientId` identifies which extension client actually
+   * closed the tab — used to scope pin cleanup in multi-client setups.
+   */
+  closeTab(tabId: number): Promise<{
+    closed: boolean;
+    tabId: number;
+    clientId?: string;
+  }>;
 }
 
 /**

package/src/tools/browser/pinned-tabs.ts

@@ -1,60 +1,97 @@
 /**
- * Per-conversation pinned-tab store for the Chrome extension browser
- * backend.
+ * Per-conversation, per-client pinned-tab store for the Chrome extension
+ * browser backend.
  *
- * When a navigate is issued with `new_tab: true`, the executor first
- * asks the extension to open a fresh tab (via the `Vellum.createTab`
- * pseudo-CDP method), then records the returned tabId here against the
- * conversation. Subsequent CDP commands constructed for the same
- * conversation pick up this tabId as the `cdpSessionId` on the
- * outgoing envelope, which causes the extension's
- * `resolveHostBrowserTarget` to route to that specific tab instead of
- * falling back to `chrome.tabs.query({ active: true })`.
+ * Pin store key is (conversationId, clientId) → tabId. This scopes pins
+ * to a specific extension instance so that closing a tab on clientA does
+ * not clear clientB's pin to a tab with the same numeric ID on a
+ * different Chrome instance (issue #31361).
  *
  * Persistence is process-lifetime (in-memory only). The daemon is a
  * single process and all CLI invocations land in it via IPC, so a
  * module-level Map is sufficient. A pin is cleared when the extension
- * reports the underlying CDP target as invalidated (see
- * `consumeInvalidatedTargetId` in `browser-session/events.ts`) — that
- * eviction is wired through `BrowserSessionManager.invalidateByTargetId`
- * and the host-browser session-invalidated event route.
+ * reports the underlying CDP target as invalidated via
+ * `host_browser_session_invalidated`.
  */
 
 import { log } from "../../cli/logger.js";
 
-const pinnedTabs = new Map<string, string>();
+const pinnedTabs = new Map<string, Map<string, string>>();
 
 /**
- * Record a tabId as the pinned tab for the given conversation. The
- * tabId is stored as a string because it travels on the wire as
- * `cdpSessionId` (a string-typed field on the host-browser envelope).
+ * Record a tabId as the pinned tab for the given conversation and optional
+ * client. The tabId is stored as a string because it travels on the wire
+ * as `cdpSessionId` (a string-typed field on the host-browser envelope).
  */
-export function setPinnedTab(conversationId: string, tabId: string): void {
+export function setPinnedTab(
+  conversationId: string,
+  tabId: string,
+  clientId?: string,
+): void {
   if (!conversationId || !tabId) return;
-  pinnedTabs.set(conversationId, tabId);
+  const key = clientId ?? "__default__";
+  let inner = pinnedTabs.get(conversationId);
+  if (!inner) {
+    inner = new Map();
+    pinnedTabs.set(conversationId, inner);
+  }
+  inner.set(key, tabId);
   log.debug(
-    { conversationId, tabId },
+    { conversationId, clientId, tabId },
     "Pinned extension tab for conversation",
   );
 }
 
 /**
- * Return the tabId pinned to the given conversation, or undefined if
- * no pin exists.
+ * Return the tabId pinned to the given conversation and optional client,
+ * or undefined if no pin exists.
+ *
+ * When `clientId` is provided, returns the pin for that client first,
+ * falling back to the `__default__` slot. When no `clientId` is given,
+ * returns the first entry (best-guess for auto-routing).
  */
-export function getPinnedTab(conversationId: string): string | undefined {
+export function getPinnedTab(
+  conversationId: string,
+  clientId?: string,
+): string | undefined {
   if (!conversationId) return undefined;
-  return pinnedTabs.get(conversationId);
+  const inner = pinnedTabs.get(conversationId);
+  if (!inner) return undefined;
+  if (clientId !== undefined) {
+    return inner.get(clientId) ?? inner.get("__default__");
+  }
+  // No clientId: return the first entry (best-guess for auto-routing)
+  const first = inner.values().next();
+  return first.done ? undefined : first.value;
 }
 
 /**
- * Clear the pin for the given conversation. Idempotent — clearing a
- * non-existent pin is a no-op.
+ * Clear the pin for the given conversation and optional client. Idempotent
+ * — clearing a non-existent pin is a no-op.
+ *
+ * When `clientId` is provided, only clears that client's slot. When
+ * omitted, clears all client slots for the conversation.
  */
-export function clearPinnedTab(conversationId: string): void {
+export function clearPinnedTab(
+  conversationId: string,
+  clientId?: string,
+): void {
   if (!conversationId) return;
-  if (pinnedTabs.delete(conversationId)) {
-    log.debug({ conversationId }, "Cleared pinned extension tab");
+  const inner = pinnedTabs.get(conversationId);
+  if (!inner) return;
+  if (clientId !== undefined) {
+    if (inner.delete(clientId)) {
+      log.debug({ conversationId, clientId }, "Cleared pinned extension tab");
+    }
+    if (inner.size === 0) pinnedTabs.delete(conversationId);
+  } else {
+    // Clear all clients for this conversation
+    if (pinnedTabs.delete(conversationId)) {
+      log.debug(
+        { conversationId },
+        "Cleared all pinned extension tabs for conversation",
+      );
+    }
   }
 }
 
@@ -64,20 +101,39 @@ export function clearPinnedTab(conversationId: string): void {
  * crashed, navigated away from a debuggable URL, etc.) so we don't
  * keep routing to a dead tab.
  *
- * Returns the number of conversations whose pin was cleared.
+ * When `clientId` is provided, only clears the slot for that client.
+ * When omitted, clears all entries pointing at this tabId (backward compat).
+ *
+ * Returns the number of slots cleared.
  */
-export function clearPinnedTabByTabId(tabId: string): number {
+export function clearPinnedTabByTabId(tabId: string, clientId?: string): number {
   if (!tabId) return 0;
   let cleared = 0;
-  for (const [conversationId, pinned] of pinnedTabs.entries()) {
-    if (pinned === tabId) {
-      pinnedTabs.delete(conversationId);
-      cleared++;
-      log.debug(
-        { conversationId, tabId },
-        "Cleared pinned extension tab due to invalidation",
-      );
+  for (const [conversationId, inner] of pinnedTabs.entries()) {
+    if (clientId !== undefined) {
+      // Only clear the specific client's slot if its tabId matches
+      if (inner.get(clientId) === tabId) {
+        inner.delete(clientId);
+        cleared++;
+        log.debug(
+          { conversationId, clientId, tabId },
+          "Cleared pinned extension tab due to invalidation",
+        );
+      }
+    } else {
+      // Backward compat: clear all entries pointing at this tabId
+      for (const [cid, pinned] of inner.entries()) {
+        if (pinned === tabId) {
+          inner.delete(cid);
+          cleared++;
+          log.debug(
+            { conversationId, clientId: cid, tabId },
+            "Cleared pinned extension tab due to invalidation",
+          );
+        }
+      }
     }
+    if (inner.size === 0) pinnedTabs.delete(conversationId);
   }
   return cleared;
 }