@vellumai/assistant 0.11.2 → 0.11.3-dev.202608080427.92f668a

package/src/inbound/__tests__/oauth-callback-url.test.ts

@@ -0,0 +1,83 @@
+/**
+ * Tests for the shared OAuth callback URL resolver.
+ *
+ * The property that matters is stability: every caller and every attempt
+ * must get the same redirect URI. Dynamic client registration and Client
+ * ID Metadata Documents both pin `redirect_uris` when the client is
+ * registered, and the authorization server matches the value exactly on
+ * each authorization request, so a URI that varies per attempt makes both
+ * mechanisms unusable.
+ */
+
+import { afterEach, describe, expect, mock, test } from "bun:test";
+
+const resolveCallbackUrl = mock(
+  async () => "https://ingress.example/webhooks/oauth/callback",
+);
+
+mock.module("../platform-callback-registration.js", () => ({
+  resolveCallbackUrl,
+}));
+
+mock.module("../public-ingress-urls.js", () => ({
+  getOAuthCallbackUrl: () => "https://direct.example/webhooks/oauth/callback",
+}));
+
+mock.module("../../config/loader.js", () => ({
+  loadConfig: () => ({}),
+}));
+
+const { OAUTH_CALLBACK_PATH, resolveOauthCallbackUrl } =
+  await import("../oauth-callback-url.js");
+
+afterEach(() => {
+  resolveCallbackUrl.mockClear();
+});
+
+describe("resolveOauthCallbackUrl", () => {
+  test("returns whatever the shared resolver decides", async () => {
+    await expect(resolveOauthCallbackUrl()).resolves.toEqual(
+      "https://ingress.example/webhooks/oauth/callback",
+    );
+  });
+
+  test("registers the shared callback path, not a per-caller one", async () => {
+    await resolveOauthCallbackUrl();
+    const [, callbackPath] = resolveCallbackUrl.mock.calls[0] as unknown[];
+    expect(callbackPath).toEqual(OAUTH_CALLBACK_PATH);
+    expect(OAUTH_CALLBACK_PATH).toEqual("webhooks/oauth/callback");
+  });
+
+  test("every call resolves to the same URL, path, and registration type", async () => {
+    // The URI a client registers and the URI it later authorizes with are
+    // the same string, which is what an exact-match redirect_uri check
+    // needs. Nothing about the caller can vary it: the function takes no
+    // arguments.
+    const first = await resolveOauthCallbackUrl();
+    const second = await resolveOauthCallbackUrl();
+    expect(first).toEqual(second);
+
+    const [, pathA, typeA] = resolveCallbackUrl.mock.calls[0] as unknown[];
+    const [, pathB, typeB] = resolveCallbackUrl.mock.calls[1] as unknown[];
+    expect(pathA).toEqual(pathB);
+    expect(typeA).toEqual(typeB);
+  });
+
+  test("registers one route type so the platform holds a single admin row", async () => {
+    await resolveOauthCallbackUrl();
+    const [, , type] = resolveCallbackUrl.mock.calls[0] as unknown[];
+    expect(type).toEqual("oauth");
+  });
+
+  test("propagates the resolver's failure rather than inventing a URL", async () => {
+    // No ingress and no platform connection means there is no URL that
+    // would work. Returning a plausible one produces an authorization
+    // request whose callback silently never arrives.
+    resolveCallbackUrl.mockImplementationOnce(async () => {
+      throw new Error("No public base URL configured.");
+    });
+    await expect(resolveOauthCallbackUrl()).rejects.toThrow(
+      /No public base URL/,
+    );
+  });
+});

package/src/inbound/oauth-callback-url.ts

@@ -0,0 +1,61 @@
+/**
+ * Public URL resolution for the assistant's shared OAuth callback route.
+ *
+ * Every browser-based OAuth flow in the daemon redirects back to one path,
+ * `webhooks/oauth/callback`, which the gateway serves and forwards to
+ * `POST /v1/internal/oauth/callback`. The runtime matches the arriving
+ * `state` against `security/oauth-callback-registry.ts` and resolves the
+ * waiting flow, so one route multiplexes every concurrent handshake and no
+ * caller needs a listener of its own.
+ *
+ * Which base URL is correct depends on how the assistant is reachable: a
+ * platform pod and a platform-connected assistant are served through a
+ * managed callback route, a self-hosted deployment through its configured
+ * public ingress. `resolveCallbackUrl` owns that decision, and this is the
+ * OAuth-shaped entry point to it, mirroring `plugin-api/webhook-url.ts`
+ * for plugin ingress.
+ */
+
+import { loadConfig } from "../config/loader.js";
+import { resolveCallbackUrl } from "./platform-callback-registration.js";
+import { getOAuthCallbackUrl } from "./public-ingress-urls.js";
+
+/**
+ * Path the gateway serves the shared OAuth callback on.
+ *
+ * Fixed rather than caller-supplied. Every flow is demultiplexed by OAuth
+ * `state`, so a per-caller path would buy nothing and would need its own
+ * gateway route and its own platform registration.
+ */
+export const OAUTH_CALLBACK_PATH = "webhooks/oauth/callback";
+
+/**
+ * Registration type recorded with the platform.
+ *
+ * The platform keys a callback route by `(path, type)`, and there is one
+ * OAuth route, so one type describes it. Registering the same path under
+ * several types would produce duplicate admin rows pointing at the same
+ * URL.
+ */
+const OAUTH_REGISTRATION_TYPE = "oauth";
+
+/**
+ * Resolve the redirect URI an authorization server should send the user
+ * back to.
+ *
+ * Takes no arguments on purpose: every caller shares one route, so there
+ * is nothing to vary. That is what makes the URI stable across callers and
+ * across attempts, which is what an exact-match `redirect_uri` check needs.
+ *
+ * @throws when no public ingress is configured and the assistant is not
+ *   connected to the platform. There is no URL that would work in that
+ *   case, and returning a plausible one produces an authorization request
+ *   whose callback silently never arrives.
+ */
+export async function resolveOauthCallbackUrl(): Promise<string> {
+  return resolveCallbackUrl(
+    () => getOAuthCallbackUrl(loadConfig()),
+    OAUTH_CALLBACK_PATH,
+    OAUTH_REGISTRATION_TYPE,
+  );
+}

package/src/ipc/__tests__/socket-path.test.ts

@@ -1,6 +1,8 @@
+import { createServer } from "node:net";
 import { tmpdir } from "node:os";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
+import { ensureSocketPathFree } from "../socket-cleanup.js";
 import { resolveIpcSocketPath } from "../socket-path.js";
 
 let savedWorkspaceDir: string | undefined;
@@ -77,4 +79,23 @@ describe("resolveIpcSocketPath", () => {
 
     delete process.env.EXAMPLE_SERVICE_IPC_SOCKET_DIR;
   });
+
+  test.skipIf(process.platform !== "win32")(
+    "rejects an occupied named pipe",
+    async () => {
+      const pipe = `\\\\.\\pipe\\vellum-ipc-test-${process.pid}`;
+      const server = createServer();
+      await new Promise<void>((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(pipe, resolve);
+      });
+      try {
+        await expect(ensureSocketPathFree(pipe)).rejects.toMatchObject({
+          code: "EADDRINUSE",
+        });
+      } finally {
+        server.close();
+      }
+    },
+  );
 });

package/src/ipc/assistant-server.ts

@@ -28,13 +28,14 @@
  * back to a shorter deterministic path so CLI commands can still connect.
  */
 
-import { existsSync, unlinkSync } from "node:fs";
 import { createServer, type Server, type Socket } from "node:net";
 
 import {
   ensureSocketDir,
   type IpcEnvelope,
   IpcFrameReader,
+  ipcListenOptions,
+  removeIpcEndpointFile,
   SocketWatchdog,
   writeLegacyMessage,
   writeMessage,
@@ -60,6 +61,7 @@ import { CONTACTS_INFO_IPC_METHODS } from "./routes/contacts-info-ipc-routes.js"
 import { CONTACTS_MIRROR_IPC_METHODS } from "./routes/contacts-mirror-ipc-routes.js";
 import { CONVERSATION_SYNC_IPC_METHODS } from "./routes/conversation-sync-ipc-routes.js";
 import { type DbProxyParams, handleDbProxy } from "./routes/db-proxy.js";
+import { DOCUMENTS_SYNC_IPC_METHODS } from "./routes/documents-sync-ipc-routes.js";
 import { EVENTS_IPC_METHODS } from "./routes/events-ipc-routes.js";
 import { GUARDIAN_LABEL_IPC_METHODS } from "./routes/guardian-label-ipc-routes.js";
 import { INVITE_IPC_METHODS } from "./routes/invite-ipc-routes.js";
@@ -215,6 +217,7 @@ export class AssistantIpcServer {
       CONTACTS_MIRROR_IPC_METHODS,
       GUARDIAN_LABEL_IPC_METHODS,
       CONVERSATION_SYNC_IPC_METHODS,
+      DOCUMENTS_SYNC_IPC_METHODS,
       EVENTS_IPC_METHODS,
     ]) {
       for (const [operationId, handler] of Object.entries(methodMap)) {
@@ -257,8 +260,18 @@ export class AssistantIpcServer {
     await ensureSocketPathFree(this.socketPath);
 
     this.server = this.createListeningServer();
-    this.server.listen(this.socketPath, () => {
-      log.info({ path: this.socketPath }, "Assistant IPC server listening");
+    await new Promise<void>((resolve, reject) => {
+      const server = this.server!;
+      const onError = (err: Error): void => {
+        this.server = null;
+        reject(err);
+      };
+      server.once("error", onError);
+      server.listen(ipcListenOptions(this.socketPath), () => {
+        server.off("error", onError);
+        log.info({ path: this.socketPath }, "Assistant IPC server listening");
+        resolve();
+      });
     });
 
     this.watchdog.start();
@@ -290,13 +303,7 @@ export class AssistantIpcServer {
       this.server = null;
     }
 
-    if (existsSync(this.socketPath)) {
-      try {
-        unlinkSync(this.socketPath);
-      } catch {
-        // Ignore
-      }
-    }
+    removeIpcEndpointFile(this.socketPath);
   }
 
   /** Get the socket path (for diagnostics). */

package/src/ipc/cli-client.ts

@@ -58,6 +58,15 @@ export interface CliIpcCallResult<T = unknown> {
    * when the originating daemon-side error carried a `details` field.
    */
   errorDetails?: unknown;
+  /**
+   * Set when the call was abandoned because `timeoutMs` elapsed with no
+   * response. Distinct from every other `ok: false` shape: the request WAS
+   * delivered and the daemon may still be executing it — closing the client
+   * socket does not abort the handler. Callers that would otherwise retry a
+   * transport failure must not retry this one until the original can no
+   * longer be in flight.
+   */
+  timedOut?: boolean;
 }
 
 /**
@@ -178,7 +187,7 @@ export async function cliIpcCall<T = unknown>(
           { method, socketPath, timeoutMs: callTimeoutMs },
           "CLI IPC call timed out waiting for response",
         );
-        finish({ ok: false, error: "Request timed out" });
+        finish({ ok: false, error: "Request timed out", timedOut: true });
       }, callTimeoutMs);
 
       socket.on("data", (chunk) => {

package/src/ipc/routes/__tests__/documents-sync-ipc-routes.test.ts

@@ -0,0 +1,56 @@
+/**
+ * The daemon-side handler for the worker → daemon documents-changed hand-off.
+ * A sidecar worker's own hub has no SSE subscriber, so it asks the daemon to
+ * republish the invalidation where clients actually observe it.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+const publishCalls: Array<string | undefined> = [];
+
+mock.module("../../../runtime/sync/resource-sync-events.js", () => ({
+  publishDocumentsChanged: (originClientId?: string) => {
+    publishCalls.push(originClientId);
+  },
+}));
+
+import { DB_MIGRATION_READINESS_EXEMPT_OPERATIONS } from "../../../daemon/daemon-readiness.js";
+import { NOTIFY_DOCUMENTS_CHANGED_IPC_METHOD } from "../../../runtime/sync/worker-daemon-notify.js";
+import {
+  DOCUMENTS_SYNC_IPC_METHODS,
+  handleNotifyDocumentsChanged,
+} from "../documents-sync-ipc-routes.js";
+
+describe("documents-sync IPC route", () => {
+  beforeEach(() => {
+    publishCalls.length = 0;
+  });
+
+  test("republishes the documents-changed invalidation on the daemon", () => {
+    const result = handleNotifyDocumentsChanged({ body: {} });
+
+    expect(result).toEqual({ ok: true });
+    expect(publishCalls).toEqual([undefined]);
+  });
+
+  test("carries no origin client id, so no client suppresses it", () => {
+    // The hand-off comes from a background turn with no originating client.
+    handleNotifyDocumentsChanged({ body: {} });
+
+    expect(publishCalls[0]).toBeUndefined();
+  });
+
+  test("is reachable on the IPC surface under the shared method name", () => {
+    expect(
+      typeof DOCUMENTS_SYNC_IPC_METHODS[NOTIFY_DOCUMENTS_CHANGED_IPC_METHOD],
+    ).toBe("function");
+  });
+
+  test("is DB-migration readiness gated (absent from the exempt set)", () => {
+    expect(
+      DB_MIGRATION_READINESS_EXEMPT_OPERATIONS.has(
+        NOTIFY_DOCUMENTS_CHANGED_IPC_METHOD,
+      ),
+    ).toBe(false);
+  });
+});

package/src/ipc/routes/documents-sync-ipc-routes.ts

@@ -0,0 +1,42 @@
+/**
+ * IPC-only route the sidecar workers (schedule, memory) call after a turn
+ * changed a document.
+ *
+ * Workers disable SSE seq stamping (`disableStreamSeqStamping`) so the daemon
+ * is the sole seq authority, and the SSE subscribers live in the daemon too. A
+ * worker that published `documents:list` on its own hub would reach nobody, so
+ * a scheduled or background turn's document edit would stay invisible: the
+ * conversation assets pill and the Library would keep serving their cached
+ * list. That is precisely the case the changed-document surfacing exists for.
+ *
+ * This route runs the publish on the daemon instead, where real subscribers
+ * observe it. The hand-off carries no originating client, so nothing suppresses
+ * the broadcast as its own echo.
+ *
+ * IPC-only: registered directly on the assistant IPC server (see
+ * `assistant-server.ts`), never in the shared `ROUTES` array. The handler
+ * touches no database, but the IPC server's uniform DB-migration gate still
+ * applies (the method is not exempt); the worker's call is best-effort and
+ * tolerates that.
+ */
+
+import type { RouteHandlerArgs } from "../../runtime/routes/types.js";
+import { publishDocumentsChanged } from "../../runtime/sync/resource-sync-events.js";
+import { NOTIFY_DOCUMENTS_CHANGED_IPC_METHOD } from "../../runtime/sync/worker-daemon-notify.js";
+
+/** Republish a worker's documents-changed invalidation to daemon subscribers. */
+export function handleNotifyDocumentsChanged(_args: RouteHandlerArgs) {
+  publishDocumentsChanged();
+  return { ok: true };
+}
+
+/**
+ * IPC-only documents-sync methods, keyed by operationId. Registered directly on
+ * the assistant IPC server (see `assistant-server.ts`).
+ */
+export const DOCUMENTS_SYNC_IPC_METHODS: Record<
+  string,
+  (args: RouteHandlerArgs) => unknown
+> = {
+  [NOTIFY_DOCUMENTS_CHANGED_IPC_METHOD]: handleNotifyDocumentsChanged,
+};

package/src/ipc/socket-cleanup.ts

@@ -7,9 +7,14 @@
  * inode, leaving two daemons in conflict with no error.
  */
 
-import { existsSync, unlinkSync } from "node:fs";
+import { existsSync } from "node:fs";
 import { connect } from "node:net";
 
+import {
+  isNamedPipePath,
+  removeIpcEndpointFile,
+} from "@vellumai/ipc-server-utils";
+
 /**
  * Maximum time to wait for the probe `connect()` to settle before declaring
  * the path occupied. Without a bound, a hung process holding the socket would
@@ -44,7 +49,8 @@ function makeAddrInUseError(message: string): NodeJS.ErrnoException {
  *   - Any other socket error → propagate.
  */
 export async function ensureSocketPathFree(socketPath: string): Promise<void> {
-  if (!existsSync(socketPath)) {
+  const namedPipe = isNamedPipePath(socketPath);
+  if (!namedPipe && !existsSync(socketPath)) {
     return;
   }
   await new Promise<void>((resolve, reject) => {
@@ -81,11 +87,7 @@ export async function ensureSocketPathFree(socketPath: string): Promise<void> {
     client.once("error", (err: NodeJS.ErrnoException) => {
       if (err.code === "ECONNREFUSED" || err.code === "ENOENT") {
         settle(() => {
-          try {
-            unlinkSync(socketPath);
-          } catch {
-            // Ignore — may already be gone
-          }
+          removeIpcEndpointFile(socketPath);
           resolve();
         });
       } else {

package/src/ipc/socket-path.ts

@@ -1,106 +1,14 @@
-import { createHash } from "node:crypto";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { resolveIpcEndpoint } from "@vellumai/ipc-server-utils";
 
 import { getWorkspaceDir } from "../util/platform.js";
 
-const DARWIN_UNIX_SOCKET_MAX_PATH_BYTES = 103;
-const DEFAULT_UNIX_SOCKET_MAX_PATH_BYTES = 107;
-const IPC_TMP_DIR_NAME = "vellum-ipc";
-
-export type IpcSocketPathSource =
-  | "env-override"
-  | "workspace"
-  | "tmp-hash"
-  | "tmp-short-hash";
-
-export interface IpcSocketPathResolution {
+export function resolveIpcSocketPath(socketName: string): {
   path: string;
-  source: IpcSocketPathSource;
-}
-
-function getUnixSocketMaxPathBytes(): number {
-  return process.platform === "darwin"
-    ? DARWIN_UNIX_SOCKET_MAX_PATH_BYTES
-    : DEFAULT_UNIX_SOCKET_MAX_PATH_BYTES;
-}
-
-function isPathWithinSocketLimit(path: string, maxPathBytes: number): boolean {
-  return Buffer.byteLength(path, "utf8") <= maxPathBytes;
-}
-
-/**
- * Derive the env var name and socket filename from a socket name.
- *
- * Examples (hyphens in the name become underscores in the env var):
- *   "gateway"   → { envVar: "GATEWAY_IPC_SOCKET_DIR", fileName: "gateway.sock" }
- *   "assistant" → { envVar: "ASSISTANT_IPC_SOCKET_DIR", fileName: "assistant.sock" }
- */
-function deriveSocketNames(socketName: string): {
-  envVar: string;
-  fileName: string;
+  source: string;
 } {
-  const envVar = `${socketName.toUpperCase().replace(/-/g, "_")}_IPC_SOCKET_DIR`;
-  const fileName = `${socketName}.sock`;
-  return { envVar, fileName };
-}
-
-/**
- * Resolve the path to an IPC socket file.
- *
- * Resolution order:
- *   1. `${SOCKET_NAME}_IPC_SOCKET_DIR` env var override — used in
- *      containerized deployments (emptyDir volume) and by hatch on macOS
- *      when the workspace path would exceed the AF_UNIX limit.
- *   2. `{workspaceDir}/{socketName}.sock` — default for local dev.
- *   3. tmpdir fallback — if the workspace path exceeds the platform's
- *      AF_UNIX path limit (103 bytes on macOS, 107 on Linux).
- */
-export function resolveIpcSocketPath(
-  socketName: string,
-): IpcSocketPathResolution {
-  const workspaceDir = getWorkspaceDir();
-  const { envVar, fileName } = deriveSocketNames(socketName);
-
-  // Explicit override via env var.
-  const envSocketDir = process.env[envVar]?.trim();
-  if (envSocketDir) {
-    return {
-      path: join(envSocketDir, fileName),
-      source: "env-override",
-    };
-  }
-
-  const maxPathBytes = getUnixSocketMaxPathBytes();
-  const workspacePath = join(workspaceDir, fileName);
-
-  if (isPathWithinSocketLimit(workspacePath, maxPathBytes)) {
-    return {
-      path: workspacePath,
-      source: "workspace",
-    };
-  }
-
-  // Workspace path exceeds AF_UNIX limit — fall back to tmpdir.
-  const hash = createHash("sha256")
-    .update(workspacePath)
-    .digest("hex")
-    .slice(0, 12);
-  const hashedPath = join(tmpdir(), IPC_TMP_DIR_NAME, `${hash}-${fileName}`);
-  if (isPathWithinSocketLimit(hashedPath, maxPathBytes)) {
-    return {
-      path: hashedPath,
-      source: "tmp-hash",
-    };
-  }
-
-  return {
-    path: join(tmpdir(), `v-${hash}.sock`),
-    source: "tmp-short-hash",
-  };
+  return resolveIpcEndpoint(socketName, { workspaceDir: getWorkspaceDir() });
 }
 
-/** Shorthand — resolves the assistant CLI IPC socket path. */
 export function getAssistantSocketPath(): string {
   return resolveIpcSocketPath("assistant").path;
 }

package/src/live-voice/__tests__/live-voice-agent-turn.test.ts

@@ -1,16 +1,13 @@
 import { describe, expect, mock, test } from "bun:test";
 
-import { sanitizeForTts } from "../../calls/tts-text-sanitizer.js";
 import type {
   VoiceTurnCallbacks,
   VoiceTurnOptions,
 } from "../../calls/voice-session-bridge.js";
-import type { LiveVoiceFrontModelConfig } from "../../config/schemas/live-voice.js";
 import type {
   StreamingTranscriber,
   SttStreamServerEvent,
 } from "../../stt/types.js";
-import type { VoiceFrontDecider } from "../front-decision.js";
 import {
   LiveVoiceSession,
   type LiveVoiceTtsStreamer,
@@ -96,8 +93,6 @@ function createSessionHarness(
     createTurnId?: () => string;
     emitMetrics?: boolean;
     streamTtsAudio?: LiveVoiceTtsStreamer;
-    frontModelConfig?: Partial<LiveVoiceFrontModelConfig>;
-    frontDecider?: VoiceFrontDecider;
   } = {},
 ) {
   const transcriber =
@@ -119,10 +114,6 @@ function createSessionHarness(
     ...(options.streamTtsAudio
       ? { streamTtsAudio: options.streamTtsAudio }
       : {}),
-    ...(options.frontModelConfig
-      ? { frontModelConfig: options.frontModelConfig }
-      : {}),
-    ...(options.frontDecider ? { frontDecider: options.frontDecider } : {}),
   });
 
   return { frames, session, startVoiceTurn, transcriber };
@@ -468,7 +459,7 @@ describe("LiveVoiceSession assistant turn", () => {
     });
   });
 
-  test("records tool_use_start on the active turn and publishes what it is doing", async () => {
+  test("publishes tool activity while the turn is running", async () => {
     let callbacks: VoiceTurnCallbacks | undefined;
     const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
       callbacks = options.callbacks;
@@ -488,12 +479,6 @@ describe("LiveVoiceSession assistant turn", () => {
     callbacks?.tool_use_start?.("some_tool");
     await waitForFrameCount(frames, 4);
 
-    const activeTurn = (
-      session as unknown as {
-        activeAssistantTurn: { toolUseStarted: boolean } | null;
-      }
-    ).activeAssistantTurn;
-    expect(activeTurn?.toolUseStarted).toBe(true);
     // One activity frame, so a silent stretch of tool work is visible on the
     // surfaces that show the session. An unrecognized tool still gets a line.
     expect(frames.at(-1)).toMatchObject({
@@ -560,90 +545,6 @@ describe("LiveVoiceSession assistant turn", () => {
   });
 });
 
-describe("LiveVoiceSession tool-use spoken ack", () => {
-  const ACK_TIMEOUT_MS = 40;
-  // Every ack is front-model-phrased; the generated text passes through the
-  // same TTS sanitizer as regular segments. The stub varies its phrasing by
-  // trigger so the two ack kinds stay distinguishable in assertions.
-  const TOOL_ACK = "Let me look that up.";
-  const FIRST_DELTA_ACK = "Sure — one moment.";
-  const EXPECTED_TOOL_ACK = sanitizeForTts(TOOL_ACK).trim();
-  const EXPECTED_FIRST_DELTA_ACK = sanitizeForTts(FIRST_DELTA_ACK).trim();
-
-  const ackDecider: VoiceFrontDecider = {
-    generateAckText: async (input) =>
-      input.toolName ? TOOL_ACK : FIRST_DELTA_ACK,
-    generateProgressText: async () => null,
-  };
-
-  function createAckHarness() {
-    const { startVoiceTurn, getCallbacks } = createCapturingTurnStarter();
-    const { streamTtsAudio, ttsTexts } = createRecordingTtsStreamer();
-    const harness = createSessionHarness({
-      startVoiceTurn,
-      streamTtsAudio,
-      frontModelConfig: { ackFirstDeltaTimeoutMs: ACK_TIMEOUT_MS },
-      frontDecider: ackDecider,
-    });
-    return { ...harness, getCallbacks, ttsTexts };
-  }
-
-  test("tool_use_start before any delta speaks an immediate tool ack and cancels the timer", async () => {
-    const { frames, session, getCallbacks, ttsTexts } = createAckHarness();
-
-    await startReleasedTurn(session, getCallbacks);
-    getCallbacks()?.tool_use_start?.("web_search");
-    await waitFor(() => ttsTexts.length === 1);
-    expect(ttsTexts).toEqual([EXPECTED_TOOL_ACK]);
-
-    // The pending first-delta timer was cancelled: letting its budget elapse
-    // speaks no second ack.
-    await new Promise((resolve) => setTimeout(resolve, ACK_TIMEOUT_MS + 40));
-    expect(ttsTexts).toEqual([EXPECTED_TOOL_ACK]);
-
-    // The ack is audio-only — no caption frame carries it.
-    expect(frames.some((frame) => frame.type === "assistant_text_delta")).toBe(
-      false,
-    );
-
-    emitTextDelta(getCallbacks, "Hello there.");
-    emitMessageComplete(getCallbacks);
-    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
-    expect(ttsTexts).toEqual([EXPECTED_TOOL_ACK, "Hello there."]);
-  });
-
-  test("tool_use_start after the first delta speaks no ack", async () => {
-    const { frames, session, getCallbacks, ttsTexts } = createAckHarness();
-
-    await startReleasedTurn(session, getCallbacks);
-    emitTextDelta(getCallbacks, "Hello there.");
-    getCallbacks()?.tool_use_start?.("web_search");
-    emitMessageComplete(getCallbacks);
-    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
-    await new Promise((resolve) => setTimeout(resolve, ACK_TIMEOUT_MS + 40));
-
-    expect(ttsTexts).toEqual(["Hello there."]);
-  });
-
-  test("tool_use_start after a first-delta ack already spoke adds no second ack", async () => {
-    const { frames, session, getCallbacks, ttsTexts } = createAckHarness();
-
-    await startReleasedTurn(session, getCallbacks);
-    // Let the slow-first-delta timer speak the turn's one ack first.
-    await waitFor(() => ttsTexts.length === 1);
-    expect(ttsTexts).toEqual([EXPECTED_FIRST_DELTA_ACK]);
-
-    getCallbacks()?.tool_use_start?.("web_search");
-    await flushAsyncCallbacks();
-    expect(ttsTexts).toEqual([EXPECTED_FIRST_DELTA_ACK]);
-
-    emitTextDelta(getCallbacks, "Hello there.");
-    emitMessageComplete(getCallbacks);
-    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
-    expect(ttsTexts).toEqual([EXPECTED_FIRST_DELTA_ACK, "Hello there."]);
-  });
-});
-
 describe("LiveVoiceSession room reveal", () => {
   function createMarkerHarness() {
     const { startVoiceTurn, getCallbacks } = createCapturingTurnStarter();
@@ -651,9 +552,6 @@ describe("LiveVoiceSession room reveal", () => {
     const harness = createSessionHarness({
       startVoiceTurn,
       streamTtsAudio,
-      // Deltas are emitted immediately in these runs; a long ack budget keeps
-      // filler phrases out of the recorded TTS text.
-      frontModelConfig: { ackFirstDeltaTimeoutMs: 10_000 },
     });
     return { ...harness, getCallbacks, ttsTexts };
   }
@@ -689,7 +587,6 @@ describe("LiveVoiceSession room reveal", () => {
     const harness = createSessionHarness({
       startVoiceTurn,
       streamTtsAudio,
-      frontModelConfig: { ackFirstDeltaTimeoutMs: 10_000 },
     });
     return {
       ...harness,