@vellumai/assistant 0.8.7 → 0.8.8-dev.202606052332.17fc8ea

package/src/__tests__/compaction-direct.test.ts

@@ -0,0 +1,132 @@
+/**
+ * Tests for the default compaction plugin (`defaultCompact`).
+ *
+ * The agent loop calls {@link defaultCompact} directly with a
+ * {@link CompactionContext} rather than routing through a middleware pipeline.
+ * These tests assert that the default implementation delegates to the
+ * supplied {@link ContextWindowManager} and forwards the request's
+ * conversational options verbatim. The orchestrator integration path
+ * (conversation-agent-loop) is exercised by
+ * `conversation-agent-loop-overflow.test.ts`.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import {
+  type CompactionContext,
+  defaultCompact,
+} from "../plugins/defaults/compaction/compact.js";
+
+type ContextWindowResultShape = {
+  compacted: boolean;
+  summaryText: string;
+  messages: unknown[];
+  previousEstimatedInputTokens: number;
+  estimatedInputTokens: number;
+  maxInputTokens: number;
+  thresholdTokens: number;
+  compactedMessages: number;
+  compactedPersistedMessages: number;
+  summaryCalls: number;
+  summaryInputTokens: number;
+  summaryOutputTokens: number;
+  summaryModel: string;
+  reason?: string;
+};
+
+function makeResult(
+  overrides: Partial<ContextWindowResultShape> = {},
+): ContextWindowResultShape {
+  return {
+    compacted: true,
+    summaryText: "default-summary",
+    messages: [],
+    previousEstimatedInputTokens: 1000,
+    estimatedInputTokens: 100,
+    maxInputTokens: 100000,
+    thresholdTokens: 80000,
+    compactedMessages: 3,
+    compactedPersistedMessages: 3,
+    summaryCalls: 1,
+    summaryInputTokens: 500,
+    summaryOutputTokens: 120,
+    summaryModel: "default-model",
+    ...overrides,
+  };
+}
+
+function makeManager(result: ContextWindowResultShape) {
+  const observed: {
+    messages: unknown;
+    signal: unknown;
+    options: unknown;
+  }[] = [];
+  const manager = {
+    maybeCompact: async (
+      messages: unknown,
+      signal: unknown,
+      options: unknown,
+    ) => {
+      observed.push({ messages, signal, options });
+      return result;
+    },
+  } as unknown as CompactionContext["manager"];
+  return { manager, observed };
+}
+
+describe("defaultCompact", () => {
+  test("delegates to the manager and returns its result unchanged", async () => {
+    // GIVEN a manager whose maybeCompact records its arguments
+    const expected = makeResult({
+      summaryText: "manager-summary",
+      compactedMessages: 7,
+    });
+    const { manager, observed } = makeManager(expected);
+    const messages = [{ role: "user", content: "hi" }] as never;
+    const signal = new AbortController().signal;
+
+    // WHEN defaultCompact runs with those messages and a signal
+    const result = (await defaultCompact({
+      manager,
+      messages,
+      signal,
+    })) as unknown as ContextWindowResultShape;
+
+    // THEN the manager saw the same messages and signal
+    expect(observed).toHaveLength(1);
+    expect(observed[0]!.messages).toBe(messages);
+    expect(observed[0]!.signal).toBe(signal);
+
+    // AND the returned result is the manager's object, unmodified
+    expect(result).toBe(expected);
+    expect(result.summaryText).toBe("manager-summary");
+    expect(result.compactedMessages).toBe(7);
+  });
+
+  test("forwards the request's compaction options to the manager", async () => {
+    // GIVEN a manager and a fully-populated compaction context
+    const { manager, observed } = makeManager(makeResult());
+
+    // WHEN defaultCompact runs with force/profile/trust options
+    await defaultCompact({
+      manager,
+      messages: [] as never,
+      force: true,
+      overrideProfile: "fast-profile",
+      precomputedEstimate: 1234,
+      minKeepRecentUserTurns: 0,
+      actorTrustClass: "guardian",
+    });
+
+    // THEN the manager received exactly those options, and the manager,
+    // messages, and signal are not leaked into the options bag
+    expect(observed).toHaveLength(1);
+    expect(observed[0]!.options).toEqual({
+      force: true,
+      overrideProfile: "fast-profile",
+      precomputedEstimate: 1234,
+      minKeepRecentUserTurns: 0,
+      actorTrustClass: "guardian",
+    });
+  });
+});

package/src/__tests__/compaction.benchmark.test.ts

@@ -172,34 +172,4 @@ describe("Compaction benchmark", () => {
     expect(result.summaryCalls).toBe(1);
     expect(result.summaryCalls).toBe(counter.calls);
   });
-
-  test("severe pressure triggers compaction even during cooldown", async () => {
-    const counter = { calls: 0 };
-    const provider = makeSummaryProvider(counter);
-    // Use a tighter maxInputTokens so 90 turns exceeds the 95% severe threshold
-    const config = {
-      ...makeConfig(),
-      maxInputTokens: 4000,
-      targetBudgetRatio: 0.55,
-    };
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config,
-    });
-
-    const messages = makeLongMessages(90);
-    const estimated = estimatePromptTokens(messages, "system prompt", {
-      providerName: "mock",
-    });
-    expect(estimated).toBeGreaterThan(config.maxInputTokens * 0.95);
-
-    // Simulate being within cooldown by setting lastCompactedAt to now
-    const result = await manager.maybeCompact(messages, undefined, {
-      lastCompactedAt: Date.now(),
-    });
-
-    expect(result.compacted).toBe(true);
-    expect(result.summaryCalls).toBeGreaterThan(0);
-  });
 });

package/src/__tests__/config-watcher.test.ts

@@ -231,7 +231,7 @@ describe("ConfigWatcher workspace file handlers", () => {
     expect(evictCallCount).toBe(1);
   });
 
-  test("SOUL.md change triggers identity intro invalidation", async () => {
+  test("SOUL.md change triggers identity intro refetch notification", async () => {
     let introCallCount = 0;
     watcher.start(
       onConversationEvict,

package/src/__tests__/conversation-abort-tool-results.test.ts

@@ -108,8 +108,13 @@ mock.module("../workspace/git-service.js", () => ({
   }),
 }));
 
-// Track all messages persisted to DB
+// Track all messages persisted to DB via addMessage (single-shot writes).
 let persistedMessages: Array<{ role: string; content: string }> = [];
+// Track the latest content written into each reserved row (reserve + update
+// pattern). Tool results persist on arrival and finalize at the loop boundary
+// through this path, so the final value per row id is what lands in the DB.
+let reservedRowContent: Map<string, string> = new Map();
+let reserveCounter = 0;
 
 mock.module("../memory/conversation-crud.js", () => ({
   setConversationOriginChannelIfUnset: () => {},
@@ -139,8 +144,10 @@ mock.module("../memory/conversation-crud.js", () => ({
   updateConversationTitle: () => {},
   getMessageById: () => null,
   getLastUserTimestampBefore: () => 0,
-  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
-  updateMessageContent: mock(() => {}),
+  reserveMessage: mock(async () => ({ id: `msg-reserve-${++reserveCounter}` })),
+  updateMessageContent: mock((id: string, content: string) => {
+    reservedRowContent.set(id, content);
+  }),
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({
@@ -226,8 +233,11 @@ mock.module("../agent/loop.js", () => ({
         isError: false,
       });
 
-      // Abort happens before second tool
-      // Synthesize cancelled result for tu_2 (what the real AgentLoop does)
+      // Abort happens before second tool. The real AgentLoop synthesizes
+      // cancelled results into history AND emits a `cancelled` tool_result
+      // event per tool so the orchestrator captures them for persistence and
+      // forwards them to the client. tu_1 (already captured via its real
+      // tool_result event) wins via the handler's gap-fill guard.
       const resultBlocks: ContentBlock[] = [
         {
           type: "tool_result",
@@ -243,8 +253,27 @@ mock.module("../agent/loop.js", () => ({
         },
       ];
       history.push({ role: "user", content: resultBlocks });
+      onEvent({
+        type: "tool_result",
+        toolUseId: "tu_1",
+        content: "Cancelled by user",
+        isError: true,
+        cancelled: true,
+      });
+      onEvent({
+        type: "tool_result",
+        toolUseId: "tu_2",
+        content: "Cancelled by user",
+        isError: true,
+        cancelled: true,
+      });
 
-      return { history, exitReason: null };
+      return {
+        history,
+        exitReason: null,
+        appendedNewMessages: true,
+        newMessages: history.slice(messages.length),
+      };
     }
   },
 }));
@@ -295,6 +324,8 @@ function makeConversation(): Conversation {
 describe("abort tool result persistence", () => {
   test("abort after first of multiple tool calls still persists all required tool_result blocks", async () => {
     persistedMessages = [];
+    reservedRowContent = new Map();
+    reserveCounter = 0;
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
@@ -303,19 +334,26 @@ describe("abort tool result persistence", () => {
       attachments: [],
     });
 
-    // Find user messages in persisted data that contain tool_result
-    const toolResultUserMessages = persistedMessages.filter((m) => {
-      if (m.role !== "user") return false;
-      try {
-        const content = JSON.parse(m.content);
-        return (
-          Array.isArray(content) &&
-          content.some((b: Record<string, unknown>) => b.type === "tool_result")
-        );
-      } catch {
-        return false;
-      }
-    });
+    // Find persisted rows whose final content contains tool_result blocks.
+    // Tool results persist on arrival into one grouped row and finalize at the
+    // abort/loop boundary; the latest content per reserved row id is what lands
+    // in the DB, so one entry per row models the persisted state (a second
+    // entry would mean the batch was wrongly split across rows).
+    const toolResultUserMessages = Array.from(reservedRowContent.values())
+      .map((content) => ({ content }))
+      .filter((m) => {
+        try {
+          const content = JSON.parse(m.content);
+          return (
+            Array.isArray(content) &&
+            content.some(
+              (b: Record<string, unknown>) => b.type === "tool_result",
+            )
+          );
+        } catch {
+          return false;
+        }
+      });
 
     // There should be at least one persisted user message with tool_results
     expect(toolResultUserMessages.length).toBeGreaterThanOrEqual(1);

package/src/__tests__/conversation-agent-loop-disk-pressure.test.ts

@@ -109,10 +109,14 @@ import { runAgentLoopImpl } from "../daemon/conversation-agent-loop.js";
 function makeCtx(
   overrides: Partial<Context> = {},
 ): AgentLoopConversationContext {
+  let processing = true;
   return {
     conversationId: "conv-123",
     messages: [{ role: "user", content: [{ type: "text", text: "hello" }] }],
-    processing: true,
+    isProcessing: () => processing,
+    setProcessing: (value: boolean) => {
+      processing = value;
+    },
     abortController: new AbortController(),
     currentRequestId: "req-123",
     agentLoop: {
@@ -141,8 +145,6 @@ function makeCtx(
     surfaceActionRequestIds: new Set<string>(),
     currentTurnSurfaces: [],
     workingDir: "/tmp",
-    workspaceTopLevelContext: null,
-    workspaceTopLevelDirty: false,
     channelCapabilities: undefined,
     commandIntent: undefined,
     trustContext: undefined,
@@ -168,7 +170,6 @@ function makeCtx(
     hasNoClient: false,
     prompter: {} as Context["prompter"],
     queue: {} as Context["queue"],
-    refreshWorkspaceTopLevelContextIfNeeded: () => {},
     markWorkspaceTopLevelDirty: () => {},
     emitActivityState: () => {},
     getQueueDepth: () => 0,
@@ -217,7 +218,7 @@ describe("runAgentLoopImpl disk pressure gate", () => {
       "error_terminal",
       { anchor: "global", requestId: "req-123" },
     ]);
-    expect(ctx.processing).toBe(false);
+    expect(ctx.isProcessing()).toBe(false);
     expect(ctx.abortController).toBeNull();
     expect(ctx.currentRequestId).toBeUndefined();
     expect(drainQueue).toHaveBeenCalledWith("loop_complete");

package/src/__tests__/conversation-agent-loop-inference-profile.test.ts

@@ -96,6 +96,9 @@ mock.module("../config/loader.js", () => ({
 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,
 }));
 
@@ -220,10 +223,6 @@ mock.module("../daemon/conversation-runtime-assembly.js", () => ({
     blocks: {},
   }),
   stripInjectionsForCompaction: (msgs: Message[]) => msgs,
-  findLastInjectedNowContent: () => null,
-  readNowScratchpad: () => null,
-  readPkbContext: () => null,
-  getPkbAutoInjectList: () => [],
   isSlackChannelConversation: () => false,
   getSlackCompactionWatermarkForPrefix: () => null,
   loadSlackChronologicalContext: () => null,
@@ -392,6 +391,12 @@ function makeCtx(
       { role: "user", content: [{ type: "text", text: "Hello" }] },
     ] as Message[],
     processing: true,
+    isProcessing(this: { processing: boolean }) {
+      return this.processing;
+    },
+    setProcessing(this: { processing: boolean }, value: boolean) {
+      this.processing = value;
+    },
     abortController: new AbortController(),
     currentRequestId: "test-req",
 
@@ -430,8 +435,6 @@ function makeCtx(
     currentTurnSurfaces: [],
 
     workingDir: "/tmp",
-    workspaceTopLevelContext: null,
-    workspaceTopLevelDirty: false,
     channelCapabilities: undefined,
     commandIntent: undefined,
     trustContext: undefined,
@@ -468,7 +471,6 @@ function makeCtx(
     getWorkspaceGitService: () => ({ ensureInitialized: async () => {} }),
     commitTurnChanges: async () => {},
 
-    refreshWorkspaceTopLevelContextIfNeeded: () => {},
     markWorkspaceTopLevelDirty: () => {},
     emitActivityState: () => {},
     getQueueDepth: () => 0,
@@ -494,6 +496,7 @@ function makeCtx(
         injectedTokens: 0,
       }),
       retrackCachedNodes: () => {},
+      recordPkbQueryVectors: () => {},
     } as unknown as AgentLoopConversationContext["graphMemory"],
 
     ...overrides,