@vellumai/assistant 0.8.5 → 0.8.7

package/src/__tests__/context-token-estimator.test.ts

@@ -126,6 +126,40 @@ describe("token estimator", () => {
     expect(largeFileTokens - smallFileTokens).toBeGreaterThan(1000);
   });
 
+  test("counts nested audio file blocks in a tool_result for Gemini", () => {
+    const audioBlock = {
+      type: "file" as const,
+      source: {
+        type: "base64" as const,
+        filename: "clip.mp3",
+        media_type: "audio/mpeg",
+        data: "a".repeat(400_000), // ~300 KB raw → ~18s → ~600 audio tokens
+      },
+    };
+    const base = {
+      type: "tool_result" as const,
+      tool_use_id: "t1",
+      content: "Audio loaded",
+      is_error: false,
+    };
+
+    const geminiDelta =
+      estimateContentBlockTokens(
+        { ...base, contentBlocks: [audioBlock] },
+        { providerName: "gemini" },
+      ) - estimateContentBlockTokens(base, { providerName: "gemini" });
+    const openaiDelta =
+      estimateContentBlockTokens(
+        { ...base, contentBlocks: [audioBlock] },
+        { providerName: "openai" },
+      ) - estimateContentBlockTokens(base, { providerName: "openai" });
+
+    // Gemini hears the audio (charged ~32 tok/sec); other providers drop it,
+    // so only Gemini accrues the payload-scaled cost.
+    expect(geminiDelta).toBeGreaterThan(500);
+    expect(geminiDelta).toBeGreaterThan(openaiDelta + 400);
+  });
+
   test("does not count file base64 payload for OpenAI-style file fallback", () => {
     const sharedSource = {
       type: "base64" as const,
@@ -367,6 +401,28 @@ describe("token estimator", () => {
     expect(tokens).toBeLessThan(4_200);
   });
 
+  test("Gemini preserves aspect ratio when resizing to the 3072px cap", () => {
+    // Gemini rescales BOTH dimensions by a single factor so the longest side
+    // becomes 3072px. A 10000x1000 image → 3072x307, i.e. ceil(3072/768)=4
+    // tiles wide * ceil(307/768)=1 tile high = 4 tiles (~1,032 tokens).
+    // Clamping each side independently would yield 4*2=8 tiles, over-counting
+    // by 2x and risking spurious compaction.
+    const tokens = estimateContentBlockTokens(
+      {
+        type: "image",
+        source: {
+          type: "base64",
+          media_type: "image/png",
+          data: makePngBase64(10000, 1000),
+        },
+      },
+      { providerName: "gemini" },
+    );
+    // 4 tiles * 258 = 1,032 image tokens + 16 block overhead + 3 media type.
+    expect(tokens).toBeGreaterThanOrEqual(1_032);
+    expect(tokens).toBeLessThan(1_100);
+  });
+
   test("Gemini images ≤384px on both sides count as a single 258-token tile", () => {
     const tokens = estimateContentBlockTokens(
       {

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,
@@ -138,6 +139,8 @@ mock.module("../memory/conversation-crud.js", () => ({
   updateConversationTitle: () => {},
   getMessageById: () => null,
   getLastUserTimestampBefore: () => 0,
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
+  updateMessageContent: mock(() => {}),
 }));
 
 mock.module("../memory/conversation-queries.js", () => ({
@@ -177,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;
@@ -190,8 +194,10 @@ 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" });
       const history = [...messages];
 
       // Simulate provider response with 2 tool_use blocks
@@ -238,7 +244,7 @@ mock.module("../agent/loop.js", () => ({
       ];
       history.push({ role: "user", content: resultBlocks });
 
-      return history;
+      return { history, exitReason: null };
     }
   },
 }));
@@ -280,9 +286,9 @@ function makeConversation(): Conversation {
     "conv-1",
     provider,
     "system prompt",
-    4096,
     () => {},
     "/tmp",
+    { maxTokens: 4096 },
   );
 }
 
@@ -292,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) => {
@@ -351,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";
@@ -100,6 +101,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   setConversationHistoryStrippedAt: () => {},
   updateConversationContextWindow: () => {},
   updateConversationSlackContextWatermark: () => {},
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 import { runAgentLoopImpl } from "../daemon/conversation-agent-loop.js";
@@ -120,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",
@@ -212,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-handlers-max-tokens.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, test } from "bun:test";
+
+import type { AgentEvent } from "../agent/loop.js";
+import {
+  createEventHandlerState,
+  type EventHandlerDeps,
+  handleMaxTokensReached,
+} from "../daemon/conversation-agent-loop-handlers.js";
+import type { ServerMessage } from "../daemon/message-protocol.js";
+
+describe("max tokens reached handler", () => {
+  test("emits and stores an inline continuation card", () => {
+    const sent: ServerMessage[] = [];
+    const ctx = {
+      conversationId: "conv-1",
+      surfaceState: new Map(),
+      currentTurnSurfaces: [],
+    };
+    const deps = {
+      ctx,
+      onEvent: (msg: ServerMessage) => sent.push(msg),
+      reqId: "req-1",
+      isFirstMessage: false,
+      shouldGenerateTitle: false,
+      rlog: { warn: () => {} },
+      turnChannelContext: {
+        userMessageChannel: "vellum",
+        assistantMessageChannel: "vellum",
+      },
+      turnInterfaceContext: {
+        userMessageInterface: "web",
+        assistantMessageInterface: "web",
+      },
+    } as unknown as EventHandlerDeps;
+
+    handleMaxTokensReached(createEventHandlerState(), deps, {
+      type: "max_tokens_reached",
+      stopReason: "max_tokens",
+    } as Extract<AgentEvent, { type: "max_tokens_reached" }>);
+
+    const show = sent.find((msg) => msg.type === "ui_surface_show");
+    expect(show).toBeDefined();
+    if (!show || show.type !== "ui_surface_show") return;
+
+    expect(show.surfaceType).toBe("card");
+    expect((show.data as { title?: unknown }).title).toBe(
+      "Response limit reached",
+    );
+    expect(show.actions?.[0]?.id).toBe("relay_prompt");
+    expect(show.actions?.[0]?.data?.prompt).toContain("Continue");
+    expect(show.actions?.[0]?.data?._completeSurface).toBe(true);
+    expect(ctx.currentTurnSurfaces).toHaveLength(1);
+    expect(ctx.surfaceState.has(show.surfaceId)).toBe(true);
+  });
+});

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";
@@ -170,6 +167,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   getMessageById: () => null,
   getLastUserTimestampBefore: () => 0,
   setLastNotifiedInferenceProfile: () => {},
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../memory/conversation-disk-view.js", () => ({
@@ -239,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: {
@@ -353,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;
@@ -373,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,
@@ -415,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",
@@ -679,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();
   });
 });