@vellumai/assistant 0.8.4 → 0.8.5

package/src/runtime/routes/browser-tabs-routes.ts

@@ -0,0 +1,200 @@
+/**
+ * Routes for browser tab management commands.
+ *
+ * Exposes `browser_tabs` so CLI commands can list, create, select, and
+ * close browser tabs via the Chrome extension backend.
+ */
+
+import { z } from "zod";
+
+import { findConversation } from "../../daemon/conversation-store.js";
+import { getCdpClient } from "../../tools/browser/cdp-client/factory.js";
+import {
+  clearPinnedTab,
+  clearPinnedTabByTabId,
+  setPinnedTab,
+} from "../../tools/browser/pinned-tabs.js";
+import type { ToolContext } from "../../tools/types.js";
+import { browserCliConversationKey } from "./browser-routes.js";
+import { BadRequestError } from "./errors.js";
+import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
+
+const BrowserTabsParams = z.object({
+  command: z.enum(["list", "select", "new", "close"]),
+  sessionId: z.string().min(1).default("default"),
+  conversationId: z.string().min(1).optional(),
+  tabId: z.number().optional(),
+  url: z.string().optional(),
+  // Route tab operations to a specific extension client in multi-client
+  // setups. Mirrors browser/execute's `target_client_id` semantics.
+  targetClientId: z.string().min(1).optional(),
+});
+
+async function handleBrowserTabs({ body = {} }: RouteHandlerArgs) {
+  const { command, sessionId, conversationId, tabId, url, targetClientId } =
+    BrowserTabsParams.parse(body);
+
+  const conversation = conversationId
+    ? findConversation(conversationId)
+    : undefined;
+  const resolvedConversationId = conversation
+    ? conversationId!
+    : browserCliConversationKey(sessionId);
+
+  const context = {
+    workingDir: process.cwd(),
+    conversationId: resolvedConversationId,
+    trustClass: conversation?.trustContext?.trustClass ?? "unknown",
+    transportInterface: conversation?.transportInterface,
+  } as unknown as ToolContext;
+
+  const cdpOptions = { mode: "extension" as const, targetClientId };
+
+  if (command === "list") {
+    const cdp = getCdpClient(context, cdpOptions);
+    try {
+      const tabs = await cdp.listTabs();
+      return { ok: true, tabs };
+    } finally {
+      cdp.dispose();
+    }
+  }
+
+  if (command === "select") {
+    if (tabId === undefined) {
+      throw new BadRequestError("tabId is required for the select command");
+    }
+    const cdp = getCdpClient(context, cdpOptions);
+    try {
+      const result = await cdp.selectTab(tabId);
+      const clientId =
+        typeof result?.clientId === "string" && result.clientId.length > 0
+          ? result.clientId
+          : undefined;
+      if (result?.tabId !== undefined) {
+        setPinnedTab(
+          resolvedConversationId,
+          String(result.tabId),
+          clientId,
+        );
+      }
+      return { ok: true, tab: result };
+    } finally {
+      cdp.dispose();
+    }
+  }
+
+  if (command === "new") {
+    const cdp = getCdpClient(context, cdpOptions);
+    try {
+      const result = await cdp.send<{ tabId?: number | string; clientId?: string }>(
+        "Vellum.createTab",
+        {},
+      );
+      // Normalise to string for internal use (setCdpSessionId / setPinnedTab)
+      // and keep the numeric form for the API response.
+      const newTabIdStr: string | undefined =
+        typeof result?.tabId === "number"
+          ? String(result.tabId)
+          : typeof result?.tabId === "string"
+            ? result.tabId
+            : undefined;
+      const newTabIdNum: number | undefined =
+        typeof result?.tabId === "number"
+          ? result.tabId
+          : typeof result?.tabId === "string"
+            ? parseInt(result.tabId, 10)
+            : undefined;
+      const clientId =
+        typeof result?.clientId === "string" && result.clientId.length > 0
+          ? result.clientId
+          : undefined;
+      if (newTabIdStr) {
+        cdp.setCdpSessionId?.(newTabIdStr);
+        setPinnedTab(resolvedConversationId, newTabIdStr, clientId);
+        if (url) {
+          await cdp.send("Page.navigate", { url });
+        }
+      } else if (targetClientId) {
+        // Only scope-clear the targeted client's pin. With the per-(conversationId,
+        // clientId) pin store (#31361), passing no clientId to clearPinnedTab
+        // would wipe pins for *every* connected client on this conversation
+        // and break their routing — so we skip the clear entirely when the
+        // caller didn't explicitly target a client. The stale pin (if any)
+        // is overwritten on the next successful tab operation.
+        clearPinnedTab(resolvedConversationId, targetClientId);
+      }
+      return { ok: true, tabId: newTabIdNum, clientId };
+    } finally {
+      cdp.dispose();
+    }
+  }
+
+  if (command === "close") {
+    if (tabId === undefined) {
+      throw new BadRequestError("tabId is required for the close command");
+    }
+    const cdp = getCdpClient(context, cdpOptions);
+    try {
+      const result = await cdp.closeTab(tabId);
+      // Clear any pinned-tab slot still pointing at the closed tabId so
+      // subsequent browser tool calls don't route to a dead cdpSessionId
+      // and fail with session-not-found. Tabs that never debugger-attached
+      // (e.g. `tabs new` without `--url`) won't emit a detach invalidation
+      // event, so the pin would otherwise leak.
+      //
+      // Scope the clear to the actual responding client. Prefer the
+      // clientId from the closeTab response (resolved by the extension
+      // dispatcher), fall back to the caller-supplied targetClientId.
+      // Without a resolved clientId we skip the clear entirely — calling
+      // clearPinnedTabByTabId without a clientId would wipe matching pins
+      // across every client (Chrome tab IDs are per-instance, not
+      // globally unique), breaking the per-(conversationId, clientId)
+      // pin isolation added in #31361. The stale pin in the unscoped
+      // case will self-heal via the session-not-found cleanup on the
+      // next browser op against that pin.
+      const resolvedClientId = result.clientId ?? targetClientId;
+      if (resolvedClientId) {
+        clearPinnedTabByTabId(String(tabId), resolvedClientId);
+      }
+      return { ok: true, ...result };
+    } finally {
+      cdp.dispose();
+    }
+  }
+
+  throw new BadRequestError(`Unknown tabs command: ${command}`);
+}
+
+export const ROUTES: RouteDefinition[] = [
+  {
+    operationId: "browser_tabs",
+    endpoint: "browser/tabs",
+    method: "POST",
+    handler: handleBrowserTabs,
+    summary: "Manage browser tabs",
+    description:
+      "List, create, select, or close browser tabs via the Chrome extension backend.",
+    tags: ["browser"],
+    requestBody: BrowserTabsParams,
+    responseBody: z.object({
+      ok: z.boolean(),
+      tabs: z
+        .array(
+          z.object({
+            tabId: z.number().optional(),
+            windowId: z.number().optional(),
+            url: z.string().optional(),
+            title: z.string().optional(),
+            active: z.boolean(),
+            pinned: z.boolean(),
+          }),
+        )
+        .optional(),
+      tab: z.unknown().optional(),
+      tabId: z.number().optional(),
+      clientId: z.string().optional(),
+      closed: z.boolean().optional(),
+    }),
+  },
+];

package/src/runtime/routes/btw-routes.ts

@@ -22,7 +22,6 @@ import { getOrCreateConversation } from "../../daemon/conversation-store.js";
 import { buildToolDefinitions } from "../../daemon/conversation-tool-setup.js";
 import { parseIdentityFields } from "../../daemon/handlers/identity.js";
 import { getConversationByKey } from "../../memory/conversation-key-store.js";
-import { resolvePersonaContext } from "../../prompts/persona-resolver.js";
 import { getLogger } from "../../util/logger.js";
 import { getWorkspacePromptPath } from "../../util/platform.js";
 import { runBtwSidechain } from "../btw-sidechain.js";
@@ -120,16 +119,11 @@ async function handleBtw({
         try {
           const isIntroRequest = conversationKey === IDENTITY_INTRO_KEY;
           const isGreeting = conversationKey === GREETING_KEY;
-          const { userPersona, userSlug, channelPersona } =
-            resolvePersonaContext(undefined, undefined);
           const result = await runBtwSidechain({
             content: effectiveContent,
             conversation,
             tools: buildToolDefinitions(),
             signal: abortSignal,
-            userPersona,
-            channelPersona,
-            userSlug,
             ...(isGreeting ? { callSite: "emptyStateGreeting" as const } : {}),
             onEvent: (event) => {
               if (event.type === "text_delta") {

package/src/runtime/routes/conversation-cli-routes.ts

@@ -145,7 +145,7 @@ function handleExportCli({ body = {} }: RouteHandlerArgs) {
 
 async function handleClearCli(_args: RouteHandlerArgs) {
   // Tear down in-memory conversation state before DB clear.
-  const cleared = clearAllActive();
+  const cleared = await clearAllActive();
   log.info(
     { cleared },
     "CLI conversations clear: active conversations torn down",

package/src/runtime/routes/conversation-list-routes.ts

@@ -111,7 +111,7 @@ function handleListConversations({ queryParams = {} }: RouteHandlerArgs) {
   return response;
 }
 
-function handleRecordSeen({ body = {} }: RouteHandlerArgs) {
+function handleRecordSeen({ body = {}, headers }: RouteHandlerArgs) {
   const rawConversationId = body.conversationId as string | undefined;
   if (!rawConversationId) {
     throw new BadRequestError("Missing conversationId");
@@ -142,7 +142,11 @@ function handleRecordSeen({ body = {} }: RouteHandlerArgs) {
     });
 
     if (wasUnseen) {
-      publishConversationListAndMetadataChanged("seen_changed", conversationId);
+      publishConversationListAndMetadataChanged(
+        "seen_changed",
+        conversationId,
+        headers?.["x-vellum-client-id"]?.trim() || undefined,
+      );
     }
 
     return { ok: true };
@@ -152,7 +156,7 @@ function handleRecordSeen({ body = {} }: RouteHandlerArgs) {
   }
 }
 
-function handleMarkUnread({ body = {} }: RouteHandlerArgs) {
+function handleMarkUnread({ body = {}, headers }: RouteHandlerArgs) {
   const rawConversationId = body.conversationId as string | undefined;
   if (!rawConversationId) {
     throw new BadRequestError("Missing conversationId");
@@ -162,7 +166,11 @@ function handleMarkUnread({ body = {} }: RouteHandlerArgs) {
   try {
     const changed = markConversationUnread(conversationId);
     if (changed) {
-      publishConversationListAndMetadataChanged("seen_changed", conversationId);
+      publishConversationListAndMetadataChanged(
+        "seen_changed",
+        conversationId,
+        headers?.["x-vellum-client-id"]?.trim() || undefined,
+      );
     }
     return { ok: true };
   } catch (err) {

package/src/runtime/routes/conversation-management-routes.ts

@@ -84,7 +84,7 @@ function cancelScheduleIfLast(conversationId: string): void {
 // Handlers
 // ---------------------------------------------------------------------------
 
-function handleCreateConversation({ body = {} }: RouteHandlerArgs) {
+function handleCreateConversation({ body = {}, headers }: RouteHandlerArgs) {
   const conversationKey =
     (body.conversationKey as string | undefined) ?? crypto.randomUUID();
   const result = getOrCreateConversation(conversationKey, {
@@ -92,7 +92,11 @@ function handleCreateConversation({ body = {} }: RouteHandlerArgs) {
   });
   if (result.created) {
     updateConversationTitle(result.conversationId, "New Conversation");
-    publishConversationListAndMetadataChanged("created", result.conversationId);
+    publishConversationListAndMetadataChanged(
+      "created",
+      result.conversationId,
+      headers?.["x-vellum-client-id"]?.trim() || undefined,
+    );
   }
   log.info(
     {
@@ -110,7 +114,7 @@ function handleCreateConversation({ body = {} }: RouteHandlerArgs) {
   };
 }
 
-async function handleForkConversation({ body = {} }: RouteHandlerArgs) {
+async function handleForkConversation({ body = {}, headers }: RouteHandlerArgs) {
   const conversationId = body.conversationId as string | undefined;
   if (!conversationId || typeof conversationId !== "string") {
     throw new BadRequestError("Missing conversationId");
@@ -136,7 +140,11 @@ async function handleForkConversation({ body = {} }: RouteHandlerArgs) {
         `Forked conversation ${forkedConversation.id} could not be loaded`,
       );
     }
-    publishConversationListAndMetadataChanged("created", forkedConversation.id);
+    publishConversationListAndMetadataChanged(
+      "created",
+      forkedConversation.id,
+      headers?.["x-vellum-client-id"]?.trim() || undefined,
+    );
     return { conversation: detail.conversation };
   } catch (err) {
     if (err instanceof UserError) {
@@ -171,6 +179,7 @@ async function handleSwitchConversation({ body = {} }: RouteHandlerArgs) {
 async function handleSetInferenceProfile({
   pathParams = {},
   body = {},
+  headers,
 }: RouteHandlerArgs) {
   if (
     body.profile !== null &&
@@ -184,6 +193,7 @@ async function handleSetInferenceProfile({
     profile: body.profile as string | null,
     ttlSeconds: body.ttlSeconds as number | null | undefined,
     sessionId: body.sessionId as string | undefined,
+    originClientId: headers?.["x-vellum-client-id"]?.trim() || undefined,
   });
 
   return result;
@@ -192,6 +202,7 @@ async function handleSetInferenceProfile({
 function handleRenameConversation({
   pathParams = {},
   body = {},
+  headers,
 }: RouteHandlerArgs) {
   const name = body.name as string | undefined;
   if (!name || typeof name !== "string") {
@@ -203,12 +214,18 @@ function handleRenameConversation({
   }
   updateConversationTitle(pathParams.id!, name, 0);
 
-  publishConversationTitleChanged(pathParams.id!, name);
+  publishConversationTitleChanged(
+    pathParams.id!,
+    name,
+    headers?.["x-vellum-client-id"]?.trim() || undefined,
+  );
 
   return { ok: true };
 }
 
-function handleClearAllConversations({ headers = {} }: RouteHandlerArgs) {
+async function handleClearAllConversations({
+  headers = {},
+}: RouteHandlerArgs) {
   const confirm = headers["x-confirm-destructive"];
   if (confirm !== "clear-all-conversations") {
     throw new BadRequestError(
@@ -216,12 +233,15 @@ function handleClearAllConversations({ headers = {} }: RouteHandlerArgs) {
         "To confirm, set header X-Confirm-Destructive: clear-all-conversations",
     );
   }
-  clearAllConversations();
-  publishConversationListChanged("deleted");
+  await clearAllConversations();
+  publishConversationListChanged(
+    "deleted",
+    headers["x-vellum-client-id"]?.trim() || undefined,
+  );
   return undefined;
 }
 
-function handleWipeConversation({ pathParams = {} }: RouteHandlerArgs) {
+function handleWipeConversation({ pathParams = {}, headers }: RouteHandlerArgs) {
   const resolvedId = resolveOrThrow(pathParams.id!);
 
   cancelScheduleIfLast(resolvedId);
@@ -248,7 +268,11 @@ function handleWipeConversation({ pathParams = {} }: RouteHandlerArgs) {
     },
     "Wiped conversation and reverted memory changes",
   );
-  publishConversationListAndMetadataChanged("deleted", resolvedId);
+  publishConversationListAndMetadataChanged(
+    "deleted",
+    resolvedId,
+    headers?.["x-vellum-client-id"]?.trim() || undefined,
+  );
   return {
     wiped: true,
     unsupersededItems: 0,
@@ -257,7 +281,10 @@ function handleWipeConversation({ pathParams = {} }: RouteHandlerArgs) {
   };
 }
 
-function handleDeleteConversation({ pathParams = {} }: RouteHandlerArgs) {
+function handleDeleteConversation({
+  pathParams = {},
+  headers,
+}: RouteHandlerArgs) {
   const resolvedId = resolveOrThrow(pathParams.id!);
 
   cancelScheduleIfLast(resolvedId);
@@ -278,28 +305,46 @@ function handleDeleteConversation({ pathParams = {} }: RouteHandlerArgs) {
   }
   log.info({ conversationId: resolvedId }, "Deleted conversation");
 
-  publishConversationListAndMetadataChanged("deleted", resolvedId);
+  publishConversationListAndMetadataChanged(
+    "deleted",
+    resolvedId,
+    headers?.["x-vellum-client-id"]?.trim() || undefined,
+  );
 
   return undefined;
 }
 
-function handleArchiveConversation({ pathParams = {} }: RouteHandlerArgs) {
+function handleArchiveConversation({
+  pathParams = {},
+  headers,
+}: RouteHandlerArgs) {
   const resolvedId = resolveOrThrow(pathParams.id!);
   const archived = archiveConversation(resolvedId);
   if (!archived) {
     throw new NotFoundError(`Conversation ${pathParams.id} not found`);
   }
-  publishConversationListAndMetadataChanged("reordered", resolvedId);
+  publishConversationListAndMetadataChanged(
+    "reordered",
+    resolvedId,
+    headers?.["x-vellum-client-id"]?.trim() || undefined,
+  );
   return { ok: true, conversationId: resolvedId };
 }
 
-function handleUnarchiveConversation({ pathParams = {} }: RouteHandlerArgs) {
+function handleUnarchiveConversation({
+  pathParams = {},
+  headers,
+}: RouteHandlerArgs) {
   const resolvedId = resolveOrThrow(pathParams.id!);
   const unarchived = unarchiveConversation(resolvedId);
   if (!unarchived) {
     throw new NotFoundError(`Conversation ${pathParams.id} not found`);
   }
-  publishConversationListAndMetadataChanged("reordered", resolvedId);
+  publishConversationListAndMetadataChanged(
+    "reordered",
+    resolvedId,
+    headers?.["x-vellum-client-id"]?.trim() || undefined,
+  );
   return { ok: true, conversationId: resolvedId };
 }
 
@@ -339,7 +384,7 @@ async function handleRegenerateResponse({ pathParams = {} }: RouteHandlerArgs) {
   }
 }
 
-function handleReorderConversations({ body = {} }: RouteHandlerArgs) {
+function handleReorderConversations({ body = {}, headers }: RouteHandlerArgs) {
   const updates = body.updates as
     | Array<{
         conversationId: string;
@@ -362,6 +407,7 @@ function handleReorderConversations({ body = {} }: RouteHandlerArgs) {
   publishConversationListAndMetadataChanged(
     "reordered",
     updates.map((u) => u.conversationId),
+    headers?.["x-vellum-client-id"]?.trim() || undefined,
   );
   return { ok: true };
 }
@@ -382,15 +428,26 @@ export const ROUTES: RouteDefinition[] = [
     requestBody: z.object({
       conversationKey: z
         .string()
-        .describe("Idempotency key for the conversation"),
+        .optional()
+        .describe(
+          "Optional external key. Echoed back in the response. Non-vellum channels (Telegram, WhatsApp) use this to scope to a logical channel thread; vellum-web clients can omit it and rely on the assistant-minted `id`.",
+        ),
       conversationType: z
         .literal("standard")
         .optional()
         .describe("Only standard conversations are created by this endpoint"),
     }),
     responseBody: z.object({
-      id: z.string(),
-      conversationKey: z.string(),
+      id: z
+        .string()
+        .describe(
+          "Assistant-minted internal conversation id. The authoritative identifier for the conversation.",
+        ),
+      conversationKey: z
+        .string()
+        .describe(
+          "Echo of the optional external key supplied by the client.",
+        ),
       conversationType: z.string(),
       created: z.boolean(),
     }),