@vellumai/assistant 0.8.3 → 0.8.5

package/src/context/compactor.ts

@@ -27,6 +27,7 @@ import {
   getAttachmentMetadataForMessage,
 } from "../memory/attachments-store.js";
 import { getMessages } from "../memory/conversation-crud.js";
+import { recordRequestLog } from "../memory/llm-request-log-store.js";
 import type {
   ContentBlock,
   ImageContent,
@@ -50,6 +51,49 @@ const log = getLogger("compactor");
  */
 const COMPACTION_CALL_SITE: LLMCallSite = "mainAgent";
 
+/**
+ * Tag stamped on `llm_request_logs.call_site` for compaction-driven rows.
+ *
+ * Distinct from `COMPACTION_CALL_SITE` (above) on purpose: that constant
+ * names the **provider config resolution** site (set to `mainAgent` so we
+ * inherit the agent's profile and keep the prefix cache warm). This
+ * constant names the **observability** site — what the row IS — so
+ * inspectors can filter "show me only compaction calls". They're
+ * semantically different even though both come from the same enum.
+ */
+const COMPACTION_LOG_CALL_SITE: LLMCallSite = "compactionAgent";
+
+/**
+ * Best-effort: persist a successful compaction LLM call into
+ * `llm_request_logs` with `call_site = "compactionAgent"`. The compactor
+ * opts out of automatic usage tracking (`usageTracking: "manual"`), so
+ * its calls otherwise never reach `recordRequestLog` via the agent-loop
+ * dispatcher. Failures are swallowed (warn-logged) so a DB hiccup never
+ * escalates compaction into a failure.
+ */
+function recordCompactionRequestLog(
+  conversationId: string,
+  response: ProviderResponse,
+  provider: Provider,
+): void {
+  if (!response.rawRequest || !response.rawResponse) return;
+  try {
+    recordRequestLog(
+      conversationId,
+      JSON.stringify(response.rawRequest),
+      JSON.stringify(response.rawResponse),
+      undefined,
+      response.actualProvider ?? provider.name,
+      COMPACTION_LOG_CALL_SITE,
+    );
+  } catch (err) {
+    log.warn(
+      { err, conversationId },
+      "Failed to persist compaction LLM request log (non-fatal)",
+    );
+  }
+}
+
 const RESULT_TAG_OPEN = "<compaction_result>";
 const RESULT_TAG_CLOSE = "</compaction_result>";
 
@@ -155,6 +199,11 @@ export interface CompactionRunResult {
   thresholdTokens: number;
   compactedMessages: number;
   compactedPersistedMessages: number;
+  /**
+   * Number of recent ("tail") messages preserved verbatim alongside the
+   * summary. Omitted on no-op / skipped results — defaults to 0 at render.
+   */
+  preservedTailMessages?: number;
   summaryCalls: number;
   summaryInputTokens: number;
   summaryOutputTokens: number;
@@ -327,7 +376,7 @@ export function renderImageManifest(entries: ManifestEntry[]): string {
  * runtime emitted — typically
  * `2026-04-02 (Thursday) 01:52:33 -05:00 (America/Chicago)`).
  */
-function extractTurnContextTimestamp(message: Message): string | null {
+export function extractTurnContextTimestamp(message: Message): string | null {
   if (message.role !== "user") return null;
   for (const block of message.content) {
     if (block.type !== "text") continue;
@@ -669,6 +718,10 @@ export async function runAssistantDrivenCompaction(
     };
   }
 
+  // Persist the compaction LLM call into `llm_request_logs` with
+  // `call_site = "compactionAgent"`. Non-fatal on DB error — see helper.
+  recordCompactionRequestLog(args.conversationId, response, args.provider);
+
   const rawText = extractTextFromResponse(response.content);
   const parsed = parseCompactionResult(rawText);
   if (!parsed) {
@@ -841,6 +894,7 @@ export async function runAssistantDrivenCompaction(
     thresholdTokens,
     compactedMessages: compactableMessages.length,
     compactedPersistedMessages,
+    preservedTailMessages: args.messages.length - tailIndex,
     summaryCalls: 1,
     summaryInputTokens: response.usage.inputTokens,
     summaryOutputTokens: response.usage.outputTokens,
@@ -1037,6 +1091,10 @@ export async function runEmergencyCompaction(
     };
   }
 
+  // Persist the emergency compaction LLM call into `llm_request_logs` with
+  // `call_site = "compactionAgent"`. Non-fatal on DB error — see helper.
+  recordCompactionRequestLog(args.conversationId, response, args.provider);
+
   const rawText = extractTextFromResponse(response.content);
   const parsed = parseCompactionResult(rawText);
   if (!parsed) {
@@ -1090,6 +1148,7 @@ export async function runEmergencyCompaction(
     thresholdTokens,
     compactedMessages: compactedCount,
     compactedPersistedMessages: Math.max(0, compactedCount - nonPersistedAway),
+    preservedTailMessages: keptTail.length,
     summaryCalls: 1,
     summaryInputTokens: response.usage.inputTokens,
     summaryOutputTokens: response.usage.outputTokens,

package/src/context/token-estimator.ts

@@ -52,6 +52,24 @@ const IMAGE_MAX_PIXELS = 1_200_000;
 const IMAGE_TOKENS_PER_PIXEL = 1 / 750;
 const IMAGE_MAX_TOKENS = 1_600;
 
+// Gemini prices images differently: any side ≤384px counts as a single 258-token
+// tile; anything larger is resized so the longest side is ≤3072px and then
+// split into 768x768 tiles at 258 tokens each. A 4000x4000 image clamps to
+// 3072x3072 → ceil(3072/768)^2 = 16 tiles = 4,128 tokens. Without the clamp
+// we'd over-count it as 36 tiles (~9,288 tokens) and trigger spurious
+// compaction. The clamped 16-tile, 4,128-token figure is also the per-image
+// ceiling we fall back to when dimensions are unparseable (e.g. HEIC/HEIF
+// from iOS attachments) — the generic 1,600 cap can under-count Gemini
+// images by ~2.5x.
+// See: https://ai.google.dev/gemini-api/docs/tokens#multimodal-tokens
+const GEMINI_IMAGE_SMALL_THRESHOLD = 384;
+const GEMINI_IMAGE_TILE_SIZE = 768;
+const GEMINI_IMAGE_TOKENS_PER_TILE = 258;
+const GEMINI_IMAGE_MAX_DIMENSION = 3072;
+const GEMINI_IMAGE_MAX_TOKENS =
+  Math.ceil(GEMINI_IMAGE_MAX_DIMENSION / GEMINI_IMAGE_TILE_SIZE) ** 2 *
+  GEMINI_IMAGE_TOKENS_PER_TILE;
+
 // Anthropic renders each PDF page as an image (~1,568 tokens at standard
 // resolution) plus any extracted text. Typical PDF pages are 50-150 KB.
 // Using ~100 KB/page and ~1,600 tokens/page gives ~0.016 tokens/byte.
@@ -129,16 +147,41 @@ function estimateImageTokensByDimensions(
   return Math.ceil(scaledWidth * scaledHeight * IMAGE_TOKENS_PER_PIXEL);
 }
 
+function estimateGeminiImageTokens(width: number, height: number): number {
+  if (
+    width <= GEMINI_IMAGE_SMALL_THRESHOLD &&
+    height <= GEMINI_IMAGE_SMALL_THRESHOLD
+  ) {
+    return GEMINI_IMAGE_TOKENS_PER_TILE;
+  }
+  // Gemini resizes images so the longest side is ≤3072px before tiling.
+  const clampedWidth = Math.min(width, GEMINI_IMAGE_MAX_DIMENSION);
+  const clampedHeight = Math.min(height, GEMINI_IMAGE_MAX_DIMENSION);
+  const tilesWide = Math.ceil(clampedWidth / GEMINI_IMAGE_TILE_SIZE);
+  const tilesHigh = Math.ceil(clampedHeight / GEMINI_IMAGE_TILE_SIZE);
+  return tilesWide * tilesHigh * GEMINI_IMAGE_TOKENS_PER_TILE;
+}
+
 function estimateImageTokens(
   block: Extract<ContentBlock, { type: "image" }>,
+  options?: TokenEstimatorOptions,
 ): number {
   const dims = parseImageDimensions(block.source.data, block.source.media_type);
   if (dims) {
+    if (options?.providerName === "gemini") {
+      return estimateGeminiImageTokens(dims.width, dims.height);
+    }
     return estimateImageTokensByDimensions(dims.width, dims.height);
   }
-  // Dimensions unparseable (corrupt header, exotic format): use the per-image
-  // cap rather than the raw base64 length, which over-counts by 30-100x for
-  // non-Anthropic providers and trips spurious compaction.
+  // Dimensions unparseable (corrupt header, or formats parseImageDimensions
+  // doesn't recognize like HEIC/HEIF coming from iOS attachments). Fall back
+  // to the per-provider per-image ceiling rather than the raw base64 length,
+  // which over-counts by 30-100x. Gemini's tile pricing tops out well above
+  // the universal 1,600-token cap, so use its max-tile budget instead to
+  // avoid under-counting large iPhone screenshots.
+  if (options?.providerName === "gemini") {
+    return GEMINI_IMAGE_MAX_TOKENS;
+  }
   return IMAGE_MAX_TOKENS;
 }
 
@@ -186,7 +229,7 @@ export function estimateContentBlockTokens(
       return (
         IMAGE_BLOCK_OVERHEAD_TOKENS +
         estimateTextTokens(block.source.media_type) +
-        estimateImageTokens(block)
+        estimateImageTokens(block, options)
       );
     case "file":
       return (

package/src/context/window-manager.ts

@@ -51,6 +51,11 @@ export interface ContextWindowResult {
   thresholdTokens: number;
   compactedMessages: number;
   compactedPersistedMessages: number;
+  /**
+   * Number of recent ("tail") messages preserved verbatim alongside the
+   * summary. Omitted on no-op / skipped results — defaults to 0 at render.
+   */
+  preservedTailMessages?: number;
   summaryCalls: number;
   summaryInputTokens: number;
   summaryOutputTokens: number;
@@ -216,6 +221,26 @@ export class ContextWindowManager {
     return getConfig().compaction;
   }
 
+  get maxInputTokens(): number {
+    return this.config.maxInputTokens;
+  }
+
+  /**
+   * Estimate the prompt-token cost of `messages` using the same path as the
+   * auto-compaction pre-check. Clears the system-prompt cache so the next
+   * turn re-resolves it (the system prompt is lazy and may have changed).
+   */
+  estimateInputTokens(messages: Message[]): number {
+    try {
+      return estimatePromptTokens(messages, this.systemPrompt, {
+        providerName: this.estimationProviderName,
+        toolTokenBudget: this.toolTokenBudget,
+      });
+    } finally {
+      this.clearSystemPromptCache();
+    }
+  }
+
   /**
    * Cheap pre-check — estimate the current token count and compare against
    * `compaction.autoThreshold`. Callers pass the estimate back through

package/src/conversations/__tests__/message-consolidation.test.ts

@@ -0,0 +1,350 @@
+import { describe, expect, test } from "bun:test";
+
+import type { MessageRow } from "../../memory/conversation-crud.js";
+import {
+  findDisplayTurnEndIndex,
+  isToolResultOnlyUserMessage,
+  mergeConsecutiveAssistantMessages,
+  mergeToolResultsIntoAssistantMessages,
+} from "../message-consolidation.js";
+
+function makeMsg(
+  role: string,
+  content: string,
+  overrides: Partial<MessageRow> = {},
+): MessageRow {
+  return {
+    id: `msg-${Math.random().toString(36).slice(2, 10)}`,
+    conversationId: "conv-1",
+    role,
+    content,
+    createdAt: Date.now(),
+    displayOrder: 0,
+    seen: 1,
+    metadata: null,
+    ...overrides,
+  } as MessageRow;
+}
+
+describe("isToolResultOnlyUserMessage", () => {
+  test("returns false for assistant rows", () => {
+    expect(isToolResultOnlyUserMessage(makeMsg("assistant", "hello"))).toBe(
+      false,
+    );
+  });
+
+  test("returns false for plain user text (non-JSON content)", () => {
+    expect(isToolResultOnlyUserMessage(makeMsg("user", "hello world"))).toBe(
+      false,
+    );
+  });
+
+  test("returns false when JSON content is not an array", () => {
+    expect(
+      isToolResultOnlyUserMessage(
+        makeMsg("user", JSON.stringify({ type: "tool_result" })),
+      ),
+    ).toBe(false);
+  });
+
+  test("returns true for a single tool_result block", () => {
+    expect(
+      isToolResultOnlyUserMessage(
+        makeMsg(
+          "user",
+          JSON.stringify([
+            { type: "tool_result", tool_use_id: "abc", content: "ok" },
+          ]),
+        ),
+      ),
+    ).toBe(true);
+  });
+
+  test("returns true for a web_search_tool_result block", () => {
+    expect(
+      isToolResultOnlyUserMessage(
+        makeMsg(
+          "user",
+          JSON.stringify([
+            { type: "web_search_tool_result", tool_use_id: "abc" },
+          ]),
+        ),
+      ),
+    ).toBe(true);
+  });
+
+  test("returns true when tool_result is wrapped with system_notice blocks", () => {
+    expect(
+      isToolResultOnlyUserMessage(
+        makeMsg(
+          "user",
+          JSON.stringify([
+            { type: "tool_result", tool_use_id: "abc" },
+            {
+              type: "text",
+              text: "<system_notice>info</system_notice>",
+            },
+          ]),
+        ),
+      ),
+    ).toBe(true);
+  });
+
+  test("returns false when mixed with real user text", () => {
+    expect(
+      isToolResultOnlyUserMessage(
+        makeMsg(
+          "user",
+          JSON.stringify([
+            { type: "tool_result", tool_use_id: "abc" },
+            { type: "text", text: "thanks!" },
+          ]),
+        ),
+      ),
+    ).toBe(false);
+  });
+
+  test("returns false when there are no tool_result blocks (system_notice alone)", () => {
+    expect(
+      isToolResultOnlyUserMessage(
+        makeMsg(
+          "user",
+          JSON.stringify([
+            {
+              type: "text",
+              text: "<system_notice>info</system_notice>",
+            },
+          ]),
+        ),
+      ),
+    ).toBe(false);
+  });
+
+  test("returns false for malformed JSON content", () => {
+    expect(
+      isToolResultOnlyUserMessage(makeMsg("user", "{not json")),
+    ).toBe(false);
+  });
+
+  test("returns false when array contains a non-object block", () => {
+    expect(
+      isToolResultOnlyUserMessage(
+        makeMsg("user", JSON.stringify(["bare string"])),
+      ),
+    ).toBe(false);
+  });
+});
+
+describe("findDisplayTurnEndIndex", () => {
+  test("returns startIdx unchanged for negative index", () => {
+    const messages = [makeMsg("user", "hi")];
+    expect(findDisplayTurnEndIndex(messages, -1)).toBe(-1);
+  });
+
+  test("returns startIdx unchanged for out-of-range index", () => {
+    const messages = [makeMsg("user", "hi")];
+    expect(findDisplayTurnEndIndex(messages, 5)).toBe(5);
+  });
+
+  test("returns startIdx unchanged for non-assistant rows", () => {
+    const messages = [
+      makeMsg("user", "hi"),
+      makeMsg("assistant", "back"),
+    ];
+    expect(findDisplayTurnEndIndex(messages, 0)).toBe(0);
+  });
+
+  test("returns startIdx for a lone assistant row at end of array", () => {
+    const messages = [
+      makeMsg("user", "hi"),
+      makeMsg("assistant", "back"),
+    ];
+    expect(findDisplayTurnEndIndex(messages, 1)).toBe(1);
+  });
+
+  test("advances past consecutive assistant rows", () => {
+    const messages = [
+      makeMsg("user", "hi"),
+      makeMsg("assistant", "step 1"),
+      makeMsg("assistant", "step 2"),
+      makeMsg("assistant", "step 3"),
+      makeMsg("user", "next"),
+    ];
+    expect(findDisplayTurnEndIndex(messages, 1)).toBe(3);
+  });
+
+  test("advances across tool-result-only user rows between assistants", () => {
+    const messages = [
+      makeMsg("user", "lookup data"),
+      makeMsg("assistant", "calling tool"),
+      makeMsg(
+        "user",
+        JSON.stringify([
+          { type: "tool_result", tool_use_id: "t1", content: "ok" },
+        ]),
+      ),
+      makeMsg("assistant", "here are the results"),
+      makeMsg("user", "thanks"),
+    ];
+    expect(findDisplayTurnEndIndex(messages, 1)).toBe(3);
+  });
+
+  test("stops at a real-text user row even after tool-result-only rows", () => {
+    const messages = [
+      makeMsg("user", "first"),
+      makeMsg("assistant", "tool call"),
+      makeMsg(
+        "user",
+        JSON.stringify([
+          { type: "tool_result", tool_use_id: "t1" },
+        ]),
+      ),
+      makeMsg("assistant", "intermediate"),
+      makeMsg("user", "real user follow-up"),
+      makeMsg("assistant", "should not be included"),
+    ];
+    expect(findDisplayTurnEndIndex(messages, 1)).toBe(3);
+  });
+
+  test("handles assistant followed by tool-result-only user at end of array", () => {
+    // No tail assistant follows — the suppressed user row still belongs to
+    // the cluster (its tool_result content gets folded into the preceding
+    // assistant by the read-path collapse).
+    const messages = [
+      makeMsg("user", "hi"),
+      makeMsg("assistant", "tool call"),
+      makeMsg(
+        "user",
+        JSON.stringify([
+          { type: "tool_result", tool_use_id: "t1" },
+        ]),
+      ),
+    ];
+    expect(findDisplayTurnEndIndex(messages, 1)).toBe(2);
+  });
+
+  test("handles a long mixed cluster", () => {
+    const messages = [
+      makeMsg("user", "go"),
+      makeMsg("assistant", "A"),
+      makeMsg("assistant", "B"),
+      makeMsg(
+        "user",
+        JSON.stringify([{ type: "tool_result", tool_use_id: "t1" }]),
+      ),
+      makeMsg("assistant", "C"),
+      makeMsg(
+        "user",
+        JSON.stringify([
+          { type: "tool_result", tool_use_id: "t2" },
+          { type: "text", text: "<system_notice>x</system_notice>" },
+        ]),
+      ),
+      makeMsg("assistant", "D"),
+      makeMsg("user", "done"),
+    ];
+    expect(findDisplayTurnEndIndex(messages, 1)).toBe(6);
+  });
+});
+
+describe("mergeToolResultsIntoAssistantMessages", () => {
+  test("suppresses tool-result-only user rows and lifts blocks onto preceding assistant", () => {
+    const messages = [
+      makeMsg(
+        "assistant",
+        JSON.stringify([{ type: "tool_use", id: "t1", name: "x", input: {} }]),
+      ),
+      makeMsg(
+        "user",
+        JSON.stringify([
+          { type: "tool_result", tool_use_id: "t1", content: "ok" },
+        ]),
+      ),
+    ];
+    const merged = mergeToolResultsIntoAssistantMessages(messages);
+    expect(merged).toHaveLength(1);
+    expect(merged[0].role).toBe("assistant");
+    const blocks = JSON.parse(merged[0].content) as Array<{ type: string }>;
+    expect(blocks.map((b) => b.type)).toEqual(["tool_use", "tool_result"]);
+  });
+
+  test("keeps mixed user messages with their non-tool-result content", () => {
+    const messages = [
+      makeMsg(
+        "assistant",
+        JSON.stringify([{ type: "tool_use", id: "t1", name: "x", input: {} }]),
+      ),
+      makeMsg(
+        "user",
+        JSON.stringify([
+          { type: "tool_result", tool_use_id: "t1", content: "ok" },
+          { type: "text", text: "thanks!" },
+        ]),
+      ),
+    ];
+    const merged = mergeToolResultsIntoAssistantMessages(messages);
+    expect(merged).toHaveLength(2);
+    expect(merged[1].role).toBe("user");
+    const userBlocks = JSON.parse(merged[1].content) as Array<{ type: string }>;
+    expect(userBlocks.map((b) => b.type)).toEqual(["text"]);
+  });
+
+  test("passes plain user text through unchanged", () => {
+    const messages = [
+      makeMsg("user", "hi"),
+      makeMsg("assistant", "hello"),
+    ];
+    const merged = mergeToolResultsIntoAssistantMessages(messages);
+    expect(merged).toHaveLength(2);
+    expect(merged[0].content).toBe("hi");
+  });
+});
+
+describe("mergeConsecutiveAssistantMessages", () => {
+  test("collapses adjacent assistant rows onto the first row", () => {
+    const a = makeMsg(
+      "assistant",
+      JSON.stringify([{ type: "text", text: "part 1" }]),
+      { id: "anchor" },
+    );
+    const b = makeMsg(
+      "assistant",
+      JSON.stringify([{ type: "text", text: "part 2" }]),
+      { id: "tail" },
+    );
+    const { messages, mergedIdMap } = mergeConsecutiveAssistantMessages([
+      makeMsg("user", "hi"),
+      a,
+      b,
+    ]);
+    expect(messages).toHaveLength(2);
+    expect(messages[1].id).toBe("anchor");
+    const blocks = JSON.parse(messages[1].content) as Array<{ text: string }>;
+    expect(blocks.map((blk) => blk.text)).toEqual(["part 1", "part 2"]);
+    expect(mergedIdMap.get("anchor")).toEqual(["tail"]);
+  });
+
+  test("leaves a single assistant row unchanged", () => {
+    const messages = [
+      makeMsg("user", "hi"),
+      makeMsg(
+        "assistant",
+        JSON.stringify([{ type: "text", text: "hello" }]),
+      ),
+    ];
+    const { messages: result, mergedIdMap } =
+      mergeConsecutiveAssistantMessages(messages);
+    expect(result).toHaveLength(2);
+    expect(mergedIdMap.size).toBe(0);
+  });
+
+  test("does not merge assistant rows separated by a real user row", () => {
+    const messages = [
+      makeMsg("assistant", JSON.stringify([{ type: "text", text: "A" }])),
+      makeMsg("user", "interrupt"),
+      makeMsg("assistant", JSON.stringify([{ type: "text", text: "B" }])),
+    ];
+    const { messages: result } = mergeConsecutiveAssistantMessages(messages);
+    expect(result).toHaveLength(3);
+  });
+});