@vellumai/assistant 0.8.5 → 0.8.7

package/src/runtime/routes/__tests__/conversation-compaction-routes.test.ts

@@ -0,0 +1,436 @@
+/**
+ * Tests for the compaction-trail route + projection.
+ *
+ * The handler is exercised against a fake `LlmRequestLogSource` so we
+ * can pin (a) the BadRequestError / NotFoundError branches that don't
+ * involve any logs, and (b) the happy path that returns a projected
+ * trail with the expected shape. The projection function is unit-tested
+ * directly so its branches stay covered even if the handler ever swaps
+ * to a different log source.
+ */
+
+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 },
+    secretDetection: { enabled: false },
+    llmRequestLogs: { readSource: "local" as const },
+  }),
+}));
+
+// ---------------------------------------------------------------------
+// Source + conversation-crud module mocks
+// ---------------------------------------------------------------------
+
+import type { LogRow } from "../../../memory/llm-request-log-store.js";
+
+interface FakeSourceState {
+  conversation: { id: string } | null;
+  selectedCall: LogRow | null;
+  turnBounds: { startTime: number; endTime: number } | null;
+  compactionLogs: LogRow[];
+}
+
+const state: FakeSourceState = {
+  conversation: null,
+  selectedCall: null,
+  turnBounds: null,
+  compactionLogs: [],
+};
+
+// Records the inputs the handler passed to its collaborators so tests
+// can pin the windowing plumbing without relying on the projection.
+const sourceCalls = {
+  getRequestLogByIdArgs: [] as string[],
+  getTurnTimeBoundsArgs: [] as Array<{
+    conversationId: string;
+    messageCreatedAt: number;
+  }>,
+  getCompactionLogsBetweenArgs: [] as Array<{
+    conversationId: string;
+    afterCreatedAt: number | null;
+    beforeCreatedAt: number;
+  }>,
+};
+
+mock.module("../../../memory/conversation-crud.js", () => ({
+  getConversation: (id: string) =>
+    state.conversation && state.conversation.id === id
+      ? state.conversation
+      : null,
+  getTurnTimeBounds: (conversationId: string, messageCreatedAt: number) => {
+    sourceCalls.getTurnTimeBoundsArgs.push({
+      conversationId,
+      messageCreatedAt,
+    });
+    return state.turnBounds;
+  },
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
+}));
+
+mock.module("../../../memory/llm-request-log-source.js", () => ({
+  getLlmRequestLogSource: async () => ({
+    getRequestLogById: async (id: string) => {
+      sourceCalls.getRequestLogByIdArgs.push(id);
+      return state.selectedCall;
+    },
+    getRequestLogsByMessageId: async () => [],
+    getRequestLogsByConversationId: async () => [],
+    getCompactionLogsBetween: async (
+      conversationId: string,
+      afterCreatedAt: number | null,
+      beforeCreatedAt: number,
+    ) => {
+      sourceCalls.getCompactionLogsBetweenArgs.push({
+        conversationId,
+        afterCreatedAt,
+        beforeCreatedAt,
+      });
+      return state.compactionLogs;
+    },
+  }),
+}));
+
+// Imported AFTER the mocks so the handler picks up the fakes.
+import {
+  projectLogRowToCompactionTrailEvent,
+  ROUTES,
+} from "../conversation-compaction-routes.js";
+import { BadRequestError, NotFoundError } from "../errors.js";
+
+const route = ROUTES.find(
+  (r) => r.operationId === "conversations_compaction_trail_get",
+)!;
+const handler = route.handler as (
+  args: Record<string, unknown>,
+) => Promise<{ conversationId: string; events: unknown[] }>;
+
+function fakeLogRow(overrides: Partial<LogRow> = {}): LogRow {
+  return {
+    id: "log-default",
+    conversationId: "conv-default",
+    messageId: null,
+    provider: "anthropic",
+    requestPayload: "{}",
+    responsePayload: "{}",
+    createdAt: 1000,
+    agentLoopExitReason: null,
+    callSite: null,
+    ...overrides,
+  };
+}
+
+beforeEach(() => {
+  state.conversation = null;
+  state.selectedCall = null;
+  state.turnBounds = null;
+  state.compactionLogs = [];
+  sourceCalls.getRequestLogByIdArgs.length = 0;
+  sourceCalls.getTurnTimeBoundsArgs.length = 0;
+  sourceCalls.getCompactionLogsBetweenArgs.length = 0;
+});
+
+// ---------------------------------------------------------------------
+// Route registration sanity
+// ---------------------------------------------------------------------
+
+describe("conversation-compaction-routes — registration", () => {
+  test("exposes one GET route at conversations/:id/compaction", () => {
+    expect(route).toBeDefined();
+    expect(route.method).toBe("GET");
+    expect(route.endpoint).toBe("conversations/:id/compaction");
+    expect(route.policy?.requiredScopes).toContain("chat.read");
+  });
+});
+
+// ---------------------------------------------------------------------
+// Handler — error branches
+// ---------------------------------------------------------------------
+
+describe("handleGetCompactionTrail — request-shape errors", () => {
+  test("throws BadRequestError when the conversation id path param is missing", async () => {
+    await expect(
+      handler({ pathParams: {}, queryParams: { callId: "call-1" } }),
+    ).rejects.toThrow(BadRequestError);
+  });
+
+  test("throws BadRequestError when the callId query param is missing", async () => {
+    state.conversation = { id: "conv-1" };
+    await expect(
+      handler({ pathParams: { id: "conv-1" }, queryParams: {} }),
+    ).rejects.toThrow(BadRequestError);
+  });
+
+  test("throws NotFoundError when the conversation does not exist", async () => {
+    state.conversation = null;
+    await expect(
+      handler({
+        pathParams: { id: "missing" },
+        queryParams: { callId: "call-1" },
+      }),
+    ).rejects.toThrow(NotFoundError);
+  });
+
+  test("throws NotFoundError when the referenced LLM call does not exist", async () => {
+    state.conversation = { id: "conv-1" };
+    state.selectedCall = null;
+    await expect(
+      handler({
+        pathParams: { id: "conv-1" },
+        queryParams: { callId: "missing-call" },
+      }),
+    ).rejects.toThrow(NotFoundError);
+  });
+
+  test("throws BadRequestError when callId belongs to a different conversation", async () => {
+    state.conversation = { id: "conv-1" };
+    state.selectedCall = fakeLogRow({
+      id: "call-x",
+      conversationId: "conv-other",
+      createdAt: 1234,
+    });
+    await expect(
+      handler({
+        pathParams: { id: "conv-1" },
+        queryParams: { callId: "call-x" },
+      }),
+    ).rejects.toThrow(BadRequestError);
+  });
+});
+
+// ---------------------------------------------------------------------
+// Handler — happy path
+// ---------------------------------------------------------------------
+
+describe("handleGetCompactionTrail — happy path", () => {
+  test("forwards the turn window to the source (start - 1 as floor, end + 1 as ceiling)", async () => {
+    state.conversation = { id: "conv-1" };
+    state.selectedCall = fakeLogRow({
+      id: "call-selected",
+      conversationId: "conv-1",
+      createdAt: 5000,
+    });
+    // Selected call sits inside a turn that runs [2000, 9000].
+    state.turnBounds = { startTime: 2000, endTime: 9000 };
+    state.compactionLogs = [];
+
+    await handler({
+      pathParams: { id: "conv-1" },
+      queryParams: { callId: "call-selected" },
+    });
+
+    expect(sourceCalls.getRequestLogByIdArgs).toEqual(["call-selected"]);
+    expect(sourceCalls.getTurnTimeBoundsArgs).toEqual([
+      { conversationId: "conv-1", messageCreatedAt: 5000 },
+    ]);
+    // 1ms-shift around the exclusive `(>, <)` predicate so rows that
+    // land on the bounds themselves come back.
+    expect(sourceCalls.getCompactionLogsBetweenArgs).toEqual([
+      { conversationId: "conv-1", afterCreatedAt: 1999, beforeCreatedAt: 9001 },
+    ]);
+  });
+
+  test("scopes the trail to the whole turn — compactions after the selected call are in scope", async () => {
+    // Selecting an early call in a turn that contains compactions
+    // *after* the selected call must still surface those later events.
+    // This is the core promise of turn-scoping: position within the
+    // turn is irrelevant.
+    state.conversation = { id: "conv-1" };
+    state.selectedCall = fakeLogRow({
+      id: "call-early",
+      conversationId: "conv-1",
+      createdAt: 2500,
+    });
+    state.turnBounds = { startTime: 2000, endTime: 9000 };
+    state.compactionLogs = [];
+
+    await handler({
+      pathParams: { id: "conv-1" },
+      queryParams: { callId: "call-early" },
+    });
+
+    // Ceiling is the *turn end*, not the selected call's createdAt.
+    expect(sourceCalls.getCompactionLogsBetweenArgs).toEqual([
+      { conversationId: "conv-1", afterCreatedAt: 1999, beforeCreatedAt: 9001 },
+    ]);
+  });
+
+  test("falls back to a null floor + selectedCall.createdAt ceiling when getTurnTimeBounds returns null", async () => {
+    // The only-message-in-conversation edge case. Preserves the
+    // pre-turn-scoping behavior for this degenerate input.
+    state.conversation = { id: "conv-1" };
+    state.selectedCall = fakeLogRow({
+      id: "call-solo",
+      conversationId: "conv-1",
+      createdAt: 5000,
+    });
+    state.turnBounds = null;
+    state.compactionLogs = [];
+
+    await handler({
+      pathParams: { id: "conv-1" },
+      queryParams: { callId: "call-solo" },
+    });
+
+    expect(sourceCalls.getCompactionLogsBetweenArgs).toEqual([
+      { conversationId: "conv-1", afterCreatedAt: null, beforeCreatedAt: 5000 },
+    ]);
+  });
+
+  test("returns an empty events list when no compactions ran in the window", async () => {
+    state.conversation = { id: "conv-1" };
+    state.selectedCall = fakeLogRow({
+      id: "call-1",
+      conversationId: "conv-1",
+      createdAt: 5000,
+    });
+    state.turnBounds = { startTime: 2000, endTime: 9000 };
+    state.compactionLogs = [];
+
+    const result = await handler({
+      pathParams: { id: "conv-1" },
+      queryParams: { callId: "call-1" },
+    });
+    expect(result).toEqual({ conversationId: "conv-1", events: [] });
+  });
+
+  test("projects each compaction log to the wire shape", async () => {
+    state.conversation = { id: "conv-1" };
+    state.selectedCall = fakeLogRow({
+      id: "call-1",
+      conversationId: "conv-1",
+      createdAt: 9000,
+    });
+    state.turnBounds = { startTime: 500, endTime: 10_000 };
+    state.compactionLogs = [
+      fakeLogRow({
+        id: "compaction-1",
+        conversationId: "conv-1",
+        createdAt: 1000,
+      }),
+      fakeLogRow({
+        id: "compaction-2",
+        conversationId: "conv-1",
+        createdAt: 2000,
+      }),
+    ];
+
+    const result = await handler({
+      pathParams: { id: "conv-1" },
+      queryParams: { callId: "call-1" },
+    });
+
+    expect(result.conversationId).toBe("conv-1");
+    expect(result.events).toHaveLength(2);
+    // Field-set check on the first event — values are validated by the
+    // projection tests below; here we just confirm the route emits the
+    // full wire shape.
+    expect(Object.keys(result.events[0] as object).sort()).toEqual([
+      "createdAt",
+      "durationMs",
+      "estimatedCostUsd",
+      "id",
+      "inputTokens",
+      "model",
+      "outputTokens",
+      "provider",
+      "requestMessageCount",
+      "responsePreview",
+      "stopReason",
+    ]);
+  });
+});
+
+// ---------------------------------------------------------------------
+// Projection unit tests
+// ---------------------------------------------------------------------
+
+describe("projectLogRowToCompactionTrailEvent", () => {
+  test("returns null for every summary-derived field when payloads are empty", () => {
+    const event = projectLogRowToCompactionTrailEvent(fakeLogRow());
+    expect(event.id).toBe("log-default");
+    expect(event.createdAt).toBe(1000);
+    expect(event.model).toBeNull();
+    expect(event.inputTokens).toBeNull();
+    expect(event.outputTokens).toBeNull();
+    expect(event.responsePreview).toBeNull();
+    expect(event.requestMessageCount).toBeNull();
+    expect(event.stopReason).toBeNull();
+    expect(event.estimatedCostUsd).toBeNull();
+  });
+
+  test("always returns null for durationMs (column not yet recorded)", () => {
+    // Even if a future payload shape carries duration info, the
+    // projection deliberately drops it — the gap is what surfaces to
+    // the UI as "Unavailable" and informs the data-model decision.
+    const event = projectLogRowToCompactionTrailEvent(
+      fakeLogRow({
+        responsePayload: JSON.stringify({
+          // A made-up shape with a duration value to confirm the
+          // projection ignores it.
+          durationMs: 1234,
+          duration_ms: 1234,
+        }),
+      }),
+    );
+    expect(event.durationMs).toBeNull();
+  });
+
+  test("falls back to the stored provider when the normalizer can't infer one", () => {
+    // Empty payloads => normalizer returns no summary => fallback to
+    // the row's stored `provider` column.
+    const event = projectLogRowToCompactionTrailEvent(
+      fakeLogRow({ provider: "anthropic" }),
+    );
+    expect(event.provider).toBe("anthropic");
+  });
+
+  test("extracts model + inputTokens + stopReason from a real Anthropic payload", () => {
+    const event = projectLogRowToCompactionTrailEvent(
+      fakeLogRow({
+        provider: "anthropic",
+        requestPayload: JSON.stringify({
+          model: "claude-sonnet-4-5",
+          messages: [{ role: "user", content: "Summarize the prior context." }],
+        }),
+        responsePayload: JSON.stringify({
+          type: "message",
+          model: "claude-sonnet-4-5",
+          role: "assistant",
+          content: [{ type: "text", text: "Summary text…" }],
+          stop_reason: "end_turn",
+          usage: { input_tokens: 12_000, output_tokens: 800 },
+        }),
+      }),
+    );
+    expect(event.model).toBe("claude-sonnet-4-5");
+    expect(event.provider).toBe("anthropic");
+    expect(event.inputTokens).toBe(12_000);
+    expect(event.outputTokens).toBe(800);
+    expect(event.stopReason).toBe("end_turn");
+  });
+
+  test("tolerates non-JSON payloads without throwing (falls back to nulls)", () => {
+    const event = projectLogRowToCompactionTrailEvent(
+      fakeLogRow({
+        requestPayload: "not-json{{{",
+        responsePayload: "<html>nope</html>",
+      }),
+    );
+    expect(event.id).toBe("log-default");
+    expect(event.model).toBeNull();
+    expect(event.inputTokens).toBeNull();
+  });
+});

package/src/runtime/routes/__tests__/conversation-list-routes.test.ts

@@ -0,0 +1,237 @@
+/**
+ * Tests for the listConversations route handler — focused on the
+ * `archiveStatus` query param introduced to keep archived rows out of the
+ * default sidebar restore. Other handlers in the file (seen/unread/get)
+ * are covered transitively by `conversation-sync-tags.test.ts`.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+// Avoid spinning up the real event hub for the pinned/groups branches.
+mock.module("../../assistant-event-hub.js", () => ({
+  assistantEventHub: {
+    publish: async () => {},
+    subscribe: () => () => {},
+  },
+  broadcastMessage: () => {},
+}));
+
+import { findConversation } from "../../../daemon/conversation-store.js";
+import { createConversation } from "../../../memory/conversation-crud.js";
+import { getDb } from "../../../memory/db-connection.js";
+import { initializeDb } from "../../../memory/db-init.js";
+import { rawRun } from "../../../memory/raw-query.js";
+import { conversations } from "../../../memory/schema.js";
+import { ROUTES as CONVERSATION_LIST_ROUTES } from "../conversation-list-routes.js";
+import { BadRequestError } from "../errors.js";
+import type { RouteDefinition } from "../types.js";
+
+// ---------------------------------------------------------------------------
+// DB bootstrap
+// ---------------------------------------------------------------------------
+
+initializeDb();
+
+function clearConversations(): void {
+  getDb().delete(conversations).run();
+}
+
+function seedArchived(title: string): string {
+  const conv = createConversation({ title });
+  rawRun(
+    "UPDATE conversations SET archived_at = ? WHERE id = ?",
+    Date.now(),
+    conv.id,
+  );
+  return conv.id;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+interface ConversationSummary {
+  id: string;
+  title: string;
+  archivedAt?: number;
+}
+
+interface ListResponse {
+  conversations: ConversationSummary[];
+  nextOffset: number;
+  hasMore: boolean;
+  groups?: unknown[];
+}
+
+function findHandler(routes: RouteDefinition[], operationId: string) {
+  const route = routes.find((r) => r.operationId === operationId);
+  if (!route) throw new Error(`Route ${operationId} not found`);
+  return route.handler;
+}
+
+const listHandler = findHandler(CONVERSATION_LIST_ROUTES, "listConversations");
+
+function invoke(queryParams: Record<string, string> = {}) {
+  return listHandler({ queryParams }) as ListResponse | Promise<ListResponse>;
+}
+
+// Sanity guard — `findConversation` is a daemon-store side-effect call in the
+// handler. Confirm it returns undefined for our cold seed rows so the assert
+// doesn't accidentally rely on in-memory residency.
+const _findConversationSentinel = findConversation;
+void _findConversationSentinel;
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("GET /v1/conversations — archiveStatus", () => {
+  beforeEach(() => {
+    clearConversations();
+  });
+
+  test("default response omits archived rows", async () => {
+    createConversation("live-1");
+    seedArchived("archived-1");
+
+    const result = (await invoke()) as ListResponse;
+
+    expect(result.conversations).toHaveLength(1);
+    expect(result.conversations[0]!.title).toBe("live-1");
+    expect(result.hasMore).toBe(false);
+  });
+
+  test("archiveStatus=archived returns only archived rows", async () => {
+    createConversation("live-1");
+    seedArchived("archived-1");
+    seedArchived("archived-2");
+
+    const result = (await invoke({
+      archiveStatus: "archived",
+    })) as ListResponse;
+
+    expect(result.conversations).toHaveLength(2);
+    const titles = result.conversations.map((c) => c.title).sort();
+    expect(titles).toEqual(["archived-1", "archived-2"]);
+  });
+
+  test("archiveStatus=all returns active and archived rows", async () => {
+    createConversation("live-1");
+    seedArchived("archived-1");
+
+    const result = (await invoke({ archiveStatus: "all" })) as ListResponse;
+
+    expect(result.conversations).toHaveLength(2);
+    const titles = result.conversations.map((c) => c.title).sort();
+    expect(titles).toEqual(["archived-1", "live-1"]);
+  });
+
+  test("hasMore reflects the archived-only total count, not the full table", async () => {
+    // 2 live rows, 1 archived. With limit=1 on the archived view there is
+    // no second page even though the table contains three rows total.
+    createConversation("live-1");
+    createConversation("live-2");
+    seedArchived("archived-1");
+
+    const result = (await invoke({
+      archiveStatus: "archived",
+      limit: "1",
+    })) as ListResponse;
+
+    expect(result.conversations).toHaveLength(1);
+    expect(result.conversations[0]!.title).toBe("archived-1");
+    expect(result.hasMore).toBe(false);
+  });
+
+  test("archived view skips pinned-row injection on first page", async () => {
+    // GIVEN a pinned-but-archived row that would otherwise be force-included
+    // on offset=0 of the active view.
+    const pinned = createConversation("pinned-archived");
+    rawRun("UPDATE conversations SET is_pinned = 1 WHERE id = ?", pinned.id);
+    rawRun(
+      "UPDATE conversations SET archived_at = ? WHERE id = ?",
+      Date.now(),
+      pinned.id,
+    );
+
+    // AND a live archived row to make sure the archived list isn't empty.
+    seedArchived("archived-live");
+
+    const result = (await invoke({
+      archiveStatus: "archived",
+    })) as ListResponse;
+
+    expect(result.conversations.map((c) => c.title).sort()).toEqual([
+      "archived-live",
+      "pinned-archived",
+    ]);
+  });
+});
+
+describe("GET /v1/conversations — conversationType", () => {
+  beforeEach(() => {
+    clearConversations();
+  });
+
+  test("default response returns foreground rows only", async () => {
+    // GIVEN a foreground, a background, and a scheduled conversation
+    createConversation("foreground-1");
+    createConversation({ title: "bg-1", conversationType: "background" });
+    createConversation({ title: "sched-1", conversationType: "scheduled" });
+
+    // WHEN listing without a conversationType filter
+    const result = (await invoke()) as ListResponse;
+
+    // THEN only the foreground row is returned
+    expect(result.conversations.map((c) => c.title)).toEqual(["foreground-1"]);
+  });
+
+  test("conversationType=background returns background and scheduled (umbrella)", async () => {
+    // GIVEN a foreground, a background, and a scheduled conversation
+    createConversation("foreground-1");
+    createConversation({ title: "bg-1", conversationType: "background" });
+    createConversation({ title: "sched-1", conversationType: "scheduled" });
+
+    // WHEN listing with conversationType=background
+    const result = (await invoke({
+      conversationType: "background",
+    })) as ListResponse;
+
+    // THEN both the background and scheduled rows are returned
+    expect(result.conversations.map((c) => c.title).sort()).toEqual([
+      "bg-1",
+      "sched-1",
+    ]);
+  });
+
+  test("conversationType=scheduled returns scheduled rows only", async () => {
+    // GIVEN a foreground, a background, and a scheduled conversation
+    createConversation("foreground-1");
+    createConversation({ title: "bg-1", conversationType: "background" });
+    createConversation({ title: "sched-1", conversationType: "scheduled" });
+
+    // WHEN listing with conversationType=scheduled
+    const result = (await invoke({
+      conversationType: "scheduled",
+    })) as ListResponse;
+
+    // THEN only the scheduled row is returned (background is excluded)
+    expect(result.conversations.map((c) => c.title)).toEqual(["sched-1"]);
+  });
+
+  test("unknown conversationType is rejected with a 400", async () => {
+    // GIVEN a request with an unrecognized conversationType
+    // WHEN listing — THEN it throws a BadRequestError (400) instead of
+    // silently falling back to the foreground list
+    expect(() => invoke({ conversationType: "private" })).toThrow(
+      BadRequestError,
+    );
+  });
+});