@vellumai/assistant 0.5.0 → 0.5.2

package/src/__tests__/history-repair.test.ts

@@ -491,12 +491,17 @@ describe("repairHistory", () => {
     expect(assistantMsg.content[1]).toMatchObject({
       type: "web_search_tool_result",
       tool_use_id: "stu_1",
-      content: { type: "web_search_tool_result_error", error_code: "unavailable" },
+      content: {
+        type: "web_search_tool_result_error",
+        error_code: "unavailable",
+      },
     });
 
     // User message has no web_search_tool_result
     const userMsg = repaired[2];
-    expect(userMsg.content.every((b) => b.type !== "web_search_tool_result")).toBe(true);
+    expect(
+      userMsg.content.every((b) => b.type !== "web_search_tool_result"),
+    ).toBe(true);
   });
 
   test("migrates legacy web_search_tool_result from user message to assistant message", () => {
@@ -527,7 +532,9 @@ describe("repairHistory", () => {
           {
             type: "web_search_tool_result",
             tool_use_id: "srvtoolu_abc",
-            content: [{ type: "web_search_result", url: "https://example.com" }],
+            content: [
+              { type: "web_search_result", url: "https://example.com" },
+            ],
           },
           { type: "tool_result", tool_use_id: "tu_1", content: "files" },
         ],
@@ -545,8 +552,12 @@ describe("repairHistory", () => {
 
     // The assistant message now has the server pair + client tool_use
     const assistantMsg = repaired[1];
-    const serverToolUse = assistantMsg.content.find((b) => b.type === "server_tool_use");
-    const webSearchResult = assistantMsg.content.find((b) => b.type === "web_search_tool_result");
+    const serverToolUse = assistantMsg.content.find(
+      (b) => b.type === "server_tool_use",
+    );
+    const webSearchResult = assistantMsg.content.find(
+      (b) => b.type === "web_search_tool_result",
+    );
     expect(serverToolUse).toBeDefined();
     expect(webSearchResult).toBeDefined();
 
@@ -554,7 +565,9 @@ describe("repairHistory", () => {
     const userMsg = repaired[2];
     expect(stats.orphanToolResultsDowngraded).toBe(1);
     expect(userMsg.content.some((b) => b.type === "tool_result")).toBe(true);
-    expect(userMsg.content.every((b) => b.type !== "web_search_tool_result")).toBe(true);
+    expect(
+      userMsg.content.every((b) => b.type !== "web_search_tool_result"),
+    ).toBe(true);
   });
 
   test("trailing server_tool_use gets synthetic result in same assistant message", () => {
@@ -584,10 +597,84 @@ describe("repairHistory", () => {
     expect(repaired[1].content[1]).toMatchObject({
       type: "web_search_tool_result",
       tool_use_id: "stu_1",
-      content: { type: "web_search_tool_result_error", error_code: "unavailable" },
+      content: {
+        type: "web_search_tool_result_error",
+        error_code: "unavailable",
+      },
     });
   });
 
+  test("synthetic web_search_tool_result is placed immediately after its server_tool_use, not at end", () => {
+    // Regression: synthetic results appended to the end of the content array
+    // get separated from their server_tool_use by ensureToolPairing's split
+    // at tool_use boundaries, causing the API to reject with "web_search
+    // tool use without a corresponding web_search_tool_result block".
+    const messages: Message[] = [
+      { role: "user", content: [{ type: "text", text: "Search and act" }] },
+      {
+        role: "assistant",
+        content: [
+          { type: "text", text: "Let me search" },
+          {
+            type: "server_tool_use",
+            id: "stu_1",
+            name: "web_search",
+            input: { query: "openai" },
+          },
+          {
+            type: "server_tool_use",
+            id: "stu_2",
+            name: "web_search",
+            input: { query: "anthropic" },
+          },
+          { type: "text", text: "Based on my research" },
+          {
+            type: "tool_use",
+            id: "tu_1",
+            name: "skill_load",
+            input: { skill: "app-builder" },
+          },
+        ],
+      },
+      {
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: "tu_1",
+            content: "Skill loaded",
+          },
+        ],
+      },
+    ];
+
+    const { messages: repaired, stats } = repairHistory(messages);
+
+    expect(stats.missingToolResultsInserted).toBe(2);
+
+    const assistantMsg = repaired[1];
+    // Synthetic results must appear immediately after their server_tool_use,
+    // NOT after the tool_use block at the end
+    const blockTypes = assistantMsg.content.map((b) => b.type);
+    expect(blockTypes).toEqual([
+      "text",
+      "server_tool_use",
+      "web_search_tool_result", // right after stu_1
+      "server_tool_use",
+      "web_search_tool_result", // right after stu_2
+      "text",
+      "tool_use",
+    ]);
+
+    // Verify the pairings are correct
+    expect(
+      (assistantMsg.content[2] as { tool_use_id: string }).tool_use_id,
+    ).toBe("stu_1");
+    expect(
+      (assistantMsg.content[4] as { tool_use_id: string }).tool_use_id,
+    ).toBe("stu_2");
+  });
+
   test("downgrades type-mismatched tool_result for server_tool_use", () => {
     // A tool_result in the user message for a server_tool_use ID is orphaned —
     // server-side results belong in the assistant message
@@ -625,11 +712,15 @@ describe("repairHistory", () => {
 
     // Assistant message has the server pair
     const assistantMsg = repaired[1];
-    expect(assistantMsg.content.some((b) => b.type === "web_search_tool_result")).toBe(true);
+    expect(
+      assistantMsg.content.some((b) => b.type === "web_search_tool_result"),
+    ).toBe(true);
 
     // User message has no web_search_tool_result — the tool_result was downgraded to text
     const userMsg = repaired[2];
-    expect(userMsg.content.every((b) => b.type !== "web_search_tool_result")).toBe(true);
+    expect(
+      userMsg.content.every((b) => b.type !== "web_search_tool_result"),
+    ).toBe(true);
     expect(userMsg.content.every((b) => b.type !== "tool_result")).toBe(true);
   });
 
@@ -649,7 +740,9 @@ describe("repairHistory", () => {
           {
             type: "web_search_tool_result",
             tool_use_id: "tu_1",
-            content: [{ type: "web_search_result", url: "https://example.com" }],
+            content: [
+              { type: "web_search_result", url: "https://example.com" },
+            ],
           },
         ],
       },

package/src/__tests__/http-conversation-lineage.test.ts

@@ -0,0 +1,251 @@
+import { mkdtempSync, realpathSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+
+const testDir = realpathSync(
+  mkdtempSync(join(tmpdir(), "http-conversation-lineage-test-")),
+);
+
+mock.module("../util/platform.js", () => ({
+  getRootDir: () => join(testDir, ".vellum"),
+  getDataDir: () => join(testDir, ".vellum", "workspace", "data"),
+  getWorkspaceDir: () => join(testDir, ".vellum", "workspace"),
+  getConversationsDir: () =>
+    join(testDir, ".vellum", "workspace", "conversations"),
+  isMacOS: () => process.platform === "darwin",
+  isLinux: () => process.platform === "linux",
+  isWindows: () => process.platform === "win32",
+  getPidPath: () => join(testDir, "test.pid"),
+  getDbPath: () => join(testDir, "test.db"),
+  getLogPath: () => join(testDir, "test.log"),
+  ensureDataDir: () => {},
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/env.js", () => ({
+  isHttpAuthDisabled: () => true,
+  hasUngatedHttpAuthDisabled: () => false,
+  getGatewayInternalBaseUrl: () => "http://127.0.0.1:7830",
+  getGatewayPort: () => 7830,
+  getRuntimeHttpPort: () => 7821,
+  getRuntimeHttpHost: () => "127.0.0.1",
+  getRuntimeGatewayOriginSecret: () => undefined,
+  getIngressPublicBaseUrl: () => undefined,
+  setIngressPublicBaseUrl: () => {},
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    model: "test",
+    provider: "test",
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0 },
+    secretDetection: { enabled: false },
+  }),
+}));
+
+import {
+  batchSetDisplayOrders,
+  createConversation,
+  updateConversationTitle,
+} from "../memory/conversation-crud.js";
+import { getDb, initializeDb, rawRun, resetDb } from "../memory/db.js";
+import { RuntimeHttpServer } from "../runtime/http-server.js";
+
+initializeDb();
+
+type ConversationSummary = {
+  id: string;
+  title: string;
+  displayOrder?: number | null;
+  isPinned?: boolean;
+  forkParent?: {
+    conversationId: string;
+    messageId: string;
+    title: string;
+  };
+};
+
+describe("conversation lineage in HTTP reads", () => {
+  let server: RuntimeHttpServer | null = null;
+
+  beforeEach(async () => {
+    await server?.stop();
+    server = null;
+    clearTables();
+  });
+
+  afterAll(async () => {
+    await server?.stop();
+    resetDb();
+    try {
+      rmSync(testDir, { recursive: true, force: true });
+    } catch {
+      /* best effort */
+    }
+  });
+
+  test("GET /v1/conversations returns forkParent for surviving parents", async () => {
+    const { child, parent } = seedForkedConversation();
+    await startServer();
+
+    const response = await fetch(url("/conversations"));
+    expect(response.status).toBe(200);
+
+    const body = (await response.json()) as {
+      conversations: ConversationSummary[];
+      hasMore: boolean;
+    };
+    const listedChild = body.conversations.find((item) => item.id === child.id);
+
+    expect(listedChild).toMatchObject({
+      id: child.id,
+      title: child.title ?? "Untitled",
+      forkParent: {
+        conversationId: parent.id,
+        messageId: "parent-msg-1",
+        title: parent.title ?? "Untitled",
+      },
+    });
+    expect(body.hasMore).toBe(false);
+  });
+
+  test("GET /v1/conversations/:id returns forkParent for surviving parents", async () => {
+    const { child, parent } = seedForkedConversation();
+    await startServer();
+
+    const response = await fetch(url(`/conversations/${child.id}`));
+    expect(response.status).toBe(200);
+
+    const body = (await response.json()) as {
+      conversation: ConversationSummary;
+    };
+
+    expect(body.conversation).toMatchObject({
+      id: child.id,
+      title: child.title ?? "Untitled",
+      forkParent: {
+        conversationId: parent.id,
+        messageId: "parent-msg-1",
+        title: parent.title ?? "Untitled",
+      },
+    });
+  });
+
+  test("GET /v1/conversations/:id includes pin metadata when present", async () => {
+    const conversation = createConversation("Pinned conversation");
+    batchSetDisplayOrders([
+      { id: conversation.id, displayOrder: 7, isPinned: true },
+    ]);
+    await startServer();
+
+    const response = await fetch(url(`/conversations/${conversation.id}`));
+    expect(response.status).toBe(200);
+
+    const body = (await response.json()) as {
+      conversation: ConversationSummary;
+    };
+
+    expect(body.conversation).toMatchObject({
+      id: conversation.id,
+      title: conversation.title ?? "Untitled",
+      displayOrder: 7,
+      isPinned: true,
+    });
+  });
+
+  test("GET /v1/conversations/:id resolves the parent's current title at read time", async () => {
+    const { child, parent } = seedForkedConversation({
+      parentTitle: "Original parent title",
+    });
+    updateConversationTitle(parent.id, "Renamed parent title", 0);
+    await startServer();
+
+    const response = await fetch(url(`/conversations/${child.id}`));
+    expect(response.status).toBe(200);
+
+    const body = (await response.json()) as {
+      conversation: ConversationSummary;
+    };
+
+    expect(body.conversation.forkParent).toEqual({
+      conversationId: parent.id,
+      messageId: "parent-msg-1",
+      title: "Renamed parent title",
+    });
+  });
+
+  test("deleted parents are omitted from list and detail responses", async () => {
+    const { child, parent } = seedForkedConversation();
+    rawRun("DELETE FROM conversations WHERE id = ?", parent.id);
+    await startServer();
+
+    const listResponse = await fetch(url("/conversations"));
+    expect(listResponse.status).toBe(200);
+    const listBody = (await listResponse.json()) as {
+      conversations: ConversationSummary[];
+    };
+    const listedChild = listBody.conversations.find(
+      (item) => item.id === child.id,
+    );
+    expect(listedChild).toBeDefined();
+    expect(listedChild?.forkParent).toBeUndefined();
+
+    const detailResponse = await fetch(url(`/conversations/${child.id}`));
+    expect(detailResponse.status).toBe(200);
+    const detailBody = (await detailResponse.json()) as {
+      conversation: ConversationSummary;
+    };
+    expect(detailBody.conversation.forkParent).toBeUndefined();
+  });
+
+  function clearTables(): void {
+    const db = getDb();
+    db.run("DELETE FROM conversation_assistant_attention_state");
+    db.run("DELETE FROM external_conversation_bindings");
+    db.run("DELETE FROM conversation_keys");
+    db.run("DELETE FROM messages");
+    db.run("DELETE FROM conversations");
+  }
+
+  function seedForkedConversation(opts?: { parentTitle?: string }) {
+    const parent = createConversation(
+      opts?.parentTitle ?? "Parent conversation",
+    );
+    const child = createConversation("Forked conversation");
+
+    rawRun(
+      `
+        UPDATE conversations
+        SET fork_parent_conversation_id = ?, fork_parent_message_id = ?
+        WHERE id = ?
+      `,
+      parent.id,
+      "parent-msg-1",
+      child.id,
+    );
+
+    return { parent, child };
+  }
+
+  async function startServer(): Promise<void> {
+    server = new RuntimeHttpServer({
+      port: 0,
+      bearerToken: "test-bearer-token",
+    });
+    await server.start();
+  }
+
+  function url(pathname: string): string {
+    if (!server) throw new Error("server not started");
+    return `http://127.0.0.1:${server.actualPort}/v1${pathname}`;
+  }
+});

package/src/__tests__/image-source-path-reinject.test.ts

@@ -0,0 +1,136 @@
+import { describe, expect, test } from "bun:test";
+
+import { reinjectImageSourcePaths } from "../daemon/conversation-lifecycle.js";
+import type { ContentBlock } from "../providers/types.js";
+
+// ---------------------------------------------------------------------------
+// reinjectImageSourcePaths — re-inject [Attached image source: /path]
+// annotations when loading conversation history from DB
+// ---------------------------------------------------------------------------
+
+describe("reinjectImageSourcePaths", () => {
+  const baseContent: ContentBlock[] = [
+    { type: "text", text: "what is this?" },
+    {
+      type: "image",
+      source: { type: "base64", media_type: "image/jpeg", data: "base64img" },
+    },
+  ];
+
+  test("adds annotation when user message has imageSourcePaths in metadata", () => {
+    const metadata = JSON.stringify({
+      imageSourcePaths: { "photo.jpg": "/Users/me/Desktop/photo.jpg" },
+    });
+    const result = reinjectImageSourcePaths(baseContent, "user", metadata);
+
+    expect(result).toHaveLength(3);
+    const annotation = result[2] as { type: "text"; text: string };
+    expect(annotation.type).toBe("text");
+    expect(annotation.text).toBe(
+      "[Attached image source: /Users/me/Desktop/photo.jpg]",
+    );
+  });
+
+  test("does NOT annotate assistant messages even if metadata has imageSourcePaths", () => {
+    const metadata = JSON.stringify({
+      imageSourcePaths: { "photo.jpg": "/Users/me/Desktop/photo.jpg" },
+    });
+    const result = reinjectImageSourcePaths(baseContent, "assistant", metadata);
+
+    // Should return the original content unchanged
+    expect(result).toBe(baseContent);
+    expect(result).toHaveLength(2);
+  });
+
+  test("returns content unchanged when metadata is null", () => {
+    const result = reinjectImageSourcePaths(baseContent, "user", null);
+    expect(result).toBe(baseContent);
+    expect(result).toHaveLength(2);
+  });
+
+  test("returns content unchanged when metadata has no imageSourcePaths", () => {
+    const metadata = JSON.stringify({
+      userMessageChannel: "desktop",
+    });
+    const result = reinjectImageSourcePaths(baseContent, "user", metadata);
+    expect(result).toBe(baseContent);
+    expect(result).toHaveLength(2);
+  });
+
+  test("returns content unchanged when imageSourcePaths is empty object", () => {
+    const metadata = JSON.stringify({
+      imageSourcePaths: {},
+    });
+    const result = reinjectImageSourcePaths(baseContent, "user", metadata);
+    expect(result).toBe(baseContent);
+    expect(result).toHaveLength(2);
+  });
+
+  test("handles multiple image source paths", () => {
+    const metadata = JSON.stringify({
+      imageSourcePaths: {
+        "a.jpg": "/path/to/a.jpg",
+        "b.png": "/path/to/b.png",
+      },
+    });
+    const result = reinjectImageSourcePaths(baseContent, "user", metadata);
+
+    expect(result).toHaveLength(3);
+    const annotation = result[2] as { type: "text"; text: string };
+    expect(annotation.type).toBe("text");
+    expect(annotation.text).toBe(
+      "[Attached image source: /path/to/a.jpg]\n[Attached image source: /path/to/b.png]",
+    );
+  });
+
+  test("gracefully handles malformed metadata JSON", () => {
+    const result = reinjectImageSourcePaths(
+      baseContent,
+      "user",
+      "not-valid-json{{{",
+    );
+    // Should return original content, not throw
+    expect(result).toBe(baseContent);
+    expect(result).toHaveLength(2);
+  });
+
+  test("filters out non-string values in imageSourcePaths", () => {
+    const metadata = JSON.stringify({
+      imageSourcePaths: {
+        "photo.jpg": "/Users/me/Desktop/photo.jpg",
+        "bad.jpg": 42,
+        "also_bad.jpg": null,
+      },
+    });
+    const result = reinjectImageSourcePaths(baseContent, "user", metadata);
+
+    expect(result).toHaveLength(3);
+    const annotation = result[2] as { type: "text"; text: string };
+    expect(annotation.text).toBe(
+      "[Attached image source: /Users/me/Desktop/photo.jpg]",
+    );
+  });
+
+  test("returns content unchanged when imageSourcePaths has only non-string values", () => {
+    const metadata = JSON.stringify({
+      imageSourcePaths: {
+        "bad.jpg": 42,
+        "also_bad.jpg": null,
+      },
+    });
+    const result = reinjectImageSourcePaths(baseContent, "user", metadata);
+    expect(result).toBe(baseContent);
+    expect(result).toHaveLength(2);
+  });
+
+  test("preserves original content blocks in returned array", () => {
+    const metadata = JSON.stringify({
+      imageSourcePaths: { "photo.jpg": "/path/photo.jpg" },
+    });
+    const result = reinjectImageSourcePaths(baseContent, "user", metadata);
+
+    // First two blocks should be identical to the originals
+    expect(result[0]).toEqual(baseContent[0]);
+    expect(result[1]).toEqual(baseContent[1]);
+  });
+});