@vellumai/assistant 0.11.3 → 0.11.4-dev.202608190019.b94dbf2

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

@@ -25,14 +25,14 @@ import { createConversation } from "../../../persistence/conversation-crud.js";
 import { getDb } from "../../../persistence/db-connection.js";
 import { initializeDb } from "../../../persistence/db-init.js";
 import { createGroup } from "../../../persistence/group-crud.js";
-import { rawRun } from "../../../persistence/raw-query.js";
+import { rawExec, rawRun } from "../../../persistence/raw-query.js";
 import {
   conversationAssistantAttentionState,
   conversationAttentionEvents,
   conversations,
 } from "../../../persistence/schema/index.js";
 import { ROUTES as CONVERSATION_LIST_ROUTES } from "../conversation-list-routes.js";
-import { BadRequestError } from "../errors.js";
+import { BadRequestError, NotFoundError } from "../errors.js";
 import type { RouteDefinition } from "../types.js";
 
 // ---------------------------------------------------------------------------
@@ -246,6 +246,42 @@ describe("GET /v1/conversations — conversationType", () => {
   });
 });
 
+describe("GET /v1/conversations/:id", () => {
+  const getHandler = findHandler(CONVERSATION_LIST_ROUTES, "getConversation");
+
+  beforeEach(() => {
+    clearConversations();
+  });
+
+  test("serves a listed conversation", () => {
+    const conv = createConversation({ title: "listed" });
+
+    const detail = getHandler({ pathParams: { id: conv.id } }) as {
+      conversation: { id: string; conversationType: string };
+    };
+
+    expect(detail.conversation.id).toBe(conv.id);
+    expect(detail.conversation.conversationType).toBe("standard");
+  });
+
+  test("does not serve a legacy private row the listing hides", () => {
+    // "private" is not a creatable type (legacy rows only); every listing
+    // hides it by type and the wire type collapses it to "standard", so a
+    // client holding only a stale id must get the same answer the listing
+    // gives: not there.
+    const conv = createConversation({ title: "hidden" });
+    rawRun(
+      "test:makePrivate",
+      "UPDATE conversations SET conversation_type = 'private' WHERE id = ?",
+      conv.id,
+    );
+
+    expect(() => getHandler({ pathParams: { id: conv.id } })).toThrow(
+      NotFoundError,
+    );
+  });
+});
+
 describe("GET /v1/conversations with groupId", () => {
   function seedInGroup(title: string, groupId: string): string {
     const conv = createConversation(title);
@@ -514,6 +550,272 @@ describe("GET /v1/conversations with groupId", () => {
   });
 });
 
+describe("GET /v1/conversations with needsAttention", () => {
+  function seedUnseen(conversationId: string): void {
+    projectAssistantMessage({
+      conversationId,
+      messageId: `msg-${conversationId}`,
+      messageAt: Date.now(),
+    });
+  }
+
+  function markSeen(conversationId: string): void {
+    recordConversationSeenSignal({
+      conversationId,
+      sourceChannel: "vellum",
+      signalType: "macos_conversation_opened",
+      confidence: "explicit",
+      source: "test",
+    });
+  }
+
+  beforeEach(() => {
+    getDb().delete(conversationAttentionEvents).run();
+    getDb().delete(conversationAssistantAttentionState).run();
+    clearConversations();
+  });
+
+  test("returns only conversations with an unseen latest assistant message", async () => {
+    const unseen = createConversation("needs-attention");
+    seedUnseen(unseen.id);
+    const seen = createConversation("already-seen");
+    seedUnseen(seen.id);
+    markSeen(seen.id);
+    // No attention projection at all: not unseen, so not returned. The
+    // filter's inner join is what excludes it; a left join would leak it.
+    createConversation("never-projected");
+
+    const result = await invoke({ needsAttention: "true" });
+
+    expect(result.conversations.map((c) => c.title)).toEqual([
+      "needs-attention",
+    ]);
+  });
+
+  test("omitting the filter leaves every list unchanged, join and all", async () => {
+    /* The sensitivity check for the conditional join: with the filter off,
+       rows with no attention row must still be listed. If the join were
+       applied unconditionally, "never-projected" would vanish from the
+       plain list, which is every list the app has today. */
+    const unseen = createConversation("has-attention-row");
+    seedUnseen(unseen.id);
+    createConversation("never-projected");
+
+    const result = await invoke();
+
+    expect(result.conversations.map((c) => c.title).sort()).toEqual([
+      "has-attention-row",
+      "never-projected",
+    ]);
+  });
+
+  test("hasMore and the total describe the filtered set, not the whole table", async () => {
+    /* countConversations reads through the same where AND the same join;
+       a page and its total have to agree or the client's hasMore lies. */
+    for (let i = 0; i < 3; i++) {
+      const c = createConversation(`unseen-${i}`);
+      seedUnseen(c.id);
+    }
+    for (let i = 0; i < 5; i++) {
+      createConversation(`quiet-${i}`);
+    }
+
+    const page = await invoke({ needsAttention: "true", limit: "2" });
+
+    expect(page.conversations).toHaveLength(2);
+    expect(page.hasMore).toBe(true);
+    const rest = await invoke({
+      needsAttention: "true",
+      limit: "2",
+      offset: "2",
+    });
+    expect(rest.conversations).toHaveLength(1);
+    expect(rest.hasMore).toBe(false);
+  });
+
+  test("an attention-scoped first page has no pinned rows appended to it", async () => {
+    /* Same rule as the group-scoped page: the pinned injection exists for
+       a client reading Pinned out of the unfiltered list, and a caller
+       that asked for the unseen subset is not that client. A seen pinned
+       row appended here would be a row outside the filter, on a page whose
+       hasMore was computed from the filtered count. */
+    const unseen = createConversation("unseen-only");
+    seedUnseen(unseen.id);
+    const pinnedSeen = createConversation("pinned-and-seen");
+    rawRun(
+      "test:pinConversation",
+      "UPDATE conversations SET is_pinned = 1, group_id = 'system:pinned' WHERE id = ?",
+      pinnedSeen.id,
+    );
+
+    const result = await invoke({ needsAttention: "true" });
+
+    expect(result.conversations.map((c) => c.title)).toEqual(["unseen-only"]);
+  });
+
+  test("composes with the other filters", async () => {
+    const group = createGroup("Work");
+    const inGroupUnseen = createConversation("in-group-unseen");
+    seedUnseen(inGroupUnseen.id);
+    rawRun(
+      "test:fileInGroup",
+      "UPDATE conversations SET group_id = ? WHERE id = ?",
+      group.id,
+      inGroupUnseen.id,
+    );
+    const outOfGroupUnseen = createConversation("out-of-group-unseen");
+    seedUnseen(outOfGroupUnseen.id);
+
+    const result = await invoke({ needsAttention: "true", groupId: group.id });
+
+    expect(result.conversations.map((c) => c.title)).toEqual([
+      "in-group-unseen",
+    ]);
+  });
+
+  test('any value other than "true" is rejected with a 400', () => {
+    /* Same posture as conversationType: silently reading a typo or a newer
+       client's value as "no filter" would hand back the full list where a
+       subset was asked for, and that skew is invisible to the client. */
+    for (const bad of ["false", "1", "yes", "TRUE"]) {
+      expect(() => invoke({ needsAttention: bad })).toThrow(BadRequestError);
+    }
+  });
+});
+
+describe("GET /v1/conversations with foregroundOnly", () => {
+  function fileIntoGroup(conversationId: string, groupId: string): void {
+    rawRun(
+      "test:fileIntoGroup",
+      "UPDATE conversations SET group_id = ? WHERE id = ?",
+      groupId,
+      conversationId,
+    );
+  }
+
+  function surface(conversationId: string): void {
+    rawRun(
+      "test:surfaceConversation",
+      "UPDATE conversations SET surfaced_at = ? WHERE id = ?",
+      Date.now(),
+      conversationId,
+    );
+  }
+
+  beforeEach(() => {
+    clearConversations();
+  });
+
+  test("drops the automated runs the standard listing admits through a custom group", async () => {
+    /* The standard listing shows a background run filed in a custom group,
+       so a caller reading page one to find "the newest chat" can lead with
+       one; the filter is what lets that caller ask for chats alone. A
+       surfaced run is a chat for this purpose, exactly as the unread count
+       treats it. */
+    const group = createGroup("Work");
+    createConversation("plain-chat");
+    const bgInGroup = createConversation({
+      title: "bg-in-group",
+      conversationType: "background",
+    });
+    fileIntoGroup(bgInGroup.id, group.id);
+    const surfacedBg = createConversation({
+      title: "surfaced-bg",
+      conversationType: "background",
+    });
+    surface(surfacedBg.id);
+
+    const unfiltered = await invoke();
+    expect(unfiltered.conversations.map((c) => c.title).sort()).toEqual([
+      "bg-in-group",
+      "plain-chat",
+      "surfaced-bg",
+    ]);
+
+    const result = await invoke({ foregroundOnly: "true" });
+    expect(result.conversations.map((c) => c.title).sort()).toEqual([
+      "plain-chat",
+      "surfaced-bg",
+    ]);
+  });
+
+  test("hasMore and the total describe the filtered set, not the whole table", async () => {
+    /* The reason for the filter is a limit=1 read whose first row is the
+       answer; that read is only right if the page and its total come from
+       the same predicate. */
+    const group = createGroup("Work");
+    for (let i = 0; i < 3; i++) {
+      const bg = createConversation({
+        title: `bg-${i}`,
+        conversationType: "background",
+      });
+      fileIntoGroup(bg.id, group.id);
+    }
+    createConversation("the-only-chat");
+
+    const page = await invoke({ foregroundOnly: "true", limit: "1" });
+
+    expect(page.conversations.map((c) => c.title)).toEqual(["the-only-chat"]);
+    expect(page.hasMore).toBe(false);
+  });
+
+  test("a foreground-only first page has no pinned rows appended to it", async () => {
+    /* Same rule as the attention- and group-scoped pages: the injection is
+       for a client reading Pinned out of the unfiltered list, and a caller
+       that asked for the newest chat in one row is not that client. The
+       older pinned chat is a member of the filter, so only the injection
+       could put it on a limit=1 page. */
+    const older = createConversation("older-pinned-chat");
+    rawRun(
+      "test:pinConversation",
+      "UPDATE conversations SET is_pinned = 1, group_id = 'system:pinned', last_message_at = ? WHERE id = ?",
+      Date.now() - 60_000,
+      older.id,
+    );
+    const newer = createConversation("newest-chat");
+    rawRun(
+      "test:bumpRecency",
+      "UPDATE conversations SET last_message_at = ? WHERE id = ?",
+      Date.now(),
+      newer.id,
+    );
+
+    const unfiltered = await invoke({ limit: "1" });
+    expect(unfiltered.conversations.map((c) => c.title)).toEqual([
+      "newest-chat",
+      "older-pinned-chat",
+    ]);
+
+    const result = await invoke({ foregroundOnly: "true", limit: "1" });
+    expect(result.conversations.map((c) => c.title)).toEqual(["newest-chat"]);
+  });
+
+  test("composes with the other filters", async () => {
+    const group = createGroup("Work");
+    const chatInGroup = createConversation("chat-in-group");
+    fileIntoGroup(chatInGroup.id, group.id);
+    const bgInGroup = createConversation({
+      title: "bg-in-group",
+      conversationType: "background",
+    });
+    fileIntoGroup(bgInGroup.id, group.id);
+    createConversation("chat-outside");
+
+    const result = await invoke({
+      foregroundOnly: "true",
+      groupId: group.id,
+    });
+
+    expect(result.conversations.map((c) => c.title)).toEqual(["chat-in-group"]);
+  });
+
+  test('any value other than "true" is rejected with a 400', () => {
+    for (const bad of ["false", "1", "yes", "TRUE"]) {
+      expect(() => invoke({ foregroundOnly: bad })).toThrow(BadRequestError);
+    }
+  });
+});
+
 describe("GET /v1/conversations/unread-count", () => {
   const unreadCountHandler = findHandler(
     CONVERSATION_LIST_ROUTES,
@@ -782,3 +1084,221 @@ describe("GET /v1/conversations/unread-count", () => {
     expect(invokeUnreadCount()).toEqual({ count: 1 });
   });
 });
+
+describe("GET /v1/conversations/sections", () => {
+  const sectionsHandler = findHandler(
+    CONVERSATION_LIST_ROUTES,
+    "getConversationSections",
+  );
+
+  interface SectionRow {
+    kind: "pinned" | "group" | "channel" | "chats";
+    groupId?: string;
+    name?: string;
+    icon?: string | null;
+    sortPosition?: number;
+    channelId?: string;
+    total: number;
+    unread: number;
+  }
+
+  function invokeSections(): SectionRow[] {
+    return (sectionsHandler({}) as { sections: SectionRow[] }).sections;
+  }
+
+  function fileIntoGroup(conversationId: string, groupId: string): void {
+    rawRun(
+      "test:fileIntoGroup",
+      "UPDATE conversations SET group_id = ? WHERE id = ?",
+      groupId,
+      conversationId,
+    );
+  }
+
+  function stampChannel(conversationId: string, channel: string): void {
+    rawRun(
+      "test:stampChannel",
+      "UPDATE conversations SET origin_channel = ? WHERE id = ?",
+      channel,
+      conversationId,
+    );
+  }
+
+  function pin(conversationId: string): void {
+    rawRun(
+      "test:pinConversation",
+      "UPDATE conversations SET is_pinned = 1, group_id = 'system:pinned' WHERE id = ?",
+      conversationId,
+    );
+  }
+
+  function seedUnseen(conversationId: string): void {
+    projectAssistantMessage({
+      conversationId,
+      messageId: `msg-${conversationId}`,
+      messageAt: Date.now(),
+    });
+  }
+
+  beforeEach(() => {
+    clearConversations();
+  });
+
+  test("an empty conversation table yields Chats alone, at zero", () => {
+    // Chats is the leftover bucket and renders regardless, so its counts
+    // are part of the contract even when nothing exists.
+    expect(invokeSections()).toEqual([{ kind: "chats", total: 0, unread: 0 }]);
+  });
+
+  test("every section kind appears with its own totals", () => {
+    const pinned = createConversation({ title: "pinned-1" });
+    pin(pinned.id);
+    const group = createGroup("Sections Spread Group");
+    fileIntoGroup(createConversation({ title: "g-1" }).id, group.id);
+    fileIntoGroup(createConversation({ title: "g-2" }).id, group.id);
+    stampChannel(createConversation({ title: "slack-1" }).id, "slack");
+    createConversation({ title: "native-unstamped" });
+    stampChannel(createConversation({ title: "native-stamped" }).id, "vellum");
+
+    const sections = invokeSections();
+
+    expect(sections).toContainEqual({ kind: "pinned", total: 1, unread: 0 });
+    expect(sections).toContainEqual({
+      kind: "group",
+      groupId: group.id,
+      name: "Sections Spread Group",
+      icon: null,
+      sortPosition: group.sortPosition,
+      total: 2,
+      unread: 0,
+    });
+    expect(sections).toContainEqual({
+      kind: "channel",
+      channelId: "slack",
+      total: 1,
+      unread: 0,
+    });
+    // NULL origin_channel reads as native, exactly as the list filter reads
+    // it, so the stamped and unstamped native rows share the Chats bucket.
+    expect(sections).toContainEqual({ kind: "chats", total: 2, unread: 0 });
+  });
+
+  test("unread counts follow the seen state per section", () => {
+    const pinned = createConversation({ title: "pinned-seen" });
+    pin(pinned.id);
+    seedUnseen(pinned.id);
+    recordConversationSeenSignal({
+      conversationId: pinned.id,
+      sourceChannel: "vellum",
+      signalType: "macos_conversation_opened",
+      confidence: "explicit",
+      source: "test",
+    });
+
+    const group = createGroup("Sections Unread Group");
+    const unreadInGroup = createConversation({ title: "g-unread" });
+    fileIntoGroup(unreadInGroup.id, group.id);
+    seedUnseen(unreadInGroup.id);
+    // A member with no attention projection at all reads as seen.
+    fileIntoGroup(createConversation({ title: "g-quiet" }).id, group.id);
+
+    const chatsUnread = createConversation({ title: "chat-unread" });
+    seedUnseen(chatsUnread.id);
+
+    const sections = invokeSections();
+
+    expect(sections).toContainEqual({ kind: "pinned", total: 1, unread: 0 });
+    expect(sections).toContainEqual({
+      kind: "group",
+      groupId: group.id,
+      name: "Sections Unread Group",
+      icon: null,
+      sortPosition: group.sortPosition,
+      total: 2,
+      unread: 1,
+    });
+    expect(sections).toContainEqual({ kind: "chats", total: 1, unread: 1 });
+  });
+
+  test("a background row filed into a group counts toward total but never unread", () => {
+    // Mirrors the unread-count contract: the custom-group visibility arm
+    // admits the row into the section, and the not-background unread rule
+    // keeps it out of the badge.
+    const group = createGroup("Sections Background Group");
+    const bg = createConversation({
+      title: "bg-in-group",
+      conversationType: "background",
+    });
+    fileIntoGroup(bg.id, group.id);
+    seedUnseen(bg.id);
+
+    const sections = invokeSections();
+
+    expect(sections).toContainEqual({
+      kind: "group",
+      groupId: group.id,
+      name: "Sections Background Group",
+      icon: null,
+      sortPosition: group.sortPosition,
+      total: 1,
+      unread: 0,
+    });
+  });
+
+  test("an empty custom group gets no section", () => {
+    const group = createGroup("Sections Empty Group");
+
+    const sections = invokeSections();
+
+    expect(sections.some((s) => s.groupId === group.id)).toBe(false);
+  });
+
+  test("archived rows count toward no section", () => {
+    const group = createGroup("Sections Archived Group");
+    fileIntoGroup(seedArchived("archived-in-group"), group.id);
+
+    const sections = invokeSections();
+
+    expect(sections.some((s) => s.groupId === group.id)).toBe(false);
+  });
+
+  test("a dangling group id is skipped, not surfaced", () => {
+    /* Live write paths cannot create this state: group_id carries a foreign
+       key, and the placement write sanitizes unknown groups precisely to
+       avoid violating it. A restored snapshot can, though: in-place restore
+       swaps the SQLite file without running migrations in-process (the same
+       window that lets legacy private rows exist transiently), so the
+       fixture creates the state the way reality does, with enforcement off. */
+    rawExec("PRAGMA foreign_keys = OFF");
+    try {
+      fileIntoGroup(
+        createConversation({ title: "dangling" }).id,
+        "00000000-0000-4000-8000-00000000dead",
+      );
+    } finally {
+      rawExec("PRAGMA foreign_keys = ON");
+    }
+
+    const sections = invokeSections();
+
+    expect(sections.some((s) => s.kind === "group")).toBe(false);
+    // Grouped, so it does not leak into the ungrouped Chats bucket either.
+    expect(sections).toContainEqual({ kind: "chats", total: 0, unread: 0 });
+  });
+
+  test("an unsurfaced background row pinned by raw column writes stays invisible", () => {
+    // Standard-listing visibility admits a pinned background row only when
+    // it is surfaced (the pinned group fails the custom-group arm on its
+    // system: prefix), so it appears in neither the Pinned list nor the
+    // Pinned count.
+    const bg = createConversation({
+      title: "bg-pinned",
+      conversationType: "background",
+    });
+    pin(bg.id);
+
+    const sections = invokeSections();
+
+    expect(sections.some((s) => s.kind === "pinned")).toBe(false);
+  });
+});

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

@@ -1712,3 +1712,55 @@ describe("config invariant flag enrichment", () => {
     }
   });
 });
+
+describe("provider membership at the write choke point", () => {
+  const configPatchRoute = ROUTES.find(
+    (r) => r.operationId === "config_patch",
+  )!;
+
+  test("a pre-existing unknown provider does not block unrelated writes", async () => {
+    // Read tolerance means a stored entry-name provider is legal on disk;
+    // re-validating it on every write would make all later settings saves
+    // fail with no in-product repair path.
+    rawConfigFixture = {
+      llm: {
+        profiles: {
+          work: {
+            source: "user",
+            provider: "anthropic-work",
+            model: "claude-opus-4-8",
+          },
+        },
+      },
+    };
+    seedRawConfig();
+
+    await configPatchRoute.handler({
+      body: { llm: { callSites: { mainAgent: { maxTokens: 2048 } } } },
+    });
+
+    const llm = loadRawConfig().llm as {
+      callSites?: Record<string, { maxTokens?: number }>;
+      profiles?: Record<string, { provider?: string }>;
+    };
+    expect(llm.callSites?.mainAgent?.maxTokens).toBe(2048);
+    expect(llm.profiles?.work?.provider).toBe("anthropic-work");
+  });
+
+  test("introducing an unknown provider is rejected", async () => {
+    rawConfigFixture = { llm: {} };
+    seedRawConfig();
+
+    await expect(
+      configPatchRoute.handler({
+        body: {
+          llm: {
+            profiles: {
+              rogue: { source: "user", provider: "not-a-provider", model: "m" },
+            },
+          },
+        },
+      }),
+    ).rejects.toThrow(/Invalid provider/);
+  });
+});

package/src/runtime/routes/__tests__/default-provider-routes.test.ts

@@ -432,6 +432,31 @@ describe("PUT config/llm/default-provider", () => {
     expect(availability(result)).toEqual({ status: "ok" });
   });
 
+  test("chatgpt persists and resolves the canonical subscription row", async () => {
+    seedConnection({
+      name: "chatgpt-subscription",
+      provider: "chatgpt",
+      auth: {
+        type: "oauth_subscription",
+        credential: "credential/chatgpt/access_token",
+      },
+    });
+    secureKeyResults["credential/chatgpt/access_token"] = {
+      value: "token",
+      unreachable: false,
+    };
+
+    const result = (await put({ provider: "chatgpt" })) as Record<
+      string,
+      unknown
+    >;
+
+    expect(persistedDefaultProvider()).toEqual({ provider: "chatgpt" });
+    expect(result.provider).toBe("chatgpt");
+    expect(result.resolvedConnectionName).toBe("chatgpt-subscription");
+    expect(availability(result)).toEqual({ status: "ok" });
+  });
+
   test("persists an explicit connectionName", async () => {
     await put({ provider: "openai", connectionName: "work-openai" });
     expect(persistedDefaultProvider()).toEqual({
@@ -449,6 +474,42 @@ describe("PUT config/llm/default-provider", () => {
     expect(availability(result).status).toBe("missing_connection");
   });
 
+  test("a noncanonical pin on a routing identity → 400 naming the canonical row", async () => {
+    for (const [provider, canonical] of [
+      ["chatgpt", "chatgpt-subscription"],
+      ["vellum", "vellum"],
+    ] as const) {
+      const err = await put({
+        provider,
+        connectionName: "some-other-row",
+      }).catch((e: unknown) => e);
+      expect(String(err)).toContain(canonical);
+    }
+  });
+
+  test("the canonical pin on a routing identity is accepted", async () => {
+    seedConnection({
+      name: "chatgpt-subscription",
+      provider: "chatgpt",
+      auth: {
+        type: "oauth_subscription",
+        credential: "credential/chatgpt/access_token",
+      },
+    });
+    secureKeyResults["credential/chatgpt/access_token"] = {
+      value: "token",
+      unreachable: false,
+    };
+
+    const result = (await put({
+      provider: "chatgpt",
+      connectionName: "chatgpt-subscription",
+    })) as Record<string, unknown>;
+
+    expect(result.resolvedConnectionName).toBe("chatgpt-subscription");
+    expect(availability(result)).toEqual({ status: "ok" });
+  });
+
   test("invalid provider → 400 naming the allowed providers", async () => {
     const err = await put({ provider: "not-a-provider" }).catch(
       (e: unknown) => e,