@vellumai/assistant 0.7.3 → 0.8.1

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`).