@vellumai/assistant 0.11.3 → 0.11.4-staging.1

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

@@ -25,7 +25,7 @@ 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,
@@ -782,3 +782,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,

package/src/runtime/routes/__tests__/inference-profiles-routes.test.ts

@@ -150,6 +150,50 @@ describe("POST inference/profiles (create) validation", () => {
     ).rejects.toBeInstanceOf(BadRequestError);
   });
 
+  test("creates an entry-backed profile, validating the model by the row's kind", async () => {
+    seedConnection("anthropic-work", "anthropic", {
+      type: "api_key",
+      credential: "credential/anthropic-work/api_key",
+    });
+    const result = (await call("inference_profiles_create", {
+      body: {
+        name: "work-profile",
+        provider: "anthropic-work",
+        model: "claude-opus-4-8",
+      },
+    })) as { entry: Record<string, unknown> };
+    expect(result.entry.provider).toBe("anthropic-work");
+    expect(result.entry.model).toBe("claude-opus-4-8");
+  });
+
+  test("rejects an entry-backed profile whose model the row's kind cannot serve", async () => {
+    seedConnection("anthropic-work", "anthropic", {
+      type: "api_key",
+      credential: "credential/anthropic-work/api_key",
+    });
+    await expect(
+      call("inference_profiles_create", {
+        body: {
+          name: "work-profile",
+          provider: "anthropic-work",
+          model: "gpt-5.5",
+        },
+      }),
+    ).rejects.toBeInstanceOf(BadRequestError);
+  });
+
+  test("rejects a provider naming no known vendor or entry", async () => {
+    await expect(
+      call("inference_profiles_create", {
+        body: {
+          name: "ghost-profile",
+          provider: "no-such-entry",
+          model: "claude-opus-4-8",
+        },
+      }),
+    ).rejects.toBeInstanceOf(BadRequestError);
+  });
+
   test("creates a vellum profile for a managed-routable model", async () => {
     seedVellumConnection();
     const result = (await call("inference_profiles_create", {

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

@@ -232,6 +232,61 @@ describe("POST inference/provider-connections (create)", () => {
     expect((err as BadRequestError).message).toContain("vellum");
   });
 
+  test("rejects a chatgpt identity row under a non-canonical name", async () => {
+    const err = await call(
+      findHandler("inference_provider_connections_create"),
+      {
+        body: {
+          name: "my-chatgpt",
+          provider: "chatgpt",
+          auth: { type: "oauth_subscription", credential: "credential/x" },
+        },
+      },
+    ).catch((e: unknown) => e);
+
+    expect(err).toBeInstanceOf(BadRequestError);
+    expect((err as BadRequestError).message).toContain("chatgpt-subscription");
+  });
+
+  test("rejects key auth on the chatgpt provider, derived or explicit", async () => {
+    for (const body of [
+      {
+        name: "chatgpt-subscription",
+        provider: "chatgpt",
+        auth: { type: "api_key", credential: "vault/x" },
+      },
+      // No explicit auth: derivation would fall through to api_key.
+      {
+        name: "chatgpt-subscription",
+        provider: "chatgpt",
+        credential: "vault/x",
+      },
+    ]) {
+      const err = await call(
+        findHandler("inference_provider_connections_create"),
+        { body },
+      ).catch((e: unknown) => e);
+      expect(err).toBeInstanceOf(BadRequestError);
+      expect((err as BadRequestError).message).toContain("sign-in");
+    }
+  });
+
+  test("rejects subscription auth on a non-chatgpt provider", async () => {
+    const err = await call(
+      findHandler("inference_provider_connections_create"),
+      {
+        body: {
+          name: "keyed-oauth",
+          provider: "openai",
+          auth: { type: "oauth_subscription", credential: "credential/x" },
+        },
+      },
+    ).catch((e: unknown) => e);
+
+    expect(err).toBeInstanceOf(BadRequestError);
+    expect((err as BadRequestError).message).toContain("chatgpt");
+  });
+
   test("rejects key auth on the vellum provider", async () => {
     const err = await call(
       findHandler("inference_provider_connections_create"),
@@ -396,7 +451,7 @@ describe("POST inference/provider-connections (create)", () => {
           models: [{ id: "my-model" }],
         },
       }),
-    ).rejects.toThrow(/belongs to a built-in provider/);
+    ).rejects.toThrow(/reserved as a provider id/);
 
     await call(findHandler("inference_provider_connections_create"), {
       body: {
@@ -677,6 +732,52 @@ describe("PATCH inference/provider-connections/:name (update)", () => {
 
   // The guard must not trap a legacy row in its mismatched state: an auth
   // change that repairs the pairing is exactly what should be allowed.
+  // The canonical subscription row owns the "chatgpt" identity: writing
+  // subscription auth to it stamps the provider (the CLI login-chatgpt path
+  // PATCHes auth through this route on a row the identity migration
+  // deliberately skipped).
+  test("stamps the chatgpt identity when subscription auth lands on the canonical row", async () => {
+    seedConnection({
+      name: "chatgpt-subscription",
+      provider: "openai",
+      auth: { type: "api_key", credential: "vault/openai/key" },
+    });
+
+    const result = (await call(
+      findHandler("inference_provider_connections_update"),
+      {
+        pathParams: { name: "chatgpt-subscription" },
+        body: {
+          auth: {
+            type: "oauth_subscription",
+            credential: "credential/chatgpt/access_token",
+          },
+        },
+      },
+    )) as { provider: string; auth: { type: string } };
+    expect(result.provider).toBe("chatgpt");
+    expect(result.auth.type).toBe("oauth_subscription");
+  });
+
+  test("does not stamp the identity for non-subscription auth on that name", async () => {
+    seedConnection({
+      name: "chatgpt-subscription",
+      provider: "openai",
+      auth: { type: "api_key", credential: "vault/openai/key" },
+    });
+
+    const result = (await call(
+      findHandler("inference_provider_connections_update"),
+      {
+        pathParams: { name: "chatgpt-subscription" },
+        body: {
+          auth: { type: "api_key", credential: "vault/openai/other-key" },
+        },
+      },
+    )) as { provider: string };
+    expect(result.provider).toBe("openai");
+  });
+
   test("allows repairing a legacy mismatched row with a valid auth change", async () => {
     seedConnection({
       name: "legacy-managed-anthropic",

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

@@ -109,6 +109,7 @@ import {
 } from "../../../cli/lib/uninstall-plugin.js";
 import {
   PluginMergeBaselineError,
+  PluginNotCuratedError,
   PluginNotUpgradableError,
   type PluginUpgradeResult,
   type UpgradePluginDeps,
@@ -252,6 +253,7 @@ const upgradeSpy = mock(
 
 mock.module("../../../cli/lib/upgrade-plugin.js", () => ({
   PluginMergeBaselineError,
+  PluginNotCuratedError,
   PluginNotUpgradableError,
   upgradePlugin: upgradeSpy,
 }));
@@ -2127,6 +2129,7 @@ describe("POST /v1/plugins/:name/upgrade", () => {
       name: "level-up",
       dryRun: false,
       strategy: undefined,
+      marketplaceOnly: false,
     });
   });
 
@@ -2148,6 +2151,7 @@ describe("POST /v1/plugins/:name/upgrade", () => {
       name: "level-up",
       dryRun: undefined,
       strategy: "ours",
+      marketplaceOnly: false,
     });
   });
 
@@ -2175,6 +2179,7 @@ describe("POST /v1/plugins/:name/upgrade", () => {
       name: "level-up",
       dryRun: undefined,
       strategy: "assistant",
+      marketplaceOnly: false,
     });
   });
 
@@ -2300,6 +2305,10 @@ describe("POST /v1/plugins/:name/upgrade", () => {
     expect(upgradeSpy.mock.calls[0]?.[0]).toEqual({
       name: "level-up",
       dryRun: undefined,
+      strategy: undefined,
+      // Unlike dryRun, an absent flag here is a definite "no": the untrusted
+      // direct path stays available unless a caller opts out of it.
+      marketplaceOnly: false,
     });
   });
 
@@ -2343,6 +2352,41 @@ describe("POST /v1/plugins/:name/upgrade", () => {
     ).rejects.toBeInstanceOf(ConflictError);
   });
 
+  test("marketplaceOnly is forwarded so the lib enforces it, not the caller", async () => {
+    // The lib re-inspects the catalog inside the call, so the flag has to
+    // travel with the request: a caller's own pre-check cannot bind a decision
+    // the lib makes afterwards.
+    upgradeSpy.mockImplementation(async () => upgradeResult());
+
+    await invokeUpgrade({
+      pathParams: { name: "level-up" },
+      body: { marketplaceOnly: true },
+    });
+
+    expect(upgradeSpy.mock.calls[0]?.[0]).toEqual({
+      name: "level-up",
+      dryRun: undefined,
+      strategy: undefined,
+      marketplaceOnly: true,
+    });
+  });
+
+  test("PluginNotCuratedError → ConflictError (409)", async () => {
+    // A marketplaceOnly caller asked about an install the catalog does not
+    // claim. Retrying changes nothing: only a human upgrading it without the
+    // flag can move it.
+    upgradeSpy.mockImplementation(async () => {
+      throw new PluginNotCuratedError("level-up");
+    });
+
+    await expect(
+      invokeUpgrade({
+        pathParams: { name: "level-up" },
+        body: { marketplaceOnly: true },
+      }),
+    ).rejects.toBeInstanceOf(ConflictError);
+  });
+
   test("PluginNotFoundError → NotFoundError (404)", async () => {
     upgradeSpy.mockImplementation(async () => {
       throw new PluginNotFoundError("level-up", "main", "vellum-ai/level-up");

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

@@ -288,6 +288,31 @@ describe("stt-routes", () => {
     expect(err.message).toContain("not available");
   });
 
+  test("surfaces a typed resolver error verbatim instead of the generic copy", async () => {
+    // A streaming-only provider IS configured, so the "nothing configured"
+    // and "not available" strings would both send the caller looking for a
+    // problem that does not exist.
+    const reason =
+      'Deepgram Flux is streaming-only. Batch transcription requires the deepgram provider: set services.stt.provider to "deepgram".';
+    mockResolveError = new SttError("provider-error", reason, {
+      userFacing: true,
+    });
+
+    const { handler } = getRoute("stt/transcribe");
+    const err = await expectRouteError(
+      () =>
+        handler(
+          makeArgs({
+            audioBase64: toBase64("audio-data"),
+            mimeType: "audio/wav",
+          }),
+        ),
+      503,
+      "SERVICE_UNAVAILABLE",
+    );
+    expect(err.message).toBe(reason);
+  });
+
   // -- Timeout --------------------------------------------------------------
 
   test("throws 504 when transcription times out", async () => {