@vellumai/assistant 0.8.4 → 0.8.5

package/src/tools/ask-question/ask-question-tool.ts

@@ -2,13 +2,12 @@ import { z } from "zod";
 
 import { QuestionPrompter } from "../../permissions/question-prompter.js";
 import { RiskLevel } from "../../permissions/types.js";
-import type { ToolDefinition } from "../../providers/types.js";
 import { broadcastMessage } from "../../runtime/assistant-event-hub.js";
 import type { Tool, ToolContext, ToolExecutionResult } from "../types.js";
 
 // ── Input schema ────────────────────────────────────────────────────
 // Runtime validation lives in Zod; the wire-level definition surfaced
-// to the LLM is the hand-written JSON Schema in getDefinition() below.
+// to the LLM is the hand-written JSON Schema in `input_schema` below.
 // (The codebase does not currently use zod-to-json-schema for tool defs,
 // so the two are kept in sync manually.)
 
@@ -109,53 +108,37 @@ const DESCRIPTION = [
   "context shown beneath the label.",
 ].join("\n");
 
+// Shared option-schema fragment used by both the batched `questions[]`
+// shape and the legacy flat `options` field.
+const OPTION_ITEMS_SCHEMA = {
+  type: "object",
+  properties: {
+    id: {
+      type: "string",
+      description:
+        "Stable identifier for this option (returned verbatim in the response).",
+    },
+    label: {
+      type: "string",
+      description: "Short human-readable label.",
+    },
+    description: {
+      type: "string",
+      description: "Optional one-line context shown beneath the label.",
+    },
+  },
+  required: ["id", "label"],
+} as const;
+
 // ── Tool ────────────────────────────────────────────────────────────
 
 export class AskQuestionTool implements Tool {
   name = "ask_question";
   description = DESCRIPTION;
   category = "interaction";
+  executionTarget = "sandbox" as const;
   defaultRiskLevel = RiskLevel.Low;
-
-  // Override hook for tests: lets a test replace the prompter factory
-  // without monkey-patching the module. Default factory wires the real
-  // broadcastMessage so the question reaches every connected client.
-  private prompterFactory: () => Pick<QuestionPrompter, "prompt">;
-
-  constructor(
-    prompterFactory: () => Pick<QuestionPrompter, "prompt"> = () =>
-      new QuestionPrompter({ broadcastMessage }),
-  ) {
-    this.prompterFactory = prompterFactory;
-  }
-
-  getDefinition(): ToolDefinition {
-    // Shared option-schema fragment used by both the batched `questions[]`
-    // shape and the legacy flat `options` field.
-    const optionItemsSchema = {
-      type: "object",
-      properties: {
-        id: {
-          type: "string",
-          description:
-            "Stable identifier for this option (returned verbatim in the response).",
-        },
-        label: {
-          type: "string",
-          description: "Short human-readable label.",
-        },
-        description: {
-          type: "string",
-          description: "Optional one-line context shown beneath the label.",
-        },
-      },
-      required: ["id", "label"],
-    } as const;
-
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
+  input_schema = {
         type: "object",
         properties: {
           // ── Recommended shape ─────────────────────────────────────
@@ -182,7 +165,7 @@ export class AskQuestionTool implements Tool {
                   maxItems: 4,
                   description:
                     "2–4 structured options. The UI always appends a free-text fallback slot, so do not include a 'something else' option here.",
-                  items: optionItemsSchema,
+                  items: OPTION_ITEMS_SCHEMA,
                 },
                 freeTextPlaceholder: {
                   type: "string",
@@ -212,7 +195,7 @@ export class AskQuestionTool implements Tool {
             maxItems: 4,
             description:
               "Legacy: 2–4 structured options. Prefer `questions[].options`. The UI always appends a free-text fallback slot, so do not include a 'something else' option here.",
-            items: optionItemsSchema,
+            items: OPTION_ITEMS_SCHEMA,
           },
           freeTextPlaceholder: {
             type: "string",
@@ -222,8 +205,18 @@ export class AskQuestionTool implements Tool {
         },
         // No top-level `required` — caller must supply either `questions`
         // or the legacy flat trio (`question` + `options`). Enforced in Zod.
-      },
     };
+
+  // Override hook for tests: lets a test replace the prompter factory
+  // without monkey-patching the module. Default factory wires the real
+  // broadcastMessage so the question reaches every connected client.
+  private prompterFactory: () => Pick<QuestionPrompter, "prompt">;
+
+  constructor(
+    prompterFactory: () => Pick<QuestionPrompter, "prompt"> = () =>
+      new QuestionPrompter({ broadcastMessage }),
+  ) {
+    this.prompterFactory = prompterFactory;
   }
 
   async execute(

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

@@ -77,4 +77,74 @@ describe("pinned-tabs", () => {
     setPinnedTab("conv-a", "");
     expect(getPinnedTab("conv-a")).toBeUndefined();
   });
+
+  describe("cross-client isolation (#31361)", () => {
+    test("same tabId on different clients are stored independently", () => {
+      setPinnedTab("conv-a", "99", "clientA");
+      setPinnedTab("conv-a", "99", "clientB");
+      expect(getPinnedTab("conv-a", "clientA")).toBe("99");
+      expect(getPinnedTab("conv-a", "clientB")).toBe("99");
+    });
+
+    test("clearPinnedTabByTabId with clientId only clears that client", () => {
+      setPinnedTab("conv-a", "99", "clientA");
+      setPinnedTab("conv-b", "99", "clientB");
+
+      const cleared = clearPinnedTabByTabId("99", "clientA");
+
+      expect(cleared).toBe(1);
+      expect(getPinnedTab("conv-a", "clientA")).toBeUndefined();
+      expect(getPinnedTab("conv-b", "clientB")).toBe("99"); // clientB's pin survives
+    });
+
+    test("getPinnedTab with matching clientId returns correct tabId", () => {
+      setPinnedTab("conv-x", "42", "clientA");
+      setPinnedTab("conv-x", "77", "clientB");
+
+      expect(getPinnedTab("conv-x", "clientA")).toBe("42");
+      expect(getPinnedTab("conv-x", "clientB")).toBe("77");
+    });
+
+    test("clearPinnedTabByTabId without clientId clears all matching entries (backward compat)", () => {
+      setPinnedTab("conv-a", "99", "clientA");
+      setPinnedTab("conv-b", "99", "clientB");
+
+      const cleared = clearPinnedTabByTabId("99");
+
+      expect(cleared).toBe(2);
+      expect(getPinnedTab("conv-a", "clientA")).toBeUndefined();
+      expect(getPinnedTab("conv-b", "clientB")).toBeUndefined();
+    });
+
+    test("clearPinnedTab with clientId only removes that client slot", () => {
+      setPinnedTab("conv-a", "42", "clientA");
+      setPinnedTab("conv-a", "77", "clientB");
+
+      clearPinnedTab("conv-a", "clientA");
+
+      expect(getPinnedTab("conv-a", "clientA")).toBeUndefined();
+      expect(getPinnedTab("conv-a", "clientB")).toBe("77");
+    });
+
+    test("clearPinnedTab without clientId removes all slots", () => {
+      setPinnedTab("conv-a", "42", "clientA");
+      setPinnedTab("conv-a", "77", "clientB");
+
+      clearPinnedTab("conv-a");
+
+      expect(getPinnedTab("conv-a", "clientA")).toBeUndefined();
+      expect(getPinnedTab("conv-a", "clientB")).toBeUndefined();
+    });
+
+    test("getPinnedTab with unknown clientId falls back to __default__ slot", () => {
+      setPinnedTab("conv-a", "42"); // stored in __default__ slot
+      expect(getPinnedTab("conv-a", "clientA")).toBe("42");
+    });
+
+    test("getPinnedTab without clientId returns first entry", () => {
+      setPinnedTab("conv-a", "42", "clientA");
+      const result = getPinnedTab("conv-a");
+      expect(result).toBe("42");
+    });
+  });
 });

package/src/tools/browser/browser-execution.ts

@@ -481,6 +481,15 @@ function wrapWithKindMemo(
     setCdpSessionId(cdpSessionId: string): void {
       inner.setCdpSessionId?.(cdpSessionId);
     },
+    listTabs() {
+      return inner.listTabs();
+    },
+    selectTab(tabId: number) {
+      return inner.selectTab(tabId);
+    },
+    closeTab(tabId: number) {
+      return inner.closeTab(tabId);
+    },
   };
 }
 
@@ -644,7 +653,7 @@ export async function executeBrowserNavigate(
   const newTab = input.new_tab === true;
   if (newTab && cdp.kind === "extension") {
     try {
-      const result = await cdp.send<{ tabId?: number | string }>(
+      const result = await cdp.send<{ tabId?: number | string; clientId?: string }>(
         "Vellum.createTab",
         {},
         context.signal,
@@ -655,6 +664,10 @@ export async function executeBrowserNavigate(
           : typeof result?.tabId === "string"
             ? result.tabId
             : undefined;
+      const clientId =
+        typeof result?.clientId === "string" && result.clientId.length > 0
+          ? result.clientId
+          : undefined;
       if (!tabId) {
         // Malformed createTab response (no tabId). We're nominally falling
         // back to active-tab routing — but the live `cdp` instance was
@@ -676,9 +689,9 @@ export async function executeBrowserNavigate(
         );
       } else {
         cdp.setCdpSessionId?.(tabId);
-        setPinnedTab(context.conversationId, tabId);
+        setPinnedTab(context.conversationId, tabId, clientId);
         log.debug(
-          { conversationId: context.conversationId, tabId },
+          { conversationId: context.conversationId, tabId, clientId },
           "Opened new tab via --new-tab; pinned subsequent ops to it",
         );
       }

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

@@ -0,0 +1,402 @@
+/**
+ * Tests that listTabs, selectTab, and closeTab are properly forwarded through
+ * the real buildChainedClient wrapper.
+ *
+ * Per the test-flat-mocks-trap rule, these tests use the REAL buildChainedClient
+ * function with a mock candidate — NOT a flat fake that has the methods defined
+ * directly on the scoped client.
+ */
+
+import { describe, expect, mock, test } from "bun:test";
+
+import type { BrowserBackend, CdpCommand, CdpResult } from "../../../../browser-session/types.js";
+import { CdpError } from "../errors.js";
+import type { BackendCandidate, CdpClient, TabInfo } from "../types.js";
+
+// Import buildChainedClient directly. Since this test file does not mock
+// any of factory.ts's imports, we import directly.
+const { buildChainedClient } = await import("../factory.js");
+
+// ── Helpers ───────────────────────────────────────────────────────────
+
+/**
+ * Create a BrowserBackend that delegates CDP sends through a CdpClient.
+ * This is the real wiring that factory.ts uses — the backend wraps the
+ * client's send method via dispatchThroughClient.
+ */
+function makeBackendFromClient(client: CdpClient, kind: "extension" | "local" | "cdp-inspect"): BrowserBackend {
+  return {
+    kind,
+    isAvailable: () => true,
+    send: async (command: CdpCommand, signal?: AbortSignal): Promise<CdpResult> => {
+      try {
+        const result = await client.send(command.method, command.params, signal);
+        return { result };
+      } catch (err) {
+        if (err instanceof CdpError) {
+          return {
+            error: { code: -1, message: err.message, data: err },
+          };
+        }
+        throw err;
+      }
+    },
+    dispose: () => client.dispose(),
+  };
+}
+
+interface FakeClientWithTabMethods extends CdpClient {
+  kind: "extension";
+  conversationId: string;
+  listTabsMock: ReturnType<typeof mock>;
+  selectTabMock: ReturnType<typeof mock>;
+  closeTabMock: ReturnType<typeof mock>;
+}
+
+function makeFakeExtensionClientWithTabMethods(
+  conversationId: string,
+): FakeClientWithTabMethods {
+  const listTabsMock = mock(async (): Promise<TabInfo[]> => [
+    {
+      tabId: 1,
+      windowId: 10,
+      url: "https://example.com",
+      title: "Example",
+      active: true,
+      pinned: false,
+    },
+  ]);
+  const selectTabMock = mock(async (_tabId: number) => ({
+    tabId: 42,
+    windowId: 10,
+    url: "https://example.com",
+    title: "Example",
+    clientId: "clientA",
+  }));
+  const closeTabMock = mock(async (_tabId: number) => ({
+    closed: true as const,
+    tabId: 99,
+  }));
+
+  return {
+    kind: "extension",
+    conversationId,
+    listTabsMock,
+    selectTabMock,
+    closeTabMock,
+    send: mock(async () => ({ ok: true })) as unknown as CdpClient["send"],
+    dispose: mock(() => {}),
+    listTabs: listTabsMock,
+    selectTab: selectTabMock,
+    closeTab: closeTabMock,
+  };
+}
+
+/**
+ * Build a BackendCandidate that wraps a fake extension client with tab methods.
+ */
+function makeCandidateFromClient(
+  conversationId: string,
+  fakeClient: CdpClient,
+  kind: "extension" | "local" | "cdp-inspect",
+): BackendCandidate {
+  return {
+    kind,
+    reason: `test ${kind} client`,
+    create() {
+      return {
+        client: fakeClient,
+        backend: makeBackendFromClient(fakeClient, kind),
+      };
+    },
+  };
+}
+
+// ── Helpers for fresh-client (pre-sticky) tests ───────────────────────
+
+/**
+ * A fake extension client whose `send` method returns Vellum.* pseudo-responses
+ * so that fresh-client tab calls can succeed without a prior `send("Runtime.*")`.
+ * This simulates how the real ExtensionCdpClient handles Vellum.listTabs etc.
+ * through the dispatcher before chrome.debugger.sendCommand.
+ */
+function makeFakeExtensionClientForFreshPath(conversationId: string) {
+  return {
+    kind: "extension" as const,
+    conversationId,
+    send: mock(
+      async (method: string, params?: Record<string, unknown>): Promise<unknown> => {
+        if (method === "Vellum.listTabs") {
+          return {
+            tabs: [
+              {
+                tabId: 1,
+                windowId: 10,
+                url: "https://example.com",
+                title: "Example",
+                active: true,
+                pinned: false,
+              },
+            ],
+          };
+        }
+        if (method === "Vellum.selectTab") {
+          return {
+            tabId: params?.tabId,
+            windowId: 10,
+            url: "https://example.com",
+            title: "Example",
+            clientId: "clientA",
+          };
+        }
+        if (method === "Vellum.closeTab") {
+          return { closed: true, tabId: params?.tabId };
+        }
+        return {};
+      },
+    ) as unknown as CdpClient["send"],
+    dispose: mock(() => {}),
+    // These must be present so active?.client.listTabs etc. check passes
+    listTabs: mock(async (): Promise<TabInfo[]> => []),
+    selectTab: mock(async (_tabId: number) => ({
+      tabId: _tabId,
+      windowId: 10,
+      url: "https://example.com",
+      title: "Example",
+      clientId: "clientA",
+    })),
+    closeTab: mock(async (_tabId: number) => ({
+      closed: true as const,
+      tabId: _tabId,
+    })),
+  };
+}
+
+// ── Tests ─────────────────────────────────────────────────────────────
+
+describe("buildChainedClient — tab management methods", () => {
+  test("listTabs is forwarded to the underlying client after backend becomes sticky", async () => {
+    const conversationId = "conv-tabs-list";
+    const fakeClient = makeFakeExtensionClientWithTabMethods(conversationId);
+    const candidate = makeCandidateFromClient(conversationId, fakeClient, "extension");
+
+    const scoped = buildChainedClient(conversationId, [candidate]);
+
+    // Establish sticky by sending a command first
+    await scoped.send("Runtime.evaluate", {});
+
+    const tabs = await scoped.listTabs();
+    expect(tabs).toHaveLength(1);
+    expect(tabs[0].tabId).toBe(1);
+    expect(tabs[0].active).toBe(true);
+    expect(fakeClient.listTabsMock).toHaveBeenCalledTimes(1);
+
+    scoped.dispose();
+  });
+
+  test("selectTab is forwarded to the underlying client", async () => {
+    const conversationId = "conv-tabs-select";
+    const fakeClient = makeFakeExtensionClientWithTabMethods(conversationId);
+    const candidate = makeCandidateFromClient(conversationId, fakeClient, "extension");
+
+    const scoped = buildChainedClient(conversationId, [candidate]);
+
+    // Establish sticky
+    await scoped.send("Runtime.evaluate", {});
+
+    const result = await scoped.selectTab(42);
+    expect(result.tabId).toBe(42);
+    expect(result.clientId).toBe("clientA");
+    expect(fakeClient.selectTabMock).toHaveBeenCalledWith(42);
+
+    scoped.dispose();
+  });
+
+  test("closeTab is forwarded to the underlying client", async () => {
+    const conversationId = "conv-tabs-close";
+    const fakeClient = makeFakeExtensionClientWithTabMethods(conversationId);
+    const candidate = makeCandidateFromClient(conversationId, fakeClient, "extension");
+
+    const scoped = buildChainedClient(conversationId, [candidate]);
+
+    // Establish sticky
+    await scoped.send("Runtime.evaluate", {});
+
+    const result = await scoped.closeTab(99);
+    expect(result.closed).toBe(true);
+    expect(result.tabId).toBe(99);
+    expect(fakeClient.closeTabMock).toHaveBeenCalledWith(99);
+
+    scoped.dispose();
+  });
+
+  test("listTabs throws transport_error when backend does not support it", async () => {
+    const conversationId = "conv-tabs-no-list";
+    // A local client without listTabs/selectTab/closeTab
+    const noTabsClient: CdpClient & {
+      kind: "local";
+      conversationId: string;
+    } = {
+      kind: "local",
+      conversationId,
+      send: mock(async () => ({})) as unknown as CdpClient["send"],
+      dispose: mock(() => {}),
+    };
+    const candidate = makeCandidateFromClient(
+      conversationId,
+      noTabsClient,
+      "local",
+    );
+
+    const scoped = buildChainedClient(conversationId, [candidate]);
+
+    // Establish sticky
+    await scoped.send("Runtime.evaluate", {});
+
+    let caught: unknown;
+    try {
+      await scoped.listTabs();
+    } catch (err) {
+      caught = err;
+    }
+    expect(caught).toBeInstanceOf(CdpError);
+    expect((caught as CdpError).code).toBe("transport_error");
+
+    scoped.dispose();
+  });
+
+  test("selectTab throws transport_error when backend does not support it", async () => {
+    const conversationId = "conv-tabs-no-select";
+    const noTabsClient: CdpClient & {
+      kind: "local";
+      conversationId: string;
+    } = {
+      kind: "local",
+      conversationId,
+      send: mock(async () => ({})) as unknown as CdpClient["send"],
+      dispose: mock(() => {}),
+    };
+    const candidate = makeCandidateFromClient(
+      conversationId,
+      noTabsClient,
+      "local",
+    );
+
+    const scoped = buildChainedClient(conversationId, [candidate]);
+
+    // Establish sticky
+    await scoped.send("Runtime.evaluate", {});
+
+    let caught: unknown;
+    try {
+      await scoped.selectTab(42);
+    } catch (err) {
+      caught = err;
+    }
+    expect(caught).toBeInstanceOf(CdpError);
+    expect((caught as CdpError).code).toBe("transport_error");
+
+    scoped.dispose();
+  });
+
+  test("closeTab throws transport_error when backend does not support it", async () => {
+    const conversationId = "conv-tabs-no-close";
+    const noTabsClient: CdpClient & {
+      kind: "local";
+      conversationId: string;
+    } = {
+      kind: "local",
+      conversationId,
+      send: mock(async () => ({})) as unknown as CdpClient["send"],
+      dispose: mock(() => {}),
+    };
+    const candidate = makeCandidateFromClient(
+      conversationId,
+      noTabsClient,
+      "local",
+    );
+
+    const scoped = buildChainedClient(conversationId, [candidate]);
+
+    // Establish sticky
+    await scoped.send("Runtime.evaluate", {});
+
+    let caught: unknown;
+    try {
+      await scoped.closeTab(77);
+    } catch (err) {
+      caught = err;
+    }
+    expect(caught).toBeInstanceOf(CdpError);
+    expect((caught as CdpError).code).toBe("transport_error");
+
+    scoped.dispose();
+  });
+});
+
+describe("buildChainedClient — fresh-client tab calls (no prior send)", () => {
+  test("listTabs on a fresh client triggers failover walk and returns tabs", async () => {
+    const conversationId = "conv-fresh-list";
+    const fakeClient = makeFakeExtensionClientForFreshPath(conversationId);
+    const candidate = makeCandidateFromClient(conversationId, fakeClient, "extension");
+    const scoped = buildChainedClient(conversationId, [candidate]);
+
+    // Call listTabs WITHOUT establishing sticky — this is the production scenario
+    const tabs = await scoped.listTabs();
+    expect(tabs).toHaveLength(1);
+    expect(tabs[0].tabId).toBe(1);
+    expect(tabs[0].active).toBe(true);
+
+    scoped.dispose();
+  });
+
+  test("selectTab on a fresh client triggers failover walk and returns tab info", async () => {
+    const conversationId = "conv-fresh-select";
+    const fakeClient = makeFakeExtensionClientForFreshPath(conversationId);
+    const candidate = makeCandidateFromClient(conversationId, fakeClient, "extension");
+    const scoped = buildChainedClient(conversationId, [candidate]);
+
+    const result = await scoped.selectTab(42);
+    expect(result.tabId).toBe(42);
+    expect(result.clientId).toBe("clientA");
+
+    scoped.dispose();
+  });
+
+  test("closeTab on a fresh client triggers failover walk and returns closed status", async () => {
+    const conversationId = "conv-fresh-close";
+    const fakeClient = makeFakeExtensionClientForFreshPath(conversationId);
+    const candidate = makeCandidateFromClient(conversationId, fakeClient, "extension");
+    const scoped = buildChainedClient(conversationId, [candidate]);
+
+    const result = await scoped.closeTab(99);
+    expect(result.closed).toBe(true);
+    expect(result.tabId).toBe(99);
+
+    scoped.dispose();
+  });
+
+  test("listTabs on fresh non-extension client throws transport_error after sticky established", async () => {
+    const conversationId = "conv-fresh-no-list";
+    const noTabsClient: CdpClient & { kind: "local"; conversationId: string } = {
+      kind: "local",
+      conversationId,
+      send: mock(async () => ({})) as unknown as CdpClient["send"],
+      dispose: mock(() => {}),
+    };
+    const candidate = makeCandidateFromClient(conversationId, noTabsClient, "local");
+    const scoped = buildChainedClient(conversationId, [candidate]);
+
+    // No prior send — fresh client, non-extension backend
+    let caught: unknown;
+    try {
+      await scoped.listTabs();
+    } catch (err) {
+      caught = err;
+    }
+    expect(caught).toBeInstanceOf(CdpError);
+    expect((caught as CdpError).code).toBe("transport_error");
+
+    scoped.dispose();
+  });
+});

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

@@ -89,6 +89,9 @@ describe("cdp-client re-exports", () => {
         },
         dispose: () => {},
         setCdpSessionId: () => {},
+        listTabs: async () => [],
+        selectTab: async (_tabId: number) => ({ tabId: _tabId }),
+        closeTab: async (_tabId: number) => ({ closed: true as const, tabId: _tabId }),
       };
       expect(scoped.kind).toBe(kind);
       expect(scoped.conversationId).toBe("conv-123");

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;