@vellumai/assistant 0.11.4-staging.2 → 0.11.4-staging.3

package/src/plugins/defaults/memory/graph/conversation-graph-memory.ts

@@ -512,6 +512,10 @@ export class ConversationGraphMemory {
    * - Turn 1 (or after compaction): full context load
    * - Every other turn: per-turn injection
    *
+   * `routingMessages` may end before an internal continuation message. The
+   * retrievers derive their query from that view, while memory is still
+   * injected into `messages`, which is the history sent to the model.
+   *
    * Returns augmented messages with memory context prepended to the last
    * user message, following the same injection pattern as the old system.
    */
@@ -520,6 +524,7 @@ export class ConversationGraphMemory {
     config: AssistantConfig,
     abortSignal: AbortSignal,
     onEvent: (msg: AssistantEvent) => void,
+    routingMessages: Message[] = messages,
   ): Promise<{
     runMessages: Message[];
     injectedTokens: number;
@@ -579,7 +584,7 @@ export class ConversationGraphMemory {
 
     // Gate: skip for empty/tool-result-only messages — unless we need to
     // reload after compaction (needsReload) or haven't initialized yet.
-    const lastMessage = messages[messages.length - 1];
+    const lastMessage = routingMessages[routingMessages.length - 1];
     if (!lastMessage || lastMessage.role !== "user") {
       return noopResult;
     }
@@ -598,6 +603,7 @@ export class ConversationGraphMemory {
 
         return await this.runContextLoad(
           messages,
+          routingMessages,
           config,
           recentSummaries,
           firstUserText ?? undefined,
@@ -606,7 +612,12 @@ export class ConversationGraphMemory {
         );
       }
 
-      return await this.runPerTurn(messages, config, abortSignal);
+      return await this.runPerTurn(
+        messages,
+        routingMessages,
+        config,
+        abortSignal,
+      );
     } catch (err) {
       const errCode =
         err instanceof z.ZodError ? err.issues[0]?.code : undefined;
@@ -629,6 +640,7 @@ export class ConversationGraphMemory {
 
   private async runContextLoad(
     messages: Message[],
+    routingMessages: Message[],
     config: AssistantConfig,
     recentSummaries: string[],
     userQuery: string | undefined,
@@ -640,9 +652,12 @@ export class ConversationGraphMemory {
     // The activation pipeline is robust to weak ANN signal — it falls back
     // to spreading + nowText to surface candidates.
     const startedAt = Date.now();
-    const rawUserText = readRawUserText(messages[messages.length - 1]);
+    const rawUserText = readRawUserText(
+      routingMessages[routingMessages.length - 1],
+    );
     const v2 = await this.maybeRouteV2Injection(
       messages,
+      routingMessages,
       config,
       "context-load",
       // Context-load runs before the messages array necessarily contains
@@ -780,6 +795,7 @@ export class ConversationGraphMemory {
 
   private async runPerTurn(
     messages: Message[],
+    routingMessages: Message[],
     config: AssistantConfig,
     signal: AbortSignal,
   ) {
@@ -788,8 +804,8 @@ export class ConversationGraphMemory {
     let userLast = "";
     let userLastBlocks: ContentBlock[] = [];
 
-    for (let i = messages.length - 1; i >= 0; i--) {
-      const msg = messages[i];
+    for (let i = routingMessages.length - 1; i >= 0; i--) {
+      const msg = routingMessages[i];
       const text = msg.content
         .filter(
           (b): b is Extract<typeof b, { type: "text" }> => b.type === "text",
@@ -815,6 +831,7 @@ export class ConversationGraphMemory {
     const startedAt = Date.now();
     const v2 = await this.maybeRouteV2Injection(
       messages,
+      routingMessages,
       config,
       "per-turn",
       null,
@@ -978,6 +995,7 @@ export class ConversationGraphMemory {
    */
   private async maybeRouteV2Injection(
     messages: Message[],
+    routingMessages: Message[],
     config: AssistantConfig,
     mode: InjectMemoryV2Mode,
     /**
@@ -1004,7 +1022,7 @@ export class ConversationGraphMemory {
     const recentTurnPairs =
       userMessageOverride !== null
         ? [{ assistantMessage: "", userMessage: userMessageOverride }]
-        : extractRecentTurnPairs(messages, historicalPairs);
+        : extractRecentTurnPairs(routingMessages, historicalPairs);
 
     const result = await injectMemoryV2Block({
       conversationId: this.conversationId,

package/src/plugins/defaults/memory/hooks/user-prompt-submit.ts

@@ -31,7 +31,10 @@ import type {
   HookFunction,
   UserPromptSubmitContext,
 } from "@vellumai/plugin-api";
-import { updateMessageMetadata } from "@vellumai/plugin-api";
+import {
+  updateMessageMetadata,
+  VOICE_ESCALATION_CONTINUATION_MESSAGE_KIND,
+} from "@vellumai/plugin-api";
 
 import type { MemoryRecalledEvent } from "../../../../api/events/memory-recalled.js";
 import { getConfig } from "../../../../config/loader.js";
@@ -48,6 +51,7 @@ import { timeLatencySubSpan } from "../../../../daemon/turn-latency-sub-spans.js
 import { broadcastMessage } from "../../../../runtime/assistant-event-hub.js";
 import type { GraphMemoryResult } from "../graph/conversation-graph-memory.js";
 import { recordMemoryRecallLog } from "../memory-recall-log-store.js";
+import { stripTailInjectionsForReinjection } from "../tail-reinjection-strip.js";
 import { MEMORY_V3_INJECTED_BLOCK_METADATA_KEY } from "../v3/ever-injected-store.js";
 
 /**
@@ -69,6 +73,39 @@ export function shouldRunLegacyMemoryRetrieval(params: {
   return params.isTrustedActor && !params.memoryV3Live;
 }
 
+/**
+ * The voice escalation continuation is a model-control message, not a
+ * retrieval query. Route memory on the latest preceding user message and strip
+ * the runtime context that was frozen onto it during its original turn.
+ */
+function legacyRetrievalRoutingMessages(
+  messages: UserPromptSubmitContext["latestMessages"],
+  routeOnPreviousUser: boolean,
+): UserPromptSubmitContext["latestMessages"] {
+  if (!routeOnPreviousUser) {
+    return messages;
+  }
+
+  for (let i = messages.length - 2; i >= 0; i -= 1) {
+    if (messages[i]?.role !== "user") {
+      continue;
+    }
+    const candidate = stripTailInjectionsForReinjection(
+      messages.slice(0, i + 1),
+    );
+    const tail = candidate[candidate.length - 1];
+    if (
+      tail?.role === "user" &&
+      tail.content.some(
+        (block) => block.type === "text" && block.text.trim().length > 0,
+      )
+    ) {
+      return candidate;
+    }
+  }
+  return [];
+}
+
 /**
  * Persist and broadcast the retrieval's side effects: the injected block on
  * the user message's metadata (so it survives reloads), a recall-log row, and
@@ -263,10 +300,11 @@ async function persistInjectionBlocks(
  * runs for every actor, writing the fully injected result back onto
  * `latestMessages` and persisting the assembled blocks.
  *
- * Memory retrieval blocks the turn — there is no soft timeout here. Memory is
- * critical context, and silently dropping it produces a worse outcome than a
- * slower turn. Cancellation still works via `ctx.signal`, which is threaded
- * into `prepareMemory`.
+ * Memory retrieval ordinarily blocks the turn. The voice front door is the
+ * latency-sensitive exception: it keeps carried memory in the front prompt
+ * and defers current-turn retrieval to the escalated leg when one is needed.
+ * Cancellation still works via the live conversation signal for ordinary
+ * retrieval.
  */
 const userPromptSubmitMemoryRetrieval: HookFunction<
   UserPromptSubmitContext
@@ -292,9 +330,14 @@ const userPromptSubmitMemoryRetrieval: HookFunction<
   // fallback — a v3 empty/failed selection yields no NEW injected memory that
   // turn (prior turns' frozen v3 cards still ride history).
   const memoryV3Live = isMemoryV3Live(config);
+  const isVoiceFrontDoor = conversation?.currentCallSite === "voiceFrontDoor";
+  if (isVoiceFrontDoor && conversation) {
+    conversation.graphMemory.recordPkbQueryVectors(undefined, undefined);
+  }
   let v2BlockPersisted = false;
   if (
     shouldRunLegacyMemoryRetrieval({ isTrustedActor, memoryV3Live }) &&
+    !isVoiceFrontDoor &&
     conversation &&
     abortSignal
   ) {
@@ -311,6 +354,11 @@ const userPromptSubmitMemoryRetrieval: HookFunction<
           config,
           abortSignal,
           broadcastMessage,
+          legacyRetrievalRoutingMessages(
+            ctx.latestMessages,
+            ctx.isHiddenPrompt === true &&
+              ctx.messageKind === VOICE_ESCALATION_CONTINUATION_MESSAGE_KIND,
+          ),
         ),
     );
 

package/src/plugins/defaults/memory/memory-retrospective-job.ts

@@ -702,10 +702,10 @@ interface SourceParityPins {
  * parity; no system-prompt section branches on the flag, so this pin does not
  * affect prompt output) and the tool-context pin (the live consumer, gating
  * tool availability), using the live-turn derivation: interactive
- * interfaces run `updateClient(_, false)` (`hasNoClient = false`), while
- * channel-routed and chrome-extension turns stay clientless (`true`) — the
- * exact `isInteractiveInterface` predicate `conversation-routes.ts` /
- * `process-message.ts` apply. Pinned explicitly even when it matches the
+ * interfaces run their turns with `isInteractive: true` (`hasNoClient` reads
+ * `false` for the turn), while channel-routed and chrome-extension turns stay
+ * clientless (`true`) — the exact `isInteractiveInterface` predicate
+ * `conversation-routes.ts` / `process-message.ts` apply. Pinned explicitly even when it matches the
  * fork's hydrated value (`true`) so the parity contract doesn't depend on
  * hydration defaults.
  *

package/src/plugins/defaults/memory/v3/__tests__/injection.test.ts

@@ -364,6 +364,24 @@ describe("memoryV3Injector — frozen net-new cards", () => {
     expect(getActiveSlugs("conv-1")).toEqual(new Set());
   });
 
+  test("voice front door skips current-turn orchestration in both injectors", async () => {
+    liveEnabled = true;
+    turnResults.set(0, result(["page-a"]));
+    seedMemoryConfig();
+    const ctx = {
+      requestId: "req-voice",
+      conversationId: "conv-voice",
+      turnIndex: 0,
+      trust: GUARDIAN_TRUST,
+      callSite: "voiceFrontDoor" as const,
+    };
+
+    expect(await memoryV3Injector.produce(ctx)).toBeNull();
+    expect(await memoryV3SpotlightInjector.produce(ctx)).toBeNull();
+    expect(observeTurnSpy).not.toHaveBeenCalled();
+    expect(getActiveSlugs("conv-voice")).toEqual(new Set());
+  });
+
   test("live retrieval failure queues a degraded-memory notice", async () => {
     liveEnabled = true;
     turnResults.set(

package/src/plugins/defaults/memory/v3/__tests__/shadow-plugin.test.ts

@@ -24,9 +24,11 @@ import { join } from "node:path";
 import { Database } from "bun:sqlite";
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
 
+import { VOICE_ESCALATION_CONTINUATION_MESSAGE_KIND } from "@vellumai/plugin-api";
 import { drizzle } from "drizzle-orm/bun-sqlite";
 
 import { setConfig } from "../../../../../__tests__/helpers/set-config.js";
+import { ESCALATION_CONTINUATION_CONTENT } from "../../../../../calls/voice-triage-escalate.js";
 import { MemoryV3GateSchema } from "../../../../../config/schemas/memory-v3.js";
 import { ensureMemoryV3SelectionsSchema } from "../../../../../persistence/migrations/338-move-memory-v3-selections-to-memory-db.js";
 import { ensureMemoryV3EverInjectedSchema } from "../../../../../persistence/migrations/345-move-memory-v3-ever-injected-to-memory-db.js";
@@ -105,7 +107,11 @@ let selectorEnabledCfg = false;
 // Mutable `memory.v3.gate.enabled` config kill-switch carried by the mocked
 // config (default on, mirroring the schema default).
 let gateEnabledCfg = true;
-let messages: Array<{ role: string; content: string }> = [];
+let messages: Array<{
+  role: string;
+  content: string;
+  metadata?: string | null;
+}> = [];
 
 // Schema defaults for `memory.v3.gate` (the tuning the mocked config carries
 // and the gate-config threading test asserts against). Includes the default-on
@@ -714,6 +720,65 @@ describe("memory-v3 engine", () => {
     expect(turn.currentMessage).toBe("hello world");
   });
 
+  test("voice escalation continuation routes on the preceding caller message", async () => {
+    messages = [
+      {
+        role: "user",
+        content: JSON.stringify([
+          { type: "text", text: "what did I say my favorite color was?" },
+        ]),
+      },
+      {
+        role: "assistant",
+        content: JSON.stringify([
+          { type: "text", text: "Let me think about that for a second." },
+        ]),
+      },
+      {
+        role: "user",
+        content: JSON.stringify([
+          { type: "text", text: ESCALATION_CONTINUATION_CONTENT },
+        ]),
+        metadata: JSON.stringify({
+          hidden: true,
+          messageKind: VOICE_ESCALATION_CONTINUATION_MESSAGE_KIND,
+        }),
+      },
+    ];
+
+    await observeTurn("conv-1", 1);
+
+    const turn = (
+      orchestrateSpy.mock.calls as unknown as unknown[][]
+    )[0]![0] as MemoryRoutingTurn;
+    expect(turn.currentMessage).toBe("what did I say my favorite color was?");
+  });
+
+  test("generic hidden prompts route on their own content", async () => {
+    messages = [
+      {
+        role: "user",
+        content: JSON.stringify([
+          { type: "text", text: "visible caller message" },
+        ]),
+      },
+      {
+        role: "user",
+        content: JSON.stringify([
+          { type: "text", text: "generic hidden prompt" },
+        ]),
+        metadata: JSON.stringify({ hidden: true }),
+      },
+    ];
+
+    await observeTurn("conv-1", 1);
+
+    const turn = (
+      orchestrateSpy.mock.calls as unknown as unknown[][]
+    )[0]![0] as MemoryRoutingTurn;
+    expect(turn.currentMessage).toBe("generic hidden prompt");
+  });
+
   test("orchestrate receives the lane deps", async () => {
     await observeTurn("conv-1", 0);
     const deps = (

package/src/plugins/defaults/memory/v3/injector.ts

@@ -286,6 +286,11 @@ export const memoryV3Injector: Injector = {
     if (!isPersonalMemoryAllowed(ctx.trust)) {
       return null;
     }
+    // The front door keeps carried cards from history but defers current-turn
+    // retrieval to the escalated leg so memory cannot delay its first token.
+    if (ctx.callSite === "voiceFrontDoor") {
+      return null;
+    }
 
     let observed: OrchestrateResult | null;
     try {
@@ -412,6 +417,9 @@ export const memoryV3SpotlightInjector: Injector = {
     if (!isPersonalMemoryAllowed(ctx.trust)) {
       return null;
     }
+    if (ctx.callSite === "voiceFrontDoor") {
+      return null;
+    }
 
     try {
       const result = await observeTurnOnce(ctx.conversationId, ctx.turnIndex);

package/src/plugins/defaults/memory/v3/shadow-plugin.ts

@@ -28,7 +28,9 @@ import { existsSync, readFileSync } from "node:fs";
 import {
   getMessages,
   listInstalledSkills,
+  parseMessageMetadata,
   stringifyMessageContent,
+  VOICE_ESCALATION_CONTINUATION_MESSAGE_KIND,
 } from "@vellumai/plugin-api";
 
 import { getConfig } from "../../../../config/loader.js";
@@ -490,9 +492,11 @@ function buildSituationalContext(): string {
 
 /**
  * Build a v3 {@link MemoryRoutingTurn} from the conversation's persisted messages.
- * `currentMessage` is the latest user message; `previousAssistantMessage` is
- * the tail of the last assistant reply BEFORE that message (the reply-query
- * pass's input — absent on a conversation's first turn); `recentContext` is
+ * `currentMessage` is the latest user message, except that the synthetic voice
+ * escalation continuation routes on the preceding caller message;
+ * `previousAssistantMessage` is the tail of the last assistant reply BEFORE
+ * the routed message (the reply-query pass's input, absent on a conversation's
+ * first turn); `recentContext` is
  * the tail of the recent transcript; `situationalContext` carries the current
  * date and the live NOW.md scratchpad. Returns `null` when there is no user
  * message to route on (nothing to shadow this turn).
@@ -509,12 +513,22 @@ async function buildShadowTurn(
   let currentMessage = "";
   let currentIndex = -1;
   for (let i = rows.length - 1; i >= 0; i--) {
-    if (rows[i]!.role === "user") {
-      currentMessage = stringifyMessageContent(rows[i]!.content);
-      if (currentMessage.length > 0) {
-        currentIndex = i;
-        break;
-      }
+    const row = rows[i]!;
+    if (row.role !== "user") {
+      continue;
+    }
+    const candidate = stringifyMessageContent(row.content);
+    const metadata = await parseMessageMetadata(row.metadata);
+    const isVoiceEscalationContinuation =
+      metadata?.hidden === true &&
+      metadata.messageKind === VOICE_ESCALATION_CONTINUATION_MESSAGE_KIND;
+    if (isVoiceEscalationContinuation) {
+      continue;
+    }
+    if (candidate.length > 0) {
+      currentMessage = candidate;
+      currentIndex = i;
+      break;
     }
   }
   if (currentMessage.length === 0) {

package/src/plugins/defaults/memory/worker-control.ts

@@ -52,6 +52,7 @@ export async function spawnMemoryWorkerProcess(
     return await spawnWorkerProcess({
       pidPath: getMemoryWorkerPidPath(),
       entry: new URL("./worker.ts", import.meta.url),
+      packagedEntry: "memory",
       workerLabel: "Memory worker",
       options: opts,
     });

package/src/plugins/defaults/worker-entrypoints.ts

@@ -0,0 +1,3 @@
+export async function loadDefaultMemoryWorker(): Promise<void> {
+  await import("./memory/worker.js");
+}

package/src/plugins/mtime-cache.ts

@@ -212,6 +212,23 @@ export function getDiscoveredUserPluginNames(): Iterable<string> {
   return discoveredPluginDirs.values();
 }
 
+/**
+ * True when this daemon process brought the plugin directory `dir` up:
+ * {@link bringUpPlugin} ran for it and its `init` was attempted. An `init` that
+ * threw still counts, because activation never aborts on init failure (see
+ * {@link activatePlugin}), and that is deliberate: an init-failed plugin's
+ * hooks and tools stay live, so its schedules must too. What membership
+ * excludes is a directory dropped in out-of-band that no boot scan and no
+ * reconcile pass has activated yet.
+ *
+ * The backing map is per-process, so a process that runs no plugin loader (the
+ * schedule worker, sidecar turn workers) reads `false` for every directory.
+ * Only code that provably runs in the main daemon may treat this as an answer.
+ */
+export function isPluginDirActivated(dir: string): boolean {
+  return discoveredPluginDirs.has(dir);
+}
+
 // ─── Source-versions reconcile ───────────────────────────────────────────────
 
 /**

package/src/prompts/templates/system-sections.ts

@@ -267,13 +267,6 @@ export const BUNDLED_SYSTEM_SECTIONS: readonly BundledSection[] = [
     body: "",
     enabled: "!excludeCustomPrefix",
   },
-  {
-    id: "01-delegate-subagents",
-    body: `## Delegate independent work
-
-When part of a task can run on its own — a research sweep, a multi-file investigation, a build-and-test loop — hand it off instead of grinding through it inline: load the \`subagent\` skill, then \`subagent_spawn\` early and in parallel. Make delegating that kind of work your default, not a last resort; an unnecessary subagent is cheaper than serialized work, and a long inline dig floods your own context.
-`,
-  },
   {
     id: "01-parallel-tool-calls",
     body: `<use_parallel_tool_calls>

package/src/providers/__tests__/context-overflow-error.test.ts

@@ -239,6 +239,30 @@ describe("detectOpenAICompatibleContextOverflow", () => {
     expect(detectOpenAICompatibleContextOverflow(err)).toBeNull();
   });
 
+  test("matches OpenAI's per-part 10MiB string_above_max_length 400", () => {
+    const err = buildOpenAIApiError(400, {
+      message:
+        "Invalid 'input[191].content[1].text': string too long. Expected a string with maximum length 10485760, but got a string with length 11436754 instead.",
+      type: "invalid_request_error",
+      code: "string_above_max_length",
+    });
+    const out = detectOpenAICompatibleContextOverflow(err);
+    expect(out).not.toBeNull();
+    // Byte lengths in this message must not be misread as token counts.
+    expect(out?.actualTokens).toBeUndefined();
+    expect(out?.maxTokens).toBeUndefined();
+  });
+
+  test("returns null for string_above_max_length on a non-content field", () => {
+    const err = buildOpenAIApiError(400, {
+      message:
+        "Invalid 'tools[0].function.description': string too long. Expected a string with maximum length 1048576, but got a string with length 2000000 instead.",
+      type: "invalid_request_error",
+      code: "string_above_max_length",
+    });
+    expect(detectOpenAICompatibleContextOverflow(err)).toBeNull();
+  });
+
   test("matches 'too many input tokens' variant emitted by some OpenAI-compatible providers", () => {
     const err = buildOpenAIApiError(400, {
       message: "too many input tokens: 250000",

package/src/providers/__tests__/retry-callsite.test.ts

@@ -370,6 +370,26 @@ describe("RetryProvider — callSite resolution", () => {
     }
   });
 
+  test("memory-v3 selection does not inherit high effort", async () => {
+    setLlmConfig({ defaultProvider: { provider: "anthropic" } });
+
+    let seen: SendMessageOptions | undefined;
+    const wrapped = new RetryProvider(
+      makeProvider("anthropic", (options) => {
+        seen = options;
+      }),
+    );
+
+    await wrapped.sendMessage(DUMMY_MESSAGES, {
+      config: { callSite: "memoryV3SelectL2" },
+    });
+
+    const config = seen?.config as Record<string, unknown>;
+    expect(config.effort).toBe("low");
+    expect(config.thinking).toEqual({ type: "disabled" });
+    expect(config.temperature).toBe(0);
+  });
+
   test("propagates resolved effort/speed/temperature; omits server-side fields", async () => {
     setLlmConfig({
       callSites: {

package/src/providers/openai/chat-completions-provider.ts

@@ -85,7 +85,17 @@ export function detectOpenAICompatibleContextOverflow(
     /context.?length.?exceeded|context.?window.?exceeded|prompt.?is.?too.?long|prompt_too_long|input.?too.?long|too.?many.?(?:input.?)?tokens|maximum.?context/i.test(
       message,
     );
-  if (!codeMatches && !messageMatches) {
+  // string_above_max_length is OpenAI's generic oversized-string validation
+  // code, so only treat it as overflow when the error points at a message
+  // content part (e.g. "Invalid 'input[191].content[1].text': string too
+  // long" — OpenAI's per-part 10 MiB cap). The overflow ladder can shrink
+  // message content (media stubbing collapses a file's extracted_text to a
+  // preview) but cannot fix other oversized fields like tool definitions.
+  const oversizedContentPart =
+    /string.?too.?long|string_above_max_length/i.test(
+      `${code ?? ""} ${message}`,
+    ) && /\b(?:input|messages)\[\d+\]\.content/i.test(message);
+  if (!codeMatches && !messageMatches && !oversizedContentPart) {
     return null;
   }
   // OpenAI-compatible providers rarely report usable token counts; best-effort extract.

package/src/providers/speech-to-text/__tests__/deepgram-flux-realtime.test.ts

@@ -185,7 +185,6 @@ describe("DeepgramFluxRealtimeTranscriber", () => {
     const transcriber = new DeepgramFluxRealtimeTranscriber(TEST_API_KEY, {
       // Long enough that no watchdog fires mid-test.
       inactivityTimeoutMs: 60_000,
-      keepaliveIntervalMs: 0,
       ...options,
     });
     const events: SttStreamServerEvent[] = [];
@@ -571,16 +570,22 @@ describe("DeepgramFluxRealtimeTranscriber", () => {
       expect(events).toEqual([{ type: "closed" }]);
     });
 
-    test("keepalive frames go out on the configured interval", async () => {
-      const { transcriber } = await startSession({ keepaliveIntervalMs: 10 });
+    test("no KeepAlive is ever sent: Flux rejects it and closes", async () => {
+      const { transcriber } = await startSession();
 
+      // Flux accepts only CloseStream and Configure. A KeepAlive earns an
+      // UNPARSABLE_CLIENT_MESSAGE error frame and a server close, which on a
+      // stream held across turns kills it every keepalive interval.
       await Bun.sleep(35);
       transcriber.stop();
 
-      const keepalives = mockWs.sentData.filter(
-        (data) => data === JSON.stringify({ type: "KeepAlive" }),
+      const controlFrames = mockWs.sentData.filter(
+        (data) => typeof data === "string",
+      );
+      expect(controlFrames).not.toContain(
+        JSON.stringify({ type: "KeepAlive" }),
       );
-      expect(keepalives.length).toBeGreaterThanOrEqual(2);
+      expect(controlFrames).toContain(JSON.stringify({ type: "CloseStream" }));
     });
 
     test("finalizeUtterance is absent, Flux has no mid-stream flush", async () => {