@vellumai/assistant 0.8.6 → 0.8.7

package/src/__tests__/context-window-manager-compact-retry.test.ts

@@ -0,0 +1,291 @@
+/**
+ * Coverage for the retry budget that lives inside
+ * `ContextWindowManager.maybeCompact`. The orchestrator (agent loop)
+ * relies on the binary `exhausted` signal — these tests pin down when
+ * the manager flips it.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+function makeLoggerStub(): Record<string, unknown> {
+  const stub: Record<string, unknown> = {};
+  for (const m of [
+    "info",
+    "warn",
+    "error",
+    "debug",
+    "trace",
+    "fatal",
+    "silent",
+    "child",
+  ]) {
+    stub[m] = m === "child" ? () => makeLoggerStub() : () => {};
+  }
+  return stub;
+}
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => makeLoggerStub(),
+}));
+
+// ── Module-level mock state ───────────────────────────────────────────
+// Per-test mocks key off these — keeps closures simple and avoids the
+// "declared after mockImplementation references it" TDZ trap.
+
+interface CompactionRunResult {
+  messages: unknown;
+  compacted: boolean;
+  previousEstimatedInputTokens: number;
+  estimatedInputTokens: number;
+  maxInputTokens: number;
+  thresholdTokens: number;
+  compactedMessages: number;
+  compactedPersistedMessages: number;
+  summaryCalls: number;
+  summaryInputTokens: number;
+  summaryOutputTokens: number;
+  summaryModel: string;
+  summaryText: string;
+  reason?: string;
+  summaryFailed?: boolean;
+}
+
+let runCalls: Array<{
+  messages: unknown;
+  previousEstimatedInputTokens: number;
+}> = [];
+let runResults: CompactionRunResult[] = [];
+const estimateReturns: number[] = [];
+
+mock.module("../context/token-estimator.js", () => ({
+  estimatePromptTokens: (): number => {
+    const next = estimateReturns.shift();
+    if (next === undefined) {
+      throw new Error(
+        "estimatePromptTokens called more times than estimateReturns seeded",
+      );
+    }
+    return next;
+  },
+}));
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    compaction: { enabled: true, autoThreshold: 0.7, prompt: null },
+  }),
+}));
+
+mock.module("../context/compactor.js", () => ({
+  runAssistantDrivenCompaction: async (args: {
+    messages: unknown;
+    previousEstimatedInputTokens: number;
+  }): Promise<CompactionRunResult> => {
+    runCalls.push({
+      messages: args.messages,
+      previousEstimatedInputTokens: args.previousEstimatedInputTokens,
+    });
+    const idx = runCalls.length - 1;
+    const result = runResults[idx];
+    if (!result) {
+      throw new Error(
+        `Mock compactor called ${runCalls.length} time(s) but only ${runResults.length} result(s) seeded`,
+      );
+    }
+    return result;
+  },
+}));
+
+import { ContextWindowManager } from "../context/window-manager.js";
+import type { Message, Provider } from "../providers/types.js";
+
+function makeProvider(): Provider {
+  return {
+    name: "mock-provider",
+    sendMessage: async () => ({
+      content: [],
+      model: "mock-model",
+      usage: { inputTokens: 0, outputTokens: 0 },
+      stopReason: "end_turn",
+    }),
+  };
+}
+
+function makeMessages(count: number): Message[] {
+  const messages: Message[] = [];
+  for (let i = 0; i < count; i++) {
+    messages.push({
+      role: i % 2 === 0 ? "user" : "assistant",
+      content: [{ type: "text", text: `msg ${i}` }],
+    });
+  }
+  return messages;
+}
+
+function compactResult(
+  overrides: Partial<CompactionRunResult> = {},
+): CompactionRunResult {
+  return {
+    messages: makeMessages(2),
+    compacted: true,
+    previousEstimatedInputTokens: 150_000,
+    estimatedInputTokens: 50_000,
+    maxInputTokens: 200_000,
+    thresholdTokens: 140_000,
+    compactedMessages: 5,
+    compactedPersistedMessages: 5,
+    summaryCalls: 1,
+    summaryInputTokens: 1000,
+    summaryOutputTokens: 200,
+    summaryModel: "mock-model",
+    summaryText: "summary",
+    summaryFailed: false,
+    ...overrides,
+  };
+}
+
+function buildManager(maxAttempts: number = 3): ContextWindowManager {
+  return new ContextWindowManager({
+    provider: makeProvider(),
+    systemPrompt: "you are a test assistant",
+    config: {
+      enabled: true,
+      maxInputTokens: 200_000,
+      targetBudgetRatio: 0.3,
+      compactThreshold: 0.8,
+      summaryBudgetRatio: 0.05,
+      overflowRecovery: {
+        enabled: true,
+        safetyMarginRatio: 0.05,
+        maxAttempts,
+        interactiveLatestTurnCompression: "summarize",
+        nonInteractiveLatestTurnCompression: "summarize",
+      },
+    },
+    conversationId: "conv-test",
+  });
+}
+
+describe("ContextWindowManager.maybeCompact retry budget", () => {
+  beforeEach(() => {
+    runCalls = [];
+    runResults = [];
+    estimateReturns.length = 0;
+  });
+
+  test("single productive pass under threshold returns without retry", async () => {
+    // Estimate sequence: (1) pre-compaction = 160k forces compaction,
+    // (2) post-attempt-1 recompute = 50k clears threshold.
+    estimateReturns.push(160_000, 50_000);
+    runResults = [compactResult({ estimatedInputTokens: 50_000 })];
+
+    const manager = buildManager();
+    const result = await manager.maybeCompact(makeMessages(10));
+
+    expect(runCalls.length).toBe(1);
+    expect(result.compacted).toBe(true);
+    expect(result.exhausted).toBeUndefined();
+    expect(result.estimatedInputTokens).toBe(50_000);
+  });
+
+  test("compacted but still above threshold retries until under", async () => {
+    // Pre-compaction 180k → attempt-1 recompute 150k (still above
+    // 140k threshold) → attempt-2 recompute 80k (under). 2 attempts
+    // consumed; counters accumulate.
+    estimateReturns.push(180_000, 150_000, 80_000);
+    runResults = [
+      compactResult({
+        estimatedInputTokens: 150_000,
+        compactedMessages: 6,
+        summaryInputTokens: 1000,
+      }),
+      compactResult({
+        estimatedInputTokens: 80_000,
+        compactedMessages: 2,
+        summaryInputTokens: 500,
+      }),
+    ];
+
+    const manager = buildManager();
+    const result = await manager.maybeCompact(makeMessages(10));
+
+    expect(runCalls.length).toBe(2);
+    expect(result.compactedMessages).toBe(8);
+    expect(result.summaryCalls).toBe(2);
+    expect(result.summaryInputTokens).toBe(1500);
+    expect(result.estimatedInputTokens).toBe(80_000);
+    expect(result.exhausted).toBeUndefined();
+  });
+
+  test("compacted but stuck (no shrinkage) breaks early with exhausted", async () => {
+    // Pre-compaction 180k → attempt-1 165k → attempt-2 165k (didn't
+    // shrink). Must break before attempt 3 even though maxAttempts=3.
+    estimateReturns.push(180_000, 165_000, 165_000);
+    runResults = [
+      compactResult({ estimatedInputTokens: 165_000 }),
+      compactResult({ estimatedInputTokens: 165_000 }),
+      // Never consumed:
+      compactResult({ estimatedInputTokens: 50_000 }),
+    ];
+
+    const manager = buildManager();
+    const result = await manager.maybeCompact(makeMessages(10));
+
+    expect(runCalls.length).toBe(2);
+    expect(result.exhausted).toBe(true);
+    expect(result.estimatedInputTokens).toBe(165_000);
+  });
+
+  test("compacted but still above threshold after maxAttempts marks exhausted", async () => {
+    // Progressive shrink that never quite clears: 170k → 160k → 150k,
+    // all above 140k threshold. Consumes all 3 attempts; exhausted.
+    estimateReturns.push(180_000, 170_000, 160_000, 150_000);
+    runResults = [
+      compactResult({ estimatedInputTokens: 170_000, compactedMessages: 3 }),
+      compactResult({ estimatedInputTokens: 160_000, compactedMessages: 2 }),
+      compactResult({ estimatedInputTokens: 150_000, compactedMessages: 1 }),
+    ];
+
+    const manager = buildManager(3);
+    const result = await manager.maybeCompact(makeMessages(10));
+
+    expect(runCalls.length).toBe(3);
+    expect(result.exhausted).toBe(true);
+    expect(result.estimatedInputTokens).toBe(150_000);
+    expect(result.compactedMessages).toBe(6);
+  });
+
+  test("compactor early-returns (compacted=false) → pass-through, no exhausted", async () => {
+    estimateReturns.push(180_000);
+    runResults = [
+      compactResult({
+        compacted: false,
+        estimatedInputTokens: 180_000,
+        compactedMessages: 0,
+        summaryCalls: 0,
+        reason: "no eligible messages",
+      }),
+    ];
+
+    const manager = buildManager();
+    const result = await manager.maybeCompact(makeMessages(10));
+
+    expect(runCalls.length).toBe(1);
+    expect(result.compacted).toBe(false);
+    expect(result.exhausted).toBeUndefined();
+  });
+
+  test("maxAttempts=1 → never retries even when above threshold", async () => {
+    estimateReturns.push(180_000, 165_000);
+    runResults = [
+      compactResult({ estimatedInputTokens: 165_000 }),
+      // Never consumed:
+      compactResult({ estimatedInputTokens: 100_000 }),
+    ];
+
+    const manager = buildManager(1);
+    const result = await manager.maybeCompact(makeMessages(10));
+
+    expect(runCalls.length).toBe(1);
+    expect(result.exhausted).toBe(true);
+    expect(result.estimatedInputTokens).toBe(165_000);
+  });
+});

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

@@ -1,6 +1,7 @@
 import { 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 {
   ContentBlock,
   Message,
@@ -179,6 +180,7 @@ mock.module("../context/window-manager.js", () => ({
 // Mock AgentLoop that simulates abort after first of multiple tool calls
 mock.module("../agent/loop.js", () => ({
   AgentLoop: class {
+    compactionCircuit = new CompactionCircuit("test-conv");
     constructor() {}
     getToolTokenBudget() {
       return 0;
@@ -192,8 +194,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" });
@@ -243,7 +244,7 @@ mock.module("../agent/loop.js", () => ({
       ];
       history.push({ role: "user", content: resultBlocks });
 
-      return history;
+      return { history, exitReason: null };
     }
   },
 }));
@@ -285,9 +286,9 @@ function makeConversation(): Conversation {
     "conv-1",
     provider,
     "system prompt",
-    4096,
     () => {},
     "/tmp",
+    { maxTokens: 4096 },
   );
 }
 
@@ -297,7 +298,10 @@ describe("abort tool result persistence", () => {
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
-    await conversation.processMessage("Run tools", [], () => {});
+    await conversation.processMessage({
+      content: "Run tools",
+      attachments: [],
+    });
 
     // Find user messages in persisted data that contain tool_result
     const toolResultUserMessages = persistedMessages.filter((m) => {
@@ -356,7 +360,10 @@ describe("abort tool result persistence", () => {
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
-    await conversation.processMessage("Run tools", [], () => {});
+    await conversation.processMessage({
+      content: "Run tools",
+      attachments: [],
+    });
 
     // Simulate reload: the in-memory messages should be valid after repair
     const messages = conversation.getMessages();

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

@@ -1,5 +1,6 @@
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { CompactionCircuit } from "../agent/compaction-circuit.js";
 import type { AgentLoop } from "../agent/loop.js";
 import type { AgentLoopConversationContext } from "../daemon/conversation-agent-loop.js";
 import type { DiskPressureStatus } from "../daemon/disk-pressure-guard.js";
@@ -121,6 +122,7 @@ function makeCtx(
       getToolTokenBudget: () => 0,
       getResolvedTools: () => [],
       getActiveModel: () => undefined,
+      compactionCircuit: new CompactionCircuit("test-conv"),
     } as unknown as AgentLoop,
     provider: { name: "mock-provider" } as Context["provider"],
     systemPrompt: "system",
@@ -213,8 +215,7 @@ describe("runAgentLoopImpl disk pressure gate", () => {
     expect(activityStates).toContainEqual([
       "idle",
       "error_terminal",
-      "global",
-      "req-123",
+      { anchor: "global", requestId: "req-123" },
     ]);
     expect(ctx.processing).toBe(false);
     expect(ctx.abortController).toBeNull();

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

@@ -14,11 +14,8 @@
 import { createRequire } from "node:module";
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
-import type {
-  AgentEvent,
-  CheckpointDecision,
-  CheckpointInfo,
-} from "../agent/loop.js";
+import { CompactionCircuit } from "../agent/compaction-circuit.js";
+import type { AgentEvent, AgentLoopRunOptions } from "../agent/loop.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
 import { resetPluginRegistryAndRegisterDefaults } from "../plugins/defaults/index.js";
 import type { Message, ToolDefinition } from "../providers/types.js";
@@ -240,7 +237,7 @@ mock.module("../daemon/date-context.js", () => ({
   formatTurnTimestamp: () => "2026-01-01 (Thursday) 00:00:00 +00:00 (UTC)",
 }));
 
-mock.module("../daemon/history-repair.js", () => ({
+mock.module("../plugins/defaults/history-repair/terminal.js", () => ({
   repairHistory: (msgs: Message[]) => ({
     messages: msgs,
     stats: {
@@ -354,15 +351,12 @@ import {
 
 // ── Test helpers ─────────────────────────────────────────────────────
 
-// Captures every positional argument the loop passes to `agentLoop.run`.
-// The 8th positional argument is the per-turn `overrideProfile`, which is
-// what most tests assert on. The 10th and 11th positional arguments re-resolve
-// that profile and its max-token budget between provider calls.
+/** Captures the options the orchestrator passes to `agentLoop.run`. */
 interface CapturedAgentLoopRun {
   callSite: LLMCallSite | undefined;
   overrideProfile: string | undefined;
   resolvedOverrideProfile: string | undefined;
-  resolvedEffectiveMaxInputTokens: number | undefined;
+  resolvedMaxInputTokens: number | undefined;
 }
 
 let mutateBeforeResolveOverrideProfile: (() => void) | undefined;
@@ -374,24 +368,14 @@ function makeCtx(
   const agentLoopRun = async (
     messages: Message[],
     _onEvent: (event: AgentEvent) => void,
-    _signal?: AbortSignal,
-    _requestId?: string,
-    _onCheckpoint?: (
-      checkpoint: CheckpointInfo,
-    ) => CheckpointDecision | Promise<CheckpointDecision>,
-    callSite?: LLMCallSite,
-    _turnContext?: unknown,
-    overrideProfile?: string,
-    _effectiveMaxInputTokens?: number,
-    resolveOverrideProfile?: () => string | undefined,
-    resolveEffectiveMaxInputTokens?: () => number | undefined,
+    options?: AgentLoopRunOptions,
   ): Promise<Message[]> => {
     mutateBeforeResolveOverrideProfile?.();
     captured.push({
-      callSite,
-      overrideProfile,
-      resolvedOverrideProfile: resolveOverrideProfile?.(),
-      resolvedEffectiveMaxInputTokens: resolveEffectiveMaxInputTokens?.(),
+      callSite: options?.callSite,
+      overrideProfile: options?.overrideProfile,
+      resolvedOverrideProfile: options?.resolveOverrideProfile?.(),
+      resolvedMaxInputTokens: options?.resolveContextWindow?.().maxInputTokens,
     });
     return [
       ...messages,
@@ -416,6 +400,7 @@ function makeCtx(
       getToolTokenBudget: () => 0,
       getResolvedTools: () => [] as ToolDefinition[],
       getActiveModel: () => undefined,
+      compactionCircuit: new CompactionCircuit("test-conv"),
     } as unknown as AgentLoopConversationContext["agentLoop"],
     provider: {
       name: "mock-provider",
@@ -680,7 +665,7 @@ describe("runAgentLoopImpl — per-conversation inferenceProfile", () => {
     expect(captured.length).toBeGreaterThan(0);
     expect(captured[0].overrideProfile).toBeUndefined();
     expect(captured[0].resolvedOverrideProfile).toBe("quality-optimized");
-    expect(captured[0].resolvedEffectiveMaxInputTokens).toBe(50000);
+    expect(captured[0].resolvedMaxInputTokens).toBe(50000);
     expect(ctx.currentTurnOverrideProfile).toBeUndefined();
   });
 });