@vellumai/assistant 0.6.4 → 0.6.6

package/src/__tests__/conversation-attachments.test.ts

@@ -32,7 +32,7 @@ const addRuleSpy = mock(() => {});
 
 mock.module("../permissions/checker.js", () => ({
   check: checkSpy,
-  classifyRisk: () => Promise.resolve("low"),
+  classifyRisk: () => Promise.resolve({ level: "low" }),
   generateAllowlistOptions: () => Promise.resolve([]),
   generateScopeOptions: () => [],
 }));

package/src/__tests__/conversation-confirmation-signals.test.ts

@@ -57,15 +57,33 @@ mock.module("../providers/registry.js", () => ({
 mock.module("../config/loader.js", () => ({
   getConfig: () => ({
     ui: {},
-    provider: "mock-provider",
-    maxTokens: 4096,
-    thinking: false,
-    contextWindow: {
-      maxInputTokens: 100000,
-      thresholdTokens: 80000,
-      preserveRecentMessages: 6,
-      summaryModel: "mock-model",
-      maxSummaryTokens: 512,
+    llm: {
+      default: {
+        provider: "mock-provider",
+        model: "mock-model",
+        maxTokens: 4096,
+        effort: "max" as const,
+        speed: "standard" as const,
+        temperature: null,
+        thinking: { enabled: false, streamThinking: true },
+        contextWindow: {
+          enabled: true,
+          maxInputTokens: 100000,
+          targetBudgetRatio: 0.3,
+          compactThreshold: 0.8,
+          summaryBudgetRatio: 0.05,
+          overflowRecovery: {
+            enabled: true,
+            safetyMarginRatio: 0.05,
+            maxAttempts: 3,
+            interactiveLatestTurnCompression: "summarize",
+            nonInteractiveLatestTurnCompression: "truncate",
+          },
+        },
+      },
+      profiles: {},
+      callSites: {},
+      pricingOverrides: [],
     },
     rateLimit: { maxRequestsPerMinute: 0 },
     timeouts: { permissionTimeoutSec: 1 },
@@ -177,12 +195,20 @@ mock.module("../agent/loop.js", () => ({
     getToolTokenBudget() {
       return 0;
     }
+    getResolvedTools() {
+      return [];
+    }
+    getActiveModel() {
+      return undefined;
+    }
     async run(
       _messages: Message[],
       _onEvent: (event: AgentEvent) => void,
       _signal?: AbortSignal,
       _requestId?: string,
-      _onCheckpoint?: (checkpoint: CheckpointInfo) => CheckpointDecision,
+      _onCheckpoint?: (
+        checkpoint: CheckpointInfo,
+      ) => CheckpointDecision | Promise<CheckpointDecision>,
     ): Promise<Message[]> {
       return [];
     }

package/src/__tests__/conversation-error.test.ts

@@ -121,7 +121,7 @@ describe("classifyConversationError", () => {
 
     it("classifies Anthropic overloaded_error (no statusCode) as PROVIDER_OVERLOADED", () => {
       const err = new ProviderError(
-        'Anthropic API error (undefined): {"type":"error","error":{"type":"overloaded_error","message":"Overloaded"}}',
+        'Anthropic API error: {"type":"error","error":{"type":"overloaded_error","message":"Overloaded"}}',
         "anthropic",
       );
       const result = classifyConversationError(err, baseCtx);
@@ -313,6 +313,37 @@ describe("classifyConversationError", () => {
     });
   });
 
+  describe("stale web-search encrypted_content errors", () => {
+    const cases = [
+      "messages.205.content.0: Invalid `encrypted_content` in `search_result` block",
+      "Invalid encrypted_content in search_result block",
+      "Invalid `encrypted_content` in `web_search_result` block",
+    ];
+
+    for (const msg of cases) {
+      it(`classifies "${msg.slice(0, 50)}…" as PROVIDER_WEB_SEARCH / stale_web_search_content`, () => {
+        const result = classifyConversationError(new Error(msg), baseCtx);
+        expect(result.code).toBe("PROVIDER_WEB_SEARCH");
+        expect(result.retryable).toBe(true);
+        expect(result.errorCategory).toBe("stale_web_search_content");
+        expect(result.userMessage).toBe(
+          "Stale web-search results in conversation history. Please try again.",
+        );
+      });
+    }
+
+    it("classifies 400 ProviderError with stale encrypted_content payload", () => {
+      const err = new ProviderError(
+        'Anthropic API error (400): 400 {"error":{"message":"Provider returned error","code":400,"metadata":{"raw":"{\\"type\\":\\"error\\",\\"error\\":{\\"type\\":\\"invalid_request_error\\",\\"message\\":\\"messages.205.content.0: Invalid `encrypted_content` in `search_result` block\\"}}","provider_name":"Anthropic","is_byok":false}}}',
+        "anthropic",
+        400,
+      );
+      const result = classifyConversationError(err, baseCtx);
+      expect(result.code).toBe("PROVIDER_WEB_SEARCH");
+      expect(result.errorCategory).toBe("stale_web_search_content");
+    });
+  });
+
   describe("provider not configured errors", () => {
     it("classifies ProviderNotConfiguredError as PROVIDER_NOT_CONFIGURED", () => {
       const err = new ProviderNotConfiguredError("anthropic", []);
@@ -583,7 +614,7 @@ describe("classifyConversationError", () => {
     for (const kind of taggedKinds) {
       it(`treats ProviderError with abortReason kind="${kind}" as user cancellation`, () => {
         const wrapped = new ProviderError(
-          "Anthropic API error (undefined): Request was aborted.",
+          "Anthropic API error: Request was aborted.",
           "anthropic",
           undefined,
           { abortReason: createAbortReason(kind, `test:${kind}`) },
@@ -594,7 +625,7 @@ describe("classifyConversationError", () => {
 
     it("does NOT treat tagged ProviderError as cancellation when ctx.aborted is false", () => {
       const wrapped = new ProviderError(
-        "Anthropic API error (undefined): Request was aborted.",
+        "Anthropic API error: Request was aborted.",
         "anthropic",
         undefined,
         { abortReason: createAbortReason("user_cancel", "test") },
@@ -605,7 +636,7 @@ describe("classifyConversationError", () => {
 
     it("does NOT treat ProviderError without abortReason as cancellation", () => {
       const wrapped = new ProviderError(
-        "Anthropic API error (undefined): Request was aborted.",
+        "Anthropic API error: Request was aborted.",
         "anthropic",
         undefined,
       );
@@ -614,7 +645,7 @@ describe("classifyConversationError", () => {
 
     it("does NOT treat ProviderError with foreign reason as cancellation", () => {
       const wrapped = new ProviderError(
-        "Anthropic API error (undefined): Request was aborted.",
+        "Anthropic API error: Request was aborted.",
         "anthropic",
         undefined,
         { abortReason: { kind: "user_cancel", source: "spoofed" } },
@@ -624,7 +655,7 @@ describe("classifyConversationError", () => {
 
     it("falls through to CONVERSATION_ABORTED when wrapped ProviderError has no tagged reason", () => {
       const wrapped = new ProviderError(
-        "Anthropic API error (undefined): Request was aborted.",
+        "Anthropic API error: Request was aborted.",
         "anthropic",
         undefined,
       );

package/src/__tests__/conversation-history-web-search.test.ts

@@ -72,6 +72,7 @@ mock.module("../memory/qdrant-client.js", () => ({
   getQdrantClient: () => {
     throw new Error("Qdrant not initialized");
   },
+  resolveQdrantUrl: () => "http://127.0.0.1:6333",
 }));
 
 // Import after mocking
@@ -795,6 +796,12 @@ describe("web_search_tool_result structural guard", () => {
     // image/file blocks. web_search_tool_result has opaque content with no
     // contentBlocks property, so it cannot contain nested media.
     "daemon/context-overflow-reducer.ts",
+
+    // Final orphan-pair safety pass in the Slack transcript renderer.
+    // Server-side block types (`server_tool_use`, `web_search_tool_result`)
+    // are stripped earlier by `buildMessageContentBlocks` and cannot reach
+    // this filter, so only `tool_use` ↔ `tool_result` pairing is relevant.
+    "messaging/providers/slack/render-transcript.ts",
   ]);
 
   /**

package/src/__tests__/conversation-init.benchmark.test.ts

@@ -107,6 +107,24 @@ const mockConfig = {
     summaryBudgetRatio: 0.05,
   },
   thinking: { enabled: false },
+  llm: {
+    default: {
+      provider: "mock",
+      model: "mock-model",
+      speed: "standard",
+      thinking: { enabled: false, streamThinking: false },
+      effort: "medium",
+      contextWindow: {
+        enabled: true,
+        maxInputTokens: 180000,
+        targetBudgetRatio: 0.3,
+        compactThreshold: 0.8,
+        summaryBudgetRatio: 0.05,
+      },
+    },
+    profiles: {},
+    callSites: {},
+  },
 };
 
 mock.module("../config/loader.js", () => ({
@@ -120,6 +138,7 @@ mock.module("../config/loader.js", () => ({
     "perplexity",
   ],
   getConfig: () => mockConfig,
+  getConfigReadOnly: () => mockConfig,
   loadConfig: () => mockConfig,
   saveConfig: () => {},
   invalidateConfigCache: () => {},
@@ -127,6 +146,10 @@ mock.module("../config/loader.js", () => ({
   saveRawConfig: () => {},
   getNestedValue: () => undefined,
   setNestedValue: () => {},
+  applyNestedDefaults: (c: unknown) => c,
+  deepMergeMissing: () => {},
+  deepMergeOverwrite: () => {},
+  mergeDefaultWorkspaceConfig: () => {},
 }));
 
 // Additional mocks required for Conversation constructor and end-to-end tests
@@ -134,6 +157,7 @@ mock.module("../config/loader.js", () => ({
 mock.module("../memory/conversation-crud.js", () => ({
   addMessage: () => ({ id: "msg-1" }),
   getMessages: () => [],
+  hasMessages: () => false,
   getMessageById: () => null,
   getConversation: () => null,
   createConversation: () => ({
@@ -148,6 +172,8 @@ mock.module("../memory/conversation-crud.js", () => ({
   getConversationOriginChannel: () => null,
   getConversationOriginInterface: () => null,
   getConversationType: () => "standard",
+  getConversationSource: () => null,
+  findAnalysisConversationFor: () => null,
   getConversationMemoryScopeId: () => "default",
   getConversationHostAccess: () => false,
   getConversationGroupId: () => null,
@@ -163,6 +189,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   updateConversationTitle: () => {},
   updateConversationUsage: () => {},
   updateMessageContent: () => {},
+  updateMessageContentAndMetadata: () => {},
   batchSetDisplayOrders: () => {},
   getDisplayMetaForConversations: () => [],
   messageMetadataSchema: {
@@ -175,6 +202,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   getTurnTimeBounds: () => null,
   PRIVATE_CONVERSATION_FORK_ERROR: "Cannot fork a private conversation",
   countConversationsByScheduleJobId: () => 0,
+  selectSlackMetaCandidateMetadata: () => [],
   forkConversation: () => null,
   wipeConversation: () => ({
     conversations: 0,
@@ -189,21 +217,20 @@ mock.module("../memory/conversation-crud.js", () => ({
   }),
   getMessagesPaginated: () => ({ messages: [], hasMore: false }),
   getLastAssistantTimestampBefore: () => null,
+  archiveConversation: () => false,
+  unarchiveConversation: () => false,
+  clearStrippedInjectionMetadataForConversation: () => {},
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({
+  buildFtsMatchQuery: () => "",
   countConversations: () => 0,
   listConversations: () => [],
+  listPinnedConversations: () => [],
   getLatestConversation: () => null,
   isLastUserMessageToolResult: () => false,
   searchConversations: () => [],
-}));
-
-mock.module("../hooks/manager.js", () => ({
-  getHookManager: () => ({
-    trigger: () => Promise.resolve(),
-    initialize: () => {},
-  }),
+  buildExcerpt: () => "",
 }));
 
 mock.module("../tools/watch/watch-state.js", () => ({
@@ -258,11 +285,6 @@ mock.module("../calls/call-store.js", () => ({
   finalizeCallbackClaim: () => true,
 }));
 
-mock.module("../daemon/watch-handler.js", () => ({
-  lastCommentaryByConversation: new Map(),
-  lastSummaryByConversation: new Map(),
-}));
-
 mock.module("../tools/browser/browser-screencast.js", () => ({
   registerConversationSender: () => {},
   unregisterConversationSender: () => {},

package/src/__tests__/conversation-lifecycle.test.ts

@@ -0,0 +1,336 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// Stub out heavy dependencies before importing Conversation
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+}));
+
+mock.module("../providers/registry.js", () => ({
+  getProvider: () => ({ name: "mock-provider" }),
+  initializeProviders: () => {},
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    llm: {
+      default: {
+        provider: "mock-provider",
+        model: "mock-model",
+        maxTokens: 4096,
+        effort: "max" as const,
+        speed: "standard" as const,
+        temperature: null,
+        thinking: { enabled: false, streamThinking: true },
+        contextWindow: {
+          enabled: true,
+          maxInputTokens: 100000,
+          targetBudgetRatio: 0.3,
+          compactThreshold: 0.8,
+          summaryBudgetRatio: 0.05,
+          overflowRecovery: {
+            enabled: true,
+            safetyMarginRatio: 0.05,
+            maxAttempts: 3,
+            interactiveLatestTurnCompression: "summarize",
+            nonInteractiveLatestTurnCompression: "truncate",
+          },
+        },
+      },
+      profiles: {},
+      callSites: {},
+      pricingOverrides: [],
+    },
+    rateLimit: { maxRequestsPerMinute: 0 },
+  }),
+  loadRawConfig: () => ({}),
+  saveRawConfig: () => {},
+  invalidateConfigCache: () => {},
+}));
+
+mock.module("../prompts/system-prompt.js", () => ({
+  buildSystemPrompt: () => "system prompt",
+}));
+
+mock.module("../permissions/trust-store.js", () => ({
+  clearCache: () => {},
+}));
+
+mock.module("../security/secret-allowlist.js", () => ({
+  resetAllowlist: () => {},
+}));
+
+// Mutable store so each test can configure its own messages
+let mockDbMessages: Array<{
+  id: string;
+  role: string;
+  content: string;
+  metadata?: string | null;
+}> = [];
+let mockConversation: Record<string, unknown> | null = null;
+let nextMockMessageId = 1;
+
+mock.module("../memory/conversation-crud.js", () => ({
+  getConversationType: () => "default",
+  updateConversationContextWindow: () => {},
+  deleteMessageById: () => {},
+  updateConversationTitle: () => {},
+  updateConversationUsage: () => {},
+  provenanceFromTrustContext: () => ({
+    source: "user",
+    trustContext: undefined,
+  }),
+  getConversationOriginInterface: () => null,
+  getConversationOriginChannel: () => null,
+  getMessages: () => mockDbMessages,
+  getConversation: () => mockConversation,
+  createConversation: () => ({ id: "conv-1" }),
+  addMessage: async (
+    _conversationId: string,
+    role: string,
+    content: string,
+    metadata?: Record<string, unknown>,
+  ) => {
+    const id = `persisted-${nextMockMessageId++}`;
+    mockDbMessages.push({
+      id,
+      role,
+      content,
+      metadata: metadata ? JSON.stringify(metadata) : null,
+    });
+    return { id };
+  },
+  setConversationOriginChannelIfUnset: () => {},
+  setConversationOriginInterfaceIfUnset: () => {},
+}));
+
+mock.module("../memory/conversation-queries.js", () => ({
+  listConversations: () => [],
+}));
+
+import { Conversation } from "../daemon/conversation.js";
+
+function makeConversation(): Conversation {
+  const provider = {
+    name: "mock",
+    sendMessage: async () => ({
+      content: [],
+      model: "mock",
+      usage: { inputTokens: 0, outputTokens: 0 },
+      stopReason: "end_turn",
+    }),
+  };
+  const conv = new Conversation(
+    "conv-1",
+    provider,
+    "system prompt",
+    4096,
+    () => {},
+    "/tmp",
+  );
+  // Default to guardian trust so tests load all messages.
+  conv.setTrustContext({ trustClass: "guardian", sourceChannel: "vellum" });
+  return conv;
+}
+
+function defaultConv() {
+  return {
+    id: "conv-1",
+    contextSummary: null,
+    contextCompactedMessageCount: 0,
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalEstimatedCost: 0,
+  };
+}
+
+describe("loadFromDb metadata injection rehydration", () => {
+  beforeEach(() => {
+    nextMockMessageId = 1;
+  });
+
+  test("memory-only rehydration still works (regression guard)", async () => {
+    mockConversation = defaultConv();
+    mockDbMessages = [
+      {
+        id: "m1",
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "Hi" }]),
+        metadata: JSON.stringify({ memoryInjectedBlock: "remember: alice" }),
+      },
+      {
+        id: "m2",
+        role: "assistant",
+        content: JSON.stringify([{ type: "text", text: "Hello" }]),
+      },
+      // Ensure m1 is historical (not the tail) so memory rehydration triggers
+      // on a non-tail user row. Memory applies to all rows either way, but a
+      // trailing assistant message keeps things concrete.
+    ];
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+    const messages = conversation.getMessages();
+
+    expect(messages).toHaveLength(2);
+    expect(messages[0].role).toBe("user");
+    expect(messages[0].content).toEqual([
+      {
+        type: "text",
+        text: "<memory __injected>\nremember: alice\n</memory>",
+      },
+      { type: "text", text: "Hi" },
+    ]);
+  });
+
+  test("historical user row rehydrates all three injection fields", async () => {
+    mockConversation = defaultConv();
+    mockDbMessages = [
+      {
+        id: "m1",
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "First turn" }]),
+        metadata: JSON.stringify({
+          memoryInjectedBlock: "mem payload",
+          turnContextBlock: "<turn_context>\nctx payload\n</turn_context>",
+          pkbSystemReminderBlock:
+            "<system_reminder>\npkb payload\n</system_reminder>",
+        }),
+      },
+      {
+        id: "m2",
+        role: "assistant",
+        content: JSON.stringify([{ type: "text", text: "Reply" }]),
+      },
+      {
+        id: "m3",
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "Second turn (tail)" }]),
+      },
+    ];
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+    const messages = conversation.getMessages();
+
+    expect(messages).toHaveLength(3);
+    // m1 is historical (not tail) — all three blocks should rehydrate in the
+    // documented shape: [<turn_context>, <memory __injected>, <system_reminder>, ...original]
+    expect(messages[0].role).toBe("user");
+    expect(messages[0].content).toEqual([
+      {
+        type: "text",
+        text: "<turn_context>\nctx payload\n</turn_context>",
+      },
+      {
+        type: "text",
+        text: "<memory __injected>\nmem payload\n</memory>",
+      },
+      {
+        type: "text",
+        text: "<system_reminder>\npkb payload\n</system_reminder>",
+      },
+      { type: "text", text: "First turn" },
+    ]);
+  });
+
+  test("tail user row skips turn_context and system_reminder", async () => {
+    mockConversation = defaultConv();
+    mockDbMessages = [
+      {
+        id: "m1",
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "First" }]),
+      },
+      {
+        id: "m2",
+        role: "assistant",
+        content: JSON.stringify([{ type: "text", text: "Reply" }]),
+      },
+      {
+        id: "m3",
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "Tail turn" }]),
+        metadata: JSON.stringify({
+          memoryInjectedBlock: "mem payload",
+          turnContextBlock: "<turn_context>\nctx\n</turn_context>",
+          pkbSystemReminderBlock: "<system_reminder>\npkb\n</system_reminder>",
+        }),
+      },
+    ];
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+    const messages = conversation.getMessages();
+
+    expect(messages).toHaveLength(3);
+    // Tail row: memory still rehydrates (existing behavior), but turn_context
+    // and system_reminder are skipped — the next turn's applyRuntimeInjections
+    // will supply fresh blocks for the tail.
+    expect(messages[2].role).toBe("user");
+    expect(messages[2].content).toEqual([
+      {
+        type: "text",
+        text: "<memory __injected>\nmem payload\n</memory>",
+      },
+      { type: "text", text: "Tail turn" },
+    ]);
+  });
+
+  test("missing fields are no-op: empty metadata leaves content unchanged", async () => {
+    mockConversation = defaultConv();
+    mockDbMessages = [
+      {
+        id: "m1",
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "First" }]),
+        metadata: JSON.stringify({}),
+      },
+      {
+        id: "m2",
+        role: "assistant",
+        content: JSON.stringify([{ type: "text", text: "Reply" }]),
+      },
+      {
+        id: "m3",
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "Second" }]),
+        metadata: JSON.stringify({ userMessageChannel: "desktop" }),
+      },
+    ];
+
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+    const messages = conversation.getMessages();
+
+    expect(messages).toHaveLength(3);
+    expect(messages[0].content).toEqual([{ type: "text", text: "First" }]);
+    expect(messages[2].content).toEqual([{ type: "text", text: "Second" }]);
+  });
+
+  test("malformed metadata is tolerated: load does not throw, content unchanged", async () => {
+    mockConversation = defaultConv();
+    mockDbMessages = [
+      {
+        id: "m1",
+        role: "user",
+        content: JSON.stringify([{ type: "text", text: "First" }]),
+        metadata: "not-json",
+      },
+      {
+        id: "m2",
+        role: "assistant",
+        content: JSON.stringify([{ type: "text", text: "Reply" }]),
+      },
+    ];
+
+    const conversation = makeConversation();
+    // Should not throw
+    await conversation.loadFromDb();
+    const messages = conversation.getMessages();
+
+    expect(messages).toHaveLength(2);
+    expect(messages[0].content).toEqual([{ type: "text", text: "First" }]);
+  });
+});

package/src/__tests__/conversation-load-history-repair.test.ts

@@ -16,16 +16,33 @@ mock.module("../providers/registry.js", () => ({
 mock.module("../config/loader.js", () => ({
   getConfig: () => ({
     ui: {},
-
-    provider: "mock-provider",
-    maxTokens: 4096,
-    thinking: false,
-    contextWindow: {
-      maxInputTokens: 100000,
-      thresholdTokens: 80000,
-      preserveRecentMessages: 6,
-      summaryModel: "mock-model",
-      maxSummaryTokens: 512,
+    llm: {
+      default: {
+        provider: "mock-provider",
+        model: "mock-model",
+        maxTokens: 4096,
+        effort: "max" as const,
+        speed: "standard" as const,
+        temperature: null,
+        thinking: { enabled: false, streamThinking: true },
+        contextWindow: {
+          enabled: true,
+          maxInputTokens: 100000,
+          targetBudgetRatio: 0.3,
+          compactThreshold: 0.8,
+          summaryBudgetRatio: 0.05,
+          overflowRecovery: {
+            enabled: true,
+            safetyMarginRatio: 0.05,
+            maxAttempts: 3,
+            interactiveLatestTurnCompression: "summarize",
+            nonInteractiveLatestTurnCompression: "truncate",
+          },
+        },
+      },
+      profiles: {},
+      callSites: {},
+      pricingOverrides: [],
     },
     rateLimit: { maxRequestsPerMinute: 0 },
   }),