@vellumai/assistant 0.6.0 → 0.6.1

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

@@ -0,0 +1,300 @@
+/**
+ * Tests for handleListMessages tool_result merging.
+ *
+ * Verifies that tool_result blocks from user messages are merged into the
+ * preceding assistant message so they render with proper tool names instead
+ * of "Unknown" after a conversation reload.
+ */
+
+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 } from "../memory/conversation-crud.js";
+import { getDb, initializeDb } from "../memory/db.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");
+}
+
+function createTestUrl(conversationId: string): URL {
+  return new URL(
+    `http://localhost/v1/messages?conversationId=${conversationId}`,
+  );
+}
+
+interface ToolCallPayload {
+  name: string;
+  input: Record<string, unknown>;
+  result?: string;
+  isError?: boolean;
+}
+
+interface MessagePayload {
+  role: string;
+  content: string;
+  toolCalls?: ToolCallPayload[];
+  textSegments?: string[];
+}
+
+describe("handleListMessages tool_result merging", () => {
+  beforeEach(resetTables);
+
+  test("merges tool_result from user message into preceding assistant", async () => {
+    const conv = createConversation();
+    // User prompt
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "run ls" }]),
+    );
+    // Assistant with tool_use
+    await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([
+        { type: "text", text: "Running command." },
+        { type: "tool_use", id: "tu1", name: "bash", input: { command: "ls" } },
+      ]),
+    );
+    // Tool result (separate user message)
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([
+        { type: "tool_result", tool_use_id: "tu1", content: "file1.txt\nfile2.txt" },
+      ]),
+    );
+
+    const response = handleListMessages(createTestUrl(conv.id), null);
+    const body = (await response.json()) as { messages: MessagePayload[] };
+
+    // Should be 2 messages: user prompt + assistant (tool_result user msg suppressed)
+    expect(body.messages).toHaveLength(2);
+    expect(body.messages[0].role).toBe("user");
+    expect(body.messages[1].role).toBe("assistant");
+
+    // Assistant tool call should have proper name AND result
+    const toolCalls = body.messages[1].toolCalls;
+    expect(toolCalls).toBeDefined();
+    expect(toolCalls).toHaveLength(1);
+    expect(toolCalls![0].name).toBe("bash");
+    expect(toolCalls![0].result).toBe("file1.txt\nfile2.txt");
+  });
+
+  test("merges multiple tool_results into matching tool_uses", async () => {
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "do stuff" }]),
+    );
+    await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([
+        { type: "tool_use", id: "tu1", name: "bash", input: { command: "ls" } },
+        { type: "text", text: "and also" },
+        { type: "tool_use", id: "tu2", name: "file_read", input: { path: "/tmp/a" } },
+      ]),
+    );
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([
+        { type: "tool_result", tool_use_id: "tu1", content: "dir listing" },
+        { type: "tool_result", tool_use_id: "tu2", content: "file contents" },
+      ]),
+    );
+
+    const response = handleListMessages(createTestUrl(conv.id), null);
+    const body = (await response.json()) as { messages: MessagePayload[] };
+
+    expect(body.messages).toHaveLength(2);
+    const toolCalls = body.messages[1].toolCalls!;
+    expect(toolCalls).toHaveLength(2);
+    expect(toolCalls[0].name).toBe("bash");
+    expect(toolCalls[0].result).toBe("dir listing");
+    expect(toolCalls[1].name).toBe("file_read");
+    expect(toolCalls[1].result).toBe("file contents");
+  });
+
+  test("plain user message passes through unchanged", async () => {
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "hello" }]),
+    );
+    await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "hi there" }]),
+    );
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "how are you?" }]),
+    );
+
+    const response = handleListMessages(createTestUrl(conv.id), null);
+    const body = (await response.json()) as { messages: MessagePayload[] };
+
+    expect(body.messages).toHaveLength(3);
+    expect(body.messages[2].role).toBe("user");
+    expect(body.messages[2].content).toBe("how are you?");
+  });
+
+  test("tool_result at start of array (no preceding assistant) is preserved", 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.
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([
+        { type: "tool_result", tool_use_id: "tu_orphan", content: "stale result" },
+      ]),
+    );
+    await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "response" }]),
+    );
+
+    const response = handleListMessages(createTestUrl(conv.id), null);
+    const body = (await response.json()) as { messages: MessagePayload[] };
+
+    // Orphan tool_result is preserved (not suppressed) to avoid data loss
+    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[1].role).toBe("assistant");
+    expect(body.messages[1].content).toBe("response");
+  });
+
+  test("multi-turn: each tool_result merges into correct assistant", async () => {
+    const conv = createConversation();
+    // Turn 1
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "list files" }]),
+    );
+    await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([
+        { type: "tool_use", id: "tu1", name: "bash", input: { command: "ls" } },
+      ]),
+    );
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([
+        { type: "tool_result", tool_use_id: "tu1", content: "files" },
+      ]),
+    );
+    // Turn 2
+    await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([
+        { type: "text", text: "Now reading:" },
+        { type: "tool_use", id: "tu2", name: "file_read", input: { path: "/x" } },
+      ]),
+    );
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([
+        { type: "tool_result", tool_use_id: "tu2", content: "file data" },
+      ]),
+    );
+    // Turn 3: real user message
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "thanks" }]),
+    );
+
+    const response = handleListMessages(createTestUrl(conv.id), null);
+    const body = (await response.json()) as { messages: MessagePayload[] };
+
+    // user("list files"), assistant(bash), assistant(file_read), user("thanks")
+    expect(body.messages).toHaveLength(4);
+    expect(body.messages[0].role).toBe("user");
+    expect(body.messages[1].role).toBe("assistant");
+    expect(body.messages[1].toolCalls![0].name).toBe("bash");
+    expect(body.messages[1].toolCalls![0].result).toBe("files");
+    expect(body.messages[2].role).toBe("assistant");
+    expect(body.messages[2].toolCalls![0].name).toBe("file_read");
+    expect(body.messages[2].toolCalls![0].result).toBe("file data");
+    expect(body.messages[3].role).toBe("user");
+    expect(body.messages[3].content).toBe("thanks");
+  });
+
+  test("tool_result with is_error propagates error status", async () => {
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "do it" }]),
+    );
+    await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([
+        { type: "tool_use", id: "tu1", name: "bash", input: { command: "fail" } },
+      ]),
+    );
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([
+        {
+          type: "tool_result",
+          tool_use_id: "tu1",
+          content: "command not found",
+          is_error: true,
+        },
+      ]),
+    );
+
+    const response = handleListMessages(createTestUrl(conv.id), null);
+    const body = (await response.json()) as { messages: MessagePayload[] };
+
+    expect(body.messages).toHaveLength(2);
+    const tc = body.messages[1].toolCalls![0];
+    expect(tc.name).toBe("bash");
+    expect(tc.result).toBe("command not found");
+    expect(tc.isError).toBe(true);
+  });
+});

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

@@ -278,12 +278,6 @@ describe("normalizeLlmContextPayloads", () => {
         role: "user",
         text: "Find the latest changelog.",
       },
-      {
-        kind: "message",
-        label: "Assistant message 2",
-        role: "assistant",
-        text: "Checking sources.",
-      },
       {
         kind: "reasoning",
         label: "Assistant message 2 reasoning",
@@ -296,6 +290,12 @@ describe("normalizeLlmContextPayloads", () => {
         role: "assistant",
         text: "[redacted thinking]",
       },
+      {
+        kind: "message",
+        label: "Assistant message 2",
+        role: "assistant",
+        text: "Checking sources.",
+      },
       {
         kind: "tool_use",
         label: "Assistant message 2 tool use",
@@ -331,12 +331,6 @@ describe("normalizeLlmContextPayloads", () => {
       },
     ]);
     expect(normalized.responseSections).toEqual([
-      {
-        kind: "message",
-        label: "Assistant response",
-        role: "assistant",
-        text: "I found the changelog.",
-      },
       {
         kind: "reasoning",
         label: "Assistant response reasoning",
@@ -349,6 +343,12 @@ describe("normalizeLlmContextPayloads", () => {
         role: "assistant",
         text: "[redacted thinking]",
       },
+      {
+        kind: "message",
+        label: "Assistant response",
+        role: "assistant",
+        text: "I found the changelog.",
+      },
       {
         kind: "tool_use",
         label: "Assistant response tool use",
@@ -412,12 +412,6 @@ describe("normalizeLlmContextPayloads", () => {
       toolCallNames: undefined,
     });
     expect(normalized.responseSections).toEqual([
-      {
-        kind: "message",
-        label: "Assistant response",
-        role: "assistant",
-        text: "The answer is 42.",
-      },
       {
         kind: "reasoning",
         label: "Assistant response reasoning",
@@ -430,6 +424,12 @@ describe("normalizeLlmContextPayloads", () => {
         role: "assistant",
         text: "[redacted thinking]",
       },
+      {
+        kind: "message",
+        label: "Assistant response",
+        role: "assistant",
+        text: "The answer is 42.",
+      },
     ]);
   });
 

package/src/__tests__/llm-context-route-provider.test.ts

@@ -33,6 +33,27 @@ function dispatchLlmContext(messageId: string): Promise<Response> | Response {
   });
 }
 
+function dispatchLogPayload(logId: string): Promise<Response> | Response {
+  const url = new URL(
+    `http://localhost/v1/llm-request-logs/${logId}/payload`,
+  );
+  const route = routes.find(
+    (r) =>
+      r.method === "GET" && r.endpoint === "llm-request-logs/:id/payload",
+  );
+  if (!route) {
+    throw new Error("No llm-request-logs payload route found");
+  }
+
+  return route.handler({
+    req: new Request(url.toString(), { method: "GET" }),
+    url,
+    server: null as never,
+    authContext: {} as never,
+    params: { id: logId },
+  });
+}
+
 function clearRequestLogs(): void {
   getDb().delete(llmRequestLogs).run();
 }
@@ -189,4 +210,84 @@ describe("GET /v1/messages/:id/llm-context provider preference", () => {
     expect(body.logs).toHaveLength(1);
     expect(body.logs[0]?.summary).toEqual({ provider: "ollama" });
   });
+
+  test("returns null payloads to keep the initial response lightweight", async () => {
+    seedRequestLog({
+      id: "log-null-payload",
+      messageId: "msg-null-payload",
+      provider: "openrouter",
+      requestPayload: openAiRequestPayload,
+      responsePayload: openAiResponsePayload,
+    });
+
+    const response = await dispatchLlmContext("msg-null-payload");
+    expect(response.status).toBe(200);
+
+    const body = (await response.json()) as {
+      logs: Array<{
+        requestPayload: unknown;
+        responsePayload: unknown;
+      }>;
+    };
+
+    expect(body.logs).toHaveLength(1);
+    expect(body.logs[0]?.requestPayload).toBeNull();
+    expect(body.logs[0]?.responsePayload).toBeNull();
+  });
+});
+
+describe("GET /v1/llm-request-logs/:id/payload", () => {
+  test("returns parsed payloads for a valid log", async () => {
+    const reqPayload = JSON.stringify({ model: "gpt-4.1", messages: [] });
+    const resPayload = JSON.stringify({
+      choices: [{ message: { content: "hi" } }],
+    });
+    seedRequestLog({
+      id: "log-payload-ok",
+      messageId: "msg-payload-ok",
+      provider: "openai",
+      requestPayload: reqPayload,
+      responsePayload: resPayload,
+    });
+
+    const response = await dispatchLogPayload("log-payload-ok");
+    expect(response.status).toBe(200);
+
+    const body = (await response.json()) as {
+      id: string;
+      requestPayload: unknown;
+      responsePayload: unknown;
+    };
+
+    expect(body.id).toBe("log-payload-ok");
+    expect(body.requestPayload).toEqual(JSON.parse(reqPayload));
+    expect(body.responsePayload).toEqual(JSON.parse(resPayload));
+  });
+
+  test("returns 404 for a nonexistent log", async () => {
+    const response = await dispatchLogPayload("does-not-exist");
+    expect(response.status).toBe(404);
+  });
+
+  test("falls back to string values for non-JSON payloads", async () => {
+    seedRequestLog({
+      id: "log-raw-strings",
+      messageId: "msg-raw-strings",
+      provider: null,
+      requestPayload: "raw-request-text",
+      responsePayload: "raw-response-text",
+    });
+
+    const response = await dispatchLogPayload("log-raw-strings");
+    expect(response.status).toBe(200);
+
+    const body = (await response.json()) as {
+      id: string;
+      requestPayload: unknown;
+      responsePayload: unknown;
+    };
+
+    expect(body.requestPayload).toBe("raw-request-text");
+    expect(body.responsePayload).toBe("raw-response-text");
+  });
 });

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

@@ -301,6 +301,168 @@ describe("getRequestLogsByMessageId — turn-aware query", () => {
     expect(logs[2]?.id).toBe("log-surviving");
   });
 
+  test("recovers unlinked logs (messageId IS NULL) within the turn time range", () => {
+    // Simulate the race: logs recorded with NULL messageId, backfill hasn't run yet.
+    const T = 1_700_000_000_000;
+    const db = getDb();
+    const conv = createConversation("unlinked-test");
+
+    db.run(
+      sql`INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES ('u1-ul', ${conv.id}, 'user', '"Do the task"', ${T})`,
+    );
+    db.run(
+      sql`INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES ('a1-ul', ${conv.id}, 'assistant', '"Done!"', ${T + 30000})`,
+    );
+
+    // Unlinked log: messageId is NULL (backfill hasn't run yet)
+    db.insert(llmRequestLogs)
+      .values({
+        id: "log-unlinked-1",
+        conversationId: conv.id,
+        messageId: null,
+        provider: "anthropic",
+        requestPayload: '{"step":1}',
+        responsePayload: '{"tool":"bash"}',
+        createdAt: T + 5000,
+      })
+      .run();
+
+    // Linked log: already backfilled to the assistant message
+    db.insert(llmRequestLogs)
+      .values({
+        id: "log-linked-1",
+        conversationId: conv.id,
+        messageId: "a1-ul",
+        provider: "anthropic",
+        requestPayload: '{"step":2}',
+        responsePayload: '{"text":"Done!"}',
+        createdAt: T + 29_000,
+      })
+      .run();
+
+    const logs = getRequestLogsByMessageId("a1-ul");
+    expect(logs).toHaveLength(2);
+    expect(logs[0]?.id).toBe("log-unlinked-1");
+    expect(logs[1]?.id).toBe("log-linked-1");
+
+    // Verify opportunistic backfill ran: the unlinked log should now have a messageId
+    const backfilledLog = db
+      .select({ messageId: llmRequestLogs.messageId })
+      .from(llmRequestLogs)
+      .where(sql`${llmRequestLogs.id} = 'log-unlinked-1'`)
+      .get();
+    expect(backfilledLog?.messageId).toBe("a1-ul");
+  });
+
+  test("unlinked logs from different conversations don't bleed", () => {
+    const T = 1_700_000_000_000;
+    const db = getDb();
+    const convA = createConversation("conv-a");
+    const convB = createConversation("conv-b");
+
+    // Conversation A: user + assistant + unlinked log
+    db.run(
+      sql`INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES ('u1-a', ${convA.id}, 'user', '"Hello A"', ${T})`,
+    );
+    db.run(
+      sql`INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES ('a1-a', ${convA.id}, 'assistant', '"Hi A"', ${T + 10000})`,
+    );
+    db.insert(llmRequestLogs)
+      .values({
+        id: "log-conv-a",
+        conversationId: convA.id,
+        messageId: null,
+        provider: "anthropic",
+        requestPayload: '{"conv":"A"}',
+        responsePayload: '{"r":"A"}',
+        createdAt: T + 5000,
+      })
+      .run();
+
+    // Conversation B: user + assistant + unlinked log (overlapping timestamps)
+    db.run(
+      sql`INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES ('u1-b', ${convB.id}, 'user', '"Hello B"', ${T})`,
+    );
+    db.run(
+      sql`INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES ('a1-b', ${convB.id}, 'assistant', '"Hi B"', ${T + 10000})`,
+    );
+    db.insert(llmRequestLogs)
+      .values({
+        id: "log-conv-b",
+        conversationId: convB.id,
+        messageId: null,
+        provider: "anthropic",
+        requestPayload: '{"conv":"B"}',
+        responsePayload: '{"r":"B"}',
+        createdAt: T + 5000,
+      })
+      .run();
+
+    // Query from conv A → should only find conv A's log
+    const logsA = getRequestLogsByMessageId("a1-a");
+    expect(logsA).toHaveLength(1);
+    expect(logsA[0]?.id).toBe("log-conv-a");
+
+    // Query from conv B → should only find conv B's log
+    const logsB = getRequestLogsByMessageId("a1-b");
+    expect(logsB).toHaveLength(1);
+    expect(logsB[0]?.id).toBe("log-conv-b");
+  });
+
+  test("unlinked logs from different turns don't bleed", () => {
+    const T = 1_700_000_000_000;
+    const db = getDb();
+    const conv = createConversation("two-turn-unlinked");
+
+    // Turn 1: user → assistant (with linked log)
+    db.run(
+      sql`INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES ('u1-t', ${conv.id}, 'user', '"Turn 1"', ${T})`,
+    );
+    db.run(
+      sql`INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES ('a1-t', ${conv.id}, 'assistant', '"Answer 1"', ${T + 10000})`,
+    );
+    db.insert(llmRequestLogs)
+      .values({
+        id: "log-turn1-unlinked",
+        conversationId: conv.id,
+        messageId: null,
+        provider: "anthropic",
+        requestPayload: '{"turn":1}',
+        responsePayload: '{"r":1}',
+        createdAt: T + 5000,
+      })
+      .run();
+
+    // Turn 2: user → assistant (with unlinked log)
+    db.run(
+      sql`INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES ('u2-t', ${conv.id}, 'user', '"Turn 2"', ${T + 60000})`,
+    );
+    db.run(
+      sql`INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES ('a2-t', ${conv.id}, 'assistant', '"Answer 2"', ${T + 70000})`,
+    );
+    db.insert(llmRequestLogs)
+      .values({
+        id: "log-turn2-unlinked",
+        conversationId: conv.id,
+        messageId: null,
+        provider: "anthropic",
+        requestPayload: '{"turn":2}',
+        responsePayload: '{"r":2}',
+        createdAt: T + 65000,
+      })
+      .run();
+
+    // Query turn 2 → should only find turn 2's unlinked log
+    const turn2Logs = getRequestLogsByMessageId("a2-t");
+    expect(turn2Logs).toHaveLength(1);
+    expect(turn2Logs[0]?.id).toBe("log-turn2-unlinked");
+
+    // Query turn 1 → should only find turn 1's unlinked log
+    const turn1Logs = getRequestLogsByMessageId("a1-t");
+    expect(turn1Logs).toHaveLength(1);
+    expect(turn1Logs[0]?.id).toBe("log-turn1-unlinked");
+  });
+
   test("relinkLlmRequestLogs moves logs from deleted messages to consolidated message", async () => {
     const conv = createConversation("relink-test");