@vellumai/assistant 0.8.8 → 0.8.9-dev.202606091926.ebb2d62

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,9 +97,18 @@ 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 "../context/window-manager.js";
+import { ContextWindowManager } from "../plugins/defaults/compaction/window-manager.js";
 import type { Message, Provider } from "../providers/types.js";
 
 function makeProvider(): Provider {
@@ -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/__tests__/conversation-abort-tool-results.test.ts

@@ -167,9 +167,10 @@ mock.module("../memory/retriever.js", () => ({
   injectMemoryRecallAsUserBlock: (msgs: Message[]) => msgs,
 }));
 
-mock.module("../context/window-manager.js", () => ({
+mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
   ContextWindowManager: class {
     constructor() {}
+    updateConfig() {}
     shouldCompact() {
       return { needed: false, estimatedTokens: 0 };
     }
@@ -198,10 +199,11 @@ mock.module("../agent/loop.js", () => ({
     getActiveModel() {
       return undefined;
     }
-    async run(
-      messages: Message[],
-      onEvent: (event: AgentEvent) => void,
-    ): Promise<AgentLoopRunResult> {
+    async run(options: {
+      messages: Message[];
+      onEvent: (event: AgentEvent) => void;
+    }): Promise<AgentLoopRunResult> {
+      const { messages, onEvent } = options;
       // Prime the assistant row anchor — production code emits this from
       // `AgentLoop.run` just before `provider.sendMessage`.
       await onEvent({ type: "llm_call_started" });

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

@@ -2,11 +2,11 @@ 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 { Conversation } from "../daemon/conversation.js";
 import type { DiskPressureStatus } from "../daemon/disk-pressure-guard.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 
-type Context = AgentLoopConversationContext;
+type Context = Conversation;
 
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
@@ -96,7 +96,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   getMessageById: () => null,
   getConversationOriginChannel: () => null,
   getConversationOriginInterface: () => null,
-  getConversationOverrideProfileFromRow: () => null,
+  resolveOverrideProfile: () => null,
   provenanceFromTrustContext: () => ({}),
   setConversationHistoryStrippedAt: () => {},
   updateConversationContextWindow: () => {},
@@ -106,9 +106,7 @@ mock.module("../memory/conversation-crud.js", () => ({
 
 import { runAgentLoopImpl } from "../daemon/conversation-agent-loop.js";
 
-function makeCtx(
-  overrides: Partial<Context> = {},
-): AgentLoopConversationContext {
+function makeCtx(overrides: Partial<Context> = {}): Conversation {
   let processing = true;
   return {
     conversationId: "conv-123",
@@ -137,6 +135,8 @@ function makeCtx(
     } as unknown as Context["contextWindowManager"],
     contextCompactedMessageCount: 0,
     contextCompactedAt: null,
+    conversationType: "background",
+    source: "memory",
     memoryPolicy: { scopeId: "default", includeDefaultFallback: true },
     currentActiveSurfaceId: undefined,
     currentPage: undefined,
@@ -145,8 +145,6 @@ function makeCtx(
     surfaceActionRequestIds: new Set<string>(),
     currentTurnSurfaces: [],
     workingDir: "/tmp",
-    workspaceTopLevelContext: null,
-    workspaceTopLevelDirty: false,
     channelCapabilities: undefined,
     commandIntent: undefined,
     trustContext: undefined,
@@ -172,7 +170,6 @@ function makeCtx(
     hasNoClient: false,
     prompter: {} as Context["prompter"],
     queue: {} as Context["queue"],
-    refreshWorkspaceTopLevelContextIfNeeded: () => {},
     markWorkspaceTopLevelDirty: () => {},
     emitActivityState: () => {},
     getQueueDepth: () => 0,
@@ -183,7 +180,7 @@ function makeCtx(
     getTurnChannelContext: () => null,
     graphMemory: {} as Context["graphMemory"],
     ...overrides,
-  } as AgentLoopConversationContext;
+  } as unknown as Conversation;
 }
 
 describe("runAgentLoopImpl disk pressure gate", () => {

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

@@ -15,7 +15,7 @@ import { createRequire } from "node:module";
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { CompactionCircuit } from "../agent/compaction-circuit.js";
-import type { AgentEvent, AgentLoopRunOptions } from "../agent/loop.js";
+import type { 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";
@@ -102,23 +102,26 @@ mock.module("../context/token-estimator.js", () => ({
   estimateToolsTokens: () => 0,
 }));
 
-mock.module("../daemon/context-overflow-reducer.js", () => ({
-  createInitialReducerState: () => ({
-    appliedTiers: [],
-    injectionMode: "full" as const,
-    exhausted: false,
-  }),
-  reduceContextOverflow: async (msgs: Message[]) => ({
-    messages: msgs,
-    tier: "forced_compaction",
-    state: {
-      appliedTiers: ["forced_compaction"],
-      injectionMode: "full",
-      exhausted: true,
-    },
-    estimatedTokens: 1000,
+mock.module(
+  "../plugins/defaults/compaction/context-overflow-reducer.js",
+  () => ({
+    createInitialReducerState: () => ({
+      appliedTiers: [],
+      injectionMode: "full" as const,
+      exhausted: false,
+    }),
+    reduceContextOverflow: async (msgs: Message[]) => ({
+      messages: msgs,
+      tier: "forced_compaction",
+      state: {
+        appliedTiers: ["forced_compaction"],
+        injectionMode: "full",
+        exhausted: true,
+      },
+      estimatedTokens: 1000,
+    }),
   }),
-}));
+);
 
 mock.module("../daemon/context-overflow-policy.js", () => ({
   resolveOverflowAction: () => "fail_gracefully",
@@ -150,12 +153,26 @@ mock.module("../memory/conversation-crud.js", () => ({
   updateMessageMetadata: () => {},
   getMessages: () => [],
   getConversation: () => mockConversationRow,
-  getConversationOverrideProfileFromRow: (
-    row: { conversationType?: string; inferenceProfile?: string | null } | null,
+  resolveOverrideProfile: (
+    fields: {
+      conversationType?: string | null;
+      inferenceProfile?: string | null;
+      inferenceProfileExpiresAt?: number | null;
+    } | null,
   ) => {
-    if (row?.conversationType === "background") return undefined;
-    const profile = row?.inferenceProfile;
-    return typeof profile === "string" ? profile : undefined;
+    if (
+      fields?.conversationType === "background" ||
+      fields?.conversationType === "scheduled"
+    ) {
+      return undefined;
+    }
+    if (
+      fields?.inferenceProfileExpiresAt != null &&
+      fields.inferenceProfileExpiresAt <= Date.now()
+    ) {
+      return undefined;
+    }
+    return fields?.inferenceProfile ?? undefined;
   },
   provenanceFromTrustContext: () => ({
     source: "user",
@@ -343,10 +360,8 @@ mock.module("../memory/llm-request-log-store.js", () => ({
 
 // ── Imports (after mocks) ────────────────────────────────────────────
 
-import {
-  type AgentLoopConversationContext,
-  runAgentLoopImpl,
-} from "../daemon/conversation-agent-loop.js";
+import type { Conversation } from "../daemon/conversation.js";
+import { runAgentLoopImpl } from "../daemon/conversation-agent-loop.js";
 
 // ── Test helpers ─────────────────────────────────────────────────────
 
@@ -362,22 +377,20 @@ let mutateBeforeResolveOverrideProfile: (() => void) | undefined;
 
 function makeCtx(
   captured: CapturedAgentLoopRun[],
-  overrides?: Partial<AgentLoopConversationContext>,
-): AgentLoopConversationContext {
+  overrides?: Partial<Conversation>,
+): Conversation {
   const agentLoopRun = async (
-    messages: Message[],
-    _onEvent: (event: AgentEvent) => void,
-    options?: AgentLoopRunOptions,
+    options: AgentLoopRunOptions,
   ): Promise<Message[]> => {
     mutateBeforeResolveOverrideProfile?.();
     captured.push({
-      callSite: options?.callSite,
-      overrideProfile: options?.overrideProfile,
-      resolvedOverrideProfile: options?.resolveOverrideProfile?.(),
-      resolvedMaxInputTokens: options?.resolveContextWindow?.().maxInputTokens,
+      callSite: options.callSite,
+      overrideProfile: options.overrideProfile,
+      resolvedOverrideProfile: options.resolveOverrideProfile?.(),
+      resolvedMaxInputTokens: options.resolveContextWindow?.().maxInputTokens,
     });
     return [
-      ...messages,
+      ...options.messages,
       {
         role: "assistant" as const,
         content: [{ type: "text" as const, text: "response" }],
@@ -406,7 +419,7 @@ function makeCtx(
       getResolvedTools: () => [] as ToolDefinition[],
       getActiveModel: () => undefined,
       compactionCircuit: new CompactionCircuit("test-conv"),
-    } as unknown as AgentLoopConversationContext["agentLoop"],
+    } as unknown as Conversation["agentLoop"],
     provider: {
       name: "mock-provider",
       sendMessage: async () => ({
@@ -415,13 +428,14 @@ function makeCtx(
         usage: { inputTokens: 0, outputTokens: 0 },
         stopReason: "end_turn",
       }),
-    } as unknown as AgentLoopConversationContext["provider"],
+    } as unknown as Conversation["provider"],
     systemPrompt: "system prompt",
 
     contextWindowManager: {
+      updateConfig: () => {},
       shouldCompact: () => ({ needed: false, estimatedTokens: 0 }),
       maybeCompact: async () => ({ compacted: false }),
-    } as unknown as AgentLoopConversationContext["contextWindowManager"],
+    } as unknown as Conversation["contextWindowManager"],
     contextCompactedMessageCount: 0,
     contextCompactedAt: null,
 
@@ -435,8 +449,6 @@ function makeCtx(
     currentTurnSurfaces: [],
 
     workingDir: "/tmp",
-    workspaceTopLevelContext: null,
-    workspaceTopLevelDirty: false,
     channelCapabilities: undefined,
     commandIntent: undefined,
     trustContext: undefined,
@@ -446,15 +458,15 @@ function makeCtx(
     preactivatedSkillIds: undefined,
     skillProjectionState: new Map(),
     skillProjectionCache:
-      new Map() as unknown as AgentLoopConversationContext["skillProjectionCache"],
+      new Map() as unknown as Conversation["skillProjectionCache"],
 
     traceEmitter: {
       emit: () => {},
-    } as unknown as AgentLoopConversationContext["traceEmitter"],
+    } as unknown as Conversation["traceEmitter"],
     profiler: {
       startRequest: () => {},
       emitSummary: () => {},
-    } as unknown as AgentLoopConversationContext["profiler"],
+    } as unknown as Conversation["profiler"],
     usageStats: {
       totalInputTokens: 0,
       totalOutputTokens: 0,
@@ -467,13 +479,12 @@ function makeCtx(
     lastAttachmentWarnings: [],
 
     hasNoClient: false,
-    prompter: {} as unknown as AgentLoopConversationContext["prompter"],
-    queue: {} as unknown as AgentLoopConversationContext["queue"],
+    prompter: {} as unknown as Conversation["prompter"],
+    queue: {} as unknown as Conversation["queue"],
 
     getWorkspaceGitService: () => ({ ensureInitialized: async () => {} }),
     commitTurnChanges: async () => {},
 
-    refreshWorkspaceTopLevelContextIfNeeded: () => {},
     markWorkspaceTopLevelDirty: () => {},
     emitActivityState: () => {},
     getQueueDepth: () => 0,
@@ -500,10 +511,10 @@ function makeCtx(
       }),
       retrackCachedNodes: () => {},
       recordPkbQueryVectors: () => {},
-    } as unknown as AgentLoopConversationContext["graphMemory"],
+    } as unknown as Conversation["graphMemory"],
 
     ...overrides,
-  } as AgentLoopConversationContext;
+  } as unknown as Conversation;
 }
 
 // ── Tests ────────────────────────────────────────────────────────────
@@ -541,20 +552,11 @@ afterAll(() => {
 
 describe("runAgentLoopImpl — per-conversation inferenceProfile", () => {
   test("non-background conversation with inferenceProfile threads it through as overrideProfile", async () => {
-    mockConversationRow = {
-      id: "conv-1",
+    const captured: CapturedAgentLoopRun[] = [];
+    const ctx = makeCtx(captured, {
       conversationType: "standard",
       inferenceProfile: "quality-optimized",
-      contextSummary: null,
-      contextCompactedMessageCount: 0,
-      totalInputTokens: 0,
-      totalOutputTokens: 0,
-      totalEstimatedCost: 0,
-      title: null,
-    };
-
-    const captured: CapturedAgentLoopRun[] = [];
-    const ctx = makeCtx(captured);
+    });
 
     await runAgentLoopImpl(ctx, "hello", "msg-1", () => {});
 
@@ -564,21 +566,12 @@ describe("runAgentLoopImpl — per-conversation inferenceProfile", () => {
     }
   });
 
-  test("background conversation ignores inferenceProfile column", async () => {
-    mockConversationRow = {
-      id: "conv-1",
+  test("background conversation ignores inferenceProfile", async () => {
+    const captured: CapturedAgentLoopRun[] = [];
+    const ctx = makeCtx(captured, {
       conversationType: "background",
       inferenceProfile: "quality-optimized",
-      contextSummary: null,
-      contextCompactedMessageCount: 0,
-      totalInputTokens: 0,
-      totalOutputTokens: 0,
-      totalEstimatedCost: 0,
-      title: null,
-    };
-
-    const captured: CapturedAgentLoopRun[] = [];
-    const ctx = makeCtx(captured);
+    });
 
     await runAgentLoopImpl(ctx, "hello", "msg-1", () => {});
 
@@ -588,22 +581,9 @@ describe("runAgentLoopImpl — per-conversation inferenceProfile", () => {
     }
   });
 
-  test("absence of inferenceProfile column behaves identically to today (no override)", async () => {
-    // `mockConversationRow` already defaults to inferenceProfile: null.
-    // Also explicitly cover the case where the column is missing entirely.
-    mockConversationRow = {
-      id: "conv-1",
-      conversationType: "standard",
-      contextSummary: null,
-      contextCompactedMessageCount: 0,
-      totalInputTokens: 0,
-      totalOutputTokens: 0,
-      totalEstimatedCost: 0,
-      title: null,
-    };
-
+  test("absence of inferenceProfile behaves identically to today (no override)", async () => {
     const captured: CapturedAgentLoopRun[] = [];
-    const ctx = makeCtx(captured);
+    const ctx = makeCtx(captured, { conversationType: "standard" });
 
     await runAgentLoopImpl(ctx, "hello", "msg-1", () => {});
 
@@ -613,26 +593,17 @@ describe("runAgentLoopImpl — per-conversation inferenceProfile", () => {
     }
   });
 
-  test("explicit options.overrideProfile takes precedence over the column read", async () => {
+  test("explicit options.overrideProfile takes precedence over the conversation override", async () => {
     // Subagent path: SubagentManager forwards the parent's pinned profile
     // into the spawned (background) conversation's runAgentLoop call via
     // `options.overrideProfile`. The agent loop must respect that even
-    // though the subagent's own conversation row is `background` (which
+    // though the subagent's own conversation is `background` (which
     // would otherwise zero out the override per the rule above).
-    mockConversationRow = {
-      id: "conv-1",
+    const captured: CapturedAgentLoopRun[] = [];
+    const ctx = makeCtx(captured, {
       conversationType: "background",
       inferenceProfile: null,
-      contextSummary: null,
-      contextCompactedMessageCount: 0,
-      totalInputTokens: 0,
-      totalOutputTokens: 0,
-      totalEstimatedCost: 0,
-      title: null,
-    };
-
-    const captured: CapturedAgentLoopRun[] = [];
-    const ctx = makeCtx(captured);
+    });
 
     await runAgentLoopImpl(ctx, "hello", "msg-1", () => {}, {
       overrideProfile: "fast",
@@ -645,27 +616,15 @@ describe("runAgentLoopImpl — per-conversation inferenceProfile", () => {
   });
 
   test("re-resolves inferenceProfile when a tool changes it mid-turn", async () => {
-    mockConversationRow = {
-      id: "conv-1",
+    const captured: CapturedAgentLoopRun[] = [];
+    const ctx = makeCtx(captured, {
       conversationType: "standard",
       inferenceProfile: null,
-      contextSummary: null,
-      contextCompactedMessageCount: 0,
-      totalInputTokens: 0,
-      totalOutputTokens: 0,
-      totalEstimatedCost: 0,
-      title: null,
-    };
+    });
     mutateBeforeResolveOverrideProfile = () => {
-      mockConversationRow = {
-        ...mockConversationRow!,
-        inferenceProfile: "quality-optimized",
-      };
+      ctx.inferenceProfile = "quality-optimized";
     };
 
-    const captured: CapturedAgentLoopRun[] = [];
-    const ctx = makeCtx(captured);
-
     await runAgentLoopImpl(ctx, "hello", "msg-1", () => {});
 
     expect(captured.length).toBeGreaterThan(0);