@vellumai/assistant 0.8.4 → 0.8.6

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

@@ -19,10 +19,9 @@ import { z } from "zod";
 import { getConfig } from "../../config/loader.js";
 import { readNowScratchpad } from "../../daemon/conversation-runtime-assembly.js";
 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 { getAllToolDefinitions } from "../../tools/registry.js";
 import { getLogger } from "../../util/logger.js";
 import { getWorkspacePromptPath } from "../../util/platform.js";
 import { runBtwSidechain } from "../btw-sidechain.js";
@@ -78,7 +77,7 @@ async function handleBtw({
         fastText = `Hi, I'm ${fields.name}!`;
       }
     }
-    fastText ??= getCachedIntro()?.text;
+    fastText ??= getCachedIntro()?.greetings[0];
     if (fastText) {
       log.debug("Returning identity intro fast-path");
       return new ReadableStream({
@@ -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(),
+            tools: getAllToolDefinitions(),
             signal: abortSignal,
-            userPersona,
-            channelPersona,
-            userSlug,
             ...(isGreeting ? { callSite: "emptyStateGreeting" as const } : {}),
             onEvent: (event) => {
               if (event.type === "text_delta") {
@@ -152,7 +146,7 @@ async function handleBtw({
 
           if (isIntroRequest && result.text) {
             try {
-              setCachedIntro(result.text);
+              setCachedIntro([result.text]);
               log.debug("Cached identity intro text");
             } catch {
               // Non-fatal — next request will regenerate.

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

@@ -9,8 +9,11 @@
  * errors, and build the success response.
  */
 
+import { z } from "zod";
+
 import { analyzeConversation } from "../services/analyze-conversation.js";
 import { buildConversationDetailResponse } from "../services/conversation-serializer.js";
+import { conversationSummarySchema } from "./conversation-list-routes.js";
 import { BadRequestError, InternalError, NotFoundError } from "./errors.js";
 import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
 
@@ -60,6 +63,9 @@ export const ROUTES: RouteDefinition[] = [
     description:
       "Create a new conversation with a structured self-assessment of an existing conversation.",
     tags: ["conversations"],
+    responseBody: z.object({
+      conversation: conversationSummarySchema,
+    }),
     handler: handleAnalyzeConversation,
   },
 ];

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-compaction-routes.ts

@@ -0,0 +1,263 @@
+/**
+ * Route definitions for the per-conversation **compaction trail** view.
+ *
+ *   GET /v1/conversations/:id/compaction?callId=…
+ *
+ * Reachable via the platform's `RuntimeProxyWildcardView` at
+ * `/v1/assistants/{assistantId}/conversations/{conversationId}/compaction/?callId=…`.
+ *
+ * # Scope
+ *
+ * Returns the set of `call_site = "compactionAgent"` rows in this
+ * conversation that ran in the **window between the previous real LLM
+ * call and the one identified by `callId`**, ordered chronologically.
+ * This is the data the Inspector's "Compaction" tab shows when you
+ * select a call in the rail: it answers "what did the compactor do to
+ * my context before *this specific* call?" — not "what has the
+ * compactor ever done in this conversation".
+ *
+ * The floor is resolved by walking back from the selected call to the
+ * most recent non-`compactionAgent` row in the same conversation. When
+ * the selected call is the *first* real call in the conversation,
+ * there is no floor and every preceding compaction is in scope.
+ *
+ * # Data model decision (in progress)
+ *
+ * Today the trail is projected from `llm_request_logs` rows alone — no
+ * `compaction_logs` table exists yet (#32055 remains a draft). This MVP
+ * route exists precisely to test whether the projected shape is enough.
+ * If real-world use surfaces UX needs that aren't in `llm_request_logs`
+ * (most likely: per-event duration, structured before/after counts,
+ * trigger reason), that becomes the concrete justification for the new
+ * table. Until then, missing fields surface as `null` and the Compaction
+ * tab renders `"Unavailable"` for them.
+ *
+ * In particular, `durationMs` is always `null` for now — the column
+ * doesn't exist on `llm_request_logs` and we deliberately ship the route
+ * without it to surface the gap in the UI.
+ */
+
+import { z } from "zod";
+
+import { getConversation } from "../../memory/conversation-crud.js";
+import { getLlmRequestLogSource } from "../../memory/llm-request-log-source.js";
+import type { LogRow } from "../../memory/llm-request-log-store.js";
+import { BadRequestError, NotFoundError } from "./errors.js";
+import {
+  type LlmContextSummary,
+  normalizeLlmContextPayloads,
+} from "./llm-context-normalization.js";
+import type { RouteDefinition, RouteHandlerArgs } from "./types.js";
+
+/**
+ * Wire shape for a single compaction event. Mirrors the React Query
+ * response type at
+ * `apps/web/src/domains/chat/inspector/compaction-trail-types.ts`.
+ * Keep the two in sync — until the OpenAPI client generator picks up
+ * this route, the frontend type is hand-maintained.
+ */
+export interface CompactionTrailEvent {
+  id: string;
+  createdAt: number;
+  model: string | null;
+  provider: string | null;
+  inputTokens: number | null;
+  outputTokens: number | null;
+  /**
+   * Per-call wall-clock latency, in milliseconds. **Always `null` for
+   * now** — `llm_request_logs` doesn't carry a duration column. Surfacing
+   * the gap in the UI is intentional: if engineers consistently miss
+   * having latency here, that's a concrete signal to extend the row
+   * (either as a column on `llm_request_logs` or on a dedicated
+   * `compaction_logs` table per the open data-model decision).
+   */
+  durationMs: number | null;
+  responsePreview: string | null;
+  requestMessageCount: number | null;
+  stopReason: string | null;
+  estimatedCostUsd: number | null;
+}
+
+export interface CompactionTrailResponse {
+  conversationId: string;
+  events: CompactionTrailEvent[];
+}
+
+const compactionTrailEventSchema = z.object({
+  id: z.string(),
+  createdAt: z.number(),
+  model: z.string().nullable(),
+  provider: z.string().nullable(),
+  inputTokens: z.number().nullable(),
+  outputTokens: z.number().nullable(),
+  durationMs: z.number().nullable(),
+  responsePreview: z.string().nullable(),
+  requestMessageCount: z.number().nullable(),
+  stopReason: z.string().nullable(),
+  estimatedCostUsd: z.number().nullable(),
+});
+
+const compactionTrailResponseSchema = z.object({
+  conversationId: z.string(),
+  events: z.array(compactionTrailEventSchema),
+});
+
+// ---------------------------------------------------------------------------
+// Projection — LogRow → CompactionTrailEvent
+// ---------------------------------------------------------------------------
+
+function tryParseJson(value: string): unknown {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+
+/**
+ * Project a raw `llm_request_logs` row into the compaction-trail wire
+ * shape. Reuses `normalizeLlmContextPayloads` so model/provider/token
+ * extraction stays consistent with what the rest of the inspector shows.
+ *
+ * Fields the normalizer can't derive (today: `durationMs`) land as
+ * `null` — see the `CompactionTrailEvent.durationMs` doc comment for the
+ * rationale.
+ *
+ * Exported only for unit tests; the route handler is the sole production
+ * caller.
+ */
+export function projectLogRowToCompactionTrailEvent(
+  log: LogRow,
+): CompactionTrailEvent {
+  const normalized = normalizeLlmContextPayloads({
+    requestPayload: tryParseJson(log.requestPayload),
+    responsePayload: tryParseJson(log.responsePayload),
+    createdAt: log.createdAt,
+  });
+  const summary: LlmContextSummary | undefined = normalized.summary;
+  return {
+    id: log.id,
+    createdAt: log.createdAt,
+    model: summary?.model ?? null,
+    // Prefer the normalized provider (derived from payload shape) over
+    // the stored column. Stored `provider` is the originating call's
+    // own identifier and matches the normalizer in all cases we ship
+    // today, but the normalizer is the source-of-truth used by sibling
+    // inspector tabs — keep that alignment.
+    provider: summary?.provider ?? log.provider ?? null,
+    inputTokens: summary?.inputTokens ?? null,
+    outputTokens: summary?.outputTokens ?? null,
+    durationMs: null,
+    responsePreview: summary?.responsePreview ?? null,
+    requestMessageCount: summary?.requestMessageCount ?? null,
+    stopReason: summary?.stopReason ?? null,
+    estimatedCostUsd: summary?.estimatedCostUsd ?? null,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Handler
+// ---------------------------------------------------------------------------
+
+async function handleGetCompactionTrail({
+  pathParams = {},
+  queryParams = {},
+}: RouteHandlerArgs): Promise<CompactionTrailResponse> {
+  const conversationId = pathParams.id;
+  const callId = queryParams.callId;
+
+  if (!conversationId) {
+    throw new BadRequestError("conversation id path parameter is required");
+  }
+  if (!callId) {
+    throw new BadRequestError("callId query parameter is required");
+  }
+
+  // Verify the conversation exists before we touch the log source —
+  // a missing conversation should 404, not return an empty trail with
+  // no signal that the caller had the wrong id.
+  const conversation = getConversation(conversationId);
+  if (!conversation) {
+    throw new NotFoundError(`Conversation ${conversationId} not found`);
+  }
+
+  const source = await getLlmRequestLogSource();
+  const selectedCall = await source.getRequestLogById(callId);
+  if (!selectedCall) {
+    throw new NotFoundError(`LLM call ${callId} not found`);
+  }
+  if (selectedCall.conversationId !== conversationId) {
+    // Treat a cross-conversation callId as a bad request rather than
+    // silently filtering against the wrong conversation. The frontend
+    // always pairs (conversationId, callId) from the same rail, so a
+    // mismatch is a real client bug — surface it.
+    throw new BadRequestError(
+      `LLM call ${callId} does not belong to conversation ${conversationId}`,
+    );
+  }
+
+  // Resolve the window floor — the most recent non-`compactionAgent`
+  // call before the selected one. `null` means the selected call is the
+  // first real call in the conversation, so every preceding compaction
+  // is in scope. The store function applies the strict-`>` predicate
+  // (or drops it entirely on null), so the selected call's own
+  // `createdAt` is the only ceiling we pass.
+  const afterCreatedAt = await source.getPreviousNonCompactionCallCreatedAt(
+    conversationId,
+    selectedCall.createdAt,
+  );
+  const logs = await source.getCompactionLogsBetween(
+    conversationId,
+    afterCreatedAt,
+    selectedCall.createdAt,
+  );
+
+  return {
+    conversationId,
+    events: logs.map(projectLogRowToCompactionTrailEvent),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Route registration
+// ---------------------------------------------------------------------------
+
+export const ROUTES: RouteDefinition[] = [
+  {
+    operationId: "conversations_compaction_trail_get",
+    endpoint: "conversations/:id/compaction",
+    method: "GET",
+    policyKey: "conversations/compaction",
+    summary: "Get the compaction trail leading up to an LLM call",
+    description:
+      "Return the chronological list of compaction events that ran in this conversation in the open window between the previous non-`compactionAgent` LLM call and the call identified by `callId`. Projected from `llm_request_logs` rows where `call_site = \"compactionAgent\"`. When the selected call is the first real call in the conversation, every preceding compaction is in scope. Drives the Inspector's Compaction tab.",
+    tags: ["conversations"],
+    pathParams: [
+      {
+        name: "id",
+        description: "Internal conversation identifier.",
+      },
+    ],
+    queryParams: [
+      {
+        name: "callId",
+        required: true,
+        schema: { type: "string" },
+        description:
+          "ID of the selected LLM call from the rail. Defines the chronological cutoff for the trail.",
+      },
+    ],
+    responseBody: compactionTrailResponseSchema,
+    additionalResponses: {
+      "400": {
+        description:
+          "Returned when the callId is missing or refers to a call in a different conversation.",
+      },
+      "404": {
+        description:
+          "Returned when the conversation or the referenced LLM call does not exist.",
+      },
+    },
+    handler: handleGetCompactionTrail,
+  },
+];