@vellumai/assistant 0.8.8-dev.202606090318.74794fe → 0.8.8-dev.202606091311.113d87f

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.8.8-dev.202606090318.74794fe",
+  "version": "0.8.8-dev.202606091311.113d87f",
   "license": "MIT",
   "type": "module",
   "exports": {

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

@@ -56,6 +56,11 @@ let runCalls: Array<{
 let runResults: CompactionRunResult[] = [];
 const estimateReturns: number[] = [];
 
+// Captured arguments from each runEmergencyCompaction invocation, so the
+// emergencyCompact tests can assert the manager fills in the fields it owns.
+let emergencyCalls: Record<string, unknown>[] = [];
+let emergencyResult: CompactionRunResult | undefined;
+
 mock.module("../context/token-estimator.js", () => ({
   estimatePromptTokens: (): number => {
     const next = estimateReturns.shift();
@@ -92,6 +97,15 @@ mock.module("../context/compactor.js", () => ({
     }
     return result;
   },
+  runEmergencyCompaction: async (
+    args: Record<string, unknown>,
+  ): Promise<CompactionRunResult> => {
+    emergencyCalls.push(args);
+    if (!emergencyResult) {
+      throw new Error("emergencyResult not seeded");
+    }
+    return emergencyResult;
+  },
 }));
 
 import { ContextWindowManager } from "../plugins/defaults/compaction/window-manager.js";
@@ -142,24 +156,28 @@ function compactResult(
   };
 }
 
+function makeConfig(maxAttempts: number = 3) {
+  return {
+    enabled: true,
+    maxInputTokens: 200_000,
+    targetBudgetRatio: 0.3,
+    compactThreshold: 0.8,
+    summaryBudgetRatio: 0.05,
+    overflowRecovery: {
+      enabled: true,
+      safetyMarginRatio: 0.05,
+      maxAttempts,
+      interactiveLatestTurnCompression: "summarize" as const,
+      nonInteractiveLatestTurnCompression: "summarize" as const,
+    },
+  };
+}
+
 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",
-      },
-    },
+    config: makeConfig(maxAttempts),
     conversationId: "conv-test",
   });
 }
@@ -289,3 +307,91 @@ describe("ContextWindowManager.maybeCompact retry budget", () => {
     expect(result.estimatedInputTokens).toBe(165_000);
   });
 });
+
+describe("ContextWindowManager.emergencyCompact", () => {
+  beforeEach(() => {
+    emergencyCalls = [];
+    emergencyResult = undefined;
+    estimateReturns.length = 0;
+  });
+
+  test("supplies manager-owned fields and forwards only overflow inputs", async () => {
+    /**
+     * The manager owns provider, system prompt, token budget, conversation
+     * id, compaction config, and non-persisted prefix count; the caller
+     * provides only the overflow-specific inputs.
+     */
+    // GIVEN a manager seeded with a non-persisted prefix and a canned result
+    emergencyResult = compactResult({
+      compacted: true,
+      compactedMessages: 40,
+      summaryText: "emergency summary",
+    });
+    const manager = buildManager();
+    manager.seedNonPersistedPrefix(3);
+    const messages = makeMessages(8);
+    const signal = new AbortController().signal;
+
+    // WHEN emergency compaction runs
+    const result = await manager.emergencyCompact(
+      messages,
+      { previousEstimatedInputTokens: 242_201, overrideProfile: "fast" },
+      signal,
+    );
+
+    // THEN the manager fills its owned fields and forwards the caller inputs
+    expect(emergencyCalls.length).toBe(1);
+    const args = emergencyCalls[0]!;
+    expect(args.conversationId).toBe("conv-test");
+    expect(args.systemPrompt).toBe("you are a test assistant");
+    expect(args.maxInputTokens).toBe(200_000);
+    expect(args.nonPersistedPrefixCount).toBe(3);
+    expect(args.tools).toBeUndefined();
+    expect(args.force).toBe(true);
+    expect(args.signal).toBe(signal);
+    expect(args.messages).toBe(messages);
+    expect(args.previousEstimatedInputTokens).toBe(242_201);
+    expect(args.overrideProfile).toBe("fast");
+    expect((args.provider as { name: string }).name).toBe("mock-provider");
+    expect(result.summaryText).toBe("emergency summary");
+  });
+
+  test("defaults overrideProfile to null when omitted", async () => {
+    /**
+     * Callers that don't resolve a per-conversation profile get an explicit
+     * null forwarded to the summary call.
+     */
+    // GIVEN a manager and a canned result
+    emergencyResult = compactResult({ compacted: true });
+    const manager = buildManager();
+
+    // WHEN emergency compaction runs without an override profile
+    await manager.emergencyCompact(makeMessages(6), {
+      previousEstimatedInputTokens: 210_000,
+    });
+
+    // THEN overrideProfile is forwarded as null
+    expect(emergencyCalls[0]!.overrideProfile).toBeNull();
+  });
+
+  test("throws when the manager has no conversation id", async () => {
+    /**
+     * Emergency compaction needs a conversation id for attachment and
+     * timestamp lookups; a manager without one cannot run it.
+     */
+    // GIVEN a manager constructed without a conversation id
+    const manager = new ContextWindowManager({
+      provider: makeProvider(),
+      systemPrompt: "you are a test assistant",
+      config: makeConfig(),
+    });
+
+    // WHEN/THEN emergency compaction rejects without invoking the compactor
+    await expect(
+      manager.emergencyCompact(makeMessages(4), {
+        previousEstimatedInputTokens: 210_000,
+      }),
+    ).rejects.toThrow(/conversationId/);
+    expect(emergencyCalls.length).toBe(0);
+  });
+});

package/src/daemon/conversation-agent-loop.ts

@@ -33,7 +33,6 @@ import {
 import { getConfig } from "../config/loader.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
 import type { ContextWindowConfig } from "../config/types.js";
-import { runEmergencyCompaction } from "../context/compactor.js";
 import {
   derefToolResultReReads,
   postTurnTruncateToolResults,
@@ -1221,22 +1220,15 @@ export async function runAgentLoopImpl(
       // compressing history. Falls through to reducer tiers on failure.
       {
         try {
-          const emergencyConfig = getConfig().compaction;
-          const emergencyResult = await runEmergencyCompaction({
-            conversationId: ctx.conversationId,
-            messages: ctx.messages,
-            provider: ctx.provider,
-            systemPrompt: ctx.systemPrompt,
-            tools: undefined,
-            compaction: emergencyConfig,
-            maxInputTokens: resolveCurrentMaxInputTokens(),
-            previousEstimatedInputTokens: estimatedTokensAtOverflow,
-            force: true,
-            signal: abortController.signal,
-            overrideProfile: resolveCurrentOverrideProfile() ?? null,
-            nonPersistedPrefixCount:
-              ctx.contextWindowManager.nonPersistedPrefixCount,
-          });
+          const emergencyResult =
+            await ctx.contextWindowManager.emergencyCompact(
+              ctx.messages,
+              {
+                previousEstimatedInputTokens: estimatedTokensAtOverflow,
+                overrideProfile: resolveCurrentOverrideProfile() ?? null,
+              },
+              abortController.signal,
+            );
           if (emergencyResult.compacted) {
             rlog.info(
               {

package/src/plugins/defaults/compaction/window-manager.ts

@@ -20,7 +20,9 @@ import type { LLMCallSite } from "../../../config/schemas/llm.js";
 import type { ContextWindowConfig } from "../../../config/types.js";
 import {
   type CompactionRunArgs,
+  type CompactionRunResult,
   runAssistantDrivenCompaction,
+  runEmergencyCompaction,
 } from "../../../context/compactor.js";
 import { estimatePromptTokens } from "../../../context/token-estimator.js";
 import type {
@@ -118,6 +120,21 @@ export interface ContextWindowCompactOptions {
   actorTrustClass?: TrustClass;
 }
 
+export interface EmergencyCompactOptions {
+  /**
+   * The provider-reported estimate at the overflow that triggered recovery.
+   * Sizing the emergency summary needs the actual rejected token count, not
+   * the manager's pre-send estimate (which under-counted, hence the
+   * rejection).
+   */
+  previousEstimatedInputTokens: number;
+  /**
+   * Per-conversation inference-profile override forwarded to the summary
+   * call.
+   */
+  overrideProfile?: string | null;
+}
+
 export interface ContextWindowManagerOptions {
   provider: Provider;
   systemPrompt: string | (() => string);
@@ -428,6 +445,45 @@ export class ContextWindowManager {
     return { ...result, estimatedInputTokens, exhausted: true };
   }
 
+  /**
+   * Emergency mid-turn compaction — summarize everything before the last
+   * tool_use/tool_result pair and let the agent continue with
+   * `[summary, last_tool_call, last_tool_result]`. Used as a recovery rung
+   * after the provider rejects a turn for context overflow. The manager
+   * supplies the provider, system prompt, token budget, conversation id, and
+   * non-persisted prefix count it already owns; the caller provides only the
+   * overflow-specific inputs.
+   */
+  async emergencyCompact(
+    messages: Message[],
+    options: EmergencyCompactOptions,
+    signal?: AbortSignal,
+  ): Promise<CompactionRunResult> {
+    if (this.conversationId == null) {
+      throw new Error(
+        "ContextWindowManager has no conversationId — cannot run emergency compaction",
+      );
+    }
+    try {
+      return await runEmergencyCompaction({
+        conversationId: this.conversationId,
+        messages,
+        provider: this.provider,
+        systemPrompt: this.systemPrompt,
+        tools: undefined,
+        compaction: this.resolveCompactionConfig(),
+        maxInputTokens: this.config.maxInputTokens,
+        previousEstimatedInputTokens: options.previousEstimatedInputTokens,
+        force: true,
+        signal,
+        overrideProfile: options.overrideProfile ?? null,
+        nonPersistedPrefixCount: this._nonPersistedPrefixCount,
+      });
+    } finally {
+      this.clearSystemPromptCache();
+    }
+  }
+
   /**
    * Recompute the prompt-token estimate against the post-compaction
    * message array. The compactor returns a conservative placeholder; the