@vellumai/assistant 0.8.0 → 0.8.1

package/src/providers/__tests__/dispatch-connection-routing.test.ts

@@ -0,0 +1,279 @@
+/**
+ * Dispatcher gate test — proves that `resolveConfiguredProvider` routes
+ * through `resolveProviderFromConnection` for every dispatch when a profile
+ * names a `provider_connection`, AND that misconfigurations now fail loudly
+ * rather than silently rerouting to a legacy registry.
+ *
+ * Hard config errors (missing connection name, unknown connection,
+ * provider mismatch) throw `ConnectionResolutionError`. Soft credential
+ * failures (resolver returns null) still return null so callers can
+ * degrade gracefully.
+ *
+ * Hard gates:
+ *   1. Two profiles, same provider, different `provider_connection` →
+ *      resolver called twice with the right connection each time, with
+ *      auth bundles distinguishable per profile (mix-and-match goal #2
+ *      of the design).
+ *   2. Profile WITHOUT `provider_connection` → throws
+ *      `ConnectionResolutionError` (configuration bug; backfill should
+ *      have populated it).
+ *   3. `provider_connection` set but unknown → throws (loud config error).
+ *   4. `provider_connection` set, found, but resolver returns null →
+ *      returns null (soft credential failure; satellite caller decides
+ *      what to do).
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Module mocks (must be declared before the import-under-test).
+// ---------------------------------------------------------------------------
+
+mock.module("../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+}));
+
+// Test fixtures for the mocked config loader.
+let mockLlmConfig: Record<string, unknown> = {};
+
+mock.module("../../config/loader.js", () => ({
+  getConfig: () => ({
+    llm: mockLlmConfig,
+    services: { inference: { mode: "your-own" } },
+  }),
+}));
+
+// Mock the DB getter — we never actually hit SQLite since `getConnection` is
+// also mocked. Returning a sentinel keeps the call signature satisfied.
+const mockDbSentinel = { __mock: "db" };
+mock.module("../../memory/db-connection.js", () => ({
+  getDb: () => mockDbSentinel,
+}));
+
+// Spy storage for the resolver — each test inspects what was passed in.
+type Connection = {
+  name: string;
+  provider: string;
+  auth: { type: string; credential?: string };
+};
+
+const resolveProviderCalls: Connection[] = [];
+
+// Each connection name maps to a distinct fake Provider instance. Returning
+// distinguishable instances lets the test assert that two profiles with
+// different connections route to different providers.
+const fakeProviders = new Map<string, { name: string; tag: string }>();
+
+// Connection registry the mocked `getConnection` reads from.
+const fakeConnections = new Map<string, Connection>();
+
+mock.module("../inference/connections.js", () => ({
+  getConnection: (_db: unknown, name: string) =>
+    fakeConnections.get(name) ?? null,
+}));
+
+mock.module("../registry.js", () => ({
+  // The dispatch path does not import getProvider.
+  // Kept here only because other test files share this mock module shape.
+  getProvider: (name: string) => {
+    throw new Error(`legacy getProvider should not be called: ${name}`);
+  },
+  initializeProviders: async () => {},
+  listProviders: () => Array.from(fakeProviders.values()),
+  // The function under test — wraps the dispatcher's connection-aware path.
+  resolveProviderFromConnection: async (connection: Connection) => {
+    resolveProviderCalls.push(connection);
+    return fakeProviders.get(`conn:${connection.name}`) ?? null;
+  },
+}));
+
+// ---------------------------------------------------------------------------
+// Imports (after mocks).
+// ---------------------------------------------------------------------------
+
+import { ConnectionResolutionError } from "../connection-resolution.js";
+import { getConfiguredProvider } from "../provider-send-message.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function setLlmConfig(c: Record<string, unknown>): void {
+  mockLlmConfig = c;
+}
+
+function registerConnection(
+  c: Connection,
+  providerStub: { name: string; tag: string },
+): void {
+  fakeConnections.set(c.name, c);
+  fakeProviders.set(`conn:${c.name}`, providerStub);
+}
+
+function reset(): void {
+  resolveProviderCalls.length = 0;
+  fakeConnections.clear();
+  fakeProviders.clear();
+  mockLlmConfig = {};
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("dispatch routes through provider_connection (Phase 1: connection-only)", () => {
+  beforeEach(reset);
+
+  test("two profiles, same provider, different connections → resolver called twice with the right connection each time", async () => {
+    // Same underlying provider impl, two distinguishable connection-bound
+    // Provider stubs.
+    registerConnection(
+      {
+        name: "anthropic-managed",
+        provider: "anthropic",
+        auth: { type: "platform" },
+      },
+      { name: "anthropic", tag: "managed-stub" },
+    );
+    registerConnection(
+      {
+        name: "anthropic-personal",
+        provider: "anthropic",
+        auth: {
+          type: "api_key",
+          credential: "credential/test/anthropic",
+        },
+      },
+      { name: "anthropic", tag: "personal-stub" },
+    );
+
+    setLlmConfig({
+      default: { provider: "anthropic", model: "claude-opus-4-7" },
+      profiles: {
+        "anthropic-managed-profile": {
+          provider: "anthropic",
+          provider_connection: "anthropic-managed",
+        },
+        "anthropic-personal-profile": {
+          provider: "anthropic",
+          provider_connection: "anthropic-personal",
+        },
+      },
+    });
+
+    const managedResult = await getConfiguredProvider("mainAgent", {
+      overrideProfile: "anthropic-managed-profile",
+    });
+    const personalResult = await getConfiguredProvider("mainAgent", {
+      overrideProfile: "anthropic-personal-profile",
+    });
+
+    // Hard gate #1: the resolver was called — at all.
+    expect(resolveProviderCalls.length).toBe(2);
+
+    // Hard gate #2: each call received the right connection by name.
+    expect(resolveProviderCalls[0].name).toBe("anthropic-managed");
+    expect(resolveProviderCalls[1].name).toBe("anthropic-personal");
+
+    // Hard gate #3: the auth bundle on the connection matches what we'd
+    // expect at adapter-call time. Different auth types per profile = mix-
+    // and-match works.
+    expect(resolveProviderCalls[0].auth.type).toBe("platform");
+    expect(resolveProviderCalls[1].auth.type).toBe("api_key");
+    expect(resolveProviderCalls[1].auth.credential).toBe(
+      "credential/test/anthropic",
+    );
+
+    // Sanity: dispatch returned non-null for both.
+    expect(managedResult).not.toBeNull();
+    expect(personalResult).not.toBeNull();
+  });
+
+  test("profile WITHOUT provider_connection returns null (graceful fallback)", async () => {
+    setLlmConfig({
+      default: { provider: "anthropic", model: "claude-opus-4-7" },
+      profiles: {
+        "legacy-profile": {
+          provider: "anthropic",
+          // no provider_connection — boot-time backfill is expected to
+          // populate this in production. When unset, the per-callsite
+          // resolver returns null so callsites with deterministic
+          // fallbacks (invite instructions, telegram resolution, etc.)
+          // keep working. Hard config errors (lookup failed, mismatch)
+          // still throw via tryResolveProviderForConnectionName.
+        },
+      },
+    });
+
+    const result = await getConfiguredProvider("mainAgent", {
+      overrideProfile: "legacy-profile",
+    });
+
+    expect(result).toBeNull();
+    // Resolver must NOT have been called — short-circuited before reaching it.
+    expect(resolveProviderCalls.length).toBe(0);
+  });
+
+  test("provider_connection set but unknown → throws ConnectionResolutionError(not_found)", async () => {
+    // No connection registered — the dispatcher should throw with reason
+    // 'not_found' rather than falling through to a legacy lookup.
+    setLlmConfig({
+      default: { provider: "anthropic", model: "claude-opus-4-7" },
+      profiles: {
+        broken: {
+          provider: "anthropic",
+          provider_connection: "does-not-exist",
+        },
+      },
+    });
+
+    let caught: unknown;
+    try {
+      await getConfiguredProvider("mainAgent", { overrideProfile: "broken" });
+    } catch (err) {
+      caught = err;
+    }
+
+    expect(caught).toBeInstanceOf(ConnectionResolutionError);
+    expect((caught as ConnectionResolutionError).reason).toBe("not_found");
+    expect((caught as ConnectionResolutionError).connectionName).toBe(
+      "does-not-exist",
+    );
+    // Resolver was NOT called (lookup failed before reaching it).
+    expect(resolveProviderCalls.length).toBe(0);
+  });
+
+  test("provider_connection set, connection found, but resolver returns null → returns null (soft credential failure)", async () => {
+    // Connection exists but resolver returns null (e.g., missing credential).
+    fakeConnections.set("anthropic-broken-personal", {
+      name: "anthropic-broken-personal",
+      provider: "anthropic",
+      auth: { type: "api_key", credential: "credential/missing" },
+    });
+    // Intentionally do NOT register a fakeProviders entry for
+    // `conn:anthropic-broken-personal` — resolver returns null.
+
+    setLlmConfig({
+      default: { provider: "anthropic", model: "claude-opus-4-7" },
+      profiles: {
+        "broken-creds": {
+          provider: "anthropic",
+          provider_connection: "anthropic-broken-personal",
+        },
+      },
+    });
+
+    const result = await getConfiguredProvider("mainAgent", {
+      overrideProfile: "broken-creds",
+    });
+
+    // Resolver WAS called — but returned null. No legacy fallback.
+    expect(resolveProviderCalls.length).toBe(1);
+    expect(resolveProviderCalls[0].name).toBe("anthropic-broken-personal");
+    // Soft credential failure → null result. Satellite callers handle null
+    // however they want (rollup producer skips, others throw a domain-
+    // specific error).
+    expect(result).toBeNull();
+  });
+});

package/src/providers/__tests__/inference.test.ts

@@ -0,0 +1,288 @@
+/**
+ * Tests for provider_connections: migration, CRUD, and
+ * mix-and-match E2E (two profiles, same provider, different connections).
+ */
+
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import type { DrizzleDb } from "../../memory/db-connection.js";
+import { getSqliteFrom } from "../../memory/db-connection.js";
+import { migrateCreateProviderConnections } from "../../memory/migrations/243-provider-connections.js";
+import { migrateProviderConnectionStatusLabel } from "../../memory/migrations/244-provider-connection-status-label.js";
+import * as schema from "../../memory/schema.js";
+import { AuthSchema } from "../inference/auth.js";
+import {
+  createConnection,
+  deleteConnection,
+  getConnection,
+  listConnections,
+  seedCanonicalConnections,
+  updateConnection,
+} from "../inference/connections.js";
+
+// ---------------------------------------------------------------------------
+// Setup — each test gets a fresh in-memory DB
+// ---------------------------------------------------------------------------
+
+function setupDb(): { db: DrizzleDb; raw: Database } {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  sqlite.exec("PRAGMA foreign_keys = ON");
+  const db = drizzle(sqlite, { schema });
+  const raw = getSqliteFrom(db);
+  migrateCreateProviderConnections(db);
+  migrateProviderConnectionStatusLabel(db);
+  return { db, raw };
+}
+
+// ---------------------------------------------------------------------------
+// Migration idempotency
+// ---------------------------------------------------------------------------
+
+describe("migrateCreateProviderConnections", () => {
+  test("creates the provider_connections table", () => {
+    const { raw } = setupDb();
+    const rows = raw.query("SELECT name FROM provider_connections").all() as { name: string }[];
+    expect(Array.isArray(rows)).toBe(true);
+  });
+
+  test("seeds canonical connections on first run", () => {
+    const { db } = setupDb();
+    const canonicals = ["anthropic-managed", "openai-managed", "gemini-managed"];
+    for (const name of canonicals) {
+      const conn = getConnection(db, name);
+      expect(conn).not.toBeNull();
+    }
+  });
+
+  test("canonical connections have correct auth types", () => {
+    const { db } = setupDb();
+    expect(getConnection(db, "anthropic-managed")?.auth.type).toBe("platform");
+    expect(getConnection(db, "openai-managed")?.auth.type).toBe("platform");
+    expect(getConnection(db, "gemini-managed")?.auth.type).toBe("platform");
+  });
+
+  test("seedCanonicalConnections is idempotent", () => {
+    const { db } = setupDb();
+    // Run twice — should not throw or create duplicates
+    seedCanonicalConnections(db);
+    seedCanonicalConnections(db);
+    const managed = listConnections(db, { provider: "anthropic" });
+    expect(managed.filter((c) => c.name === "anthropic-managed").length).toBe(1);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Connection CRUD
+// ---------------------------------------------------------------------------
+
+describe("Connection CRUD", () => {
+  test("createConnection — happy path", () => {
+    const { db } = setupDb();
+    const result = createConnection(db, {
+      name: "my-anthropic",
+      provider: "anthropic",
+      auth: { type: "api_key", credential: "credential/anthropic/api_key" },
+    });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.connection.name).toBe("my-anthropic");
+    expect(result.connection.provider).toBe("anthropic");
+    expect(result.connection.auth.type).toBe("api_key");
+  });
+
+  test("createConnection — rejects unknown provider", () => {
+    const { db } = setupDb();
+    const result = createConnection(db, {
+      name: "bad-conn",
+      provider: "unknown-llm" as never,
+      auth: { type: "none" },
+    });
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.error.code).toBe("invalid_provider");
+  });
+
+  test("createConnection — rejects duplicate name", () => {
+    const { db } = setupDb();
+    createConnection(db, {
+      name: "dup-conn",
+      provider: "openai",
+      auth: { type: "platform" },
+    });
+    const result = createConnection(db, {
+      name: "dup-conn",
+      provider: "openai",
+      auth: { type: "platform" },
+    });
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.error.code).toBe("already_exists");
+  });
+
+  test("getConnection — returns null for unknown name", () => {
+    const { db } = setupDb();
+    expect(getConnection(db, "nonexistent")).toBeNull();
+  });
+
+  test("listConnections — filters by provider", () => {
+    const { db } = setupDb();
+    createConnection(db, {
+      name: "test-openai",
+      provider: "openai",
+      auth: { type: "api_key", credential: "credential/openai/api_key" },
+    });
+    const openai = listConnections(db, { provider: "openai" });
+    expect(openai.every((c) => c.provider === "openai")).toBe(true);
+  });
+
+  test("updateConnection — happy path", () => {
+    const { db } = setupDb();
+    createConnection(db, {
+      name: "updatable",
+      provider: "anthropic",
+      auth: { type: "platform" },
+    });
+    const result = updateConnection(db, "updatable", {
+      auth: { type: "api_key", credential: "credential/anthropic/api_key" },
+    });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(result.connection.auth.type).toBe("api_key");
+    const fetched = getConnection(db, "updatable");
+    expect(fetched?.auth.type).toBe("api_key");
+  });
+
+  test("updateConnection — rejects unknown name", () => {
+    const { db } = setupDb();
+    const result = updateConnection(db, "ghost", { auth: { type: "none" } });
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.error.code).toBe("not_found");
+  });
+
+  test("deleteConnection — happy path", () => {
+    const { db } = setupDb();
+    createConnection(db, {
+      name: "to-delete",
+      provider: "gemini",
+      auth: { type: "platform" },
+    });
+    const result = deleteConnection(db, "to-delete");
+    expect(result.ok).toBe(true);
+    expect(getConnection(db, "to-delete")).toBeNull();
+  });
+
+  test("deleteConnection — rejects unknown name", () => {
+    const { db } = setupDb();
+    const result = deleteConnection(db, "ghost");
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.error.code).toBe("not_found");
+  });
+
+  test("deleteConnection — rejects when profiles reference it (no --force)", () => {
+    const { db } = setupDb();
+    createConnection(db, {
+      name: "referenced",
+      provider: "anthropic",
+      auth: { type: "platform" },
+    });
+    const result = deleteConnection(db, "referenced", {
+      force: false,
+      referencingProfiles: ["profile-a", "profile-b"],
+    });
+    expect(result.ok).toBe(false);
+    if (result.ok) return;
+    expect(result.error.code).toBe("has_references");
+    if (result.error.code !== "has_references") return;
+    expect(result.error.count).toBe(2);
+  });
+
+  test("deleteConnection --force removes even with references", () => {
+    const { db } = setupDb();
+    createConnection(db, {
+      name: "force-delete",
+      provider: "anthropic",
+      auth: { type: "platform" },
+    });
+    const result = deleteConnection(db, "force-delete", {
+      force: true,
+      referencingProfiles: ["some-profile"],
+    });
+    expect(result.ok).toBe(true);
+    expect(getConnection(db, "force-delete")).toBeNull();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Auth schema validation
+// ---------------------------------------------------------------------------
+
+describe("AuthSchema", () => {
+  test("api_key variant requires credential", () => {
+    const ok = AuthSchema.safeParse({ type: "api_key", credential: "cred/foo/api_key" });
+    expect(ok.success).toBe(true);
+
+    const bad = AuthSchema.safeParse({ type: "api_key" }); // missing credential
+    expect(bad.success).toBe(false);
+  });
+
+  test("platform variant has no extra fields", () => {
+    const ok = AuthSchema.safeParse({ type: "platform" });
+    expect(ok.success).toBe(true);
+  });
+
+  test("none variant parses", () => {
+    const ok = AuthSchema.safeParse({ type: "none" });
+    expect(ok.success).toBe(true);
+  });
+
+  test("oauth_subscription and service_account parse (v2 variants, runtime-rejected)", () => {
+    expect(
+      AuthSchema.safeParse({ type: "oauth_subscription", credential: "x" }).success,
+    ).toBe(true);
+    expect(
+      AuthSchema.safeParse({ type: "service_account", credential: "x" }).success,
+    ).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Mix-and-match correctness
+// ---------------------------------------------------------------------------
+
+describe("Mix-and-match: two profiles, same provider, different connections", () => {
+  test("getConnection returns the right auth for each connection name", () => {
+    const { db } = setupDb();
+
+    // anthropic-managed already exists (canonical seed) with platform auth.
+    const managedConn = getConnection(db, "anthropic-managed");
+    expect(managedConn?.auth.type).toBe("platform");
+
+    // Create a personal connection with api_key auth.
+    createConnection(db, {
+      name: "anthropic-personal",
+      provider: "anthropic",
+      auth: { type: "api_key", credential: "credential/anthropic/api_key" },
+    });
+
+    const personalConn = getConnection(db, "anthropic-personal");
+    expect(personalConn?.auth.type).toBe("api_key");
+
+    // Both connections exist for the same provider.
+    const anthropicConns = listConnections(db, { provider: "anthropic" });
+    const names = anthropicConns.map((c) => c.name);
+    expect(names).toContain("anthropic-managed");
+    expect(names).toContain("anthropic-personal");
+
+    // Auth is distinct per connection.
+    const managed = anthropicConns.find((c) => c.name === "anthropic-managed");
+    const personal = anthropicConns.find((c) => c.name === "anthropic-personal");
+    expect(managed?.auth.type).toBe("platform");
+    expect(personal?.auth.type).toBe("api_key");
+  });
+});

package/src/providers/__tests__/provider-env-vars.test.ts

@@ -34,6 +34,7 @@ describe("getLlmProviderEnvVar", () => {
   test("returns undefined for search providers (out of scope)", () => {
     expect(getLlmProviderEnvVar("brave")).toBeUndefined();
     expect(getLlmProviderEnvVar("perplexity")).toBeUndefined();
+    expect(getLlmProviderEnvVar("tavily")).toBeUndefined();
   });
 
   test("returns undefined for unknown provider", () => {
@@ -50,6 +51,10 @@ describe("getSearchProviderEnvVar", () => {
     expect(getSearchProviderEnvVar("perplexity")).toBe("PERPLEXITY_API_KEY");
   });
 
+  test("returns TAVILY_API_KEY for tavily", () => {
+    expect(getSearchProviderEnvVar("tavily")).toBe("TAVILY_API_KEY");
+  });
+
   test("returns undefined for LLM providers (out of scope)", () => {
     expect(getSearchProviderEnvVar("anthropic")).toBeUndefined();
     expect(getSearchProviderEnvVar("openai")).toBeUndefined();
@@ -69,6 +74,7 @@ describe("getAnyProviderEnvVar", () => {
   test("returns search env var for search providers", () => {
     expect(getAnyProviderEnvVar("brave")).toBe("BRAVE_API_KEY");
     expect(getAnyProviderEnvVar("perplexity")).toBe("PERPLEXITY_API_KEY");
+    expect(getAnyProviderEnvVar("tavily")).toBe("TAVILY_API_KEY");
   });
 
   test("returns undefined for ollama (keyless LLM provider)", () => {

package/src/providers/__tests__/provider-secret-catalog.test.ts

@@ -39,4 +39,10 @@ describe("API_KEY_PROVIDERS", () => {
     expect(API_KEY_PROVIDERS).toContain("openai");
     expect(API_KEY_PROVIDERS).toContain("gemini");
   });
+
+  test("includes search providers", () => {
+    expect(API_KEY_PROVIDERS).toContain("brave");
+    expect(API_KEY_PROVIDERS).toContain("perplexity");
+    expect(API_KEY_PROVIDERS).toContain("tavily");
+  });
 });

package/src/providers/__tests__/retry-callsite.test.ts

@@ -38,7 +38,6 @@ mock.module("../registry.js", () => ({
 // ── Imports (after mocks) ───────────────────────────────────────────────────
 
 import { LLMSchema } from "../../config/schemas/llm.js";
-import { getConfiguredProvider } from "../provider-send-message.js";
 import { RetryProvider } from "../retry.js";
 import type {
   Message,
@@ -47,6 +46,13 @@ import type {
   SendMessageOptions,
 } from "../types.js";
 
+// Side-effect import: ensures `provider-send-message.ts` (and its transitive
+// `connection-resolution` + `registry`) are loaded in a deterministic order
+// across the test suite. Without this, bun's module loader has produced
+// "Export named 'clearConnectionProviderCache' not found" errors when this
+// file runs before others that mock `registry.js`.
+import "../provider-send-message.js";
+
 // ── Test fixtures ──────────────────────────────────────────────────────────
 
 const DUMMY_MESSAGES: Message[] = [
@@ -746,34 +752,10 @@ describe("RetryProvider — no callSite (pre-resolved config passes through)", (
   });
 });
 
-// ── getConfiguredProvider — call-site routing ──────────────────────────────
-
-describe("getConfiguredProvider — callSite routing", () => {
-  test("selects provider from llm.callSites[id].provider when callSite given", async () => {
-    setLlmConfig({
-      default: { provider: "anthropic", model: "claude-opus-4-7" },
-      callSites: {
-        heartbeatAgent: { provider: "openai", model: "gpt-5.4" },
-      },
-    });
-    mockProviders.set("openai", { name: "openai" });
-    mockProviders.set("anthropic", { name: "anthropic" });
-
-    const provider = await getConfiguredProvider("heartbeatAgent");
-    expect(provider?.name).toBe("openai");
-  });
-
-  test("falls back to llm.default.provider when callSite has no provider override", async () => {
-    setLlmConfig({
-      default: { provider: "anthropic", model: "claude-opus-4-7" },
-      callSites: {
-        // No provider field — default takes over.
-        heartbeatAgent: { model: "claude-haiku-4-5-20251001" },
-      },
-    });
-    mockProviders.set("anthropic", { name: "anthropic" });
-
-    const provider = await getConfiguredProvider("heartbeatAgent");
-    expect(provider?.name).toBe("anthropic");
-  });
-});
+// `getConfiguredProvider` — call-site routing coverage lives in
+// `dispatch-connection-routing.test.ts`, where the connection lookup is
+// fully mocked. Keeping those tests here would require mocking
+// `inference/connections.js` and `memory/db-connection.js` at the file
+// level, and bun's `mock.module` leaks across files in a single suite
+// run — that pollutes `inference.test.ts` (which exercises the real
+// SQLite-backed `getConnection`).