@vellumai/assistant 0.8.8 → 0.8.9-staging.1

package/src/__tests__/agent-loop-exit-reason.test.ts

@@ -13,17 +13,17 @@
  * Sites not exercised here (`aborted_via_error`) require deeper provider
  * fakery and are best covered by integration tests.
  */
-import { describe, expect, spyOn, test } from "bun:test";
+import { describe, expect, mock, test } from "bun:test";
 
 import type {
   AgentEvent,
+  AgentLoopRunOptions,
   CheckpointDecision,
   CheckpointInfo,
-  MidLoopCompaction,
 } from "../agent/loop.js";
 import { AgentLoop, isMaxTokensStopReason } from "../agent/loop.js";
-import type { TurnContext } from "../plugins/types.js";
-import { PluginTimeoutError } from "../plugins/types.js";
+import type { TrustContext } from "../daemon/trust-context.js";
+import type { PostCompactContext } from "../plugins/defaults/memory-retrieval/hooks/post-compact.js";
 import type {
   Message,
   Provider,
@@ -32,6 +32,23 @@ import type {
   ToolDefinition,
 } from "../providers/types.js";
 
+// The agent loop invokes the default post-compaction re-injection hook directly
+// when it compacts in place. Stub it so these unit tests can drive the
+// re-injection result without the daemon-level injector chain. Tests assign
+// `postCompactImpl` to observe the call or force a failure; when unset
+// the hook is a no-op that returns the history it was handed.
+let postCompactImpl:
+  | ((input: PostCompactContext) => Promise<Message[]>)
+  | null = null;
+mock.module(
+  "../plugins/defaults/memory-retrieval/hooks/post-compact.js",
+  () => ({
+    default: async (input: PostCompactContext) => ({
+      messages: postCompactImpl ? await postCompactImpl(input) : input.history,
+    }),
+  }),
+);
+
 // ---------------------------------------------------------------------------
 // Helpers (mirrored from agent-loop.test.ts so this file is self-contained)
 // ---------------------------------------------------------------------------
@@ -101,38 +118,20 @@ const userMessage: Message = {
   content: [{ type: "text", text: "Hello" }],
 };
 
-// A turn context whose `contextWindowManager.maybeCompact` returns a canned
-// result, so the loop's native compaction pipeline runs without the real
-// orchestrator machinery.
-function fakeCompactionTurnContext(result: {
-  compacted: boolean;
-  exhausted: boolean;
-}): TurnContext {
+// A trust snapshot plus a context-window manager whose `maybeCompact` returns a
+// canned result, so the loop's compaction call runs without the real
+// orchestrator machinery. Both are supplied to the loop as dedicated run
+// options.
+function fakeCompaction(result: { compacted: boolean; exhausted: boolean }): {
+  trust: TrustContext;
+  contextWindowManager: AgentLoopRunOptions["contextWindowManager"];
+} {
   return {
-    requestId: "req-compact",
-    conversationId: "conv-compact",
-    turnIndex: 0,
     trust: { sourceChannel: "vellum", trustClass: "unknown" },
     contextWindowManager: {
       maybeCompact: async () => result,
-    },
-  } as unknown as TurnContext;
-}
-
-// A turn context whose compaction call times out, exercising the loop's
-// PluginTimeoutError handling.
-function timeoutCompactionTurnContext(): TurnContext {
-  return {
-    requestId: "req-compact",
-    conversationId: "conv-compact",
-    turnIndex: 0,
-    trust: { sourceChannel: "vellum", trustClass: "unknown" },
-    contextWindowManager: {
-      maybeCompact: async () => {
-        throw new PluginTimeoutError("compaction", "default-compaction", 1);
-      },
-    },
-  } as unknown as TurnContext;
+    } as unknown as AgentLoopRunOptions["contextWindowManager"],
+  };
 }
 
 function lastExitEvent(
@@ -164,11 +163,19 @@ describe("AgentLoop exit-reason instrumentation", () => {
 
   test("emits exit event exactly once with 'no_tool_calls' on plain text response", async () => {
     const { provider } = createMockProvider([textResponse("Hi there!")]);
-    const loop = new AgentLoop(provider, "system prompt");
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system prompt",
+      conversationId: "test-conversation",
+    });
 
     const events: AgentEvent[] = [];
-    await loop.run([userMessage], (e) => {
-      events.push(e);
+    await loop.run({
+      messages: [userMessage],
+      onEvent: (e) => {
+        events.push(e);
+      },
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
     });
 
     expect(countExitEvents(events)).toBe(1);
@@ -178,11 +185,19 @@ describe("AgentLoop exit-reason instrumentation", () => {
 
   test("agent_loop_exit is the last event emitted", async () => {
     const { provider } = createMockProvider([textResponse("Hi there!")]);
-    const loop = new AgentLoop(provider, "system prompt");
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system prompt",
+      conversationId: "test-conversation",
+    });
 
     const events: AgentEvent[] = [];
-    await loop.run([userMessage], (e) => {
-      events.push(e);
+    await loop.run({
+      messages: [userMessage],
+      onEvent: (e) => {
+        events.push(e);
+      },
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
     });
 
     expect(events.length).toBeGreaterThan(0);
@@ -193,11 +208,19 @@ describe("AgentLoop exit-reason instrumentation", () => {
     const { provider } = createMockProvider([
       maxTokensResponse("Partial answer"),
     ]);
-    const loop = new AgentLoop(provider, "system prompt");
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system prompt",
+      conversationId: "test-conversation",
+    });
 
     const events: AgentEvent[] = [];
-    await loop.run([userMessage], (e) => {
-      events.push(e);
+    await loop.run({
+      messages: [userMessage],
+      onEvent: (e) => {
+        events.push(e);
+      },
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
     });
 
     expect(events.map((e) => e.type)).toEqual([
@@ -228,13 +251,20 @@ describe("AgentLoop exit-reason instrumentation", () => {
         stopReason: "max_tokens",
       },
     ]);
-    const loop = new AgentLoop(provider, "system prompt", {
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system prompt",
+      conversationId: "test-conversation",
       tools: dummyTools,
     });
 
     const events: AgentEvent[] = [];
-    const { history: result } = await loop.run([userMessage], (e) => {
-      events.push(e);
+    const { history: result } = await loop.run({
+      messages: [userMessage],
+      onEvent: (e) => {
+        events.push(e);
+      },
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
     });
 
     expect(events.some((e) => e.type === "tool_use")).toBe(false);
@@ -246,19 +276,24 @@ describe("AgentLoop exit-reason instrumentation", () => {
 
   test("emits 'aborted_pre_call' when signal is already aborted at run start", async () => {
     const { provider } = createMockProvider([textResponse("never sent")]);
-    const loop = new AgentLoop(provider, "system prompt");
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system prompt",
+      conversationId: "test-conversation",
+    });
 
     const controller = new AbortController();
     controller.abort();
 
     const events: AgentEvent[] = [];
-    await loop.run(
-      [userMessage],
-      (e) => {
+    await loop.run({
+      messages: [userMessage],
+      onEvent: (e) => {
         events.push(e);
       },
-      { signal: controller.signal },
-    );
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+      signal: controller.signal,
+    });
 
     expect(countExitEvents(events)).toBe(1);
     expect(lastExitEvent(events)?.reason).toBe("aborted_pre_call");
@@ -273,14 +308,21 @@ describe("AgentLoop exit-reason instrumentation", () => {
       isError: false,
       yieldToUser: true,
     });
-    const loop = new AgentLoop(provider, "system", {
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
       tools: dummyTools,
       toolExecutor: toolExecutor,
     });
 
     const events: AgentEvent[] = [];
-    await loop.run([userMessage], (e) => {
-      events.push(e);
+    await loop.run({
+      messages: [userMessage],
+      onEvent: (e) => {
+        events.push(e);
+      },
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
     });
 
     expect(countExitEvents(events)).toBe(1);
@@ -293,7 +335,10 @@ describe("AgentLoop exit-reason instrumentation", () => {
       textResponse("never reached"),
     ]);
     const toolExecutor = async () => ({ content: "ok", isError: false });
-    const loop = new AgentLoop(provider, "system", {
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
       tools: dummyTools,
       toolExecutor: toolExecutor,
     });
@@ -302,13 +347,14 @@ describe("AgentLoop exit-reason instrumentation", () => {
       "budget";
 
     const events: AgentEvent[] = [];
-    await loop.run(
-      [userMessage],
-      (e) => {
+    await loop.run({
+      messages: [userMessage],
+      onEvent: (e) => {
         events.push(e);
       },
-      { onCheckpoint },
-    );
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+      onCheckpoint,
+    });
 
     expect(countExitEvents(events)).toBe(0);
   });
@@ -321,7 +367,10 @@ describe("AgentLoop exit-reason instrumentation", () => {
       textResponse("never reached"),
     ]);
     const toolExecutor = async () => ({ content: "ok", isError: false });
-    const loop = new AgentLoop(provider, "system", {
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
       tools: dummyTools,
       toolExecutor: toolExecutor,
     });
@@ -329,7 +378,10 @@ describe("AgentLoop exit-reason instrumentation", () => {
     // AND an effective context window so small that any real token estimate
     // of the running history exceeds the mid-loop threshold.
     // WHEN the loop checkpoints after the tool results land
-    const result = await loop.run([userMessage], () => {}, {
+    const result = await loop.run({
+      messages: [userMessage],
+      onEvent: () => {},
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
       resolveContextWindow: () => ({
         maxInputTokens: 10,
         overflowRecovery: { enabled: true, safetyMarginRatio: 0 },
@@ -348,13 +400,19 @@ describe("AgentLoop exit-reason instrumentation", () => {
       textResponse("done"),
     ]);
     const toolExecutor = async () => ({ content: "ok", isError: false });
-    const loop = new AgentLoop(provider, "system", {
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
       tools: dummyTools,
       toolExecutor: toolExecutor,
     });
 
     // WHEN the loop runs to completion
-    const result = await loop.run([userMessage], () => {}, {
+    const result = await loop.run({
+      messages: [userMessage],
+      onEvent: () => {},
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
       resolveContextWindow: () => ({
         maxInputTokens: 10,
         overflowRecovery: { enabled: false, safetyMarginRatio: 0 },
@@ -373,38 +431,37 @@ describe("AgentLoop exit-reason instrumentation", () => {
       textResponse("done after compaction"),
     ]);
     const toolExecutor = async () => ({ content: "ok", isError: false });
-    const loop = new AgentLoop(provider, "system", {
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
       tools: dummyTools,
       toolExecutor: toolExecutor,
     });
 
     let reinjected = false;
     const events: AgentEvent[] = [];
-    const compaction: MidLoopCompaction = {
-      postCompactionHook: async () => {
-        reinjected = true;
-        return [userMessage];
-      },
+    postCompactImpl = async () => {
+      reinjected = true;
+      return [userMessage];
     };
 
     // WHEN the in-loop budget gate trips at the checkpoint
-    const result = await loop.run(
-      [userMessage],
-      (event) => {
+    const result = await loop.run({
+      messages: [userMessage],
+      onEvent: (event) => {
         events.push(event);
       },
-      {
-        resolveContextWindow: () => ({
-          maxInputTokens: 10,
-          overflowRecovery: { enabled: true, safetyMarginRatio: 0 },
-        }),
-        compaction,
-        turnContext: fakeCompactionTurnContext({
-          compacted: true,
-          exhausted: false,
-        }),
-      },
-    );
+      resolveContextWindow: () => ({
+        maxInputTokens: 10,
+        overflowRecovery: { enabled: true, safetyMarginRatio: 0 },
+      }),
+      compactInPlace: true,
+      ...fakeCompaction({
+        compacted: true,
+        exhausted: false,
+      }),
+    });
 
     // THEN the loop runs the compaction ceremony in place and continues to a
     // clean exit instead of yielding for budget. The durable commit is
@@ -416,67 +473,36 @@ describe("AgentLoop exit-reason instrumentation", () => {
     expect(result.exitReason).not.toBe("budget");
   });
 
-  test("yields 'budget' when inline compaction times out", async () => {
-    const { provider } = createMockProvider([
-      toolUseResponse("t1", "read_file", { path: "/a.txt" }),
-      textResponse("never reached"),
-    ]);
-    const toolExecutor = async () => ({ content: "ok", isError: false });
-    const loop = new AgentLoop(provider, "system", {
-      tools: dummyTools,
-      toolExecutor: toolExecutor,
-    });
-
-    const compaction: MidLoopCompaction = {
-      postCompactionHook: async () => {
-        throw new Error("postCompactionHook must not run after a timeout");
-      },
-    };
-    const recordOutcomeSpy = spyOn(loop.compactionCircuit, "recordOutcome");
-
-    // WHEN the compaction pipeline throws a PluginTimeoutError
-    const result = await loop.run([userMessage], () => {}, {
-      resolveContextWindow: () => ({
-        maxInputTokens: 10,
-        overflowRecovery: { enabled: true, safetyMarginRatio: 0 },
-      }),
-      compaction,
-      turnContext: timeoutCompactionTurnContext(),
-    });
-
-    // THEN the loop records the timeout as a compaction failure against its
-    // own circuit breaker, and yields for budget so the orchestrator can
-    // escalate.
-    expect(recordOutcomeSpy).toHaveBeenCalledTimes(1);
-    expect(recordOutcomeSpy.mock.calls[0]?.[1]).toBe(true);
-    expect(result.exitReason).toBe("budget");
-  });
-
   test("yields 'budget' when inline compaction reports exhausted", async () => {
     const { provider } = createMockProvider([
       toolUseResponse("t1", "read_file", { path: "/a.txt" }),
       textResponse("never reached"),
     ]);
     const toolExecutor = async () => ({ content: "ok", isError: false });
-    const loop = new AgentLoop(provider, "system", {
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
       tools: dummyTools,
       toolExecutor: toolExecutor,
     });
 
-    const compaction: MidLoopCompaction = {
-      postCompactionHook: async () => {
-        throw new Error("postCompactionHook must not run when exhausted");
-      },
+    postCompactImpl = async () => {
+      throw new Error(
+        "post-compaction re-injection must not run when exhausted",
+      );
     };
 
     // WHEN compaction exhausts its retry budget
-    const result = await loop.run([userMessage], () => {}, {
+    const result = await loop.run({
+      messages: [userMessage],
+      onEvent: () => {},
       resolveContextWindow: () => ({
         maxInputTokens: 10,
         overflowRecovery: { enabled: true, safetyMarginRatio: 0 },
       }),
-      compaction,
-      turnContext: fakeCompactionTurnContext({
+      compactInPlace: true,
+      ...fakeCompaction({
         compacted: false,
         exhausted: true,
       }),
@@ -493,11 +519,19 @@ describe("AgentLoop exit-reason instrumentation", () => {
         throw new Error("provider exploded");
       },
     };
-    const loop = new AgentLoop(provider, "system prompt");
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system prompt",
+      conversationId: "test-conversation",
+    });
 
     const events: AgentEvent[] = [];
-    await loop.run([userMessage], (e) => {
-      events.push(e);
+    await loop.run({
+      messages: [userMessage],
+      onEvent: (e) => {
+        events.push(e);
+      },
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
     });
 
     expect(countExitEvents(events)).toBe(1);
@@ -516,14 +550,21 @@ describe("AgentLoop exit-reason instrumentation", () => {
       isError: false,
       yieldToUser: true,
     });
-    const loop = new AgentLoop(provider, "system", {
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
       tools: dummyTools,
       toolExecutor: toolExecutor,
     });
 
     const events: AgentEvent[] = [];
-    await loop.run([userMessage], (e) => {
-      events.push(e);
+    await loop.run({
+      messages: [userMessage],
+      onEvent: (e) => {
+        events.push(e);
+      },
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
     });
 
     expect(countExitEvents(events)).toBe(1);
@@ -540,19 +581,23 @@ describe("AgentLoop exit-reason instrumentation", () => {
       controller.abort();
       return { content: "ok", isError: false };
     };
-    const loop = new AgentLoop(provider, "system", {
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
       tools: dummyTools,
       toolExecutor: toolExecutor,
     });
 
     const events: AgentEvent[] = [];
-    await loop.run(
-      [userMessage],
-      (e) => {
+    await loop.run({
+      messages: [userMessage],
+      onEvent: (e) => {
         events.push(e);
       },
-      { signal: controller.signal },
-    );
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+      signal: controller.signal,
+    });
 
     expect(countExitEvents(events)).toBe(1);
     expect(lastExitEvent(events)?.reason).toBe("aborted_during_tools");

package/src/__tests__/agent-loop-mutable-latest-user-message.test.ts

@@ -1,16 +1,17 @@
 /**
- * Verifies that the per-turn `mutableLatestUserMessage` plumbed into
- * `AgentLoop.run()` surfaces on every `SendMessageOptions.config` the loop
- * emits — this is the memory-v3-live cache-anchor signal (the latest user
- * message carries a volatile `<memory>` block, so the provider must anchor its
- * long-TTL cache breakpoint on the most recent STABLE message instead).
+ * Verifies that the `memory-v3-live` cache-anchor signal surfaces on every
+ * `SendMessageOptions.config` the loop emits. When the flag is on, the latest
+ * user message carries a volatile `<memory>` block, so the loop sets
+ * `providerConfig.mutableLatestUserMessage` to tell the provider to anchor its
+ * long-TTL cache breakpoint on the most recent STABLE message instead.
  *
- * Default behavior (option unset) must remain unchanged — the field is omitted
- * from `providerConfig` rather than carrying `undefined`/`false`, so the wire
- * is byte-identical to today when the flag is off.
+ * The loop reads the flag directly where it assembles `providerConfig`, so the
+ * signal is sourced from the flag rather than a run option. When the flag is
+ * off the field is omitted (not `false`/`undefined`) so the wire stays
+ * byte-identical to today.
  */
 
-import { describe, expect, mock, test } from "bun:test";
+import { afterEach, describe, expect, mock, test } from "bun:test";
 
 import { makeMockLogger } from "./helpers/mock-logger.js";
 
@@ -19,6 +20,10 @@ mock.module("../util/logger.js", () => ({
 }));
 
 import { AgentLoop } from "../agent/loop.js";
+import {
+  clearCachedOverrides,
+  setCachedOverrides,
+} from "../config/feature-flag-cache.js";
 import type {
   Message,
   Provider,
@@ -75,13 +80,20 @@ function makeRecordingProvider(responses: ProviderResponse[]): {
   return { provider, configs: () => configs };
 }
 
-describe("AgentLoop.run — mutableLatestUserMessage plumbing", () => {
-  test("forwards mutableLatestUserMessage=true to providerConfig on every LLM call (multi-turn)", async () => {
+describe("AgentLoop.run — mutableLatestUserMessage from memory-v3-live", () => {
+  afterEach(() => {
+    clearCachedOverrides();
+  });
+
+  test("sets mutableLatestUserMessage on every LLM call when memory-v3-live is on (multi-turn)", async () => {
+    // GIVEN memory-v3-live is enabled
+    setCachedOverrides({ "memory-v3-live": true }, { fromGateway: true });
+
+    // AND a provider that records the config of each LLM call across a tool round-trip
     const { provider, configs } = makeRecordingProvider([
       toolUseResponse("t1", "echo", { value: "first" }),
       textResponse("done"),
     ]);
-
     const dummyTools: ToolDefinition[] = [
       {
         name: "echo",
@@ -92,50 +104,53 @@ describe("AgentLoop.run — mutableLatestUserMessage plumbing", () => {
         },
       },
     ];
-
-    const toolExecutor = async () => ({ content: "ok", isError: false });
-
-    const loop = new AgentLoop(provider, "system", {
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
       config: { maxTokens: 1024 },
       tools: dummyTools,
-      toolExecutor: toolExecutor,
+      toolExecutor: async () => ({ content: "ok", isError: false }),
     });
 
-    await loop.run([userMessage], () => {}, {
+    // WHEN the loop runs
+    await loop.run({
+      messages: [userMessage],
+      onEvent: () => {},
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
       callSite: "mainAgent",
-      mutableLatestUserMessage: true,
     });
 
-    // Two sends — initial + one tool round-trip. Every send carries the flag.
+    // THEN every send (initial + tool round-trip) carries the cache-anchor signal
     expect(configs()).toHaveLength(2);
     for (const cfg of configs()) {
       expect(cfg?.mutableLatestUserMessage).toBe(true);
     }
   });
 
-  test("omits mutableLatestUserMessage when unset (default behavior unchanged)", async () => {
-    const { provider, configs } = makeRecordingProvider([textResponse("hi")]);
-    const loop = new AgentLoop(provider, "system", {
-      config: { maxTokens: 1024 },
-    });
-
-    await loop.run([userMessage], () => {});
+  test("omits mutableLatestUserMessage when memory-v3-live is off (flag-off byte-identity)", async () => {
+    // GIVEN memory-v3-live is off (no override; registry default is false)
+    clearCachedOverrides();
 
-    expect(configs()).toHaveLength(1);
-    expect("mutableLatestUserMessage" in (configs()[0] ?? {})).toBe(false);
-  });
-
-  test("omits mutableLatestUserMessage when explicitly false (flag-off byte-identity)", async () => {
+    // AND a provider that records the config of each LLM call
     const { provider, configs } = makeRecordingProvider([textResponse("hi")]);
-    const loop = new AgentLoop(provider, "system", {
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
       config: { maxTokens: 1024 },
     });
 
-    await loop.run([userMessage], () => {}, {
+    // WHEN the loop runs
+    await loop.run({
+      messages: [userMessage],
+      onEvent: () => {},
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
       callSite: "mainAgent",
-      mutableLatestUserMessage: false,
     });
 
+    // THEN the field is omitted entirely, not carried as false/undefined
+    expect(configs()).toHaveLength(1);
     expect("mutableLatestUserMessage" in (configs()[0] ?? {})).toBe(false);
   });
 });