@vellumai/assistant 0.8.6 → 0.8.7-dev.202606052118.34cd356

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

@@ -345,9 +345,9 @@ describe("End-to-end session creation benchmark", () => {
       "bench-warmup-0",
       mockProvider,
       systemPrompt,
-      64000,
       noop,
       testDir,
+      { maxTokens: 64000 },
     );
     await warmup.loadFromDb();
     warmup.dispose();
@@ -360,9 +360,9 @@ describe("End-to-end session creation benchmark", () => {
         id,
         mockProvider,
         systemPrompt,
-        64000,
         noop,
         testDir,
+        { maxTokens: 64000 },
       );
       await session.loadFromDb();
       timings.push(performance.now() - start);
@@ -388,9 +388,9 @@ describe("End-to-end session creation benchmark", () => {
       "bench-warmup-s",
       mockProvider,
       systemPrompt,
-      64000,
       noop,
       testDir,
+      { maxTokens: 64000 },
     );
     warmup.preactivatedSkillIds = testSkillIds;
     await warmup.loadFromDb();
@@ -410,9 +410,9 @@ describe("End-to-end session creation benchmark", () => {
         id,
         mockProvider,
         systemPrompt,
-        64000,
         noop,
         testDir,
+        { maxTokens: 64000 },
       );
       session.preactivatedSkillIds = testSkillIds;
       await session.loadFromDb();
@@ -446,9 +446,9 @@ describe("End-to-end session creation benchmark", () => {
       "bench-events-w",
       mockProvider,
       systemPrompt,
-      64000,
       noop,
       testDir,
+      { maxTokens: 64000 },
     );
     warmup.dispose();
 
@@ -459,9 +459,9 @@ describe("End-to-end session creation benchmark", () => {
         `bench-events-${i}`,
         mockProvider,
         systemPrompt,
-        64000,
         noop,
         testDir,
+        { maxTokens: 64000 },
       );
       timings.push(performance.now() - start);
 

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

@@ -89,8 +89,9 @@ mock.module("../memory/conversation-crud.js", () => ({
     _conversationId: string,
     role: string,
     content: string,
-    metadata?: Record<string, unknown>,
+    options?: { metadata?: Record<string, unknown> },
   ) => {
+    const metadata = options?.metadata;
     const id = `persisted-${nextMockMessageId++}`;
     mockDbMessages.push({
       id,
@@ -125,9 +126,9 @@ function makeConversation(): Conversation {
     "conv-1",
     provider,
     "system prompt",
-    4096,
     () => {},
     "/tmp",
+    { maxTokens: 4096 },
   );
   // Default to guardian trust so tests load all messages.
   conv.setTrustContext({ trustClass: "guardian", sourceChannel: "vellum" });

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

@@ -91,8 +91,9 @@ mock.module("../memory/conversation-crud.js", () => ({
     _conversationId: string,
     role: string,
     content: string,
-    metadata?: Record<string, unknown>,
+    options?: { metadata?: Record<string, unknown> },
   ) => {
+    const metadata = options?.metadata;
     const id = `persisted-${nextMockMessageId++}`;
     mockDbMessages.push({
       id,
@@ -127,9 +128,9 @@ function makeConversation(): Conversation {
     "conv-1",
     provider,
     "system prompt",
-    4096,
     () => {},
     "/tmp",
+    { maxTokens: 4096 },
   );
   // Default to guardian trust so history repair tests load all messages.
   // Tests that exercise untrusted-actor filtering override this explicitly.

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

@@ -110,9 +110,9 @@ function makeConversation(): Conversation {
     "conv-1",
     provider,
     "system prompt",
-    4096,
     () => {},
     "/tmp",
+    { maxTokens: 4096 },
   );
   conv.setTrustContext({ trustClass: "guardian", sourceChannel: "vellum" });
   return conv;

package/src/__tests__/conversation-message-sync-tags.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, test } from "bun:test";
 
 import {
   conversationMessagesSyncTag,
-  type SyncChangedMessage,
+  type SyncChangedEvent,
 } from "../daemon/message-types/sync.js";
 import type { AssistantEvent } from "../runtime/assistant-event.js";
 import {
@@ -34,12 +34,11 @@ async function captureEvents(
   }
 }
 
-function syncMessages(events: AssistantEvent[]): SyncChangedMessage[] {
+function syncMessages(events: AssistantEvent[]): SyncChangedEvent[] {
   return events
     .map((event) => event.message)
     .filter(
-      (message): message is SyncChangedMessage =>
-        message.type === "sync_changed",
+      (message): message is SyncChangedEvent => message.type === "sync_changed",
     );
 }
 

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

@@ -39,8 +39,7 @@ const addMessageMock = mock(
     _conversationId: string,
     _role: string,
     _content: string,
-    _metadata?: unknown,
-    _opts?: unknown,
+    _options?: unknown,
   ) => {
     if (addMessageShouldThrow) throw new Error("DB write failed");
     return { id: mockMessageId };
@@ -292,8 +291,11 @@ describe("pairDeliveryWithConversation", () => {
       copy,
     );
 
-    const optsArg = addMessageMock.mock.calls[0]![4] as Record<string, unknown>;
-    expect(optsArg.skipIndexing).toBe(true);
+    const optionsArg = addMessageMock.mock.calls[0]![3] as Record<
+      string,
+      unknown
+    >;
+    expect(optionsArg.skipIndexing).toBe(true);
   });
 
   // ── continue_existing_conversation (telegram) ─────────────────────
@@ -842,7 +844,7 @@ describe("pairDeliveryWithConversation", () => {
     expect(addMessageMock).not.toHaveBeenCalled();
   });
 
-  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",
@@ -862,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-pre-run-repair.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 
-import { repairHistory } from "../daemon/history-repair.js";
+import { repairHistory } from "../plugins/defaults/history-repair/terminal.js";
 import type { Message } from "../providers/types.js";
 
 describe("pre-run history repair", () => {

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", () => {}),
@@ -164,6 +170,10 @@ function makeFakeContext(opts: {
         compactedMessages: 0,
       } as never;
     },
+    trustContext: {
+      trustClass: "guardian" as const,
+      guardianPrincipalId: "user-1",
+    },
     setTransportHints() {},
     applyHostEnvFromTransport() {},
     ensureHostProxiesForTurn() {},

package/src/__tests__/conversation-process-callsite.test.ts

@@ -4,14 +4,15 @@
  * user-initiated turns default to `'mainAgent'` when no caller-supplied
  * `callSite` is set.
  *
- * The test mocks `AgentLoop.run()` so it can capture the `callSite` parameter
- * the conversation passes after `processMessage` runs the slash-resolver and
- * runtime-injection pipeline. Adapter callers (heartbeat, filing, scheduler)
- * pass an explicit `callSite` so `RetryProvider` resolves their per-call
- * config from `llm.callSites.<id>`.
+ * The test mocks `AgentLoop.run()` so it can capture the `callSite` option
+ * the conversation passes via `AgentLoopRunOptions` after `processMessage`
+ * runs the slash-resolver and runtime-injection pipeline. Adapter callers
+ * (heartbeat, filing, scheduler) pass an explicit `callSite` so
+ * `RetryProvider` resolves their per-call config from `llm.callSites.<id>`.
  */
 import { describe, expect, mock, test } from "bun:test";
 
+import { CompactionCircuit } from "../agent/compaction-circuit.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
 
 // Use an object wrapper so TypeScript doesn't narrow the captured type to
@@ -202,21 +203,21 @@ mock.module("../memory/retriever.js", () => ({
   injectMemoryRecallAsUserBlock: (msgs: Message[]) => msgs,
 }));
 
-// Mock AgentLoop to capture the callSite argument that runAgentLoopImpl passes.
-// The 6th positional parameter is `callSite` (see assistant/src/agent/loop.ts).
+// Mock AgentLoop to capture the callSite argument that runAgentLoopImpl passes
+// via the options object (see assistant/src/agent/loop.ts → AgentLoopConstructorOptions).
 mock.module("../agent/loop.js", () => ({
   AgentLoop: class {
+    compactionCircuit = new CompactionCircuit("test-conv");
     constructor(
       _provider: unknown,
       _systemPrompt: string,
-      config?: Record<string, unknown>,
-      _tools?: unknown,
-      _toolExecutor?: unknown,
-      _resolveTools?: unknown,
-      resolveSystemPrompt?: (history: Message[]) => Record<string, unknown>,
+      options?: {
+        config?: Record<string, unknown>;
+        resolveSystemPrompt?: (history: Message[]) => Record<string, unknown>;
+      },
     ) {
-      captured.constructorMaxTokens = config?.maxTokens;
-      const resolved = resolveSystemPrompt?.([]);
+      captured.constructorMaxTokens = options?.config?.maxTokens;
+      const resolved = options?.resolveSystemPrompt?.([]);
       captured.resolvedMaxTokens = resolved?.maxTokens;
       captured.resolvedHasMaxTokens =
         resolved !== undefined &&
@@ -231,12 +232,9 @@ mock.module("../agent/loop.js", () => ({
     async run(
       messages: Message[],
       onEvent: (event: Record<string, unknown>) => void,
-      _signal?: AbortSignal,
-      _requestId?: string,
-      _onCheckpoint?: unknown,
-      callSite?: string,
+      options?: { callSite?: string },
     ): Promise<Message[]> {
-      captured.callSite = callSite;
+      captured.callSite = options?.callSite;
       onEvent({
         type: "usage",
         inputTokens: 0,
@@ -311,9 +309,9 @@ function makeConversation(): Conversation {
     "conv-1",
     provider,
     "system prompt",
-    4096,
     () => {},
     "/tmp",
+    { maxTokens: 4096 },
   );
 }
 
@@ -333,15 +331,11 @@ describe("processMessage callSite threading", () => {
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
-    await conversation.processMessage(
-      "Heartbeat tick",
-      [],
-      () => {},
-      undefined, // requestId
-      undefined, // activeSurfaceId
-      undefined, // currentPage
-      { callSite: "heartbeatAgent" },
-    );
+    await conversation.processMessage({
+      content: "Heartbeat tick",
+      attachments: [],
+      callSite: "heartbeatAgent",
+    });
 
     expect(captured.callSite).toBe("heartbeatAgent");
   });
@@ -361,7 +355,10 @@ describe("processMessage callSite threading", () => {
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
-    await conversation.processMessage("Plain user message", [], () => {});
+    await conversation.processMessage({
+      content: "Plain user message",
+      attachments: [],
+    });
 
     expect(captured.callSite).toBe("mainAgent");
   });

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

@@ -1,6 +1,7 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import type { AgentEvent } from "../agent/loop.js";
+import { CompactionCircuit } from "../agent/compaction-circuit.js";
+import type { AgentEvent, AgentLoopRunResult } from "../agent/loop.js";
 import type { UserMessageAttachment } from "../daemon/message-protocol.js";
 import { resetPluginRegistryAndRegisterDefaults } from "../plugins/defaults/index.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
@@ -83,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,
 }));
 
@@ -264,6 +269,7 @@ let firstRunErrorMode:
 
 mock.module("../agent/loop.js", () => ({
   AgentLoop: class {
+    compactionCircuit = new CompactionCircuit("test-conv");
     constructor() {}
     getToolTokenBudget() {
       return 0;
@@ -277,8 +283,7 @@ mock.module("../agent/loop.js", () => ({
     async run(
       messages: Message[],
       onEvent: (event: AgentEvent) => void,
-      _signal?: AbortSignal,
-    ): Promise<Message[]> {
+    ): Promise<AgentLoopRunResult> {
       // Prime the assistant row anchor — production code emits this from
       // `AgentLoop.run` just before `provider.sendMessage`.
       await onEvent({ type: "llm_call_started" });
@@ -332,7 +337,13 @@ mock.module("../agent/loop.js", () => ({
             { type: "tool_result", tool_use_id: "tu-1", content: "hi" },
           ],
         } as Message);
-        return history; // 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
@@ -374,7 +385,13 @@ mock.module("../agent/loop.js", () => ({
           );
         })();
         onEvent({ type: "error", error });
-        return [...messages]; // Return unchanged — no progress
+        // Return unchanged — no progress
+        return {
+          history: [...messages],
+          exitReason: null,
+          appendedNewMessages: false,
+          newMessages: [],
+        };
       }
 
       // Second call (retry) or non-error: succeed normally
@@ -392,7 +409,12 @@ mock.module("../agent/loop.js", () => ({
       };
       history.push(assistantMsg);
       onEvent({ type: "message_complete", message: assistantMsg });
-      return history;
+      return {
+        history,
+        exitReason: null,
+        appendedNewMessages: true,
+        newMessages: history.slice(messages.length),
+      };
     }
   },
 }));
@@ -441,9 +463,9 @@ function makeConversation(): Conversation {
     "conv-1",
     provider,
     "system prompt",
-    4096,
     () => {},
     "/tmp",
+    { maxTokens: 4096 },
   );
 }
 
@@ -464,11 +486,10 @@ describe("provider ordering error retry", () => {
     firstRunErrorMode = "ordering";
     maybeCompactCalls = [];
     forceCompactionEnabled = false;
-    // Orchestrator pipelines (`overflowReduce`, `persistence`, …) run through
-    // the plugin registry; re-register every default so each pipeline has a
-    // middleware to dispatch to. The `context-overflow-reducer` module itself
-    // (and other collaborators) are mocked above, so the default plugins'
-    // delegates go through the mocked implementations.
+    // The compaction pipeline runs through the plugin registry; re-register
+    // every default so it has a middleware to dispatch to. Collaborators are
+    // mocked above, so the default plugins' delegates go through the mocked
+    // implementations.
     resetPluginRegistryAndRegisterDefaults();
   });
 
@@ -479,9 +500,11 @@ describe("provider ordering error retry", () => {
     await conversation.loadFromDb();
 
     const events: Array<Record<string, unknown>> = [];
-    await conversation.processMessage("Hello", [], (msg) =>
-      events.push(msg as unknown as Record<string, unknown>),
-    );
+    await conversation.processMessage({
+      content: "Hello",
+      attachments: [],
+      onEvent: (msg) => events.push(msg as unknown as Record<string, unknown>),
+    });
 
     // Should have been called exactly 2 times: original + one retry
     expect(agentLoopRunCount).toBe(2);
@@ -494,9 +517,11 @@ describe("provider ordering error retry", () => {
     await conversation.loadFromDb();
 
     const events: Array<Record<string, unknown>> = [];
-    await conversation.processMessage("Hello", [], (msg) =>
-      events.push(msg as unknown as Record<string, unknown>),
-    );
+    await conversation.processMessage({
+      content: "Hello",
+      attachments: [],
+      onEvent: (msg) => events.push(msg as unknown as Record<string, unknown>),
+    });
 
     // Should have a message_complete event (from successful retry)
     const messageComplete = events.find((e) => e.type === "message_complete");
@@ -519,9 +544,11 @@ describe("provider ordering error retry", () => {
     await conversation.loadFromDb();
 
     const events: Array<Record<string, unknown>> = [];
-    await conversation.processMessage("Hello", [], (msg) =>
-      events.push(msg as unknown as Record<string, unknown>),
-    );
+    await conversation.processMessage({
+      content: "Hello",
+      attachments: [],
+      onEvent: (msg) => events.push(msg as unknown as Record<string, unknown>),
+    });
 
     // Should have been called exactly 1 time (no retry for non-ordering errors)
     expect(agentLoopRunCount).toBe(1);
@@ -535,11 +562,11 @@ describe("provider ordering error retry", () => {
     await conversation.loadFromDb();
 
     const events: Array<Record<string, unknown>> = [];
-    await conversation.processMessage(
-      "Please compare these images.",
-      makeImageAttachments(8),
-      (msg) => events.push(msg as unknown as Record<string, unknown>),
-    );
+    await conversation.processMessage({
+      content: "Please compare these images.",
+      attachments: makeImageAttachments(8),
+      onEvent: (msg) => events.push(msg as unknown as Record<string, unknown>),
+    });
 
     expect(agentLoopRunCount).toBe(2);
     expect(maybeCompactCalls).toEqual([{ force: false }, { force: true }]);
@@ -555,11 +582,11 @@ describe("provider ordering error retry", () => {
     await conversation.loadFromDb();
 
     const events: Array<Record<string, unknown>> = [];
-    await conversation.processMessage(
-      "Please compare these images.",
-      makeImageAttachments(8),
-      (msg) => events.push(msg as unknown as Record<string, unknown>),
-    );
+    await conversation.processMessage({
+      content: "Please compare these images.",
+      attachments: makeImageAttachments(8),
+      onEvent: (msg) => events.push(msg as unknown as Record<string, unknown>),
+    });
 
     // The convergence loop enters and applies the reducer (which returns
     // exhausted:true). With the early-break removed, the loop still re-runs
@@ -582,9 +609,11 @@ describe("provider ordering error retry", () => {
     await conversation.loadFromDb();
 
     const events: Array<Record<string, unknown>> = [];
-    await conversation.processMessage("No attachments here.", [], (msg) =>
-      events.push(msg as unknown as Record<string, unknown>),
-    );
+    await conversation.processMessage({
+      content: "No attachments here.",
+      attachments: [],
+      onEvent: (msg) => events.push(msg as unknown as Record<string, unknown>),
+    });
 
     // Same as above — convergence loop re-runs agent loop, which also fails.
     expect(agentLoopRunCount).toBe(2);
@@ -600,11 +629,11 @@ describe("provider ordering error retry", () => {
     await conversation.loadFromDb();
 
     const events: Array<Record<string, unknown>> = [];
-    await conversation.processMessage(
-      "Please compare these images.",
-      makeImageAttachments(4),
-      (msg) => events.push(msg as unknown as Record<string, unknown>),
-    );
+    await conversation.processMessage({
+      content: "Please compare these images.",
+      attachments: makeImageAttachments(4),
+      onEvent: (msg) => events.push(msg as unknown as Record<string, unknown>),
+    });
 
     expect(agentLoopRunCount).toBe(2);
     expect(maybeCompactCalls).toEqual([{ force: false }, { force: true }]);
@@ -620,11 +649,11 @@ describe("provider ordering error retry", () => {
     await conversation.loadFromDb();
 
     const events: Array<Record<string, unknown>> = [];
-    await conversation.processMessage(
-      "Please compare these images.",
-      makeImageAttachments(8),
-      (msg) => events.push(msg as unknown as Record<string, unknown>),
-    );
+    await conversation.processMessage({
+      content: "Please compare these images.",
+      attachments: makeImageAttachments(8),
+      onEvent: (msg) => events.push(msg as unknown as Record<string, unknown>),
+    });
 
     // The 413 ProviderError message "request entity too large" doesn't match
     // the regex patterns, but classifyConversationError recognizes statusCode 413
@@ -643,11 +672,11 @@ describe("provider ordering error retry", () => {
     await conversation.loadFromDb();
 
     const events: Array<Record<string, unknown>> = [];
-    await conversation.processMessage(
-      "Run some tools then hit the limit.",
-      [],
-      (msg) => events.push(msg as unknown as Record<string, unknown>),
-    );
+    await conversation.processMessage({
+      content: "Run some tools then hit the limit.",
+      attachments: [],
+      onEvent: (msg) => events.push(msg as unknown as Record<string, unknown>),
+    });
 
     // Two agent loop runs — first makes progress then 413, convergence loop
     // re-runs after reducer (which returns exhausted). Second run also fails