@vellumai/assistant 0.8.6 → 0.8.7

package/src/__tests__/compaction-timeout-recovery.test.ts

@@ -5,8 +5,9 @@
  * `DEFAULT_TIMEOUTS.compaction`), the pipeline runner throws
  * `PluginTimeoutError`. The three compaction call sites in
  * `conversation-agent-loop.ts` (start-of-turn, mid-loop, emergency) catch
- * that error, invoke `trackCompactionOutcome(..., true, onEvent)` so the
- * circuit breaker records the failure, and degrade gracefully.
+ * that error, record the failure on the loop-held `CompactionCircuit`
+ * (`recordOutcome(turn, true, ...)`) so the circuit breaker counts it, and degrade
+ * gracefully.
  *
  * This file asserts the tight coupling between:
  *  (1) a `PluginTimeoutError`-driven failure and
@@ -21,13 +22,14 @@
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
-import { trackCompactionOutcome } from "../daemon/conversation-agent-loop.js";
+import {
+  type CircuitTurnInfo,
+  CompactionCircuit,
+} from "../agent/compaction-circuit.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { TrustContext } from "../daemon/trust-context.js";
-import {
-  COMPACTION_CIRCUIT_FAILURE_THRESHOLD,
-  defaultCircuitBreakerPlugin,
-} from "../plugins/defaults/circuit-breaker.js";
+import { COMPACTION_CIRCUIT_FAILURE_THRESHOLD } from "../plugins/defaults/circuit-breaker/middlewares/circuitBreaker.js";
+import { defaultCircuitBreakerPlugin } from "../plugins/defaults/circuit-breaker/register.js";
 import { DEFAULT_TIMEOUTS, runPipeline } from "../plugins/pipeline.js";
 import {
   getMiddlewaresFor,
@@ -44,27 +46,14 @@ import {
 
 // ─── Fixtures ───────────────────────────────────────────────────────────────
 
-interface FakeConversationCtx {
-  readonly conversationId: string;
-  consecutiveCompactionFailures: number;
-  compactionCircuitOpenUntil: number | null;
-  currentRequestId?: string;
-  currentTurnTrustContext?: TrustContext;
-  trustContext?: TrustContext;
-  turnCount: number;
+function makeCircuit(conversationId = "conv-timeout-test"): CompactionCircuit {
+  return new CompactionCircuit(conversationId);
 }
 
-function makeConversationCtx(
-  conversationId = "conv-timeout-test",
-): FakeConversationCtx {
-  return {
-    conversationId,
-    consecutiveCompactionFailures: 0,
-    compactionCircuitOpenUntil: null,
-    turnCount: 0,
-    trustContext: { sourceChannel: "vellum", trustClass: "guardian" },
-  };
-}
+const turn: CircuitTurnInfo = {
+  turnCount: 0,
+  trustContext: { sourceChannel: "vellum", trustClass: "guardian" },
+};
 
 const trust: TrustContext = {
   sourceChannel: "vellum",
@@ -130,34 +119,34 @@ describe("compaction timeout recovery (JARVIS-587)", () => {
     expect((caught as PluginTimeoutError).pipeline).toBe("compaction");
   });
 
-  test("trackCompactionOutcome(failed=true) driven by PluginTimeoutError trips the breaker at the 3rd strike", async () => {
+  test("recordOutcome(failed=true) driven by PluginTimeoutError trips the breaker at the 3rd strike", async () => {
     // Simulates the production sequence: each mid-loop compaction hits the
-    // pipeline's 30s ceiling, the orchestrator's catch block calls
-    // `trackCompactionOutcome(ctx, true, onEvent)`. After three such catches
+    // pipeline's 30s ceiling, the catch path calls
+    // `circuit.recordOutcome(turn, true, onEvent)`. After three such catches
     // the circuit breaker must be open — matching the same invariant the
     // existing breaker test file exercises for normal summary-LLM throws.
-    const ctx = makeConversationCtx();
+    const circuit = makeCircuit();
     const { onEvent, events } = collectEvents();
 
     // First two timeouts — circuit still closed.
-    await trackCompactionOutcome(ctx, true, onEvent);
-    await trackCompactionOutcome(ctx, true, onEvent);
-    expect(ctx.consecutiveCompactionFailures).toBe(2);
-    expect(ctx.compactionCircuitOpenUntil).toBeNull();
+    await circuit.recordOutcome(turn, true, onEvent);
+    await circuit.recordOutcome(turn, true, onEvent);
+    expect(circuit.consecutiveCompactionFailures).toBe(2);
+    expect(circuit.compactionCircuitOpenUntil).toBeNull();
     expect(events).toHaveLength(0);
 
     // Third timeout — breaker trips and emits the canonical transition event.
-    await trackCompactionOutcome(ctx, true, onEvent);
-    expect(ctx.consecutiveCompactionFailures).toBe(
+    await circuit.recordOutcome(turn, true, onEvent);
+    expect(circuit.consecutiveCompactionFailures).toBe(
       COMPACTION_CIRCUIT_FAILURE_THRESHOLD,
     );
-    expect(ctx.compactionCircuitOpenUntil).not.toBeNull();
+    expect(circuit.compactionCircuitOpenUntil).not.toBeNull();
     expect(events).toHaveLength(1);
     expect(events[0]).toEqual({
       type: "compaction_circuit_open",
-      conversationId: ctx.conversationId,
+      conversationId: circuit.conversationId,
       reason: "3_consecutive_failures",
-      openUntil: ctx.compactionCircuitOpenUntil as number,
+      openUntil: circuit.compactionCircuitOpenUntil as number,
     });
   });
 
@@ -165,19 +154,19 @@ describe("compaction timeout recovery (JARVIS-587)", () => {
     // The recovery path doesn't interfere with the breaker's normal reset —
     // once a compaction call eventually succeeds, the streak is broken and
     // the next failure starts counting from 1.
-    const ctx = makeConversationCtx();
+    const circuit = makeCircuit();
     const { onEvent } = collectEvents();
 
-    await trackCompactionOutcome(ctx, true, onEvent);
-    await trackCompactionOutcome(ctx, true, onEvent);
-    expect(ctx.consecutiveCompactionFailures).toBe(2);
+    await circuit.recordOutcome(turn, true, onEvent);
+    await circuit.recordOutcome(turn, true, onEvent);
+    expect(circuit.consecutiveCompactionFailures).toBe(2);
 
-    await trackCompactionOutcome(ctx, false, onEvent);
-    expect(ctx.consecutiveCompactionFailures).toBe(0);
-    expect(ctx.compactionCircuitOpenUntil).toBeNull();
+    await circuit.recordOutcome(turn, false, onEvent);
+    expect(circuit.consecutiveCompactionFailures).toBe(0);
+    expect(circuit.compactionCircuitOpenUntil).toBeNull();
 
-    await trackCompactionOutcome(ctx, true, onEvent);
-    expect(ctx.consecutiveCompactionFailures).toBe(1);
+    await circuit.recordOutcome(turn, true, onEvent);
+    expect(circuit.consecutiveCompactionFailures).toBe(1);
   });
 
   test("compaction call-site recovery remains defense-in-depth even when DEFAULT_TIMEOUTS.compaction is null", () => {

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__/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 invalidation", 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,