@vellumai/assistant 0.8.0 → 0.8.1

package/src/__tests__/lifecycle-memory-v2-seed.test.ts

@@ -33,6 +33,7 @@ interface TestState {
   countResult: number;
   listPagesResult: string[];
   enqueueCalls: Array<{ type: string; payload: Record<string, unknown> }>;
+  clearSentinelCallCount: number;
 }
 
 const state: TestState = {
@@ -46,6 +47,7 @@ const state: TestState = {
   countResult: 0,
   listPagesResult: [],
   enqueueCalls: [],
+  clearSentinelCallCount: 0,
 };
 
 // ---------------------------------------------------------------------------
@@ -66,6 +68,9 @@ mock.module("../memory/v2/qdrant.js", () => ({
     return state.ensureCollectionResult;
   },
   countConceptPagePoints: async (): Promise<number> => state.countResult,
+  clearReembedSentinel: async (): Promise<void> => {
+    state.clearSentinelCallCount += 1;
+  },
   // The rebuild gate does not call this, but the seed gate's fire-and-forget
   // chain imports it; provide a no-op so the dynamic import resolves.
   dropLegacySkillsCollection: async (): Promise<void> => {},
@@ -88,6 +93,11 @@ mock.module("../memory/jobs-store.js", () => ({
 
 mock.module("../util/platform.js", () => ({
   getWorkspaceDir: () => "/tmp/test-workspace",
+  // qdrant.ts (mocked away in this file) reads `getDataDir` for the reembed
+  // sentinel path; bun mocks share the same module record across files, so
+  // include it here too so a peer test importing `getDataDir` doesn't see
+  // `undefined` after this mock evaluates.
+  getDataDir: () => "/tmp/test-workspace/data",
 }));
 
 mock.module("../util/logger.js", () => ({
@@ -148,6 +158,7 @@ function resetState(): void {
   state.countResult = 0;
   state.listPagesResult = [];
   state.enqueueCalls = [];
+  state.clearSentinelCallCount = 0;
 }
 
 describe("maybeSeedMemoryV2Skills (daemon startup gate)", () => {
@@ -202,6 +213,10 @@ describe("maybeRebuildMemoryV2Concepts (daemon startup gate)", () => {
     expect(state.enqueueCalls).toEqual([
       { type: "memory_v2_reembed", payload: {} },
     ]);
+    // After the reembed is queued, the on-disk sentinel that the qdrant
+    // ensure-path may have written is cleared so it does not re-trigger on
+    // the next startup.
+    expect(state.clearSentinelCallCount).toBe(1);
     // Migrated path skips the count probe — drift detection is the trigger.
     // (The mock's countConceptPagePoints would silently return 0 either way,
     // but keeping the path conditional keeps the lifecycle hook predictable.)

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

@@ -2,7 +2,9 @@ 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 { resolvePricing, resolvePricingForUsage } from "../util/pricing.js";
 
 /**
  * Parity guard: daemon LLM provider catalog vs client LLM catalog JSON.
@@ -50,6 +52,13 @@ interface ClientCatalogModel {
     outputPer1mTokens: number;
     cacheWritePer1mTokens?: number;
     cacheReadPer1mTokens?: number;
+    tiers?: Array<{
+      inputTokenThreshold: number;
+      inputPer1mTokens: number;
+      outputPer1mTokens: number;
+      cacheReadPer1mTokens?: number;
+      cacheWritePer1mTokens?: number;
+    }>;
   };
 }
 
@@ -62,6 +71,7 @@ interface ClientCatalogEntry {
   envVar?: string;
   apiKeyPlaceholder?: string;
   credentialsGuide?: ClientCatalogCredentialsGuide;
+  supportsManagedAuth?: boolean;
   defaultModel: string;
   models: ClientCatalogModel[];
 }
@@ -114,6 +124,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.supportsManagedAuth).toBe(
+        daemonEntry.supportsManagedAuth,
+      );
       expect(clientEntry.credentialsGuide).toEqual(
         daemonEntry.credentialsGuide,
       );
@@ -121,6 +134,19 @@ describe("LLM catalog parity: daemon vs client", () => {
     }
   });
 
+  test("supportsManagedAuth mirrors MANAGED_PROVIDER_META", () => {
+    // The catalog field is derived from MANAGED_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
+    // 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);
+    }
+  });
+
   test("each provider's model count matches the daemon catalog", () => {
     const json = loadClientCatalog();
 
@@ -248,6 +274,126 @@ 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(

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

@@ -0,0 +1,188 @@
+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("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,124 @@
+import { afterAll, beforeEach, 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's tests actually exercise the CH read path.
+const LOCAL_DEFAULT_CONFIG = {
+  llmRequestLogs: {
+    readSource: "local",
+    clickhouse: {
+      database: "default",
+      table: "llm_request_logs",
+      user: "default",
+    },
+  },
+};
+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. Also drop the factory's internal
+// cache so the next caller resolves fresh against the reset config.
+afterAll(() => {
+  currentConfig = LOCAL_DEFAULT_CONFIG;
+  invalidateLlmRequestLogSourceCache();
+});
+
+import {
+  getLlmRequestLogSource,
+  invalidateLlmRequestLogSourceCache,
+} 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" },
+      },
+    };
+    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("caches the resolved source across calls", async () => {
+    currentConfig = {
+      llmRequestLogs: {
+        readSource: "local",
+        clickhouse: { database: "default", table: "llm_request_logs", user: "default" },
+      },
+    };
+    const first = await getLlmRequestLogSource();
+    const second = await getLlmRequestLogSource();
+    expect(second).toBe(first);
+  });
+
+  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();
+    currentConfig = {
+      llmRequestLogs: {
+        readSource: "clickhouse",
+        clickhouse: { database: "default", table: "llm_request_logs", user: "default" },
+      },
+    };
+    const second = await getLlmRequestLogSource();
+    expect(second).not.toBe(first);
+    expect(second).toBeInstanceOf(ClickHouseLlmRequestLogSource);
+  });
+});

package/src/__tests__/llm-resolver.test.ts

@@ -52,6 +52,50 @@ describe("resolveCallSiteConfig", () => {
     expect(resolved.maxTokens).toBe(64000);
   });
 
+  test("model-only call-site override infers provider from known model owner", () => {
+    const llm = LLMSchema.parse({
+      default: {
+        ...fullDefault,
+        provider: "openai",
+        model: "gpt-5.5",
+      },
+      profiles: {
+        active: { provider: "openai", model: "gpt-5.5" },
+      },
+      activeProfile: "active",
+      callSites: {
+        conversationStarters: {
+          model: "claude-haiku-4-5-20251001",
+          effort: "low",
+        },
+      },
+    });
+
+    const resolved = resolveCallSiteConfig("conversationStarters", llm);
+
+    expect(resolved.provider).toBe("anthropic");
+    expect(resolved.model).toBe("claude-haiku-4-5-20251001");
+    expect(resolved.effort).toBe("low");
+  });
+
+  test("unknown model-only override preserves inherited provider", () => {
+    const llm = LLMSchema.parse({
+      default: {
+        ...fullDefault,
+        provider: "openai",
+        model: "gpt-5.5",
+      },
+      callSites: {
+        memoryExtraction: { model: "local-custom-model" },
+      },
+    });
+
+    const resolved = resolveCallSiteConfig("memoryExtraction", llm);
+
+    expect(resolved.provider).toBe("openai");
+    expect(resolved.model).toBe("local-custom-model");
+  });
+
   test("profile field overrides default when call site references it", () => {
     const llm = LLMSchema.parse({
       default: fullDefault,
@@ -207,6 +251,7 @@ describe("resolveCallSiteConfig", () => {
       callSites: {
         mainAgent: { profile: "nonexistent" },
       },
+      profileSession: { defaultTtlSeconds: 1800, maxTtlSeconds: 43200 },
       pricingOverrides: [],
     };
     expect(() => resolveCallSiteConfig("mainAgent", llm)).toThrow(
@@ -339,6 +384,7 @@ describe("resolveCallSiteConfig", () => {
       profileOrder: [],
       callSites: {},
       activeProfile: "nonexistent",
+      profileSession: { defaultTtlSeconds: 1800, maxTtlSeconds: 43200 },
       pricingOverrides: [],
     };
     const resolved = resolveCallSiteConfig("mainAgent", llm);