@vellumai/assistant 0.8.0 → 0.8.1

package/src/__tests__/inference-no-mode-boot-e2e.test.ts

@@ -0,0 +1,246 @@
+/**
+ * Cutover-proof e2e: boot with a config that has no `services.inference.mode`
+ * field (the field was removed in Phase 1.2) and verify that:
+ *
+ *  1. The Zod schema parses the config without errors.
+ *  2. `initializeProviders` registers a `user-key` provider for any provider
+ *     that has a credential in the test vault.
+ *  3. A dispatch through a profile that references an `api_key`-auth connection
+ *     succeeds when the underlying vault credential exists.
+ *  4. A dispatch through a profile that references a `platform`-auth connection
+ *     (managed, not yet seeded — PR-D) fails with `ConnectionResolutionError`
+ *     reason `not_found`.
+ *
+ * This is the gate test mandated by the cc-cutover-proof rule for Phase 1.2.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Mocks — declared before imports that pull in transitive deps
+// ---------------------------------------------------------------------------
+
+const logProxy = new Proxy({} as Record<string, unknown>, {
+  get: () => () => {},
+});
+mock.module("../util/logger.js", () => ({
+  getLogger: () => logProxy,
+}));
+
+// Vault mock — keyed by credential name.
+const mockVault: Record<string, string | null> = {};
+
+mock.module("../security/secure-keys.js", () => ({
+  getSecureKeyAsync: async (key: string) => mockVault[key] ?? null,
+}));
+
+// Managed proxy context — always unavailable in this test (no platform auth).
+mock.module("../providers/managed-proxy/context.js", () => ({
+  buildManagedBaseUrl: async () => null,
+  resolveManagedProxyContext: async () => {
+    throw new Error("managed proxy not available in test");
+  },
+}));
+
+// DB mock — getConnection returns null (no managed connections seeded yet).
+const mockGetConnection: Record<string, unknown> = {};
+mock.module("../providers/inference/connections.js", () => ({
+  getConnection: (_db: unknown, name: string) =>
+    mockGetConnection[name] ?? null,
+  listConnections: () => [],
+  createConnection: () => ({ ok: true, value: {} }),
+  seedCanonicalConnections: () => {},
+}));
+
+mock.module("../memory/db-connection.js", () => ({
+  getDb: () => ({
+    select: () => ({ from: () => ({ where: () => ({ get: () => null, all: () => [] }), all: () => [] }) }),
+    insert: () => ({ values: () => ({ run: () => {} }) }),
+  }),
+}));
+
+// Anthropic SDK mock — returns a canned response.
+mock.module("@anthropic-ai/sdk", () => ({
+  default: class MockAnthropic {
+    messages = {
+      stream: () => ({
+        [Symbol.asyncIterator]: async function* () {
+          yield {
+            type: "content_block_delta",
+            delta: { type: "text_delta", text: "ok" },
+          };
+          yield {
+            type: "message_delta",
+            usage: { output_tokens: 1 },
+            delta: { stop_reason: "end_turn" },
+          };
+        },
+        finalMessage: async () => ({
+          content: [{ type: "text", text: "ok" }],
+          model: "claude-opus-4-7",
+          usage: { input_tokens: 10, output_tokens: 1 },
+          stop_reason: "end_turn",
+        }),
+      }),
+    };
+    constructor(_opts: unknown) {}
+  },
+}));
+
+// ---------------------------------------------------------------------------
+// Imports (after mocks)
+// ---------------------------------------------------------------------------
+
+import { AssistantConfigSchema } from "../config/schema.js";
+import { LLMSchema } from "../config/schemas/llm.js";
+import { ConnectionResolutionError } from "../providers/connection-resolution.js";
+import {
+  getProvider,
+  getProviderRoutingSource,
+  initializeProviders,
+  listProviders,
+} from "../providers/registry.js";
+import { credentialKey } from "../security/credential-key.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const baseLlm = LLMSchema.parse({});
+
+function makeConfig(overrides?: Record<string, unknown>) {
+  return {
+    services: {
+      inference: {},
+      "image-generation": {
+        mode: "your-own" as const,
+        provider: "gemini",
+        model: "gemini-3.1-flash-image-preview",
+      },
+      "web-search": { mode: "your-own" as const, provider: "inference-provider-native" },
+    },
+    llm: {
+      ...baseLlm,
+      default: {
+        ...baseLlm.default,
+        provider: "anthropic" as const,
+        model: "claude-opus-4-7",
+        provider_connection: "anthropic-personal",
+      },
+    },
+    ...overrides,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("inference-no-mode-boot-e2e: config without services.inference.mode", () => {
+  beforeEach(() => {
+    // Clear vault and connection registry between tests.
+    for (const k of Object.keys(mockVault)) {
+      delete mockVault[k];
+    }
+    for (const k of Object.keys(mockGetConnection)) {
+      delete mockGetConnection[k];
+    }
+  });
+
+  // ── Gate 1: Schema parses cleanly ───────────────────────────────────────
+
+  test("Zod schema parses config with no services.inference.mode without error", () => {
+    const raw = {
+      services: { inference: {} },
+      llm: { default: { provider: "anthropic", model: "claude-opus-4-7" } },
+    };
+    const result = AssistantConfigSchema.safeParse(raw);
+    expect(result.success).toBe(true);
+    if (result.success) {
+      // inference is an empty object — no mode field
+      expect(result.data.services.inference).toEqual({});
+    }
+  });
+
+  test("Zod schema also parses config with services.inference absent entirely", () => {
+    const raw = {
+      llm: { default: { provider: "anthropic", model: "claude-opus-4-7" } },
+    };
+    const result = AssistantConfigSchema.safeParse(raw);
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.services.inference).toEqual({});
+    }
+  });
+
+  // ── Gate 2: initializeProviders populates routingSources ────────────────
+
+  test("initializeProviders registers anthropic user-key when vault has a credential", async () => {
+    mockVault[credentialKey("anthropic", "api_key")] = "sk-ant-test-key";
+
+    await initializeProviders(makeConfig());
+
+    expect(listProviders()).toContain("anthropic");
+    expect(getProviderRoutingSource("anthropic")).toBe("user-key");
+  });
+
+  test("initializeProviders skips anthropic when vault has no credential", async () => {
+    // No key in vault.
+    await initializeProviders(makeConfig());
+
+    expect(listProviders()).not.toContain("anthropic");
+    expect(getProviderRoutingSource("anthropic")).toBeUndefined();
+  });
+
+  test("initializeProviders registers multiple providers independently", async () => {
+    mockVault[credentialKey("anthropic", "api_key")] = "sk-ant-test";
+    mockVault[credentialKey("openai", "api_key")] = "sk-openai-test";
+
+    await initializeProviders(makeConfig());
+
+    expect(listProviders()).toContain("anthropic");
+    expect(listProviders()).toContain("openai");
+    expect(getProviderRoutingSource("anthropic")).toBe("user-key");
+    expect(getProviderRoutingSource("openai")).toBe("user-key");
+    expect(listProviders()).not.toContain("gemini");
+  });
+
+  // ── Gate 3: api_key-auth connection dispatch succeeds ───────────────────
+
+  test("getProvider returns a registered provider after initializeProviders with a user key", async () => {
+    mockVault[credentialKey("anthropic", "api_key")] = "sk-ant-test-key";
+    await initializeProviders(makeConfig());
+
+    const provider = getProvider("anthropic");
+    expect(provider).toBeDefined();
+    expect(typeof provider.sendMessage).toBe("function");
+  });
+
+  // ── Gate 4: platform-auth connection fails with ConnectionResolutionError ─
+
+  test("ConnectionResolutionError is exported with expected reason codes", () => {
+    const err = new ConnectionResolutionError(
+      "anthropic-managed",
+      "not_found",
+      'provider_connection "anthropic-managed" not found — managed connections not yet seeded (PR-D)',
+    );
+    expect(err).toBeInstanceOf(ConnectionResolutionError);
+    expect(err.reason).toBe("not_found");
+    expect(err.connectionName).toBe("anthropic-managed");
+  });
+
+  test("tryResolveProviderForConnectionName throws not_found for an unseed managed connection", async () => {
+    // anthropic-managed is not in mockGetConnection (simulates PR-D not yet run).
+    const { tryResolveProviderForConnectionName } = await import(
+      "../providers/connection-resolution.js"
+    );
+
+    await expect(
+      tryResolveProviderForConnectionName("anthropic-managed", makeConfig()),
+    ).rejects.toMatchObject({
+      name: "ConnectionResolutionError",
+      reason: "not_found",
+      connectionName: "anthropic-managed",
+    });
+  });
+});

package/src/__tests__/inference-profile-reaper.test.ts

@@ -0,0 +1,154 @@
+import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { makeMockLogger } from "./helpers/mock-logger.js";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => makeMockLogger(),
+}));
+
+import {
+  createConversation,
+  getConversation,
+  setConversationInferenceProfileSession,
+} from "../memory/conversation-crud.js";
+import { getDb, resetDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { assistantEventHub } from "../runtime/assistant-event-hub.js";
+import {
+  startInferenceProfileSessionReaper,
+  stopInferenceProfileSessionReaper,
+  tickInferenceProfileReaper,
+} from "../runtime/routes/inference-profile-session-reaper.js";
+
+initializeDb();
+
+function clearTables(): void {
+  const db = getDb();
+  db.run("DELETE FROM conversation_assistant_attention_state");
+  db.run("DELETE FROM external_conversation_bindings");
+  db.run("DELETE FROM conversation_keys");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+}
+
+describe("inference-profile-session-reaper", () => {
+  beforeEach(() => {
+    clearTables();
+    stopInferenceProfileSessionReaper();
+  });
+
+  afterAll(() => {
+    stopInferenceProfileSessionReaper();
+    resetDb();
+    mock.restore();
+  });
+
+  test("basic sweep: clears 2 expired sessions, leaves 1 future session untouched, emits 2 events", async () => {
+    const conv1 = createConversation("reaper-conv-1");
+    const conv2 = createConversation("reaper-conv-2");
+    const conv3 = createConversation("reaper-conv-3");
+
+    // Two expired sessions
+    setConversationInferenceProfileSession(
+      conv1.id,
+      "balanced",
+      "session-1",
+      Date.now() - 1,
+    );
+    setConversationInferenceProfileSession(
+      conv2.id,
+      "quality-optimized",
+      "session-2",
+      Date.now() - 1,
+    );
+    // One future session — should NOT be cleared
+    setConversationInferenceProfileSession(
+      conv3.id,
+      "cost-optimized",
+      "session-3",
+      Date.now() + 60_000,
+    );
+
+    const publishedEvents: Array<{
+      conversationId: string | undefined;
+      profile: string | null | undefined;
+    }> = [];
+    const subscription = assistantEventHub.subscribe({
+      type: "process",
+      callback: (event) => {
+        if (event.message.type === "conversation_inference_profile_updated") {
+          publishedEvents.push({
+            conversationId: event.conversationId,
+            profile: event.message.profile,
+          });
+        }
+      },
+    });
+
+    tickInferenceProfileReaper();
+    // Allow microtasks (promise callbacks) to settle
+    await Promise.resolve();
+
+    // Expired rows should be cleared
+    expect(getConversation(conv1.id)?.inferenceProfile).toBeNull();
+    expect(getConversation(conv1.id)?.inferenceProfileExpiresAt).toBeNull();
+    expect(getConversation(conv2.id)?.inferenceProfile).toBeNull();
+    expect(getConversation(conv2.id)?.inferenceProfileExpiresAt).toBeNull();
+
+    // Future row should be untouched
+    expect(getConversation(conv3.id)?.inferenceProfile).toBe("cost-optimized");
+    expect(getConversation(conv3.id)?.inferenceProfileExpiresAt).not.toBeNull();
+
+    // Exactly 2 events emitted
+    expect(publishedEvents).toHaveLength(2);
+    const convIds = publishedEvents.map((e) => e.conversationId).sort();
+    expect(convIds).toEqual([conv1.id, conv2.id].sort());
+    for (const ev of publishedEvents) {
+      expect(ev.profile).toBeNull();
+    }
+
+    subscription.dispose();
+  });
+
+  test("CAS protection: row with NULL expiresAt (sticky override) is not touched", async () => {
+    const conv = createConversation("reaper-cas-conv");
+
+    // Seed a row that initially looks expired — but before the reaper runs,
+    // simulate a concurrent write that sets expiresAt to NULL (sticky override).
+    setConversationInferenceProfileSession(
+      conv.id,
+      "balanced",
+      null,
+      null, // NULL expiresAt — sticky, non-session override
+    );
+
+    tickInferenceProfileReaper();
+    await Promise.resolve();
+
+    // The row must not have been cleared — expiresAt was NULL so the WHERE
+    // condition `inference_profile_expires_at IS NOT NULL AND <= now` did not match.
+    const row = getConversation(conv.id);
+    expect(row?.inferenceProfile).toBe("balanced");
+    expect(row?.inferenceProfileExpiresAt).toBeNull();
+  });
+
+  test("stop function clears the interval", () => {
+    startInferenceProfileSessionReaper();
+    // Timer should now be running (non-null internally)
+    // We verify by stopping and confirming stop is idempotent without throwing.
+    stopInferenceProfileSessionReaper();
+    // Calling stop again must be safe
+    stopInferenceProfileSessionReaper();
+  });
+
+  test("idempotent start: calling startInferenceProfileSessionReaper twice uses a single timer", () => {
+    startInferenceProfileSessionReaper();
+    // A second call should be a no-op — the idempotency guard (`if (reaperTimer) return`)
+    // prevents a second interval from being created.
+    startInferenceProfileSessionReaper();
+
+    // Verify stop cleans up without errors (would throw on double-clear if two
+    // timers had been registered, though setInterval handles that gracefully).
+    stopInferenceProfileSessionReaper();
+  });
+});