@vellumai/assistant 0.8.0 → 0.8.2

package/src/__tests__/llm-call-pipeline.test.ts

@@ -157,7 +157,6 @@ describe("llmCall pipeline", () => {
       manifest: {
         name: "spy-llm",
         version: "0.0.1",
-        requires: { pluginRuntime: "v1" },
       },
       middleware: {
         llmCall: async (args, next, _ctx) => {
@@ -209,7 +208,6 @@ describe("llmCall pipeline", () => {
       manifest: {
         name: "spy-llm-after-default",
         version: "0.0.1",
-        requires: { pluginRuntime: "v1" },
       },
       middleware: {
         llmCall: async (args, next, _ctx) => {
@@ -255,7 +253,6 @@ describe("llmCall pipeline", () => {
       manifest: {
         name: "short-circuit-llm",
         version: "0.0.1",
-        requires: { pluginRuntime: "v1" },
       },
       middleware: { llmCall: shortCircuit },
     };

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

@@ -2,7 +2,7 @@ import { describe, expect, test } from "bun:test";
 
 import { getLLMCallSiteLabel } from "../config/llm-callsite-catalog.js";
 import { CALL_SITE_CATALOG } from "../config/schemas/call-site-catalog.js";
-import { LLMCallSiteEnum } from "../config/schemas/llm.js";
+import { LLMCallSiteEnum, LLMSchema } from "../config/schemas/llm.js";
 
 describe("LLM call-site catalog", () => {
   test("resolves every backend call-site enum value from the catalog", () => {
@@ -31,4 +31,23 @@ describe("LLM call-site catalog", () => {
   test("returns the raw ID for unknown call sites", () => {
     expect(getLLMCallSiteLabel("unknownCallSite")).toBe("unknownCallSite");
   });
+
+  test("registers the memoryRouter call site under the memory domain", () => {
+    expect(LLMCallSiteEnum.options).toContain("memoryRouter");
+
+    const entry = CALL_SITE_CATALOG.find(({ id }) => id === "memoryRouter");
+    expect(entry).toBeDefined();
+    expect(entry?.domain).toBe("memory");
+    expect(entry?.displayName).toBe("Memory Router");
+    expect(entry?.description).toBe(
+      "Selects which concept pages to inject for the next agent turn by routing over a cached page index.",
+    );
+  });
+
+  test("memoryRouter is addressable as a call-site override key in LLMSchema", () => {
+    const parsed = LLMSchema.parse({
+      callSites: { memoryRouter: { model: "claude-sonnet-4-6" } },
+    });
+    expect(parsed.callSites.memoryRouter?.model).toBe("claude-sonnet-4-6");
+  });
 });

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

@@ -3,6 +3,8 @@ import { join } from "node:path";
 import { describe, expect, test } from "bun:test";
 
 import { PROVIDER_CATALOG } from "../providers/model-catalog.js";
+import { PLATFORM_PROVIDER_META } from "../providers/platform-proxy/constants.js";
+import { resolvePricing, resolvePricingForUsage } from "../util/pricing.js";
 
 /**
  * Parity guard: daemon LLM provider catalog vs client LLM catalog JSON.
@@ -27,6 +29,15 @@ function getRepoRoot(): string {
   return join(process.cwd(), "..");
 }
 
+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;
   url: string;
@@ -50,6 +61,13 @@ interface ClientCatalogModel {
     outputPer1mTokens: number;
     cacheWritePer1mTokens?: number;
     cacheReadPer1mTokens?: number;
+    tiers?: Array<{
+      inputTokenThreshold: number;
+      inputPer1mTokens: number;
+      outputPer1mTokens: number;
+      cacheReadPer1mTokens?: number;
+      cacheWritePer1mTokens?: number;
+    }>;
   };
 }
 
@@ -62,6 +80,7 @@ interface ClientCatalogEntry {
   envVar?: string;
   apiKeyPlaceholder?: string;
   credentialsGuide?: ClientCatalogCredentialsGuide;
+  supportsPlatformAuth?: boolean;
   defaultModel: string;
   models: ClientCatalogModel[];
 }
@@ -72,8 +91,7 @@ interface ClientCatalog {
 }
 
 function loadClientCatalog(): ClientCatalog {
-  const catalogPath = join(getRepoRoot(), "meta", "llm-provider-catalog.json");
-  const raw = readFileSync(catalogPath, "utf-8");
+  const raw = readFileSync(META_JSON_PATH, "utf-8");
   return JSON.parse(raw);
 }
 
@@ -114,6 +132,9 @@ describe("LLM catalog parity: daemon vs client", () => {
       expect(clientEntry.setupHint).toBe(daemonEntry.setupHint);
       expect(clientEntry.envVar).toBe(daemonEntry.envVar);
       expect(clientEntry.apiKeyPlaceholder).toBe(daemonEntry.apiKeyPlaceholder);
+      expect(clientEntry.supportsPlatformAuth).toBe(
+        daemonEntry.supportsPlatformAuth,
+      );
       expect(clientEntry.credentialsGuide).toEqual(
         daemonEntry.credentialsGuide,
       );
@@ -121,6 +142,19 @@ describe("LLM catalog parity: daemon vs client", () => {
     }
   });
 
+  test("supportsPlatformAuth mirrors PLATFORM_PROVIDER_META", () => {
+    // The catalog field is derived from PLATFORM_PROVIDER_META at build
+    // time. This test guards against future hand-edits to model-catalog.ts
+    // that would let the two drift. Adding a provider to PLATFORM_PROVIDER_META
+    // must auto-propagate; flipping `managed: true` to `false` (or vice
+    // versa) must propagate too.
+    for (const entry of PROVIDER_CATALOG) {
+      const expectedSupportsManagedAuth =
+        PLATFORM_PROVIDER_META[entry.id]?.managed === true;
+      expect(entry.supportsPlatformAuth).toBe(expectedSupportsManagedAuth);
+    }
+  });
+
   test("each provider's model count matches the daemon catalog", () => {
     const json = loadClientCatalog();
 
@@ -182,6 +216,26 @@ describe("LLM catalog parity: daemon vs client", () => {
     }
   });
 
+  test("cache pricing rates are positive when defined", () => {
+    for (const entry of PROVIDER_CATALOG) {
+      for (const model of entry.models) {
+        if (!model.pricing) continue;
+        if (model.pricing.cacheReadPer1mTokens !== undefined) {
+          expect(
+            model.pricing.cacheReadPer1mTokens,
+            `${entry.id}/${model.id} cacheReadPer1mTokens must be positive`,
+          ).toBeGreaterThan(0);
+        }
+        if (model.pricing.cacheWritePer1mTokens !== undefined) {
+          expect(
+            model.pricing.cacheWritePer1mTokens,
+            `${entry.id}/${model.id} cacheWritePer1mTokens must be positive`,
+          ).toBeGreaterThan(0);
+        }
+      }
+    }
+  });
+
   test("every model default context is capped by its context window", () => {
     const json = loadClientCatalog();
 
@@ -248,6 +302,125 @@ describe("LLM catalog parity: daemon vs client", () => {
     });
   });
 
+  // -----------------------------------------------------------------------
+  // pricing.ts ↔ model-catalog.ts parity
+  //
+  // `assistant/src/util/pricing.ts` reads pricing from `PROVIDER_CATALOG`
+  // (catalog-first) with a legacy fallback table for models we still bill
+  // for but no longer advertise. These tests probe `resolvePricing` /
+  // `resolvePricingForUsage` for every priced catalog model so any drift
+  // between the catalog row and the resolver's output (including cache
+  // discounts and long-context tier rates) fails CI.
+  // -----------------------------------------------------------------------
+
+  test("each priced catalog model has matching base rates in pricing.ts", () => {
+    // 100k tokens stays below every long-context tier threshold in the
+    // catalog (smallest threshold is 200k), so resolvePricing returns the
+    // base rate uncontaminated by tier selection.
+    const PROBE_TOKENS = 100_000;
+    const TOKENS_PER_MILLION = 1_000_000;
+
+    for (const provider of PROVIDER_CATALOG) {
+      for (const model of provider.models) {
+        if (!model.pricing) continue;
+
+        const inputResult = resolvePricing(
+          provider.id,
+          model.id,
+          PROBE_TOKENS,
+          0,
+        );
+        expect(
+          inputResult.pricingStatus,
+          `${provider.id}/${model.id} unpriced in pricing.ts`,
+        ).toBe("priced");
+        const inputRate =
+          (inputResult.estimatedCostUsd ?? 0) *
+          (TOKENS_PER_MILLION / PROBE_TOKENS);
+        expect(
+          inputRate,
+          `${provider.id}/${model.id} input rate drift`,
+        ).toBeCloseTo(model.pricing.inputPer1mTokens, 6);
+
+        const outputResult = resolvePricing(
+          provider.id,
+          model.id,
+          0,
+          PROBE_TOKENS,
+        );
+        const outputRate =
+          (outputResult.estimatedCostUsd ?? 0) *
+          (TOKENS_PER_MILLION / PROBE_TOKENS);
+        expect(
+          outputRate,
+          `${provider.id}/${model.id} output rate drift`,
+        ).toBeCloseTo(model.pricing.outputPer1mTokens, 6);
+      }
+    }
+  });
+
+  test("each priced catalog model has matching cache-read rate in pricing.ts", () => {
+    const PROBE_TOKENS = 100_000;
+    const TOKENS_PER_MILLION = 1_000_000;
+
+    for (const provider of PROVIDER_CATALOG) {
+      for (const model of provider.models) {
+        const cacheReadCatalogRate = model.pricing?.cacheReadPer1mTokens;
+        if (cacheReadCatalogRate === undefined) continue;
+
+        const result = resolvePricingForUsage(provider.id, model.id, {
+          directInputTokens: 0,
+          outputTokens: 0,
+          cacheCreationInputTokens: 0,
+          cacheReadInputTokens: PROBE_TOKENS,
+          anthropicCacheCreation: null,
+        });
+        expect(
+          result.pricingStatus,
+          `${provider.id}/${model.id} unpriced in pricing.ts`,
+        ).toBe("priced");
+        const cacheReadResolvedRate =
+          (result.estimatedCostUsd ?? 0) * (TOKENS_PER_MILLION / PROBE_TOKENS);
+        expect(
+          cacheReadResolvedRate,
+          `${provider.id}/${model.id} cache-read rate drift`,
+        ).toBeCloseTo(cacheReadCatalogRate, 6);
+      }
+    }
+  });
+
+  test("each priced catalog tier resolves at its tier rate", () => {
+    const TOKENS_PER_MILLION = 1_000_000;
+
+    for (const provider of PROVIDER_CATALOG) {
+      for (const model of provider.models) {
+        const tiers = model.pricing?.tiers;
+        if (!tiers || tiers.length === 0) continue;
+
+        for (const tier of tiers) {
+          const probeTokens = tier.inputTokenThreshold + 1_000;
+          const result = resolvePricingForUsage(provider.id, model.id, {
+            directInputTokens: probeTokens,
+            outputTokens: 0,
+            cacheCreationInputTokens: 0,
+            cacheReadInputTokens: 0,
+            anthropicCacheCreation: null,
+          });
+          expect(
+            result.pricingStatus,
+            `${provider.id}/${model.id} unpriced at tier ${tier.inputTokenThreshold}`,
+          ).toBe("priced");
+          const resolvedRate =
+            (result.estimatedCostUsd ?? 0) * (TOKENS_PER_MILLION / probeTokens);
+          expect(
+            resolvedRate,
+            `${provider.id}/${model.id} input rate drift at tier ${tier.inputTokenThreshold}`,
+          ).toBeCloseTo(tier.inputPer1mTokens, 6);
+        }
+      }
+    }
+  });
+
   test("Gemini 2.5 Pro catalog context matches provider limits", () => {
     const gemini = PROVIDER_CATALOG.find((entry) => entry.id === "gemini");
     expect(
@@ -261,4 +434,19 @@ 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-request-log-source-clickhouse.test.ts

@@ -0,0 +1,222 @@
+import { describe, expect, mock, test } from "bun:test";
+
+function makeLoggerStub(): Record<string, unknown> {
+  const stub: Record<string, unknown> = {};
+  for (const m of [
+    "info",
+    "warn",
+    "error",
+    "debug",
+    "trace",
+    "fatal",
+    "silent",
+    "child",
+  ]) {
+    stub[m] = m === "child" ? () => makeLoggerStub() : () => {};
+  }
+  return stub;
+}
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => makeLoggerStub(),
+}));
+
+import { ClickHouseLlmRequestLogSource } from "../memory/llm-request-log-source-clickhouse.js";
+
+const DEFAULT_CONFIG = {
+  database: "default",
+  table: "llm_request_logs",
+  user: "default",
+};
+
+interface FakeFetchCall {
+  url: string;
+  init: RequestInit | undefined;
+}
+
+function fakeFetchReturning(
+  body: string,
+  status = 200,
+  recorder?: FakeFetchCall[],
+): typeof fetch {
+  return ((url: string | URL | Request, init?: RequestInit) => {
+    recorder?.push({
+      url: typeof url === "string" ? url : url.toString(),
+      init,
+    });
+    return Promise.resolve(
+      new Response(body, {
+        status,
+        headers: { "content-type": "application/x-ndjson" },
+      }),
+    );
+  }) as typeof fetch;
+}
+
+function makeSource(opts: {
+  body?: string;
+  status?: number;
+  recorder?: FakeFetchCall[];
+  resolveTurnMessageIds?: (messageId: string) => string[];
+  resolveMessage?: (messageId: string) => { metadata: string | null } | null;
+}) {
+  return new ClickHouseLlmRequestLogSource(DEFAULT_CONFIG, {
+    resolveUrl: async () => "https://ch.example.test:8443",
+    resolvePassword: async () => "hunter2",
+    resolveAssistantId: async () => "asst-fixture-001",
+    resolveTurnMessageIds: opts.resolveTurnMessageIds ?? (() => []),
+    resolveMessage: opts.resolveMessage ?? (() => null),
+    fetchImpl: fakeFetchReturning(
+      opts.body ?? "",
+      opts.status ?? 200,
+      opts.recorder,
+    ),
+  });
+}
+
+const SAMPLE_ROW = {
+  id: "log-1",
+  conversation_id: "conv-1",
+  message_id: "msg-1",
+  provider: "anthropic",
+  request_payload: '{"foo":1}',
+  response_payload: '{"bar":2}',
+  // ClickHouse emits Int64 as a quoted string under JSONEachRow by default.
+  created_at: "1778465138786",
+};
+
+describe("ClickHouseLlmRequestLogSource", () => {
+  test("getRequestLogById returns null on empty response", async () => {
+    const src = makeSource({ body: "" });
+    expect(await src.getRequestLogById("missing")).toBeNull();
+  });
+
+  test("getRequestLogById parses a single JSONEachRow row into LogRow", async () => {
+    const src = makeSource({ body: JSON.stringify(SAMPLE_ROW) + "\n" });
+    const row = await src.getRequestLogById("log-1");
+    expect(row).toEqual({
+      id: "log-1",
+      conversationId: "conv-1",
+      messageId: "msg-1",
+      provider: "anthropic",
+      requestPayload: '{"foo":1}',
+      responsePayload: '{"bar":2}',
+      createdAt: 1778465138786,
+    });
+  });
+
+  test("maps empty-string message_id and provider back to null", async () => {
+    const src = makeSource({
+      body:
+        JSON.stringify({
+          ...SAMPLE_ROW,
+          message_id: "",
+          provider: "",
+        }) + "\n",
+    });
+    const row = await src.getRequestLogById("log-1");
+    expect(row?.messageId).toBeNull();
+    expect(row?.provider).toBeNull();
+  });
+
+  test("sets the database URL param + assistant_id query param + Basic auth", async () => {
+    const recorder: FakeFetchCall[] = [];
+    const src = makeSource({
+      body: JSON.stringify(SAMPLE_ROW) + "\n",
+      recorder,
+    });
+    await src.getRequestLogById("log-1");
+    expect(recorder).toHaveLength(1);
+    const call = recorder[0]!;
+    const parsed = new URL(call.url);
+    expect(parsed.searchParams.get("database")).toBe("default");
+    expect(parsed.searchParams.get("param_assistant_id")).toBe("asst-fixture-001");
+    expect(parsed.searchParams.get("param_log_id")).toBe("log-1");
+    expect(call.init?.method).toBe("POST");
+    const auth = (call.init?.headers as Record<string, string>).Authorization;
+    expect(auth).toMatch(/^Basic /);
+    const decoded = Buffer.from(auth.slice("Basic ".length), "base64").toString(
+      "utf8",
+    );
+    expect(decoded).toBe("default:hunter2");
+    // The SQL body should reference the configured table and the parameterized
+    // placeholders ClickHouse will substitute from `param_*`.
+    expect(call.init?.body).toContain("`llm_request_logs`");
+    expect(call.init?.body).toContain("{assistant_id:String}");
+    expect(call.init?.body).toContain("{log_id:String}");
+  });
+
+  test("throws a descriptive error on non-2xx", async () => {
+    const src = makeSource({ body: "boom", status: 503 });
+    await expect(src.getRequestLogById("log-1")).rejects.toThrow(
+      /ClickHouse query failed \(HTTP 503\): boom/,
+    );
+  });
+
+  test("getRequestLogsByMessageId returns [] when turn resolution yields no message IDs", async () => {
+    // The module-level mock of conversation-crud returns [] for the turn,
+    // and null for fork-source resolution, so this exercises the empty path
+    // without any database setup.
+    const src = makeSource({ body: "" });
+    const rows = await src.getRequestLogsByMessageId("msg-x");
+    expect(rows).toEqual([]);
+  });
+
+  test("getRequestLogsByMessageId binds message ids via parameterized placeholders", async () => {
+    // Regression for ATL-537. `getAssistantMessageIdsInTurn` returns the
+    // caller-supplied id straight through when the message lookup misses,
+    // so the value passed in here is what the IN clause receives. The id
+    // ends in a backslash on purpose: with the old inline-literal approach
+    // (quote-doubling only), ClickHouse would honor `\'` as an escaped
+    // quote and the string literal would break out of the IN clause.
+    // The fix binds each id as a typed `{id_N:String}` parameter, so the
+    // hostile content flows as data, never syntax.
+    const recorder: FakeFetchCall[] = [];
+    const malicious = "foo\\";
+    const src = makeSource({
+      body: "",
+      recorder,
+      resolveTurnMessageIds: () => [malicious, "msg-b"],
+    });
+    await src.getRequestLogsByMessageId(malicious);
+    expect(recorder).toHaveLength(1);
+    const call = recorder[0]!;
+    const parsed = new URL(call.url);
+    expect(parsed.searchParams.get("param_assistant_id")).toBe(
+      "asst-fixture-001",
+    );
+    expect(parsed.searchParams.get("param_id_0")).toBe(malicious);
+    expect(parsed.searchParams.get("param_id_1")).toBe("msg-b");
+    const body = String(call.init?.body ?? "");
+    expect(body).toContain("message_id IN ({id_0:String},{id_1:String})");
+    // No inline single-quoted literal should appear for the IN clause:
+    // if any caller-supplied id surfaces unbound in the SQL, that's the
+    // injection surface the regression test guards against.
+    expect(body).not.toContain(`'${malicious}'`);
+    expect(body).not.toContain(`'msg-b'`);
+  });
+
+  test("missing clickhouse:url credential surfaces a clear error", async () => {
+    const src = new ClickHouseLlmRequestLogSource(DEFAULT_CONFIG, {
+      resolveUrl: async () => null,
+      resolvePassword: async () => "x",
+      resolveAssistantId: async () => "asst-1",
+      fetchImpl: fakeFetchReturning(""),
+    });
+    await expect(src.getRequestLogById("log-1")).rejects.toThrow(
+      /clickhouse:url credential is required/,
+    );
+  });
+
+  test("missing vellum:platform_assistant_id surfaces a clear error", async () => {
+    const src = new ClickHouseLlmRequestLogSource(DEFAULT_CONFIG, {
+      resolveUrl: async () => "https://ch.example.test",
+      resolvePassword: async () => "x",
+      resolveAssistantId: async () => null,
+      fetchImpl: fakeFetchReturning(""),
+    });
+    await expect(src.getRequestLogById("log-1")).rejects.toThrow(
+      /vellum:platform_assistant_id credential is required/,
+    );
+  });
+});

package/src/__tests__/llm-request-log-source-factory.test.ts

@@ -0,0 +1,100 @@
+import { afterAll, describe, expect, mock, test } from "bun:test";
+
+function makeLoggerStub(): Record<string, unknown> {
+  const stub: Record<string, unknown> = {};
+  for (const m of [
+    "info",
+    "warn",
+    "error",
+    "debug",
+    "trace",
+    "fatal",
+    "silent",
+    "child",
+  ]) {
+    stub[m] = m === "child" ? () => makeLoggerStub() : () => {};
+  }
+  return stub;
+}
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => makeLoggerStub(),
+}));
+
+// Configurable config stub. Each test sets `currentConfig` before calling
+// the factory. The ClickHouse source is dynamic-imported, so its
+// constructor runs lazily; we don't need to mock conversation-crud here
+// because none of the factory tests exercise the CH read path.
+const LOCAL_DEFAULT_CONFIG = { llmRequestLogs: { readSource: "local" } };
+let currentConfig: unknown = LOCAL_DEFAULT_CONFIG;
+mock.module("../config/loader.js", () => ({
+  getConfig: () => currentConfig,
+}));
+
+// Bun's `mock.module()` persists process-wide; reset to the safe local
+// default after this file runs so other test files that touch this module
+// (or transitively call `getConfig()` through the factory) don't pick up
+// a stale `readSource=clickhouse` value.
+afterAll(() => {
+  currentConfig = LOCAL_DEFAULT_CONFIG;
+});
+
+import { getLlmRequestLogSource } from "../memory/llm-request-log-source.js";
+import { ClickHouseLlmRequestLogSource } from "../memory/llm-request-log-source-clickhouse.js";
+import { LocalLlmRequestLogSource } from "../memory/llm-request-log-source-local.js";
+
+describe("getLlmRequestLogSource factory", () => {
+  test("returns LocalLlmRequestLogSource when readSource is 'local'", async () => {
+    currentConfig = { llmRequestLogs: { readSource: "local" } };
+    const src = await getLlmRequestLogSource();
+    expect(src).toBeInstanceOf(LocalLlmRequestLogSource);
+  });
+
+  test("returns LocalLlmRequestLogSource when llmRequestLogs is undefined (defensive)", async () => {
+    currentConfig = {};
+    const src = await getLlmRequestLogSource();
+    expect(src).toBeInstanceOf(LocalLlmRequestLogSource);
+  });
+
+  test("returns ClickHouseLlmRequestLogSource when readSource is 'clickhouse'", async () => {
+    currentConfig = {
+      llmRequestLogs: {
+        readSource: "clickhouse",
+        clickhouse: {
+          database: "default",
+          table: "llm_request_logs",
+          user: "default",
+        },
+      },
+    };
+    const src = await getLlmRequestLogSource();
+    expect(src).toBeInstanceOf(ClickHouseLlmRequestLogSource);
+  });
+
+  test("instantiates a fresh source on every call (no module-level cache)", async () => {
+    currentConfig = { llmRequestLogs: { readSource: "local" } };
+    const first = await getLlmRequestLogSource();
+    const second = await getLlmRequestLogSource();
+    expect(second).not.toBe(first);
+    expect(second).toBeInstanceOf(LocalLlmRequestLogSource);
+  });
+
+  test("picks up live config changes without an invalidation hook", async () => {
+    currentConfig = { llmRequestLogs: { readSource: "local" } };
+    const before = await getLlmRequestLogSource();
+    expect(before).toBeInstanceOf(LocalLlmRequestLogSource);
+
+    currentConfig = {
+      llmRequestLogs: {
+        readSource: "clickhouse",
+        clickhouse: {
+          database: "default",
+          table: "llm_request_logs",
+          user: "default",
+        },
+      },
+    };
+    const after = await getLlmRequestLogSource();
+    expect(after).toBeInstanceOf(ClickHouseLlmRequestLogSource);
+  });
+});