@vellumai/assistant 0.8.5 → 0.8.7-dev.202606052118.34cd356

package/src/__tests__/send-endpoint-busy.test.ts

@@ -91,11 +91,14 @@ mock.module("../config/loader.js", () => ({
 let _conversationFactory: (() => Conversation) | undefined;
 let _approvalGenerator: unknown;
 
-mock.module("../daemon/conversation-store.js", () => ({
+mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: () => {
     if (!_conversationFactory) return undefined;
     return _conversationFactory();
   },
+}));
+
+mock.module("../daemon/conversation-store.js", () => ({
   getOrCreateConversation: async (..._args: unknown[]) => {
     if (!_conversationFactory)
       throw new Error("_conversationFactory not set in test");
@@ -136,13 +139,9 @@ function makeCompletingConversation(): Conversation {
   const messages: unknown[] = [];
   return {
     isProcessing: () => processing,
-    persistUserMessage: (
-      _content: string,
-      _attachments: unknown[],
-      requestId?: string,
-    ) => {
+    persistUserMessage: (options: { requestId?: string }) => {
       processing = true;
-      return requestId ?? "msg-1";
+      return { id: options.requestId ?? "msg-1", deduplicated: false };
     },
     memoryPolicy: {
       scopeId: "default",
@@ -170,8 +169,9 @@ function makeCompletingConversation(): Conversation {
     runAgentLoop: async (
       _content: string,
       _messageId: string,
-      onEvent: (msg: ServerMessage) => void,
+      options?: { onEvent?: (msg: ServerMessage) => void },
     ) => {
+      const onEvent = options?.onEvent ?? (() => {});
       onEvent({ type: "assistant_text_delta", text: "Hello!" });
       onEvent({ type: "message_complete", conversationId: "test-session" });
       processing = false;
@@ -188,18 +188,14 @@ function makeHangingConversation(): Conversation {
   const messages: unknown[] = [];
   const enqueuedMessages: Array<{
     content: string;
-    onEvent: (msg: ServerMessage) => void;
-    requestId: string;
+    onEvent?: (msg: ServerMessage) => void;
+    requestId?: string;
   }> = [];
   return {
     isProcessing: () => processing,
-    persistUserMessage: (
-      _content: string,
-      _attachments: unknown[],
-      requestId?: string,
-    ) => {
+    persistUserMessage: (options: { requestId?: string }) => {
       processing = true;
-      return requestId ?? "msg-1";
+      return { id: options.requestId ?? "msg-1", deduplicated: false };
     },
     memoryPolicy: {
       scopeId: "default",
@@ -223,14 +219,20 @@ function makeHangingConversation(): Conversation {
     hasPendingConfirmation: () => false,
     denyAllPendingConfirmations: () => {},
     getQueueDepth: () => enqueuedMessages.length,
-    enqueueMessage: (
-      content: string,
-      _attachments: unknown[],
-      onEvent: (msg: ServerMessage) => void,
-      requestId: string,
-    ) => {
-      enqueuedMessages.push({ content, onEvent, requestId });
-      return { queued: true, requestId };
+    enqueueMessage: (options: {
+      content: string;
+      onEvent?: (msg: ServerMessage) => void;
+      requestId?: string;
+    }) => {
+      enqueuedMessages.push({
+        content: options.content,
+        onEvent: options.onEvent,
+        requestId: options.requestId,
+      });
+      return {
+        queued: true,
+        requestId: options.requestId ?? "hanging-req",
+      };
     },
     runAgentLoop: async () => {
       // Hang forever
@@ -259,14 +261,9 @@ function makePendingApprovalConversation(
   const messages: unknown[] = [];
   const runAgentLoopMock = mock(async () => {});
   const enqueueMessageMock = mock(
-    (
-      _content: string,
-      _attachments: unknown[],
-      _onEvent: (msg: ServerMessage) => void,
-      queuedRequestId: string,
-    ) => ({
+    (options: { content: string; requestId?: string }) => ({
       queued: true,
-      requestId: queuedRequestId,
+      requestId: options.requestId ?? "queued-req",
     }),
   );
   const denyAllPendingConfirmationsMock = mock(() => {
@@ -278,11 +275,10 @@ function makePendingApprovalConversation(
 
   const conversation = {
     isProcessing: () => processing,
-    persistUserMessage: (
-      _content: string,
-      _attachments: unknown[],
-      reqId?: string,
-    ) => reqId ?? "msg-1",
+    persistUserMessage: (options: { requestId?: string }) => ({
+      id: options.requestId ?? "msg-1",
+      deduplicated: false,
+    }),
     memoryPolicy: {
       scopeId: "default",
       includeDefaultFallback: false,
@@ -895,7 +891,7 @@ describe("POST /v1/messages — queue-if-busy and hub publishing", () => {
     await stopServer();
   });
 
-  test("accepts message when conversationKey is omitted (defaults to stable channel key)", async () => {
+  test("accepts message when conversationKey is omitted (vellum channel mints fresh)", async () => {
     await startServer(() => makeCompletingConversation());
 
     const res = await fetch(messagesUrl(), {
@@ -908,14 +904,24 @@ describe("POST /v1/messages — queue-if-busy and hub publishing", () => {
       }),
     });
     expect(res.status).toBe(202);
+    const body = (await res.json()) as {
+      accepted: boolean;
+      conversationId: string;
+    };
+    expect(body.accepted).toBe(true);
+    expect(body.conversationId).toBeTruthy();
+
+    // The vellum channel never falls through to the shared
+    // `default:vellum:<interface>` thread: each empty-handed send mints
+    // a fresh conversation so the first-message id surfaces to the client.
+    expect(getConversationByKey("default:vellum:macos")).toBeNull();
 
     await stopServer();
   });
 
-  test("two calls without conversationKey use the same conversation", async () => {
+  test("two empty-handed vellum sends each mint distinct conversations", async () => {
     await startServer(() => makeCompletingConversation());
 
-    // First message — no conversationKey
     const res1 = await fetch(messagesUrl(), {
       method: "POST",
       headers: { "Content-Type": "application/json", ...AUTH_HEADERS },
@@ -926,8 +932,8 @@ describe("POST /v1/messages — queue-if-busy and hub publishing", () => {
       }),
     });
     expect(res1.status).toBe(202);
+    const body1 = (await res1.json()) as { conversationId: string };
 
-    // Second message — same channel/interface, still no conversationKey
     const res2 = await fetch(messagesUrl(), {
       method: "POST",
       headers: { "Content-Type": "application/json", ...AUTH_HEADERS },
@@ -938,12 +944,49 @@ describe("POST /v1/messages — queue-if-busy and hub publishing", () => {
       }),
     });
     expect(res2.status).toBe(202);
+    const body2 = (await res2.json()) as { conversationId: string };
+
+    expect(body1.conversationId).toBeTruthy();
+    expect(body2.conversationId).toBeTruthy();
+    expect(body1.conversationId).not.toBe(body2.conversationId);
+
+    await stopServer();
+  });
+
+  test("two empty-handed phone sends share the default channel thread", async () => {
+    await startServer(() => makeCompletingConversation());
+
+    const res1 = await fetch(messagesUrl(), {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...AUTH_HEADERS },
+      body: JSON.stringify({
+        content: "First",
+        sourceChannel: "phone",
+        interface: "phone",
+      }),
+    });
+    expect(res1.status).toBe(202);
+    const body1 = (await res1.json()) as { conversationId: string };
+
+    const res2 = await fetch(messagesUrl(), {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...AUTH_HEADERS },
+      body: JSON.stringify({
+        content: "Second",
+        sourceChannel: "phone",
+        interface: "phone",
+      }),
+    });
+    expect(res2.status).toBe(202);
+    const body2 = (await res2.json()) as { conversationId: string };
 
-    // Both should have resolved to the same default conversation key
-    // ("default:vellum:macos"), which maps to the same conversationId.
-    const mapping = getConversationByKey("default:vellum:macos");
+    // Non-vellum channels keep the legacy `default:<channel>:<interface>`
+    // co-location so repeated inbound messages from the same external
+    // channel/interface land on a single thread.
+    expect(body1.conversationId).toBe(body2.conversationId);
+    const mapping = getConversationByKey("default:phone:phone");
     expect(mapping).not.toBeNull();
-    expect(mapping!.conversationId).toBeTruthy();
+    expect(mapping!.conversationId).toBe(body1.conversationId);
 
     await stopServer();
   });

package/src/__tests__/server-history-render.test.ts

@@ -8,6 +8,7 @@ mock.module("../util/logger.js", () => ({
 }));
 
 import { renderHistoryContent } from "../daemon/handlers/shared.js";
+import type { ToolActivityMetadata } from "../daemon/message-types/web-activity.js";
 import {
   getAttachmentsForMessage,
   linkAttachmentToMessage,
@@ -226,7 +227,7 @@ describe("renderHistoryContent", () => {
 
     expect(output.text).toBe("");
     expect(output.toolCalls).toEqual([
-      { name: "web_fetch", input: { url: "https://example.com" } },
+      { id: "tu_1", name: "web_fetch", input: { url: "https://example.com" } },
     ]);
     expect(output.toolCallsBeforeText).toBe(true);
   });
@@ -244,6 +245,7 @@ describe("renderHistoryContent", () => {
 
     expect(output.toolCalls).toEqual([
       {
+        id: "tu_1",
         name: "bash",
         input: { command: "ls" },
         result: "file1.txt\nfile2.txt",
@@ -265,6 +267,7 @@ describe("renderHistoryContent", () => {
 
     expect(output.toolCalls).toEqual([
       {
+        id: "tu_1",
         name: "bash",
         input: { command: "bad" },
         result: "command not found",
@@ -273,6 +276,74 @@ describe("renderHistoryContent", () => {
     ]);
   });
 
+  test("omits id when the tool_use block carries none", () => {
+    const output = renderHistoryContent([
+      { type: "tool_use", name: "bash", input: { command: "ls" } },
+    ]);
+
+    // No provider id on the block — emit the entry without an `id` rather than
+    // materializing an empty string, so clients fall back to a synthesized id.
+    expect(output.toolCalls).toEqual([
+      { name: "bash", input: { command: "ls" } },
+    ]);
+    expect(output.toolCalls[0]).not.toHaveProperty("id");
+  });
+
+  test("carries the provider id for server_tool_use blocks", () => {
+    const output = renderHistoryContent([
+      {
+        type: "server_tool_use",
+        id: "srvtu_1",
+        name: "web_search",
+        input: { query: "vellum" },
+      },
+    ]);
+
+    expect(output.toolCalls).toEqual([
+      { id: "srvtu_1", name: "web_search", input: { query: "vellum" } },
+    ]);
+  });
+
+  test("synthesizes a positional id when a tool_use lacks a provider id", () => {
+    const output = renderHistoryContent(
+      [
+        { type: "tool_use", name: "bash", input: { command: "ls" } },
+        { type: "tool_use", name: "bash", input: { command: "pwd" } },
+      ],
+      undefined,
+      "msg-1",
+    );
+
+    // Same positional scheme the web client used to synthesize, so snapshot and
+    // stream tool calls stay keyed consistently and the client can drop its own
+    // fallback once it no longer skews ahead of the daemon.
+    expect(output.toolCalls.map((tc) => tc.id)).toEqual([
+      "tool-history-msg-1-0",
+      "tool-history-msg-1-1",
+    ]);
+  });
+
+  test("keeps the provider id and only synthesizes for blocks missing one", () => {
+    const output = renderHistoryContent(
+      [
+        {
+          type: "tool_use",
+          id: "tu_1",
+          name: "bash",
+          input: { command: "ls" },
+        },
+        { type: "tool_use", name: "bash", input: { command: "pwd" } },
+      ],
+      undefined,
+      "msg-1",
+    );
+
+    expect(output.toolCalls.map((tc) => tc.id)).toEqual([
+      "tu_1",
+      "tool-history-msg-1-1",
+    ]);
+  });
+
   // ── Persisted risk-option ladders (Phase B of conflation track) ─────────────
 
   test("hydrates persisted _risk*Options annotations onto tool calls", () => {
@@ -315,6 +386,79 @@ describe("renderHistoryContent", () => {
     expect(entry.riskDirectoryScopeOptions).toEqual(directoryScopeOptions);
   });
 
+  // ── Persisted tool activity (web_search / web_fetch) ────────────────────────
+
+  test("hydrates persisted _activityMetadata onto a tool_use block", () => {
+    // Mirrors what `annotatePersistedAssistantMessage` writes so the activity
+    // card survives a history reopen instead of degrading to plain text.
+    const activityMetadata: ToolActivityMetadata = {
+      webSearch: {
+        query: "vellum docs",
+        provider: "brave",
+        resultCount: 1,
+        durationMs: 120,
+        results: [
+          {
+            rank: 1,
+            title: "Vellum",
+            url: "https://vellum.ai",
+            domain: "vellum.ai",
+          },
+        ],
+      },
+    };
+
+    const output = renderHistoryContent([
+      {
+        type: "tool_use",
+        id: "tu_1",
+        name: "web_search",
+        input: { query: "vellum docs" },
+        _activityMetadata: activityMetadata,
+      },
+    ]);
+
+    expect(output.toolCalls[0].activityMetadata).toEqual(activityMetadata);
+  });
+
+  test("hydrates persisted _activityMetadata onto a server_tool_use block", () => {
+    const activityMetadata: ToolActivityMetadata = {
+      webSearch: {
+        query: "native search",
+        provider: "anthropic-native",
+        resultCount: 0,
+        durationMs: 80,
+        results: [],
+      },
+    };
+
+    const output = renderHistoryContent([
+      {
+        type: "server_tool_use",
+        id: "srvtu_1",
+        name: "web_search",
+        input: { query: "native search" },
+        _activityMetadata: activityMetadata,
+      },
+    ]);
+
+    expect(output.toolCalls[0].activityMetadata).toEqual(activityMetadata);
+  });
+
+  test("ignores non-object _activityMetadata annotations", () => {
+    const output = renderHistoryContent([
+      {
+        type: "tool_use",
+        id: "tu_1",
+        name: "web_search",
+        input: { query: "x" },
+        _activityMetadata: "not an object",
+      },
+    ]);
+
+    expect(output.toolCalls[0].activityMetadata).toBeUndefined();
+  });
+
   test("ignores non-array _risk*Options annotations", () => {
     // Defensive: a malformed persisted block should not throw or coerce.
     const output = renderHistoryContent([
@@ -355,6 +499,46 @@ describe("renderHistoryContent", () => {
     expect(entry.riskDirectoryScopeOptions).toBeUndefined();
   });
 
+  test("reads back a persisted confirmation decision from the closed enum", () => {
+    // GIVEN a persisted tool_use block stamped with a recorded decision
+    const output = renderHistoryContent([
+      {
+        type: "tool_use",
+        id: "tu_1",
+        name: "bash",
+        input: { command: "rm file" },
+        _confirmationDecision: "denied",
+        _confirmationLabel: "Run Command",
+      },
+    ]);
+
+    // WHEN it is rendered into a history tool call
+    const [entry] = output.toolCalls;
+
+    // THEN the decision survives verbatim alongside its label
+    expect(entry.confirmationDecision).toBe("denied");
+    expect(entry.confirmationLabel).toBe("Run Command");
+  });
+
+  test("drops a _confirmationDecision outside the closed enum", () => {
+    // GIVEN a malformed persisted decision the daemon never writes
+    const output = renderHistoryContent([
+      {
+        type: "tool_use",
+        id: "tu_1",
+        name: "bash",
+        input: { command: "ls" },
+        _confirmationDecision: "bogus",
+      },
+    ]);
+
+    // WHEN it is rendered into a history tool call
+    const [entry] = output.toolCalls;
+
+    // THEN the unknown value is not surfaced on the wire
+    expect(entry.confirmationDecision).toBeUndefined();
+  });
+
   test("handles mixed text and tool blocks", () => {
     const output = renderHistoryContent([
       { type: "text", text: "Let me look that up." },
@@ -569,6 +753,135 @@ describe("renderHistoryContent", () => {
   });
 });
 
+describe("renderHistoryContent contentBlocks", () => {
+  test("builds an ordered block array while walking interleaved content", () => {
+    // GIVEN a turn that interleaves text, reasoning, a tool call, a surface,
+    // and trailing text in the raw model content
+    const output = renderHistoryContent([
+      { type: "text", text: "before tool" },
+      { type: "thinking", thinking: "reasoning", signature: "sig" },
+      { type: "tool_use", id: "t1", name: "run_command", input: { cmd: "ls" } },
+      { type: "tool_result", tool_use_id: "t1", content: "file.txt" },
+      {
+        type: "ui_surface",
+        surfaceId: "s1",
+        surfaceType: "ui_card",
+        data: {},
+      },
+      { type: "text", text: "after tool" },
+    ]);
+
+    // THEN contentBlocks mirrors the walk order
+    expect(output.contentBlocks.map((b) => b.type)).toEqual([
+      "text",
+      "thinking",
+      "tool_use",
+      "surface",
+      "text",
+    ]);
+    expect(output.contentBlocks[0]).toEqual({
+      type: "text",
+      text: "before tool",
+    });
+    expect(output.contentBlocks[1]).toEqual({
+      type: "thinking",
+      thinking: "reasoning",
+    });
+    expect(output.contentBlocks[4]).toEqual({
+      type: "text",
+      text: "after tool",
+    });
+    // AND the tool_use / surface blocks reuse the same objects the positional
+    // arrays hold, so the tool result paired in later is reflected here too
+    const toolBlock = output.contentBlocks[2];
+    expect(toolBlock.type === "tool_use" && toolBlock.toolCall).toBe(
+      output.toolCalls[0],
+    );
+    expect(output.toolCalls[0].result).toBe("file.txt");
+    const surfaceBlock = output.contentBlocks[3];
+    expect(surfaceBlock.type === "surface" && surfaceBlock.surface).toBe(
+      output.surfaces[0],
+    );
+    // AND no attachment block appears (this turn has no file blocks)
+    expect(output.contentBlocks.some((b) => b.type === "attachment")).toBe(
+      false,
+    );
+  });
+
+  const pdfBlock = {
+    type: "file",
+    source: {
+      type: "base64",
+      media_type: "application/pdf",
+      filename: "spec.pdf",
+      data: Buffer.from("hi").toString("base64"),
+    },
+  } as const;
+  const pdfAttachment = {
+    id: "att-1",
+    filename: "spec.pdf",
+    mimeType: "application/pdf",
+    sizeBytes: 2,
+    kind: "file",
+  } as const;
+
+  test("inlines an attachment block when hydrated metadata is supplied", () => {
+    // GIVEN a turn with text, a file attachment, then more text, and the
+    // caller supplies the DB-hydrated metadata for that file block
+    const output = renderHistoryContent(
+      [
+        { type: "text", text: "see file" },
+        pdfBlock,
+        { type: "text", text: "thanks" },
+      ],
+      [pdfAttachment],
+    );
+
+    // THEN the attachment block is placed inline between the two text blocks
+    expect(output.contentBlocks).toEqual([
+      { type: "text", text: "see file" },
+      { type: "attachment", attachment: pdfAttachment },
+      { type: "text", text: "thanks" },
+    ]);
+  });
+
+  test("omits the file block from contentBlocks when no metadata is supplied", () => {
+    // GIVEN the same turn but no hydrated metadata (the file still ships via
+    // the positional attachments array, just not as an inline block)
+    const output = renderHistoryContent([
+      { type: "text", text: "see file" },
+      pdfBlock,
+      { type: "text", text: "thanks" },
+    ]);
+
+    expect(output.contentBlocks).toEqual([
+      { type: "text", text: "see file" },
+      { type: "text", text: "thanks" },
+    ]);
+    expect(output.attachments.length).toBe(1);
+  });
+
+  test("excludes the trailing attachment-description segment from blocks", () => {
+    // GIVEN an attachment-only turn (the legacy text body carries a synthetic
+    // attachment description segment for clients without attachment UI)
+    const output = renderHistoryContent([pdfBlock], [pdfAttachment]);
+
+    // THEN the only block is the inlined attachment — the synthetic text
+    // segment stays in textSegments but never pollutes contentBlocks
+    expect(output.contentBlocks).toEqual([
+      { type: "attachment", attachment: pdfAttachment },
+    ]);
+    expect(output.textSegments.length).toBe(1);
+  });
+
+  test("emits a single text block for the non-array fallback", () => {
+    expect(renderHistoryContent("raw string").contentBlocks).toEqual([
+      { type: "text", text: "raw string" },
+    ]);
+    expect(renderHistoryContent(null).contentBlocks).toEqual([]);
+  });
+});
+
 describe("getAttachmentsForMessage", () => {
   beforeEach(() => {
     const db = getDb();
@@ -578,7 +891,10 @@ describe("getAttachmentsForMessage", () => {
     db.run("DELETE FROM conversations");
   });
 
-  async function createMessage(role: string, content: string): Promise<string> {
+  async function createMessage(
+    role: "user" | "assistant" | "system",
+    content: string,
+  ): Promise<string> {
     const conv = createConversation("test");
     const msg = await addMessage(conv.id, role, content);
     return msg.id;