@vellumai/assistant 0.6.0 → 0.6.2

package/src/__tests__/jobs-store-qdrant-breaker.test.ts

@@ -37,15 +37,15 @@ describe("claimMemoryJobs with Qdrant circuit breaker", () => {
 
   test("claims embed jobs when circuit breaker is closed (healthy)", () => {
     enqueueMemoryJob("embed_segment", { segmentId: "seg-1" });
-    enqueueMemoryJob("embed_item", { itemId: "item-1" });
-    enqueueMemoryJob("extract_items", { conversationId: "conv-1" });
+    enqueueMemoryJob("embed_graph_node", { nodeId: "node-1" });
+    enqueueMemoryJob("graph_extract", { conversationId: "conv-1" });
 
     const claimed = claimMemoryJobs(10);
     const types = claimed.map((j) => j.type);
 
     expect(types).toContain("embed_segment");
-    expect(types).toContain("embed_item");
-    expect(types).toContain("extract_items");
+    expect(types).toContain("embed_graph_node");
+    expect(types).toContain("graph_extract");
     expect(claimed).toHaveLength(3);
   });
 
@@ -62,9 +62,9 @@ describe("claimMemoryJobs with Qdrant circuit breaker", () => {
     }
 
     enqueueMemoryJob("embed_segment", { segmentId: "seg-1" });
-    enqueueMemoryJob("embed_item", { itemId: "item-1" });
+    enqueueMemoryJob("embed_graph_node", { nodeId: "node-1" });
     enqueueMemoryJob("embed_summary", { summaryId: "sum-1" });
-    enqueueMemoryJob("extract_items", { conversationId: "conv-1" });
+    enqueueMemoryJob("graph_extract", { conversationId: "conv-1" });
     enqueueMemoryJob("build_conversation_summary", {
       conversationId: "conv-1",
     });
@@ -73,10 +73,10 @@ describe("claimMemoryJobs with Qdrant circuit breaker", () => {
     const types = claimed.map((j) => j.type);
 
     // Only non-embed jobs should be claimed
-    expect(types).toContain("extract_items");
+    expect(types).toContain("graph_extract");
     expect(types).toContain("build_conversation_summary");
     expect(types).not.toContain("embed_segment");
-    expect(types).not.toContain("embed_item");
+    expect(types).not.toContain("embed_graph_node");
     expect(types).not.toContain("embed_summary");
     expect(claimed).toHaveLength(2);
   });
@@ -95,7 +95,7 @@ describe("claimMemoryJobs with Qdrant circuit breaker", () => {
 
     // Verify embed jobs are skipped while open
     enqueueMemoryJob("embed_segment", { segmentId: "seg-1" });
-    enqueueMemoryJob("extract_items", { conversationId: "conv-1" });
+    enqueueMemoryJob("graph_extract", { conversationId: "conv-1" });
 
     const claimedWhileOpen = claimMemoryJobs(10);
     expect(claimedWhileOpen.map((j) => j.type)).not.toContain("embed_segment");
@@ -104,21 +104,22 @@ describe("claimMemoryJobs with Qdrant circuit breaker", () => {
     _resetQdrantBreaker();
 
     // Re-enqueue an embed job (the previous one is now "running")
-    enqueueMemoryJob("embed_item", { itemId: "item-2" });
+    enqueueMemoryJob("embed_graph_node", { nodeId: "node-2" });
 
     const claimedAfterClose = claimMemoryJobs(10);
     const types = claimedAfterClose.map((j) => j.type);
 
-    expect(types).toContain("embed_item");
+    expect(types).toContain("embed_graph_node");
   });
 
   test("all embed job types are skipped when breaker is open", async () => {
     const embedTypes: MemoryJobType[] = [
       "embed_segment",
-      "embed_item",
       "embed_summary",
       "embed_media",
       "embed_attachment",
+      "embed_graph_node",
+      "graph_trigger_embed",
     ];
 
     // Trip the circuit breaker
@@ -137,13 +138,13 @@ describe("claimMemoryJobs with Qdrant circuit breaker", () => {
       enqueueMemoryJob(type, { id: `test-${type}` });
     }
     // Also enqueue a non-embed job
-    enqueueMemoryJob("extract_entities", { conversationId: "conv-1" });
+    enqueueMemoryJob("graph_consolidate", { conversationId: "conv-1" });
 
     const claimed = claimMemoryJobs(20);
     const types = claimed.map((j) => j.type);
 
     // Only the non-embed job should be claimed
     expect(claimed).toHaveLength(1);
-    expect(types).toEqual(["extract_entities"]);
+    expect(types).toEqual(["graph_consolidate"]);
   });
 });

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