@vellumai/assistant 0.8.7 → 0.8.8

package/src/__tests__/annotate-activity-metadata.test.ts

@@ -0,0 +1,262 @@
+/**
+ * Tests for `annotatePersistedAssistantMessage` persisting `_activityMetadata`
+ * (web_search / web_fetch) alongside the tool call.
+ *
+ * Without this annotation the tool activity card (e.g. WebSearchProgressCard)
+ * is lost on a history reopen — the snapshot only carries the plain result
+ * text. External provider tools (brave/perplexity/tavily, web_fetch) resolve
+ * their activity only when the `tool_result` lands, after `message_complete`
+ * already persisted the block, so they are stamped here. Native server tools
+ * (Anthropic web_search) resolve before `message_complete` and are stamped at
+ * persist time in `buildPersistedAssistantContent` (covered separately in
+ * build-persisted-content.test.ts).
+ *
+ * The test exercises the populate → annotate → persist round-trip:
+ *   handleToolResult(event with activityMetadata)
+ *     → state.toolActivityMetadata captures it
+ *     → annotatePersistedAssistantMessage writes _activityMetadata onto the row
+ *     → updateMessageContent receives the JSON-serialized output
+ *
+ * Read-side coverage (renderHistoryContent in handlers/shared.ts) lives in
+ * server-history-render.test.ts.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ── Mock platform (must precede imports that read it) ─────────────────────────
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    skills: {
+      entries: {},
+      load: { extraDirs: [], watch: false, watchDebounceMs: 0 },
+      install: { nodeManager: "npm" },
+      allowBundled: null,
+      remoteProviders: {
+        skillssh: { enabled: true },
+        clawhub: { enabled: true },
+      },
+      remotePolicy: {
+        blockSuspicious: true,
+        blockMalware: true,
+        maxSkillsShRisk: "medium",
+      },
+    },
+  }),
+  loadConfig: () => ({}),
+}));
+
+let mockedRowContent = "";
+const updates: Array<{ id: string; content: string }> = [];
+
+mock.module("../memory/conversation-crud.js", () => ({
+  addMessage: () => ({ id: "mock-msg-id" }),
+  getMessageById: (id: string) =>
+    mockedRowContent ? { id, content: mockedRowContent } : null,
+  updateMessageContent: (id: string, content: string) => {
+    updates.push({ id, content });
+  },
+  provenanceFromTrustContext: () => ({}),
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
+}));
+
+mock.module("../memory/llm-request-log-store.js", () => ({
+  recordRequestLog: () => {},
+  backfillMessageIdOnLogs: () => {},
+}));
+
+// ── Imports (after mocks) ─────────────────────────────────────────────────────
+import type {
+  EventHandlerDeps,
+  EventHandlerState,
+} from "../daemon/conversation-agent-loop-handlers.js";
+import {
+  createEventHandlerState,
+  handleToolResult,
+} from "../daemon/conversation-agent-loop-handlers.js";
+import type { ToolActivityMetadata } from "../daemon/message-types/web-activity.js";
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function makeDeps(): EventHandlerDeps {
+  return {
+    ctx: {
+      conversationId: "test-conv",
+      provider: { name: "anthropic" },
+      traceEmitter: { emit: () => {} },
+      streamThinking: false,
+      emitActivityState: () => {},
+      markWorkspaceTopLevelDirty: () => {},
+      currentTurnSurfaces: [],
+    } as unknown as EventHandlerDeps["ctx"],
+    onEvent: () => {},
+    reqId: "test-req",
+    isFirstMessage: false,
+    shouldGenerateTitle: false,
+    rlog: new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }) as unknown as EventHandlerDeps["rlog"],
+    turnChannelContext: {
+      userMessageChannel: "vellum",
+      assistantMessageChannel: "vellum",
+    } as unknown as EventHandlerDeps["turnChannelContext"],
+    turnInterfaceContext: {
+      userMessageInterface: "web",
+      assistantMessageInterface: "web",
+    } as unknown as EventHandlerDeps["turnInterfaceContext"],
+    applyCompaction: async () => {},
+  };
+}
+
+function setupState(toolUseId: string): EventHandlerState {
+  const state = createEventHandlerState();
+  state.lastAssistantMessageId = "msg-1";
+  state.toolUseIdToName.set(toolUseId, "web_search");
+  state.toolCallTimestamps.set(toolUseId, { startedAt: Date.now() });
+  state.currentTurnToolUseIds.push(toolUseId);
+  return state;
+}
+
+function findBlockById(
+  rawContent: string,
+  id: string,
+): Record<string, unknown> {
+  const parsed = JSON.parse(rawContent) as Array<Record<string, unknown>>;
+  const block = parsed.find((b) => b.id === id);
+  if (!block) throw new Error(`block ${id} not found`);
+  return block;
+}
+
+const webSearchActivity: ToolActivityMetadata = {
+  webSearch: {
+    query: "vellum docs",
+    provider: "brave",
+    resultCount: 2,
+    durationMs: 142,
+    results: [
+      {
+        rank: 1,
+        title: "Vellum",
+        url: "https://vellum.ai",
+        domain: "vellum.ai",
+      },
+      {
+        rank: 2,
+        title: "Docs",
+        url: "https://docs.vellum.ai",
+        domain: "docs.vellum.ai",
+      },
+    ],
+  },
+};
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+
+describe("annotatePersistedAssistantMessage — activityMetadata", () => {
+  beforeEach(() => {
+    updates.length = 0;
+    mockedRowContent = "";
+  });
+
+  test("persists activityMetadata from the live tool_result event onto the tool_use block", () => {
+    // GIVEN a persisted tool_use block for an external web_search tool
+    const toolUseId = "tu_web_search";
+    const state = setupState(toolUseId);
+    mockedRowContent = JSON.stringify([
+      {
+        type: "tool_use",
+        id: toolUseId,
+        name: "web_search",
+        input: { query: "vellum docs" },
+      },
+    ]);
+
+    // WHEN the tool result lands carrying activityMetadata
+    handleToolResult(state, makeDeps(), {
+      type: "tool_result",
+      toolUseId,
+      content: "results",
+      isError: false,
+      activityMetadata: webSearchActivity,
+    });
+
+    // THEN the metadata is stamped on the persisted block verbatim
+    expect(updates).toHaveLength(1);
+    const block = findBlockById(updates[0].content, toolUseId);
+    expect(block._activityMetadata).toEqual(webSearchActivity);
+  });
+
+  test("leaves native server_tool_use blocks untouched (stamped at persist time)", () => {
+    // GIVEN an external tool completes (to trigger annotation) AND a native
+    // server_tool_use block whose activity was captured at server_tool_complete
+    const externalId = "tu_external";
+    const nativeId = "srvtu_native_search";
+    const state = setupState(externalId);
+    state.toolActivityMetadata.set(nativeId, webSearchActivity);
+    mockedRowContent = JSON.stringify([
+      {
+        type: "server_tool_use",
+        id: nativeId,
+        name: "web_search",
+        input: { query: "vellum docs" },
+      },
+      {
+        type: "tool_use",
+        id: externalId,
+        name: "bash",
+        input: { command: "ls" },
+      },
+    ]);
+
+    // WHEN the external tool result lands (no activity of its own)
+    handleToolResult(state, makeDeps(), {
+      type: "tool_result",
+      toolUseId: externalId,
+      content: "ok",
+      isError: false,
+    });
+
+    // THEN the annotate pass does not stamp the server_tool_use block — native
+    // activity is stamped earlier by `buildPersistedAssistantContent` (covered
+    // in build-persisted-content.test.ts), and the unrelated external tool_use
+    // block carries no activity of its own
+    expect(updates).toHaveLength(1);
+    const nativeBlock = findBlockById(updates[0].content, nativeId);
+    expect(nativeBlock._activityMetadata).toBeUndefined();
+    const externalBlock = findBlockById(updates[0].content, externalId);
+    expect(externalBlock._activityMetadata).toBeUndefined();
+  });
+
+  test("omits activityMetadata when the tool produced none", () => {
+    // GIVEN a non-activity tool
+    const toolUseId = "tu_plain";
+    const state = setupState(toolUseId);
+    state.toolUseIdToName.set(toolUseId, "bash");
+    mockedRowContent = JSON.stringify([
+      {
+        type: "tool_use",
+        id: toolUseId,
+        name: "bash",
+        input: { command: "ls" },
+      },
+    ]);
+
+    // WHEN the result lands with no activityMetadata
+    handleToolResult(state, makeDeps(), {
+      type: "tool_result",
+      toolUseId,
+      content: "ok",
+      isError: false,
+    });
+
+    // THEN no _activityMetadata is written
+    expect(updates).toHaveLength(1);
+    const block = findBlockById(updates[0].content, toolUseId);
+    expect(block._activityMetadata).toBeUndefined();
+  });
+});

package/src/__tests__/annotate-risk-options.test.ts

@@ -103,6 +103,7 @@ function makeDeps(): EventHandlerDeps {
       userMessageInterface: "web",
       assistantMessageInterface: "web",
     } as unknown as EventHandlerDeps["turnInterfaceContext"],
+    applyCompaction: async () => {},
   };
 }
 
@@ -120,9 +121,7 @@ function findPersistedToolUse(
   toolUseId: string,
 ): Record<string, unknown> {
   const parsed = JSON.parse(rawContent) as Array<Record<string, unknown>>;
-  const block = parsed.find(
-    (b) => b.type === "tool_use" && b.id === toolUseId,
-  );
+  const block = parsed.find((b) => b.type === "tool_use" && b.id === toolUseId);
   if (!block) throw new Error(`tool_use block ${toolUseId} not found`);
   return block;
 }

package/src/__tests__/anthropic-provider.test.ts

@@ -102,12 +102,13 @@ mock.module("@anthropic-ai/sdk", () => ({
 }));
 
 // Import after mocking
+import { cachedTextBlock } from "../memory/v3/provider-blocks.js";
+import { AnthropicProvider } from "../providers/anthropic/client.js";
 import {
-  AnthropicProvider,
   isPlaceholderSentinelText,
   PLACEHOLDER_BLOCKS_OMITTED,
   PLACEHOLDER_EMPTY_TURN,
-} from "../providers/anthropic/client.js";
+} from "../providers/placeholder-sentinels.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -323,6 +324,98 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     expect(tools[0].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
   });
 
+  test("preserves a caller's 1h block cache_control and sends the extended-cache beta (non-Haiku)", async () => {
+    // v3's `cachedTextBlock` stamps a stable prefix block with a 1h TTL; the
+    // non-Haiku path must forward it unchanged and send the beta header.
+    await provider.sendMessage([
+      {
+        role: "user",
+        content: [
+          cachedTextBlock("stable pages block"),
+          { type: "text", text: "volatile current message" },
+        ],
+      },
+    ]);
+
+    const messages = lastStreamParams!.messages as Array<{
+      content: Array<{ cache_control?: { type: string; ttl?: string } }>;
+    }>;
+    expect(messages[0].content[0].cache_control).toEqual({
+      type: "ephemeral",
+      ttl: "1h",
+    });
+    expect(lastStreamParams!.betas).toContain("extended-cache-ttl-2025-04-11");
+  });
+
+  test("strips ttl from a caller's block cache_control and omits the beta for Haiku", async () => {
+    // Haiku doesn't support the extended-cache-ttl beta, so a caller-stamped
+    // 1h ttl (e.g. from `cachedTextBlock`) must be stripped before sending.
+    const haiku = new AnthropicProvider(
+      "sk-ant-test",
+      "claude-haiku-4-5-20251001",
+    );
+    await haiku.sendMessage([
+      {
+        role: "user",
+        content: [
+          cachedTextBlock("stable pages block"),
+          { type: "text", text: "volatile current message" },
+        ],
+      },
+    ]);
+
+    const messages = lastStreamParams!.messages as Array<{
+      content: Array<{ cache_control?: { type: string; ttl?: string } }>;
+    }>;
+    expect(messages[0].content[0].cache_control).toEqual({ type: "ephemeral" });
+    expect(messages[0].content[0].cache_control).not.toHaveProperty("ttl");
+    expect(
+      (lastStreamParams!.betas as string[] | undefined) ?? [],
+    ).not.toContain("extended-cache-ttl-2025-04-11");
+  });
+
+  test("v3-shape call (system + tools + cached prefix block) stays within the 4-breakpoint cap", async () => {
+    // Mirrors a v3 L2 selector call: a system prompt, a forced tool, and a user
+    // message whose stable <pages> block carries a cache_control breakpoint
+    // followed by the volatile current-message block. The preserved prefix
+    // breakpoint plus the client's system/tools/turn-start anchors must total
+    // exactly Anthropic's max of 4.
+    await provider.sendMessage(
+      [
+        {
+          role: "user",
+          content: [
+            cachedTextBlock("stable pages block"),
+            { type: "text", text: "volatile current message" },
+          ],
+        },
+      ],
+      { systemPrompt: "Select relevant pages.", tools: [sampleTools[0]] },
+    );
+
+    let breakpoints = 0;
+    const system = lastStreamParams!.system as
+      | Array<{ cache_control?: unknown }>
+      | undefined;
+    for (const b of system ?? []) if (b.cache_control) breakpoints++;
+    const tools = lastStreamParams!.tools as
+      | Array<{ cache_control?: unknown }>
+      | undefined;
+    for (const t of tools ?? []) if (t.cache_control) breakpoints++;
+    const messages = lastStreamParams!.messages as Array<{
+      content: Array<{ cache_control?: { type: string; ttl?: string } }>;
+    }>;
+    for (const m of messages)
+      for (const b of m.content) if (b.cache_control) breakpoints++;
+
+    expect(breakpoints).toBe(4);
+    // The stable pages block specifically must hold the preserved breakpoint.
+    expect(messages[0].content[0].cache_control).toEqual({
+      type: "ephemeral",
+      ttl: "1h",
+    });
+  });
+
   test("no tools param when tools are omitted", async () => {
     await provider.sendMessage([userMsg("Hi")]);
 

package/src/__tests__/assistant-event-hub.test.ts

@@ -189,6 +189,31 @@ describe("AssistantEventHub — unsubscribe cleanup", () => {
     expect(s.active).toBe(false);
   });
 
+  test("assigns a distinct per-connection id to each subscription", () => {
+    const hub = new AssistantEventHub();
+
+    // Two connections sharing one clientId (an old connection and the
+    // reconnect that supersedes it) must be distinguishable by connection
+    // id so logs can be attributed to a specific connection.
+    const first = hub.subscribe({
+      type: "client",
+      clientId: "client-1",
+      interfaceId: "macos",
+      capabilities: [],
+      callback: () => {},
+    });
+    const second = hub.subscribe({
+      type: "client",
+      clientId: "client-1",
+      interfaceId: "macos",
+      capabilities: [],
+      callback: () => {},
+    });
+
+    expect(first.connectionId).not.toBe(second.connectionId);
+    expect(second.connectionId).toMatch(/^conn-/);
+  });
+
   test("subscriberCount reflects live subscriptions only", () => {
     const hub = new AssistantEventHub();
 

package/src/__tests__/assistant-events-sse-shed.test.ts

@@ -36,6 +36,7 @@ interface ShedReport {
   client_id: string | null;
   interface_id: string | null;
   conversation_key: string | null;
+  connection_id: string | null;
   subscription_age_ms: number;
 }
 
@@ -54,6 +55,7 @@ function makeReporterCaptor(): {
         client_id: inst.clientId,
         interface_id: inst.interfaceId,
         conversation_key: inst.conversationKey,
+        connection_id: inst.connectionId,
         subscription_age_ms: Date.now() - inst.subscribedAtMs,
       });
     },
@@ -181,6 +183,10 @@ describe("SSE route — backpressure shed observability", () => {
     expect(reports.length).toBe(1);
     expect(reports[0]?.client_id).toBe("client-abc");
     expect(reports[0]?.interface_id).toBe("macos");
+    // The hub-assigned per-connection id is threaded into the shed
+    // report so a shed can be attributed to a specific connection even
+    // when several share a clientId across reconnects.
+    expect(reports[0]?.connection_id).toMatch(/^conn-/);
 
     ac.abort();
   });
@@ -195,6 +201,7 @@ describe("buildSseShedSentryContext", () => {
     interfaceId: "macos",
     // Channel-backed conversation key embedding a phone number.
     conversationKey: "asst:self:whatsapp:447123456789",
+    connectionId: "conn-1",
   };
   const elDelay = { mean_ms: 1.2, p99_ms: 3.4, max_ms: 5.6 };
 
@@ -224,6 +231,7 @@ describe("buildSseShedSentryContext", () => {
       heartbeats_sent: 3,
       client_id: "client-xyz",
       interface_id: "macos",
+      connection_id: "conn-1",
       event_loop_delay_mean_ms: 1.2,
       event_loop_delay_p99_ms: 3.4,
       event_loop_delay_max_ms: 5.6,