@vellumai/assistant 0.8.7 → 0.8.8

package/src/__tests__/conversation-analysis-routes.test.ts

@@ -54,6 +54,12 @@ function makeConversation() {
     setSubagentAllowedTools: mock(() => {}),
     updateClient: mock(() => {}),
     processing: false,
+    isProcessing(this: { processing: boolean }) {
+      return this.processing;
+    },
+    setProcessing(this: { processing: boolean }, value: boolean) {
+      this.processing = value;
+    },
     abortController: null as AbortController | null,
     currentRequestId: null as string | null,
     runAgentLoop: mock(() => Promise.resolve()),

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

@@ -441,6 +441,7 @@ describe("regenerate with web_search_tool_result", () => {
 
     const events: Array<{ type: string; message?: string }> = [];
 
+    let processing = false;
     const session: HistoryConversationContext = {
       conversationId,
       traceEmitter: {
@@ -448,7 +449,10 @@ describe("regenerate with web_search_tool_result", () => {
       } as unknown as HistoryConversationContext["traceEmitter"],
       sendToClient: (msg) => events.push(msg),
       messages: [...inMemoryMessages],
-      processing: false,
+      isProcessing: () => processing,
+      setProcessing: (value: boolean) => {
+        processing = value;
+      },
       abortController: null,
       async runAgentLoop(content, userMessageId) {
         agentLoopCalled = true;
@@ -778,6 +782,12 @@ describe("web_search_tool_result structural guard", () => {
     // provider, not the local tool executor, so they never flow here.
     "agent/loop.ts",
 
+    // Counts consecutive errors for locally-executed tools to bound retry
+    // coaching. Server-side web search results (web_search_tool_result) carry
+    // no is_error flag and are not produced by the tool executor, so only
+    // tool_result is relevant. Same reasoning as agent/loop.ts above.
+    "plugins/defaults/tool-error/hooks/post-tool-use.ts",
+
     // Reconciles synthesized cancellation tool_results for locally-executed
     // tools only. Same reasoning as agent/loop.ts above.
     "daemon/conversation-agent-loop.ts",

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

@@ -103,7 +103,6 @@ import type {
   NotificationChannel,
   RenderedChannelCopy,
 } from "../notifications/types.js";
-import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 
 // ── Test helpers ────────────────────────────────────────────────────────
 
@@ -155,10 +154,6 @@ describe("pairDeliveryWithConversation", () => {
     addMessageShouldThrow = false;
     mockExistingConversations = {};
     mockBindings = {};
-    // The passive-suppression gate requires the home-page flag; default it on
-    // so the existing creation/suppression expectations hold. The dedicated
-    // flag-off test below overrides this to assert the create fallback.
-    setOverridesForTesting({ "home-page": true });
   });
 
   // ── start_new_conversation (vellum) ─────────────────────────────────
@@ -849,30 +844,7 @@ describe("pairDeliveryWithConversation", () => {
     expect(addMessageMock).not.toHaveBeenCalled();
   });
 
-  test("passive vellum signal creates a conversation when home-page flag is off", async () => {
-    // Without the home feed there is no surface for passive notifications, so
-    // the suppression is gated off and pairing falls back to creating a
-    // conversation (the pre-home-feed behavior).
-    setOverridesForTesting({ "home-page": false });
-    const signal = makeSignal({ requiresConversation: undefined });
-    const copy = makeCopy();
-
-    const result = await pairDeliveryWithConversation(
-      signal,
-      "vellum" as NotificationChannel,
-      copy,
-    );
-
-    expect(result.conversationId).toBe("conv-001");
-    expect(result.messageId).toBe("msg-001");
-    expect(result.strategy).toBe("start_new_conversation");
-    expect(result.createdNewConversation).toBe(true);
-    expect(result.conversationFallbackUsed).toBe(false);
-    expect(createConversationMock).toHaveBeenCalledTimes(1);
-    expect(addMessageMock).toHaveBeenCalledTimes(1);
-  });
-
-  test("passive vellum signal still honors explicit reuse_existing action", async () => {
+  test("passive vellum signal suppresses even when decision engine says reuse_existing", async () => {
     mockExistingConversations["conv-explicit-passive"] = {
       id: "conv-explicit-passive",
       source: "notification",
@@ -892,10 +864,11 @@ describe("pairDeliveryWithConversation", () => {
       { conversationAction },
     );
 
-    expect(result.conversationId).toBe("conv-explicit-passive");
+    expect(result.conversationId).toBeNull();
+    expect(result.messageId).toBeNull();
     expect(result.createdNewConversation).toBe(false);
     expect(createConversationMock).not.toHaveBeenCalled();
-    expect(addMessageMock).toHaveBeenCalledTimes(1);
+    expect(addMessageMock).not.toHaveBeenCalled();
   });
 
   // ── conversationMetadata.conversationType override ─────────────────

package/src/__tests__/conversation-process-app-control-preactivation.test.ts

@@ -120,6 +120,12 @@ function makeFakeContext(opts: {
     conversationId: "conv-app-control-preactivation",
     messages: [],
     processing: false,
+    isProcessing(this: { processing: boolean }) {
+      return this.processing;
+    },
+    setProcessing(this: { processing: boolean }, value: boolean) {
+      this.processing = value;
+    },
     abortController: null,
     queue: opts.queue,
     traceEmitter: new TraceEmitter("conv-app-control-preactivation", () => {}),

package/src/__tests__/conversation-provider-retry-repair.test.ts

@@ -84,11 +84,15 @@ mock.module("../config/loader.js", () => ({
 
 // Token estimator: return a small value (well within budget) so preflight
 // does not trigger in existing tests. Stub both the calibrated and raw
-// entry points — the latter backs the default `tokenEstimate` plugin
-// pipeline now used by the orchestrator's preflight / mid-loop checkpoints.
+// entry points — the calibrated estimate backs the orchestrator's preflight /
+// mid-loop overflow checkpoints, and the raw estimate backs the pre-send
+// calibration capture.
 mock.module("../context/token-estimator.js", () => ({
   estimatePromptTokens: () => 1000,
   estimatePromptTokensRaw: () => 1000,
+  // The preflight overflow gate calls this calibrated wrapper directly; stub
+  // it alongside the others so it returns the same small value.
+  estimatePromptTokensWithTools: () => 1000,
   estimateToolsTokens: () => 0,
 }));
 
@@ -333,7 +337,13 @@ mock.module("../agent/loop.js", () => ({
             { type: "tool_result", tool_use_id: "tu-1", content: "hi" },
           ],
         } as Message);
-        return { history, exitReason: null }; // Progress was made — history grew
+        // Progress was made — history grew
+        return {
+          history,
+          exitReason: null,
+          appendedNewMessages: true,
+          newMessages: history.slice(messages.length),
+        };
       }
 
       // Context-too-large modes: keep failing when compaction can't help
@@ -375,7 +385,13 @@ mock.module("../agent/loop.js", () => ({
           );
         })();
         onEvent({ type: "error", error });
-        return { history: [...messages], exitReason: null }; // Return unchanged — no progress
+        // Return unchanged — no progress
+        return {
+          history: [...messages],
+          exitReason: null,
+          appendedNewMessages: false,
+          newMessages: [],
+        };
       }
 
       // Second call (retry) or non-error: succeed normally
@@ -393,7 +409,12 @@ mock.module("../agent/loop.js", () => ({
       };
       history.push(assistantMsg);
       onEvent({ type: "message_complete", message: assistantMsg });
-      return { history, exitReason: null };
+      return {
+        history,
+        exitReason: null,
+        appendedNewMessages: true,
+        newMessages: history.slice(messages.length),
+      };
     }
   },
 }));

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

@@ -368,6 +368,8 @@ mock.module("../agent/loop.js", () => ({
             resolveResult({
               history,
               exitReason: pending.exitReason,
+              appendedNewMessages: history.length > messages.length,
+              newMessages: history.slice(messages.length),
             }),
           reject,
           messages,

package/src/__tests__/conversation-routes-disk-view.test.ts

@@ -153,6 +153,9 @@ function createFakeConversation(conversationId: string): Conversation {
     isProcessing(this: { processing: boolean }) {
       return this.processing;
     },
+    setProcessing(this: { processing: boolean }, value: boolean) {
+      this.processing = value;
+    },
     setChannelCapabilities: () => {},
     setAssistantId: () => {},
     setTrustContext(this: { trustContext: unknown }, ctx: unknown) {

package/src/__tests__/conversation-routes-slash-commands.test.ts

@@ -260,10 +260,10 @@ function makeConversation() {
   }));
   const events: unknown[] = [];
   const messages: unknown[] = [];
+  let processing = false;
   const conversation = {
     conversationId: "conv-slash-test",
     messages,
-    processing: false,
     abortController: null,
     currentRequestId: undefined,
     queue: { length: 0 },
@@ -276,7 +276,10 @@ function makeConversation() {
     getTurnChannelContext: () => null,
     getTurnInterfaceContext: () => null,
     ensureActorScopedHistory: async () => {},
-    isProcessing: () => false,
+    isProcessing: () => processing,
+    setProcessing: (value: boolean) => {
+      processing = value;
+    },
     hasAnyPendingConfirmation: () => false,
     denyAllPendingConfirmations: () => {},
     enqueueMessage: () => ({ queued: true, requestId: "queued-id" }),
@@ -430,9 +433,7 @@ describe("handleSendMessage slash command interception", () => {
 
     // Regression: without the guard `processing` stays stuck true, leaving
     // every later send queued forever; the queue must also be drained.
-    expect(
-      (conversation as unknown as { processing: boolean }).processing,
-    ).toBe(false);
+    expect(conversation.isProcessing()).toBe(false);
     expect(drainQueue).toHaveBeenCalledTimes(1);
   });