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

package/src/__tests__/channel-retry-sweep.test.ts

@@ -213,29 +213,27 @@ describe("channel-retry-sweep", () => {
           }
         | undefined;
 
-      await sweepFailedEvents(
-        async (conversationId, _content, _attachmentIds, options) => {
-          capturedOptions = options as {
-            trustContext?: {
-              trustClass?: string;
-              guardianPrincipalId?: string;
-            };
-            isInteractive?: boolean;
+      await sweepFailedEvents(async (conversationId, _content, options) => {
+        capturedOptions = options as {
+          trustContext?: {
+            trustClass?: string;
+            guardianPrincipalId?: string;
           };
-          const messageId = `message-${c.trustClass}`;
-          const db = getDb();
-          db.insert(messages)
-            .values({
-              id: messageId,
-              conversationId,
-              role: "user",
-              content: JSON.stringify([{ type: "text", text: "retry me" }]),
-              createdAt: Date.now(),
-            })
-            .run();
-          return { messageId };
-        },
-      );
+          isInteractive?: boolean;
+        };
+        const messageId = `message-${c.trustClass}`;
+        const db = getDb();
+        db.insert(messages)
+          .values({
+            id: messageId,
+            conversationId,
+            role: "user",
+            content: JSON.stringify([{ type: "text", text: "retry me" }]),
+            createdAt: Date.now(),
+          })
+          .run();
+        return { messageId };
+      });
 
       expect(capturedOptions?.trustContext?.trustClass).toBe(c.trustClass);
       expect(capturedOptions?.trustContext?.guardianPrincipalId).toBe(
@@ -263,23 +261,21 @@ describe("channel-retry-sweep", () => {
       const eventId = seedFailedEventWithActorRoleOnly(actorRole);
       let processMessageCalled = false;
 
-      await sweepFailedEvents(
-        async (conversationId, _content, _attachmentIds, _options) => {
-          processMessageCalled = true;
-          const messageId = `message-legacy-${actorRole}`;
-          const db = getDb();
-          db.insert(messages)
-            .values({
-              id: messageId,
-              conversationId,
-              role: "user",
-              content: JSON.stringify([{ type: "text", text: "retry me" }]),
-              createdAt: Date.now(),
-            })
-            .run();
-          return { messageId };
-        },
-      );
+      await sweepFailedEvents(async (conversationId, _content, _options) => {
+        processMessageCalled = true;
+        const messageId = `message-legacy-${actorRole}`;
+        const db = getDb();
+        db.insert(messages)
+          .values({
+            id: messageId,
+            conversationId,
+            role: "user",
+            content: JSON.stringify([{ type: "text", text: "retry me" }]),
+            createdAt: Date.now(),
+          })
+          .run();
+        return { messageId };
+      });
 
       // Legacy payloads with trustCtx that can't be parsed into canonical form
       // must be marked as failed to prevent privilege escalation — processMessage
@@ -301,23 +297,21 @@ describe("channel-retry-sweep", () => {
     const eventId = seedFailedEventWithTrustClass("invalid_value");
     let processMessageCalled = false;
 
-    await sweepFailedEvents(
-      async (conversationId, _content, _attachmentIds, _options) => {
-        processMessageCalled = true;
-        const messageId = "message-invalid";
-        const db = getDb();
-        db.insert(messages)
-          .values({
-            id: messageId,
-            conversationId,
-            role: "user",
-            content: JSON.stringify([{ type: "text", text: "retry me" }]),
-            createdAt: Date.now(),
-          })
-          .run();
-        return { messageId };
-      },
-    );
+    await sweepFailedEvents(async (conversationId, _content, _options) => {
+      processMessageCalled = true;
+      const messageId = "message-invalid";
+      const db = getDb();
+      db.insert(messages)
+        .values({
+          id: messageId,
+          conversationId,
+          role: "user",
+          content: JSON.stringify([{ type: "text", text: "retry me" }]),
+          createdAt: Date.now(),
+        })
+        .run();
+      return { messageId };
+    });
 
     // trustCtx was present but couldn't be parsed (invalid trustClass),
     // so the event must be failed rather than processed without trust context.
@@ -361,25 +355,23 @@ describe("channel-retry-sweep", () => {
         }
       | undefined;
 
-    await sweepFailedEvents(
-      async (conversationId, _content, _attachmentIds, options) => {
-        capturedOptions = options as {
-          trustContext?: { trustClass?: string; sourceChannel?: string };
-          isInteractive?: boolean;
-        };
-        const messageId = "message-no-ctx";
-        db.insert(messages)
-          .values({
-            id: messageId,
-            conversationId,
-            role: "user",
-            content: JSON.stringify([{ type: "text", text: "retry me" }]),
-            createdAt: Date.now(),
-          })
-          .run();
-        return { messageId };
-      },
-    );
+    await sweepFailedEvents(async (conversationId, _content, options) => {
+      capturedOptions = options as {
+        trustContext?: { trustClass?: string; sourceChannel?: string };
+        isInteractive?: boolean;
+      };
+      const messageId = "message-no-ctx";
+      db.insert(messages)
+        .values({
+          id: messageId,
+          conversationId,
+          role: "user",
+          content: JSON.stringify([{ type: "text", text: "retry me" }]),
+          createdAt: Date.now(),
+        })
+        .run();
+      return { messageId };
+    });
 
     // When trustCtx is absent, the sweep synthesizes an explicit 'unknown'
     // trust context to prevent downstream defaults from granting guardian trust.
@@ -421,7 +413,7 @@ describe("channel-retry-sweep", () => {
     };
 
     let processMessageCalls = 0;
-    await sweepFailedEvents(async (conversationId, _content, _ids, options) => {
+    await sweepFailedEvents(async (conversationId, _content, options) => {
       processMessageCalls++;
       options?.onEvent?.({
         type: "message_complete",
@@ -487,7 +479,7 @@ describe("channel-retry-sweep", () => {
       .where(eq(channelInboundEvents.id, inbound.eventId))
       .run();
 
-    await sweepFailedEvents(async (conversationId, _content, _ids, options) => {
+    await sweepFailedEvents(async (conversationId, _content, options) => {
       options?.onEvent?.({
         type: "assistant_text_delta",
         text: "Already delivered live response.",
@@ -590,7 +582,7 @@ describe("channel-retry-sweep", () => {
       ts: "1700000000.000044",
     });
 
-    await sweepFailedEvents(async (conversationId, _content, _ids, options) => {
+    await sweepFailedEvents(async (conversationId, _content, options) => {
       options?.onEvent?.({
         type: "assistant_text_delta",
         text: "Live retry response.",
@@ -686,7 +678,7 @@ describe("channel-retry-sweep", () => {
       throw new Error("fetch failed before progress callback");
     };
 
-    await sweepFailedEvents(async (conversationId, _content, _ids, options) => {
+    await sweepFailedEvents(async (conversationId, _content, options) => {
       options?.onEvent?.({
         type: "assistant_text_delta",
         text: "Live retry response.",

package/src/__tests__/clawhub-files.test.ts

@@ -291,6 +291,7 @@ describe("toSlimSkill", () => {
     expect(slim!.kind).toBe("catalog");
     expect(slim!.status).toBe("available");
     expect(slim!.origin).toBe("clawhub");
+    expect(slim!.category).toBe("integrations");
 
     // Clawhub-specific fields
     const clawhub = slim as unknown as Record<string, unknown>;

package/src/__tests__/compaction-circuit.test.ts

@@ -0,0 +1,258 @@
+/**
+ * Tests for the `CompactionCircuit` class.
+ *
+ * The breaker logic lives as direct methods on the per-conversation
+ * `CompactionCircuit` state container (`agent/compaction-circuit.ts`). These
+ * tests assert the threshold (3 consecutive failures) and cooldown (1 hour)
+ * exactly match the user-visible behavior:
+ *   (a) counter increments on each failure outcome
+ *   (b) circuit opens after exactly 3 consecutive failures
+ *   (c) successful compaction resets counter and clears the circuit
+ *   (d) isOpen() reflects state and cooldown expiry
+ *   (e) circuit re-opens after cooldown expiry when 3 more failures
+ *       accumulate (guards the stale-timestamp regression)
+ *   (f) isOpen() is query-only and never mutates the counter
+ *   (g) open→closed transition emits `compaction_circuit_closed` exactly once
+ *   (h) closed→closed transition emits nothing
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  COMPACTION_CIRCUIT_COOLDOWN_MS,
+  COMPACTION_CIRCUIT_FAILURE_THRESHOLD,
+  CompactionCircuit,
+} from "../agent/compaction-circuit.js";
+import type { CompactionCircuitEvent } from "../plugins/types.js";
+
+// ─── Fixtures ───────────────────────────────────────────────────────────────
+
+const CONVERSATION_ID = "conv-breaker-test";
+
+function collectEvents(): {
+  events: CompactionCircuitEvent[];
+  onEvent: (msg: CompactionCircuitEvent) => void;
+} {
+  const events: CompactionCircuitEvent[] = [];
+  return { events, onEvent: (msg) => events.push(msg) };
+}
+
+describe("CompactionCircuit", () => {
+  let originalDateNow: () => number;
+
+  beforeEach(() => {
+    originalDateNow = Date.now;
+  });
+
+  afterEach(() => {
+    Date.now = originalDateNow;
+  });
+
+  test("threshold and cooldown constants match the user-visible contract", () => {
+    expect(COMPACTION_CIRCUIT_FAILURE_THRESHOLD).toBe(3);
+    expect(COMPACTION_CIRCUIT_COOLDOWN_MS).toBe(60 * 60 * 1000);
+  });
+
+  test("(a) counter increments on each failure outcome", async () => {
+    const circuit = new CompactionCircuit(CONVERSATION_ID);
+    const { onEvent, events } = collectEvents();
+
+    await circuit.recordOutcome(true, onEvent);
+    expect(circuit.consecutiveCompactionFailures).toBe(1);
+    expect(circuit.compactionCircuitOpenUntil).toBeNull();
+    expect(events).toHaveLength(0);
+
+    await circuit.recordOutcome(true, onEvent);
+    expect(circuit.consecutiveCompactionFailures).toBe(2);
+    expect(circuit.compactionCircuitOpenUntil).toBeNull();
+    expect(events).toHaveLength(0);
+  });
+
+  test("(b) circuit opens after exactly 3 consecutive failures", async () => {
+    const fixedNow = 1_700_000_000_000;
+    Date.now = () => fixedNow;
+
+    const circuit = new CompactionCircuit(CONVERSATION_ID);
+    const { onEvent, events } = collectEvents();
+
+    await circuit.recordOutcome(true, onEvent);
+    await circuit.recordOutcome(true, onEvent);
+    // Two failures — circuit still closed.
+    expect(circuit.compactionCircuitOpenUntil).toBeNull();
+    expect(events).toHaveLength(0);
+
+    await circuit.recordOutcome(true, onEvent);
+    // Third failure — circuit trips and fires the event exactly once.
+    expect(circuit.consecutiveCompactionFailures).toBe(3);
+    expect(circuit.compactionCircuitOpenUntil).toBe(fixedNow + 60 * 60 * 1000);
+    expect(await circuit.isOpen()).toBe(true);
+    expect(events).toHaveLength(1);
+    expect(events[0]).toEqual({
+      type: "compaction_circuit_open",
+      conversationId: CONVERSATION_ID,
+      reason: "3_consecutive_failures",
+      openUntil: fixedNow + 60 * 60 * 1000,
+    });
+
+    // Further failures do not re-fire the event while the circuit is open.
+    await circuit.recordOutcome(true, onEvent);
+    expect(circuit.consecutiveCompactionFailures).toBe(4);
+    expect(events).toHaveLength(1);
+  });
+
+  test("(c) successful outcome resets counter and clears circuit", async () => {
+    const fixedNow = 1_700_000_000_000;
+    Date.now = () => fixedNow;
+
+    const circuit = new CompactionCircuit(CONVERSATION_ID);
+    const { onEvent } = collectEvents();
+
+    // Trip the breaker.
+    await circuit.recordOutcome(true, onEvent);
+    await circuit.recordOutcome(true, onEvent);
+    await circuit.recordOutcome(true, onEvent);
+    expect(circuit.compactionCircuitOpenUntil).not.toBeNull();
+
+    // Success resets state.
+    await circuit.recordOutcome(false, onEvent);
+    expect(circuit.consecutiveCompactionFailures).toBe(0);
+    expect(circuit.compactionCircuitOpenUntil).toBeNull();
+  });
+
+  test("(d) isOpen() reflects state and expiry", async () => {
+    const fixedNow = 1_700_000_000_000;
+    Date.now = () => fixedNow;
+
+    const circuit = new CompactionCircuit(CONVERSATION_ID);
+    const { onEvent } = collectEvents();
+
+    // Fresh state: closed.
+    expect(await circuit.isOpen()).toBe(false);
+
+    // Trip the breaker.
+    await circuit.recordOutcome(true, onEvent);
+    await circuit.recordOutcome(true, onEvent);
+    await circuit.recordOutcome(true, onEvent);
+
+    // While open.
+    expect(await circuit.isOpen()).toBe(true);
+
+    // After cooldown expires the breaker reports closed again, even without
+    // an explicit reset — the open-until timestamp is the only source of
+    // truth for the gate.
+    Date.now = () => fixedNow + 60 * 60 * 1000 + 1;
+    expect(await circuit.isOpen()).toBe(false);
+  });
+
+  test("(e) circuit re-opens after cooldown expiry when 3 more failures accumulate", async () => {
+    // Regression: opening the breaker a second time must not require
+    // `compactionCircuitOpenUntil === null`. Once a cooldown expires, the
+    // gate correctly reports "closed" but a stale past-timestamp stays on the
+    // state, so the next 3-strike window must still trip a new cooldown. Any
+    // expired timestamp is treated the same as null.
+    const t0 = 1_700_000_000_000;
+    Date.now = () => t0;
+
+    const circuit = new CompactionCircuit(CONVERSATION_ID);
+    const { onEvent, events } = collectEvents();
+
+    // Trip the breaker the first time.
+    await circuit.recordOutcome(true, onEvent);
+    await circuit.recordOutcome(true, onEvent);
+    await circuit.recordOutcome(true, onEvent);
+    expect(circuit.compactionCircuitOpenUntil).toBe(t0 + 60 * 60 * 1000);
+    expect(events).toHaveLength(1);
+
+    // Advance past the cooldown window. Reset the counter — in production this
+    // happens when a subsequent `maybeCompact` call succeeds after the
+    // cooldown elapses, but the bug manifests even when the counter is reset:
+    // the stale `compactionCircuitOpenUntil` is what breaks re-opening.
+    const t1 = t0 + 60 * 60 * 1000 + 1;
+    Date.now = () => t1;
+    expect(await circuit.isOpen()).toBe(false);
+    circuit.consecutiveCompactionFailures = 0;
+    // `compactionCircuitOpenUntil` is deliberately left as the old timestamp
+    // to reproduce the bug condition.
+    expect(circuit.compactionCircuitOpenUntil).toBe(t0 + 60 * 60 * 1000);
+
+    // Three more failures must trip a fresh cooldown even though the old
+    // timestamp is still set.
+    await circuit.recordOutcome(true, onEvent);
+    await circuit.recordOutcome(true, onEvent);
+    await circuit.recordOutcome(true, onEvent);
+    expect(circuit.consecutiveCompactionFailures).toBe(3);
+    expect(circuit.compactionCircuitOpenUntil).toBe(t1 + 60 * 60 * 1000);
+    expect(events).toHaveLength(2);
+    expect(events[1]).toEqual({
+      type: "compaction_circuit_open",
+      conversationId: CONVERSATION_ID,
+      reason: "3_consecutive_failures",
+      openUntil: t1 + 60 * 60 * 1000,
+    });
+  });
+
+  test("(f) isOpen() is query-only and never mutates the counter", async () => {
+    // `maybeCompact()` early-return paths skip `recordOutcome` entirely and
+    // only gate on `isOpen()`. The query must never touch the 3-strike
+    // counter so those early returns can't silently reset it.
+    const circuit = new CompactionCircuit(CONVERSATION_ID);
+    const { onEvent } = collectEvents();
+
+    await circuit.recordOutcome(true, onEvent);
+    await circuit.recordOutcome(true, onEvent);
+    expect(circuit.consecutiveCompactionFailures).toBe(2);
+
+    // Query-only — must NOT touch the counter.
+    expect(await circuit.isOpen()).toBe(false);
+    expect(circuit.consecutiveCompactionFailures).toBe(2);
+
+    // A third real failure then trips the breaker as expected.
+    await circuit.recordOutcome(true, onEvent);
+    expect(circuit.consecutiveCompactionFailures).toBe(3);
+    expect(circuit.compactionCircuitOpenUntil).not.toBeNull();
+  });
+
+  test("(g) open→closed transition emits compaction_circuit_closed exactly once", async () => {
+    // Regression: the reset branch must notify the client on open→closed.
+    // Otherwise the Swift banner set from `compaction_circuit_open` stays
+    // visible until the original `openUntil` deadline (up to 1h),
+    // misrepresenting the live state.
+    const fixedNow = 1_700_000_000_000;
+    Date.now = () => fixedNow;
+
+    const circuit = new CompactionCircuit(CONVERSATION_ID);
+    const { onEvent, events } = collectEvents();
+
+    // Force the circuit into the open state directly — the emitted-event
+    // transition logic is what we're testing, not the tripping path.
+    circuit.compactionCircuitOpenUntil = fixedNow + 60 * 60 * 1000;
+    circuit.consecutiveCompactionFailures = 3;
+
+    await circuit.recordOutcome(false, onEvent);
+
+    expect(circuit.consecutiveCompactionFailures).toBe(0);
+    expect(circuit.compactionCircuitOpenUntil).toBeNull();
+    expect(events).toHaveLength(1);
+    expect(events[0]).toEqual({
+      type: "compaction_circuit_closed",
+      conversationId: CONVERSATION_ID,
+    });
+  });
+
+  test("(h) successful outcome against an already-closed circuit emits no event", async () => {
+    // Emitting `compaction_circuit_closed` on every successful compaction
+    // would spam the client (the breaker is closed in the common case).
+    // Only the open→closed transition is meaningful.
+    const circuit = new CompactionCircuit(CONVERSATION_ID);
+    const { onEvent, events } = collectEvents();
+
+    expect(circuit.compactionCircuitOpenUntil).toBeNull();
+    await circuit.recordOutcome(false, onEvent);
+    expect(circuit.compactionCircuitOpenUntil).toBeNull();
+    expect(events).toHaveLength(0);
+
+    // A second successful outcome while still closed — still no event.
+    await circuit.recordOutcome(false, onEvent);
+    expect(events).toHaveLength(0);
+  });
+});

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

@@ -10,12 +10,8 @@
  */
 import { describe, expect, mock, test } from "bun:test";
 
-import type {
-  AgentEvent,
-  AgentLoopConfig,
-  CheckpointDecision,
-  CheckpointInfo,
-} from "../agent/loop.js";
+import { CompactionCircuit } from "../agent/compaction-circuit.js";
+import type { AgentEvent } from "../agent/loop.js";
 import type { ContextWindowResult } from "../context/window-manager.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
@@ -221,11 +217,8 @@ mock.module("../memory/auto-analysis-enqueue.js", () => ({
 
 mock.module("../agent/loop.js", () => ({
   AgentLoop: class {
-    constructor(
-      _provider: unknown,
-      _systemPrompt: string,
-      _config?: Partial<AgentLoopConfig>,
-    ) {}
+    compactionCircuit = new CompactionCircuit("test-conv");
+    constructor() {}
     getToolTokenBudget() {
       return 0;
     }
@@ -238,11 +231,6 @@ mock.module("../agent/loop.js", () => ({
     async run(
       _messages: Message[],
       _onEvent: (event: AgentEvent) => void,
-      _signal?: AbortSignal,
-      _requestId?: string,
-      _onCheckpoint?: (
-        checkpoint: CheckpointInfo,
-      ) => CheckpointDecision | Promise<CheckpointDecision>,
     ): Promise<Message[]> {
       return [];
     }
@@ -301,11 +289,11 @@ function makeConversation(
     id,
     makeProvider(),
     "system prompt",
-    4096,
     (msg) => {
       collected.push(msg);
     },
     "/tmp",
+    { maxTokens: 4096 },
   );
 }