@vellumai/assistant 0.8.6 → 0.8.7-dev.202606052118.34cd356

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-registry.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__/conversation-query-routes.test.ts

@@ -175,7 +175,10 @@ function seedRequestLog(
     .run();
 }
 
-function seedConversationKey(conversationKey: string, conversationId: string): void {
+function seedConversationKey(
+  conversationKey: string,
+  conversationId: string,
+): void {
   getDb()
     .insert(conversationKeys)
     .values({
@@ -776,6 +779,33 @@ describe("PUT /v1/config/llm/profiles/:name", () => {
     });
   });
 
+  test("saves a profile using the minimax provider (regression #32404)", async () => {
+    // minimax is exposed as a first-class provider in the catalog, so saving
+    // a profile bound to it must pass ProfileEntry validation rather than 400.
+    const result = await replaceProfileRoute.handler({
+      pathParams: { name: "custom" },
+      body: {
+        provider: "minimax",
+        model: "MiniMax-M2.7",
+      },
+    });
+
+    expect(result).toEqual({ ok: true });
+    const savedProfile = (
+      savedRawConfig?.llm as {
+        profiles: Record<string, Record<string, unknown>>;
+      }
+    ).profiles.custom;
+
+    expect(savedProfile.provider).toBe("minimax");
+    expect(savedProfile.model).toBe("MiniMax-M2.7");
+    expect(savedProfile.provider_connection).toBe("minimax-personal");
+
+    const conn = getConnection(getDb(), "minimax-personal");
+    expect(conn).not.toBeNull();
+    expect(conn!.provider).toBe("minimax");
+  });
+
   describe("managed profile guard", () => {
     beforeEach(() => {
       // Seed a managed profile alongside the existing custom one.

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-routes.test.ts

@@ -155,7 +155,11 @@ describe("memory_v2_ema_scores route registration", () => {
     expect(route!.tags).toContain("memory");
     // Schema rejects unknown keys so accidental request-body fields fail
     // loudly during route adapter parsing rather than silently propagating.
-    expect(() => route!.requestBody!.parse({ extra: true })).toThrow();
-    expect(() => route!.requestBody!.parse({})).not.toThrow();
+    const requestBody = route!.requestBody;
+    if (!requestBody || !("parse" in requestBody)) {
+      throw new Error("expected a JSON (Zod) request-body schema");
+    }
+    expect(() => requestBody.parse({ extra: true })).toThrow();
+    expect(() => requestBody.parse({})).not.toThrow();
   });
 });

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__/surface-action-routes.test.ts

@@ -42,7 +42,7 @@ const findBySurfaceCalls: string[] = [];
 const getOrCreateCalls: string[] = [];
 const rawGetCalls: Array<{ sql: string; params: unknown[] }> = [];
 
-mock.module("../../../daemon/conversation-store.js", () => ({
+mock.module("../../../daemon/conversation-registry.js", () => ({
   findConversation: (id: string) => {
     findConvCalls.push(id);
     return memoryById ?? undefined;
@@ -51,6 +51,9 @@ mock.module("../../../daemon/conversation-store.js", () => ({
     findBySurfaceCalls.push(surfaceId);
     return memoryBySurface ?? undefined;
   },
+}));
+
+mock.module("../../../daemon/conversation-store.js", () => ({
   getOrCreateConversation: async (id: string) => {
     getOrCreateCalls.push(id);
     if (!rehydrated) {
@@ -183,9 +186,7 @@ describe("triggerSurfaceAction handler", () => {
     // SQL must filter the messages table by ui_surface payload pattern.
     expect(rawGetCalls[0]!.sql).toContain("FROM messages");
     expect(rawGetCalls[0]!.sql).toContain("LIKE");
-    expect(rawGetCalls[0]!.params).toEqual([
-      `%"surfaceId":"surf-evicted"%`,
-    ]);
+    expect(rawGetCalls[0]!.params).toEqual([`%"surfaceId":"surf-evicted"%`]);
     expect(getOrCreateCalls).toEqual(["conv-from-db"]);
     expect(rehydrated.surfaceActionCalls).toEqual([
       { surfaceId: "surf-evicted", actionId: "act-3", data: undefined },

package/src/runtime/routes/__tests__/surface-content-routes.test.ts

@@ -51,7 +51,7 @@ const findBySurfaceCalls: string[] = [];
 const getOrCreateCalls: string[] = [];
 const rawGetCalls: Array<{ sql: string; params: unknown[] }> = [];
 
-mock.module("../../../daemon/conversation-store.js", () => ({
+mock.module("../../../daemon/conversation-registry.js", () => ({
   findConversation: (id: string) => {
     findConvCalls.push(id);
     return memoryById ?? undefined;
@@ -60,6 +60,9 @@ mock.module("../../../daemon/conversation-store.js", () => ({
     findBySurfaceCalls.push(surfaceId);
     return undefined;
   },
+}));
+
+mock.module("../../../daemon/conversation-store.js", () => ({
   getOrCreateConversation: async (id: string) => {
     getOrCreateCalls.push(id);
     if (!rehydrated) {

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

@@ -164,20 +164,24 @@ afterEach(() => {
 // ---------------------------------------------------------------------------
 
 describe("tts-routes", () => {
-  test("exports route definitions for messages/:messageId/tts, tts/synthesize, and tts/synthesize-cli", () => {
-    expect(ROUTES).toHaveLength(3);
+  test("exports route definitions for tts/providers, messages/:messageId/tts, tts/synthesize, and tts/synthesize-cli", () => {
+    expect(ROUTES).toHaveLength(4);
+
+    const providers = getRoute("tts/providers");
+    expect(providers.method).toBe("GET");
+    expect(providers.policy?.requiredScopes).toContain("settings.read");
 
     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 --------------------------------------------------