@vellumai/assistant 0.8.6 → 0.8.7-dev.202606052118.34cd356

package/src/__tests__/compaction-trail-store.test.ts

@@ -1,7 +1,5 @@
 /**
- * Tests for the compaction-trail store helpers:
- *   - `getCompactionLogsBetween` (windowed trail fetch)
- *   - `getPreviousNonCompactionCallCreatedAt` (window-floor resolver)
+ * Tests for the compaction-trail store helper `getCompactionLogsBetween`.
  *
  * Exercises the SQL directly against a real in-memory DB — same pattern
  * as `llm-request-log-turn-query.test.ts`. Each test sets up a small
@@ -37,7 +35,6 @@ import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import {
   getCompactionLogsBetween,
-  getPreviousNonCompactionCallCreatedAt,
   recordRequestLog,
 } from "../memory/llm-request-log-store.js";
 import { llmRequestLogs } from "../memory/schema.js";
@@ -187,78 +184,3 @@ describe("getCompactionLogsBetween", () => {
     expect(result).toEqual([]);
   });
 });
-
-describe("getPreviousNonCompactionCallCreatedAt", () => {
-  beforeEach(() => {
-    resetTables();
-  });
-
-  test("returns the most recent non-compaction call's createdAt before the cutoff", () => {
-    const conv = createConversation("prior-call");
-
-    // Timeline:
-    //   100 → mainAgent
-    //   200 → compactionAgent  ← skipped (we want the previous *real* call)
-    //   300 → mainAgent        ← this should be the answer for cutoff=500
-    //   400 → compactionAgent  ← skipped
-    //   500 ← cutoff
-    //   600 → mainAgent        ← excluded (after cutoff)
-    insertLogAt(conv.id, 100, "mainAgent");
-    insertLogAt(conv.id, 200, "compactionAgent");
-    insertLogAt(conv.id, 300, "mainAgent");
-    insertLogAt(conv.id, 400, "compactionAgent");
-    insertLogAt(conv.id, 600, "mainAgent");
-
-    const result = getPreviousNonCompactionCallCreatedAt(conv.id, 500);
-    expect(result).toBe(300);
-  });
-
-  test("returns null when no non-compaction call exists before the cutoff", () => {
-    const conv = createConversation("no-prior");
-
-    // Only compactions before the cutoff.
-    insertLogAt(conv.id, 100, "compactionAgent");
-    insertLogAt(conv.id, 200, "compactionAgent");
-
-    const result = getPreviousNonCompactionCallCreatedAt(conv.id, 500);
-    expect(result).toBeNull();
-  });
-
-  test("returns null for an unknown conversation_id", () => {
-    const result = getPreviousNonCompactionCallCreatedAt("nope", 500);
-    expect(result).toBeNull();
-  });
-
-  test("treats NULL call_site (pre-migration-264) as a real agent call", () => {
-    const conv = createConversation("null-site");
-
-    // Pre-migration rows have NULL call_site. They were mainAgent calls
-    // in practice, so the floor walker must surface them.
-    insertLogAt(conv.id, 100, null);
-    insertLogAt(conv.id, 200, "compactionAgent");
-
-    const result = getPreviousNonCompactionCallCreatedAt(conv.id, 500);
-    expect(result).toBe(100);
-  });
-
-  test("uses strict < at the cutoff (a row exactly at the cutoff is excluded)", () => {
-    const conv = createConversation("strict-prior");
-
-    insertLogAt(conv.id, 100, "mainAgent");
-    insertLogAt(conv.id, 500, "mainAgent"); // exactly at the cutoff
-
-    const result = getPreviousNonCompactionCallCreatedAt(conv.id, 500);
-    expect(result).toBe(100);
-  });
-
-  test("scopes by conversation_id (a prior call in another conversation is invisible)", () => {
-    const a = createConversation("conv-a");
-    const b = createConversation("conv-b");
-
-    insertLogAt(b.id, 100, "mainAgent"); // wrong conversation
-    insertLogAt(a.id, 200, "compactionAgent");
-
-    const result = getPreviousNonCompactionCallCreatedAt(a.id, 500);
-    expect(result).toBeNull();
-  });
-});

package/src/__tests__/compaction.benchmark.test.ts

@@ -172,34 +172,4 @@ describe("Compaction benchmark", () => {
     expect(result.summaryCalls).toBe(1);
     expect(result.summaryCalls).toBe(counter.calls);
   });
-
-  test("severe pressure triggers compaction even during cooldown", async () => {
-    const counter = { calls: 0 };
-    const provider = makeSummaryProvider(counter);
-    // Use a tighter maxInputTokens so 90 turns exceeds the 95% severe threshold
-    const config = {
-      ...makeConfig(),
-      maxInputTokens: 4000,
-      targetBudgetRatio: 0.55,
-    };
-    const manager = new ContextWindowManager({
-      provider,
-      systemPrompt: "system prompt",
-      config,
-    });
-
-    const messages = makeLongMessages(90);
-    const estimated = estimatePromptTokens(messages, "system prompt", {
-      providerName: "mock",
-    });
-    expect(estimated).toBeGreaterThan(config.maxInputTokens * 0.95);
-
-    // Simulate being within cooldown by setting lastCompactedAt to now
-    const result = await manager.maybeCompact(messages, undefined, {
-      lastCompactedAt: Date.now(),
-    });
-
-    expect(result.compacted).toBe(true);
-    expect(result.summaryCalls).toBeGreaterThan(0);
-  });
 });

package/src/__tests__/compactor-image-manifest-trust.test.ts

@@ -0,0 +1,112 @@
+/**
+ * Compaction must not surface guardian-only images to untrusted actors.
+ *
+ * `loadFromDb` hides guardian-provenance messages (and their images) from
+ * untrusted actors. The compaction image manifest reads the DB directly, so
+ * without the same provenance filter an untrusted actor's compaction turn
+ * could list a guardian image, retain it, and re-attach its bytes — leaking
+ * content the actor was never allowed to see. `collectImageManifest` applies
+ * the identical trust filter so this cannot happen.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    model: "test",
+    provider: "test",
+    memory: { enabled: false },
+  }),
+}));
+
+import { collectImageManifest } from "../context/compactor.js";
+import { attachInlineAttachmentToMessage } from "../memory/attachments-store.js";
+import { addMessage, createConversation } from "../memory/conversation-crud.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+
+initializeDb();
+
+// 1x1 transparent PNG.
+const PNG_1X1_BASE64 =
+  "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==";
+
+function resetTables(): void {
+  const db = getDb();
+  db.run("DELETE FROM message_attachments");
+  db.run("DELETE FROM attachments");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+}
+
+async function addImageMessage(
+  conversationId: string,
+  provenanceTrustClass: "guardian" | "trusted_contact" | "unknown",
+  filename: string,
+): Promise<void> {
+  const inserted = await addMessage(
+    conversationId,
+    "user",
+    JSON.stringify([{ type: "text", text: filename }]),
+    {
+      metadata: { provenanceTrustClass },
+      skipIndexing: true,
+    },
+  );
+  attachInlineAttachmentToMessage(
+    inserted.id,
+    0,
+    filename,
+    "image/png",
+    PNG_1X1_BASE64,
+  );
+}
+
+describe("collectImageManifest trust filtering", () => {
+  beforeEach(resetTables);
+
+  test("untrusted actor manifest excludes guardian images", async () => {
+    // GIVEN a conversation with a guardian image and an unknown-actor image
+    const conv = createConversation();
+    await addImageMessage(conv.id, "guardian", "guardian-secret.png");
+    await addImageMessage(conv.id, "unknown", "visitor.png");
+
+    // WHEN the manifest is built for an untrusted ("unknown") actor
+    const manifest = collectImageManifest(conv.id, "unknown");
+
+    // THEN only the untrusted actor's own image is listed
+    const filenames = manifest.map((e) => e.filename);
+    expect(filenames).toContain("visitor.png");
+    expect(filenames).not.toContain("guardian-secret.png");
+  });
+
+  test("guardian actor manifest includes all images", async () => {
+    // GIVEN a conversation with a guardian image and an unknown-actor image
+    const conv = createConversation();
+    await addImageMessage(conv.id, "guardian", "guardian-secret.png");
+    await addImageMessage(conv.id, "unknown", "visitor.png");
+
+    // WHEN the manifest is built for the guardian
+    const manifest = collectImageManifest(conv.id, "guardian");
+
+    // THEN every image is listed
+    const filenames = manifest.map((e) => e.filename);
+    expect(filenames).toContain("guardian-secret.png");
+    expect(filenames).toContain("visitor.png");
+  });
+
+  test("omitted trust class defaults to the untrusted filter", async () => {
+    // GIVEN a conversation containing a guardian image
+    const conv = createConversation();
+    await addImageMessage(conv.id, "guardian", "guardian-secret.png");
+    await addImageMessage(conv.id, "trusted_contact", "contact.png");
+
+    // WHEN the manifest is built without an explicit trust class
+    const manifest = collectImageManifest(conv.id);
+
+    // THEN the guardian image is excluded (fail-closed, mirroring loadFromDb)
+    const filenames = manifest.map((e) => e.filename);
+    expect(filenames).toContain("contact.png");
+    expect(filenames).not.toContain("guardian-secret.png");
+  });
+});

package/src/__tests__/computer-use-tools.test.ts

@@ -23,7 +23,7 @@ interface JsonSchema {
 }
 
 /** Cast a tool definition's input_schema to a usable JSON Schema shape. */
-function schema(tool: { input_schema: object }): JsonSchema {
+function schema(tool: { input_schema?: object }): JsonSchema {
   return tool.input_schema as JsonSchema;
 }
 
@@ -53,7 +53,7 @@ describe("computer-use tool definitions", () => {
 
   test("all tools have descriptions", () => {
     for (const tool of allComputerUseTools) {
-      expect(tool.description.length).toBeGreaterThan(0);
+      expect(tool.description!.length).toBeGreaterThan(0);
     }
   });
 });

package/src/__tests__/config-watcher.test.ts

@@ -231,6 +231,24 @@ describe("ConfigWatcher workspace file handlers", () => {
     expect(evictCallCount).toBe(1);
   });
 
+  test("SOUL.md change triggers identity intro refetch notification", async () => {
+    let introCallCount = 0;
+    watcher.start(
+      onConversationEvict,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      undefined,
+      () => {
+        introCallCount += 1;
+      },
+    );
+    simulateFileChange(WORKSPACE_DIR, "SOUL.md");
+    await new Promise((r) => setTimeout(r, WAIT_MS));
+    expect(introCallCount).toBe(1);
+  });
+
   test("IDENTITY.md change triggers onConversationEvict", async () => {
     watcher.start(onConversationEvict);
     simulateFileChange(WORKSPACE_DIR, "IDENTITY.md");
@@ -238,6 +256,16 @@ describe("ConfigWatcher workspace file handlers", () => {
     expect(evictCallCount).toBe(1);
   });
 
+  test("IDENTITY.md change triggers onIdentityChanged", async () => {
+    let identityCallCount = 0;
+    watcher.start(onConversationEvict, () => {
+      identityCallCount += 1;
+    });
+    simulateFileChange(WORKSPACE_DIR, "IDENTITY.md");
+    await new Promise((r) => setTimeout(r, WAIT_MS));
+    expect(identityCallCount).toBe(1);
+  });
+
   test("UPDATES.md is not subscribed (only the registered handler set is)", () => {
     watcher.start(onConversationEvict);
     // Per-file watching only registers config.json, SOUL.md, IDENTITY.md.

package/src/__tests__/context-search-agent-runner.test.ts

@@ -699,7 +699,10 @@ describe("runAgenticRecall", () => {
       citationIds: ["workspace:more"],
       unresolved: ["The original seed only named the topic."],
     });
-    const finalTools = providerCalls[1]?.[1] as Array<{ name: string }>;
+    const finalOptions = providerCalls[1]?.[1] as {
+      tools?: Array<{ name: string }>;
+    };
+    const finalTools = finalOptions?.tools as Array<{ name: string }>;
     expect(finalTools.map((tool) => tool.name)).toEqual(["finish_recall"]);
     expect(result.evidence.map((item) => item.id)).toEqual(["workspace:more"]);
     expect(result.content).toBe(
@@ -876,7 +879,7 @@ describe("runAgenticRecall", () => {
 
     expect(getConfiguredProviderCallSites).toEqual(["recall"]);
     expect(providerCalls).toHaveLength(1);
-    const options = providerCalls[0]?.[3] as {
+    const options = providerCalls[0]?.[1] as {
       config?: Record<string, unknown>;
     };
     expect(options.config).toEqual({
@@ -928,7 +931,7 @@ describe("runAgenticRecall", () => {
     );
 
     expect(providerCalls).toHaveLength(2);
-    const finalizeOptions = providerCalls[1]?.[3] as {
+    const finalizeOptions = providerCalls[1]?.[1] as {
       config?: Record<string, unknown>;
     };
     expect(finalizeOptions.config).toEqual({

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,

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);
+  });
+});