@vellumai/assistant 0.11.2 → 0.11.3-staging.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.2",
+  "version": "0.11.3-staging.2",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/agent-image-optimize.test.ts

@@ -115,9 +115,9 @@ describe("upscaleTargetDimensions", () => {
 });
 
 describe("upscaleImageToMinimum", () => {
-  it("returns null when dimensions are unparseable", () => {
+  it("returns null when dimensions are unparseable", async () => {
     expect(
-      upscaleImageToMinimum(
+      await upscaleImageToMinimum(
         Buffer.from("not an image").toString("base64"),
         "image/png",
       ),
@@ -126,12 +126,12 @@ describe("upscaleImageToMinimum", () => {
 });
 
 describe("optimizeImageForTransport", () => {
-  it("passes an undersized image through unchanged — the minimum floor is rejection-path only", () => {
+  it("passes an undersized image through unchanged: the minimum floor is rejection-path only", async () => {
     // The floor is undocumented provider behavior, so pre-send transport
     // never enforces it; only the image-recovery plugin reacts to an actual
     // "Could not process image" rejection.
     const tiny = makePngBase64(16, 14);
-    expect(optimizeImageForTransport(tiny, "image/png")).toEqual({
+    expect(await optimizeImageForTransport(tiny, "image/png")).toEqual({
       data: tiny,
       mediaType: "image/png",
     });

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

@@ -1,36 +1,22 @@
 /**
- * Verifies that the memory-v3-live cache-anchor signal surfaces on every
- * `SendMessageOptions.config` the loop emits. When v3-live 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.
+ * Verifies how the loop derives the `mutableLatestUserMessage` cache-anchor
+ * signal on `SendMessageOptions.config`.
  *
- * The loop reads `config.memory.v3.live` directly where it assembles
- * `providerConfig`, so the signal is sourced from config rather than a run
- * option. When v3-live is off the field is omitted (not `false`/`undefined`) so
- * the wire stays byte-identical to today.
+ * The signal means "the latest user message's bytes do not recur next turn", so
+ * it is set from the history actually being sent: only when the latest user
+ * message carries a memory-v3 `<memory_spotlight>` block, the one injected
+ * block that is strip-and-replaced on the tail every turn. Every other injected
+ * block is frozen into history and re-renders byte-identically, so turns
+ * without a spotlight keep a normal cache anchor even when memory-v3 is live.
+ *
+ * When no spotlight is present the field is omitted entirely (not `false`) so
+ * the wire stays byte-identical for conversations that never see one.
  */
 
-import { afterEach, describe, expect, mock, test } from "bun:test";
-
-// AgentLoop reads the v3-live gate (`config.memory.v3.live`) via
-// `isMemoryV3Live` to decide the cache-anchor signal; drive it per-test.
-let memoryV3LiveSlot = false;
-mock.module("../config/memory-v3-gate.js", () => ({
-  isMemoryV3Live: () => memoryV3LiveSlot,
-  isV3TierActive: () => memoryV3LiveSlot,
-  isMemoryEnabled: (config?: { memory?: { enabled?: boolean } }) =>
-    config?.memory?.enabled !== false,
-  usesConceptPageMemory: (memory?: {
-    enabled?: boolean;
-    v2?: { enabled?: boolean };
-    v3?: { live?: boolean };
-  }) =>
-    memory?.enabled !== false &&
-    (memory?.v3?.live === true || memory?.v2?.enabled === true),
-}));
+import { describe, expect, test } from "bun:test";
 
 import { AgentLoop } from "../agent/loop.js";
+import { wrapMemorySpotlightBlock } from "../plugins/defaults/memory/memory-marker.js";
 import type {
   Message,
   Provider,
@@ -44,6 +30,15 @@ const userMessage: Message = {
   content: [{ type: "text", text: "hi" }],
 };
 
+/** A user turn whose tail block is the ephemeral memory-v3 spotlight. */
+const spotlightUserMessage: Message = {
+  role: "user",
+  content: [
+    { type: "text", text: "hi" },
+    { type: "text", text: wrapMemorySpotlightBlock("recalled: Alice's plan") },
+  ],
+};
+
 function textResponse(text: string): ProviderResponse {
   return {
     content: [{ type: "text", text }],
@@ -87,40 +82,52 @@ function makeRecordingProvider(responses: ProviderResponse[]): {
   return { provider, configs: () => configs };
 }
 
-describe("AgentLoop.run — mutableLatestUserMessage from memory-v3-live", () => {
-  afterEach(() => {
-    memoryV3LiveSlot = false;
-  });
+const echoTool: ToolDefinition = {
+  name: "echo",
+  description: "Echo back the input",
+  input_schema: {
+    type: "object",
+    properties: { value: { type: "string" } },
+  },
+};
 
-  test("sets mutableLatestUserMessage on every LLM call when memory-v3-live is on (multi-turn)", async () => {
-    // GIVEN memory-v3-live is enabled
-    memoryV3LiveSlot = true;
+describe("AgentLoop.run: mutableLatestUserMessage from spotlight presence", () => {
+  test("sets mutableLatestUserMessage when the latest user message carries a spotlight block", async () => {
+    // GIVEN a provider that records the config of each LLM call
+    const { provider, configs } = makeRecordingProvider([textResponse("done")]);
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
+      config: { maxTokens: 1024 },
+    });
 
-    // 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",
-        description: "Echo back the input",
-        input_schema: {
-          type: "object",
-          properties: { value: { type: "string" } },
-        },
-      },
-    ];
+    // WHEN the loop runs over a history whose tail carries the spotlight
+    await loop.run({
+      requestId: "test-request",
+      messages: [spotlightUserMessage],
+      onEvent: () => {},
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+      callSite: "mainAgent",
+    });
+
+    // THEN the send carries the cache-anchor signal
+    expect(configs()).toHaveLength(1);
+    expect(configs()[0]?.mutableLatestUserMessage).toBe(true);
+  });
+
+  test("omits mutableLatestUserMessage when the latest user message carries no spotlight", async () => {
+    // GIVEN a provider that records the config of each LLM call
+    const { provider, configs } = makeRecordingProvider([textResponse("hi")]);
     const loop = new AgentLoop({
-      provider: provider,
+      provider,
       systemPrompt: "system",
       conversationId: "test-conversation",
       config: { maxTokens: 1024 },
-      tools: dummyTools,
-      toolExecutor: async () => ({ content: "ok", isError: false }),
     });
 
-    // WHEN the loop runs
+    // WHEN the loop runs over a spotlight-free history: the shape memory-v3
+    // produces whenever it selects nothing to spotlight
     await loop.run({
       requestId: "test-request",
       messages: [userMessage],
@@ -129,21 +136,16 @@ describe("AgentLoop.run — mutableLatestUserMessage from memory-v3-live", () =>
       callSite: "mainAgent",
     });
 
-    // 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);
-    }
+    // THEN the field is omitted entirely, not carried as false/undefined
+    expect(configs()).toHaveLength(1);
+    expect("mutableLatestUserMessage" in (configs()[0] ?? {})).toBe(false);
   });
 
-  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)
-    memoryV3LiveSlot = false;
-
-    // AND a provider that records the config of each LLM call
+  test("a text block merely opening with the spotlight tag is not treated as volatile", async () => {
+    // GIVEN a user message discussing the marker rather than carrying one
     const { provider, configs } = makeRecordingProvider([textResponse("hi")]);
     const loop = new AgentLoop({
-      provider: provider,
+      provider,
       systemPrompt: "system",
       conversationId: "test-conversation",
       config: { maxTokens: 1024 },
@@ -152,14 +154,59 @@ describe("AgentLoop.run — mutableLatestUserMessage from memory-v3-live", () =>
     // WHEN the loop runs
     await loop.run({
       requestId: "test-request",
-      messages: [userMessage],
+      messages: [
+        {
+          role: "user",
+          content: [
+            {
+              type: "text",
+              text: "<memory_spotlight>\nwhat does this tag do?",
+            },
+          ],
+        },
+      ],
       onEvent: () => {},
       trust: { sourceChannel: "vellum", trustClass: "unknown" },
       callSite: "mainAgent",
     });
 
-    // THEN the field is omitted entirely, not carried as false/undefined
+    // THEN the unterminated wrapper does not count: matching the full-wrapper
+    // requirement the per-turn strip applies
     expect(configs()).toHaveLength(1);
     expect("mutableLatestUserMessage" in (configs()[0] ?? {})).toBe(false);
   });
+
+  test("the signal holds for every request in a tool loop", async () => {
+    // GIVEN a spotlight-bearing opening message and a tool round-trip
+    const { provider, configs } = makeRecordingProvider([
+      toolUseResponse("t1", "echo", { value: "first" }),
+      textResponse("done"),
+    ]);
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
+      config: { maxTokens: 1024 },
+      tools: [echoTool],
+      toolExecutor: async () => ({ content: "ok", isError: false }),
+    });
+
+    // WHEN the loop runs
+    await loop.run({
+      requestId: "test-request",
+      messages: [spotlightUserMessage],
+      onEvent: () => {},
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+      callSite: "mainAgent",
+    });
+
+    // THEN both calls report the turn as volatile. The signal describes the
+    // turn-starting message, not whichever user message happens to be last, so
+    // the trailing tool-result turn does not clear it. Holding it steady is
+    // what keeps the provider marking that one block at a single TTL for the
+    // whole turn instead of writing it twice.
+    expect(configs()).toHaveLength(2);
+    expect(configs()[0]?.mutableLatestUserMessage).toBe(true);
+    expect(configs()[1]?.mutableLatestUserMessage).toBe(true);
+  });
 });

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

@@ -1,16 +1,17 @@
 /**
  * Verifies that the per-turn `overrideProfile` plumbed into `AgentLoop.run()`
  * surfaces on every `SendMessageOptions.config` the loop emits, and that
- * `SubagentManager.spawn()` propagates an inherited `overrideProfile` from
- * its `SubagentConfig` into the subagent's `runAgentLoop()` call.
+ * `SubagentManager.spawn()` propagates an `overrideProfile` set on its
+ * `SubagentConfig` into the subagent's `runAgentLoop()` call.
  *
- * Together these two assertions establish the PR 6 contract: a parent
- * conversation that pins an inference profile sees that profile applied to
- * every LLM call within its agent-loop turn, and any subagent spawned during
- * that turn inherits the same profile automatically.
+ * Together these establish where a pinned profile does and does not travel: it
+ * applies to every LLM call within the pinning conversation's own turn, and it
+ * stops at the spawn boundary. `executeSubagentSpawn` sets `overrideProfile`
+ * on the `SubagentConfig` only for a profile named explicitly on the spawn, so
+ * the propagation above carries a caller's choice rather than a parent's pin.
  *
- * Default behavior (no `overrideProfile` set) must remain unchanged — the
- * field is omitted from `providerConfig` rather than carrying `undefined`.
+ * With no `overrideProfile` set, the field is omitted from `providerConfig`
+ * rather than carrying `undefined`.
  */
 
 import { describe, expect, mock, test } from "bun:test";
@@ -183,7 +184,7 @@ describe("AgentLoop.run — overrideProfile plumbing", () => {
   });
 });
 
-// ── Subagent inheritance ─────────────────────────────────────────────────
+// ── Subagent profile forwarding ──────────────────────────────────────────
 
 // Capture the SubagentManager → Conversation handshake so we can verify the
 // `overrideProfile` from `SubagentConfig` is forwarded into the spawned
@@ -329,7 +330,7 @@ seedLlmConfig();
 
 import { SubagentManager } from "../subagent/manager.js";
 
-describe("SubagentManager.spawn — overrideProfile inheritance", () => {
+describe("SubagentManager.spawn: forwards a configured overrideProfile", () => {
   test("forwards overrideProfile from SubagentConfig into runAgentLoop", async () => {
     capturedRunAgentLoopOptions.length = 0;
 
@@ -344,9 +345,9 @@ describe("SubagentManager.spawn — overrideProfile inheritance", () => {
       () => {},
     );
 
-    // The spawned subagent's runAgentLoop must receive both the
-    // `subagentSpawn` callSite (existing behavior) and the inherited
-    // `overrideProfile` (new behavior).
+    // The spawned subagent's runAgentLoop receives the `subagentSpawn`
+    // callSite and whatever `overrideProfile` the config carries, which
+    // `executeSubagentSpawn` sets only for an explicitly named profile.
     expect(capturedRunAgentLoopOptions).toHaveLength(1);
     const captured = capturedRunAgentLoopOptions[0];
     expect(captured.callSite).toBe("subagentSpawn");
@@ -399,21 +400,18 @@ describe("SubagentManager.spawn — overrideProfile inheritance", () => {
   });
 });
 
-// ── Nested subagent spawn — context.overrideProfile preferred ────────────
+// ── Nested subagent spawn: no profile crosses the boundary ───────────────
 
-// Verify the third-level inheritance contract: when a subagent's agent loop
-// is running with `currentTurnOverrideProfile`, the executor closure plumbs
-// that value into `ToolContext.overrideProfile`. `executeSubagentSpawn` must
-// then prefer `context.overrideProfile` over a row read against the in-flight
-// subagent's own conversationId — that row never has `inferenceProfile` set,
-// and `getConversationOverrideProfile` short-circuits for background
-// conversations regardless. Without preferring the in-memory context, the
-// inheritance chain breaks at the second nesting level.
+// When a subagent's agent loop is running under a turn profile, the executor
+// closure plumbs that value into `ToolContext.overrideProfile`. That value
+// describes the spawning turn, so `executeSubagentSpawn` leaves it behind: a
+// child resolves the `subagentSpawn` call site on its own, and a forwarded
+// override would both re-price the child and file its spend as a pin nobody
+// set. These tests cover the nesting levels where a profile could otherwise
+// compound down a chain of children.
 
 mock.module("../persistence/conversation-crud.js", () => ({
   setConversationProcessingStartedAt: () => {},
-  // Always return undefined for the row read so the test fails fast unless
-  // executeSubagentSpawn reads from context.overrideProfile first.
   getConversationOverrideProfile: () => undefined,
   reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
@@ -421,8 +419,8 @@ mock.module("../persistence/conversation-crud.js", () => ({
 import { getSubagentManager } from "../subagent/index.js";
 import { executeSubagentSpawn } from "../tools/subagent/spawn.js";
 
-describe("executeSubagentSpawn — nested inheritance via context.overrideProfile", () => {
-  test("forwards context.overrideProfile to SubagentConfig (third-level inheritance)", async () => {
+describe("executeSubagentSpawn: the spawn boundary carries no profile", () => {
+  test("a subagent spawning a subagent does not pass its own turn profile down", async () => {
     const manager = getSubagentManager();
     const originalSpawn = manager.spawn.bind(manager);
     let capturedConfig: Record<string, unknown> | undefined;
@@ -432,11 +430,11 @@ describe("executeSubagentSpawn — nested inheritance via context.overrideProfil
     };
 
     try {
-      // Simulate the second-level spawn: tool invocation occurs inside the
-      // first subagent's tool context, where `overrideProfile` was populated
-      // by `runAgentLoopImpl` from its `currentTurnOverrideProfile` snapshot.
-      // The first subagent's own conversation row has no `inferenceProfile`,
-      // so the row-read fallback would otherwise return undefined.
+      // The second-level spawn: this tool call happens inside the first
+      // subagent's tool context, where `overrideProfile` was populated by
+      // `runAgentLoopImpl` from its own turn snapshot. That snapshot describes
+      // the parent's turn, so it stops here rather than compounding down a
+      // chain of nested children.
       const result = await executeSubagentSpawn(
         { label: "nested", objective: "do nested work" },
         {
@@ -450,16 +448,13 @@ describe("executeSubagentSpawn — nested inheritance via context.overrideProfil
 
       expect(result.isError).toBe(false);
       expect(capturedConfig).toBeDefined();
-      // The forwarded SubagentConfig must carry the in-memory override so
-      // SubagentManager.spawn forwards it into the nested subagent's
-      // runAgentLoop options — preserving inheritance across the chain.
-      expect(capturedConfig!.overrideProfile).toBe("fast");
+      expect("overrideProfile" in capturedConfig!).toBe(false);
     } finally {
       manager.spawn = originalSpawn;
     }
   });
 
-  test("forwards the invoker's resolved default profile when neither context nor row carries an override", async () => {
+  test("no override anywhere leaves the child on the subagentSpawn default", async () => {
     const manager = getSubagentManager();
     const originalSpawn = manager.spawn.bind(manager);
     let capturedConfig: Record<string, unknown> | undefined;
@@ -481,22 +476,17 @@ describe("executeSubagentSpawn — nested inheritance via context.overrideProfil
       );
 
       expect(capturedConfig).toBeDefined();
-      // With no explicit override anywhere, the invoker-default tier forwards
-      // the invoking call site's resolved default profile — here `mainAgent`
-      // with no active profile or pin, which resolves the catalog `balanced`
-      // default — so the subagent matches its invoker's model selection.
-      expect(capturedConfig!.overrideProfile).toBe("balanced");
+      expect("overrideProfile" in capturedConfig!).toBe(false);
     } finally {
       manager.spawn = originalSpawn;
     }
   });
 
-  test("an explicit subagentSpawn call-site pin suppresses the invoker-default inheritance", async () => {
-    // With an active profile the invoker-default tier resolves ("fast"), so
-    // absent a pin it is forwarded as the inherited override; with an
-    // explicit llm.callSites.subagentSpawn profile the heuristic must yield —
-    // a forwarded override would outrank the pin under single-winner
-    // resolution, overriding the user's explicit call-site choice.
+  test("a workspace active profile does not reach the child, pinned or not", async () => {
+    // The child resolves `llm.callSites.subagentSpawn` on its own, so the
+    // spawn must forward nothing either way: a forwarded override would
+    // outrank an explicit call-site pin under single-winner resolution and
+    // overturn the operator's choice.
     const manager = getSubagentManager();
     const originalSpawn = manager.spawn.bind(manager);
     let capturedConfig: Record<string, unknown> | undefined;
@@ -517,7 +507,7 @@ describe("executeSubagentSpawn — nested inheritance via context.overrideProfil
         { label: "nested", objective: "do nested work" },
         baseContext,
       );
-      expect(capturedConfig!.overrideProfile).toBe("fast");
+      expect("overrideProfile" in capturedConfig!).toBe(false);
 
       seedLlmConfig({
         activeProfile: "fast",

package/src/__tests__/agent-loop-subagent-billing-headers.test.ts

@@ -0,0 +1,166 @@
+/**
+ * The runtime proxy bills delegated work off `X-Vellum-Subagent-Role` and
+ * `X-Vellum-Subagent-Spawn-Mode`. `RetryProvider` resolves both from
+ * `config.conversationId`, so the headers only ever materialize in production
+ * if `AgentLoop` stamps its own conversation id onto the provider config it
+ * sends. These tests drive a real `AgentLoop` through a real `RetryProvider`
+ * so a config field dropped at the loop can never pass silently.
+ *
+ * Subagents run their turns through `ConversationRunner.runAgentLoop` with
+ * `callSite: "subagentSpawn"`, which is the shape reproduced here.
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { AgentLoop } from "../agent/loop.js";
+import { initializeDb } from "../persistence/db-init.js";
+import { rawRun } from "../persistence/raw-query.js";
+import { RetryProvider } from "../providers/retry.js";
+import type {
+  Message,
+  Provider,
+  ProviderResponse,
+  SendMessageOptions,
+} from "../providers/types.js";
+import { resetSubagentAttributionCacheForTests } from "../usage/subagent-attribution.js";
+import { setConfig } from "./helpers/set-config.js";
+
+const userMessage: Message = {
+  role: "user",
+  content: [{ type: "text", text: "hi" }],
+};
+
+/**
+ * Stands in for the transport underneath `RetryProvider`, recording the config
+ * it is handed. That config is what would go on the wire, so it is also where
+ * the resolved billing headers land.
+ */
+function makeRecordingProvider(name: string): {
+  provider: Provider;
+  configs: () => Array<Record<string, unknown>>;
+} {
+  const configs: Array<Record<string, unknown>> = [];
+  const provider: Provider = {
+    name,
+    async sendMessage(
+      _messages: Message[],
+      options?: SendMessageOptions,
+    ): Promise<ProviderResponse> {
+      configs.push((options?.config ?? {}) as Record<string, unknown>);
+      return {
+        content: [{ type: "text", text: "ok" }],
+        model: "gpt-sub",
+        usage: { inputTokens: 1, outputTokens: 1 },
+        stopReason: "end_turn",
+      };
+    },
+  };
+  return { provider, configs: () => configs };
+}
+
+async function seedConversation(
+  id: string,
+  subagentRole: string | null,
+  subagentSpawnMode: string | null,
+): Promise<void> {
+  await initializeDb();
+  resetSubagentAttributionCacheForTests();
+  rawRun(
+    "test:seedSubagentConversation",
+    `INSERT OR REPLACE INTO conversations (id, conversation_type, created_at, updated_at, subagent_role, subagent_spawn_mode)
+     VALUES (?, 'background', 1000, 1000, ?, ?)`,
+    id,
+    subagentRole,
+    subagentSpawnMode,
+  );
+}
+
+/** Runs one loop turn the way a subagent's conversation runner does. */
+async function runSubagentTurn(
+  provider: Provider,
+  conversationId: string,
+): Promise<void> {
+  const loop = new AgentLoop({
+    provider,
+    systemPrompt: "system",
+    conversationId,
+    config: { maxTokens: 1024 },
+  });
+  await loop.run({
+    requestId: "test-request",
+    messages: [userMessage],
+    onEvent: () => {},
+    trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    callSite: "subagentSpawn",
+  });
+}
+
+describe("AgentLoop subagent billing-header attribution", () => {
+  beforeEach(() => {
+    setConfig("llm", {
+      callSites: { subagentSpawn: { provider: "openai", model: "gpt-sub" } },
+    });
+  });
+
+  test("forwards the spawning role and mode on a subagent conversation's turn", async () => {
+    // GIVEN a conversation stamped as an advisor-consult subagent
+    await seedConversation("conv-loop-advisor", "advisor", "advisor_consult");
+
+    // AND a managed-proxy-shaped provider stack (headers forwarded)
+    const { provider, configs } = makeRecordingProvider("openai");
+    const wrapped = new RetryProvider(provider, {
+      forwardUsageAttributionHeaders: true,
+    });
+
+    // WHEN that subagent's loop runs a turn
+    await runSubagentTurn(wrapped, "conv-loop-advisor");
+
+    // THEN the transport sees the delegated-work attribution
+    expect(configs()).toHaveLength(1);
+    const headers = configs()[0]?.usageAttributionHeaders as Record<
+      string,
+      string
+    >;
+    expect(headers["X-Vellum-Subagent-Role"]).toBe("advisor");
+    expect(headers["X-Vellum-Subagent-Spawn-Mode"]).toBe("advisor_consult");
+    expect(headers["X-Vellum-LLM-Call-Site"]).toBe("subagentSpawn");
+
+    // AND the routing-time id itself never reaches the wire config
+    expect(configs()[0]?.conversationId).toBeUndefined();
+  });
+
+  test("omits the subagent headers on a turn for a plain conversation", async () => {
+    // GIVEN a conversation that was not spawned as a subagent
+    await seedConversation("conv-loop-plain", null, null);
+
+    const { provider, configs } = makeRecordingProvider("openai");
+    const wrapped = new RetryProvider(provider, {
+      forwardUsageAttributionHeaders: true,
+    });
+
+    // WHEN its loop runs a turn
+    await runSubagentTurn(wrapped, "conv-loop-plain");
+
+    // THEN the base attribution is present without the delegated-work fields
+    const headers = configs()[0]?.usageAttributionHeaders as Record<
+      string,
+      string
+    >;
+    expect(headers["X-Vellum-LLM-Call-Site"]).toBe("subagentSpawn");
+    expect(headers["X-Vellum-Subagent-Role"]).toBeUndefined();
+    expect(headers["X-Vellum-Subagent-Spawn-Mode"]).toBeUndefined();
+  });
+
+  test("stamps the conversation id on the provider config it sends", async () => {
+    // GIVEN a bare recording provider (no `RetryProvider` to consume the field)
+    const { provider, configs } = makeRecordingProvider("openai");
+
+    // WHEN a loop with a conversation id runs a call-site turn
+    await runSubagentTurn(provider, "conv-loop-raw");
+
+    // THEN the id the header lookup depends on is on the config, alongside the
+    // mix-expansion seed
+    expect(configs()[0]?.conversationId).toBe("conv-loop-raw");
+    expect(configs()[0]?.selectionSeed).toBe("conv-loop-raw");
+  });
+});

package/src/__tests__/agent-wake-disk-pressure-callsite.test.ts

@@ -88,6 +88,7 @@ function makeTarget(): Conversation {
     getTurnChannelContext: () => null,
     getTurnInterfaceContext: () => null,
     drainQueue: async () => {},
+    kickDrainQueue: async () => {},
     // Pre-run auto-compaction gate — no-op for these tests.
     maybeCompact: async () => null,
   };

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

@@ -100,6 +100,7 @@ function makeTarget(): {
     getTurnChannelContext: () => null,
     getTurnInterfaceContext: () => null,
     drainQueue: async () => {},
+    kickDrainQueue: async () => {},
     // Pre-run auto-compaction gate — no-op for these tests.
     maybeCompact: async () => null,
     buildCurrentSystemPrompt: () => "mock-system-prompt",