@vellumai/assistant 0.8.3 → 0.8.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.8.3",
+  "version": "0.8.4",
   "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";
 
 // ---------------------------------------------------------------------------
@@ -204,6 +206,28 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     expect(lastStreamParams!.thinking).toEqual({ type: "disabled" });
   });
 
+  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 messages = lastStreamParams!.messages as Array<{
+      role: string;
+      content: Array<{ type: string; text?: string; thinking?: string }>;
+    }>;
+    const assistant = messages.find((message) => message.role === "assistant");
+
+    expect(assistant?.content).toEqual([{ type: "text", text: "I can help." }]);
+  });
+
   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.";
@@ -2405,3 +2429,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", () => ({

package/src/__tests__/background-workers-disk-pressure.test.ts

@@ -131,7 +131,6 @@ mock.module("../memory/conversation-crud.js", () => ({
   getConversationSource: () => null,
   getAssistantMessageIdsInTurn: () => [],
   getDisplayMetaForConversations: () => new Map(),
-  getLastAssistantTimestampBefore: () => null,
   getLastUserTimestampBefore: () => null,
   getMessageById: () => null,
   getMessages: () => [],
@@ -156,6 +155,8 @@ mock.module("../memory/conversation-crud.js", () => ({
   updateConversationSlackContextWatermark: mock(() => {}),
   updateConversationTitle: mock(() => {}),
   updateConversationUsage: mock(() => {}),
+  setLastNotifiedInferenceProfile: mock(() => {}),
+  setConversationCleanedAt: mock(() => {}),
   wipeConversation: mock(() => ({ memoryIds: [] })),
 }));