@vellumai/assistant 0.8.8-dev.202606072033.0e97ff6 → 0.8.8-dev.202606072131.4817a81

package/openapi.yaml

@@ -16027,6 +16027,8 @@ paths:
                           type: array
                           items:
                             type: string
+                        clientMessageId:
+                          type: string
                         role:
                           type: string
                           enum:
@@ -16995,6 +16997,12 @@ paths:
                   type: string
                 clientTimezone:
                   type: string
+                clientMessageId:
+                  type: string
+                  description:
+                    Client-generated idempotency nonce. Persisted on the row and echoed back on the message_echo event and the
+                    messages snapshot so the client can correlate its optimistic row by identity. Duplicate sends for
+                    the same (conversation, clientMessageId) are deduplicated server-side.
                 inferenceProfile:
                   anyOf:
                     - type: string

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.8.8-dev.202606072033.0e97ff6",
+  "version": "0.8.8-dev.202606072131.4817a81",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/agent-loop-callsite-precedence.test.ts

@@ -101,10 +101,14 @@ describe("AgentLoop — call-site precedence", () => {
 
     const { provider, lastConfig } = makePipeline("anthropic");
     const loop = new AgentLoop(provider, "system", {
+      conversationId: "test-conversation",
       config: { maxTokens: 64000 },
     });
 
-    await loop.run([userMessage], () => {}, { callSite: "mainAgent" });
+    await loop.run([userMessage], () => {}, {
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+      callSite: "mainAgent",
+    });
 
     expect(lastConfig()!.max_tokens).toBe(4096);
   });
@@ -121,13 +125,17 @@ describe("AgentLoop — call-site precedence", () => {
 
     const { provider, lastConfig } = makePipeline("anthropic");
     const loop = new AgentLoop(provider, "system", {
+      conversationId: "test-conversation",
       config: {
         maxTokens: 64000,
         effort: "high",
       },
     });
 
-    await loop.run([userMessage], () => {}, { callSite: "mainAgent" });
+    await loop.run([userMessage], () => {}, {
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+      callSite: "mainAgent",
+    });
 
     expect(lastConfig()!.effort).toBe("low");
   });
@@ -144,6 +152,7 @@ describe("AgentLoop — call-site precedence", () => {
 
     const { provider, lastConfig } = makePipeline("anthropic");
     const loop = new AgentLoop(provider, "system", {
+      conversationId: "test-conversation",
       config: {
         maxTokens: 64000,
         effort: "high",
@@ -153,7 +162,10 @@ describe("AgentLoop — call-site precedence", () => {
       },
     });
 
-    await loop.run([userMessage], () => {}, { callSite: "mainAgent" });
+    await loop.run([userMessage], () => {}, {
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+      callSite: "mainAgent",
+    });
 
     expect(lastConfig()!.speed).toBe("fast");
   });
@@ -175,6 +187,7 @@ describe("AgentLoop — call-site precedence", () => {
 
     const { provider, lastConfig } = makePipeline("anthropic");
     const loop = new AgentLoop(provider, "system", {
+      conversationId: "test-conversation",
       config: {
         maxTokens: 64000,
         // Conversation default also has thinking on — without the fix, this
@@ -184,7 +197,10 @@ describe("AgentLoop — call-site precedence", () => {
       },
     });
 
-    await loop.run([userMessage], () => {}, { callSite: "mainAgent" });
+    await loop.run([userMessage], () => {}, {
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+      callSite: "mainAgent",
+    });
 
     // Call-site override resolves `thinking.enabled: false`, so the
     // RetryProvider normalizer must send Anthropic's explicit disabled shape.
@@ -203,10 +219,14 @@ describe("AgentLoop — call-site precedence", () => {
 
     const { provider, lastConfig } = makePipeline("anthropic");
     const loop = new AgentLoop(provider, "system", {
+      conversationId: "test-conversation",
       config: { maxTokens: 64000 },
     });
 
-    await loop.run([userMessage], () => {}, { callSite: "mainAgent" });
+    await loop.run([userMessage], () => {}, {
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+      callSite: "mainAgent",
+    });
 
     // Must be wire-format `{ type: "adaptive" }` so the Anthropic SDK's
     // `ThinkingConfigParam` accepts it. The schema-shape `{ enabled,
@@ -228,6 +248,7 @@ describe("AgentLoop — call-site precedence", () => {
 
     const { provider, lastConfig } = makePipeline("anthropic");
     const loop = new AgentLoop(provider, "system", {
+      conversationId: "test-conversation",
       config: {
         maxTokens: 64000,
         effort: "high",
@@ -236,7 +257,9 @@ describe("AgentLoop — call-site precedence", () => {
       },
     });
 
-    await loop.run([userMessage], () => {});
+    await loop.run([userMessage], () => {}, {
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
 
     const config = lastConfig()!;
     expect(config.max_tokens).toBe(64000);
@@ -263,11 +286,15 @@ describe("AgentLoop — call-site precedence", () => {
     });
 
     const loop = new AgentLoop(provider, "system", {
+      conversationId: "test-conversation",
       config: { maxTokens: 64000 },
       resolveSystemPrompt: resolveSystemPrompt,
     });
 
-    await loop.run([userMessage], () => {}, { callSite: "mainAgent" });
+    await loop.run([userMessage], () => {}, {
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+      callSite: "mainAgent",
+    });
 
     // Per-turn explicit value beats both the call-site (4096) and the
     // default (64000).

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

@@ -23,7 +23,7 @@ import type {
 } from "../agent/loop.js";
 import { AgentLoop, isMaxTokensStopReason } from "../agent/loop.js";
 import type { TrustContext } from "../daemon/trust-context.js";
-import type { PostCompactionHookInput } from "../plugins/defaults/memory-retrieval/hooks/post-compact.js";
+import type { PostCompactContext } from "../plugins/defaults/memory-retrieval/hooks/post-compact.js";
 import type {
   Message,
   Provider,
@@ -35,18 +35,16 @@ import type {
 // 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
-// `postCompactReinjectImpl` to observe the call or force a failure; when unset
+// `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 postCompactReinjectImpl:
-  | ((input: PostCompactionHookInput) => Promise<Message[]>)
+let postCompactImpl:
+  | ((input: PostCompactContext) => Promise<Message[]>)
   | null = null;
 mock.module(
   "../plugins/defaults/memory-retrieval/hooks/post-compact.js",
   () => ({
-    default: async (input: PostCompactionHookInput) => ({
-      messages: postCompactReinjectImpl
-        ? await postCompactReinjectImpl(input)
-        : input.history,
+    default: async (input: PostCompactContext) => ({
+      messages: postCompactImpl ? await postCompactImpl(input) : input.history,
     }),
   }),
 );
@@ -165,12 +163,18 @@ 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, "system prompt", {
+      conversationId: "test-conversation",
+    });
 
     const events: AgentEvent[] = [];
-    await loop.run([userMessage], (e) => {
-      events.push(e);
-    });
+    await loop.run(
+      [userMessage],
+      (e) => {
+        events.push(e);
+      },
+      { trust: { sourceChannel: "vellum", trustClass: "unknown" } },
+    );
 
     expect(countExitEvents(events)).toBe(1);
     const exit = lastExitEvent(events);
@@ -179,12 +183,18 @@ 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, "system prompt", {
+      conversationId: "test-conversation",
+    });
 
     const events: AgentEvent[] = [];
-    await loop.run([userMessage], (e) => {
-      events.push(e);
-    });
+    await loop.run(
+      [userMessage],
+      (e) => {
+        events.push(e);
+      },
+      { trust: { sourceChannel: "vellum", trustClass: "unknown" } },
+    );
 
     expect(events.length).toBeGreaterThan(0);
     expect(events[events.length - 1].type).toBe("agent_loop_exit");
@@ -194,12 +204,18 @@ describe("AgentLoop exit-reason instrumentation", () => {
     const { provider } = createMockProvider([
       maxTokensResponse("Partial answer"),
     ]);
-    const loop = new AgentLoop(provider, "system prompt");
+    const loop = new AgentLoop(provider, "system prompt", {
+      conversationId: "test-conversation",
+    });
 
     const events: AgentEvent[] = [];
-    await loop.run([userMessage], (e) => {
-      events.push(e);
-    });
+    await loop.run(
+      [userMessage],
+      (e) => {
+        events.push(e);
+      },
+      { trust: { sourceChannel: "vellum", trustClass: "unknown" } },
+    );
 
     expect(events.map((e) => e.type)).toEqual([
       "llm_call_started",
@@ -230,13 +246,18 @@ describe("AgentLoop exit-reason instrumentation", () => {
       },
     ]);
     const loop = new AgentLoop(provider, "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(
+      [userMessage],
+      (e) => {
+        events.push(e);
+      },
+      { trust: { sourceChannel: "vellum", trustClass: "unknown" } },
+    );
 
     expect(events.some((e) => e.type === "tool_use")).toBe(false);
     expect(lastExitEvent(events)?.reason).toBe("max_tokens_reached");
@@ -247,7 +268,9 @@ 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, "system prompt", {
+      conversationId: "test-conversation",
+    });
 
     const controller = new AbortController();
     controller.abort();
@@ -258,7 +281,10 @@ describe("AgentLoop exit-reason instrumentation", () => {
       (e) => {
         events.push(e);
       },
-      { signal: controller.signal },
+      {
+        trust: { sourceChannel: "vellum", trustClass: "unknown" },
+        signal: controller.signal,
+      },
     );
 
     expect(countExitEvents(events)).toBe(1);
@@ -275,14 +301,19 @@ describe("AgentLoop exit-reason instrumentation", () => {
       yieldToUser: true,
     });
     const loop = new AgentLoop(provider, "system", {
+      conversationId: "test-conversation",
       tools: dummyTools,
       toolExecutor: toolExecutor,
     });
 
     const events: AgentEvent[] = [];
-    await loop.run([userMessage], (e) => {
-      events.push(e);
-    });
+    await loop.run(
+      [userMessage],
+      (e) => {
+        events.push(e);
+      },
+      { trust: { sourceChannel: "vellum", trustClass: "unknown" } },
+    );
 
     expect(countExitEvents(events)).toBe(1);
     expect(lastExitEvent(events)?.reason).toBe("yield_to_user");
@@ -295,6 +326,7 @@ describe("AgentLoop exit-reason instrumentation", () => {
     ]);
     const toolExecutor = async () => ({ content: "ok", isError: false });
     const loop = new AgentLoop(provider, "system", {
+      conversationId: "test-conversation",
       tools: dummyTools,
       toolExecutor: toolExecutor,
     });
@@ -308,7 +340,10 @@ describe("AgentLoop exit-reason instrumentation", () => {
       (e) => {
         events.push(e);
       },
-      { onCheckpoint },
+      {
+        trust: { sourceChannel: "vellum", trustClass: "unknown" },
+        onCheckpoint,
+      },
     );
 
     expect(countExitEvents(events)).toBe(0);
@@ -323,6 +358,7 @@ describe("AgentLoop exit-reason instrumentation", () => {
     ]);
     const toolExecutor = async () => ({ content: "ok", isError: false });
     const loop = new AgentLoop(provider, "system", {
+      conversationId: "test-conversation",
       tools: dummyTools,
       toolExecutor: toolExecutor,
     });
@@ -331,6 +367,7 @@ describe("AgentLoop exit-reason instrumentation", () => {
     // of the running history exceeds the mid-loop threshold.
     // WHEN the loop checkpoints after the tool results land
     const result = await loop.run([userMessage], () => {}, {
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
       resolveContextWindow: () => ({
         maxInputTokens: 10,
         overflowRecovery: { enabled: true, safetyMarginRatio: 0 },
@@ -350,12 +387,14 @@ describe("AgentLoop exit-reason instrumentation", () => {
     ]);
     const toolExecutor = async () => ({ content: "ok", isError: false });
     const loop = new AgentLoop(provider, "system", {
+      conversationId: "test-conversation",
       tools: dummyTools,
       toolExecutor: toolExecutor,
     });
 
     // WHEN the loop runs to completion
     const result = await loop.run([userMessage], () => {}, {
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
       resolveContextWindow: () => ({
         maxInputTokens: 10,
         overflowRecovery: { enabled: false, safetyMarginRatio: 0 },
@@ -375,13 +414,14 @@ describe("AgentLoop exit-reason instrumentation", () => {
     ]);
     const toolExecutor = async () => ({ content: "ok", isError: false });
     const loop = new AgentLoop(provider, "system", {
+      conversationId: "test-conversation",
       tools: dummyTools,
       toolExecutor: toolExecutor,
     });
 
     let reinjected = false;
     const events: AgentEvent[] = [];
-    postCompactReinjectImpl = async () => {
+    postCompactImpl = async () => {
       reinjected = true;
       return [userMessage];
     };
@@ -422,11 +462,12 @@ describe("AgentLoop exit-reason instrumentation", () => {
     ]);
     const toolExecutor = async () => ({ content: "ok", isError: false });
     const loop = new AgentLoop(provider, "system", {
+      conversationId: "test-conversation",
       tools: dummyTools,
       toolExecutor: toolExecutor,
     });
 
-    postCompactReinjectImpl = async () => {
+    postCompactImpl = async () => {
       throw new Error(
         "post-compaction re-injection must not run when exhausted",
       );
@@ -456,12 +497,18 @@ describe("AgentLoop exit-reason instrumentation", () => {
         throw new Error("provider exploded");
       },
     };
-    const loop = new AgentLoop(provider, "system prompt");
+    const loop = new AgentLoop(provider, "system prompt", {
+      conversationId: "test-conversation",
+    });
 
     const events: AgentEvent[] = [];
-    await loop.run([userMessage], (e) => {
-      events.push(e);
-    });
+    await loop.run(
+      [userMessage],
+      (e) => {
+        events.push(e);
+      },
+      { trust: { sourceChannel: "vellum", trustClass: "unknown" } },
+    );
 
     expect(countExitEvents(events)).toBe(1);
     expect(lastExitEvent(events)?.reason).toBe("error");
@@ -480,14 +527,19 @@ describe("AgentLoop exit-reason instrumentation", () => {
       yieldToUser: true,
     });
     const loop = new AgentLoop(provider, "system", {
+      conversationId: "test-conversation",
       tools: dummyTools,
       toolExecutor: toolExecutor,
     });
 
     const events: AgentEvent[] = [];
-    await loop.run([userMessage], (e) => {
-      events.push(e);
-    });
+    await loop.run(
+      [userMessage],
+      (e) => {
+        events.push(e);
+      },
+      { trust: { sourceChannel: "vellum", trustClass: "unknown" } },
+    );
 
     expect(countExitEvents(events)).toBe(1);
   });
@@ -504,6 +556,7 @@ describe("AgentLoop exit-reason instrumentation", () => {
       return { content: "ok", isError: false };
     };
     const loop = new AgentLoop(provider, "system", {
+      conversationId: "test-conversation",
       tools: dummyTools,
       toolExecutor: toolExecutor,
     });
@@ -514,7 +567,10 @@ describe("AgentLoop exit-reason instrumentation", () => {
       (e) => {
         events.push(e);
       },
-      { signal: controller.signal },
+      {
+        trust: { sourceChannel: "vellum", trustClass: "unknown" },
+        signal: controller.signal,
+      },
     );
 
     expect(countExitEvents(events)).toBe(1);

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

@@ -105,13 +105,17 @@ describe("AgentLoop.run — mutableLatestUserMessage from memory-v3-live", () =>
       },
     ];
     const loop = new AgentLoop(provider, "system", {
+      conversationId: "test-conversation",
       config: { maxTokens: 1024 },
       tools: dummyTools,
       toolExecutor: async () => ({ content: "ok", isError: false }),
     });
 
     // WHEN the loop runs
-    await loop.run([userMessage], () => {}, { callSite: "mainAgent" });
+    await loop.run([userMessage], () => {}, {
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+      callSite: "mainAgent",
+    });
 
     // THEN every send (initial + tool round-trip) carries the cache-anchor signal
     expect(configs()).toHaveLength(2);
@@ -127,11 +131,15 @@ describe("AgentLoop.run — mutableLatestUserMessage from memory-v3-live", () =>
     // AND a provider that records the config of each LLM call
     const { provider, configs } = makeRecordingProvider([textResponse("hi")]);
     const loop = new AgentLoop(provider, "system", {
+      conversationId: "test-conversation",
       config: { maxTokens: 1024 },
     });
 
     // WHEN the loop runs
-    await loop.run([userMessage], () => {}, { callSite: "mainAgent" });
+    await loop.run([userMessage], () => {}, {
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+      callSite: "mainAgent",
+    });
 
     // THEN the field is omitted entirely, not carried as false/undefined
     expect(configs()).toHaveLength(1);

package/src/__tests__/agent-loop-output-hooks.test.ts

@@ -94,9 +94,13 @@ describe("agent loop output hooks", () => {
       },
     });
     const { provider } = createMockProvider([textResponse("my secret value")]);
-    const loop = new AgentLoop(provider, "system");
+    const loop = new AgentLoop(provider, "system", {
+      conversationId: "test-conversation",
+    });
     const events: AgentEvent[] = [];
-    const { history } = await loop.run([userMessage], collect(events));
+    const { history } = await loop.run([userMessage], collect(events), {
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
     expect(textOf(lastAssistant(history).content)).toBe("my [redacted] value");
   });
 
@@ -110,9 +114,13 @@ describe("agent loop output hooks", () => {
       },
     });
     const { provider } = createMockProvider([textResponse("my secret value")]);
-    const loop = new AgentLoop(provider, "system");
+    const loop = new AgentLoop(provider, "system", {
+      conversationId: "test-conversation",
+    });
     const events: AgentEvent[] = [];
-    const { history } = await loop.run([userMessage], collect(events));
+    const { history } = await loop.run([userMessage], collect(events), {
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
     // Her real words never streamed; only the transformed text did, once.
     expect(streamedText(events)).not.toContain("secret");
     expect(streamedText(events)).toBe("[filtered]");
@@ -126,9 +134,13 @@ describe("agent loop output hooks", () => {
       },
     });
     const { provider } = createMockProvider([textResponse("live text")]);
-    const loop = new AgentLoop(provider, "system");
+    const loop = new AgentLoop(provider, "system", {
+      conversationId: "test-conversation",
+    });
     const events: AgentEvent[] = [];
-    const { history } = await loop.run([userMessage], collect(events));
+    const { history } = await loop.run([userMessage], collect(events), {
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
     expect(streamedText(events)).toBe("live text"); // streamed live, untransformed
     expect(textOf(lastAssistant(history).content)).toBe("[stored]"); // storage transformed
   });
@@ -155,6 +167,7 @@ describe("agent loop output hooks", () => {
       textResponse("done"),
     ]);
     const loop = new AgentLoop(provider, "system", {
+      conversationId: "test-conversation",
       tools: [
         {
           name: "noop",
@@ -164,7 +177,9 @@ describe("agent loop output hooks", () => {
       ],
       toolExecutor: async () => ({ content: "ok", isError: false }),
     });
-    const { history } = await loop.run([userMessage], collect([]));
+    const { history } = await loop.run([userMessage], collect([]), {
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
     const toolTurn = history.find(
       (m) =>
         m.role === "assistant" && m.content.some((b) => b.type === "tool_use"),
@@ -187,8 +202,12 @@ describe("agent loop output hooks", () => {
       },
     });
     const { provider, calls } = createMockProvider([textResponse("hi")]);
-    const loop = new AgentLoop(provider, "base prompt");
-    await loop.run([userMessage], collect([]));
+    const loop = new AgentLoop(provider, "base prompt", {
+      conversationId: "test-conversation",
+    });
+    await loop.run([userMessage], collect([]), {
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
     expect(calls[0].systemPrompt).toContain("[EDITED]");
   });
 
@@ -204,8 +223,12 @@ describe("agent loop output hooks", () => {
       },
     });
     const { provider } = createMockProvider([textResponse("untouched")]);
-    const loop = new AgentLoop(provider, "system");
-    const { history } = await loop.run([userMessage], collect([]));
+    const loop = new AgentLoop(provider, "system", {
+      conversationId: "test-conversation",
+    });
+    const { history } = await loop.run([userMessage], collect([]), {
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
     const finalContent = lastAssistant(history).content;
     expect(textOf(finalContent)).toBe("untouched");
     expect(
@@ -236,9 +259,13 @@ describe("agent loop output hooks", () => {
       stopReason: "max_tokens",
     };
     const { provider } = createMockProvider([truncated]);
-    const loop = new AgentLoop(provider, "system");
+    const loop = new AgentLoop(provider, "system", {
+      conversationId: "test-conversation",
+    });
     const events: AgentEvent[] = [];
-    const { history } = await loop.run([userMessage], collect(events));
+    const { history } = await loop.run([userMessage], collect(events), {
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
     expect(seen.calls).toBe(1);
     expect(textOf(lastAssistant(history).content)).toBe("PARTIAL ANSWER");
     // Real stream suppressed; transformed final text emitted once.
@@ -268,6 +295,7 @@ describe("agent loop output hooks", () => {
     ];
     const { provider } = createMockProvider(toolThenText);
     const loop = new AgentLoop(provider, "system", {
+      conversationId: "test-conversation",
       tools: [
         {
           name: "issue",
@@ -282,7 +310,9 @@ describe("agent loop output hooks", () => {
       }),
     });
     const events: AgentEvent[] = [];
-    const { history } = await loop.run([userMessage], collect(events));
+    const { history } = await loop.run([userMessage], collect(events), {
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
     // Persisted message keeps the placeholder — model must never see real
     // values on reload.
     expect(textOf(lastAssistant(history).content)).toContain(placeholder);

package/src/__tests__/agent-loop-override-profile.test.ts

@@ -111,12 +111,14 @@ describe("AgentLoop.run — overrideProfile plumbing", () => {
     ) => ({ content: "ok", isError: false });
 
     const loop = new AgentLoop(provider, "system", {
+      conversationId: "test-conversation",
       config: { maxTokens: 1024 },
       tools: dummyTools,
       toolExecutor: toolExecutor,
     });
 
     await loop.run([userMessage], () => {}, {
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
       callSite: "mainAgent",
       overrideProfile: "fast",
     });
@@ -131,10 +133,13 @@ describe("AgentLoop.run — overrideProfile plumbing", () => {
   test("omits overrideProfile from providerConfig when unset (default behavior unchanged)", async () => {
     const { provider, configs } = makeRecordingProvider([textResponse("hi")]);
     const loop = new AgentLoop(provider, "system", {
+      conversationId: "test-conversation",
       config: { maxTokens: 1024 },
     });
 
-    await loop.run([userMessage], () => {});
+    await loop.run([userMessage], () => {}, {
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
 
     // Single send, no overrideProfile field at all.
     expect(configs()).toHaveLength(1);
@@ -149,10 +154,12 @@ describe("AgentLoop.run — overrideProfile plumbing", () => {
     // provider layer (covered by provider-send-message-override-profile.test.ts).
     const { provider, configs } = makeRecordingProvider([textResponse("hi")]);
     const loop = new AgentLoop(provider, "system", {
+      conversationId: "test-conversation",
       config: { maxTokens: 1024 },
     });
 
     await loop.run([userMessage], () => {}, {
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
       callSite: "mainAgent",
       overrideProfile: "does-not-exist",
     });