@vellumai/assistant 0.8.6 → 0.8.7

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

@@ -39,24 +39,24 @@ import type { LogRow } from "../../../memory/llm-request-log-store.js";
 interface FakeSourceState {
   conversation: { id: string } | null;
   selectedCall: LogRow | null;
-  previousNonCompactionCallCreatedAt: number | null;
+  turnBounds: { startTime: number; endTime: number } | null;
   compactionLogs: LogRow[];
 }
 
 const state: FakeSourceState = {
   conversation: null,
   selectedCall: null,
-  previousNonCompactionCallCreatedAt: null,
+  turnBounds: null,
   compactionLogs: [],
 };
 
-// Records the inputs the handler passed to the source so tests can
-// pin the windowing plumbing without relying on the projection.
+// 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[],
-  getPreviousNonCompactionCallCreatedAtArgs: [] as Array<{
+  getTurnTimeBoundsArgs: [] as Array<{
     conversationId: string;
-    beforeCreatedAt: number;
+    messageCreatedAt: number;
   }>,
   getCompactionLogsBetweenArgs: [] as Array<{
     conversationId: string;
@@ -70,6 +70,13 @@ mock.module("../../../memory/conversation-crud.js", () => ({
     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" })),
 }));
 
@@ -81,16 +88,6 @@ mock.module("../../../memory/llm-request-log-source.js", () => ({
     },
     getRequestLogsByMessageId: async () => [],
     getRequestLogsByConversationId: async () => [],
-    getPreviousNonCompactionCallCreatedAt: async (
-      conversationId: string,
-      beforeCreatedAt: number,
-    ) => {
-      sourceCalls.getPreviousNonCompactionCallCreatedAtArgs.push({
-        conversationId,
-        beforeCreatedAt,
-      });
-      return state.previousNonCompactionCallCreatedAt;
-    },
     getCompactionLogsBetween: async (
       conversationId: string,
       afterCreatedAt: number | null,
@@ -107,7 +104,10 @@ mock.module("../../../memory/llm-request-log-source.js", () => ({
 }));
 
 // Imported AFTER the mocks so the handler picks up the fakes.
-import { projectLogRowToCompactionTrailEvent,ROUTES } from "../conversation-compaction-routes.js";
+import {
+  projectLogRowToCompactionTrailEvent,
+  ROUTES,
+} from "../conversation-compaction-routes.js";
 import { BadRequestError, NotFoundError } from "../errors.js";
 
 const route = ROUTES.find(
@@ -135,10 +135,10 @@ function fakeLogRow(overrides: Partial<LogRow> = {}): LogRow {
 beforeEach(() => {
   state.conversation = null;
   state.selectedCall = null;
-  state.previousNonCompactionCallCreatedAt = null;
+  state.turnBounds = null;
   state.compactionLogs = [];
   sourceCalls.getRequestLogByIdArgs.length = 0;
-  sourceCalls.getPreviousNonCompactionCallCreatedAtArgs.length = 0;
+  sourceCalls.getTurnTimeBoundsArgs.length = 0;
   sourceCalls.getCompactionLogsBetweenArgs.length = 0;
 });
 
@@ -151,7 +151,7 @@ describe("conversation-compaction-routes — registration", () => {
     expect(route).toBeDefined();
     expect(route.method).toBe("GET");
     expect(route.endpoint).toBe("conversations/:id/compaction");
-    expect(route.policyKey).toBe("conversations/compaction");
+    expect(route.policy?.requiredScopes).toContain("chat.read");
   });
 });
 
@@ -215,14 +215,15 @@ describe("handleGetCompactionTrail — request-shape errors", () => {
 // ---------------------------------------------------------------------
 
 describe("handleGetCompactionTrail — happy path", () => {
-  test("forwards both window bounds to the source (prior call as floor, selected call as ceiling)", async () => {
+  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,
     });
-    state.previousNonCompactionCallCreatedAt = 2000;
+    // Selected call sits inside a turn that runs [2000, 9000].
+    state.turnBounds = { startTime: 2000, endTime: 9000 };
     state.compactionLogs = [];
 
     await handler({
@@ -231,27 +232,56 @@ describe("handleGetCompactionTrail — happy path", () => {
     });
 
     expect(sourceCalls.getRequestLogByIdArgs).toEqual(["call-selected"]);
-    expect(sourceCalls.getPreviousNonCompactionCallCreatedAtArgs).toEqual([
-      { conversationId: "conv-1", beforeCreatedAt: 5000 },
+    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: 2000, beforeCreatedAt: 5000 },
+      { conversationId: "conv-1", afterCreatedAt: 1999, beforeCreatedAt: 9001 },
     ]);
   });
 
-  test("passes a null floor when the selected call is the first real call in the conversation", async () => {
+  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-first",
+      id: "call-solo",
       conversationId: "conv-1",
       createdAt: 5000,
     });
-    state.previousNonCompactionCallCreatedAt = null;
+    state.turnBounds = null;
     state.compactionLogs = [];
 
     await handler({
       pathParams: { id: "conv-1" },
-      queryParams: { callId: "call-first" },
+      queryParams: { callId: "call-solo" },
     });
 
     expect(sourceCalls.getCompactionLogsBetweenArgs).toEqual([
@@ -266,7 +296,7 @@ describe("handleGetCompactionTrail — happy path", () => {
       conversationId: "conv-1",
       createdAt: 5000,
     });
-    state.previousNonCompactionCallCreatedAt = 2000;
+    state.turnBounds = { startTime: 2000, endTime: 9000 };
     state.compactionLogs = [];
 
     const result = await handler({
@@ -283,7 +313,7 @@ describe("handleGetCompactionTrail — happy path", () => {
       conversationId: "conv-1",
       createdAt: 9000,
     });
-    state.previousNonCompactionCallCreatedAt = 500;
+    state.turnBounds = { startTime: 500, endTime: 10_000 };
     state.compactionLogs = [
       fakeLogRow({
         id: "compaction-1",
@@ -307,7 +337,7 @@ describe("handleGetCompactionTrail — happy path", () => {
     // 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([
+    expect(Object.keys(result.events[0] as object).sort()).toEqual([
       "createdAt",
       "durationMs",
       "estimatedCostUsd",

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

package/src/runtime/routes/__tests__/inference-provider-connection-routes.test.ts

@@ -33,7 +33,8 @@ import { setOverridesForTesting } from "../../../__tests__/feature-flag-test-hel
 import { getDb } from "../../../memory/db-connection.js";
 import { initializeDb } from "../../../memory/db-init.js";
 import { providerConnections } from "../../../memory/schema/inference.js";
-import { getPolicy } from "../../auth/route-policy.js";
+// Route policies are read directly off `route.policy` now (ATL-315
+// followup) — no registry lookup.
 import { BadRequestError, ConflictError, NotFoundError } from "../errors.js";
 import { ROUTES } from "../inference-provider-connection-routes.js";
 import type { RouteDefinition, RouteHandlerArgs } from "../types.js";
@@ -887,44 +888,34 @@ describe("isManaged flag on connection responses", () => {
 
 // ── Auth / route-policy wiring ────────────────────────────────────────────────
 
-describe("Route policy registrations", () => {
+describe("Route policy declarations", () => {
   test("GET list has settings.read policy", () => {
     const route = findRoute("inference_provider_connections_list");
-    const policyKey = `${route.policyKey ?? "inference/provider-connections"}:GET`;
-    const policy = getPolicy(policyKey);
-    expect(policy).toBeDefined();
-    expect(policy?.requiredScopes).toContain("settings.read");
+    expect(route.policy).not.toBeNull();
+    expect(route.policy!.requiredScopes).toContain("settings.read");
   });
 
   test("POST create has settings.write policy", () => {
     const route = findRoute("inference_provider_connections_create");
-    const policyKey = `${route.policyKey ?? "inference/provider-connections"}:POST`;
-    const policy = getPolicy(policyKey);
-    expect(policy).toBeDefined();
-    expect(policy?.requiredScopes).toContain("settings.write");
+    expect(route.policy).not.toBeNull();
+    expect(route.policy!.requiredScopes).toContain("settings.write");
   });
 
   test("GET single has settings.read policy", () => {
     const route = findRoute("inference_provider_connections_get");
-    const policyKey = `${route.policyKey ?? "inference/provider-connections/detail"}:GET`;
-    const policy = getPolicy(policyKey);
-    expect(policy).toBeDefined();
-    expect(policy?.requiredScopes).toContain("settings.read");
+    expect(route.policy).not.toBeNull();
+    expect(route.policy!.requiredScopes).toContain("settings.read");
   });
 
   test("PATCH update has settings.write policy", () => {
     const route = findRoute("inference_provider_connections_update");
-    const policyKey = `${route.policyKey ?? "inference/provider-connections/detail"}:PATCH`;
-    const policy = getPolicy(policyKey);
-    expect(policy).toBeDefined();
-    expect(policy?.requiredScopes).toContain("settings.write");
+    expect(route.policy).not.toBeNull();
+    expect(route.policy!.requiredScopes).toContain("settings.write");
   });
 
   test("DELETE has settings.write policy", () => {
     const route = findRoute("inference_provider_connections_delete");
-    const policyKey = `${route.policyKey ?? "inference/provider-connections/detail"}:DELETE`;
-    const policy = getPolicy(policyKey);
-    expect(policy).toBeDefined();
-    expect(policy?.requiredScopes).toContain("settings.write");
+    expect(route.policy).not.toBeNull();
+    expect(route.policy!.requiredScopes).toContain("settings.write");
   });
 });

package/src/runtime/routes/__tests__/memory-v2-simulate-route.test.ts

@@ -192,8 +192,13 @@ const { invalidatePageIndex } =
 function makeProvider(pageIds: number[]): Provider {
   return {
     name: "stub",
-    sendMessage: async (messages, tools, systemPrompt, options) => {
-      providerCalls.push({ messages, tools, systemPrompt, options });
+    sendMessage: async (messages, options) => {
+      providerCalls.push({
+        messages,
+        tools: options?.tools,
+        systemPrompt: options?.systemPrompt,
+        options,
+      });
       return {
         model: "stub-model",
         stopReason: "tool_use",

package/src/runtime/routes/__tests__/sanity-routes.test.ts

@@ -264,17 +264,17 @@ describe("sanity_connect", () => {
 });
 
 // ---------------------------------------------------------------------------
-// Policy key verification
+// Route policy verification
 // ---------------------------------------------------------------------------
 
-describe("route policy keys", () => {
-  test("sanity_discover uses policyKey: secrets", () => {
+describe("route policies", () => {
+  test("sanity_discover requires settings.write (secrets-grade)", () => {
     const route = ROUTES.find((r) => r.operationId === "sanity_discover");
-    expect(route?.policyKey).toBe("secrets");
+    expect(route?.policy?.requiredScopes).toContain("settings.write");
   });
 
-  test("sanity_connect uses policyKey: secrets", () => {
+  test("sanity_connect requires settings.write (secrets-grade)", () => {
     const route = ROUTES.find((r) => r.operationId === "sanity_connect");
-    expect(route?.policyKey).toBe("secrets");
+    expect(route?.policy?.requiredScopes).toContain("settings.write");
   });
 });

package/src/runtime/routes/__tests__/stt-routes.test.ts

@@ -104,15 +104,15 @@ describe("stt-routes", () => {
 
     const providers = getRoute("stt/providers");
     expect(providers.method).toBe("GET");
-    expect(providers.policyKey).toBe("stt/providers");
+    expect(providers.policy?.requiredScopes).toContain("settings.read");
 
     const transcribe = getRoute("stt/transcribe");
     expect(transcribe.method).toBe("POST");
-    expect(transcribe.policyKey).toBe("stt/transcribe");
+    expect(transcribe.policy?.requiredScopes).toContain("chat.write");
 
     const transcribeFile = getRoute("stt/transcribe-file");
     expect(transcribeFile.method).toBe("POST");
-    expect(transcribeFile.policyKey).toBe("stt/transcribe-file");
+    expect(transcribeFile.policy?.requiredScopes).toContain("chat.write");
   });
 
   // -- Success path ---------------------------------------------------------

package/src/runtime/routes/__tests__/suggest-trust-rule-routes.test.ts

@@ -169,8 +169,11 @@ describe("suggestTrustRuleRoute", () => {
 
       expect(mockSendMessage).toHaveBeenCalledTimes(1);
       const callArgs = mockSendMessage.mock.calls[0] as unknown[];
-      const options = callArgs[3] as {
-        config: { callSite: string; tool_choice: { type: string; name: string } };
+      const options = callArgs[1] as {
+        config: {
+          callSite: string;
+          tool_choice: { type: string; name: string };
+        };
       };
       expect(options.config.callSite).toBe("trustRuleSuggestion");
       expect(options.config.tool_choice).toEqual({

package/src/runtime/routes/__tests__/tts-routes.test.ts

@@ -169,15 +169,15 @@ describe("tts-routes", () => {
 
     const msgTts = getRoute("messages/:messageId/tts");
     expect(msgTts.method).toBe("POST");
-    expect(msgTts.policyKey).toBe("messages/tts");
+    expect(msgTts.policy?.requiredScopes).toContain("chat.read");
 
     const synthesize = getRoute("tts/synthesize");
     expect(synthesize.method).toBe("POST");
-    expect(synthesize.policyKey).toBe("tts/synthesize");
+    expect(synthesize.policy?.requiredScopes).toContain("chat.read");
 
     const synthesizeCli = getRoute("tts/synthesize-cli");
     expect(synthesizeCli.method).toBe("POST");
-    expect(synthesizeCli.policyKey).toBe("tts/synthesize-cli");
+    expect(synthesizeCli.policy?.requiredScopes).toContain("chat.read");
   });
 
   // -- Feature flag gating --------------------------------------------------