@vellumai/assistant 0.8.2 → 0.8.4

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: [] })),
 }));
 

package/src/__tests__/channel-delivery-store.test.ts

@@ -7,6 +7,15 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    slack: {
+      teamId: "T123",
+      teamUrl: "https://example.slack.com/",
+    },
+  }),
+}));
+
 import { eq } from "drizzle-orm";
 
 import {
@@ -25,8 +34,11 @@ import {
 import {
   acknowledgeDelivery,
   getDeadLetterEvents,
+  getRetryableDeliveryEvents,
   getRetryableEvents,
+  markDeliveryDelivered,
   markProcessed,
+  recordDeliveryFailure,
   recordProcessingFailure,
   replayDeadLetters,
 } from "../memory/delivery-status.js";
@@ -52,6 +64,7 @@ function resetTables() {
   db.run("DELETE FROM channel_inbound_events");
   db.run("DELETE FROM messages");
   db.run("DELETE FROM conversation_keys");
+  db.run("DELETE FROM external_conversation_bindings");
   db.run("DELETE FROM conversations");
 }
 
@@ -421,6 +434,7 @@ describe("channel-delivery-store", () => {
       conversationId: result.conversationId,
       sourceChannel: "slack",
       externalChatId: "C0123ABCDEF",
+      externalChatName: "engineering",
       externalThreadId: "1710000000.000100",
     });
 
@@ -429,12 +443,105 @@ describe("channel-delivery-store", () => {
     expect(detail?.conversation.channelBinding).toMatchObject({
       sourceChannel: "slack",
       externalChatId: "C0123ABCDEF",
+      externalChatName: "engineering",
       externalThreadId: "1710000000.000100",
       slackThread: {
         channelId: "C0123ABCDEF",
         threadTs: "1710000000.000100",
+        link: {
+          appUrl:
+            "slack://channel?team=T123&id=C0123ABCDEF&message=1710000000.000100",
+          webUrl:
+            "https://example.slack.com/archives/C0123ABCDEF/p1710000000000100",
+        },
       },
+      slackChannel: {
+        channelId: "C0123ABCDEF",
+        name: "engineering",
+        link: {
+          webUrl: "https://example.slack.com/archives/C0123ABCDEF",
+        },
+      },
+    });
+  });
+
+  test("conversation detail exposes Slack channel id fallback without stored channel name", () => {
+    const result = recordInbound("slack", "C0123ABCDEF", "msg-1", {
+      sourceThreadId: "1710000000.000100",
+    });
+
+    upsertBinding({
+      conversationId: result.conversationId,
+      sourceChannel: "slack",
+      externalChatId: "C0123ABCDEF",
+      externalThreadId: "1710000000.000100",
+    });
+
+    const detail = buildConversationDetailResponse(result.conversationId);
+
+    expect(detail?.conversation.channelBinding).toMatchObject({
+      sourceChannel: "slack",
+      externalChatId: "C0123ABCDEF",
+      externalChatName: "C0123ABCDEF",
+      slackChannel: {
+        channelId: "C0123ABCDEF",
+        name: "C0123ABCDEF",
+        link: {
+          webUrl: "https://example.slack.com/archives/C0123ABCDEF",
+        },
+      },
+    });
+  });
+
+  test("binding upsert preserves existing chat name when incoming name is missing", () => {
+    const result = recordInbound("slack", "C0123ABCDEF", "msg-1", {
+      sourceThreadId: "1710000000.000100",
+    });
+
+    upsertBinding({
+      conversationId: result.conversationId,
+      sourceChannel: "slack",
+      externalChatId: "C0123ABCDEF",
+      externalChatName: "engineering",
+      externalThreadId: "1710000000.000100",
     });
+    upsertBinding({
+      conversationId: result.conversationId,
+      sourceChannel: "slack",
+      externalChatId: "C0123ABCDEF",
+      externalThreadId: "1710000000.000100",
+    });
+
+    expect(
+      getBindingByChannelChatThread("slack", "C0123ABCDEF", "1710000000.000100")
+        ?.externalChatName,
+    ).toBe("engineering");
+  });
+
+  test("binding upsert preserves existing chat name when incoming name is blank", () => {
+    const result = recordInbound("slack", "C0123ABCDEF", "msg-1", {
+      sourceThreadId: "1710000000.000100",
+    });
+
+    upsertBinding({
+      conversationId: result.conversationId,
+      sourceChannel: "slack",
+      externalChatId: "C0123ABCDEF",
+      externalChatName: "engineering",
+      externalThreadId: "1710000000.000100",
+    });
+    upsertBinding({
+      conversationId: result.conversationId,
+      sourceChannel: "slack",
+      externalChatId: "C0123ABCDEF",
+      externalChatName: "   ",
+      externalThreadId: "1710000000.000100",
+    });
+
+    expect(
+      getBindingByChannelChatThread("slack", "C0123ABCDEF", "1710000000.000100")
+        ?.externalChatName,
+    ).toBe("engineering");
   });
 
   // ── Deduplication ─────────────────────────────────────────────────
@@ -506,11 +613,97 @@ describe("channel-delivery-store", () => {
     expect(row!.deliveryStatus).toBe("delivered");
   });
 
+  test("acknowledgeDelivery accepts late acks after retryable delivery failure", () => {
+    const result = recordInbound("telegram", "chat-1", "msg-1");
+    markProcessed(result.eventId);
+    recordDeliveryFailure(result.eventId, new Error("fetch failed"));
+
+    const ack = acknowledgeDelivery("telegram", "chat-1", "msg-1");
+    expect(ack).toBe(true);
+
+    const db = getDb();
+    const row = db
+      .select()
+      .from(channelInboundEvents)
+      .where(eq(channelInboundEvents.id, result.eventId))
+      .get();
+    expect(row!.deliveryStatus).toBe("delivered");
+    expect(row!.retryAfter).toBeNull();
+  });
+
   test("acknowledgeDelivery returns false for unknown event", () => {
     const ack = acknowledgeDelivery("telegram", "chat-1", "nonexistent");
     expect(ack).toBe(false);
   });
 
+  test("delivery failures are retryable without changing processing status", () => {
+    const result = recordInbound("telegram", "chat-1", "msg-1");
+    markProcessed(result.eventId);
+
+    recordDeliveryFailure(result.eventId, new Error("fetch failed"));
+
+    const db = getDb();
+    let row = db
+      .select()
+      .from(channelInboundEvents)
+      .where(eq(channelInboundEvents.id, result.eventId))
+      .get();
+    expect(row!.processingStatus).toBe("processed");
+    expect(row!.deliveryStatus).toBe("failed");
+    expect(row!.processingAttempts).toBe(0);
+    expect(row!.deliveryAttempts).toBe(1);
+    expect(row!.lastProcessingError).toBe("fetch failed");
+    expect(row!.retryAfter).toBeGreaterThan(0);
+
+    db.update(channelInboundEvents)
+      .set({ retryAfter: Date.now() - 10_000, deliveredSegmentCount: 2 })
+      .where(eq(channelInboundEvents.id, result.eventId))
+      .run();
+
+    const retryable = getRetryableDeliveryEvents();
+    expect(retryable).toHaveLength(1);
+    expect(retryable[0].id).toBe(result.eventId);
+    expect(retryable[0].deliveredSegmentCount).toBe(2);
+
+    markDeliveryDelivered(result.eventId);
+
+    row = db
+      .select()
+      .from(channelInboundEvents)
+      .where(eq(channelInboundEvents.id, result.eventId))
+      .get();
+    expect(row!.processingStatus).toBe("processed");
+    expect(row!.deliveryStatus).toBe("delivered");
+    expect(row!.retryAfter).toBeNull();
+    expect(getRetryableDeliveryEvents()).toHaveLength(0);
+  });
+
+  test("delivery dead letters are listed and replayed as delivery retries", () => {
+    const result = recordInbound("telegram", "chat-1", "msg-1");
+    markProcessed(result.eventId);
+
+    recordDeliveryFailure(result.eventId, { status: 400, message: "bad" });
+
+    const deadLetters = getDeadLetterEvents();
+    expect(deadLetters).toHaveLength(1);
+    expect(deadLetters[0].id).toBe(result.eventId);
+
+    const count = replayDeadLetters([result.eventId]);
+    expect(count).toBe(1);
+
+    const db = getDb();
+    const row = db
+      .select()
+      .from(channelInboundEvents)
+      .where(eq(channelInboundEvents.id, result.eventId))
+      .get();
+    expect(row!.processingStatus).toBe("processed");
+    expect(row!.deliveryStatus).toBe("failed");
+    expect(row!.deliveryAttempts).toBe(0);
+    expect(row!.lastProcessingError).toBeNull();
+    expect(row!.retryAfter).toBeGreaterThan(0);
+  });
+
   // ── Processing status transitions ─────────────────────────────────
 
   test("markProcessed sets processingStatus to processed", () => {