@vellumai/assistant 0.8.8 → 0.8.9-staging.2

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-events.test.ts

@@ -190,8 +190,8 @@ let mockCompactResult: ContextWindowResult = {
 mock.module("../context/window-manager.js", () => ({
   ContextWindowManager: class {
     nonPersistedPrefixCount = 0;
-    summaryIsInjected = false;
     constructor() {}
+    updateConfig() {}
     shouldCompact() {
       return { needed: false, estimatedTokens: 0 };
     }
@@ -228,10 +228,10 @@ mock.module("../agent/loop.js", () => ({
     getActiveModel() {
       return undefined;
     }
-    async run(
-      _messages: Message[],
-      _onEvent: (event: AgentEvent) => void,
-    ): Promise<Message[]> {
+    async run(_options: {
+      messages: Message[];
+      onEvent: (event: AgentEvent) => void;
+    }): Promise<Message[]> {
       return [];
     }
   },

package/src/__tests__/compactor-web-search-strip.test.ts

@@ -0,0 +1,213 @@
+import { 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(),
+}));
+
+mock.module("../memory/conversation-crud.js", () => ({
+  getMessages: () => [],
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
+}));
+
+mock.module("../memory/attachments-store.js", () => ({
+  getAttachmentMetadataForMessage: () => [],
+  getAttachmentContent: () => null,
+}));
+
+import {
+  runAssistantDrivenCompaction,
+  runEmergencyCompaction,
+} from "../context/compactor.js";
+import type { Message, Provider } from "../providers/types.js";
+
+const TAIL_TIMESTAMP =
+  "2026-05-21 (Thursday) 10:00:00 -05:00 (America/Chicago)";
+
+const compactionResponse = `
+<compaction_result>
+<summary>
+Earlier turns summarized here.
+</summary>
+
+<key_state>
+- Nothing critical pending.
+</key_state>
+
+<tail_start timestamp="${TAIL_TIMESTAMP}" preview="tail anchor message" />
+</compaction_result>
+`;
+
+const ENCRYPTED_TOKEN = "expired_encrypted_token_abc123";
+
+const userText = (text: string): Message => ({
+  role: "user",
+  content: [{ type: "text", text }],
+});
+
+const userTextWithTurnContext = (text: string, timestamp: string): Message => ({
+  role: "user",
+  content: [
+    {
+      type: "text",
+      text: `<turn_context>\ncurrent_time: ${timestamp}\n</turn_context>\n${text}`,
+    },
+  ],
+});
+
+const assistantWithWebSearch = (): Message => ({
+  role: "assistant",
+  content: [
+    {
+      type: "server_tool_use",
+      id: "stu_1",
+      name: "web_search",
+      input: { query: "cats" },
+    },
+    {
+      type: "web_search_tool_result",
+      tool_use_id: "stu_1",
+      content: [
+        {
+          type: "web_search_result",
+          url: "https://cats.example",
+          title: "All About Cats",
+          encrypted_content: ENCRYPTED_TOKEN,
+        },
+      ],
+    },
+  ],
+});
+
+const assistantToolUse = (): Message => ({
+  role: "assistant",
+  content: [
+    { type: "tool_use", id: "tu_1", name: "bash", input: { cmd: "ls" } },
+  ],
+});
+
+const toolResult = (): Message => ({
+  role: "user",
+  content: [{ type: "tool_result", tool_use_id: "tu_1", content: "ok" }],
+});
+
+function serializeBlocks(messages: Message[]): string {
+  return JSON.stringify(messages);
+}
+
+// Records the exact message list the provider is asked to summarize.
+function recordingProvider(sink: { sent: Message[] }): Provider {
+  return {
+    name: "mock-provider",
+    sendMessage: async (msgs: Message[]) => {
+      sink.sent = msgs;
+      return {
+        content: [{ type: "text", text: compactionResponse }],
+        model: "mock-model",
+        usage: { inputTokens: 100, outputTokens: 50 },
+        stopReason: "end_turn",
+      };
+    },
+  };
+}
+
+// Expired Anthropic web-search tokens must never reach the summarization LLM:
+// both compaction provider calls funnel through the same request builder, so
+// each is guarded here.
+describe("compaction summary calls — historical web-search sanitization", () => {
+  test("runAssistantDrivenCompaction strips expired encrypted_content from the request while leaving durable history untouched", async () => {
+    // GIVEN a history whose older turn contains a native web_search_tool_result
+    // block carrying an opaque, expired `encrypted_content` token
+    const messages: Message[] = [
+      userText("old user turn"),
+      assistantWithWebSearch(),
+      userTextWithTurnContext("tail anchor message", TAIL_TIMESTAMP),
+      assistantWithWebSearch(),
+    ];
+
+    // AND a snapshot of the caller's array so we can assert it is not mutated
+    const inputSnapshot = serializeBlocks(messages);
+    const sink = { sent: [] as Message[] };
+
+    // WHEN compaction runs over that history
+    const result = await runAssistantDrivenCompaction({
+      conversationId: "conv-web-search",
+      messages,
+      provider: recordingProvider(sink),
+      systemPrompt: "system",
+      compaction: { enabled: true, autoThreshold: 0.7 },
+      maxInputTokens: 1000,
+      previousEstimatedInputTokens: 900,
+    });
+
+    // THEN the summary request the provider received carries no expired token
+    // and no native web_search blocks, but keeps the search content as text
+    const sentSerialized = serializeBlocks(sink.sent);
+    expect(sentSerialized).not.toContain(ENCRYPTED_TOKEN);
+    expect(sentSerialized).not.toContain("web_search_tool_result");
+    expect(sentSerialized).not.toContain("server_tool_use");
+    expect(sentSerialized).toContain("All About Cats");
+    expect(sentSerialized).toContain("https://cats.example");
+
+    // AND the caller's durable history array is left byte-for-byte untouched,
+    // so persisted messages keep the original rich blocks
+    expect(serializeBlocks(messages)).toBe(inputSnapshot);
+    expect(result.compacted).toBe(true);
+  });
+
+  test("runEmergencyCompaction strips expired encrypted_content from the prefix request", async () => {
+    // GIVEN a mid-turn history whose prefix (before the last tool pair) holds a
+    // web_search_tool_result block with an expired token
+    const messages: Message[] = [
+      userText("old user turn"),
+      assistantWithWebSearch(),
+      userText("keep going"),
+      assistantToolUse(),
+      toolResult(),
+    ];
+
+    const inputSnapshot = serializeBlocks(messages);
+    const sink = { sent: [] as Message[] };
+
+    // WHEN emergency compaction splits at the last tool pair and summarizes the
+    // prefix
+    const result = await runEmergencyCompaction({
+      conversationId: "conv-web-search-emergency",
+      messages,
+      provider: recordingProvider(sink),
+      systemPrompt: "system",
+      compaction: { enabled: true, autoThreshold: 0.7 },
+      // Large budget so the prefix is not front-truncated — this test exercises
+      // the web-search sanitizer, not the truncation fallback.
+      maxInputTokens: 100000,
+      previousEstimatedInputTokens: 90000,
+    });
+
+    // THEN the prefix sent to the provider carries no expired token
+    const sentSerialized = serializeBlocks(sink.sent);
+    expect(sentSerialized).not.toContain(ENCRYPTED_TOKEN);
+    expect(sentSerialized).not.toContain("web_search_tool_result");
+    expect(sentSerialized).not.toContain("server_tool_use");
+    expect(sentSerialized).toContain("All About Cats");
+
+    // AND the caller's durable history is untouched
+    expect(serializeBlocks(messages)).toBe(inputSnapshot);
+    expect(result.compacted).toBe(true);
+  });
+});

package/src/__tests__/context-overflow-reducer.test.ts

@@ -11,7 +11,7 @@ import {
   reduceContextOverflow,
   type ReducerConfig,
   type ReducerState,
-} from "../daemon/context-overflow-reducer.js";
+} from "../plugins/defaults/compaction/context-overflow-reducer.js";
 import type { Message } from "../providers/types.js";
 
 function msg(role: "user" | "assistant", text: string): Message {

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

@@ -170,6 +170,7 @@ mock.module("../memory/retriever.js", () => ({
 mock.module("../context/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", () => {