@vellumai/assistant 0.6.4 → 0.6.6

package/src/__tests__/plugin-types.test.ts

@@ -0,0 +1,320 @@
+/**
+ * Shape-only tests for the plugin core types (PR 11).
+ *
+ * These tests don't exercise any runtime behavior — they only assert, via
+ * the `satisfies` operator, that a fully-populated `Plugin` literal lines
+ * up with the public interface. If a later PR changes a field name or
+ * signature in a breaking way, this file fails to type-check and the
+ * regression is caught at `tsc --noEmit` / `bun test` time.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import type { TrustContext } from "../daemon/conversation-runtime-assembly.js";
+import { RiskLevel } from "../permissions/types.js";
+import {
+  type CircuitBreakerArgs,
+  type CircuitBreakerResult,
+  type CompactionArgs,
+  type CompactionResult,
+  type EmptyResponseArgs,
+  type EmptyResponseResult,
+  type EstimateArgs,
+  type EstimateResult,
+  type Injector,
+  type LLMCallArgs,
+  type LLMCallResult,
+  type MemoryArgs,
+  type MemoryResult,
+  type Middleware,
+  type OverflowReduceArgs,
+  type OverflowReduceResult,
+  type PersistArgs,
+  type PersistResult,
+  type Plugin,
+  PluginExecutionError,
+  type PluginInitContext,
+  type PluginManifest,
+  PluginTimeoutError,
+  type TitleArgs,
+  type TitleResult,
+  type ToolErrorArgs,
+  type ToolErrorDecision,
+  type ToolExecuteArgs,
+  type ToolExecuteResult,
+  type ToolResultTruncateArgs,
+  type ToolResultTruncateResult,
+  type TurnContext,
+} from "../plugins/types.js";
+import type { Tool } from "../tools/types.js";
+
+const sampleTrust: TrustContext = {
+  sourceChannel: "vellum",
+  trustClass: "guardian",
+};
+
+const sampleTurnContext: TurnContext = {
+  requestId: "req-abc",
+  conversationId: "conv-xyz",
+  turnIndex: 0,
+  pluginName: "sample-plugin",
+  trust: sampleTrust,
+};
+
+describe("plugin core types", () => {
+  test("a fully-populated Plugin literal satisfies the interface", () => {
+    const manifest: PluginManifest = {
+      name: "sample-plugin",
+      version: "0.1.0",
+      provides: { sampleApi: "v1" },
+      requires: { pluginRuntime: "v1" },
+      requiresCredential: ["SAMPLE_API_KEY"],
+      requiresFlag: ["sample-feature"],
+      config: { parse: (input: unknown) => input },
+    };
+
+    // Generic passthrough — typed per slot below because per-pipeline
+    // arg/result types have diverged from the early `{input: unknown}` /
+    // `{output: unknown}` placeholders as individual pipeline wrap-up PRs
+    // land.
+    function passthroughFor<A, R>(): Middleware<A, R> {
+      return async (args, next, _ctx) => next(args);
+    }
+    const passthrough: Middleware<
+      { input: unknown },
+      { output: unknown }
+    > = async (args, next, _ctx) => next(args);
+    const passthroughHistoryRepair = passthroughFor<
+      import("../plugins/types.js").HistoryRepairArgs,
+      import("../plugins/types.js").HistoryRepairResult
+    >();
+
+    // `llmCall` has concrete arg/result types (upgraded in PR 15).
+    const llmCallPassthrough: Middleware<LLMCallArgs, LLMCallResult> = async (
+      args,
+      next,
+      _ctx,
+    ) => next(args);
+
+    // `toolExecute` has concrete arg/result types (refined in PR 16).
+    const toolExecutePassthrough: Middleware<
+      ToolExecuteArgs,
+      ToolExecuteResult
+    > = async (args, next, _ctx) => next(args);
+
+    // `toolResultTruncate` has a concrete args/result shape (PR 17) so we
+    // need a dedicated passthrough for that slot.
+    const truncatePassthrough: Middleware<
+      ToolResultTruncateArgs,
+      ToolResultTruncateResult
+    > = async (args, _next, _ctx) => ({
+      content: args.content,
+      truncated: false,
+    });
+
+    // The `emptyResponse` slot has concrete args/result types; use a
+    // dedicated passthrough so the `satisfies Plugin` check stays honest.
+    const emptyResponsePassthrough: Middleware<
+      EmptyResponseArgs,
+      EmptyResponseResult
+    > = async (args, next, _ctx) => next(args);
+
+    // The `toolError` slot has concrete args/result types (PR 19); use a
+    // dedicated passthrough so the shape-only test keeps compiling as types
+    // get tightened.
+    const toolErrorPassthrough: Middleware<
+      ToolErrorArgs,
+      ToolErrorDecision
+    > = async (args, next, _ctx) => next(args);
+
+    // `memoryRetrieval` has a concrete typed signature (MemoryArgs →
+    // MemoryResult) introduced in PR 20, so it can't use the generic
+    // `{ input }` passthrough above.
+    const memoryPassthrough: Middleware<MemoryArgs, MemoryResult> = async (
+      args,
+      next,
+      _ctx,
+    ) => next(args);
+
+    // `tokenEstimate` has a concrete arg/result shape (refined in the
+    // tokenEstimate-pipeline PR), so its middleware can't share the generic
+    // `{ input, output }` passthrough. A slot-specific passthrough keeps the
+    // shape-only assertion honest across type-refinement PRs.
+    const tokenEstimatePassthrough: Middleware<
+      EstimateArgs,
+      EstimateResult
+    > = async (args, next, _ctx) => next(args);
+
+    // `overflowReduce` has a concrete arg/result shape (PR 23). Uses a
+    // dedicated passthrough that returns a structurally-correct result so
+    // `satisfies Plugin` keeps verifying the signature.
+    const overflowReducePassthrough: Middleware<
+      OverflowReduceArgs,
+      OverflowReduceResult
+    > = async (args, _next, _ctx) => ({
+      messages: args.messages,
+      runMessages: args.runMessages,
+      injectionMode: "full",
+      reducerState: {
+        appliedTiers: [],
+        injectionMode: "full",
+        exhausted: true,
+      },
+      reducerCompacted: false,
+      attempts: 0,
+    });
+
+    // Slot-specific passthrough for the `compaction` pipeline — PR 25
+    // narrowed its args/result away from the generic `{ input: unknown }`
+    // placeholder, so the generic `passthrough` no longer satisfies its
+    // middleware signature. This dedicated middleware keeps the shape-only
+    // assertion for the slot without forcing every other slot to narrow.
+    const compactionPassthrough: Middleware<
+      CompactionArgs,
+      CompactionResult
+    > = async (args, next, _ctx) => next(args);
+
+    // `circuitBreaker` carries a concrete arg shape (pipeline wrapping
+    // landed ahead of the other slots) so it needs its own passthrough
+    // rather than reusing the generic placeholder.
+    const circuitPassthrough: Middleware<
+      CircuitBreakerArgs,
+      CircuitBreakerResult
+    > = async (args, next, _ctx) => next(args);
+
+    // `persistence` has concrete discriminated-union arg/result types
+    // (upgraded from the initial `{ input }/{ output }` placeholder in PR 27)
+    // so it gets its own passthrough rather than sharing the generic one
+    // above.
+    const persistPassthrough: Middleware<PersistArgs, PersistResult> = async (
+      args,
+      next,
+      _ctx,
+    ) => next(args);
+
+    // The `titleGenerate` slot now has concrete arg/result types (PR 28)
+    // rather than the placeholder `{ input/output: unknown }` shape, so it
+    // needs its own passthrough implementation.
+    const titlePassthrough: Middleware<TitleArgs, TitleResult> = async (
+      args,
+      next,
+      _ctx,
+    ) => next(args);
+
+    const injector: Injector = {
+      name: "sample-injector",
+      order: 10,
+      async produce(_ctx) {
+        return { id: "sample-block", text: "hello", meta: { kind: "demo" } };
+      },
+    };
+
+    const sampleTool: Tool = {
+      name: "sample-tool",
+      description: "Sample plugin tool",
+      category: "plugins",
+      defaultRiskLevel: RiskLevel.Low,
+      getDefinition() {
+        return {
+          name: "sample-tool",
+          description: "Sample plugin tool",
+          input_schema: { type: "object", properties: {}, required: [] },
+        };
+      },
+      async execute() {
+        return { content: "ok", isError: false };
+      },
+    };
+
+    const plugin = {
+      manifest,
+      async init(ctx: PluginInitContext) {
+        // Touch every field so refactors that rename any of them break here.
+        void ctx.config;
+        void ctx.credentials;
+        void ctx.logger;
+        void ctx.pluginStorageDir;
+        void ctx.assistantVersion;
+        void ctx.apiVersions;
+      },
+      async onShutdown() {
+        // no-op
+      },
+      tools: [sampleTool],
+      routes: [
+        {
+          pattern: /^\/sample$/,
+          methods: ["GET"],
+          handler: async () => new Response("ok", { status: 200 }),
+        },
+      ],
+      skills: [
+        {
+          id: "sample-skill",
+          name: "Sample Skill",
+          description: "Demo plugin-contributed skill",
+          body: "## Sample\n\nPlugin-provided skill body.",
+        },
+      ],
+      injectors: [injector],
+      middleware: {
+        turn: passthrough,
+        llmCall: llmCallPassthrough,
+        toolExecute: toolExecutePassthrough,
+        memoryRetrieval: memoryPassthrough,
+        historyRepair: passthroughHistoryRepair,
+        tokenEstimate: tokenEstimatePassthrough,
+        compaction: compactionPassthrough,
+        overflowReduce: overflowReducePassthrough,
+        persistence: persistPassthrough,
+        titleGenerate: titlePassthrough,
+        toolResultTruncate: truncatePassthrough,
+        emptyResponse: emptyResponsePassthrough,
+        toolError: toolErrorPassthrough,
+        circuitBreaker: circuitPassthrough,
+      },
+    } satisfies Plugin;
+
+    // Minimal runtime check so the test body is non-empty.
+    expect(plugin.manifest.name).toBe("sample-plugin");
+    expect(plugin.middleware.turn).toBe(passthrough);
+    expect(plugin.middleware.historyRepair).toBe(passthroughHistoryRepair);
+  });
+
+  test("PluginTimeoutError carries pipeline, plugin, and elapsed fields", () => {
+    const err = new PluginTimeoutError("compaction", "sample-plugin", 30000);
+    expect(err).toBeInstanceOf(Error);
+    expect(err.name).toBe("PluginTimeoutError");
+    expect(err.pipeline).toBe("compaction");
+    expect(err.pluginName).toBe("sample-plugin");
+    expect(err.elapsedMs).toBe(30000);
+    expect(err.message).toContain("compaction");
+    expect(err.message).toContain("30000");
+    expect(err.message).toContain("sample-plugin");
+  });
+
+  test("PluginTimeoutError omits plugin suffix when unknown", () => {
+    const err = new PluginTimeoutError("llmCall", undefined, 1234);
+    expect(err.pluginName).toBeUndefined();
+    expect(err.message).not.toContain("offending plugin");
+  });
+
+  test("PluginExecutionError carries the plugin name and message", () => {
+    const err = new PluginExecutionError(
+      "plugin 'x' requires memoryApi@v2, assistant exposes v1",
+      "x",
+    );
+    expect(err).toBeInstanceOf(Error);
+    expect(err.name).toBe("PluginExecutionError");
+    expect(err.pluginName).toBe("x");
+    expect(err.message).toContain("memoryApi@v2");
+  });
+
+  test("TurnContext references the canonical TrustContext", () => {
+    // Assignment is the real assertion — if `TurnContext.trust` drifts from
+    // `TrustContext` this fails to compile.
+    const ctx: TurnContext = sampleTurnContext;
+    expect(ctx.trust.trustClass).toBe("guardian");
+    expect(ctx.trust.sourceChannel).toBe("vellum");
+  });
+});

package/src/__tests__/pricing.test.ts

@@ -30,7 +30,7 @@ describe("resolvePricing", () => {
         1_000_000,
       );
       expect(result.pricingStatus).toBe("priced");
-      expect(result.estimatedCostUsd).toBe(15 + 75);
+      expect(result.estimatedCostUsd).toBe(5 + 25);
     });
 
     test("returns priced for claude-sonnet-4", () => {
@@ -52,7 +52,7 @@ describe("resolvePricing", () => {
         1_000_000,
       );
       expect(result.pricingStatus).toBe("priced");
-      expect(result.estimatedCostUsd).toBe(0.8 + 4);
+      expect(result.estimatedCostUsd).toBe(1 + 5);
     });
   });
 
@@ -116,15 +116,15 @@ describe("resolvePricing", () => {
       expect(result.estimatedCostUsd).toBe(0.15 + 0.6);
     });
 
-    test("returns priced for gemini-2.0-flash", () => {
+    test("returns priced for gemini-2.5-flash-lite", () => {
       const result = resolvePricing(
         "gemini",
-        "gemini-2.0-flash",
+        "gemini-2.5-flash-lite",
         1_000_000,
         1_000_000,
       );
       expect(result.pricingStatus).toBe("priced");
-      expect(result.estimatedCostUsd).toBe(0.1 + 0.4);
+      expect(result.estimatedCostUsd).toBe(0.02 + 0.1);
     });
   });
 
@@ -202,7 +202,7 @@ describe("resolvePricing", () => {
         1_000_000,
       );
       expect(result.pricingStatus).toBe("priced");
-      expect(result.estimatedCostUsd).toBe(15 + 75);
+      expect(result.estimatedCostUsd).toBe(5 + 25);
     });
 
     test("matches gpt-4o-mini-2024-07-18 via gpt-4o-mini prefix", () => {
@@ -269,6 +269,7 @@ describe("resolvePricingForUsage", () => {
     );
 
     expect(result.pricingStatus).toBe("priced");
+    // 5 (input) + 50 (output) + 0.15 (cache-read) + 1.25 (5m write) + 1.0 (1h write) = 57.4
     expect(result.estimatedCostUsd).toBeCloseTo(57.4, 10);
   });
 
@@ -306,7 +307,11 @@ describe("fast mode pricing", () => {
       speed: "fast",
     };
 
-    const result = resolvePricingForUsage("anthropic", "claude-opus-4-6", usage);
+    const result = resolvePricingForUsage(
+      "anthropic",
+      "claude-opus-4-6",
+      usage,
+    );
 
     // Base: $5 input + $25 output = $30; fast: $30 * 6 = $180
     expect(result.pricingStatus).toBe("priced");
@@ -323,7 +328,11 @@ describe("fast mode pricing", () => {
       speed: "standard",
     };
 
-    const result = resolvePricingForUsage("anthropic", "claude-opus-4-6", usage);
+    const result = resolvePricingForUsage(
+      "anthropic",
+      "claude-opus-4-6",
+      usage,
+    );
 
     expect(result.pricingStatus).toBe("priced");
     expect(result.estimatedCostUsd).toBe(5 + 25);
@@ -339,7 +348,11 @@ describe("fast mode pricing", () => {
       speed: null,
     };
 
-    const result = resolvePricingForUsage("anthropic", "claude-opus-4-6", usage);
+    const result = resolvePricingForUsage(
+      "anthropic",
+      "claude-opus-4-6",
+      usage,
+    );
 
     expect(result.pricingStatus).toBe("priced");
     expect(result.estimatedCostUsd).toBe(5 + 25);
@@ -374,7 +387,9 @@ describe("fast mode pricing", () => {
     expect(fastResult.pricingStatus).toBe("priced");
     expect(standardResult.pricingStatus).toBe("priced");
     // Fast mode applies 6x to base rates; cache multipliers stack on top
-    expect(fastResult.estimatedCostUsd).toBe(standardResult.estimatedCostUsd! * 6);
+    expect(fastResult.estimatedCostUsd).toBe(
+      standardResult.estimatedCostUsd! * 6,
+    );
   });
 
   test("does not apply fast mode multiplier for non-Anthropic providers", () => {
@@ -459,7 +474,7 @@ describe("Anthropic models on OpenRouter", () => {
       1_000_000,
     );
     expect(result.pricingStatus).toBe("priced");
-    expect(result.estimatedCostUsd).toBe(0.8 + 4);
+    expect(result.estimatedCostUsd).toBe(1 + 5);
   });
 
   test("prices bare claude-opus-4-6 slug returned unprefixed", () => {
@@ -484,6 +499,53 @@ describe("Anthropic models on OpenRouter", () => {
     expect(result.estimatedCostUsd).toBe(5 + 25);
   });
 
+  test("prices version-first anthropic/claude-4.7-opus-<date> at Opus 4.7 rates", () => {
+    // OpenRouter's response.model for Anthropic calls comes back in the form
+    // `anthropic/claude-<version>-<family>-<date>`, which previously failed
+    // the catalog prefix match (catalog keys are `claude-<family>-<version>`).
+    const result = resolvePricing(
+      "openrouter",
+      "anthropic/claude-4.7-opus-20260416",
+      1_000_000,
+      1_000_000,
+    );
+    expect(result.pricingStatus).toBe("priced");
+    expect(result.estimatedCostUsd).toBe(5 + 25);
+  });
+
+  test("prices version-first dash-form anthropic/claude-4-7-opus-<date>", () => {
+    const result = resolvePricing(
+      "openrouter",
+      "anthropic/claude-4-7-opus-20260416",
+      1_000_000,
+      1_000_000,
+    );
+    expect(result.pricingStatus).toBe("priced");
+    expect(result.estimatedCostUsd).toBe(5 + 25);
+  });
+
+  test("prices version-first anthropic/claude-4.6-sonnet", () => {
+    const result = resolvePricing(
+      "openrouter",
+      "anthropic/claude-4.6-sonnet",
+      1_000_000,
+      1_000_000,
+    );
+    expect(result.pricingStatus).toBe("priced");
+    expect(result.estimatedCostUsd).toBe(3 + 15);
+  });
+
+  test("prices version-first anthropic/claude-4.5-haiku", () => {
+    const result = resolvePricing(
+      "openrouter",
+      "anthropic/claude-4.5-haiku",
+      1_000_000,
+      1_000_000,
+    );
+    expect(result.pricingStatus).toBe("priced");
+    expect(result.estimatedCostUsd).toBe(1 + 5);
+  });
+
   test("returns unpriced for unknown anthropic model on OpenRouter", () => {
     const result = resolvePricing(
       "openrouter",
@@ -495,13 +557,24 @@ describe("Anthropic models on OpenRouter", () => {
     expect(result.estimatedCostUsd).toBeNull();
   });
 
-  test("returns unpriced for non-Anthropic OpenRouter model", () => {
+  test("prices non-Anthropic OpenRouter model from catalog", () => {
     const result = resolvePricing(
       "openrouter",
       "x-ai/grok-4.20-beta",
       1_000_000,
       1_000_000,
     );
+    expect(result.pricingStatus).toBe("priced");
+    expect(result.estimatedCostUsd).toBe(3 + 15);
+  });
+
+  test("returns unpriced for unknown non-Anthropic OpenRouter model", () => {
+    const result = resolvePricing(
+      "openrouter",
+      "unknown-provider/some-model",
+      1_000_000,
+      1_000_000,
+    );
     expect(result.pricingStatus).toBe("unpriced");
     expect(result.estimatedCostUsd).toBeNull();
   });
@@ -519,7 +592,11 @@ describe("Anthropic models on OpenRouter", () => {
       "anthropic/claude-opus-4.6",
       usage,
     );
-    const direct = resolvePricingForUsage("anthropic", "claude-opus-4-6", usage);
+    const direct = resolvePricingForUsage(
+      "anthropic",
+      "claude-opus-4-6",
+      usage,
+    );
 
     // Cache-read tokens are charged at 10% of input rate for Anthropic models.
     expect(openRouter.pricingStatus).toBe("priced");
@@ -576,7 +653,9 @@ describe("Anthropic models on OpenRouter", () => {
 
 describe("usesAnthropicPricingRules", () => {
   test("returns true for direct Anthropic", () => {
-    expect(usesAnthropicPricingRules("anthropic", "claude-opus-4-6")).toBe(true);
+    expect(usesAnthropicPricingRules("anthropic", "claude-opus-4-6")).toBe(
+      true,
+    );
   });
 
   test("returns true for anthropic/* on OpenRouter", () => {

package/src/__tests__/profiler-routes.test.ts

@@ -383,7 +383,7 @@ describe("Profiler routes", () => {
       };
       expect(body.error.code).toBe("INTERNAL_ERROR");
       expect(body.error.message).toContain("archive size");
-    });
+    }, 30000);
   });
 
   describe("DELETE /v1/profiler/runs/:runId", () => {

package/src/__tests__/provider-commit-message-generator.test.ts

@@ -20,15 +20,11 @@ mock.module("../security/secure-keys.js", () => ({
 // ---------------------------------------------------------------------------
 function cloneConfig(): AssistantConfig {
   const cfg = structuredClone(DEFAULT_CONFIG);
-  cfg.services.inference.provider = "anthropic";
+  cfg.llm.default.provider = "anthropic";
   cfg.workspaceGit.commitMessageLLM = {
     ...cfg.workspaceGit.commitMessageLLM,
     enabled: true,
-    useConfiguredProvider: true,
-    providerFastModelOverrides: {},
     timeoutMs: 5000,
-    maxTokens: 120,
-    temperature: 0.2,
     maxFilesInPrompt: 30,
     maxDiffBytes: 12000,
     minRemainingTurnBudgetMs: 1000,
@@ -140,17 +136,6 @@ describe("ProviderCommitMessageGenerator", () => {
     expect(result.reason).toBe("disabled");
   });
 
-  // 2. useConfiguredProvider false
-  test('useConfiguredProvider false → returns deterministic, reason "disabled"', async () => {
-    currentConfig.workspaceGit.commitMessageLLM.useConfiguredProvider = false;
-    const gen = getCommitMessageGenerator();
-    const result = await gen.generateCommitMessage(baseContext, {
-      changedFiles: baseContext.changedFiles,
-    });
-    expect(result.source).toBe("deterministic");
-    expect(result.reason).toBe("disabled");
-  });
-
   // 3. missing API key
   test('missing API key → returns deterministic, reason "missing_provider_api_key"', async () => {
     mockSecureKeys = {};
@@ -221,7 +206,7 @@ describe("ProviderCommitMessageGenerator", () => {
   });
 
   // 6. LLM success
-  test('LLM success → returns LLM message, source "llm", fast model passed', async () => {
+  test('LLM success → returns LLM message, source "llm", callSite passed', async () => {
     const commitMsg = "feat: add new feature";
     mockSendMessage.mockResolvedValueOnce(makeSuccessResponse(commitMsg));
     const gen = getCommitMessageGenerator();
@@ -232,29 +217,13 @@ describe("ProviderCommitMessageGenerator", () => {
     expect(result.message).toBe(commitMsg);
     expect(result.reason).toBeUndefined();
 
-    // Verify the fast model was passed in the config
+    // Verify the callSite was passed so the provider's RetryProvider routes
+    // through `resolveCallSiteConfig` for model/max_tokens/temperature.
     const callArgs = mockSendMessage.mock.calls[0];
-    const options = callArgs[3] as { config: { model: string } };
-    expect(options.config.model).toBe("claude-haiku-4-5-20251001");
-  });
-
-  // 7. fast-model override
-  test("fast-model override → uses override instead of default", async () => {
-    currentConfig.workspaceGit.commitMessageLLM.providerFastModelOverrides = {
-      anthropic: "claude-sonnet-4-20250514",
+    const options = callArgs[3] as {
+      config: { callSite: string };
     };
-    const commitMsg = "fix: resolve issue";
-    mockSendMessage.mockResolvedValueOnce(makeSuccessResponse(commitMsg));
-    const gen = getCommitMessageGenerator();
-    const result = await gen.generateCommitMessage(baseContext, {
-      changedFiles: baseContext.changedFiles,
-    });
-    expect(result.source).toBe("llm");
-    expect(result.message).toBe(commitMsg);
-
-    const callArgs = mockSendMessage.mock.calls[0];
-    const options = callArgs[3] as { config: { model: string } };
-    expect(options.config.model).toBe("claude-sonnet-4-20250514");
+    expect(options.config.callSite).toBe("commitMessage");
   });
 
   // 8. LLM timeout
@@ -330,53 +299,16 @@ describe("ProviderCommitMessageGenerator", () => {
     expect(result.message).toBe("b".repeat(72) + body);
   });
 
-  // 12. Keyless provider (Ollama) without fast model → missing_fast_model (skips API key check)
-  test('Ollama without API key or fast model → returns deterministic, reason "missing_fast_model"', async () => {
-    currentConfig.services.inference.provider = "ollama";
+  // 12. Ollama (keyless provider) — passes the API-key preflight even without
+  // a stored secret, then succeeds because the call-site resolver supplies
+  // the model from `llm.default`/`llm.callSites.commitMessage`.
+  test("Ollama (keyless) — succeeds because call-site resolver supplies the model", async () => {
+    currentConfig.llm.default.provider = "ollama";
     mockSecureKeys = {};
     resolvedProvider = {
       provider: mockProvider,
       configuredProviderName: "ollama",
     };
-    const gen = getCommitMessageGenerator();
-    const result = await gen.generateCommitMessage(baseContext, {
-      changedFiles: baseContext.changedFiles,
-    });
-    expect(result.source).toBe("deterministic");
-    expect(result.reason).toBe("missing_fast_model");
-    expect(result.reason).not.toBe("missing_provider_api_key");
-    expect(mockSendMessage).not.toHaveBeenCalled();
-  });
-
-  // 13. Unknown provider without fast model default → missing_fast_model, no provider call
-  test('Unknown provider without fast model default → returns deterministic, reason "missing_fast_model"', async () => {
-    (currentConfig.services.inference as Record<string, unknown>).provider =
-      "exotic-provider";
-    mockSecureKeys = { "exotic-provider": "sk-exotic" };
-    resolvedProvider = {
-      provider: mockProvider,
-      configuredProviderName: "exotic-provider",
-    };
-    const gen = getCommitMessageGenerator();
-    const result = await gen.generateCommitMessage(baseContext, {
-      changedFiles: baseContext.changedFiles,
-    });
-    expect(result.source).toBe("deterministic");
-    expect(result.reason).toBe("missing_fast_model");
-    expect(mockSendMessage).not.toHaveBeenCalled();
-  });
-
-  // 14. Fast-model override enables LLM path for provider without built-in default
-  test("fast-model override enables LLM path for provider without built-in default", async () => {
-    currentConfig.services.inference.provider = "ollama";
-    mockSecureKeys = {}; // Ollama is keyless
-    resolvedProvider = {
-      provider: mockProvider,
-      configuredProviderName: "ollama",
-    };
-    currentConfig.workspaceGit.commitMessageLLM.providerFastModelOverrides = {
-      ollama: "llama3.2:3b",
-    };
     const commitMsg = "fix: local model commit";
     mockSendMessage.mockResolvedValueOnce(makeSuccessResponse(commitMsg));
     const gen = getCommitMessageGenerator();
@@ -385,10 +317,8 @@ describe("ProviderCommitMessageGenerator", () => {
     });
     expect(result.source).toBe("llm");
     expect(result.message).toBe(commitMsg);
-
-    // Verify the override model was passed
     const callArgs = mockSendMessage.mock.calls[0];
-    const options = callArgs[3] as { config: { model: string } };
-    expect(options.config.model).toBe("llama3.2:3b");
+    const options = callArgs[3] as { config: { callSite: string } };
+    expect(options.config.callSite).toBe("commitMessage");
   });
 });