@vellumai/assistant 0.12.2-dev.202609181515.7e76c92 → 0.12.2-dev.202609181713.fb1ff61

package/ARCHITECTURE.md

@@ -614,6 +614,8 @@ Transcription mode is selected once per session in `media-stream-stt-session.ts`
 
 Every phone turn runs the same two-leg triage as live voice through `startVoiceTurn` (`src/calls/voice-session-bridge.ts`): `call-controller.ts` opens on a toolless front-door leg (`routingLeg: "front-door"`, the `voiceFrontDoor` call site) and drives it through the shared `createFrontDoorLegCoordinator` (`src/calls/voice-leg-coordinator.ts`), which reads the stream through the verdict machine and sequences the hand-off (pause narration, abort the leg, resolve and speak the bridge, mark it as the floor holder, start the escalated leg pinned to the conversation's own model, re-arm narration); each driver supplies only a host for how text and the bridge are spoken, how a leg is started or aborted, and (live voice only) the speculative hold and commit. Phone has no partial transcripts, so the hold verdict is never taught and routing is escalate-only. The controller also passes the bridge's turn callbacks (tool activity is recorded as `tool_use_started` / `tool_use_completed` call events, persisted row ids ride the `assistant_spoke` event), `launchedAtMs` for dispatch timing, and a `voiceTelemetry` bag keyed by the call session with a `phone_inbound` / `phone_outbound` entry. Both drivers share the spoken progress narration cadence (`src/calls/voice-progress-cadence.ts`, tuned by `voice.frontModel.progress`): the cadence owns the tool-activity log, the triggers (an ops burst, a long operation completing, a full interval of audible silence with news, the `maxSilenceMs` heartbeat) and the generated or static phrase, while each driver supplies its own view of audible silence (live voice from its TTS queue and playback-tail estimate; the media-stream transport from `isPlaybackIdle()` and a running sum of sent frame durations) and how to speak a phrase.
 
+Both drivers also share the per-turn latency marks (`src/calls/voice-metrics.ts`). The controller opens a turn's marks when it dispatches, seeded with when the caller's transcript arrived, and stamps the leg dispatch, the first assistant delta, the first audible audio, a barge-in, and how the turn settled. Live voice streams a snapshot to its client on every mark; a call has no client on the line, so the aggregate is logged once per turn, cancelled turns included. Each call also records a `phone_call_started` / `phone_call_ended` pair on the onboarding telemetry substrate (`src/telemetry/phone-call-funnel.ts`), written by the call store at session creation and at the single terminal status transition: duration is the gap between the two rows, and a call that took no caller turn carries why on the end row (`silent_no_connect` when it never connected, `silent_no_turn` when it did and nobody spoke).
+
 A credential preflight (`resolveTelephonyCredentialReadiness()` in `src/calls/telephony-credential-preflight.ts`) gates every call: it requires a credentialed, telephony-capable STT provider **and** a media-stream-playable TTS provider (the configured one or a credentialed playable fallback). Inbound calls that fail the preflight receive `<Say>` setup-required copy plus `<Hangup/>` instead of a doomed stream; outbound placement fails before dialing via `preflightVoiceIngress()` with the same user-facing message.
 
 Key modules:
@@ -623,6 +625,7 @@ Key modules:
 | `src/calls/twilio-routes.ts`                        | Voice webhook handler; generates `<Connect><Stream>` TwiML, enforces the inbound credential preflight |
 | `src/calls/telephony-credential-preflight.ts`       | Combined STT + TTS credential-readiness resolver                                                      |
 | `src/calls/media-stream-parser.ts`                  | Twilio Media Streams protocol parser                                                                  |
+| `src/calls/voice-metrics.ts`                        | Per-turn latency marks, shared with live voice                                                        |
 | `src/calls/media-turn-detector.ts`                  | Energy-based VAD turn detector for raw audio (batch mode)                                             |
 | `src/calls/media-stream-stt-session.ts`             | STT session — streaming/batch mode selection and transcription via `services.stt`                     |
 | `src/calls/media-stream-audio-transcode.ts`         | Mu-law ↔ PCM16 codecs and resampling                                                                  |
@@ -729,7 +732,7 @@ The assistant-side live voice module is intentionally bounded under `src/live-vo
 | `live-voice-session.ts`         | Session orchestration: streaming STT, push-to-talk release, voice turn bridge callbacks, assistant text deltas, TTS, archive, metrics, interrupt, and close |
 | `live-voice-tts.ts`             | Streaming TTS helper that resolves `services.tts`, requires `TtsProvider.synthesizeStream()`, and forwards audio chunks as `tts_audio` frames               |
 | `live-voice-archive.ts`         | Audio artifact creation/linking for user utterance and assistant response message IDs                                                                       |
-| `live-voice-metrics.ts`         | Per-session and per-turn latency snapshots emitted as `metrics` frames                                                                                      |
+| `../calls/voice-metrics.ts`     | Shared per-session and per-turn latency marks; live voice emits each snapshot as a `metrics` frame, phone calls log the per-turn aggregate                  |
 
 Live voice STT uses the same `resolveStreamingTranscriber()` path as conversation streaming, dialed with the provider the `liveVoice` STT role resolves to after managed-speech defaulting (`resolveEffectiveSpeechProviders`, see `config/managed-speech-defaults.ts`). For V1 latency-sensitive behavior, that provider must resolve to a `daemon-streaming` transcriber whose catalog entry has `conversationStreamingMode: "realtime-ws"` and usable credentials. Providers that only support batch or incremental-batch transcription remain valid for other voice surfaces, but do not satisfy live voice's streaming STT requirement.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.12.2-dev.202609181515.7e76c92",
+  "version": "0.12.2-dev.202609181713.fb1ff61",
   "license": "MIT",
   "type": "module",
   "exports": {

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

@@ -6,7 +6,7 @@
  */
 import { beforeEach, describe, expect, test } from "bun:test";
 
-import type { AgentEvent } from "../agent/loop.js";
+import type { AgentEvent, PreparedModelCall } from "../agent/loop.js";
 import { AgentLoop } from "../agent/loop.js";
 import type {
   PostModelCallContext,
@@ -18,12 +18,14 @@ import type {
   ContentBlock,
   Message,
   ProviderResponse,
+  ToolDefinition,
 } from "../providers/types.js";
 import {
   createMockProvider,
   textResponse,
   toolUseResponse,
 } from "./helpers/mock-provider.js";
+import { setConfig } from "./helpers/set-config.js";
 
 const userMessage: Message = {
   role: "user",
@@ -91,6 +93,7 @@ function registerOutputHookPlugin(hooks: {
 describe("agent loop output hooks", () => {
   beforeEach(() => {
     resetPluginRegistryAndRegisterDefaults();
+    setConfig("llm", {});
   });
 
   test("post-model-call transforms the persisted message content", async () => {
@@ -403,6 +406,152 @@ describe("agent loop output hooks", () => {
     expect(calls[0].options?.config?.overrideProfile).toBe("fast-profile");
   });
 
+  test("prepared model call carries the post-hook route and wire tool surface", async () => {
+    registerOutputHookPlugin({
+      preModelCall: (ctx) => {
+        ctx.systemPrompt = `${ctx.systemPrompt ?? ""} [EDITED]`;
+        ctx.modelProfile = "fast-profile";
+      },
+    });
+    const tool: ToolDefinition = {
+      name: "dynamic_tool",
+      description: "Dynamic",
+      input_schema: { type: "object" },
+    };
+    const { provider, calls } = createMockProvider([textResponse("hi")]);
+    Object.assign(provider, { supportsNativeWebSearch: true });
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "base prompt",
+      conversationId: "test-conversation",
+      config: { enableNativeWebSearch: true },
+      resolveTools: () => [tool],
+    });
+    let prepared: PreparedModelCall | undefined;
+
+    await loop.run({
+      requestId: "test-request",
+      messages: [userMessage],
+      onEvent: collect([]),
+      callSite: "mainAgent",
+      overrideProfile: "conversation-profile",
+      forceOverrideProfile: true,
+      onModelCallPrepared: (value) => {
+        prepared = value;
+      },
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
+
+    expect(prepared).toMatchObject({
+      callSite: "mainAgent",
+      overrideProfile: "fast-profile",
+      forceOverrideProfile: true,
+      systemPrompt: "base prompt [EDITED]",
+    });
+    expect(prepared?.tools.map((item) => item.name)).toEqual([
+      "dynamic_tool",
+      "web_search",
+    ]);
+    expect(calls[0].tools).toEqual(prepared?.tools);
+  });
+
+  test("prepared model call carries the finalized cache policy", async () => {
+    setConfig("llm", {
+      callSites: { mainAgent: { disableCache: true } },
+    });
+    const { provider } = createMockProvider([textResponse("hi")]);
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "base prompt",
+      conversationId: "test-conversation",
+    });
+    let prepared: PreparedModelCall | undefined;
+
+    await loop.run({
+      requestId: "test-request",
+      messages: [userMessage],
+      onEvent: collect([]),
+      callSite: "mainAgent",
+      onModelCallPrepared: (value) => {
+        prepared = value;
+      },
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
+
+    expect(prepared?.disableCache).toBe(true);
+  });
+
+  test("prepared model call preserves explicit system-prompt removal", async () => {
+    registerOutputHookPlugin({
+      preModelCall: (ctx) => {
+        ctx.systemPrompt = null;
+      },
+    });
+    const { provider, calls } = createMockProvider([textResponse("hi")]);
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "base prompt",
+      conversationId: "test-conversation",
+    });
+    let prepared: PreparedModelCall | undefined;
+
+    await loop.run({
+      requestId: "test-request",
+      messages: [userMessage],
+      onEvent: collect([]),
+      callSite: "mainAgent",
+      onModelCallPrepared: (value) => {
+        prepared = value;
+      },
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
+
+    expect(prepared?.systemPrompt).toBeNull();
+    expect(calls[0].options?.systemPrompt).toBeUndefined();
+  });
+
+  test("inference routing preserves the semantic call site for hooks and events", async () => {
+    const preModelCallSites: Array<string | null> = [];
+    const postModelCallSites: Array<string | null> = [];
+    registerOutputHookPlugin({
+      preModelCall: (ctx) => {
+        preModelCallSites.push(ctx.callSite);
+      },
+      postModelCall: (ctx) => {
+        postModelCallSites.push(ctx.callSite);
+      },
+    });
+    const { provider, calls } = createMockProvider([textResponse("hi")]);
+    const loop = new AgentLoop({
+      provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
+    });
+    const events: AgentEvent[] = [];
+    let prepared: PreparedModelCall | undefined;
+
+    await loop.run({
+      requestId: "test-request",
+      messages: [userMessage],
+      onEvent: collect(events),
+      callSite: "callAgent",
+      inferenceCallSite: "mainAgent",
+      onModelCallPrepared: (value) => {
+        prepared = value;
+      },
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
+
+    expect(calls[0].options?.config?.callSite).toBe("mainAgent");
+    expect(prepared?.callSite).toBe("mainAgent");
+    expect(preModelCallSites).toEqual(["callAgent"]);
+    expect(postModelCallSites).toEqual(["callAgent"]);
+    expect(events).toContainEqual({
+      type: "llm_call_started",
+      callSite: "callAgent",
+    });
+  });
+
   test("pre-model-call seeds modelProfile from the resolved override and clearing it drops the override", async () => {
     // GIVEN a hook that observes the seeded override and then clears it
     let seeded: string | null | undefined;

package/src/__tests__/call-conversation-messages.test.ts

@@ -102,6 +102,7 @@ describe("call-conversation-messages", () => {
     const conversationId = "conv-call-msg-failed";
     ensureConversation(conversationId);
     const session = createCallSession({
+      direction: "inbound",
       conversationId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -122,6 +123,7 @@ describe("call-conversation-messages", () => {
     const conversationId = "conv-call-msg-cancelled";
     ensureConversation(conversationId);
     const session = createCallSession({
+      direction: "inbound",
       conversationId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -142,6 +144,7 @@ describe("call-conversation-messages", () => {
     const conversationId = "conv-call-msg-completed";
     ensureConversation(conversationId);
     const session = createCallSession({
+      direction: "inbound",
       conversationId,
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -171,6 +174,7 @@ describe("call-conversation-messages", () => {
     const conversationId = "conv-call-msg-fallback";
     ensureConversation(conversationId);
     const session = createCallSession({
+      direction: "inbound",
       conversationId,
       provider: "twilio",
       fromNumber: "+12025550101",
@@ -208,6 +212,7 @@ describe("call-conversation-messages", () => {
     const conversationId = "conv-call-msg-schema";
     ensureConversation(conversationId);
     const session = createCallSession({
+      direction: "inbound",
       conversationId,
       provider: "twilio",
       fromNumber: "+12025550101",

package/src/__tests__/call-recovery.test.ts

@@ -54,9 +54,14 @@ function resetTables() {
   ensuredConvIds = new Set();
 }
 
-function createTestCallSession(opts: Parameters<typeof createCallSession>[0]) {
+function createTestCallSession(
+  opts: Omit<Parameters<typeof createCallSession>[0], "direction"> & {
+    direction?: Parameters<typeof createCallSession>[0]["direction"];
+  },
+) {
   ensureConversation(opts.conversationId);
-  return createCallSession(opts);
+  // Direction only shapes the funnel stamp; these suites test other things.
+  return createCallSession({ direction: "inbound", ...opts });
 }
 
 /** Backdate a session's createdAt so it appears older than the grace period. */

package/src/__tests__/call-routes-http.test.ts

@@ -327,6 +327,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-get-1");
 
     const session = createCallSession({
+      direction: "outbound",
       conversationId: "conv-get-1",
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -378,6 +379,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-cancel-1");
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: "conv-cancel-1",
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -407,6 +409,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-cancel-2");
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: "conv-cancel-2",
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -447,6 +450,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-answer-badjson");
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: "conv-answer-badjson",
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -469,6 +473,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-answer-1");
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: "conv-answer-1",
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -495,6 +500,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-answer-2");
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: "conv-answer-2",
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -517,6 +523,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-answer-3");
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: "conv-answer-3",
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -548,6 +555,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-instr-badjson");
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: "conv-instr-badjson",
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -570,6 +578,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-instr-empty");
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: "conv-instr-empty",
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -596,6 +605,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-instr-missing");
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: "conv-instr-missing",
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -640,6 +650,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-instr-ended");
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: "conv-instr-ended",
       provider: "twilio",
       fromNumber: "+15550001111",
@@ -668,6 +679,7 @@ describe("runtime call routes — HTTP layer", () => {
     ensureConversation("conv-instr-no-orch");
 
     const session = createCallSession({
+      direction: "inbound",
       conversationId: "conv-instr-no-orch",
       provider: "twilio",
       fromNumber: "+15550001111",

package/src/__tests__/call-store.test.ts

@@ -53,9 +53,14 @@ function resetTables() {
 }
 
 /** Wrapper that ensures the FK conversation row exists before creating a session. */
-function createTestCallSession(opts: Parameters<typeof createCallSession>[0]) {
+function createTestCallSession(
+  opts: Omit<Parameters<typeof createCallSession>[0], "direction"> & {
+    direction?: Parameters<typeof createCallSession>[0]["direction"];
+  },
+) {
   ensureConversation(opts.conversationId);
-  return createCallSession(opts);
+  // Direction only shapes the funnel stamp; these suites test other things.
+  return createCallSession({ direction: "inbound", ...opts });
 }
 
 describe("call-store", () => {

package/src/__tests__/conversation-agent-loop-disk-pressure.test.ts

@@ -169,6 +169,7 @@ describe("runAgentLoopImpl disk pressure gate", () => {
     const events: AssistantEvent[] = [];
     const activityStates: unknown[][] = [];
     const drainQueue = mock(async (_reason: unknown) => {});
+    const onFirstModelCallPrepared = mock(() => {});
     const ctx = makeCtx({
       emitActivityState: (...args: unknown[]) => {
         activityStates.push(args);
@@ -176,8 +177,12 @@ describe("runAgentLoopImpl disk pressure gate", () => {
       drainQueue,
     });
 
-    await runAgentLoopImpl(ctx, "background task", "msg-1", (event) =>
-      events.push(event),
+    await runAgentLoopImpl(
+      ctx,
+      "background task",
+      "msg-1",
+      (event) => events.push(event),
+      { onFirstModelCallPrepared },
     );
 
     expect(events.find((event) => event.type === "error")).toMatchObject({
@@ -195,5 +200,6 @@ describe("runAgentLoopImpl disk pressure gate", () => {
     expect(ctx.abortController).toBeNull();
     expect(ctx.currentRequestId).toBeUndefined();
     expect(drainQueue).toHaveBeenCalledWith("loop_complete");
+    expect(onFirstModelCallPrepared).not.toHaveBeenCalled();
   });
 });

package/src/__tests__/conversation-agent-loop.test.ts

@@ -24,7 +24,12 @@ import { getConversationDirName } from "../persistence/conversation-directories.
 import type { UserPromptSubmitContext } from "../plugin-api/types.js";
 import { resetPluginRegistryAndRegisterDefaults } from "../plugins/defaults/index.js";
 import { registerPlugin } from "../plugins/registry.js";
-import type { Message, Provider, ToolDefinition } from "../providers/types.js";
+import type {
+  Message,
+  Provider,
+  SendMessageOptions,
+  ToolDefinition,
+} from "../providers/types.js";
 import { ContextOverflowError } from "../providers/types.js";
 import {
   resolveUsageAttribution,
@@ -715,7 +720,7 @@ mock.module("../persistence/llm-request-log-store.js", () => ({
 // ── Imports (after mocks) ────────────────────────────────────────────
 
 import { AgentLoop } from "../agent/loop.js";
-import type { Conversation } from "../daemon/conversation.js";
+import { Conversation } from "../daemon/conversation.js";
 import {
   applyCompactionResult,
   runAgentLoopImpl,
@@ -1100,6 +1105,82 @@ beforeEach(() => {
   resetPluginRegistryAndRegisterDefaults();
 });
 
+describe("prompt cache warming", () => {
+  test("attributes provider usage to the conversation", async () => {
+    const sendMessage = mock(
+      async (_messages: Message[], _options?: SendMessageOptions) =>
+        textResponse("unused"),
+    );
+    const conversation = Object.assign(
+      Object.create(Conversation.prototype) as object,
+      {
+        conversationId: "conv-cache-warm-test",
+        messages: [],
+        provider: { name: "mock-provider", sendMessage },
+        agentLoop: { getResolvedTools: () => [] },
+        buildCurrentSystemPrompt: () => "system prompt",
+      },
+    ) as unknown as Conversation;
+
+    await conversation.warmPromptCache();
+
+    expect(sendMessage).toHaveBeenCalledTimes(1);
+    expect(sendMessage.mock.calls[0]?.[1]?.config).toMatchObject({
+      callSite: "mainAgent",
+      conversationId: "conv-cache-warm-test",
+      max_tokens: 16,
+      selectionSeed: "conv-cache-warm-test",
+    });
+    expect(
+      sendMessage.mock.calls[0]?.[1]?.config?.usageTracking,
+    ).toBeUndefined();
+  });
+
+  test("stays non-rejecting when request preparation fails", async () => {
+    const sendMessage = mock(async () => textResponse("unused"));
+    const conversation = Object.assign(
+      Object.create(Conversation.prototype) as object,
+      {
+        conversationId: "conv-cache-warm-test",
+        messages: [],
+        provider: { name: "mock-provider", sendMessage },
+        agentLoop: {
+          getResolvedTools: () => {
+            throw new Error("tool resolution failed");
+          },
+        },
+        buildCurrentSystemPrompt: () => "system prompt",
+      },
+    ) as unknown as Conversation;
+
+    await expect(conversation.warmPromptCache()).resolves.toBeUndefined();
+    expect(sendMessage).not.toHaveBeenCalled();
+  });
+
+  test("does not rebuild a system prompt explicitly removed by a hook", async () => {
+    const sendMessage = mock(
+      async (_messages: Message[], _options?: SendMessageOptions) =>
+        textResponse("unused"),
+    );
+    const buildCurrentSystemPrompt = mock(() => "rebuilt prompt");
+    const conversation = Object.assign(
+      Object.create(Conversation.prototype) as object,
+      {
+        conversationId: "conv-cache-warm-test",
+        messages: [],
+        provider: { name: "mock-provider", sendMessage },
+        agentLoop: { getResolvedTools: () => [] },
+        buildCurrentSystemPrompt,
+      },
+    ) as unknown as Conversation;
+
+    await conversation.warmPromptCache({ systemPrompt: null, tools: [] });
+
+    expect(buildCurrentSystemPrompt).not.toHaveBeenCalled();
+    expect(sendMessage.mock.calls[0]?.[1]?.systemPrompt).toBeUndefined();
+  });
+});
+
 describe("session-agent-loop", () => {
   describe("user-prompt-submit hook failures", () => {
     test("passes the effective profile to hooks even when it was already announced", async () => {
@@ -2165,6 +2246,43 @@ describe("session-agent-loop", () => {
       const call = recordRequestLogMock.mock.calls[0] as unknown as unknown[];
       expect(call[5]).toBe("callAgent");
     });
+
+    test("reports only the first finalized model call", async () => {
+      const tool: ToolDefinition = {
+        name: "echo",
+        description: "Echo",
+        input_schema: { type: "object" },
+      };
+      const onFirstModelCallPrepared = mock(() => {});
+      const ctx = makeCtx({
+        providerResponses: [
+          toolUseResponse("tool-1", "echo", {}),
+          textResponse("done"),
+        ],
+        loopTools: [tool],
+        toolExecutor: async () => ({ content: "ok", isError: false }),
+      });
+      const turnSignal = ctx.abortController?.signal;
+
+      await runAgentLoopImpl(ctx, "hello", "msg-1", () => {}, {
+        callSite: "callAgent",
+        inferenceCallSite: "mainAgent",
+        overrideProfile: "quality-optimized",
+        forceOverrideProfile: true,
+        onFirstModelCallPrepared,
+      });
+
+      expect(onFirstModelCallPrepared).toHaveBeenCalledTimes(1);
+      expect(onFirstModelCallPrepared).toHaveBeenCalledWith({
+        callSite: "mainAgent",
+        overrideProfile: "quality-optimized",
+        forceOverrideProfile: true,
+        signal: turnSignal,
+        systemPrompt: "system prompt",
+        tools: [tool],
+      });
+      expect(ctx.currentCallSite).toBe("callAgent");
+    });
   });
 
   describe("usage accounting", () => {

package/src/__tests__/deterministic-verification-control-plane.test.ts

@@ -153,6 +153,7 @@ describe("Call session mode metadata", () => {
 
     const { conversationId } = getOrCreateConversation("test-conv-mode");
     const session = createCallSession({
+      direction: "inbound",
       conversationId,
       provider: "twilio",
       fromNumber: "+15551234567",
@@ -181,6 +182,7 @@ describe("Call session mode metadata", () => {
       "test-conv-mode-default",
     );
     const session = createCallSession({
+      direction: "inbound",
       conversationId,
       provider: "twilio",
       fromNumber: "+15551234567",