@vellumai/assistant 0.8.3 → 0.8.4

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");
   });
 

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

@@ -91,7 +91,7 @@ describe("handleListMessages tool_result merging", () => {
       ]),
     );
 
-    const response = handleListMessages(createTestArgs(conv.id), null);
+    const response = handleListMessages(createTestArgs(conv.id));
     const body = response as { messages: MessagePayload[] };
 
     // Should be 2 messages: user prompt + assistant (tool_result user msg suppressed)
@@ -137,7 +137,7 @@ describe("handleListMessages tool_result merging", () => {
       ]),
     );
 
-    const response = handleListMessages(createTestArgs(conv.id), null);
+    const response = handleListMessages(createTestArgs(conv.id));
     const body = response as { messages: MessagePayload[] };
 
     expect(body.messages).toHaveLength(2);
@@ -167,7 +167,7 @@ describe("handleListMessages tool_result merging", () => {
       JSON.stringify([{ type: "text", text: "how are you?" }]),
     );
 
-    const response = handleListMessages(createTestArgs(conv.id), null);
+    const response = handleListMessages(createTestArgs(conv.id));
     const body = response as { messages: MessagePayload[] };
 
     expect(body.messages).toHaveLength(3);
@@ -175,11 +175,15 @@ describe("handleListMessages tool_result merging", () => {
     expect(body.messages[2].content).toBe("how are you?");
   });
 
-  test("tool_result at start of array (no preceding assistant) is preserved", async () => {
+  test("tool_result at start of array (no preceding assistant) is dropped", async () => {
     const conv = createConversation();
-    // Orphan tool_result with no preceding assistant (pagination boundary).
-    // The preceding assistant tool_use lives in the previous page — dropping
-    // the result would be unrecoverable, so it is kept as-is.
+    // Orphan tool_result with no preceding assistant. Without the parent
+    // tool_use we can't tell the user what tool ran, so the result is
+    // meaningless — renderHistoryContent drops it rather than synthesizing
+    // a phantom "unknown" tool call. See shared.ts comment.
+    // The user message itself is preserved at the pagination boundary
+    // (mergeToolResultsIntoAssistantMessages keeps it to avoid data loss
+    // in case the matching tool_use lives on the previous page).
     await addMessage(
       conv.id,
       "user",
@@ -197,17 +201,14 @@ describe("handleListMessages tool_result merging", () => {
       JSON.stringify([{ type: "text", text: "response" }]),
     );
 
-    const response = handleListMessages(createTestArgs(conv.id), null);
+    const response = handleListMessages(createTestArgs(conv.id));
     const body = response as { messages: MessagePayload[] };
 
-    // Orphan tool_result is preserved (not suppressed) to avoid data loss
+    // Both messages exist — user message preserved at pagination boundary,
+    // but the orphan tool_result is dropped (no phantom toolCalls)
     expect(body.messages).toHaveLength(2);
     expect(body.messages[0].role).toBe("user");
-    // The preserved message must retain the actual tool_result payload
-    const orphanToolCalls = body.messages[0].toolCalls;
-    expect(orphanToolCalls).toBeDefined();
-    expect(orphanToolCalls).toHaveLength(1);
-    expect(orphanToolCalls![0].result).toBe("stale result");
+    expect(body.messages[0].toolCalls).toBeUndefined();
     expect(body.messages[1].role).toBe("assistant");
     expect(body.messages[1].content).toBe("response");
   });
@@ -262,7 +263,7 @@ describe("handleListMessages tool_result merging", () => {
       JSON.stringify([{ type: "text", text: "thanks" }]),
     );
 
-    const response = handleListMessages(createTestArgs(conv.id), null);
+    const response = handleListMessages(createTestArgs(conv.id));
     const body = response as { messages: MessagePayload[] };
 
     // Consecutive assistant messages are merged at query time so the client
@@ -312,7 +313,7 @@ describe("handleListMessages tool_result merging", () => {
       ]),
     );
 
-    const response = handleListMessages(createTestArgs(conv.id), null);
+    const response = handleListMessages(createTestArgs(conv.id));
     const body = response as { messages: MessagePayload[] };
 
     expect(body.messages).toHaveLength(2);

package/src/__tests__/llm-context-normalization.test.ts

@@ -1152,7 +1152,6 @@ describe("normalizeLlmContextPayloads", () => {
         reasoning: { effort: "high" },
         max_output_tokens: 64000,
         stream: true,
-        store: false,
       },
       responsePayload: {
         id: "resp_abc123",
@@ -1245,7 +1244,6 @@ describe("normalizeLlmContextPayloads", () => {
           reasoning: { effort: "high" },
           max_output_tokens: 64000,
           stream: true,
-          store: false,
         },
         language: "json",
       },

package/src/__tests__/llm-resolver.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, test } from "bun:test";
 
 import { z } from "zod";
 
-import { resolveCallSiteConfig } from "../config/llm-resolver.js";
+import { resolveCallSiteConfig, resolveDefaultProfileKey } from "../config/llm-resolver.js";
 import { type LLMCallSite, LLMSchema } from "../config/schemas/llm.js";
 
 const fullDefault = {
@@ -790,3 +790,87 @@ describe("resolveCallSiteConfig", () => {
     expect(resolved.provider_connection).toBe("anthropic-managed");
   });
 });
+
+describe("resolveDefaultProfileKey", () => {
+  test("mainAgent returns activeProfile when set and enabled", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        balanced: { provider: "anthropic", model: "claude-sonnet-4-7" },
+        gemini: { provider: "gemini", model: "gemini-2.5-pro" },
+      },
+      activeProfile: "gemini",
+    });
+    expect(resolveDefaultProfileKey("mainAgent", llm)).toBe("gemini");
+  });
+
+  test("mainAgent falls back to catalog default when activeProfile is unset", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        balanced: { provider: "anthropic", model: "claude-sonnet-4-7" },
+      },
+    });
+    // mainAgent's CALL_SITE_DEFAULTS profile is `balanced`.
+    expect(resolveDefaultProfileKey("mainAgent", llm)).toBe("balanced");
+  });
+
+  test("mainAgent falls back to catalog default when activeProfile points to a missing profile", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        balanced: { provider: "anthropic", model: "claude-sonnet-4-7" },
+      },
+    });
+    // `LLMSchema.superRefine` rejects unknown `activeProfile` references at
+    // config-load time, so this branch is unreachable for a parsed config.
+    // Mutate after parse to exercise the resolver's defensive fall-through.
+    const mutated = { ...llm, activeProfile: "does-not-exist" };
+    expect(resolveDefaultProfileKey("mainAgent", mutated)).toBe("balanced");
+  });
+
+  test("mainAgent falls back to catalog default when activeProfile is disabled", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        balanced: { provider: "anthropic", model: "claude-sonnet-4-7" },
+        gemini: {
+          provider: "gemini",
+          model: "gemini-2.5-pro",
+          status: "disabled",
+        },
+      },
+      activeProfile: "gemini",
+    });
+    expect(resolveDefaultProfileKey("mainAgent", llm)).toBe("balanced");
+  });
+
+  test("non-mainAgent ignores activeProfile and returns catalog default", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        balanced: { provider: "anthropic", model: "claude-sonnet-4-7" },
+        "cost-optimized": { provider: "openai", model: "gpt-5-mini" },
+        gemini: { provider: "gemini", model: "gemini-2.5-pro" },
+      },
+      activeProfile: "gemini",
+    });
+    // filingAgent's CALL_SITE_DEFAULTS profile is `cost-optimized` — not gemini.
+    expect(resolveDefaultProfileKey("filingAgent", llm)).toBe("cost-optimized");
+  });
+
+  test("non-mainAgent falls back to custom-* when catalog profile is missing", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        "custom-cost-optimized": {
+          provider: "openai",
+          model: "gpt-5-mini",
+        },
+      },
+    });
+    expect(resolveDefaultProfileKey("filingAgent", llm)).toBe(
+      "custom-cost-optimized",
+    );
+  });
+});