@vellumai/assistant 0.8.3 → 0.8.5

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

@@ -78,7 +78,7 @@ describe("handleListMessages attachments", () => {
     const stored = uploadAttachment("photo.png", "image/png", IMAGE_BASE64);
     linkAttachmentToMessage(msg.id, stored.id, 0);
 
-    const response = handleListMessages(createTestArgs(conv.id), null);
+    const response = handleListMessages(createTestArgs(conv.id));
     const body = response as { messages: MessagePayload[] };
 
     expect(body.messages).toHaveLength(1);
@@ -103,7 +103,7 @@ describe("handleListMessages attachments", () => {
     );
     linkAttachmentToMessage(msg.id, stored.id, 0);
 
-    const response = handleListMessages(createTestArgs(conv.id), null);
+    const response = handleListMessages(createTestArgs(conv.id));
     const body = response as { messages: MessagePayload[] };
 
     expect(body.messages).toHaveLength(1);
@@ -125,7 +125,7 @@ describe("handleListMessages attachments", () => {
     const stored = uploadAttachment("result.png", "image/png", IMAGE_BASE64);
     linkAttachmentToMessage(msg.id, stored.id, 0);
 
-    const response = handleListMessages(createTestArgs(conv.id), null);
+    const response = handleListMessages(createTestArgs(conv.id));
     const body = response as { messages: MessagePayload[] };
 
     expect(body.messages).toHaveLength(1);
@@ -153,7 +153,7 @@ describe("handleListMessages attachments", () => {
     linkAttachmentToMessage(msg.id, imgStored.id, 0);
     linkAttachmentToMessage(msg.id, docStored.id, 1);
 
-    const response = handleListMessages(createTestArgs(conv.id), null);
+    const response = handleListMessages(createTestArgs(conv.id));
     const body = response as { messages: MessagePayload[] };
 
     const attachments = body.messages[0].attachments!;
@@ -177,7 +177,7 @@ describe("handleListMessages no_response filtering", () => {
       JSON.stringify([{ type: "text", text: "<no_response/>" }]),
     );
 
-    const response = handleListMessages(createTestArgs(conv.id), null);
+    const response = handleListMessages(createTestArgs(conv.id));
     const body = response as {
       messages: { content: string; textSegments: string[] }[];
     };
@@ -199,7 +199,7 @@ describe("handleListMessages no_response filtering", () => {
       ]),
     );
 
-    const response = handleListMessages(createTestArgs(conv.id), null);
+    const response = handleListMessages(createTestArgs(conv.id));
     const body = response as {
       messages: { content: string; textSegments: string[] }[];
     };
@@ -228,7 +228,7 @@ describe("handleListMessages no_response filtering", () => {
       ]),
     );
 
-    const response = handleListMessages(createTestArgs(conv.id), null);
+    const response = handleListMessages(createTestArgs(conv.id));
     const body = response as {
       messages: {
         content: string;
@@ -252,7 +252,7 @@ describe("handleListMessages no_response filtering", () => {
       JSON.stringify([{ type: "text", text: "What does <no_response/> do?" }]),
     );
 
-    const response = handleListMessages(createTestArgs(conv.id), null);
+    const response = handleListMessages(createTestArgs(conv.id));
     const body = response as {
       messages: { content: string }[];
     };
@@ -308,7 +308,7 @@ describe("handleListMessages pagination", () => {
     const conv = createConversation();
     await insertMessages(conv.id, 5);
 
-    const response = handleListMessages(createTestArgs(conv.id), null);
+    const response = handleListMessages(createTestArgs(conv.id));
     const body = response as unknown as PaginatedResponse;
 
     expect(body.messages).toHaveLength(5);
@@ -322,7 +322,7 @@ describe("handleListMessages pagination", () => {
     await insertMessages(conv.id, 5);
 
     const args = createPaginatedArgs(conv.id, { limit: "3" });
-    const response = handleListMessages(args, null);
+    const response = handleListMessages(args);
     const body = response as unknown as PaginatedResponse;
 
     // Option A: without beforeTimestamp, all messages are returned regardless of limit
@@ -339,7 +339,7 @@ describe("handleListMessages pagination", () => {
       beforeTimestamp: String(msgs[7].createdAt),
       limit: "3",
     });
-    const response = handleListMessages(args, null);
+    const response = handleListMessages(args);
     const body = response as unknown as PaginatedResponse;
 
     expect(body.messages).toHaveLength(3);
@@ -360,7 +360,7 @@ describe("handleListMessages pagination", () => {
       beforeTimestamp: String(msgs[1].createdAt),
       limit: "10",
     });
-    const response = handleListMessages(args, null);
+    const response = handleListMessages(args);
     const body = response as unknown as PaginatedResponse;
 
     const ids = body.messages.map((m) => m.id);
@@ -378,7 +378,7 @@ describe("handleListMessages pagination", () => {
       beforeTimestamp: String(msgs[4].createdAt + 1),
       limit: "10",
     });
-    const response = handleListMessages(args, null);
+    const response = handleListMessages(args);
     const body = response as unknown as PaginatedResponse;
 
     expect(body.messages).toHaveLength(5);
@@ -394,7 +394,7 @@ describe("handleListMessages pagination", () => {
       beforeTimestamp: String(msgs[4].createdAt + 1),
       limit: "3",
     });
-    const response = handleListMessages(args, null);
+    const response = handleListMessages(args);
     const body = response as unknown as PaginatedResponse;
 
     expect(body.messages).toHaveLength(3);
@@ -405,7 +405,7 @@ describe("handleListMessages pagination", () => {
 
   test("empty / nonexistent conversation → empty messages, no pagination metadata", async () => {
     const args = createPaginatedArgs("nonexistent-conv-id");
-    const response = handleListMessages(args, null);
+    const response = handleListMessages(args);
     const body = response as unknown as PaginatedResponse;
 
     expect(body.messages).toEqual([]);
@@ -418,13 +418,17 @@ describe("handleListMessages pagination", () => {
     const conv = createConversation();
     const args = createPaginatedArgs(conv.id, { limit: "abc" });
 
-    expect(() => handleListMessages(args, null)).toThrow("limit must be a valid number");
+    expect(() => handleListMessages(args)).toThrow(
+      "limit must be a valid number",
+    );
   });
 
   test("invalid beforeTimestamp (NaN) → 400", async () => {
     const conv = createConversation();
     const args = createPaginatedArgs(conv.id, { beforeTimestamp: "abc" });
 
-    expect(() => handleListMessages(args, null)).toThrow("beforeTimestamp must be a valid number");
+    expect(() => handleListMessages(args)).toThrow(
+      "beforeTimestamp must be a valid number",
+    );
   });
 });

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

@@ -0,0 +1,217 @@
+/**
+ * Tests for handleListMessages metadata.hidden filtering.
+ *
+ * Messages persisted with `metadata: { hidden: true }` (e.g. internal
+ * scaffolding like retrospective instructions) must be omitted from the
+ * UI history list while remaining visible to the LLM-side history loader.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    model: "test",
+    provider: "test",
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0 },
+  }),
+}));
+
+import {
+  addMessage,
+  createConversation,
+  getMessages,
+} from "../memory/conversation-crud.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { handleListMessages } from "../runtime/routes/conversation-routes.js";
+
+initializeDb();
+
+function resetTables() {
+  const db = getDb();
+  db.run("DELETE FROM message_attachments");
+  db.run("DELETE FROM attachments");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+}
+
+interface MessagePayload {
+  role: string;
+  content: string;
+}
+
+describe("handleListMessages metadata.hidden filtering", () => {
+  beforeEach(resetTables);
+
+  test("UI serializer omits hidden messages but LLM-side getMessages includes them", async () => {
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "first visible" }]),
+    );
+    await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "internal scaffolding" }]),
+      { hidden: true },
+    );
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "second visible" }]),
+    );
+
+    const response = handleListMessages({
+      queryParams: { conversationId: conv.id },
+    });
+    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(
+      body.messages.some((m) => m.content.includes("internal scaffolding")),
+    ).toBe(false);
+
+    // LLM-side loader must include the hidden row so agent context is intact.
+    const llmRows = getMessages(conv.id);
+    expect(llmRows).toHaveLength(3);
+    expect(llmRows[1].metadata).toContain('"hidden":true');
+  });
+
+  test("messages without metadata or with hidden=false are returned", async () => {
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "no metadata" }]),
+    );
+    await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "hidden false" }]),
+      { hidden: false },
+    );
+
+    const response = handleListMessages({
+      queryParams: { conversationId: conv.id },
+    });
+    const body = response as { messages: MessagePayload[] };
+
+    expect(body.messages).toHaveLength(2);
+  });
+
+  test("pagination skips hidden rows so hasMore and oldest cursor reflect visible rows", async () => {
+    const conv = createConversation();
+    // 4 visible older rows, then a block of 3 hidden rows, then 2 visible newer.
+    // With limit=2 and page=latest we should get the 2 newest visible rows,
+    // hasMore=true (older visible rows exist), and a cursor pointing at the
+    // oldest visible row in the page rather than null.
+    for (let i = 0; i < 4; i++) {
+      await addMessage(
+        conv.id,
+        "user",
+        JSON.stringify([{ type: "text", text: `old visible ${i}` }]),
+      );
+    }
+    for (let i = 0; i < 3; i++) {
+      await addMessage(
+        conv.id,
+        "assistant",
+        JSON.stringify([{ type: "text", text: `hidden ${i}` }]),
+        { hidden: true },
+      );
+    }
+    for (let i = 0; i < 2; i++) {
+      await addMessage(
+        conv.id,
+        "user",
+        JSON.stringify([{ type: "text", text: `new visible ${i}` }]),
+      );
+    }
+
+    const latest = handleListMessages({
+      queryParams: { conversationId: conv.id, page: "latest", limit: "2" },
+    }) as {
+      messages: MessagePayload[];
+      hasMore: boolean;
+      oldestTimestamp: number | null;
+      oldestMessageId: string | null;
+    };
+
+    expect(latest.messages.map((m) => m.content)).toEqual([
+      "new visible 0",
+      "new visible 1",
+    ]);
+    expect(latest.hasMore).toBe(true);
+    expect(latest.oldestTimestamp).not.toBeNull();
+    expect(latest.oldestMessageId).not.toBeNull();
+
+    // Older page request — anchored before the latest page's oldest row —
+    // should skip the hidden block entirely and return the next 2 visible rows.
+    const older = handleListMessages({
+      queryParams: {
+        conversationId: conv.id,
+        beforeTimestamp: String(latest.oldestTimestamp),
+        limit: "2",
+      },
+    }) as {
+      messages: MessagePayload[];
+      hasMore: boolean;
+    };
+
+    expect(older.messages.map((m) => m.content)).toEqual([
+      "old visible 2",
+      "old visible 3",
+    ]);
+    expect(older.hasMore).toBe(true);
+  });
+
+  test("pagination drains DB when every row in a page is hidden", async () => {
+    const conv = createConversation();
+    // 5 hidden rows then 2 visible older rows. With limit=2, the naive
+    // implementation fetches 3 newest (all hidden), filters to 0 visible, and
+    // returns hasMore=true with no cursor. We expect the loop to keep going
+    // and surface the visible rows instead.
+    for (let i = 0; i < 2; i++) {
+      await addMessage(
+        conv.id,
+        "user",
+        JSON.stringify([{ type: "text", text: `old visible ${i}` }]),
+      );
+    }
+    for (let i = 0; i < 5; i++) {
+      await addMessage(
+        conv.id,
+        "assistant",
+        JSON.stringify([{ type: "text", text: `hidden ${i}` }]),
+        { hidden: true },
+      );
+    }
+
+    const latest = handleListMessages({
+      queryParams: { conversationId: conv.id, page: "latest", limit: "2" },
+    }) as {
+      messages: MessagePayload[];
+      hasMore: boolean;
+      oldestTimestamp: number | null;
+    };
+
+    expect(latest.messages.map((m) => m.content)).toEqual([
+      "old visible 0",
+      "old visible 1",
+    ]);
+    expect(latest.hasMore).toBe(false);
+    expect(latest.oldestTimestamp).not.toBeNull();
+  });
+});

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

@@ -32,6 +32,11 @@ mock.module("../config/loader.js", () => ({
   }),
 }));
 
+let mockAssistantName: string | null = null;
+mock.module("../daemon/identity-helpers.js", () => ({
+  getAssistantName: () => mockAssistantName,
+}));
+
 import { createConversation } from "../memory/conversation-crud.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
@@ -89,8 +94,10 @@ interface MessagePayload {
   timestamp: string;
   slackMessage?: {
     channelId: string;
+    channelName?: string;
     channelTs: string;
     threadTs?: string;
+    sender?: { displayName?: string; externalUserId?: string };
     messageLink?: { appUrl?: string; webUrl?: string };
     threadLink?: { appUrl?: string; webUrl?: string };
   };
@@ -104,14 +111,16 @@ interface ListResponse {
 }
 
 function callList(query: Record<string, string>): ListResponse {
-  return handleListMessages(
-    { queryParams: query },
-    null,
-  ) as unknown as ListResponse;
+  return handleListMessages({
+    queryParams: query,
+  }) as unknown as ListResponse;
 }
 
 describe("handleListMessages page=latest", () => {
-  beforeEach(resetTables);
+  beforeEach(() => {
+    resetTables();
+    mockAssistantName = null;
+  });
 
   test("page=latest with no limit returns all messages chronologically", () => {
     const conv = createConversation();
@@ -219,8 +228,11 @@ describe("handleListMessages page=latest", () => {
           slackMeta: writeSlackMetadata({
             source: "slack",
             channelId: "C123ABCDEF",
+            channelName: "engineering",
             channelTs: "1710000000.000200",
             threadTs: "1710000000.000100",
+            displayName: "Alice",
+            actorExternalUserId: "U_ALICE",
             eventKind: "message",
           }),
         }),
@@ -232,13 +244,18 @@ describe("handleListMessages page=latest", () => {
 
     expect(body.messages[0].slackMessage).toEqual({
       channelId: "C123ABCDEF",
+      channelName: "engineering",
       channelTs: "1710000000.000200",
       threadTs: "1710000000.000100",
+      sender: {
+        displayName: "Alice",
+        externalUserId: "U_ALICE",
+      },
       messageLink: {
         appUrl:
           "slack://channel?team=T123&id=C123ABCDEF&message=1710000000.000200",
         webUrl:
-          "https://example.slack.com/archives/C123ABCDEF/p1710000000000200",
+          "https://example.slack.com/archives/C123ABCDEF/p1710000000000200?thread_ts=1710000000.000100&cid=C123ABCDEF",
       },
       threadLink: {
         appUrl:
@@ -249,6 +266,107 @@ describe("handleListMessages page=latest", () => {
     });
   });
 
+  test("top-level Slack messages with matching threadTs use plain permalinks", () => {
+    const conv = createConversation();
+    const db = getDb();
+    db.insert(messages)
+      .values({
+        id: "msg-slack-top-level",
+        conversationId: conv.id,
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "Slack top-level" }]),
+        metadata: JSON.stringify({
+          slackMeta: writeSlackMetadata({
+            source: "slack",
+            channelId: "C123ABCDEF",
+            channelName: "engineering",
+            channelTs: "1710000000.000200",
+            threadTs: "1710000000.000200",
+            displayName: "Alice",
+            actorExternalUserId: "U_ALICE",
+            eventKind: "message",
+          }),
+        }),
+        createdAt: 1,
+      })
+      .run();
+
+    const body = callList({ conversationId: conv.id, page: "latest" });
+
+    expect(body.messages[0].slackMessage).toEqual({
+      channelId: "C123ABCDEF",
+      channelName: "engineering",
+      channelTs: "1710000000.000200",
+      threadTs: "1710000000.000200",
+      sender: {
+        displayName: "Alice",
+        externalUserId: "U_ALICE",
+      },
+      messageLink: {
+        appUrl:
+          "slack://channel?team=T123&id=C123ABCDEF&message=1710000000.000200",
+        webUrl:
+          "https://example.slack.com/archives/C123ABCDEF/p1710000000000200",
+      },
+    });
+  });
+
+  test("assistant Slack messages without stored sender use the assistant name", () => {
+    mockAssistantName = "Nova";
+    const conv = createConversation();
+    const db = getDb();
+    db.insert(messages)
+      .values({
+        id: "msg-slack-assistant",
+        conversationId: conv.id,
+        role: "assistant",
+        content: JSON.stringify([{ type: "text", text: "Slack response" }]),
+        metadata: JSON.stringify({
+          slackMeta: writeSlackMetadata({
+            source: "slack",
+            channelId: "C123ABCDEF",
+            channelTs: "1710000000.000300",
+            eventKind: "message",
+          }),
+        }),
+        createdAt: 1,
+      })
+      .run();
+
+    const body = callList({ conversationId: conv.id, page: "latest" });
+
+    expect(body.messages[0].slackMessage?.sender).toEqual({
+      displayName: "Nova",
+    });
+  });
+
+  test("user Slack messages without stored sender do not use the assistant name", () => {
+    mockAssistantName = "Nova";
+    const conv = createConversation();
+    const db = getDb();
+    db.insert(messages)
+      .values({
+        id: "msg-slack-user",
+        conversationId: conv.id,
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "Slack request" }]),
+        metadata: JSON.stringify({
+          slackMeta: writeSlackMetadata({
+            source: "slack",
+            channelId: "C123ABCDEF",
+            channelTs: "1710000000.000300",
+            eventKind: "message",
+          }),
+        }),
+        createdAt: 1,
+      })
+      .run();
+
+    const body = callList({ conversationId: conv.id, page: "latest" });
+
+    expect(body.messages[0].slackMessage?.sender).toBeUndefined();
+  });
+
   test("page=latest on unresolved conversationKey returns null metadata contract", () => {
     const body = callList({
       conversationKey: "no-such-key",
@@ -274,16 +392,14 @@ describe("handleListMessages page=latest", () => {
     const conv = createConversation();
 
     expect(() =>
-      handleListMessages(
-        { queryParams: { conversationId: conv.id, page: "invalid" } },
-        null,
-      ),
+      handleListMessages({
+        queryParams: { conversationId: conv.id, page: "invalid" },
+      }),
     ).toThrow(BadRequestError);
     expect(() =>
-      handleListMessages(
-        { queryParams: { conversationId: conv.id, page: "invalid" } },
-        null,
-      ),
+      handleListMessages({
+        queryParams: { conversationId: conv.id, page: "invalid" },
+      }),
     ).toThrow("page must be 'latest' when provided");
   });