@vellumai/assistant 0.8.1 → 0.8.3

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

@@ -1,5 +1,6 @@
 import { describe, expect, test } from "bun:test";
 
+import { CALL_SITE_DEFAULTS } from "../config/call-site-defaults.js";
 import { getLLMCallSiteLabel } from "../config/llm-callsite-catalog.js";
 import { CALL_SITE_CATALOG } from "../config/schemas/call-site-catalog.js";
 import { LLMCallSiteEnum, LLMSchema } from "../config/schemas/llm.js";
@@ -50,4 +51,28 @@ describe("LLM call-site catalog", () => {
     });
     expect(parsed.callSites.memoryRouter?.model).toBe("claude-sonnet-4-6");
   });
+
+  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),
+    );
+    expect(missing).toEqual([]);
+  });
+
+  test("CALL_SITE_DEFAULTS contains no unknown call-site keys", () => {
+    const enumIds = new Set<string>(LLMCallSiteEnum.options);
+    const extra = Object.keys(CALL_SITE_DEFAULTS).filter(
+      (id) => !enumIds.has(id),
+    );
+    expect(extra).toEqual([]);
+  });
+
+  test("every CALL_SITE_DEFAULTS entry has a profile field", () => {
+    for (const [, config] of Object.entries(CALL_SITE_DEFAULTS)) {
+      expect(config.profile).toBeDefined();
+      expect(typeof config.profile).toBe("string");
+      expect(config.profile!.length).toBeGreaterThan(0);
+    }
+  });
 });

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

@@ -2,8 +2,8 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { describe, expect, test } from "bun:test";
 
-import { MANAGED_PROVIDER_META } from "../providers/managed-proxy/constants.js";
 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";
 
 /**
@@ -29,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;
@@ -71,7 +80,7 @@ interface ClientCatalogEntry {
   envVar?: string;
   apiKeyPlaceholder?: string;
   credentialsGuide?: ClientCatalogCredentialsGuide;
-  supportsManagedAuth?: boolean;
+  supportsPlatformAuth?: boolean;
   defaultModel: string;
   models: ClientCatalogModel[];
 }
@@ -82,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);
 }
 
@@ -124,8 +132,8 @@ 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.supportsManagedAuth).toBe(
-        daemonEntry.supportsManagedAuth,
+      expect(clientEntry.supportsPlatformAuth).toBe(
+        daemonEntry.supportsPlatformAuth,
       );
       expect(clientEntry.credentialsGuide).toEqual(
         daemonEntry.credentialsGuide,
@@ -134,16 +142,16 @@ describe("LLM catalog parity: daemon vs client", () => {
     }
   });
 
-  test("supportsManagedAuth mirrors MANAGED_PROVIDER_META", () => {
-    // The catalog field is derived from MANAGED_PROVIDER_META at build
+  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 MANAGED_PROVIDER_META
+    // 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 =
-        MANAGED_PROVIDER_META[entry.id]?.managed === true;
-      expect(entry.supportsManagedAuth).toBe(expectedSupportsManagedAuth);
+        PLATFORM_PROVIDER_META[entry.id]?.managed === true;
+      expect(entry.supportsPlatformAuth).toBe(expectedSupportsManagedAuth);
     }
   });
 
@@ -200,6 +208,9 @@ describe("LLM catalog parity: daemon vs client", () => {
 
   test("every provider's defaultModel exists in its models list", () => {
     for (const entry of PROVIDER_CATALOG) {
+      // Providers with an empty models list (e.g. openai-compatible) use
+      // per-connection model identifiers instead of a static catalog.
+      if (entry.models.length === 0) continue;
       const found = entry.models.some((m) => m.id === entry.defaultModel);
       expect(
         found,
@@ -208,6 +219,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();
 
@@ -383,8 +414,7 @@ describe("LLM catalog parity: daemon vs client", () => {
             `${provider.id}/${model.id} unpriced at tier ${tier.inputTokenThreshold}`,
           ).toBe("priced");
           const resolvedRate =
-            (result.estimatedCostUsd ?? 0) *
-            (TOKENS_PER_MILLION / probeTokens);
+            (result.estimatedCostUsd ?? 0) * (TOKENS_PER_MILLION / probeTokens);
           expect(
             resolvedRate,
             `${provider.id}/${model.id} input rate drift at tier ${tier.inputTokenThreshold}`,
@@ -407,4 +437,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-agent-loop-exit-reason.test.ts

@@ -0,0 +1,116 @@
+/**
+ * Tests for `setAgentLoopExitReasonOnLatestLog` and the
+ * `agentLoopExitReason` field on the LogRow type. The helper stamps the
+ * reason onto the most-recent `llm_request_logs` row for a conversation,
+ * which is how downstream tooling distinguishes "loop kept going" (null)
+ * from "loop exited because X" (specific reason) on a per-row basis.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    model: "test",
+    provider: "test",
+    memory: { enabled: false },
+    rateLimit: { maxRequestsPerMinute: 0 },
+    secretDetection: { enabled: false },
+  }),
+}));
+
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import {
+  getRequestLogById,
+  recordRequestLog,
+  setAgentLoopExitReasonOnLatestLog,
+} from "../memory/llm-request-log-store.js";
+import { llmRequestLogs } from "../memory/schema.js";
+
+initializeDb();
+
+function resetLogs(): void {
+  const db = getDb();
+  db.delete(llmRequestLogs).run();
+}
+
+describe("setAgentLoopExitReasonOnLatestLog", () => {
+  beforeEach(resetLogs);
+
+  test("recordRequestLog leaves agentLoopExitReason NULL", () => {
+    const id = recordRequestLog("conv-1", '{"req":1}', '{"res":1}');
+    const row = getRequestLogById(id);
+    expect(row).not.toBeNull();
+    expect(row!.agentLoopExitReason).toBeNull();
+  });
+
+  test("stamps the reason onto the most-recent log for the conversation", () => {
+    const first = recordRequestLog("conv-1", '{"req":1}', '{"res":1}');
+    // Ensure createdAt strict ordering — `recordRequestLog` uses
+    // `Date.now()` and bun-sqlite is fast enough that two consecutive
+    // inserts can share a millisecond. Sleep a tick to disambiguate.
+    Bun.sleepSync(2);
+    const second = recordRequestLog("conv-1", '{"req":2}', '{"res":2}');
+
+    setAgentLoopExitReasonOnLatestLog("conv-1", "no_tool_calls");
+
+    expect(getRequestLogById(first)?.agentLoopExitReason).toBeNull();
+    expect(getRequestLogById(second)?.agentLoopExitReason).toBe(
+      "no_tool_calls",
+    );
+  });
+
+  test("scopes the stamp to the given conversation only", () => {
+    const a = recordRequestLog("conv-a", '{"req":1}', '{"res":1}');
+    Bun.sleepSync(2);
+    const b = recordRequestLog("conv-b", '{"req":1}', '{"res":1}');
+
+    setAgentLoopExitReasonOnLatestLog("conv-a", "yield_to_user");
+
+    expect(getRequestLogById(a)?.agentLoopExitReason).toBe("yield_to_user");
+    // conv-b is later overall but belongs to a different conversation —
+    // must stay NULL.
+    expect(getRequestLogById(b)?.agentLoopExitReason).toBeNull();
+  });
+
+  test("no-op when conversation has no logs", () => {
+    expect(() =>
+      setAgentLoopExitReasonOnLatestLog("conv-missing", "error"),
+    ).not.toThrow();
+  });
+
+  test("does not clobber a previous run's reason when the current run never landed a row", () => {
+    // Previous run: completes, lands a log, gets stamped.
+    const prev = recordRequestLog("conv-1", '{"prev_req":1}', '{"prev_res":1}');
+    setAgentLoopExitReasonOnLatestLog("conv-1", "no_tool_calls");
+    expect(getRequestLogById(prev)?.agentLoopExitReason).toBe("no_tool_calls");
+
+    // Current run aborts pre-call (or similar) before any LLM call lands.
+    // The helper must NOT overwrite the previous run's row.
+    setAgentLoopExitReasonOnLatestLog("conv-1", "aborted_pre_call");
+    expect(getRequestLogById(prev)?.agentLoopExitReason).toBe("no_tool_calls");
+  });
+
+  test("stamps the current run's newest row even when a prior row is already stamped", () => {
+    // Prior run already stamped.
+    const prev = recordRequestLog("conv-1", '{"prev_req":1}', '{"prev_res":1}');
+    setAgentLoopExitReasonOnLatestLog("conv-1", "no_tool_calls");
+
+    // Current run lands a new log, then exits.
+    Bun.sleepSync(2);
+    const current = recordRequestLog("conv-1", '{"cur_req":1}', '{"cur_res":1}');
+    setAgentLoopExitReasonOnLatestLog("conv-1", "yield_to_user");
+
+    expect(getRequestLogById(prev)?.agentLoopExitReason).toBe("no_tool_calls");
+    expect(getRequestLogById(current)?.agentLoopExitReason).toBe(
+      "yield_to_user",
+    );
+  });
+});

package/src/__tests__/llm-request-log-error-payload.test.ts

@@ -0,0 +1,138 @@
+/**
+ * Unit tests for `buildProviderErrorResponsePayload` — the shared serializer
+ * used by `handleProviderError` (daemon) and the wake-path `onEvent` to
+ * record provider-rejected LLM calls in `llm_request_logs`.
+ *
+ * The serializer's job: take an arbitrary thrown `Error`, return a
+ * structured `{ error: {...} }` object whose fields are queryable in the
+ * LLM inspector and that round-trips cleanly through `JSON.stringify`.
+ * The `error` key wrap is load-bearing — it mirrors a successful row's
+ * `usage.rawResponse` shape so an inspector consumer can branch on
+ * `responsePayload.error` vs the success shape without re-parsing.
+ *
+ * Coverage:
+ *  - `ProviderError` with full metadata (provider, statusCode, retryAfterMs).
+ *  - `ProviderError` without optional metadata.
+ *  - Non-provider `AssistantError` (carries `code` but not provider fields).
+ *  - Plain `Error` (degrades to `{name, message}`).
+ *  - Custom `Error` subclass with overridden `name` is preserved.
+ *
+ * Each test stringifies and re-parses the payload so the on-disk shape
+ * (what eventually lands in the `responsePayload` column) is what we
+ * assert on, not the JS object identity.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import { buildProviderErrorResponsePayload } from "../memory/llm-request-log-store.js";
+import {
+  AssistantError,
+  ErrorCode,
+  ProviderError,
+} from "../util/errors.js";
+
+function persisted(err: Error): { error: Record<string, unknown> } {
+  // Round-trip through JSON to assert on the actual stored shape, not the
+  // in-memory object reference.
+  return JSON.parse(
+    JSON.stringify(buildProviderErrorResponsePayload(err)),
+  );
+}
+
+describe("buildProviderErrorResponsePayload", () => {
+  test("ProviderError with statusCode + retryAfterMs serializes every queryable field", () => {
+    const err = new ProviderError(
+      "Anthropic API error (429): rate limited",
+      "anthropic",
+      429,
+      { retryAfterMs: 1500 },
+    );
+    const got = persisted(err);
+    expect(got).toEqual({
+      error: {
+        name: "ProviderError",
+        message: "Anthropic API error (429): rate limited",
+        code: ErrorCode.PROVIDER_ERROR,
+        provider: "anthropic",
+        statusCode: 429,
+        retryAfterMs: 1500,
+      },
+    });
+  });
+
+  test("ProviderError without optional metadata omits statusCode + retryAfterMs", () => {
+    const err = new ProviderError(
+      "Gemini API error: surprise internal state",
+      "gemini",
+    );
+    const got = persisted(err);
+    expect(got).toEqual({
+      error: {
+        name: "ProviderError",
+        message: "Gemini API error: surprise internal state",
+        code: ErrorCode.PROVIDER_ERROR,
+        provider: "gemini",
+      },
+    });
+    // Explicit assertion: omitted fields aren't present as `null` either —
+    // the inspector should be able to test `'statusCode' in error` reliably.
+    expect("statusCode" in got.error).toBe(false);
+    expect("retryAfterMs" in got.error).toBe(false);
+  });
+
+  test("non-provider AssistantError carries the ErrorCode but no provider fields", () => {
+    // Tool errors / permission denials are technically also AssistantErrors;
+    // we just want to confirm the generic AssistantError branch produces a
+    // sensible row rather than silently degrading to a plain Error shape.
+    const err = new AssistantError(
+      "internal state corrupted",
+      ErrorCode.INTERNAL_ERROR,
+    );
+    const got = persisted(err);
+    expect(got).toEqual({
+      error: {
+        name: "AssistantError",
+        message: "internal state corrupted",
+        code: ErrorCode.INTERNAL_ERROR,
+      },
+    });
+    expect("provider" in got.error).toBe(false);
+  });
+
+  test("plain Error degrades to {name, message} with no code/provider noise", () => {
+    const err = new Error("connection reset");
+    const got = persisted(err);
+    expect(got).toEqual({
+      error: {
+        name: "Error",
+        message: "connection reset",
+      },
+    });
+    expect("code" in got.error).toBe(false);
+  });
+
+  test("custom Error subclass with overridden name is preserved", () => {
+    class TimeoutError extends Error {
+      constructor(message: string) {
+        super(message);
+        this.name = "TimeoutError";
+      }
+    }
+    const got = persisted(new TimeoutError("provider timed out after 60s"));
+    expect(got).toEqual({
+      error: {
+        name: "TimeoutError",
+        message: "provider timed out after 60s",
+      },
+    });
+  });
+
+  test("ProviderError with statusCode 0 is still recorded (not coerced to undefined)", () => {
+    // Defensive: `if (err.statusCode !== undefined)` correctly admits 0.
+    // A raw `if (err.statusCode)` would drop it, so the test guards against
+    // a regression to truthy-checking.
+    const err = new ProviderError("weird provider", "fake", 0);
+    const got = persisted(err);
+    expect(got.error.statusCode).toBe(0);
+  });
+});

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

@@ -83,6 +83,7 @@ const SAMPLE_ROW = {
   response_payload: '{"bar":2}',
   // ClickHouse emits Int64 as a quoted string under JSONEachRow by default.
   created_at: "1778465138786",
+  agent_loop_exit_reason: "no_tool_calls",
 };
 
 describe("ClickHouseLlmRequestLogSource", () => {
@@ -102,6 +103,7 @@ describe("ClickHouseLlmRequestLogSource", () => {
       requestPayload: '{"foo":1}',
       responsePayload: '{"bar":2}',
       createdAt: 1778465138786,
+      agentLoopExitReason: "no_tool_calls",
     });
   });
 
@@ -162,6 +164,40 @@ describe("ClickHouseLlmRequestLogSource", () => {
     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,

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

@@ -1,4 +1,4 @@
-import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
+import { afterAll, describe, expect, mock, test } from "bun:test";
 
 function makeLoggerStub(): Record<string, unknown> {
   const stub: Record<string, unknown> = {};
@@ -22,19 +22,10 @@ mock.module("../util/logger.js", () => ({
 }));
 
 // 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's tests actually exercise the CH read path.
-const LOCAL_DEFAULT_CONFIG = {
-  llmRequestLogs: {
-    readSource: "local",
-    clickhouse: {
-      database: "default",
-      table: "llm_request_logs",
-      user: "default",
-    },
-  },
-};
+// 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,
@@ -43,32 +34,18 @@ mock.module("../config/loader.js", () => ({
 // 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. Also drop the factory's internal
-// cache so the next caller resolves fresh against the reset config.
+// a stale `readSource=clickhouse` value.
 afterAll(() => {
   currentConfig = LOCAL_DEFAULT_CONFIG;
-  invalidateLlmRequestLogSourceCache();
 });
 
-import {
-  getLlmRequestLogSource,
-  invalidateLlmRequestLogSourceCache,
-} from "../memory/llm-request-log-source.js";
+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", () => {
-  beforeEach(() => {
-    invalidateLlmRequestLogSourceCache();
-  });
-
   test("returns LocalLlmRequestLogSource when readSource is 'local'", async () => {
-    currentConfig = {
-      llmRequestLogs: {
-        readSource: "local",
-        clickhouse: { database: "default", table: "llm_request_logs", user: "default" },
-      },
-    };
+    currentConfig = { llmRequestLogs: { readSource: "local" } };
     const src = await getLlmRequestLogSource();
     expect(src).toBeInstanceOf(LocalLlmRequestLogSource);
   });
@@ -83,42 +60,41 @@ describe("getLlmRequestLogSource factory", () => {
     currentConfig = {
       llmRequestLogs: {
         readSource: "clickhouse",
-        clickhouse: { database: "default", table: "llm_request_logs", user: "default" },
+        clickhouse: {
+          database: "default",
+          table: "llm_request_logs",
+          user: "default",
+        },
       },
     };
     const src = await getLlmRequestLogSource();
     expect(src).toBeInstanceOf(ClickHouseLlmRequestLogSource);
   });
 
-  test("caches the resolved source across calls", async () => {
-    currentConfig = {
-      llmRequestLogs: {
-        readSource: "local",
-        clickhouse: { database: "default", table: "llm_request_logs", user: "default" },
-      },
-    };
+  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).toBe(first);
+    expect(second).not.toBe(first);
+    expect(second).toBeInstanceOf(LocalLlmRequestLogSource);
   });
 
-  test("invalidateLlmRequestLogSourceCache forces a fresh resolution", async () => {
-    currentConfig = {
-      llmRequestLogs: {
-        readSource: "local",
-        clickhouse: { database: "default", table: "llm_request_logs", user: "default" },
-      },
-    };
-    const first = await getLlmRequestLogSource();
-    invalidateLlmRequestLogSourceCache();
+  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" },
+        clickhouse: {
+          database: "default",
+          table: "llm_request_logs",
+          user: "default",
+        },
       },
     };
-    const second = await getLlmRequestLogSource();
-    expect(second).not.toBe(first);
-    expect(second).toBeInstanceOf(ClickHouseLlmRequestLogSource);
+    const after = await getLlmRequestLogSource();
+    expect(after).toBeInstanceOf(ClickHouseLlmRequestLogSource);
   });
 });