@vellumai/assistant 0.8.3 → 0.8.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.8.3",
+  "version": "0.8.5",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/agent-loop-exit-reason.test.ts

@@ -7,8 +7,8 @@
  *     throw → catch-block fallback case).
  *  2. **Reason matches break site** — for each reachable break site, the
  *     emitted reason is the one documented in `AgentLoopExitReason`.
- *  3. **Always the last AgentEvent of the run** — consumers can rely on
- *     positional ordering to find it.
+ *  3. **Always the last AgentEvent of terminal runs** — consumers can rely on
+ *     positional ordering to find it when a run reaches a terminal state.
  *
  * Sites not exercised here (`empty_response_exhausted`, `aborted_via_error`)
  * require deeper provider fakery and are best covered by integration tests
@@ -172,7 +172,7 @@ describe("AgentLoop exit-reason instrumentation", () => {
     expect(lastExitEvent(events)?.reason).toBe("yield_to_user");
   });
 
-  test("emits 'checkpoint_yield' when onCheckpoint returns 'yield'", async () => {
+  test("does not emit agent_loop_exit when onCheckpoint yields control", async () => {
     const { provider } = createMockProvider([
       toolUseResponse("t1", "read_file", { path: "/a.txt" }),
       textResponse("never reached"),
@@ -198,8 +198,7 @@ describe("AgentLoop exit-reason instrumentation", () => {
       onCheckpoint,
     );
 
-    expect(countExitEvents(events)).toBe(1);
-    expect(lastExitEvent(events)?.reason).toBe("checkpoint_yield");
+    expect(countExitEvents(events)).toBe(0);
   });
 
   test("emits 'error' when provider throws an unhandled error", async () => {

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

@@ -257,7 +257,7 @@ const anthropicStub = { name: "anthropic" };
 mock.module("../providers/registry.js", () => ({
   getProvider: () => anthropicStub,
   listProviders: () => ["anthropic"],
-  initializeProviders: () => {},
+  initializeProviders: async () => {},
   resolveProviderFromConnection: async () => anthropicStub,
 }));
 

package/src/__tests__/agent-loop.test.ts

@@ -181,6 +181,88 @@ describe("AgentLoop", () => {
     ]);
   });
 
+  test("re-resolves override profile before each provider call", async () => {
+    const toolCallId = "tool-1";
+    const { provider, calls } = createMockProvider([
+      toolUseResponse(toolCallId, "read_file", { path: "/tmp/test.txt" }),
+      textResponse("File contents received."),
+    ]);
+
+    let overrideProfile: string | undefined;
+    const toolExecutor = async () => {
+      overrideProfile = "quality-optimized";
+      return { content: "ok", isError: false };
+    };
+    const loop = new AgentLoop(
+      provider,
+      "system",
+      {},
+      dummyTools,
+      toolExecutor,
+    );
+
+    await loop.run(
+      [userMessage],
+      collectEvents([]),
+      undefined,
+      "req-1",
+      undefined,
+      "mainAgent",
+      undefined,
+      undefined,
+      undefined,
+      () => overrideProfile,
+    );
+
+    expect(calls).toHaveLength(2);
+    expect(calls[0].options?.config?.overrideProfile).toBeUndefined();
+    expect(calls[1].options?.config?.overrideProfile).toBe("quality-optimized");
+  });
+
+  test("re-resolves max input tokens before truncating tool results", async () => {
+    const toolCallId = "tool-1";
+    const toolOutput = "x".repeat(2_500);
+    const { provider, calls } = createMockProvider([
+      toolUseResponse(toolCallId, "read_file", { path: "/tmp/test.txt" }),
+      textResponse("File contents received."),
+    ]);
+
+    let maxInputTokens = 1_000;
+    const toolExecutor = async () => {
+      maxInputTokens = 10_000;
+      return { content: toolOutput, isError: false };
+    };
+    const loop = new AgentLoop(
+      provider,
+      "system",
+      {},
+      dummyTools,
+      toolExecutor,
+    );
+
+    await loop.run(
+      [userMessage],
+      collectEvents([]),
+      undefined,
+      "req-1",
+      undefined,
+      "mainAgent",
+      undefined,
+      undefined,
+      1_000,
+      undefined,
+      () => maxInputTokens,
+    );
+
+    const secondCallMessages = calls[1].messages;
+    const lastMsg = secondCallMessages[secondCallMessages.length - 1];
+    const toolResultBlock = lastMsg.content.find(
+      (b): b is Extract<ContentBlock, { type: "tool_result" }> =>
+        b.type === "tool_result",
+    );
+    expect(toolResultBlock?.content).toBe(toolOutput);
+  });
+
   // 3. Multi-turn tool loop
   test("supports multi-turn tool execution", async () => {
     const { provider, calls } = createMockProvider([
@@ -470,7 +552,6 @@ describe("AgentLoop", () => {
     ).toBe(false);
   });
 
-
   // 9. Tool executor error results are forwarded correctly
   test("forwards tool error results to provider", async () => {
     const { provider, calls } = createMockProvider([
@@ -1767,7 +1848,9 @@ describe("AgentLoop", () => {
     ]);
 
     // message_complete emitted for tool_use response + retry text response (not the empty one)
-    const messageCompletes = events.filter((e) => e.type === "message_complete");
+    const messageCompletes = events.filter(
+      (e) => e.type === "message_complete",
+    );
     expect(messageCompletes).toHaveLength(2);
   });
 
@@ -1883,7 +1966,9 @@ describe("AgentLoop", () => {
     expect(calls).toHaveLength(3);
 
     // message_complete: tool_use response + final empty response (retry exhausted)
-    const messageCompletes = events.filter((e) => e.type === "message_complete");
+    const messageCompletes = events.filter(
+      (e) => e.type === "message_complete",
+    );
     expect(messageCompletes).toHaveLength(2);
 
     // The last assistant message in history is the empty one

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

@@ -1,5 +1,7 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+import type { Anthropic } from "@anthropic-ai/sdk";
+
 import type { Message, ToolDefinition } from "../providers/types.js";
 
 // ---------------------------------------------------------------------------
@@ -100,7 +102,6 @@ mock.module("@anthropic-ai/sdk", () => ({
 }));
 
 // Import after mocking
-import { SYSTEM_PROMPT_CACHE_BOUNDARY } from "../prompts/system-prompt.js";
 import {
   AnthropicProvider,
   isPlaceholderSentinelText,
@@ -204,28 +205,30 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     expect(lastStreamParams!.thinking).toEqual({ type: "disabled" });
   });
 
-  test("splits system prompt into two cache blocks on boundary marker", async () => {
-    const staticBlock = "You are a helpful assistant.";
-    const dynamicBlock = "User workspace files here.";
-    const prompt = staticBlock + SYSTEM_PROMPT_CACHE_BOUNDARY + dynamicBlock;
-
-    await provider.sendMessage([userMsg("Hi")], undefined, prompt);
+  test("drops unsigned thinking blocks from prior assistant messages", async () => {
+    await provider.sendMessage([
+      userMsg("Hi"),
+      {
+        role: "assistant",
+        content: [
+          { type: "thinking", thinking: "non-native reasoning", signature: "" },
+          { type: "text", text: "I can help." },
+        ],
+      },
+      userMsg("Continue"),
+    ]);
 
-    const system = lastStreamParams!.system as Array<{
-      type: string;
-      text: string;
-      cache_control?: { type: string; ttl?: string };
+    const messages = lastStreamParams!.messages as Array<{
+      role: string;
+      content: Array<{ type: string; text?: string; thinking?: string }>;
     }>;
-    expect(system).toHaveLength(2);
-    expect(system[0].text).toBe(staticBlock);
-    expect(system[0].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
-    expect(system[1].text).toBe(dynamicBlock);
-    expect(system[1].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
+    const assistant = messages.find((message) => message.role === "assistant");
+
+    expect(assistant?.content).toEqual([{ type: "text", text: "I can help." }]);
   });
 
-  test("omits empty dynamic system block after cache boundary", async () => {
-    const staticBlock = "You are a helpful assistant.";
-    const prompt = staticBlock + SYSTEM_PROMPT_CACHE_BOUNDARY;
+  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);
 
@@ -235,16 +238,14 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
       cache_control?: { type: string; ttl?: string };
     }>;
     expect(system).toHaveLength(1);
-    expect(system[0].text).toBe(staticBlock);
+    expect(system[0].text).toBe(prompt);
     expect(system[0].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
   });
 
-  test("drops static system block cache_control when total would exceed 4", async () => {
-    const staticBlock = "You are a helpful assistant.";
-    const dynamicBlock = "User workspace files here.";
-    const prompt = staticBlock + SYSTEM_PROMPT_CACHE_BOUNDARY + dynamicBlock;
-
-    // Boundary (2 system) + tools (1) + turn-start (1) + tail (1) = 5 → must cap at 4
+  test("applies the standard 4-breakpoint cache layout in a tool-use loop", async () => {
+    // system(1) + tools(1) + turn-start(1) + tail(1) = 4, the Anthropic
+    // per-request cap.  All four breakpoints should be present.
+    const prompt = "You are a helpful assistant.";
     const messages: Message[] = [
       userMsg("Do something"),
       toolUseMsg("tu_1", "bash"),
@@ -257,13 +258,9 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
       text: string;
       cache_control?: { type: string; ttl?: string };
     }>;
-    expect(system).toHaveLength(2);
-    // Static block's cache_control dropped (small, cheap to re-read)
-    expect(system[0].cache_control).toBeUndefined();
-    // Dynamic block keeps its cache_control
-    expect(system[1].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
+    expect(system).toHaveLength(1);
+    expect(system[0].cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
 
-    // Tools breakpoint still present
     const tools = lastStreamParams!.tools as Array<{
       cache_control?: { type: string; ttl?: string };
     }>;
@@ -272,7 +269,6 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
       ttl: "1h",
     });
 
-    // Turn-start + tail breakpoints still present
     const sent = lastStreamParams!.messages as Array<{
       role: string;
       content: Array<{
@@ -408,6 +404,31 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     expect(lastBlock.cache_control).toEqual({ type: "ephemeral", ttl: "1h" });
   });
 
+  test("disableTurnStartCache suppresses the 1h breakpoint on the turn-starting user message", async () => {
+    // One-shot callers (e.g. the memory router) send a single user message
+    // 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 },
+      },
+    );
+
+    const sent = lastStreamParams!.messages as Array<{
+      role: string;
+      content: Array<{
+        type: string;
+        cache_control?: { type: string; ttl?: string };
+      }>;
+    }>;
+    const lastBlock = sent[0].content[sent[0].content.length - 1];
+    expect(lastBlock.cache_control).toBeUndefined();
+  });
+
   test("previous-turn anchor is NOT applied during a tool-use loop", async () => {
     // When the request is mid tool-use (last msg is a tool_result), the
     // turn-start anchor already covers the long prefix, so we must not
@@ -2405,3 +2426,251 @@ describe("OpenRouterProvider — Anthropic dispatch", () => {
     expect(lastStreamParams!.model).toBe("anthropic/claude-haiku-4.5");
   });
 });
+
+// ---------------------------------------------------------------------------
+// Thinking block send-time filtering
+// ---------------------------------------------------------------------------
+
+describe("AnthropicProvider — thinking block send-time filtering", () => {
+  let provider: AnthropicProvider;
+
+  beforeEach(() => {
+    lastStreamParams = null;
+    _lastStreamOptions = null;
+    lastConstructorArgs = null;
+    scriptedStream = null;
+    provider = new AnthropicProvider("sk-ant-test", "claude-sonnet-4-6");
+  });
+
+  function assistantThinkingMsg(
+    thinking: string,
+    signature: string,
+    text: string,
+  ): Message {
+    return {
+      role: "assistant",
+      content: [
+        { type: "thinking", thinking, signature },
+        { type: "text", text },
+      ],
+    };
+  }
+
+  function assistantThinkingToolUseMsg(
+    thinking: string,
+    signature: string,
+    toolUseId: string,
+    toolName: string,
+  ): Message {
+    return {
+      role: "assistant",
+      content: [
+        { type: "thinking", thinking, signature },
+        { type: "tool_use", id: toolUseId, name: toolName, input: {} },
+      ],
+    };
+  }
+
+  function assistantRedactedThinkingMsg(data: string, text: string): Message {
+    return {
+      role: "assistant",
+      content: [
+        { type: "redacted_thinking", data },
+        { type: "text", text },
+      ],
+    };
+  }
+
+  test("strips thinking blocks from completed historical assistant turns", async () => {
+    const messages: Message[] = [
+      userMsg("What is 2+2?"),
+      assistantThinkingMsg("let me think...", "sig-abc-old", "4"),
+      userMsg("And what is 3+3?"),
+    ];
+
+    await provider.sendMessage(messages, sampleTools, "system");
+    expect(lastStreamParams).toBeTruthy();
+
+    const sent = lastStreamParams!.messages as Anthropic.MessageParam[];
+    const assistantTurn = sent.find((m) => m.role === "assistant");
+    expect(assistantTurn).toBeTruthy();
+
+    const blocks = assistantTurn!.content as Anthropic.ContentBlockParam[];
+    const thinkingBlocks = blocks.filter(
+      (b) => typeof b !== "string" && b.type === "thinking",
+    );
+    expect(thinkingBlocks).toHaveLength(0);
+
+    const textBlocks = blocks.filter(
+      (b) => typeof b !== "string" && b.type === "text",
+    );
+    expect(textBlocks).toHaveLength(1);
+  });
+
+  test("strips redacted_thinking blocks from completed historical turns", async () => {
+    const messages: Message[] = [
+      userMsg("What is 2+2?"),
+      assistantRedactedThinkingMsg("encrypted-data-xyz", "4"),
+      userMsg("And what is 3+3?"),
+    ];
+
+    await provider.sendMessage(messages, sampleTools, "system");
+    expect(lastStreamParams).toBeTruthy();
+
+    const sent = lastStreamParams!.messages as Anthropic.MessageParam[];
+    const assistantTurn = sent.find((m) => m.role === "assistant");
+    expect(assistantTurn).toBeTruthy();
+
+    const blocks = assistantTurn!.content as Anthropic.ContentBlockParam[];
+    const redactedBlocks = blocks.filter(
+      (b) => typeof b !== "string" && b.type === "redacted_thinking",
+    );
+    expect(redactedBlocks).toHaveLength(0);
+  });
+
+  test("preserves thinking blocks in active tool-use continuation span", async () => {
+    const messages: Message[] = [
+      userMsg("Read the file"),
+      assistantThinkingToolUseMsg(
+        "I should read the file",
+        "sig-valid-123",
+        "tu-1",
+        "file_read",
+      ),
+      toolResultMsg("tu-1", "file contents here"),
+    ];
+
+    await provider.sendMessage(messages, sampleTools, "system");
+    expect(lastStreamParams).toBeTruthy();
+
+    const sent = lastStreamParams!.messages as Anthropic.MessageParam[];
+    const assistantTurn = sent.find((m) => m.role === "assistant");
+    expect(assistantTurn).toBeTruthy();
+
+    const blocks = assistantTurn!.content as Anthropic.ContentBlockParam[];
+    const thinkingBlocks = blocks.filter(
+      (b) => typeof b !== "string" && b.type === "thinking",
+    );
+    expect(thinkingBlocks).toHaveLength(1);
+    expect((thinkingBlocks[0] as { signature: string }).signature).toBe(
+      "sig-valid-123",
+    );
+  });
+
+  test("strips historical thinking but preserves active continuation in same conversation", async () => {
+    const messages: Message[] = [
+      // Completed historical turn
+      userMsg("What is 2+2?"),
+      assistantThinkingMsg("old thinking", "sig-old-stale", "4"),
+      // Active tool-use continuation
+      userMsg("Now read the file"),
+      assistantThinkingToolUseMsg(
+        "current thinking",
+        "sig-current-valid",
+        "tu-2",
+        "file_read",
+      ),
+      toolResultMsg("tu-2", "file contents"),
+    ];
+
+    await provider.sendMessage(messages, sampleTools, "system");
+    expect(lastStreamParams).toBeTruthy();
+
+    const sent = lastStreamParams!.messages as Anthropic.MessageParam[];
+    const assistantTurns = sent.filter((m) => m.role === "assistant");
+    expect(assistantTurns.length).toBeGreaterThanOrEqual(2);
+
+    // Historical turn: thinking stripped
+    const historicalBlocks = assistantTurns[0]
+      .content as Anthropic.ContentBlockParam[];
+    const historicalThinking = historicalBlocks.filter(
+      (b) => typeof b !== "string" && b.type === "thinking",
+    );
+    expect(historicalThinking).toHaveLength(0);
+
+    // Active turn: thinking preserved
+    const activeBlocks = assistantTurns[1]
+      .content as Anthropic.ContentBlockParam[];
+    const activeThinking = activeBlocks.filter(
+      (b) => typeof b !== "string" && b.type === "thinking",
+    );
+    expect(activeThinking).toHaveLength(1);
+    expect((activeThinking[0] as { signature: string }).signature).toBe(
+      "sig-current-valid",
+    );
+  });
+
+  test("uses placeholder when stripping thinking leaves assistant message empty", async () => {
+    const messages: Message[] = [
+      userMsg("Think about this"),
+      {
+        role: "assistant",
+        content: [{ type: "thinking", thinking: "hmm...", signature: "sig-x" }],
+      },
+      userMsg("What did you conclude?"),
+    ];
+
+    await provider.sendMessage(messages, sampleTools, "system");
+    expect(lastStreamParams).toBeTruthy();
+
+    const sent = lastStreamParams!.messages as Anthropic.MessageParam[];
+    const assistantTurn = sent.find((m) => m.role === "assistant");
+    expect(assistantTurn).toBeTruthy();
+
+    const blocks = assistantTurn!.content as Anthropic.ContentBlockParam[];
+    expect(blocks).toHaveLength(1);
+    expect((blocks[0] as { type: string; text: string }).type).toBe("text");
+    expect(
+      isPlaceholderSentinelText((blocks[0] as { text: string }).text),
+    ).toBe(true);
+  });
+
+  test("multi-step tool-use chain preserves all thinking in the active span", async () => {
+    const messages: Message[] = [
+      // Completed historical turn
+      userMsg("Hello"),
+      assistantThinkingMsg("old thinking", "sig-old", "Hi there"),
+      // Multi-step active tool-use chain
+      userMsg("Do two things"),
+      assistantThinkingToolUseMsg(
+        "step 1 thinking",
+        "sig-step1",
+        "tu-a",
+        "file_read",
+      ),
+      toolResultMsg("tu-a", "result a"),
+      assistantThinkingToolUseMsg(
+        "step 2 thinking",
+        "sig-step2",
+        "tu-b",
+        "file_write",
+      ),
+      toolResultMsg("tu-b", "result b"),
+    ];
+
+    await provider.sendMessage(messages, sampleTools, "system");
+    expect(lastStreamParams).toBeTruthy();
+
+    const sent = lastStreamParams!.messages as Anthropic.MessageParam[];
+
+    // Collect all thinking blocks across all assistant messages
+    const allThinking: Anthropic.ContentBlockParam[] = [];
+    for (const m of sent) {
+      if (m.role !== "assistant") continue;
+      const blocks = m.content as Anthropic.ContentBlockParam[];
+      for (const b of blocks) {
+        if (typeof b !== "string" && b.type === "thinking") {
+          allThinking.push(b);
+        }
+      }
+    }
+
+    // Only the active span's thinking blocks should remain
+    const signatures = allThinking.map(
+      (b) => (b as { signature: string }).signature,
+    );
+    expect(signatures).not.toContain("sig-old");
+    expect(signatures).toContain("sig-step1");
+    expect(signatures).toContain("sig-step2");
+  });
+});

package/src/__tests__/approval-cascade.test.ts

@@ -50,7 +50,7 @@ mock.module("../memory/guardian-action-store.js", () => ({
 
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
-  initializeProviders: () => {},
+  initializeProviders: async () => {},
 }));
 
 mock.module("../config/loader.js", () => ({