@vellumai/assistant 0.8.7-dev.202606052232.2ddc989 → 0.8.8

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

@@ -1,258 +0,0 @@
-/**
- * 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

@@ -1,132 +0,0 @@
-/**
- * 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__/conversations-import-system-filter.test.ts

@@ -1,101 +0,0 @@
-/**
- * Tests that the conversations import route never persists non-renderable
- * roles. The messages store is UI-facing (`ConversationMessage`), so an
- * imported export carrying agent-context `system` rows must land only its
- * `user`/`assistant` turns — the `system` rows are dropped, not persisted.
- */
-
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-    model: "test",
-    provider: "test",
-    memory: { enabled: false },
-    rateLimit: { maxRequestsPerMinute: 0 },
-  }),
-}));
-
-mock.module("../memory/indexer.js", () => ({
-  indexMessageNow: async () => {},
-}));
-
-import { getMessages } from "../memory/conversation-crud.js";
-import { getDb } from "../memory/db-connection.js";
-import { initializeDb } from "../memory/db-init.js";
-import { conversations, messages } from "../memory/schema.js";
-import { ROUTES } from "../runtime/routes/conversations-import-routes.js";
-import type { RouteHandlerArgs } from "../runtime/routes/types.js";
-
-initializeDb();
-
-function resetTables() {
-  const db = getDb();
-  db.run("DELETE FROM message_attachments");
-  db.run("DELETE FROM attachments");
-  db.run("DELETE FROM messages");
-  db.run("DELETE FROM conversation_keys");
-  db.run("DELETE FROM conversations");
-}
-
-const importHandler = ROUTES.find(
-  (r) => r.operationId === "conversations_import",
-)!.handler;
-
-describe("conversations import system-row filtering", () => {
-  beforeEach(resetTables);
-
-  test("imports renderable turns but drops system rows", async () => {
-    // GIVEN an export whose conversation sandwiches a system row between two
-    // renderable turns (e.g. agent-context scaffolding an export carried)
-    const body = {
-      conversations: [
-        {
-          sourceKey: "src-1",
-          title: "Imported chat",
-          messages: [
-            { role: "user", content: "first visible" },
-            { role: "system", content: "agent-context scaffolding" },
-            { role: "assistant", content: "second visible" },
-          ],
-        },
-      ],
-    };
-
-    // WHEN the conversation is imported
-    const result = (await importHandler({
-      body,
-    } as unknown as RouteHandlerArgs)) as {
-      ok: boolean;
-      imported: number;
-      messages: number;
-    };
-
-    // THEN the import succeeds and only counts the renderable turns
-    expect(result.ok).toBe(true);
-    expect(result.imported).toBe(1);
-    expect(result.messages).toBe(2);
-
-    // AND the persisted rows are exactly the user/assistant turns, never the
-    // system scaffolding
-    const db = getDb();
-    const conv = db.select().from(conversations).all()[0];
-    const rows = getMessages(conv.id);
-    expect(rows.map((m) => m.role)).toEqual(["user", "assistant"]);
-    expect(
-      db
-        .select()
-        .from(messages)
-        .all()
-        .some((m) => m.role === "system"),
-    ).toBe(false);
-  });
-});

package/src/acp/__tests__/agent-process.test.ts

@@ -1,161 +0,0 @@
-/**
- * Unit tests for AcpAgentProcess capability getters.
- *
- * The getters reflect the InitializeResponse captured during initialize();
- * before that resolves (or after kill()) they must report false. The
- * connection is stubbed directly so no child process is spawned.
- */
-
-import { describe, expect, test } from "bun:test";
-
-import type { InitializeResponse } from "@agentclientprotocol/sdk";
-
-import { AcpAgentProcess } from "../agent-process.js";
-
-function makeProcess(): AcpAgentProcess {
-  return new AcpAgentProcess(
-    "test-agent",
-    { command: "echo", args: [] },
-    () => {
-      throw new Error("client factory should not be called in this test");
-    },
-  );
-}
-
-/** Injects a stub connection whose initialize() resolves with `response`. */
-function stubConnection(
-  proc: AcpAgentProcess,
-  response: InitializeResponse,
-): void {
-  (
-    proc as unknown as {
-      connection: { initialize: () => Promise<InitializeResponse> };
-    }
-  ).connection = {
-    initialize: () => Promise.resolve(response),
-  };
-}
-
-describe("AcpAgentProcess capability getters", () => {
-  test("both getters return false before initialize() resolves", () => {
-    const proc = makeProcess();
-    expect(proc.supportsLoadSession).toBe(false);
-    expect(proc.supportsSessionResume).toBe(false);
-  });
-
-  test("supportsLoadSession reflects agentCapabilities.loadSession", async () => {
-    const proc = makeProcess();
-    stubConnection(proc, {
-      protocolVersion: 1,
-      agentCapabilities: { loadSession: true },
-    });
-
-    await proc.initialize();
-
-    expect(proc.supportsLoadSession).toBe(true);
-    expect(proc.supportsSessionResume).toBe(false);
-  });
-
-  test("supportsSessionResume reflects agentCapabilities.sessionCapabilities.resume", async () => {
-    const proc = makeProcess();
-    stubConnection(proc, {
-      protocolVersion: 1,
-      agentCapabilities: { sessionCapabilities: { resume: {} } },
-    });
-
-    await proc.initialize();
-
-    expect(proc.supportsSessionResume).toBe(true);
-    expect(proc.supportsLoadSession).toBe(false);
-  });
-
-  test("both getters return false when the agent advertises no capabilities", async () => {
-    const proc = makeProcess();
-    stubConnection(proc, { protocolVersion: 1 });
-
-    await proc.initialize();
-
-    expect(proc.supportsLoadSession).toBe(false);
-    expect(proc.supportsSessionResume).toBe(false);
-  });
-
-  test("kill() clears the captured initialize response", async () => {
-    const proc = makeProcess();
-    stubConnection(proc, {
-      protocolVersion: 1,
-      agentCapabilities: {
-        loadSession: true,
-        sessionCapabilities: { resume: {} },
-      },
-    });
-
-    await proc.initialize();
-    expect(proc.supportsLoadSession).toBe(true);
-    expect(proc.supportsSessionResume).toBe(true);
-
-    proc.kill();
-
-    expect(proc.supportsLoadSession).toBe(false);
-    expect(proc.supportsSessionResume).toBe(false);
-  });
-});
-
-describe("AcpAgentProcess loadSession/resumeSession", () => {
-  /** Injects a stub connection that records loadSession/resumeSession params. */
-  function stubSessionConnection(proc: AcpAgentProcess): {
-    loadCalls: unknown[];
-    resumeCalls: unknown[];
-  } {
-    const loadCalls: unknown[] = [];
-    const resumeCalls: unknown[] = [];
-    (proc as unknown as { connection: unknown }).connection = {
-      loadSession: (params: unknown) => {
-        loadCalls.push(params);
-        return Promise.resolve({});
-      },
-      resumeSession: (params: unknown) => {
-        resumeCalls.push(params);
-        return Promise.resolve({});
-      },
-    };
-    return { loadCalls, resumeCalls };
-  }
-
-  test("loadSession forwards { sessionId, cwd, mcpServers: [] } to the connection", async () => {
-    const proc = makeProcess();
-    const { loadCalls } = stubSessionConnection(proc);
-
-    await proc.loadSession("session-1", "/tmp/project");
-
-    expect(loadCalls).toEqual([
-      { sessionId: "session-1", cwd: "/tmp/project", mcpServers: [] },
-    ]);
-  });
-
-  test("resumeSession forwards { sessionId, cwd, mcpServers: [] } to the connection", async () => {
-    const proc = makeProcess();
-    const { resumeCalls } = stubSessionConnection(proc);
-
-    await proc.resumeSession("session-2", "/tmp/project");
-
-    expect(resumeCalls).toEqual([
-      { sessionId: "session-2", cwd: "/tmp/project", mcpServers: [] },
-    ]);
-  });
-
-  test("loadSession throws when the process is not spawned", async () => {
-    const proc = makeProcess();
-
-    await expect(proc.loadSession("session-1", "/tmp/project")).rejects.toThrow(
-      'ACP agent "test-agent" is not spawned',
-    );
-  });
-
-  test("resumeSession throws when the process is not spawned", async () => {
-    const proc = makeProcess();
-
-    await expect(
-      proc.resumeSession("session-1", "/tmp/project"),
-    ).rejects.toThrow('ACP agent "test-agent" is not spawned');
-  });
-});