@vellumai/assistant 0.10.12 → 0.11.0-staging.2

package/src/__tests__/conversation-group-tools.test.ts

@@ -0,0 +1,279 @@
+import type { Database } from "bun:sqlite";
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  createConversation,
+  getDisplayMetaForConversations,
+} from "../persistence/conversation-crud.js";
+import { ensureGroupMigration } from "../persistence/conversation-group-migration.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import { executeConversationGroupCreate } from "../tools/conversation-groups/group_create.js";
+import { executeConversationGroupList } from "../tools/conversation-groups/group_list.js";
+import { executeConversationMoveToGroup } from "../tools/conversation-groups/move_to_group.js";
+import type { ToolContext } from "../tools/types.js";
+
+await initializeDb();
+ensureGroupMigration();
+
+function getRawDb(): Database {
+  return (getDb() as unknown as { $client: Database }).$client;
+}
+
+const ctx: ToolContext = {
+  workingDir: "/tmp",
+  conversationId: "test-conversation",
+  trustClass: "guardian",
+};
+
+function clearState(): void {
+  const raw = getRawDb();
+  raw.run("DELETE FROM conversations");
+  raw.run("DELETE FROM conversation_groups WHERE is_system_group = 0");
+}
+
+function extractGroupId(content: string): string {
+  const match = content.match(/id: ([0-9a-f-]{36})/);
+  expect(match).not.toBeNull();
+  return match![1];
+}
+
+function groupIdOf(conversationId: string): string | null {
+  return (
+    getDisplayMetaForConversations([conversationId]).get(conversationId)
+      ?.groupId ?? null
+  );
+}
+
+// ── conversation_group_list ─────────────────────────────────────────
+
+describe("conversation_group_list tool", () => {
+  beforeEach(clearState);
+
+  test("lists system groups", async () => {
+    const result = await executeConversationGroupList({}, ctx);
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Pinned (id: system:pinned)");
+    expect(result.content).toContain("Recents (id: system:all)");
+    expect(result.content).toContain("[system group]");
+  });
+
+  test("lists custom groups after creation", async () => {
+    await executeConversationGroupCreate({ name: "Work" }, ctx);
+
+    const result = await executeConversationGroupList({}, ctx);
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Work");
+  });
+});
+
+// ── conversation_group_create ───────────────────────────────────────
+
+describe("conversation_group_create tool", () => {
+  beforeEach(clearState);
+
+  test("creates a custom group", async () => {
+    const result = await executeConversationGroupCreate(
+      { name: "Travel planning" },
+      ctx,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Created group "Travel planning"');
+  });
+
+  test("trims the name", async () => {
+    const result = await executeConversationGroupCreate(
+      { name: "  Padded  " },
+      ctx,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Created group "Padded"');
+  });
+
+  test("reuses an existing group with the same name (case-insensitive)", async () => {
+    const first = await executeConversationGroupCreate({ name: "Work" }, ctx);
+    const firstId = extractGroupId(first.content);
+
+    const second = await executeConversationGroupCreate({ name: "work" }, ctx);
+    expect(second.isError).toBe(false);
+    expect(second.content).toContain("already exists");
+    expect(second.content).toContain(firstId);
+  });
+
+  test("rejects system group names", async () => {
+    const result = await executeConversationGroupCreate(
+      { name: "pinned" },
+      ctx,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("system group");
+  });
+
+  test("rejects missing name", async () => {
+    const result = await executeConversationGroupCreate({}, ctx);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("name is required");
+  });
+});
+
+// ── conversation_move_to_group ──────────────────────────────────────
+
+describe("conversation_move_to_group tool", () => {
+  beforeEach(clearState);
+
+  test("moves a conversation into a custom group by name", async () => {
+    createConversation({ id: "conv-1", title: "Trip ideas" });
+    await executeConversationGroupCreate({ name: "Travel" }, ctx);
+
+    const result = await executeConversationMoveToGroup(
+      { group: "travel", conversation_id: "conv-1" },
+      ctx,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Moved "Trip ideas" to group "Travel"');
+    expect(groupIdOf("conv-1")).not.toBe("system:all");
+  });
+
+  test("moves a conversation by group id", async () => {
+    createConversation({ id: "conv-2" });
+    const created = await executeConversationGroupCreate({ name: "Work" }, ctx);
+    const groupId = extractGroupId(created.content);
+
+    const result = await executeConversationMoveToGroup(
+      { group: groupId, conversation_id: "conv-2" },
+      ctx,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(groupIdOf("conv-2")).toBe(groupId);
+  });
+
+  test("defaults to the current conversation", async () => {
+    createConversation({ id: "test-conversation", title: "This chat" });
+    await executeConversationGroupCreate({ name: "Inbox" }, ctx);
+
+    const result = await executeConversationMoveToGroup(
+      { group: "Inbox" },
+      ctx,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain('Moved "This chat" to group "Inbox"');
+  });
+
+  test("moving to Pinned pins the conversation", async () => {
+    createConversation({ id: "conv-pin" });
+
+    const result = await executeConversationMoveToGroup(
+      { group: "Pinned", conversation_id: "conv-pin" },
+      ctx,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("pinned");
+    expect(groupIdOf("conv-pin")).toBe("system:pinned");
+    const pinned = getRawDb()
+      .query("SELECT is_pinned FROM conversations WHERE id = ?")
+      .get("conv-pin") as { is_pinned: number };
+    expect(pinned.is_pinned).toBe(1);
+  });
+
+  test("preserves display_order across a move", async () => {
+    createConversation({ id: "conv-ord" });
+    getRawDb().run(
+      "UPDATE conversations SET display_order = 7 WHERE id = 'conv-ord'",
+    );
+    await executeConversationGroupCreate({ name: "Ordered" }, ctx);
+
+    const result = await executeConversationMoveToGroup(
+      { group: "Ordered", conversation_id: "conv-ord" },
+      ctx,
+    );
+
+    expect(result.isError).toBe(false);
+    const row = getRawDb()
+      .query("SELECT display_order FROM conversations WHERE id = ?")
+      .get("conv-ord") as { display_order: number | null };
+    expect(row.display_order).toBe(7);
+  });
+
+  test("no-op when already in the target group", async () => {
+    createConversation({ id: "conv-3", title: "Settled" });
+
+    const result = await executeConversationMoveToGroup(
+      { group: "Recents", conversation_id: "conv-3" },
+      ctx,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("already in group");
+  });
+
+  test("errors on unknown group with available list", async () => {
+    createConversation({ id: "conv-4" });
+
+    const result = await executeConversationMoveToGroup(
+      { group: "Nonexistent", conversation_id: "conv-4" },
+      ctx,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('No group named "Nonexistent"');
+    expect(result.content).toContain("Available groups:");
+  });
+
+  test("errors on ambiguous group name", async () => {
+    // Two custom groups whose names differ only by case
+    await executeConversationGroupCreate({ name: "Alpha" }, ctx);
+    // Bypass the tool's dedup to create the case-variant directly
+    getRawDb().run(
+      "INSERT INTO conversation_groups (id, name, sort_position, is_system_group, created_at, updated_at) VALUES ('dup-group-id', 'alpha', 99, 0, 0, 0)",
+    );
+    createConversation({ id: "conv-5" });
+
+    const result = await executeConversationMoveToGroup(
+      { group: "ALPHA", conversation_id: "conv-5" },
+      ctx,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("ambiguous");
+    expect(result.content).toContain("Retry with the group id");
+  });
+
+  test("errors on unknown conversation", async () => {
+    const result = await executeConversationMoveToGroup(
+      { group: "Recents", conversation_id: "missing-conv" },
+      ctx,
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("no conversation found");
+  });
+
+  test("notes hidden conversation types", async () => {
+    createConversation({ id: "conv-bg", conversationType: "background" });
+    await executeConversationGroupCreate({ name: "Visible" }, ctx);
+
+    const result = await executeConversationMoveToGroup(
+      { group: "Visible", conversation_id: "conv-bg" },
+      ctx,
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("hidden from the sidebar");
+  });
+
+  test("rejects missing group", async () => {
+    const result = await executeConversationMoveToGroup({}, ctx);
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("group is required");
+  });
+});

package/src/__tests__/conversation-history-web-search.test.ts

@@ -652,7 +652,7 @@ describe("web_search_tool_result structural guard", () => {
     // provider, not the local tool executor, so they never flow here.
     "agent/loop.ts",
 
-    // Matches the `tool_result` ServerMessage SSE event (api/events/
+    // Matches the `tool_result` AssistantEvent SSE event (api/events/
     // tool-result.ts), not a conversation content block. There is no
     // web_search_tool_result SSE event — web-search activity travels as
     // activityMetadata on the same tool_result event. Same event-vs-block

package/src/__tests__/conversation-key-store-disk-view.test.ts

@@ -14,6 +14,7 @@ const testDir = process.env.VELLUM_WORKSPACE_DIR!;
 const conversationsDir = join(testDir, "conversations");
 mkdirSync(conversationsDir, { recursive: true });
 
+import type { AssistantEventEnvelope } from "../api/index.js";
 import { getOrCreateConversation } from "../persistence/conversation-key-store.js";
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
@@ -21,7 +22,6 @@ import {
   conversationKeys,
   conversations,
 } from "../persistence/schema/index.js";
-import type { AssistantEvent } from "../runtime/assistant-event.js";
 import {
   _resetStreamStateForTesting,
   _simulateRestartForTesting,
@@ -87,7 +87,7 @@ describe("conversation-key-store disk view", () => {
     // /messages for their entire first turn — the anchor-less snapshot that
     // let mid-turn refetches wipe streamed transcript content on clients.
     _resetStreamStateForTesting();
-    const event: AssistantEvent = {
+    const event: AssistantEventEnvelope = {
       id: "seed-evt",
       conversationId: "other-conversation",
       emittedAt: new Date().toISOString(),
@@ -95,7 +95,7 @@ describe("conversation-key-store disk view", () => {
         type: "assistant_text_delta",
         conversationId: "other-conversation",
         text: "x",
-      } as AssistantEvent["message"],
+      } as AssistantEventEnvelope["message"],
     };
     stampAndBuffer(event);
     const baseline = getCurrentSeq();
@@ -116,7 +116,7 @@ describe("conversation-key-store disk view", () => {
     // its ceiling — a conversation created before the first stamp must seed
     // from that ceiling, not report NULL as if the assistant were brand new.
     _resetStreamStateForTesting();
-    const event: AssistantEvent = {
+    const event: AssistantEventEnvelope = {
       id: "restart-evt",
       conversationId: "other-conversation",
       emittedAt: new Date().toISOString(),
@@ -124,7 +124,7 @@ describe("conversation-key-store disk view", () => {
         type: "assistant_text_delta",
         conversationId: "other-conversation",
         text: "x",
-      } as AssistantEvent["message"],
+      } as AssistantEventEnvelope["message"],
     };
     stampAndBuffer(event);
     _simulateRestartForTesting();

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

@@ -0,0 +1,235 @@
+/**
+ * Tests for `resolveConversationLineage`: a conversation plus every subagent
+ * ancestor above it, nearest first, bounded by a depth cap and a visited set.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+/**
+ * Resident top-level conversations, mapped to the id they were forked from —
+ * the eviction-managed store. A key absent from the map stands for a
+ * conversation that is not resident there.
+ */
+let residents = new Map<string, string | undefined>();
+
+/**
+ * Resident subagent conversations, in the separate index `SubagentManager`
+ * owns. A background subagent's id lives only here, never in `residents`.
+ */
+let subagentResidents = new Map<string, string | undefined>();
+
+mock.module("../daemon/conversation-registry.js", () => ({
+  findConversationOrSubagent: (id: string | undefined) => {
+    if (id === undefined) {
+      return undefined;
+    }
+    // Mirrors the registry: top-level store first, then the subagent index.
+    if (residents.has(id)) {
+      return { parentConversationId: residents.get(id) };
+    }
+    if (subagentResidents.has(id)) {
+      return { parentConversationId: subagentResidents.get(id) };
+    }
+    return undefined;
+  },
+  /** Present so a lookup through the top-level-only accessor fails loudly. */
+  findConversation: () => {
+    throw new Error(
+      "lineage must resolve through findConversationOrSubagent, not findConversation",
+    );
+  },
+}));
+
+/**
+ * Durable `parent_conversation_id` rows, keyed by conversation id. Stands for
+ * parentage that outlives residency in either in-memory index.
+ */
+let persistedParents = new Map<string, string>();
+
+/** When set, every durable read fails — the degraded-database case. */
+let persistedReadFails = false;
+
+mock.module("../persistence/conversation-parent.js", () => ({
+  getPersistedParentConversationId: (id: string) => {
+    if (persistedReadFails) {
+      throw new Error("database unavailable");
+    }
+    return persistedParents.get(id);
+  },
+}));
+
+const { MAX_LINEAGE_DEPTH, resolveConversationLineage } =
+  await import("../daemon/conversation-lineage.js");
+
+describe("resolveConversationLineage", () => {
+  beforeEach(() => {
+    residents = new Map();
+    subagentResidents = new Map();
+    persistedParents = new Map();
+    persistedReadFails = false;
+  });
+
+  test("a plain conversation is its own lineage", () => {
+    residents.set("conv-a", undefined);
+
+    expect(resolveConversationLineage("conv-a")).toEqual(["conv-a"]);
+  });
+
+  test("one fork level reaches the spawner", () => {
+    residents.set("conv-child", "conv-parent");
+    residents.set("conv-parent", undefined);
+
+    expect(resolveConversationLineage("conv-child")).toEqual([
+      "conv-child",
+      "conv-parent",
+    ]);
+  });
+
+  test("two fork levels are ordered nearest first", () => {
+    residents.set("conv-child", "conv-mid");
+    residents.set("conv-mid", "conv-root");
+    residents.set("conv-root", undefined);
+
+    expect(resolveConversationLineage("conv-child")).toEqual([
+      "conv-child",
+      "conv-mid",
+      "conv-root",
+    ]);
+  });
+
+  test("a background subagent id reaches its user-visible parent", () => {
+    // The live-voice duplex continuation: the seed id is registered only in
+    // the subagent index, never in the eviction-managed top-level store.
+    subagentResidents.set("conv-subagent", "conv-visible");
+    residents.set("conv-visible", undefined);
+
+    expect(resolveConversationLineage("conv-subagent")).toEqual([
+      "conv-subagent",
+      "conv-visible",
+    ]);
+  });
+
+  test("nested subagents walk out of the subagent index into the store", () => {
+    subagentResidents.set("conv-inner", "conv-outer");
+    subagentResidents.set("conv-outer", "conv-visible");
+    residents.set("conv-visible", undefined);
+
+    expect(resolveConversationLineage("conv-inner")).toEqual([
+      "conv-inner",
+      "conv-outer",
+      "conv-visible",
+    ]);
+  });
+
+  test("a conversation resident nowhere and unparented in the database is its own lineage", () => {
+    expect(resolveConversationLineage("conv-gone")).toEqual(["conv-gone"]);
+  });
+
+  test("a non-resident ancestor with no durable parentage ends the walk", () => {
+    residents.set("conv-child", "conv-evicted");
+
+    expect(resolveConversationLineage("conv-child")).toEqual([
+      "conv-child",
+      "conv-evicted",
+    ]);
+  });
+
+  // ── Durable parentage ─────────────────────────────────────────────────────
+  // The subagent index entry is dropped as soon as a run goes terminal and
+  // idle top-level conversations are evicted, so an artifact linked after
+  // either point must still reach the user-visible thread.
+
+  test("a seed dropped from the subagent index still reaches its parent", () => {
+    persistedParents.set("conv-terminal-subagent", "conv-visible");
+    residents.set("conv-visible", undefined);
+
+    expect(resolveConversationLineage("conv-terminal-subagent")).toEqual([
+      "conv-terminal-subagent",
+      "conv-visible",
+    ]);
+  });
+
+  test("an ancestor resident only in the database is reached", () => {
+    subagentResidents.set("conv-inner", "conv-outer");
+    persistedParents.set("conv-outer", "conv-visible");
+
+    expect(resolveConversationLineage("conv-inner")).toEqual([
+      "conv-inner",
+      "conv-outer",
+      "conv-visible",
+    ]);
+  });
+
+  test("the resident record wins over the durable column", () => {
+    subagentResidents.set("conv-fork", "conv-resident-parent");
+    persistedParents.set("conv-fork", "conv-stale-parent");
+    residents.set("conv-resident-parent", undefined);
+
+    expect(resolveConversationLineage("conv-fork")).toEqual([
+      "conv-fork",
+      "conv-resident-parent",
+    ]);
+  });
+
+  test("a failing durable read degrades to the chain resolved so far", () => {
+    subagentResidents.set("conv-inner", "conv-outer");
+    persistedReadFails = true;
+
+    expect(() => resolveConversationLineage("conv-inner")).not.toThrow();
+    expect(resolveConversationLineage("conv-inner")).toEqual([
+      "conv-inner",
+      "conv-outer",
+    ]);
+  });
+
+  test("a cycle spanning the durable column terminates", () => {
+    persistedParents.set("conv-a", "conv-b");
+    persistedParents.set("conv-b", "conv-a");
+
+    expect(resolveConversationLineage("conv-a")).toEqual(["conv-a", "conv-b"]);
+  });
+
+  test("a durable chain longer than the depth cap is truncated at the cap", () => {
+    const chain = Array.from(
+      { length: MAX_LINEAGE_DEPTH + 5 },
+      (_, i) => `conv-durable-${i}`,
+    );
+    for (const [i, id] of chain.entries()) {
+      const parent = chain[i + 1];
+      if (parent) {
+        persistedParents.set(id, parent);
+      }
+    }
+
+    expect(resolveConversationLineage(chain[0]!)).toEqual(
+      chain.slice(0, MAX_LINEAGE_DEPTH),
+    );
+  });
+
+  test("a self-referential parent does not loop forever", () => {
+    residents.set("conv-self", "conv-self");
+
+    expect(resolveConversationLineage("conv-self")).toEqual(["conv-self"]);
+  });
+
+  test("a cycle between two conversations terminates", () => {
+    residents.set("conv-a", "conv-b");
+    residents.set("conv-b", "conv-a");
+
+    expect(resolveConversationLineage("conv-a")).toEqual(["conv-a", "conv-b"]);
+  });
+
+  test("a chain longer than the depth cap is truncated at the cap", () => {
+    const chain = Array.from(
+      { length: MAX_LINEAGE_DEPTH + 5 },
+      (_, i) => `conv-${i}`,
+    );
+    for (const [i, id] of chain.entries()) {
+      residents.set(id, chain[i + 1]);
+    }
+
+    expect(resolveConversationLineage(chain[0]!)).toEqual(
+      chain.slice(0, MAX_LINEAGE_DEPTH),
+    );
+  });
+});

package/src/__tests__/conversation-loop-db-lock-resilience.test.ts

@@ -48,9 +48,9 @@ mock.module("../persistence/conversation-crud.js", () => ({
     id: role === "user" ? "tool-result-row" : "assistant-row",
   }),
   recordConversationPersistedSeq: (id: string, seq: number) => {
-    if (!Number.isFinite(seq) || seq <= 0) return;
+    if (!Number.isFinite(seq) || seq <= 0) {return;}
     const prev = persistedSeqByConversation.get(id);
-    if (prev == null || prev < seq) persistedSeqByConversation.set(id, seq);
+    if (prev == null || prev < seq) {persistedSeqByConversation.set(id, seq);}
   },
   getConversationPersistedSeq: (id: string) =>
     persistedSeqByConversation.get(id) ?? null,
@@ -70,7 +70,7 @@ mock.module("../plugins/defaults/memory/memory-recall-log-store.js", () => ({
 }));
 
 mock.module(
-  "../plugins/defaults/memory/memory-v2-activation-log-store.js",
+  "../plugins/defaults/memory/v2/activation-log-store.js",
   () => ({
     backfillMemoryV2ActivationMessageId: () => {},
   }),
@@ -78,6 +78,7 @@ mock.module(
 
 // ── Imports (after mocks) ─────────────────────────────────────────────────────
 import type { AgentEvent } from "../agent/loop.js";
+import type { AssistantEvent } from "../api/index.js";
 import type {
   EventHandlerDeps,
   EventHandlerState,
@@ -86,7 +87,6 @@ import {
   createEventHandlerState,
   handleMessageComplete,
 } from "../daemon/conversation-agent-loop-handlers.js";
-import type { ServerMessage } from "../daemon/message-protocol.js";
 import { getConversationPersistedSeq } from "../persistence/conversation-crud.js";
 
 const CONVERSATION_ID = "test-session-id";
@@ -101,7 +101,7 @@ function createMockDeps(): EventHandlerDeps {
       markWorkspaceTopLevelDirty: () => {},
       currentTurnSurfaces: [],
     } as unknown as EventHandlerDeps["ctx"],
-    onEvent: (_msg: ServerMessage) => {},
+    onEvent: (_msg: AssistantEvent) => {},
     reqId: "test-req-id",
     isFirstMessage: false,
     shouldGenerateTitle: false,

package/src/__tests__/conversation-message-sync-tags.test.ts

@@ -1,10 +1,10 @@
 import { describe, expect, test } from "bun:test";
 
+import type { AssistantEventEnvelope } from "../api/index.js";
 import {
   conversationMessagesSyncTag,
   type SyncChangedEvent,
 } from "../daemon/message-types/sync.js";
-import type { AssistantEvent } from "../runtime/assistant-event.js";
 import {
   assistantEventHub,
   broadcastMessage,
@@ -15,8 +15,8 @@ import { waitFor } from "./helpers/wait-for.js";
 async function captureEvents(
   action: () => void | Promise<unknown>,
   expectedCount: number,
-): Promise<AssistantEvent[]> {
-  const received: AssistantEvent[] = [];
+): Promise<AssistantEventEnvelope[]> {
+  const received: AssistantEventEnvelope[] = [];
   const subscription = assistantEventHub.subscribe({
     type: "process",
     callback: (event) => {
@@ -34,7 +34,7 @@ async function captureEvents(
   }
 }
 
-function syncMessages(events: AssistantEvent[]): SyncChangedEvent[] {
+function syncMessages(events: AssistantEventEnvelope[]): SyncChangedEvent[] {
   return events
     .map((event) => event.message)
     .filter(