@vellumai/assistant 0.7.0 → 0.7.2

package/src/__tests__/assistant-feature-flags-integration.test.ts

@@ -12,7 +12,7 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 // Test-scoped config state
 // ---------------------------------------------------------------------------
 
-const DECLARED_FLAG_ID = "sounds";
+const DECLARED_FLAG_ID = "email-channel";
 const DECLARED_FLAG_KEY = DECLARED_FLAG_ID;
 
 const { isAssistantFeatureFlagEnabled, _setOverridesForTesting } =
@@ -54,10 +54,12 @@ describe("isAssistantFeatureFlagEnabled", () => {
 
   test("missing persisted value falls back to defaults registry defaultEnabled", () => {
     // No explicit config at all — should fall back to defaults registry
-    // which has defaultEnabled: true for sounds
+    // which has defaultEnabled: false for email-channel
     const config = {} as any;
 
-    expect(isAssistantFeatureFlagEnabled(DECLARED_FLAG_KEY, config)).toBe(true);
+    expect(isAssistantFeatureFlagEnabled(DECLARED_FLAG_KEY, config)).toBe(
+      false,
+    );
   });
 
   test("unknown flag defaults to true when no persisted override", () => {
@@ -67,10 +69,12 @@ describe("isAssistantFeatureFlagEnabled", () => {
   });
 
   test("undeclared flag respects persisted override", () => {
-    _setOverridesForTesting({ browser: false });
+    _setOverridesForTesting({ "some-undeclared-flag": false });
     const config = {} as any;
 
-    expect(isAssistantFeatureFlagEnabled("browser", config)).toBe(false);
+    expect(isAssistantFeatureFlagEnabled("some-undeclared-flag", config)).toBe(
+      false,
+    );
   });
 });
 
@@ -87,7 +91,7 @@ describe("isAssistantFeatureFlagEnabled with skillFlagKey", () => {
     ).toBe(false);
   });
 
-  test("enabled when no override set (registry default is true)", () => {
+  test("disabled when no override set (registry default is false)", () => {
     const config = {} as any;
 
     expect(
@@ -95,35 +99,6 @@ describe("isAssistantFeatureFlagEnabled with skillFlagKey", () => {
         skillFlagKey({ featureFlag: DECLARED_FLAG_ID })!,
         config,
       ),
-    ).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// compaction-v2 flag (opt-in): ensures registry-declared defaultEnabled=false
-// is honored and that an explicit override can flip it on. Guards the rollout
-// gate for the boundary-message-based compaction pipeline introduced in
-// later PRs.
-// ---------------------------------------------------------------------------
-
-describe("compaction-v2 flag", () => {
-  test("defaults to false (disabled) when no override is set", () => {
-    const config = {} as any;
-
-    expect(isAssistantFeatureFlagEnabled("compaction-v2", config)).toBe(false);
-  });
-
-  test("returns true when explicitly overridden to true", () => {
-    _setOverridesForTesting({ "compaction-v2": true });
-    const config = {} as any;
-
-    expect(isAssistantFeatureFlagEnabled("compaction-v2", config)).toBe(true);
-  });
-
-  test("returns false when explicitly overridden to false", () => {
-    _setOverridesForTesting({ "compaction-v2": false });
-    const config = {} as any;
-
-    expect(isAssistantFeatureFlagEnabled("compaction-v2", config)).toBe(false);
+    ).toBe(false);
   });
 });

package/src/__tests__/background-shell-host-bash.test.ts

@@ -66,8 +66,6 @@ const mockConfig = {
   rateLimit: { maxRequestsPerMinute: 0 },
   secretDetection: {
     enabled: true,
-    action: "warn" as const,
-    entropyThreshold: 4.0,
   },
   auditLog: { retentionDays: 0 },
 };
@@ -76,7 +74,6 @@ mock.module("../config/loader.js", () => ({
   getConfig: () => mockConfig,
   loadConfig: () => mockConfig,
   invalidateConfigCache: () => {},
-  saveConfig: () => {},
   loadRawConfig: () => ({}),
   saveRawConfig: () => {},
   getNestedValue: () => undefined,
@@ -90,12 +87,30 @@ mock.module("../util/logger.js", () => ({
     }),
 }));
 
-mock.module("../tools/terminal/sandbox.js", () => ({
-  wrapCommand: (...args: unknown[]) => ({
-    command: "bash",
-    args: ["-c", "--", args[0]],
-    sandboxed: false,
-  }),
+// Mock HostBashProxy singleton — proxy delegation tests configure this.
+let mockProxyAvailable = false;
+let mockProxyRequestImpl: (
+  input: {
+    command: string;
+    working_dir?: string;
+    timeout_seconds?: number;
+    env?: Record<string, string>;
+  },
+  conversationId: string,
+  signal?: AbortSignal,
+) => Promise<ToolExecutionResult> = () =>
+  Promise.resolve({ content: "", isError: false });
+
+mock.module("../daemon/host-bash-proxy.js", () => ({
+  HostBashProxy: {
+    get instance() {
+      return {
+        isAvailable: () => mockProxyAvailable,
+        request: (...args: Parameters<typeof mockProxyRequestImpl>) =>
+          mockProxyRequestImpl(...args),
+      };
+    },
+  },
 }));
 
 // ---------------------------------------------------------------------------
@@ -118,7 +133,7 @@ function makeContext(overrides: Partial<ToolContext> = {}): ToolContext {
   };
 }
 
-function makeMockProxy(result: ToolExecutionResult) {
+function setupMockProxy(result: ToolExecutionResult) {
   const requestMock = mock(
     (
       _input: {
@@ -132,17 +147,10 @@ function makeMockProxy(result: ToolExecutionResult) {
     ) => Promise.resolve(result),
   );
 
-  return {
-    proxy: {
-      isAvailable: () => true,
-      request: requestMock,
-      updateSender: () => {},
-      dispose: () => {},
-      resolve: () => {},
-      hasPendingRequest: () => false,
-    },
-    requestMock,
-  };
+  mockProxyAvailable = true;
+  mockProxyRequestImpl = requestMock;
+
+  return requestMock;
 }
 
 // ---------------------------------------------------------------------------
@@ -158,10 +166,13 @@ beforeEach(() => {
   mockIsBackgroundToolLimitReached.mockClear();
   mockIsBackgroundToolLimitReached.mockReturnValue(false);
   latestChild = undefined;
+  mockProxyAvailable = false;
+  mockProxyRequestImpl = () => Promise.resolve({ content: "", isError: false });
 });
 
 afterEach(() => {
   latestChild = undefined;
+  mockProxyAvailable = false;
 });
 
 // ---------------------------------------------------------------------------
@@ -174,11 +185,9 @@ describe("host_bash background mode — proxy path", () => {
       content: "proxy output",
       isError: false,
     };
-    const { proxy } = makeMockProxy(proxyResult);
+    setupMockProxy(proxyResult);
 
-    const ctx = makeContext({
-      hostBashProxy: proxy as unknown as ToolContext["hostBashProxy"],
-    });
+    const ctx = makeContext({});
 
     const result = await hostShellTool.execute(
       { command: "echo bg-proxy", background: true },
@@ -196,11 +205,9 @@ describe("host_bash background mode — proxy path", () => {
       content: "proxy output",
       isError: false,
     };
-    const { proxy } = makeMockProxy(proxyResult);
+    setupMockProxy(proxyResult);
 
-    const ctx = makeContext({
-      hostBashProxy: proxy as unknown as ToolContext["hostBashProxy"],
-    });
+    const ctx = makeContext({});
 
     await hostShellTool.execute(
       { command: "echo bg-proxy", background: true },
@@ -221,11 +228,9 @@ describe("host_bash background mode — proxy path", () => {
       content: "proxy success output",
       isError: false,
     };
-    const { proxy } = makeMockProxy(proxyResult);
+    setupMockProxy(proxyResult);
 
-    const ctx = makeContext({
-      hostBashProxy: proxy as unknown as ToolContext["hostBashProxy"],
-    });
+    const ctx = makeContext({});
 
     await hostShellTool.execute(
       { command: "echo bg-proxy", background: true },
@@ -252,11 +257,9 @@ describe("host_bash background mode — proxy path", () => {
       content: "command not found",
       isError: true,
     };
-    const { proxy } = makeMockProxy(proxyResult);
+    setupMockProxy(proxyResult);
 
-    const ctx = makeContext({
-      hostBashProxy: proxy as unknown as ToolContext["hostBashProxy"],
-    });
+    const ctx = makeContext({});
 
     await hostShellTool.execute(
       { command: "bad-command", background: true },
@@ -274,22 +277,11 @@ describe("host_bash background mode — proxy path", () => {
   });
 
   test("calls wakeAgentForOpportunity on proxy rejection", async () => {
-    const requestMock = mock(() =>
-      Promise.reject(new Error("proxy transport error")),
-    );
-
-    const proxy = {
-      isAvailable: () => true,
-      request: requestMock,
-      updateSender: () => {},
-      dispose: () => {},
-      resolve: () => {},
-      hasPendingRequest: () => false,
-    };
+    mockProxyAvailable = true;
+    mockProxyRequestImpl = () =>
+      Promise.reject(new Error("proxy transport error"));
 
-    const ctx = makeContext({
-      hostBashProxy: proxy as unknown as ToolContext["hostBashProxy"],
-    });
+    const ctx = makeContext({});
 
     await hostShellTool.execute(
       { command: "echo fail", background: true },
@@ -311,11 +303,9 @@ describe("host_bash background mode — proxy path", () => {
       content: "done",
       isError: false,
     };
-    const { proxy } = makeMockProxy(proxyResult);
+    setupMockProxy(proxyResult);
 
-    const ctx = makeContext({
-      hostBashProxy: proxy as unknown as ToolContext["hostBashProxy"],
-    });
+    const ctx = makeContext({});
 
     const result = await hostShellTool.execute(
       { command: "echo bg-proxy", background: true },

package/src/__tests__/bootstrap-turn-cleanup.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  BOOTSTRAP_CLEANUP_USER_TURN_THRESHOLD,
+  countBootstrapUserTurns,
+  shouldCleanupBootstrapAfterTurn,
+} from "../daemon/bootstrap-turn-cleanup.js";
+
+function message(role: string, content: string) {
+  return { role, content };
+}
+
+describe("bootstrap turn cleanup", () => {
+  test("does not count the hidden wake-up greeting as a user turn", () => {
+    const messages = [
+      message(
+        "user",
+        JSON.stringify([{ type: "text", text: "Wake up, my friend." }]),
+      ),
+      message("assistant", "hello"),
+      message("user", "real request"),
+    ];
+
+    expect(countBootstrapUserTurns(messages)).toBe(1);
+  });
+
+  test("cleans up after the configured user-turn threshold", () => {
+    const messages = Array.from(
+      { length: BOOTSTRAP_CLEANUP_USER_TURN_THRESHOLD },
+      (_value, index) => message("user", `request ${index + 1}`),
+    );
+
+    expect(shouldCleanupBootstrapAfterTurn(messages)).toBe(true);
+  });
+
+  test("keeps bootstrap before the configured user-turn threshold", () => {
+    const messages = Array.from(
+      { length: BOOTSTRAP_CLEANUP_USER_TURN_THRESHOLD - 1 },
+      (_value, index) => message("user", `request ${index + 1}`),
+    );
+
+    expect(shouldCleanupBootstrapAfterTurn(messages)).toBe(false);
+  });
+});

package/src/__tests__/btw-routes.test.ts

@@ -73,13 +73,16 @@ mock.module("../prompts/persona-resolver.js", () => ({
 
 mock.module("../runtime/routes/identity-intro-cache.js", () => ({
   getCachedIntro: () => null,
+  readWorkspaceIdentityIntro: () => null,
   setCachedIntro: () => {},
   computeIdentityContentHash: () => "test-hash",
 }));
 
 // Mock getOrCreateConversation from conversation-store so the handler
 // never touches DaemonServer.
-const mockGetOrCreateConversation = mock(async (_id: string) => makeMockSession());
+const mockGetOrCreateConversation = mock(async (_id: string) =>
+  makeMockSession(),
+);
 
 mock.module("../daemon/conversation-store.js", () => ({
   getOrCreateConversation: mockGetOrCreateConversation,
@@ -114,7 +117,10 @@ import type {
   SendMessageOptions,
 } from "../providers/types.js";
 import { ROUTES } from "../runtime/routes/btw-routes.js";
-import { BadRequestError, ServiceUnavailableError } from "../runtime/routes/errors.js";
+import {
+  BadRequestError,
+  ServiceUnavailableError,
+} from "../runtime/routes/errors.js";
 import type { RouteHandlerArgs } from "../runtime/routes/types.js";
 
 // ---------------------------------------------------------------------------
@@ -199,7 +205,8 @@ async function readStream(stream: ReadableStream<Uint8Array>): Promise<string> {
     chunks.push(value);
   }
   return new TextDecoder().decode(
-    new Uint8Array(chunks.reduce((a, c) => a + c.length, 0)).buffer.byteLength === 0
+    new Uint8Array(chunks.reduce((a, c) => a + c.length, 0)).buffer
+      .byteLength === 0
       ? new Uint8Array(0)
       : Buffer.concat(chunks),
   );
@@ -415,6 +422,8 @@ describe("POST /v1/btw", () => {
     });
     await readStream(result as ReadableStream<Uint8Array>);
 
-    expect(mockGetOrCreateConversation).toHaveBeenCalledWith("existing-conv-id");
+    expect(mockGetOrCreateConversation).toHaveBeenCalledWith(
+      "existing-conv-id",
+    );
   });
 });

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

@@ -38,6 +38,10 @@ mock.module("../config/loader.js", () => {
     },
     memory: { enabled: false },
     notifications: {},
+    ingress: {
+      enabled: true,
+      publicBaseUrl: "https://generic.example.com",
+    },
     services: {
       tts: {
         mode: "your-own" as const,
@@ -77,7 +81,6 @@ mock.module("../config/loader.js", () => {
     getConfig: () => config,
     loadConfig: () => config,
     loadRawConfig: () => ({}),
-    saveConfig: () => {},
     saveRawConfig: () => {},
     invalidateConfigCache: () => {},
     applyNestedDefaults: (c: unknown) => c,
@@ -243,7 +246,6 @@ import {
 import type { CallTransport } from "../calls/call-transport.js";
 import { resolveCallTtsProvider } from "../calls/resolve-call-tts-provider.js";
 import { loadConfig } from "../config/loader.js";
-import { createGuardianBinding } from "../contacts/contacts-write.js";
 import {
   getCanonicalGuardianRequest,
   getPendingCanonicalRequestByCallSessionId,
@@ -253,6 +255,7 @@ import { getDb, resetDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { resetTestTables } from "../memory/raw-query.js";
 import { conversations } from "../memory/schema.js";
+import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
 
 initializeDb();
 
@@ -468,6 +471,7 @@ describe("call-controller", () => {
     const cfg = loadConfig();
     cfg.services.tts.provider = "elevenlabs";
     cfg.services.tts.providers["fish-audio"].referenceId = "";
+    cfg.ingress.publicBaseUrl = "https://generic.example.com";
     // Reset TTS provider registry to ensure clean state
     registerTestTtsProviders();
   });
@@ -2532,6 +2536,50 @@ describe("call-controller", () => {
     controller.destroy();
   });
 
+  test("synthesized provider: play URL uses public base URL", async () => {
+    const cfg = loadConfig();
+    cfg.ingress.publicBaseUrl = "https://twilio.example.com/";
+    cfg.services.tts.provider = "fish-audio";
+    cfg.services.tts.providers["fish-audio"].referenceId = "fish-ref-123";
+
+    _resetTtsProviderRegistry();
+    const fishAudioStreaming: TtsProvider = {
+      id: "fish-audio",
+      capabilities: {
+        supportsStreaming: true,
+        supportedFormats: ["mp3", "wav", "opus"],
+      },
+      async synthesize() {
+        return {
+          audio: Buffer.from("fish-audio-buffer"),
+          contentType: "audio/mpeg",
+        };
+      },
+      async synthesizeStream(_request, onChunk) {
+        onChunk(Buffer.from("fish-audio-stream"));
+        return {
+          audio: Buffer.from("fish-audio-stream"),
+          contentType: "audio/mpeg",
+        };
+      },
+    };
+    registerTtsProvider(fishAudioStreaming);
+
+    mockStartVoiceTurn.mockImplementation(
+      createMockVoiceTurn(["Hello from synthesized path."]),
+    );
+    const { relay, controller } = setupController();
+
+    await controller.handleCallerUtterance("Hi");
+
+    expect(relay.sentPlayUrls.length).toBeGreaterThan(0);
+    expect(relay.sentPlayUrls[0]).toStartWith(
+      "https://twilio.example.com/v1/audio/",
+    );
+
+    controller.destroy();
+  });
+
   test("Deepgram selected path resolves useSynthesizedPath to true", () => {
     const cfg = loadConfig();
     cfg.services.tts.provider = "deepgram";

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

@@ -28,8 +28,6 @@ mock.module("../calls/twilio-config.js", () => ({
     accountSid: "AC_test",
     authToken: "test_token",
     phoneNumber: assistantId === "ast-alpha" ? "+15550003333" : "+15550001111",
-    webhookBaseUrl: "https://test.example.com",
-    wssBaseUrl: "wss://test.example.com",
   }),
 }));
 

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

@@ -77,8 +77,6 @@ mock.module("../calls/twilio-config.js", () => ({
     accountSid: "AC_test",
     authToken: "test_token",
     phoneNumber: assistantId === "asst-alpha" ? "+15550009999" : "+15550001111",
-    webhookBaseUrl: "https://test.example.com",
-    wssBaseUrl: "wss://test.example.com",
   }),
 }));
 

package/src/__tests__/call-site-routing-provider.test.ts

@@ -194,6 +194,91 @@ describe("CallSiteRoutingProvider", () => {
     expect(response.model).toBe("anthropic");
   });
 
+  test("stamps actualProvider when routing to an alternative provider", async () => {
+    setLlmConfig({
+      default: { provider: "anthropic", model: "claude-opus-4-7" },
+      callSites: {
+        memoryRetrieval: { provider: "openai", model: "gpt-5.5" },
+      },
+    });
+
+    const defaultProvider = makeProvider("anthropic", () => {});
+    const altProvider = makeProvider("openai", () => {});
+
+    const wrapped = new CallSiteRoutingProvider(defaultProvider, (name) =>
+      name === "openai" ? altProvider : undefined,
+    );
+
+    const response = await wrapped.sendMessage(
+      DUMMY_MESSAGES,
+      undefined,
+      undefined,
+      { config: { callSite: "memoryRetrieval" } },
+    );
+
+    // actualProvider must reflect the alternative, not the default, so that
+    // loop.ts / emitUsage / llm_call_finished log and bill the correct
+    // provider (fixes gpt-5.5 showing as "anthropic" with $0 cost).
+    expect(response.actualProvider).toBe("openai");
+  });
+
+  test("does not overwrite actualProvider already set by the alternative provider", async () => {
+    setLlmConfig({
+      default: { provider: "anthropic", model: "claude-opus-4-7" },
+      callSites: {
+        memoryRetrieval: { provider: "openai", model: "gpt-5.5" },
+      },
+    });
+
+    const defaultProvider = makeProvider("anthropic", () => {});
+    // Simulate a wrapper provider that sets actualProvider itself
+    const altProvider: Provider = {
+      name: "openai",
+      async sendMessage() {
+        return {
+          ...makeResponse("openai"),
+          actualProvider: "openai-via-proxy",
+        };
+      },
+    };
+
+    const wrapped = new CallSiteRoutingProvider(defaultProvider, (name) =>
+      name === "openai" ? altProvider : undefined,
+    );
+
+    const response = await wrapped.sendMessage(
+      DUMMY_MESSAGES,
+      undefined,
+      undefined,
+      { config: { callSite: "memoryRetrieval" } },
+    );
+
+    expect(response.actualProvider).toBe("openai-via-proxy");
+  });
+
+  test("does not set actualProvider when routing to the default provider", async () => {
+    setLlmConfig({
+      default: { provider: "anthropic", model: "claude-opus-4-7" },
+    });
+
+    const defaultProvider = makeProvider("anthropic", () => {});
+
+    const wrapped = new CallSiteRoutingProvider(
+      defaultProvider,
+      () => undefined,
+    );
+
+    const response = await wrapped.sendMessage(
+      DUMMY_MESSAGES,
+      undefined,
+      undefined,
+      { config: { callSite: "memoryRetrieval" } },
+    );
+
+    // No alternative was resolved — actualProvider should stay unset.
+    expect(response.actualProvider).toBeUndefined();
+  });
+
   test("delegates `name` and `tokenEstimationProvider` to the default provider", () => {
     const defaultProvider: Provider = {
       name: "anthropic",
@@ -211,4 +296,112 @@ describe("CallSiteRoutingProvider", () => {
     expect(wrapped.name).toBe("anthropic");
     expect(wrapped.tokenEstimationProvider).toBe("anthropic");
   });
+
+  test("name getter reflects the routed provider during sendMessage and reverts after", async () => {
+    // Regression: emitLlmCallStartedIfNeeded fires on the first text_delta,
+    // *during* the sendMessage call (before the response completes). It reads
+    // provider.name directly — if that's always the default name the trace
+    // event says "LLM call to anthropic" even when the call went to openai.
+    setLlmConfig({
+      default: { provider: "anthropic", model: "claude-opus-4-7" },
+      callSites: {
+        memoryRetrieval: { provider: "openai", model: "gpt-5.5" },
+      },
+    });
+
+    const defaultProvider = makeProvider("anthropic", () => {});
+    const namesDuringCall: string[] = [];
+
+    const altProvider: Provider = {
+      name: "openai",
+      async sendMessage() {
+        // Simulate reading provider.name mid-stream (as handleTextDelta does).
+        namesDuringCall.push(wrapped.name);
+        return makeResponse("openai");
+      },
+    };
+
+    const wrapped = new CallSiteRoutingProvider(defaultProvider, (name) =>
+      name === "openai" ? altProvider : undefined,
+    );
+
+    expect(wrapped.name).toBe("anthropic"); // idle → default
+    await wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+      config: { callSite: "memoryRetrieval" },
+    });
+    expect(namesDuringCall).toEqual(["openai"]); // mid-call → routed provider
+    expect(wrapped.name).toBe("anthropic"); // after call → reverted to default
+  });
+
+  test("concurrent sendMessage calls each see their own provider name (no clobbering)", async () => {
+    // Regression: if _routedProviderName were a plain instance field, concurrent
+    // calls (e.g. main turn + title-gen both in-flight) would clobber each
+    // other. AsyncLocalStorage gives each call its own async-context slot.
+    setLlmConfig({
+      default: { provider: "anthropic", model: "claude-opus-4-7" },
+      callSites: {
+        memoryRetrieval: { provider: "openai", model: "gpt-5.5" },
+        conversationTitle: { provider: "fireworks", model: "qwen3-235b" },
+      },
+    });
+
+    const defaultProvider = makeProvider("anthropic", () => {});
+    const nameSeenByOpenAI: string[] = [];
+    const nameSeenByFireworks: string[] = [];
+
+    // Shared resolve handles so we can interleave the two calls:
+    // openAI starts → fireworks starts → openAI resolves → fireworks resolves
+    let resolveOpenAI!: () => void;
+    let resolveFireworks!: () => void;
+
+    const openAIProvider: Provider = {
+      name: "openai",
+      async sendMessage() {
+        // Yield so fireworks call can start before we complete.
+        await new Promise<void>((r) => {
+          resolveOpenAI = r;
+        });
+        nameSeenByOpenAI.push(wrapped.name);
+        return makeResponse("openai");
+      },
+    };
+
+    const fireworksProvider: Provider = {
+      name: "fireworks",
+      async sendMessage() {
+        await new Promise<void>((r) => {
+          resolveFireworks = r;
+        });
+        nameSeenByFireworks.push(wrapped.name);
+        return makeResponse("fireworks");
+      },
+    };
+
+    const wrapped = new CallSiteRoutingProvider(defaultProvider, (name) => {
+      if (name === "openai") return openAIProvider;
+      if (name === "fireworks") return fireworksProvider;
+      return undefined;
+    });
+
+    // Start both calls concurrently (do not await yet).
+    const callA = wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+      config: { callSite: "memoryRetrieval" }, // → openai
+    });
+    const callB = wrapped.sendMessage(DUMMY_MESSAGES, undefined, undefined, {
+      config: { callSite: "conversationTitle" }, // → fireworks
+    });
+
+    // Let both reach their suspension point, then resolve in order.
+    await Promise.resolve(); // flush microtasks so both calls are in-flight
+    resolveOpenAI();
+    resolveFireworks();
+
+    await Promise.all([callA, callB]);
+
+    // Each call must have seen its own provider, not the other's.
+    expect(nameSeenByOpenAI).toEqual(["openai"]);
+    expect(nameSeenByFireworks).toEqual(["fireworks"]);
+    // And the idle name reverts to the default.
+    expect(wrapped.name).toBe("anthropic");
+  });
 });