@vellumai/assistant 0.8.5 → 0.8.7

package/src/__tests__/agent-wake-disk-pressure-callsite.test.ts

@@ -22,6 +22,7 @@ import type { Message } from "../providers/types.js";
 
 mock.module("../memory/conversation-crud.js", () => ({
   getConversationOverrideProfile: () => undefined,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../config/loader.js", () => ({
@@ -73,8 +74,10 @@ function makeTarget(): WakeTarget {
   return {
     conversationId: "conv-wake-callsite",
     agentLoop: {
-      run: (async (messages: Message[]) =>
-        messages) as WakeTarget["agentLoop"]["run"],
+      run: (async (messages: Message[]) => ({
+        history: messages,
+        exitReason: null,
+      })) as WakeTarget["agentLoop"]["run"],
     },
     getMessages: () => history,
     pushMessage: (msg) => {

package/src/__tests__/agent-wake-override-profile.test.ts

@@ -32,6 +32,7 @@ let mockOverrideProfile: string | undefined = undefined;
 
 mock.module("../memory/conversation-crud.js", () => ({
   getConversationOverrideProfile: (_id: string) => mockOverrideProfile,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 // Mutable stub for `getConfig().llm` consumed by `RetryProvider`'s
@@ -47,7 +48,7 @@ mock.module("../config/loader.js", () => ({
   }),
 }));
 
-import type { AgentEvent } from "../agent/loop.js";
+import type { AgentEvent, AgentLoopRunOptions } from "../agent/loop.js";
 import { LLMSchema } from "../config/schemas/llm.js";
 import { RetryProvider } from "../providers/retry.js";
 import type {
@@ -64,13 +65,7 @@ import {
 
 interface RunArgs {
   messages: Message[];
-  signal: AbortSignal | undefined;
-  requestId: string | undefined;
-  onCheckpoint: unknown;
-  callSite: unknown;
-  turnContext: unknown;
-  overrideProfile: string | undefined;
-  effectiveMaxInputTokens: number | undefined;
+  options: AgentLoopRunOptions | undefined;
 }
 
 function makeTarget(): {
@@ -89,26 +84,15 @@ function makeTarget(): {
       run: (async (
         messages: Message[],
         _onEvent: (event: AgentEvent) => void | Promise<void>,
-        signal?: AbortSignal,
-        requestId?: string,
-        onCheckpoint?: unknown,
-        callSite?: unknown,
-        turnContext?: unknown,
-        overrideProfile?: string,
-        effectiveMaxInputTokens?: number,
+        options?: AgentLoopRunOptions,
       ) => {
         runArgs.push({
           messages: [...messages],
-          signal,
-          requestId,
-          onCheckpoint,
-          callSite,
-          turnContext,
-          overrideProfile,
-          effectiveMaxInputTokens,
+          options,
         });
         // Return the input verbatim → silent no-op (no assistant tail).
-        return messages;
+        // Wake never yields at a checkpoint, so the pause-reason is null.
+        return { history: messages, exitReason: null };
       }) as WakeTarget["agentLoop"]["run"],
     },
     getMessages: () => history,
@@ -166,18 +150,17 @@ describe("wakeAgentForOpportunity — overrideProfile forwarding", () => {
 
     expect(result.invoked).toBe(true);
     expect(runArgs).toHaveLength(1);
-    // The 8th positional argument (after messages, onEvent, signal,
-    // requestId, onCheckpoint, callSite, turnContext) is overrideProfile.
-    expect(runArgs[0]!.overrideProfile).toBe("frontier");
-    // The 6th positional argument is callSite. Wakes resume a user-facing
-    // conversation, so route through the same `mainAgent` call site as a
-    // normal user turn — without it the resolver and routing layers would
-    // short-circuit and silently drop both the call-site config and the
-    // pinned override profile.
-    expect(runArgs[0]!.callSite).toBe("mainAgent");
-    expect(runArgs[0]!.effectiveMaxInputTokens).toBe(150000);
+    expect(runArgs[0]!.options?.overrideProfile).toBe("frontier");
+    // Wakes resume a user-facing conversation, so route through the same
+    // `mainAgent` call site as a normal user turn — without it the resolver
+    // and routing layers would short-circuit and silently drop both the
+    // call-site config and the pinned override profile.
+    expect(runArgs[0]!.options?.callSite).toBe("mainAgent");
+    expect(runArgs[0]!.options?.resolveContextWindow?.().maxInputTokens).toBe(
+      150000,
+    );
     // Sanity: the wake-source tag still propagates as requestId.
-    expect(runArgs[0]!.requestId).toBe("wake:scheduler");
+    expect(runArgs[0]!.options?.requestId).toBe("wake:scheduler");
   });
 
   test("passes undefined overrideProfile when the conversation has no pinned profile, but still forwards mainAgent callSite", async () => {
@@ -194,13 +177,15 @@ describe("wakeAgentForOpportunity — overrideProfile forwarding", () => {
     );
 
     expect(runArgs).toHaveLength(1);
-    expect(runArgs[0]!.overrideProfile).toBeUndefined();
+    expect(runArgs[0]!.options?.overrideProfile).toBeUndefined();
     // Even without an override profile, we still need callSite="mainAgent"
     // so the resolver picks up `llm.callSites.mainAgent` config (model,
     // maxTokens, effort, etc.). Otherwise the wake silently runs under
     // workspace defaults regardless of any per-call-site configuration.
-    expect(runArgs[0]!.callSite).toBe("mainAgent");
-    expect(runArgs[0]!.effectiveMaxInputTokens).toBeGreaterThan(0);
+    expect(runArgs[0]!.options?.callSite).toBe("mainAgent");
+    expect(
+      runArgs[0]!.options?.resolveContextWindow?.().maxInputTokens,
+    ).toBeGreaterThan(0);
   });
 });
 
@@ -220,7 +205,7 @@ describe("wakeAgentForOpportunity — resolver actually engages", () => {
   ): Provider {
     return {
       name,
-      async sendMessage(_messages, _tools, _systemPrompt, options) {
+      async sendMessage(_messages: Message[], options?: SendMessageOptions) {
         onCall(options);
         const response: ProviderResponse = {
           content: [{ type: "text", text: "ok" }],
@@ -266,8 +251,6 @@ describe("wakeAgentForOpportunity — resolver actually engages", () => {
     // `callSite` and `overrideProfile` are both set (see `agent/loop.ts`).
     await wrapped.sendMessage(
       [{ role: "user", content: [{ type: "text", text: "hi" }] }],
-      undefined,
-      undefined,
       { config: { callSite: "mainAgent", overrideProfile: "frontier" } },
     );
 

package/src/__tests__/always-loaded-tools-guard.test.ts

@@ -14,12 +14,12 @@
 import { afterAll, describe, expect, test } from "bun:test";
 
 import {
-  buildToolDefinitions,
   isToolActiveForContext,
   type SkillProjectionContext,
 } from "../daemon/conversation-tool-setup.js";
 import {
   __resetRegistryForTesting,
+  getAllToolDefinitions,
   initializeTools,
 } from "../tools/registry.js";
 
@@ -30,7 +30,7 @@ afterAll(() => {
 describe("always-loaded tool count", () => {
   test("should be exactly 11 with recall occupying the existing slot", async () => {
     await initializeTools();
-    const allDefs = buildToolDefinitions();
+    const allDefs = getAllToolDefinitions();
 
     // Minimal context: no client, no capabilities
     const minimalContext: SkillProjectionContext = {

package/src/__tests__/annotate-risk-options.test.ts

@@ -57,6 +57,7 @@ mock.module("../memory/conversation-crud.js", () => ({
     updates.push({ id, content });
   },
   provenanceFromTrustContext: () => ({}),
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/llm-request-log-store.js", () => ({

package/src/__tests__/anthropic-provider.test.ts

@@ -180,7 +180,9 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
   // System prompt cache control
   // -----------------------------------------------------------------------
   test("system prompt has cache_control ephemeral with 1h TTL", async () => {
-    await provider.sendMessage([userMsg("Hi")], undefined, "You are helpful.");
+    await provider.sendMessage([userMsg("Hi")], {
+      systemPrompt: "You are helpful.",
+    });
 
     const system = lastStreamParams!.system as Array<{
       type: string;
@@ -198,7 +200,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
   });
 
   test("sends disabled thinking config natively", async () => {
-    await provider.sendMessage([userMsg("Hi")], undefined, undefined, {
+    await provider.sendMessage([userMsg("Hi")], {
       config: { thinking: { type: "disabled" } },
     });
 
@@ -230,7 +232,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
   test("renders the system prompt as a single 1h-cached block", async () => {
     const prompt = "You are a helpful assistant.";
 
-    await provider.sendMessage([userMsg("Hi")], undefined, prompt);
+    await provider.sendMessage([userMsg("Hi")], { systemPrompt: prompt });
 
     const system = lastStreamParams!.system as Array<{
       type: string;
@@ -251,7 +253,10 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
       toolUseMsg("tu_1", "bash"),
       toolResultMsg("tu_1", "output"),
     ];
-    await provider.sendMessage(messages, sampleTools, prompt);
+    await provider.sendMessage(messages, {
+      tools: sampleTools,
+      systemPrompt: prompt,
+    });
 
     const system = lastStreamParams!.system as Array<{
       type: string;
@@ -291,7 +296,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
   // Tool cache control
   // -----------------------------------------------------------------------
   test("only last tool definition includes cache_control", async () => {
-    await provider.sendMessage([userMsg("Hi")], sampleTools);
+    await provider.sendMessage([userMsg("Hi")], { tools: sampleTools });
 
     const tools = lastStreamParams!.tools as Array<{
       name: string;
@@ -308,7 +313,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
   });
 
   test("single tool gets cache_control", async () => {
-    await provider.sendMessage([userMsg("Hi")], [sampleTools[0]]);
+    await provider.sendMessage([userMsg("Hi")], { tools: [sampleTools[0]] });
 
     const tools = lastStreamParams!.tools as Array<{
       name: string;
@@ -409,14 +414,9 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     // per call with content that changes every time. Caching the turn-start
     // block would create unused entries — `disableTurnStartCache: true`
     // opts out.
-    await provider.sendMessage(
-      [userMsg("Pick relevant pages")],
-      undefined,
-      undefined,
-      {
-        config: { disableTurnStartCache: true },
-      },
-    );
+    await provider.sendMessage([userMsg("Pick relevant pages")], {
+      config: { disableTurnStartCache: true },
+    });
 
     const sent = lastStreamParams!.messages as Array<{
       role: string;
@@ -458,6 +458,128 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     }
   });
 
+  // -----------------------------------------------------------------------
+  // mutableLatestUserMessage — volatile trailing user message cache anchor
+  // -----------------------------------------------------------------------
+  test("mutableLatestUserMessage: first-of-turn skips the volatile turn-start anchor and anchors the previous stable user message", async () => {
+    // The latest user message carries per-turn-volatile content (e.g. an
+    // injected memory block). The long-TTL anchor must move off it onto the
+    // most recent stable user message so the cached prefix stays reusable.
+    const messages: Message[] = [
+      userMsg("Turn 1"),
+      assistantMsg("Response 1"),
+      userMsg("Turn 2 (volatile)"),
+    ];
+    await provider.sendMessage(messages, {
+      config: { mutableLatestUserMessage: true },
+    });
+
+    const sent = lastStreamParams!.messages as Array<{
+      role: string;
+      content: Array<{
+        type: string;
+        text: string;
+        cache_control?: { type: string; ttl?: string };
+      }>;
+    }>;
+    const userMessages = sent.filter((m) => m.role === "user");
+
+    // Latest (turn-start) user message gets NO long-TTL breakpoint — it's volatile.
+    const latest = userMessages[userMessages.length - 1];
+    for (const block of latest.content) {
+      expect(block.cache_control).toBeUndefined();
+    }
+
+    // Previous stable user message (Turn 1) becomes the primary anchor.
+    const prev = userMessages[userMessages.length - 2];
+    const prevLast = prev.content[prev.content.length - 1];
+    expect(prevLast.cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
+  });
+
+  test("mutableLatestUserMessage absent: breakpoint placement is byte-identical to default behavior (v2 regression guard)", async () => {
+    const messages: Message[] = [
+      userMsg("Turn 1"),
+      assistantMsg("Response 1"),
+      userMsg("Turn 2"),
+    ];
+    await provider.sendMessage(messages);
+
+    const sent = lastStreamParams!.messages as Array<{
+      role: string;
+      content: Array<{
+        type: string;
+        cache_control?: { type: string; ttl?: string };
+      }>;
+    }>;
+    const userMessages = sent.filter((m) => m.role === "user");
+
+    // Current-turn (latest) anchor keeps 1h.
+    const latest = userMessages[userMessages.length - 1];
+    const latestLast = latest.content[latest.content.length - 1];
+    expect(latestLast.cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
+    // Previous-turn anchor keeps 1h.
+    const prev = userMessages[userMessages.length - 2];
+    const prevLast = prev.content[prev.content.length - 1];
+    expect(prevLast.cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
+  });
+
+  test("mutableLatestUserMessage: during a tool-use loop placement is unchanged (block is fixed within the turn)", async () => {
+    // Turn-start is not the last message (tool_result follows), so the
+    // turn-start block is fixed for the rest of the turn — the flag must not
+    // move the anchor.
+    const messages: Message[] = [
+      userMsg("Turn 1"),
+      assistantMsg("Response 1"),
+      userMsg("Turn 2"),
+      toolUseMsg("tu_1", "bash"),
+      toolResultMsg("tu_1", "output"),
+    ];
+    await provider.sendMessage(messages, {
+      config: { mutableLatestUserMessage: true },
+    });
+
+    const sent = lastStreamParams!.messages as Array<{
+      role: string;
+      content: Array<{
+        type: string;
+        cache_control?: { type: string; ttl?: string };
+      }>;
+    }>;
+
+    // Turn-start (Turn 2, index 2) still gets the 1h anchor — within a tool-use
+    // loop the block is fixed, so the volatile-latest flag must not move it.
+    const turn2 = sent[2];
+    const turn2Last = turn2.content[turn2.content.length - 1];
+    expect(turn2Last.cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
+  });
+
+  test("mutableLatestUserMessage: first turn with no previous user message does not throw and applies no long-TTL anchor", async () => {
+    await provider.sendMessage([userMsg("First ever turn (volatile)")], {
+      config: { mutableLatestUserMessage: true },
+    });
+
+    const sent = lastStreamParams!.messages as Array<{
+      role: string;
+      content: Array<{
+        type: string;
+        cache_control?: { type: string; ttl?: string };
+      }>;
+    }>;
+    // Only user message is volatile and there is no prior stable one, so no
+    // long-TTL breakpoint lands on any user message — graceful, no throw.
+    const lastBlock = sent[0].content[sent[0].content.length - 1];
+    expect(lastBlock.cache_control).toBeUndefined();
+  });
+
+  test("mutableLatestUserMessage is not forwarded to the Anthropic API", async () => {
+    await provider.sendMessage([userMsg("Hi")], {
+      config: { mutableLatestUserMessage: true },
+    });
+    expect(
+      (lastStreamParams as Record<string, unknown>).mutableLatestUserMessage,
+    ).toBeUndefined();
+  });
+
   // -----------------------------------------------------------------------
   // Negative: assistant messages never get cache_control
   // -----------------------------------------------------------------------
@@ -1537,7 +1659,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
       { kind: "blockStop" },
     ];
     const emitted: string[] = [];
-    await provider.sendMessage([userMsg("Hi")], undefined, undefined, {
+    await provider.sendMessage([userMsg("Hi")], {
       onEvent: (event) => {
         if (event.type === "text_delta") emitted.push(event.text);
       },
@@ -1554,7 +1676,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
       { kind: "blockStop" },
     ];
     const emitted: string[] = [];
-    await provider.sendMessage([userMsg("Hi")], undefined, undefined, {
+    await provider.sendMessage([userMsg("Hi")], {
       onEvent: (event) => {
         if (event.type === "text_delta") emitted.push(event.text);
       },
@@ -1569,7 +1691,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
       { kind: "blockStop" },
     ];
     const emitted: string[] = [];
-    await provider.sendMessage([userMsg("Hi")], undefined, undefined, {
+    await provider.sendMessage([userMsg("Hi")], {
       onEvent: (event) => {
         if (event.type === "text_delta") emitted.push(event.text);
       },
@@ -1586,7 +1708,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
       { kind: "blockStop" },
     ];
     const emitted: string[] = [];
-    await provider.sendMessage([userMsg("Hi")], undefined, undefined, {
+    await provider.sendMessage([userMsg("Hi")], {
       onEvent: (event) => {
         if (event.type === "text_delta") emitted.push(event.text);
       },
@@ -1605,7 +1727,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
       { kind: "blockStop" },
     ];
     const emitted: string[] = [];
-    await provider.sendMessage([userMsg("Hi")], undefined, undefined, {
+    await provider.sendMessage([userMsg("Hi")], {
       onEvent: (event) => {
         if (event.type === "text_delta") emitted.push(event.text);
       },
@@ -1622,7 +1744,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
       { kind: "blockStop" },
     ];
     const emitted: string[] = [];
-    await provider.sendMessage([userMsg("Hi")], undefined, undefined, {
+    await provider.sendMessage([userMsg("Hi")], {
       onEvent: (event) => {
         if (event.type === "text_delta") emitted.push(event.text);
       },
@@ -1640,7 +1762,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
       { kind: "blockStop" },
     ];
     const emitted: string[] = [];
-    await provider.sendMessage([userMsg("Hi")], undefined, undefined, {
+    await provider.sendMessage([userMsg("Hi")], {
       onEvent: (event) => {
         if (event.type === "text_delta") emitted.push(event.text);
       },
@@ -2120,11 +2242,10 @@ describe("AnthropicProvider — Managed Proxy Fallback", () => {
       baseURL: "https://platform.example.com/v1/runtime-proxy/anthropic",
     });
 
-    await provider.sendMessage(
-      [userMsg("Hi")],
-      sampleTools,
-      "You are helpful.",
-    );
+    await provider.sendMessage([userMsg("Hi")], {
+      tools: sampleTools,
+      systemPrompt: "You are helpful.",
+    });
 
     // System prompt cache control
     const system = lastStreamParams!.system as Array<{
@@ -2224,13 +2345,16 @@ describe("AnthropicProvider — Haiku Model Gating", () => {
   });
 
   test("max_tokens defaults to 8192 for Haiku", async () => {
-    await provider.sendMessage([userMsg("Hi")], undefined, "You are helpful.");
+    await provider.sendMessage([userMsg("Hi")], {
+      systemPrompt: "You are helpful.",
+    });
 
     expect(lastStreamParams!.max_tokens).toBe(8192);
   });
 
   test("caller max_tokens is clamped to 8192 for Haiku", async () => {
-    await provider.sendMessage([userMsg("Hi")], undefined, "You are helpful.", {
+    await provider.sendMessage([userMsg("Hi")], {
+      systemPrompt: "You are helpful.",
       config: { max_tokens: 64000 },
     });
 
@@ -2238,7 +2362,8 @@ describe("AnthropicProvider — Haiku Model Gating", () => {
   });
 
   test("caller max_tokens below 8192 is preserved for Haiku", async () => {
-    await provider.sendMessage([userMsg("Hi")], undefined, "You are helpful.", {
+    await provider.sendMessage([userMsg("Hi")], {
+      systemPrompt: "You are helpful.",
       config: { max_tokens: 128 },
     });
 
@@ -2250,18 +2375,18 @@ describe("AnthropicProvider — Haiku Model Gating", () => {
       "sk-ant-test",
       "claude-sonnet-4-6",
     );
-    await sonnetProvider.sendMessage(
-      [userMsg("Hi")],
-      undefined,
-      "You are helpful.",
-      { config: { max_tokens: 200 } },
-    );
+    await sonnetProvider.sendMessage([userMsg("Hi")], {
+      systemPrompt: "You are helpful.",
+      config: { max_tokens: 200 },
+    });
 
     expect(lastStreamParams!.max_tokens).toBe(200);
   });
 
   test("cache_control omits ttl for Haiku", async () => {
-    await provider.sendMessage([userMsg("Hi")], undefined, "You are helpful.");
+    await provider.sendMessage([userMsg("Hi")], {
+      systemPrompt: "You are helpful.",
+    });
 
     const system = lastStreamParams!.system as Array<{
       cache_control?: { type: string; ttl?: string };
@@ -2271,7 +2396,9 @@ describe("AnthropicProvider — Haiku Model Gating", () => {
   });
 
   test("betas array is empty for Haiku (no extended cache TTL)", async () => {
-    await provider.sendMessage([userMsg("Hi")], undefined, "You are helpful.");
+    await provider.sendMessage([userMsg("Hi")], {
+      systemPrompt: "You are helpful.",
+    });
 
     // When betas is empty, the non-beta stream path is used, so no betas
     // field should appear in lastStreamParams.
@@ -2279,7 +2406,8 @@ describe("AnthropicProvider — Haiku Model Gating", () => {
   });
 
   test("effort is stripped for Haiku even when provided in config", async () => {
-    await provider.sendMessage([userMsg("Hi")], undefined, "You are helpful.", {
+    await provider.sendMessage([userMsg("Hi")], {
+      systemPrompt: "You are helpful.",
       config: { effort: "high" },
     });
 
@@ -2291,12 +2419,10 @@ describe("AnthropicProvider — Haiku Model Gating", () => {
       "sk-ant-test",
       "claude-sonnet-4-6",
     );
-    await sonnetProvider.sendMessage(
-      [userMsg("Hi")],
-      undefined,
-      "You are helpful.",
-      { config: { effort: "none" } },
-    );
+    await sonnetProvider.sendMessage([userMsg("Hi")], {
+      systemPrompt: "You are helpful.",
+      config: { effort: "none" },
+    });
 
     // mergedOutputConfig is empty when effort is "none" and no other
     // output_config fields were supplied, so output_config is not attached
@@ -2323,7 +2449,9 @@ describe("OpenRouterProvider — Anthropic dispatch", () => {
       "or-key",
       "anthropic/claude-sonnet-4.6",
     );
-    await provider.sendMessage([userMsg("hi")], undefined, "You are helpful.");
+    await provider.sendMessage([userMsg("hi")], {
+      systemPrompt: "You are helpful.",
+    });
 
     expect(lastConstructorArgs).toMatchObject({
       apiKey: null,
@@ -2358,7 +2486,7 @@ describe("OpenRouterProvider — Anthropic dispatch", () => {
       "or-key",
       "anthropic/claude-sonnet-4.6",
     );
-    await provider.sendMessage([userMsg("hi")], undefined, undefined, {
+    await provider.sendMessage([userMsg("hi")], {
       config: { thinking: { type: "adaptive" } },
     });
 
@@ -2375,7 +2503,7 @@ describe("OpenRouterProvider — Anthropic dispatch", () => {
       "or-key",
       "anthropic/claude-sonnet-4.6",
     );
-    await provider.sendMessage([userMsg("hi")], undefined, undefined, {
+    await provider.sendMessage([userMsg("hi")], {
       config: { thinking: { type: "disabled" } },
     });
 
@@ -2390,7 +2518,7 @@ describe("OpenRouterProvider — Anthropic dispatch", () => {
       "or-key",
       "anthropic/claude-sonnet-4.6",
     );
-    await provider.sendMessage([userMsg("hi")], undefined, undefined, {
+    await provider.sendMessage([userMsg("hi")], {
       config: {
         usageAttributionHeaders: {
           "Vellum-Organization-Id": "org-123",
@@ -2418,7 +2546,7 @@ describe("OpenRouterProvider — Anthropic dispatch", () => {
     // Default model is non-Anthropic, but the request overrides with an
     // Anthropic model — dispatch must honour the request-level model.
     const provider = new OpenRouterProvider("or-key", "x-ai/grok-4");
-    await provider.sendMessage([userMsg("hi")], undefined, undefined, {
+    await provider.sendMessage([userMsg("hi")], {
       config: { model: "anthropic/claude-haiku-4.5" },
     });
 
@@ -2488,7 +2616,10 @@ describe("AnthropicProvider — thinking block send-time filtering", () => {
       userMsg("And what is 3+3?"),
     ];
 
-    await provider.sendMessage(messages, sampleTools, "system");
+    await provider.sendMessage(messages, {
+      tools: sampleTools,
+      systemPrompt: "system",
+    });
     expect(lastStreamParams).toBeTruthy();
 
     const sent = lastStreamParams!.messages as Anthropic.MessageParam[];
@@ -2514,7 +2645,10 @@ describe("AnthropicProvider — thinking block send-time filtering", () => {
       userMsg("And what is 3+3?"),
     ];
 
-    await provider.sendMessage(messages, sampleTools, "system");
+    await provider.sendMessage(messages, {
+      tools: sampleTools,
+      systemPrompt: "system",
+    });
     expect(lastStreamParams).toBeTruthy();
 
     const sent = lastStreamParams!.messages as Anthropic.MessageParam[];
@@ -2540,7 +2674,10 @@ describe("AnthropicProvider — thinking block send-time filtering", () => {
       toolResultMsg("tu-1", "file contents here"),
     ];
 
-    await provider.sendMessage(messages, sampleTools, "system");
+    await provider.sendMessage(messages, {
+      tools: sampleTools,
+      systemPrompt: "system",
+    });
     expect(lastStreamParams).toBeTruthy();
 
     const sent = lastStreamParams!.messages as Anthropic.MessageParam[];
@@ -2573,7 +2710,10 @@ describe("AnthropicProvider — thinking block send-time filtering", () => {
       toolResultMsg("tu-2", "file contents"),
     ];
 
-    await provider.sendMessage(messages, sampleTools, "system");
+    await provider.sendMessage(messages, {
+      tools: sampleTools,
+      systemPrompt: "system",
+    });
     expect(lastStreamParams).toBeTruthy();
 
     const sent = lastStreamParams!.messages as Anthropic.MessageParam[];
@@ -2610,7 +2750,10 @@ describe("AnthropicProvider — thinking block send-time filtering", () => {
       userMsg("What did you conclude?"),
     ];
 
-    await provider.sendMessage(messages, sampleTools, "system");
+    await provider.sendMessage(messages, {
+      tools: sampleTools,
+      systemPrompt: "system",
+    });
     expect(lastStreamParams).toBeTruthy();
 
     const sent = lastStreamParams!.messages as Anthropic.MessageParam[];
@@ -2648,7 +2791,10 @@ describe("AnthropicProvider — thinking block send-time filtering", () => {
       toolResultMsg("tu-b", "result b"),
     ];
 
-    await provider.sendMessage(messages, sampleTools, "system");
+    await provider.sendMessage(messages, {
+      tools: sampleTools,
+      systemPrompt: "system",
+    });
     expect(lastStreamParams).toBeTruthy();
 
     const sent = lastStreamParams!.messages as Anthropic.MessageParam[];