@vellumai/assistant 0.9.0 → 0.9.1-staging.1

package/src/__tests__/identity-routes.test.ts

@@ -22,57 +22,6 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
-const checkpointStore = new Map<string, string>();
-
-mock.module("../memory/checkpoints.js", () => ({
-  getMemoryCheckpoint: (key: string) => checkpointStore.get(key) ?? null,
-  setMemoryCheckpoint: (key: string, value: string) => {
-    checkpointStore.set(key, value);
-  },
-}));
-
-const getConfiguredProviderCalls: string[] = [];
-const mockProvider = { name: "mock-provider" };
-
-mock.module("../providers/provider-send-message.js", () => ({
-  getConfiguredProvider: mock(async (callSite: string) => {
-    getConfiguredProviderCalls.push(callSite);
-    return mockProvider;
-  }),
-}));
-
-type SidechainCall = {
-  callSite?: string;
-  content: string;
-  maxTokens?: number;
-  systemPrompt?: string;
-  tools: unknown[];
-};
-
-type SidechainResult = {
-  text: string;
-  hadTextDeltas: false;
-  response: { content: [] };
-};
-
-const sidechainCalls: SidechainCall[] = [];
-let sidechainText = "";
-let sidechainResultPromise: Promise<SidechainResult> | null = null;
-
-mock.module("../runtime/btw-sidechain.js", () => ({
-  runBtwSidechain: mock(async (params: SidechainCall) => {
-    sidechainCalls.push(params);
-    if (sidechainResultPromise) {
-      return sidechainResultPromise;
-    }
-    return {
-      text: sidechainText,
-      hadTextDeltas: false,
-      response: { content: [] },
-    };
-  }),
-}));
-
 import {
   handleDetailedHealth,
   handleReadyz,
@@ -86,17 +35,6 @@ import {
   selectHatchedAtFromStats,
 } from "../workspace/hatched-date.js";
 
-function createDeferred<T>(): {
-  promise: Promise<T>;
-  resolve: (value: T) => void;
-} {
-  let resolve!: (value: T) => void;
-  const promise = new Promise<T>((res) => {
-    resolve = res;
-  });
-  return { promise, resolve };
-}
-
 // ── Env helpers ─────────────────────────────────────────────────────────
 
 let savedEnv: Record<string, string | undefined>;
@@ -194,11 +132,6 @@ beforeEach(() => {
   rmSync(getHatchedSidecarPath(), { force: true });
   rmSync(join(getWorkspaceDir(), "IDENTITY.md"), { force: true });
   rmSync(join(getWorkspaceDir(), "SOUL.md"), { force: true });
-  checkpointStore.clear();
-  getConfiguredProviderCalls.length = 0;
-  sidechainCalls.length = 0;
-  sidechainText = "";
-  sidechainResultPromise = null;
 });
 
 afterEach(() => {
@@ -564,125 +497,3 @@ describe("identity routes — createdAt selection", () => {
     expect(existsSync(getHatchedSidecarPath())).toBe(false);
   });
 });
-
-describe("identity routes — intro greetings", () => {
-  test("returns fallback immediately, generates personalized greetings in the background, then reuses the cache", async () => {
-    const workspaceDir = getWorkspaceDir();
-    writeFileSync(
-      join(workspaceDir, "IDENTITY.md"),
-      [
-        "# Identity",
-        "",
-        "- **Name:** Example Assistant",
-        "- **Personality:** enjoys crisp, useful hellos",
-        "",
-        "Identity sentinel: chartreuse compass.",
-      ].join("\n"),
-      "utf-8",
-    );
-    writeFileSync(
-      join(workspaceDir, "SOUL.md"),
-      [
-        "# Soul",
-        "",
-        "Soul sentinel: copper lighthouse.",
-        "",
-        "Keep greetings warm and specific.",
-      ].join("\n"),
-      "utf-8",
-    );
-    const deferredSidechain = createDeferred<SidechainResult>();
-    sidechainResultPromise = deferredSidechain.promise;
-
-    const route = ROUTES.find(
-      (candidate) => candidate.operationId === "identity_intro",
-    );
-    expect(route).toBeDefined();
-
-    const body = route!.handler({
-      queryParams: { localHour: "8", localMinute: "15" },
-    }) as {
-      greetings: string[];
-      text: string;
-      source: string;
-      refreshing: boolean;
-    };
-
-    expect(body).toEqual({
-      greetings: [
-        "What are we working on?",
-        "I'm here whenever you need me.",
-        "What's on your mind?",
-        "Ready when you are.",
-      ],
-      text: "What are we working on?",
-      source: "fallback",
-      refreshing: true,
-    });
-    expect(getConfiguredProviderCalls).toEqual([]);
-    expect(sidechainCalls).toEqual([]);
-
-    await Promise.resolve();
-    await Promise.resolve();
-
-    expect(getConfiguredProviderCalls).toEqual(["emptyStateGreeting"]);
-    expect(sidechainCalls).toHaveLength(1);
-    expect(sidechainCalls[0]?.callSite).toBe("emptyStateGreeting");
-    expect(sidechainCalls[0]?.tools).toEqual([]);
-    expect(sidechainCalls[0]?.content).toContain("Generate 5 short");
-    expect(sidechainCalls[0]?.content).not.toContain("Current time of day:");
-    expect(sidechainCalls[0]?.content).toContain(
-      "do not mention the current time",
-    );
-    expect(sidechainCalls[0]?.content).toMatch(
-      /Current user-local time for subtle tone only: morning \(08:15\)\.$/,
-    );
-    expect(sidechainCalls[0]?.content).toContain("JSON array");
-    expect(sidechainCalls[0]?.systemPrompt).toContain(
-      "Identity sentinel: chartreuse compass.",
-    );
-    expect(sidechainCalls[0]?.systemPrompt).toContain(
-      "Soul sentinel: copper lighthouse.",
-    );
-    deferredSidechain.resolve({
-      text: JSON.stringify([
-        "Charting the next useful thing?",
-        "I brought the compass. Where to?",
-        "Ready to make this lighter.",
-        "Morning momentum?",
-        "Five options, one good start.",
-        "A useful next step?",
-      ]),
-      hadTextDeltas: false,
-      response: { content: [] },
-    });
-
-    await sidechainResultPromise;
-    await new Promise((resolve) => setTimeout(resolve, 0));
-
-    sidechainCalls.length = 0;
-    getConfiguredProviderCalls.length = 0;
-
-    const cachedBody = (await route!.handler({})) as {
-      greetings: string[];
-      text: string;
-      source: string;
-      refreshing: boolean;
-    };
-
-    expect(cachedBody).toEqual({
-      greetings: [
-        "Charting the next useful thing?",
-        "I brought the compass. Where to?",
-        "Ready to make this lighter.",
-        "Five options, one good start.",
-        "A useful next step?",
-      ],
-      text: "Charting the next useful thing?",
-      source: "cache",
-      refreshing: false,
-    });
-    expect(getConfiguredProviderCalls).toEqual([]);
-    expect(sidechainCalls).toEqual([]);
-  });
-});

package/src/__tests__/inbound-invite-redemption.test.ts

@@ -173,7 +173,7 @@ describe("inbound invite redemption intercept", () => {
     // Verify the user is now an active member
     const result = findContactChannel({
       channelType: "telegram",
-      externalUserId: "user-invite-123",
+      address: "user-invite-123",
     });
     expect(result).not.toBeNull();
     expect(result!.channel.status).toBe("active");
@@ -203,7 +203,7 @@ describe("inbound invite redemption intercept", () => {
     // Verify the user was NOT made a member
     const result = findContactChannel({
       channelType: "telegram",
-      externalUserId: "user-invite-123",
+      address: "user-invite-123",
     });
     expect(result).toBeNull();
   });
@@ -400,7 +400,7 @@ describe("inbound invite redemption intercept", () => {
     // its ID as the invite's contactId (satisfies the FK constraint).
     const existing = findContactChannel({
       channelType: "telegram",
-      externalUserId: "user-invite-123",
+      address: "user-invite-123",
       externalChatId: "chat-invite-test",
     });
     const targetContactId = existing!.contact.id;
@@ -422,7 +422,7 @@ describe("inbound invite redemption intercept", () => {
 
     const result = findContactChannel({
       channelType: "telegram",
-      externalUserId: "user-invite-123",
+      address: "user-invite-123",
       externalChatId: "chat-invite-test",
     });
     expect(result).not.toBeNull();

package/src/__tests__/invite-redemption-service.test.ts

@@ -83,7 +83,7 @@ describe("invite-redemption-service", () => {
 
     const result = findContactChannel({
       channelType: "telegram",
-      externalUserId: "user-1",
+      address: "user-1",
     });
 
     expect(result).not.toBeNull();
@@ -112,7 +112,7 @@ describe("invite-redemption-service", () => {
 
     const result = findContactChannel({
       channelType: "telegram",
-      externalUserId: "code-user-1",
+      address: "code-user-1",
     });
 
     expect(result).not.toBeNull();
@@ -325,7 +325,7 @@ describe("invite-redemption-service", () => {
     // Verify the redeemer's Telegram ID is now bound to Mom's contact
     const result = findContactChannel({
       channelType: "telegram",
-      externalUserId: "guardian-tg-id",
+      address: "guardian-tg-id",
     });
     expect(result).not.toBeNull();
     expect(result!.contact.id).toBe(momContact.id);
@@ -417,7 +417,7 @@ describe("invite-redemption-service", () => {
     // Verify the redeemer's Telegram ID is now bound to Mom's contact
     const result = findContactChannel({
       channelType: "telegram",
-      externalUserId: "guardian-code-id",
+      address: "guardian-code-id",
     });
     expect(result).not.toBeNull();
     expect(result!.contact.id).toBe(momContact.id);

package/src/__tests__/llm-callsite-catalog.test.ts

@@ -54,9 +54,7 @@ describe("LLM call-site catalog", () => {
 
   test("CALL_SITE_DEFAULTS covers every LLMCallSite enum value", () => {
     const defaultIds = new Set(Object.keys(CALL_SITE_DEFAULTS));
-    const missing = LLMCallSiteEnum.options.filter(
-      (id) => !defaultIds.has(id),
-    );
+    const missing = LLMCallSiteEnum.options.filter((id) => !defaultIds.has(id));
     expect(missing).toEqual([]);
   });
 
@@ -68,11 +66,12 @@ describe("LLM call-site catalog", () => {
     expect(extra).toEqual([]);
   });
 
-  test("every CALL_SITE_DEFAULTS entry has a profile field", () => {
+  test("every CALL_SITE_DEFAULTS profile, when present, is a non-empty string", () => {
     for (const [, config] of Object.entries(CALL_SITE_DEFAULTS)) {
-      expect(config.profile).toBeDefined();
+      // A call site may omit `profile` to inherit the workspace default config.
+      if (config.profile === undefined) continue;
       expect(typeof config.profile).toBe("string");
-      expect(config.profile!.length).toBeGreaterThan(0);
+      expect(config.profile.length).toBeGreaterThan(0);
     }
   });
 });

package/src/__tests__/llm-catalog-parity.test.ts

@@ -30,13 +30,6 @@ function getRepoRoot(): string {
 }
 
 const META_JSON_PATH = join(getRepoRoot(), "meta", "llm-provider-catalog.json");
-const SWIFTPM_MIRROR_PATH = join(
-  getRepoRoot(),
-  "clients",
-  "shared",
-  "Resources",
-  "llm-provider-catalog.json",
-);
 
 interface ClientCatalogCredentialsGuide {
   description: string;
@@ -457,19 +450,4 @@ describe("LLM catalog parity: daemon vs client", () => {
       longContextMode: "native-model",
     });
   });
-
-  // -----------------------------------------------------------------------
-  // Mirror byte-equality
-  // -----------------------------------------------------------------------
-
-  test("SwiftPM mirror is byte-identical to meta/ copy", () => {
-    // `sync-llm-catalog.ts` writes both files from the same serializer; this
-    // guard catches any case where one copy is regenerated without the other.
-    // Byte equality is required because SwiftPM bundles the resource verbatim
-    // into `VellumAssistantShared` while the meta/ JSON is consumed as a
-    // cross-package artifact (web codegen, etc.).
-    const metaBytes = readFileSync(META_JSON_PATH);
-    const swiftPmBytes = readFileSync(SWIFTPM_MIRROR_PATH);
-    expect(swiftPmBytes.equals(metaBytes)).toBe(true);
-  });
 });

package/src/__tests__/llm-resolver.test.ts

@@ -670,30 +670,6 @@ describe("resolveCallSiteConfig", () => {
     expect(resolved.effort).toBe("medium");
   });
 
-  test("workflowLeaf defaults to the cost-optimized profile", () => {
-    const llm = LLMSchema.parse({
-      default: fullDefault,
-      profiles: {
-        balanced: {
-          model: "claude-sonnet-4-7",
-          effort: "medium",
-        },
-        "cost-optimized": {
-          model: "claude-haiku-4-5-20251001",
-          effort: "low",
-        },
-      },
-    });
-
-    expect(resolveDefaultProfileKey("workflowLeaf", llm)).toBe(
-      "cost-optimized",
-    );
-    const resolved = resolveCallSiteConfig("workflowLeaf", llm);
-    expect(resolved.model).toBe("claude-haiku-4-5-20251001");
-    expect(resolved.effort).toBe("low");
-    expect(resolved.thinking.enabled).toBe(false);
-  });
-
   test("explicit callSites config overrides CALL_SITE_DEFAULTS", () => {
     const llm = LLMSchema.parse({
       default: fullDefault,
@@ -1437,3 +1413,52 @@ describe("resolveCallSiteConfig logitBias provenance", () => {
     expect(resolveCallSiteConfig("mainAgent", llm).logitBias).toBeUndefined();
   });
 });
+
+describe("resolveCallSiteConfig — workflowLeaf default", () => {
+  test("inherits the workspace default config rather than pinning cost-optimized", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        "cost-optimized": {
+          provider: "anthropic",
+          model: "claude-haiku-4-5-20251001",
+        },
+      },
+    });
+    const resolved = resolveCallSiteConfig("workflowLeaf", llm);
+    // No pinned profile → the model comes from llm.default, NOT the
+    // `cost-optimized` profile (which is uncredentialed on a BYOK install).
+    expect(resolved.model).toBe("claude-opus-4-7");
+    // Call-site tuning still applies.
+    expect(resolved.effort).toBe("low");
+    expect(resolved.thinking?.enabled).toBe(false);
+    // The call site has no implicit default profile key.
+    expect(resolveDefaultProfileKey("workflowLeaf", llm)).toBeUndefined();
+  });
+
+  test("honors an explicit workflowLeaf call-site override", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        cheap: { provider: "anthropic", model: "claude-haiku-4-5-20251001" },
+      },
+      callSites: { workflowLeaf: { profile: "cheap" } },
+    });
+    expect(resolveCallSiteConfig("workflowLeaf", llm).model).toBe(
+      "claude-haiku-4-5-20251001",
+    );
+  });
+
+  test("honors a per-call override profile (an explicit per-leaf profile)", () => {
+    const llm = LLMSchema.parse({
+      default: fullDefault,
+      profiles: {
+        fancy: { provider: "anthropic", model: "claude-sonnet-4-7" },
+      },
+    });
+    expect(
+      resolveCallSiteConfig("workflowLeaf", llm, { overrideProfile: "fancy" })
+        .model,
+    ).toBe("claude-sonnet-4-7");
+  });
+});

package/src/__tests__/oauth-provider-seed-logos.test.ts

@@ -3,17 +3,15 @@ import { describe, expect, test } from "bun:test";
 import { PROVIDER_SEED_DATA } from "../oauth/seed-providers.js";
 
 /**
- * Allowed CDN prefixes for ``logoUrl``. Mirrors the source registry in
- * ``clients/shared/Resources/integration-logos-manifest.json``:
+ * Allowed CDN prefixes for the ``logoUrl`` field on ``PROVIDER_SEED_DATA``
+ * (``assistant/src/oauth/seed-providers.ts``):
  *
  * - Simple Icons (CC0) is the default for most providers.
  * - thesvg via jsDelivr is the documented fallback for brands Simple Icons
  *   doesn't host (e.g. Salesforce, which Simple Icons removed for
- *   trademark reasons). Same source is already used for the bundled PDFs
- *   of figma/github/gmail/linear/notion/outlook/slack.
+ *   trademark reasons).
  *
- * Adding another CDN should be a deliberate choice — extend this list
- * and update the manifest in tandem.
+ * Adding another CDN should be a deliberate choice — extend this list.
  */
 const ALLOWED_LOGO_URL_PREFIXES = [
   "https://cdn.simpleicons.org/",

package/src/__tests__/onboarding-persona-write.test.ts

@@ -59,7 +59,7 @@ mock.module("../util/platform.js", () => ({
 }));
 
 mock.module("../contacts/contact-store.js", () => ({
-  findContactByChannelExternalId: () => null,
+  findContactByAddress: () => null,
   findGuardianForChannel: (channelType: string) =>
     channelType === "vellum" ? mockVellumGuardian : null,
   listGuardianChannels: () => null,

package/src/__tests__/persona-resolver.test.ts

@@ -32,18 +32,14 @@ import {
 // ── Mock state ────────────────────────────────────────────────────
 
 let mockWorkspaceDir: string = "";
-let mockVellumGuardian:
-  | {
-      contact: { userFile: string | null };
-      channel: Record<string, unknown>;
-    }
-  | null = null;
-let mockAnyGuardian:
-  | {
-      contact: { userFile: string | null };
-      channels: Record<string, unknown>[];
-    }
-  | null = null;
+let mockVellumGuardian: {
+  contact: { userFile: string | null };
+  channel: Record<string, unknown>;
+} | null = null;
+let mockAnyGuardian: {
+  contact: { userFile: string | null };
+  channels: Record<string, unknown>[];
+} | null = null;
 
 // ── Mock modules (must precede imports from the module under test) ──
 
@@ -52,7 +48,7 @@ mock.module("../util/platform.js", () => ({
 }));
 
 mock.module("../contacts/contact-store.js", () => ({
-  findContactByChannelExternalId: () => null,
+  findContactByAddress: () => null,
   findGuardianForChannel: (channelType: string) =>
     channelType === "vellum" ? mockVellumGuardian : null,
   listGuardianChannels: () => mockAnyGuardian,
@@ -138,7 +134,8 @@ describe("ensureGuardianPersonaFile", () => {
     const userFile = "alice.md";
     const dir = join(mockWorkspaceDir, "users");
     const filePath = join(dir, userFile);
-    const existingContent = "# Existing user notes\n\n- Likes sparkling water\n";
+    const existingContent =
+      "# Existing user notes\n\n- Likes sparkling water\n";
 
     mkdirSync(dir, { recursive: true });
     writeFileSync(filePath, existingContent, "utf-8");

package/src/__tests__/plugin-api-model-profiles.test.ts

@@ -0,0 +1,178 @@
+import { writeFileSync } from "node:fs";
+import { afterEach, describe, expect, test } from "bun:test";
+
+import { invalidateConfigCache } from "../config/loader.js";
+import { getModelProfiles } from "../plugin-api/index.js";
+import { getWorkspaceConfigPath } from "../util/platform.js";
+
+/**
+ * `getModelProfiles()` — the runtime handle a plugin (e.g. a model router) calls
+ * to learn which inference profiles a workspace defines. These tests pin its
+ * contract: presentation ordering (`profileOrder` then alphabetical tail), mix
+ * profiles included and flagged via `isMix`, disabled profiles included and
+ * flagged via `isDisabled`, and the per-field fallbacks (label → key,
+ * description → null, isActive → `llm.activeProfile`).
+ */
+
+function writeFixtureConfig(config: Record<string, unknown>): void {
+  writeFileSync(getWorkspaceConfigPath(), JSON.stringify(config), "utf-8");
+  invalidateConfigCache();
+}
+
+describe("getModelProfiles", () => {
+  afterEach(() => {
+    invalidateConfigCache();
+  });
+
+  test("orders profiles by profileOrder then the remaining keys alphabetically", () => {
+    // GIVEN a workspace whose profileOrder names some keys, with a duplicate
+    // ("balanced") and a key that resolves to no profile ("ghost").
+    writeFixtureConfig({
+      llm: {
+        profiles: { zeta: {}, alpha: {}, balanced: {}, "cost-optimized": {} },
+        profileOrder: ["balanced", "cost-optimized", "balanced", "ghost"],
+      },
+    });
+    // WHEN the profiles are listed.
+    const keys = getModelProfiles().map((p) => p.key);
+    // THEN profileOrder keys come first (deduped, existing-only), then the rest
+    // alphabetically.
+    expect(keys).toEqual(["balanced", "cost-optimized", "alpha", "zeta"]);
+  });
+
+  test("includes mix profiles and flags them via isMix", () => {
+    // GIVEN a workspace with a weighted mix profile alongside plain ones.
+    writeFixtureConfig({
+      llm: {
+        profiles: {
+          alpha: {},
+          beta: {},
+          blend: {
+            mix: [
+              { profile: "alpha", weight: 1 },
+              { profile: "beta", weight: 1 },
+            ],
+          },
+        },
+        profileOrder: ["alpha", "beta", "blend"],
+      },
+    });
+    // WHEN the profiles are listed.
+    const flags = getModelProfiles().map((p) => [p.key, p.isMix]);
+    // THEN the mix profile is present and flagged isMix, while plain profiles are not.
+    expect(flags).toEqual([
+      ["alpha", false],
+      ["beta", false],
+      ["blend", true],
+    ]);
+  });
+
+  test("marks an active mix profile via isActive", () => {
+    // GIVEN a workspace whose activeProfile is itself a weighted mix.
+    writeFixtureConfig({
+      llm: {
+        profiles: {
+          alpha: {},
+          blend: {
+            mix: [
+              { profile: "alpha", weight: 1 },
+              { profile: "beta", weight: 1 },
+            ],
+          },
+          beta: {},
+        },
+        profileOrder: ["alpha", "blend", "beta"],
+        activeProfile: "blend",
+      },
+    });
+    // WHEN the profiles are listed.
+    const active = getModelProfiles()
+      .filter((p) => p.isActive)
+      .map((p) => p.key);
+    // THEN the active mix profile is the one flagged isActive.
+    expect(active).toEqual(["blend"]);
+  });
+
+  test("includes disabled profiles and flags them via isDisabled", () => {
+    // GIVEN a workspace with one active and one disabled profile.
+    writeFixtureConfig({
+      llm: {
+        profiles: {
+          alpha: { status: "active" },
+          beta: { status: "disabled" },
+        },
+        profileOrder: ["alpha", "beta"],
+      },
+    });
+    // WHEN the profiles are listed.
+    const flags = getModelProfiles().map((p) => [p.key, p.isDisabled]);
+    // THEN the disabled profile is present and marked isDisabled.
+    expect(flags).toEqual([
+      ["alpha", false],
+      ["beta", true],
+    ]);
+  });
+
+  test("falls back to the key when a profile has no label", () => {
+    // GIVEN a workspace where one profile sets a label and one does not.
+    writeFixtureConfig({
+      llm: {
+        profiles: { balanced: { label: "Balanced" }, terse: {} },
+        profileOrder: ["balanced", "terse"],
+      },
+    });
+    // WHEN the profiles are listed.
+    const byKey = Object.fromEntries(
+      getModelProfiles().map((p) => [p.key, p.label]),
+    );
+    // THEN the unlabeled profile's label falls back to its key.
+    expect(byKey.balanced).toBe("Balanced");
+    expect(byKey.terse).toBe("terse");
+  });
+
+  test("marks the workspace active profile via isActive", () => {
+    // GIVEN a workspace whose activeProfile is "beta".
+    writeFixtureConfig({
+      llm: {
+        profiles: { alpha: {}, beta: {} },
+        profileOrder: ["alpha", "beta"],
+        activeProfile: "beta",
+      },
+    });
+    // WHEN the profiles are listed.
+    const flags = getModelProfiles().map((p) => [p.key, p.isActive]);
+    // THEN only the active profile is marked isActive.
+    expect(flags).toEqual([
+      ["alpha", false],
+      ["beta", true],
+    ]);
+  });
+
+  test("reports description as null when a profile sets none", () => {
+    // GIVEN a workspace where one profile has a description and one does not.
+    writeFixtureConfig({
+      llm: {
+        profiles: {
+          documented: { description: "Cheaper models, slower" },
+          bare: {},
+        },
+        profileOrder: ["documented", "bare"],
+      },
+    });
+    // WHEN the profiles are listed.
+    const byKey = Object.fromEntries(
+      getModelProfiles().map((p) => [p.key, p.description]),
+    );
+    // THEN a missing description is reported as null.
+    expect(byKey.documented).toBe("Cheaper models, slower");
+    expect(byKey.bare).toBeNull();
+  });
+
+  test("returns an empty list when the workspace defines no profiles", () => {
+    // GIVEN a workspace with no profiles defined.
+    writeFixtureConfig({ llm: { profiles: {}, profileOrder: [] } });
+    // WHEN the profiles are listed.
+    // THEN the result is empty.
+    expect(getModelProfiles()).toEqual([]);
+  });
+});