@vellumai/assistant 0.8.8 → 0.8.9-staging.2

package/src/__tests__/injector-v3-suppression.test.ts

@@ -110,7 +110,7 @@ describe("memory-v3-live v2 suppression", () => {
     ];
 
     const result = await applyRuntimeInjections(runMessages, {
-      turnContext: makeTurnContext(),
+      ...makeTurnContext(),
     });
 
     // Exactly one <memory> source across the WHOLE assembled context.
@@ -149,7 +149,7 @@ describe("memory-v3-live v2 suppression", () => {
     ];
 
     const result = await applyRuntimeInjections(runMessages, {
-      turnContext: makeTurnContext(),
+      ...makeTurnContext(),
     });
 
     // v2's block survives — the turn still ships memory.
@@ -177,7 +177,7 @@ describe("memory-v3-live v2 suppression", () => {
     // captures the exact pre-flag assembly behavior: v2 prefix stays, v3
     // splices after it.
     const offResult = await applyRuntimeInjections(runMessages, {
-      turnContext: makeTurnContext(),
+      ...makeTurnContext(),
     });
 
     // The tail keeps v2's block AND gains v3's (the historical double-injection
@@ -206,7 +206,7 @@ describe("memory-v3-live v2 suppression", () => {
     ];
 
     const result = await applyRuntimeInjections(runMessages, {
-      turnContext: makeTurnContext(),
+      ...makeTurnContext(),
     });
 
     expect(result.messages).toEqual(runMessages);

package/src/__tests__/list-messages-client-message-id.test.ts

@@ -0,0 +1,91 @@
+/**
+ * Tests for handleListMessages clientMessageId projection.
+ *
+ * Verifies that the persisted idempotency nonce is echoed back on the
+ * messages snapshot row so a client can correlate its optimistic row with
+ * the confirmed server row by identity instead of matching message text.
+ */
+
+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 },
+  }),
+}));
+
+import { addMessage, createConversation } from "../memory/conversation-crud.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { handleListMessages } from "../runtime/routes/conversation-routes.js";
+
+initializeDb();
+
+function resetTables() {
+  const db = getDb();
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+}
+
+interface MessagePayload {
+  role: string;
+  clientMessageId?: string;
+}
+
+describe("handleListMessages clientMessageId", () => {
+  beforeEach(resetTables);
+
+  test("echoes the persisted clientMessageId onto the user row", async () => {
+    // GIVEN a user message persisted with a client-generated idempotency nonce
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "hello" }]),
+      { clientMessageId: "nonce-abc", skipIndexing: true },
+    );
+
+    // WHEN the messages snapshot is built
+    const response = handleListMessages({
+      queryParams: { conversationId: conv.id },
+    });
+    const body = response as { messages: MessagePayload[] };
+
+    // THEN the snapshot row carries the nonce back for id-based correlation
+    expect(body.messages).toHaveLength(1);
+    expect(body.messages[0].role).toBe("user");
+    expect(body.messages[0].clientMessageId).toBe("nonce-abc");
+  });
+
+  test("omits clientMessageId when the row was persisted without one", async () => {
+    // GIVEN a user message persisted without a client nonce (e.g. a channel send)
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "hello" }]),
+      { skipIndexing: true },
+    );
+
+    // WHEN the messages snapshot is built
+    const response = handleListMessages({
+      queryParams: { conversationId: conv.id },
+    });
+    const body = response as { messages: MessagePayload[] };
+
+    // THEN the field is absent rather than emitted as null/empty
+    expect(body.messages).toHaveLength(1);
+    expect(body.messages[0].clientMessageId).toBeUndefined();
+  });
+});

package/src/__tests__/list-messages-hidden-metadata.test.ts

@@ -96,6 +96,44 @@ describe("handleListMessages metadata.hidden filtering", () => {
     expect(llmRows[1].metadata).toContain('"hidden":true');
   });
 
+  test("UI serializer omits system rows but LLM-side getMessages includes them", async () => {
+    // GIVEN a conversation with a system row sandwiched between two
+    // renderable turns (e.g. a skill-authored context message)
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([{ type: "text", text: "first visible" }]),
+    );
+    await addMessage(
+      conv.id,
+      "system",
+      JSON.stringify([{ type: "text", text: "system scaffolding" }]),
+    );
+    await addMessage(
+      conv.id,
+      "assistant",
+      JSON.stringify([{ type: "text", text: "second visible" }]),
+    );
+
+    // WHEN the UI history list is serialized
+    const response = handleListMessages({
+      queryParams: { conversationId: conv.id },
+    });
+    const body = response as { messages: MessagePayload[] };
+
+    // THEN only the user/assistant turns are returned, never the system row
+    expect(body.messages.map((m) => m.role)).toEqual(["user", "assistant"]);
+    expect(
+      body.messages.some((m) => plainText(m).includes("system scaffolding")),
+    ).toBe(false);
+
+    // AND the LLM-side loader still includes the system row for agent context
+    const llmRows = getMessages(conv.id);
+    expect(llmRows).toHaveLength(3);
+    expect(llmRows[1].role).toBe("system");
+  });
+
   test("messages without metadata or with hidden=false are returned", async () => {
     const conv = createConversation();
     await addMessage(

package/src/__tests__/memory-retrieval-hook.test.ts

@@ -1,12 +1,16 @@
 /**
- * Tests for the default `user-prompt-submit-temp` hook (memory retrieval).
+ * Tests for the default `user-prompt-submit-temp` hook (memory retrieval +
+ * runtime injection).
  *
  * Covers the retrieval behavior, the side effects the hook owns (injected-block
- * metadata, recall log, `memory_recalled` event), trust gating, error
- * propagation, and abort-signal forwarding. Uses `mock.module` to stub the
- * persistence helpers so the test doesn't touch the developer's real
- * `~/.vellum` or database. The memory graph handle is a hand-rolled fake
- * passed on the hook context — the hook only needs `prepareMemory`.
+ * metadata, recall log, `memory_recalled` event), trust gating, the runtime
+ * injection the hook applies for every actor (and the assembled-block persist),
+ * error propagation, and abort-signal forwarding. Uses `mock.module` to stub
+ * the persistence helpers, `applyRuntimeInjections`, and the conversation
+ * registry / trust resolver so the test doesn't touch the developer's real
+ * `~/.vellum`, database, or live conversation state. The memory graph handle,
+ * abort signal, and trust class are self-resolved by the hook from a fake
+ * conversation installed in the registry mock.
  */
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
@@ -23,7 +27,36 @@ mock.module("../memory/memory-recall-log-store.js", () => ({
   recordMemoryRecallLog: recordMemoryRecallLogMock,
 }));
 
+// Pass-through injection stub: returns the input messages unchanged with no
+// assembled blocks, so existing array-identity assertions hold. Individual
+// tests override it via `mockImplementationOnce` to exercise injected blocks.
+const applyRuntimeInjectionsMock = mock(async (messages: unknown) => ({
+  messages,
+  blocks: {},
+}));
+mock.module("../daemon/conversation-runtime-assembly.js", () => ({
+  applyRuntimeInjections: applyRuntimeInjectionsMock,
+}));
+
+// The hook self-resolves the live conversation and its trust class; both are
+// driven from these refs so each test controls what the hook sees.
+let currentConversation: Conversation | undefined;
+let currentTrustClass: "guardian" | "unknown" = "guardian";
+const findConversationOrSubagentMock = mock(
+  (_conversationId?: string) => currentConversation,
+);
+mock.module("../daemon/conversation-registry.js", () => ({
+  findConversationOrSubagent: findConversationOrSubagentMock,
+}));
+mock.module("../daemon/trust-context.js", () => ({
+  resolveTrustClass: () => currentTrustClass,
+}));
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({}) as AssistantConfig,
+}));
+
 import type { AssistantConfig } from "../config/schema.js";
+import type { Conversation } from "../daemon/conversation.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { ConversationGraphMemory } from "../memory/graph/conversation-graph-memory.js";
 import type { QdrantSparseVector } from "../memory/qdrant-client.js";
@@ -104,26 +137,47 @@ function makeFakeGraphMemory(overrides?: {
 function makeHookCtx(
   overrides: Partial<MemoryRetrievalHookContext> = {},
 ): MemoryRetrievalHookContext {
-  const { memory } = makeFakeGraphMemory();
   return {
-    graphMemory: memory,
-    config: {} as AssistantConfig,
     onEvent: () => {},
-    isTrustedActor: true,
     conversationId: "conv-test",
     userMessageId: "msg-test",
     logger: {
       warn: () => {},
     } as unknown as MemoryRetrievalHookContext["logger"],
-    signal: new AbortController().signal,
     latestMessages: [],
+    requestId: "req-test",
+    mode: "full",
+    isNonInteractive: false,
+    modelProfile: null,
+    actorContext: null,
     ...overrides,
   };
 }
 
+/**
+ * Install a fake live conversation for the hook to self-resolve by id: the
+ * graph handle, abort signal, and trust class all come from here rather than
+ * the hook context.
+ */
+function installConversation(
+  graphMemory: ConversationGraphMemory,
+  opts?: { trusted?: boolean; signal?: AbortSignal },
+): void {
+  currentTrustClass = opts?.trusted === false ? "unknown" : "guardian";
+  currentConversation = {
+    graphMemory,
+    trustContext: undefined,
+    abortController: { signal: opts?.signal ?? new AbortController().signal },
+  } as unknown as Conversation;
+}
+
 beforeEach(() => {
   updateMessageMetadataMock.mockReset();
   recordMemoryRecallLogMock.mockReset();
+  applyRuntimeInjectionsMock.mockClear();
+  findConversationOrSubagentMock.mockClear();
+  currentConversation = undefined;
+  currentTrustClass = "guardian";
 });
 
 describe("user-prompt-submit-temp hook (memory retrieval)", () => {
@@ -134,7 +188,8 @@ describe("user-prompt-submit-temp hook (memory retrieval)", () => {
     const { memory, prepareMemoryMock } = makeFakeGraphMemory({
       messages: injected,
     });
-    const ctx = makeHookCtx({ graphMemory: memory, isTrustedActor: true });
+    installConversation(memory, { trusted: true });
+    const ctx = makeHookCtx();
 
     await userPromptSubmitMemoryRetrieval(ctx);
 
@@ -156,7 +211,8 @@ describe("user-prompt-submit-temp hook (memory retrieval)", () => {
       userQueryVector: userDense,
       userQuerySparseVector: userSparse,
     });
-    const userCtx = makeHookCtx({ graphMemory: withUserQuery.memory });
+    installConversation(withUserQuery.memory, { trusted: true });
+    const userCtx = makeHookCtx();
     await userPromptSubmitMemoryRetrieval(userCtx);
     // User-query pair wins — never crossed with the summary signal — and is
     // recorded back onto the graph handle for the PKB-reminder injector.
@@ -169,7 +225,8 @@ describe("user-prompt-submit-temp hook (memory retrieval)", () => {
       queryVector: summaryDense,
       sparseVector: summarySparse,
     });
-    const summaryCtx = makeHookCtx({ graphMemory: summaryOnly.memory });
+    installConversation(summaryOnly.memory, { trusted: true });
+    const summaryCtx = makeHookCtx();
     await userPromptSubmitMemoryRetrieval(summaryCtx);
     expect(summaryOnly.recordPkbQueryVectorsMock).toHaveBeenCalledWith(
       summaryDense,
@@ -177,17 +234,59 @@ describe("user-prompt-submit-temp hook (memory retrieval)", () => {
     );
   });
 
+  test("applies runtime injection on the retrieved history and persists the assembled blocks", async () => {
+    const retrieved: Message[] = [
+      { role: "user", content: [{ type: "text", text: "retrieved" }] },
+    ];
+    const injected: Message[] = [
+      { role: "user", content: [{ type: "text", text: "injected" }] },
+    ];
+    const { memory } = makeFakeGraphMemory({ messages: retrieved });
+    applyRuntimeInjectionsMock.mockImplementationOnce(async () => ({
+      messages: injected,
+      blocks: { unifiedTurnContext: "tc-block" },
+    }));
+    installConversation(memory, { trusted: true });
+    const ctx = makeHookCtx({ userMessageId: "msg-77" });
+
+    await userPromptSubmitMemoryRetrieval(ctx);
+
+    // Injection runs on the retrieved history; its result becomes the working
+    // list the loop reads back.
+    expect(applyRuntimeInjectionsMock).toHaveBeenCalledTimes(1);
+    expect(applyRuntimeInjectionsMock.mock.calls[0]?.[0]).toBe(retrieved);
+    expect(ctx.latestMessages).toBe(injected);
+    // The assembled blocks are persisted onto the user message metadata.
+    expect(updateMessageMetadataMock).toHaveBeenCalledWith("msg-77", {
+      turnContextBlock: "tc-block",
+    });
+  });
+
+  test("applies runtime injection for untrusted actors despite skipping retrieval", async () => {
+    const { memory, prepareMemoryMock } = makeFakeGraphMemory();
+    const seeded: Message[] = [
+      { role: "user", content: [{ type: "text", text: "seeded" }] },
+    ];
+    installConversation(memory, { trusted: false });
+    const ctx = makeHookCtx({ latestMessages: seeded });
+
+    await userPromptSubmitMemoryRetrieval(ctx);
+
+    // The memory-graph step is gated on trust, but injection runs for everyone
+    // — on the seeded history, since no retrieval replaced it.
+    expect(prepareMemoryMock).not.toHaveBeenCalled();
+    expect(applyRuntimeInjectionsMock).toHaveBeenCalledTimes(1);
+    expect(applyRuntimeInjectionsMock.mock.calls[0]?.[0]).toBe(seeded);
+  });
+
   test("skips graph retrieval and side effects for untrusted actors", async () => {
     const { memory, prepareMemoryMock, recordPkbQueryVectorsMock } =
       makeFakeGraphMemory();
     const seeded: Message[] = [
       { role: "user", content: [{ type: "text", text: "seeded" }] },
     ];
-    const ctx = makeHookCtx({
-      graphMemory: memory,
-      isTrustedActor: false,
-      latestMessages: seeded,
-    });
+    installConversation(memory, { trusted: false });
+    const ctx = makeHookCtx({ latestMessages: seeded });
 
     await userPromptSubmitMemoryRetrieval(ctx);
 
@@ -206,8 +305,8 @@ describe("user-prompt-submit-temp hook (memory retrieval)", () => {
       injectedBlockText: "injected-block",
       metrics: makeMetrics(),
     });
+    installConversation(memory, { trusted: true });
     const ctx = makeHookCtx({
-      graphMemory: memory,
       onEvent: (msg) => received.push(msg),
       userMessageId: "msg-42",
       conversationId: "conv-42",
@@ -231,7 +330,8 @@ describe("user-prompt-submit-temp hook (memory retrieval)", () => {
 
   test("skips metadata persist when no block text is injected", async () => {
     const { memory } = makeFakeGraphMemory({ injectedBlockText: null });
-    const ctx = makeHookCtx({ graphMemory: memory });
+    installConversation(memory, { trusted: true });
+    const ctx = makeHookCtx();
 
     await userPromptSubmitMemoryRetrieval(ctx);
 
@@ -254,16 +354,17 @@ describe("user-prompt-submit-temp hook (memory retrieval)", () => {
     const graphMemory = {
       prepareMemory: failingPrepare,
     } as unknown as ConversationGraphMemory;
-    const ctx = makeHookCtx({ graphMemory, isTrustedActor: true });
+    installConversation(graphMemory, { trusted: true });
+    const ctx = makeHookCtx();
 
     await expect(userPromptSubmitMemoryRetrieval(ctx)).rejects.toThrow(
       "retrieval failed",
     );
   });
 
-  test("forwards the context abort signal into prepareMemory", async () => {
-    // The hook hands its `ctx.signal` straight to `prepareMemory` so an
-    // external cancel aborts the underlying retrieval.
+  test("forwards the conversation abort signal into prepareMemory", async () => {
+    // The hook hands the live conversation's abort signal straight to
+    // `prepareMemory` so an external cancel aborts the underlying retrieval.
     let capturedSignal: AbortSignal | undefined;
     const prepareMemoryMock = mock(
       async (
@@ -288,7 +389,11 @@ describe("user-prompt-submit-temp hook (memory retrieval)", () => {
       recordPkbQueryVectors: mock(() => {}),
     } as unknown as ConversationGraphMemory;
     const controller = new AbortController();
-    const ctx = makeHookCtx({ graphMemory, signal: controller.signal });
+    installConversation(graphMemory, {
+      trusted: true,
+      signal: controller.signal,
+    });
+    const ctx = makeHookCtx();
 
     await userPromptSubmitMemoryRetrieval(ctx);
 

package/src/__tests__/memory-v2-static-injector.test.ts

@@ -11,6 +11,9 @@
  *   - Skips (re)injection when the `<info>` block is already present in the
  *     turn's working messages (presence detection — the block persists in
  *     history between compactions).
+ *   - Still injects when only a dynamic `<memory>` activation block is present
+ *     (that wrapper must not be mistaken for the static block) — both on a
+ *     normal turn and after compaction strips the prior `<info>` block.
  *
  * The injector sources its content itself via `readMemoryV2StaticContent()`
  * behind the personal-memory trust gate, so each test seeds the workspace
@@ -35,7 +38,7 @@ mock.module("../config/loader.js", () => ({
 }));
 
 const { defaultInjectors } =
-  await import("../plugins/defaults/injectors/register.js");
+  await import("../plugins/defaults/memory-retrieval/injectors.js");
 import type { Injector, TurnContext } from "../plugins/types.js";
 import type { Message } from "../providers/types.js";
 import { getWorkspacePromptPath } from "../util/platform.js";
@@ -54,7 +57,6 @@ function makeContext(overrides: Partial<TurnContext> = {}): TurnContext {
     conversationId: "conv-test",
     turnIndex: 0,
     trust: { sourceChannel: "vellum", trustClass: "guardian" },
-    injectionInputs: {},
     ...overrides,
   };
 }
@@ -96,7 +98,7 @@ describe("memory-v2-static injector", () => {
 
   test("returns null in minimal mode even with content", async () => {
     seedEssentials("Alice prefers VS Code.");
-    const ctx = makeContext({ injectionInputs: { mode: "minimal" } });
+    const ctx = makeContext({ mode: "minimal" });
     expect(await memoryV2StaticInjector.produce(ctx)).toBeNull();
   });
 
@@ -140,10 +142,12 @@ describe("memory-v2-static injector", () => {
     expect(await memoryV2StaticInjector.produce(ctx, runMessages)).toBeNull();
   });
 
-  test("skips (re)injection when a legacy <memory>-wrapped static block is present", async () => {
-    // Rows persisted before the `<info>` switch rehydrate the static block as
-    // `<memory>…</memory>`. Re-injecting a fresh `<info>` copy alongside it
-    // would duplicate the content until the next compaction.
+  test("injects the <info> block even when a dynamic <memory> activation block is present", async () => {
+    // Regression (#33612): the v2 *dynamic* activation block uses the
+    // `<memory>…</memory>` wrapper and `prepareMemory` prepends it to the tail
+    // user message every turn, before this injector runs. The static injector
+    // must NOT treat that as its own `<info>` block — doing so suppressed the
+    // static block on essentially every turn.
     seedEssentials("Alice prefers VS Code.");
     const ctx = makeContext();
     const runMessages: Message[] = [
@@ -152,12 +156,86 @@ describe("memory-v2-static injector", () => {
         content: [
           {
             type: "text",
-            text: "<memory>\n## Essentials\n\nAlice prefers VS Code.\n</memory>",
+            text: "<memory>\n# memory/concepts/foo.md\nactivated page summary\n</memory>",
           },
           { type: "text", text: "What next?" },
         ],
       },
     ];
+    const block = await memoryV2StaticInjector.produce(ctx, runMessages);
+    expect(block).not.toBeNull();
+    expect(block!.id).toBe("memory-v2-static");
+    expect(block!.text).toBe(
+      "<info>\n## Essentials\n\nAlice prefers VS Code.\n</info>",
+    );
+  });
+
+  test("reinjects the <info> block after compaction strips it, alongside a fresh <memory> block", async () => {
+    // Post-compaction state: `stripInjectionsForCompaction` removed the prior
+    // `<info>` block, and the next turn's `prepareMemory` re-added a fresh
+    // dynamic `<memory>` block ahead of the chain. With no `<info>` present, the
+    // injector must reinject it rather than skip on the `<memory>` block.
+    seedEssentials("Alice prefers VS Code.");
+    const ctx = makeContext();
+    const postCompactMessages: Message[] = [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "<memory>\nactivated page summary\n</memory>" },
+          { type: "text", text: "Continue please." },
+        ],
+      },
+    ];
+    const block = await memoryV2StaticInjector.produce(
+      ctx,
+      postCompactMessages,
+    );
+    expect(block).not.toBeNull();
+    expect(block!.id).toBe("memory-v2-static");
+    expect(block!.text).toContain("## Essentials");
+  });
+
+  test("skips (re)injection when the <info> block is carried in a flattened history block", async () => {
+    // Regression: when a historical user message's separate injection content
+    // blocks get collapsed into one text block (observed after a daemon restart
+    // / plugin hot-reload rebuilt the rendered history mid-conversation — the
+    // blocks are joined with "\n"), the `<info>` wrapper is no longer its own
+    // block but a newline-delimited section inside a larger block. Presence
+    // detection must still recognize it; otherwise the injector re-injects a
+    // duplicate `<info>` onto the new tail (the double-injection bug).
+    seedEssentials("Alice prefers VS Code.");
+    const ctx = makeContext();
+    const flattenedFirstUser = [
+      "<workspace>\nRoot: /ws\nFiles: a.md\n</workspace>",
+      "<turn_context>\ncurrent_time: now\n</turn_context>",
+      "<memory>\nactivated page summary\n</memory>",
+      "<info>\n## Essentials\n\nAlice prefers VS Code.\n</info>",
+      "what should we do next?",
+    ].join("\n");
+    const runMessages: Message[] = [
+      { role: "user", content: [{ type: "text", text: flattenedFirstUser }] },
+      { role: "assistant", content: [{ type: "text", text: "On it." }] },
+      { role: "user", content: [{ type: "text", text: "great, continue" }] },
+    ];
     expect(await memoryV2StaticInjector.produce(ctx, runMessages)).toBeNull();
   });
+
+  test("still injects when a user message opens an <info> tag without closing it", async () => {
+    // False-positive guard: the wrapper matcher requires BOTH the opening and
+    // closing tags, so user prose that merely opens an injection-like tag must
+    // not be mistaken for a carried block and suppress injection.
+    seedEssentials("Alice prefers VS Code.");
+    const ctx = makeContext();
+    const runMessages: Message[] = [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "<info>\n is this how the tag works?" },
+        ],
+      },
+    ];
+    const block = await memoryV2StaticInjector.produce(ctx, runMessages);
+    expect(block).not.toBeNull();
+    expect(block!.id).toBe("memory-v2-static");
+  });
 });

package/src/__tests__/parallel-tool.benchmark.test.ts

@@ -128,12 +128,19 @@ describe("Parallel tool execution benchmarks", () => {
       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 start = Date.now();
-    await loop.run([userMessage], () => {});
+    await loop.run({
+      messages: [userMessage],
+      onEvent: () => {},
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
     const elapsed = Date.now() - start;
 
     // Parallel: ~50ms + overhead. Sequential would be ~250ms.
@@ -169,12 +176,19 @@ describe("Parallel tool execution benchmarks", () => {
       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 start = Date.now();
-    await loop.run([userMessage], () => {});
+    await loop.run({
+      messages: [userMessage],
+      onEvent: () => {},
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
     const elapsed = Date.now() - start;
 
     // All 10 tools should have executed
@@ -222,13 +236,20 @@ describe("Parallel tool execution benchmarks", () => {
       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[] = [];
     const start = Date.now();
-    await loop.run([userMessage], collectEvents(events));
+    await loop.run({
+      messages: [userMessage],
+      onEvent: collectEvents(events),
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
     const elapsed = Date.now() - start;
 
     // Parallel: ~2000ms (dominated by slow tool). Sequential: ~2400ms (2000 + 4*100).
@@ -289,12 +310,18 @@ describe("Parallel tool execution benchmarks", () => {
         return { content: "should not return", isError: false };
       };
 
-      const loop = new AgentLoop(provider, "system", {
+      const loop = new AgentLoop({
+        provider: provider,
+        systemPrompt: "system",
+        conversationId: "test-conversation",
         tools: dummyTools,
         toolExecutor: toolExecutor,
       });
       const start = Date.now();
-      const { history } = await loop.run([userMessage], () => {}, {
+      const { history } = await loop.run({
+        messages: [userMessage],
+        onEvent: () => {},
+        trust: { sourceChannel: "vellum", trustClass: "unknown" },
         signal: controller.signal,
       });
       const elapsed = Date.now() - start;