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

package/src/__tests__/list-messages-attachments.test.ts

@@ -179,11 +179,10 @@ describe("handleListMessages no_response filtering", () => {
 
     const response = handleListMessages(createTestArgs(conv.id));
     const body = response as {
-      messages: { content: string; textSegments: string[] }[];
+      messages: { textSegments?: string[] }[];
     };
 
     expect(body.messages).toHaveLength(1);
-    expect(body.messages[0].content).toBe("");
     // textSegments is omitted from payload when empty
     expect(body.messages[0].textSegments).toBeUndefined();
   });
@@ -201,11 +200,10 @@ describe("handleListMessages no_response filtering", () => {
 
     const response = handleListMessages(createTestArgs(conv.id));
     const body = response as {
-      messages: { content: string; textSegments: string[] }[];
+      messages: { textSegments?: string[] }[];
     };
 
     expect(body.messages).toHaveLength(1);
-    expect(body.messages[0].content).toBe("Real reply.");
     expect(body.messages[0].textSegments).toEqual(["Real reply."]);
   });
 
@@ -231,7 +229,6 @@ describe("handleListMessages no_response filtering", () => {
     const response = handleListMessages(createTestArgs(conv.id));
     const body = response as {
       messages: {
-        content: string;
         textSegments: string[];
         contentOrder: string[];
       }[];
@@ -254,11 +251,13 @@ describe("handleListMessages no_response filtering", () => {
 
     const response = handleListMessages(createTestArgs(conv.id));
     const body = response as {
-      messages: { content: string }[];
+      messages: { textSegments?: string[] }[];
     };
 
     expect(body.messages).toHaveLength(1);
-    expect(body.messages[0].content).toBe("What does <no_response/> do?");
+    expect(body.messages[0].textSegments).toEqual([
+      "What does <no_response/> do?",
+    ]);
   });
 });
 
@@ -267,7 +266,7 @@ describe("handleListMessages no_response filtering", () => {
 // ---------------------------------------------------------------------------
 
 interface PaginatedResponse {
-  messages: { id: string; content: string; timestamp: string }[];
+  messages: { id: string; timestamp: string }[];
   hasMore?: boolean;
   oldestTimestamp?: number;
   oldestMessageId?: string;

package/src/__tests__/list-messages-hidden-metadata.test.ts

@@ -48,7 +48,12 @@ function resetTables() {
 
 interface MessagePayload {
   role: string;
-  content: string;
+  textSegments?: string[];
+}
+
+/** Flatten a payload's text segments to plain text for content assertions. */
+function plainText(message: MessagePayload): string {
+  return (message.textSegments ?? []).join("");
 }
 
 describe("handleListMessages metadata.hidden filtering", () => {
@@ -65,7 +70,7 @@ describe("handleListMessages metadata.hidden filtering", () => {
       conv.id,
       "assistant",
       JSON.stringify([{ type: "text", text: "internal scaffolding" }]),
-      { hidden: true },
+      { metadata: { hidden: true } },
     );
     await addMessage(
       conv.id,
@@ -79,10 +84,10 @@ describe("handleListMessages metadata.hidden filtering", () => {
     const body = response as { messages: MessagePayload[] };
 
     expect(body.messages).toHaveLength(2);
-    expect(body.messages[0].content).toBe("first visible");
-    expect(body.messages[1].content).toBe("second visible");
+    expect(plainText(body.messages[0])).toBe("first visible");
+    expect(plainText(body.messages[1])).toBe("second visible");
     expect(
-      body.messages.some((m) => m.content.includes("internal scaffolding")),
+      body.messages.some((m) => plainText(m).includes("internal scaffolding")),
     ).toBe(false);
 
     // LLM-side loader must include the hidden row so agent context is intact.
@@ -91,6 +96,44 @@ describe("handleListMessages metadata.hidden filtering", () => {
     expect(llmRows[1].metadata).toContain('"hidden":true');
   });
 
+  test("UI serializer omits system rows but LLM-side getMessages includes them", async () => {
+    // GIVEN a conversation with a system row sandwiched between two
+    // renderable turns (e.g. a skill-authored context message)
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "first visible" }]),
+    );
+    await addMessage(
+      conv.id,
+      "system",
+      JSON.stringify([{ type: "text", text: "system scaffolding" }]),
+    );
+    await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "second visible" }]),
+    );
+
+    // WHEN the UI history list is serialized
+    const response = handleListMessages({
+      queryParams: { conversationId: conv.id },
+    });
+    const body = response as { messages: MessagePayload[] };
+
+    // THEN only the user/assistant turns are returned, never the system row
+    expect(body.messages.map((m) => m.role)).toEqual(["user", "assistant"]);
+    expect(
+      body.messages.some((m) => plainText(m).includes("system scaffolding")),
+    ).toBe(false);
+
+    // AND the LLM-side loader still includes the system row for agent context
+    const llmRows = getMessages(conv.id);
+    expect(llmRows).toHaveLength(3);
+    expect(llmRows[1].role).toBe("system");
+  });
+
   test("messages without metadata or with hidden=false are returned", async () => {
     const conv = createConversation();
     await addMessage(
@@ -102,7 +145,7 @@ describe("handleListMessages metadata.hidden filtering", () => {
       conv.id,
       "assistant",
       JSON.stringify([{ type: "text", text: "hidden false" }]),
-      { hidden: false },
+      { metadata: { hidden: false } },
     );
 
     const response = handleListMessages({
@@ -131,7 +174,7 @@ describe("handleListMessages metadata.hidden filtering", () => {
         conv.id,
         "assistant",
         JSON.stringify([{ type: "text", text: `hidden ${i}` }]),
-        { hidden: true },
+        { metadata: { hidden: true } },
       );
     }
     for (let i = 0; i < 2; i++) {
@@ -151,7 +194,7 @@ describe("handleListMessages metadata.hidden filtering", () => {
       oldestMessageId: string | null;
     };
 
-    expect(latest.messages.map((m) => m.content)).toEqual([
+    expect(latest.messages.map(plainText)).toEqual([
       "new visible 0",
       "new visible 1",
     ]);
@@ -172,7 +215,7 @@ describe("handleListMessages metadata.hidden filtering", () => {
       hasMore: boolean;
     };
 
-    expect(older.messages.map((m) => m.content)).toEqual([
+    expect(older.messages.map(plainText)).toEqual([
       "old visible 2",
       "old visible 3",
     ]);
@@ -247,10 +290,7 @@ describe("handleListMessages metadata.hidden filtering", () => {
         },
       }) as { messages: MessagePayload[]; hasMore: boolean };
 
-      expect(older.messages.map((m) => m.content)).toEqual([
-        "visible 0",
-        "visible 1",
-      ]);
+      expect(older.messages.map(plainText)).toEqual(["visible 0", "visible 1"]);
       expect(older.hasMore).toBe(false);
     } finally {
       _setPaginationScanCapForTesting(undefined);
@@ -275,7 +315,7 @@ describe("handleListMessages metadata.hidden filtering", () => {
         conv.id,
         "assistant",
         JSON.stringify([{ type: "text", text: `hidden ${i}` }]),
-        { hidden: true },
+        { metadata: { hidden: true } },
       );
     }
 
@@ -287,7 +327,7 @@ describe("handleListMessages metadata.hidden filtering", () => {
       oldestTimestamp: number | null;
     };
 
-    expect(latest.messages.map((m) => m.content)).toEqual([
+    expect(latest.messages.map(plainText)).toEqual([
       "old visible 0",
       "old visible 1",
     ]);

package/src/__tests__/list-messages-page-latest.test.ts

@@ -42,6 +42,10 @@ import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { messages } from "../memory/schema.js";
 import { writeSlackMetadata } from "../messaging/providers/slack/message-metadata.js";
+import {
+  _resetStreamStateForTesting,
+  recordPersistedSeq,
+} from "../runtime/assistant-stream-state.js";
 import { handleListMessages } from "../runtime/routes/conversation-routes.js";
 import { BadRequestError } from "../runtime/routes/errors.js";
 
@@ -90,7 +94,6 @@ function seedMessages(
 interface MessagePayload {
   id: string;
   role: string;
-  content: string;
   timestamp: string;
   slackMessage?: {
     channelId: string;
@@ -108,6 +111,7 @@ interface ListResponse {
   hasMore?: boolean;
   oldestTimestamp?: number | null;
   oldestMessageId?: string | null;
+  seq?: number | null;
 }
 
 function callList(query: Record<string, string>): ListResponse {
@@ -119,9 +123,64 @@ function callList(query: Record<string, string>): ListResponse {
 describe("handleListMessages page=latest", () => {
   beforeEach(() => {
     resetTables();
+    _resetStreamStateForTesting();
     mockAssistantName = null;
   });
 
+  describe("persisted seq", () => {
+    test("returns the recorded persisted seq for the conversation", () => {
+      /**
+       * The snapshot must advertise the `seq` of the last durably-persisted
+       * event so a client can align it with the `/events` stream.
+       */
+
+      // GIVEN a conversation with persisted messages
+      const conv = createConversation();
+      seedMessages(conv.id, 3);
+      // AND the daemon has recorded a persisted seq for it
+      recordPersistedSeq(conv.id, 42);
+
+      // WHEN the snapshot is fetched
+      const body = callList({ conversationId: conv.id, page: "latest" });
+
+      // THEN the response carries that seq
+      expect(body.seq).toBe(42);
+    });
+
+    test("returns null seq when nothing has been persisted in-process", () => {
+      /**
+       * A cold conversation (or one aged out / post-restart) reports no seq,
+       * signalling the client to cold-start rather than align to a stale
+       * position.
+       */
+
+      // GIVEN a conversation with no recorded persisted seq
+      const conv = createConversation();
+      seedMessages(conv.id, 2);
+
+      // WHEN the snapshot is fetched
+      const body = callList({ conversationId: conv.id, page: "latest" });
+
+      // THEN seq is null
+      expect(body.seq).toBeNull();
+    });
+
+    test("the no-pagination path also returns the persisted seq", () => {
+      /** `seq` is present on every resolved-conversation response shape. */
+
+      // GIVEN a conversation with a recorded persisted seq
+      const conv = createConversation();
+      seedMessages(conv.id, 2);
+      recordPersistedSeq(conv.id, 7);
+
+      // WHEN fetched with no pagination params
+      const body = callList({ conversationId: conv.id });
+
+      // THEN the seq still rides along
+      expect(body.seq).toBe(7);
+    });
+  });
+
   test("page=latest with no limit returns all messages chronologically", () => {
     const conv = createConversation();
     seedMessages(conv.id, 120);

package/src/__tests__/list-messages-tool-merge.test.ts

@@ -52,10 +52,13 @@ interface ToolCallPayload {
 }
 
 interface MessagePayload {
+  id: string;
+  mergedMessageIds?: string[];
   role: string;
-  content: string;
   toolCalls?: ToolCallPayload[];
   textSegments?: string[];
+  contentOrder?: string[];
+  contentBlocks?: Array<{ type: string; [key: string]: unknown }>;
 }
 
 describe("handleListMessages tool_result merging", () => {
@@ -105,6 +108,24 @@ describe("handleListMessages tool_result merging", () => {
     expect(toolCalls).toHaveLength(1);
     expect(toolCalls![0].name).toBe("bash");
     expect(toolCalls![0].result).toBe("file1.txt\nfile2.txt");
+
+    // The unified contentBlocks projection ships alongside the legacy arrays,
+    // in contentOrder order, with the tool_result already paired onto the
+    // tool_use block.
+    expect(body.messages[1].contentOrder).toEqual(["text:0", "tool:0"]);
+    expect(body.messages[1].contentBlocks).toEqual([
+      { type: "text", text: "Running command." },
+      {
+        type: "tool_use",
+        toolCall: {
+          id: "tu1",
+          name: "bash",
+          input: { command: "ls" },
+          result: "file1.txt\nfile2.txt",
+          isError: false,
+        },
+      },
+    ]);
   });
 
   test("merges multiple tool_results into matching tool_uses", async () => {
@@ -172,7 +193,36 @@ describe("handleListMessages tool_result merging", () => {
 
     expect(body.messages).toHaveLength(3);
     expect(body.messages[2].role).toBe("user");
-    expect(body.messages[2].content).toBe("how are you?");
+    expect(body.messages[2].textSegments).toEqual(["how are you?"]);
+  });
+
+  test("includes merged assistant ids for consecutive assistant history rows", async () => {
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "start" }]),
+    );
+    const anchor = await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "Checking." }]),
+    );
+    const tail = await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "Done." }]),
+    );
+
+    const response = handleListMessages(createTestArgs(conv.id));
+    const body = response as { messages: MessagePayload[] };
+
+    expect(body.messages).toHaveLength(2);
+    expect(body.messages[1]).toMatchObject({
+      id: anchor.id,
+      role: "assistant",
+      mergedMessageIds: [tail.id],
+    });
   });
 
   test("orphan tool_result at pagination boundary is suppressed entirely", async () => {
@@ -205,7 +255,7 @@ describe("handleListMessages tool_result merging", () => {
     // User row dropped entirely; only the assistant survives.
     expect(body.messages).toHaveLength(1);
     expect(body.messages[0].role).toBe("assistant");
-    expect(body.messages[0].content).toBe("response");
+    expect(body.messages[0].textSegments).toEqual(["response"]);
   });
 
   test("mixed content at pagination boundary keeps real user text", async () => {
@@ -236,10 +286,10 @@ describe("handleListMessages tool_result merging", () => {
 
     expect(body.messages).toHaveLength(2);
     expect(body.messages[0].role).toBe("user");
-    expect(body.messages[0].content).toBe("what about this?");
+    expect(body.messages[0].textSegments).toEqual(["what about this?"]);
     expect(body.messages[0].toolCalls).toBeUndefined();
     expect(body.messages[1].role).toBe("assistant");
-    expect(body.messages[1].content).toBe("answering");
+    expect(body.messages[1].textSegments).toEqual(["answering"]);
   });
 
   test("orphan tool_result + system_notice at boundary is suppressed", async () => {
@@ -337,7 +387,7 @@ describe("handleListMessages tool_result merging", () => {
     expect(body.messages[1].toolCalls![1].name).toBe("file_read");
     expect(body.messages[1].toolCalls![1].result).toBe("file data");
     expect(body.messages[2].role).toBe("user");
-    expect(body.messages[2].content).toBe("thanks");
+    expect(body.messages[2].textSegments).toEqual(["thanks"]);
   });
 
   test("tool_result with is_error propagates error status", async () => {

package/src/__tests__/llm-request-log-turn-query.test.ts

@@ -65,10 +65,10 @@ describe("getRequestLogsByMessageId — turn-aware query", () => {
 
   test("single message, single log: backward compat — returns 1 log", async () => {
     const conv = createConversation("single-msg");
-    await addMessage(conv.id, "user", "Hello", undefined, {
+    await addMessage(conv.id, "user", "Hello", {
       skipIndexing: true,
     });
-    const a1 = await addMessage(conv.id, "assistant", "Hi!", undefined, {
+    const a1 = await addMessage(conv.id, "assistant", "Hi!", {
       skipIndexing: true,
     });
 
@@ -86,33 +86,25 @@ describe("getRequestLogsByMessageId — turn-aware query", () => {
     const conv = createConversation("multi-step");
 
     // user → A1 (+ log1) → tool_result → A2 (+ log2)
-    await addMessage(conv.id, "user", "Do the task", undefined, {
+    await addMessage(conv.id, "user", "Do the task", {
       skipIndexing: true,
     });
 
     // First LLM call → A1
     recordRequestLog(conv.id, '{"step":1}', '{"tool_use":"bash"}');
-    const a1 = await addMessage(
-      conv.id,
-      "assistant",
-      "Using tool...",
-      undefined,
-      { skipIndexing: true },
-    );
+    const a1 = await addMessage(conv.id, "assistant", "Using tool...", {
+      skipIndexing: true,
+    });
     backfillMessageIdOnLogs(conv.id, a1.id);
 
     // tool_result user message
-    await addMessage(
-      conv.id,
-      "user",
-      toolResultContent(["tool-1"]),
-      undefined,
-      { skipIndexing: true },
-    );
+    await addMessage(conv.id, "user", toolResultContent(["tool-1"]), {
+      skipIndexing: true,
+    });
 
     // Second LLM call → A2
     recordRequestLog(conv.id, '{"step":2}', '{"result":"done"}');
-    const a2 = await addMessage(conv.id, "assistant", "All done!", undefined, {
+    const a2 = await addMessage(conv.id, "assistant", "All done!", {
       skipIndexing: true,
     });
     backfillMessageIdOnLogs(conv.id, a2.id);
@@ -130,36 +122,24 @@ describe("getRequestLogsByMessageId — turn-aware query", () => {
     const source = createConversation("source-conv");
 
     // Build a multi-step turn in the source conversation
-    await addMessage(source.id, "user", "Original task", undefined, {
+    await addMessage(source.id, "user", "Original task", {
       skipIndexing: true,
     });
 
     recordRequestLog(source.id, '{"step":1}', '{"tool":"bash"}');
-    const a1 = await addMessage(
-      source.id,
-      "assistant",
-      "Using tool...",
-      undefined,
-      { skipIndexing: true },
-    );
+    const a1 = await addMessage(source.id, "assistant", "Using tool...", {
+      skipIndexing: true,
+    });
     backfillMessageIdOnLogs(source.id, a1.id);
 
-    await addMessage(
-      source.id,
-      "user",
-      toolResultContent(["tool-1"]),
-      undefined,
-      { skipIndexing: true },
-    );
+    await addMessage(source.id, "user", toolResultContent(["tool-1"]), {
+      skipIndexing: true,
+    });
 
     recordRequestLog(source.id, '{"step":2}', '{"result":"ok"}');
-    const a2 = await addMessage(
-      source.id,
-      "assistant",
-      "Done with source!",
-      undefined,
-      { skipIndexing: true },
-    );
+    const a2 = await addMessage(source.id, "assistant", "Done with source!", {
+      skipIndexing: true,
+    });
     backfillMessageIdOnLogs(source.id, a2.id);
 
     // Fork the conversation
@@ -183,49 +163,33 @@ describe("getRequestLogsByMessageId — turn-aware query", () => {
     const conv = createConversation("two-turns");
 
     // First turn: user → A1 (+ log1)
-    await addMessage(conv.id, "user", "First question", undefined, {
+    await addMessage(conv.id, "user", "First question", {
       skipIndexing: true,
     });
     recordRequestLog(conv.id, '{"turn":1}', '{"answer":"first"}');
-    const a1 = await addMessage(
-      conv.id,
-      "assistant",
-      "First answer",
-      undefined,
-      { skipIndexing: true },
-    );
+    const a1 = await addMessage(conv.id, "assistant", "First answer", {
+      skipIndexing: true,
+    });
     backfillMessageIdOnLogs(conv.id, a1.id);
 
     // Second turn: user → A2 (+ log2) → tool_result → A3 (+ log3)
-    await addMessage(conv.id, "user", "Second question", undefined, {
+    await addMessage(conv.id, "user", "Second question", {
       skipIndexing: true,
     });
     recordRequestLog(conv.id, '{"turn":2,"step":1}', '{"tool":"bash"}');
-    const a2 = await addMessage(
-      conv.id,
-      "assistant",
-      "Using tool...",
-      undefined,
-      { skipIndexing: true },
-    );
+    const a2 = await addMessage(conv.id, "assistant", "Using tool...", {
+      skipIndexing: true,
+    });
     backfillMessageIdOnLogs(conv.id, a2.id);
 
-    await addMessage(
-      conv.id,
-      "user",
-      toolResultContent(["tool-2"]),
-      undefined,
-      { skipIndexing: true },
-    );
+    await addMessage(conv.id, "user", toolResultContent(["tool-2"]), {
+      skipIndexing: true,
+    });
 
     recordRequestLog(conv.id, '{"turn":2,"step":2}', '{"result":"done"}');
-    const a3 = await addMessage(
-      conv.id,
-      "assistant",
-      "Second done!",
-      undefined,
-      { skipIndexing: true },
-    );
+    const a3 = await addMessage(conv.id, "assistant", "Second done!", {
+      skipIndexing: true,
+    });
     backfillMessageIdOnLogs(conv.id, a3.id);
 
     // Query second turn → should only return logs for A2 and A3, NOT A1
@@ -468,33 +432,25 @@ describe("getRequestLogsByMessageId — turn-aware query", () => {
     const conv = createConversation("relink-test");
 
     // Simulate multi-step turn: user → A1 (+ log1) → tool_result → A2 (+ log2)
-    await addMessage(conv.id, "user", "Do the task", undefined, {
+    await addMessage(conv.id, "user", "Do the task", {
       skipIndexing: true,
     });
 
     // First LLM call → A1 (tool_use response)
     recordRequestLog(conv.id, '{"step":1}', '{"tool_use":"bash"}');
-    const a1 = await addMessage(
-      conv.id,
-      "assistant",
-      "Using tool...",
-      undefined,
-      { skipIndexing: true },
-    );
+    const a1 = await addMessage(conv.id, "assistant", "Using tool...", {
+      skipIndexing: true,
+    });
     backfillMessageIdOnLogs(conv.id, a1.id);
 
     // tool_result user message
-    await addMessage(
-      conv.id,
-      "user",
-      toolResultContent(["tool-1"]),
-      undefined,
-      { skipIndexing: true },
-    );
+    await addMessage(conv.id, "user", toolResultContent(["tool-1"]), {
+      skipIndexing: true,
+    });
 
     // Second LLM call → A2 (text response)
     recordRequestLog(conv.id, '{"step":2}', '{"result":"done"}');
-    const a2 = await addMessage(conv.id, "assistant", "All done!", undefined, {
+    const a2 = await addMessage(conv.id, "assistant", "All done!", {
       skipIndexing: true,
     });
     backfillMessageIdOnLogs(conv.id, a2.id);