nanocodex 0.6.4 → 0.6.6

package/README.md

@@ -10,7 +10,7 @@ import { Actions, Agent, Transport } from "nanocodex/node";
 
 const agent = await Agent.create({
   transport: Transport.openAi({ apiKey: process.env.OPENAI_API_KEY }),
-  model: "gpt-5.6-luna",
+  model: "gpt-6-luna",
   instructions: "You are a Rust coding agent. Preserve unrelated work and run relevant tests.",
   reasoningMode: "pro",
   thinking: "high",
@@ -236,8 +236,13 @@ requesting speech. Context and speech are split into provider-sized messages.
 These commands retain frames until sent and preserve them
 across reconnects when using the sideband transport. They are also methods on
 the resource and on
-`useVoice` from `nanocodex-react`. These settings use ChatGPT subscription voice;
-custom voices and Platform audio configuration are not accepted.
+`useVoice` from `nanocodex-react`. Choose `outputProvider: "elevenlabs"` and `elevenLabsVoiceId` to synthesize
+spoken output with an ElevenLabs account voice, including an instant clone.
+The account voice settings panel connects the API key, lists voices, and uploads
+cloning samples after explicit consent. Keys are encrypted on the server and
+never included in saved voice settings. ChatGPT still owns live input and agent
+handoffs; `voice` continues to select its built-in voice. The default output
+provider is `openai`. Platform audio configuration is not accepted.
 
 `Voice.create(...)` remains the equivalent namespaced resource constructor, and
 `Voice.voices` is the exact ChatGPT V3 voice catalog. The constructor accepts a
@@ -247,6 +252,20 @@ normal browser Agent, an account-owned managed Agent, or a grant-scoped
 one-use ticket for that path. The browser binding never receives ChatGPT
 credentials or places its reusable grant bearer in a WebSocket URL.
 
+### Content-free Worker tracing
+
+`nanocodex/cloudflare/tracing` wraps native `tracing.enterSpan(name, callback)`
+with sanitized exception events. Use static operation names: they become
+exception codes on failure. The original error is rethrown; its message and
+stack are never passed to `recordException`.
+
+`setSpanAttributes(span, attributes)` sets bulk metadata, while
+`annotateActiveSpan(attributes)` annotates the current invocation or active
+span without changing nesting. `recordSpanException(span, code)` handles
+failures represented by results rather than thrown errors. Supply only static
+codes and content-free attributes. On older workerd versions, these retain
+individual attributes and `error.type` without requiring the September APIs.
+
 ### Durable Cloudflare Agent
 
 `nanocodex/cloudflare` is the standard Durable Object consumer. It keeps the
@@ -302,10 +321,12 @@ Cloudflare Agents default to direct tool mode because Workers prohibit dynamic
 `eval`/`new Function`. Caller-defined tools therefore work without a code
 evaluator. Select `toolMode: "code"` only when also supplying an evaluator that
 is explicitly compatible with the deployed Worker runtime. Runtime-owned
-Subagents are installed by default, including on a durable root. Clean children
-persist independent execution state under their own agent session IDs. The
-Rust task-tree registry remains in memory and is closed with the live root, so
-tree-local IDs and topology are not reconstructed from those agent states. Use
+Subagents are installed by default, including on a durable root. All children are
+ephemeral: their identities, topology, conversations, results, and routing exist
+only for the lifetime of the root runtime. Root shutdown or restart discards the
+entire child tree; only the root's own durable history resumes. Existing child
+checkpoints from older versions are discarded. Within a live runtime, completed
+children remain available for follow-up messages until closed. Use
 `Subagents.create({ maxConcurrency })` in `tools` to set an explicit finite
 concurrency limit. Active subagent turns are unlimited by default.
 
@@ -349,6 +370,11 @@ native and WASM consumers run the same Rust implementation and receive the
 same seven tools: `spawn_agent`, `submit_result`, `send_agent_message`,
 `list_agents`, `wait_agent`, `interrupt_agent`, and `close_agent`.
 
+Children call `submit_result({output})`; the runtime supplies the trusted
+instruction revision. The response is `{accepted: true, status: "accepted"}` or
+`{accepted: false, status: "superseded"}`. Superseded submissions are normal
+continuations: incorporate the updated instructions and submit again.
+
 Inside a caller-owned Worker or server isolate, host capabilities stay as
 ordinary functions without crossing another compatibility protocol:
 
@@ -686,7 +712,7 @@ const mpp = tempoProvider.session;
 
 const agent = await Agent.create({
   transport: Transport.mpp({ session: tempoProvider }),
-  thinking: "none",
+  thinking: "low",
   fastMode: true,
   tools,
 });
@@ -736,8 +762,8 @@ of its wallet adapter, and constructs both payment paths from that provider's
 adapter-neutral `getMppxParameters()` contract. The lower-level
 `createTempoProvider({ session, payment })` remains available when the
 application constructs MPPx itself. Both explicitly select Tempo provider mode.
-In that mode Nanocodex automatically adds its built-in Mercator MCP and wraps it
-with the same wallet and payment policy. The provider also exposes an MPP-aware
+In that mode Nanocodex automatically adds its built-in Mercator MCP at
+`https://mercator.sh/mcp` and wraps it with the same wallet and payment policy. The provider also exposes an MPP-aware
 `fetch`; Mercator's paid REST handoffs use that same method rather than a second
 wallet or payment configuration. Its MCP transport remains wrapped at the MCP
 protocol layer, so browser requests do not need an `Accept-Payment` CORS header.
@@ -1155,7 +1181,7 @@ package manager or build step:
 
 ```html
 <script type="module">
-  import { Agent, Transport } from "https://cdn.jsdelivr.net/npm/nanocodex@0.6.4/host/index.mjs";
+  import { Agent, Transport } from "https://cdn.jsdelivr.net/npm/nanocodex@0.6.6/host/index.mjs";
   const agent = await Agent.create({
     transport: Transport.hostManaged({
       websocketUrl: "/api/responses",

package/browser/Agent.d.mts

@@ -33,7 +33,7 @@ export declare namespace create {
     transport: ManagedTransport;
     tools?: Tools | undefined;
   }>;
-  type Options = AgentOptions & WorkerToolExposureOptions & {
+  type Options = Omit<AgentOptions, "beforeCompaction"> & WorkerToolExposureOptions & {
     /** Precompiled browser module; WebAssembly modules are structured-clone-safe. */
     module?: WebAssembly.Module | undefined;
     /** Fixed browser workspace facts, including its AGENTS.md snapshot. */

package/browser/ElevenLabsPlayback.mjs

@@ -0,0 +1,119 @@
+/** Plays account-proxied PCM without exposing provider credentials to the browser. */
+export class ElevenLabsPlayback {
+  #synthesize;
+  #onError;
+  #context;
+  #abort = new AbortController();
+  #queue = Promise.resolve();
+  #sources = new Set();
+  #nextTime = 0;
+  #caption;
+  #offset = 0;
+  #suppressedThrough = -1;
+  #pending = 0;
+  #pendingChars = 0;
+  #closed = false;
+
+  constructor(synthesize, onError) {
+    this.#synthesize = synthesize;
+    this.#onError = onError;
+  }
+
+  prime() {
+    if (this.#closed) return;
+    this.#context ??= new AudioContext({ sampleRate: 24000 });
+    return this.#context.resume();
+  }
+
+  transcript(entry) {
+    if (this.#closed || entry.speaker !== "assistant" || entry.id <= this.#suppressedThrough) return;
+    if (this.#caption !== undefined && entry.id < this.#caption) return;
+    if (entry.id !== this.#caption) { this.#caption = entry.id; this.#offset = 0; }
+    const remaining = entry.text.slice(this.#offset);
+    // Buffer partial words; emit complete sentences before the turn finishes.
+    const boundary = entry.is_partial ? [...remaining.matchAll(/[.!?\n](?:\s|$)/g)].at(-1) : undefined;
+    const length = entry.is_partial ? (boundary ? boundary.index + boundary[0].length : 0) : remaining.length;
+    const text = remaining.slice(0, length).trim();
+    this.#offset += length;
+    if (!text) return;
+    if (this.#pending >= 32 || this.#pendingChars + text.length > 32768) {
+      this.interrupt();
+      this.#onError(new Error("ElevenLabs playback queue exceeded its limit"));
+      return;
+    }
+    this.#pending++;
+    this.#pendingChars += text.length;
+    const signal = this.#abort.signal;
+    this.#queue = this.#queue.then(async () => {
+      if (signal.aborted) return;
+      this.#context ??= new AudioContext({ sampleRate: 24000 });
+      await this.#context.resume();
+      if (signal.aborted) return;
+      const response = await this.#synthesize(text, signal);
+      if (!response.ok) throw new Error(`ElevenLabs synthesis failed (${response.status})`);
+      const reader = response.body?.getReader();
+      if (!reader) throw new Error("ElevenLabs returned no audio stream");
+      const cancel = () => { void reader.cancel().catch(() => {}); };
+      signal.addEventListener("abort", cancel, { once: true });
+      let carry;
+      try {
+        while (!signal.aborted) {
+          const { value, done } = await reader.read();
+          if (done) break;
+          if (signal.aborted) break;
+          if (value.byteLength > 1024 * 1024) throw new Error("ElevenLabs audio chunk exceeded its limit");
+          const bytes = carry === undefined ? value : Uint8Array.from([carry, ...value]);
+          const size = bytes.length - bytes.length % 2;
+          carry = size < bytes.length ? bytes[size] : undefined;
+          if (!size) continue;
+          // Keep decoded/scheduled audio bounded even when synthesis outruns playback.
+          for (let offset = 0; offset < size && !signal.aborted; offset += 9600) {
+            while (!signal.aborted && (this.#nextTime - this.#context.currentTime > 2 || this.#sources.size >= 128)) {
+              await new Promise((resolve) => {
+                const done = () => { clearTimeout(timer); signal.removeEventListener("abort", done); resolve(); };
+                const timer = setTimeout(done, 25);
+                signal.addEventListener("abort", done, { once: true });
+              });
+            }
+            if (signal.aborted) break;
+            const length = Math.min(9600, size - offset);
+            const buffer = this.#context.createBuffer(1, length / 2, 24000);
+            const output = buffer.getChannelData(0);
+            const view = new DataView(bytes.buffer, bytes.byteOffset + offset, length);
+            for (let i = 0; i < output.length; i++) output[i] = view.getInt16(i * 2, true) / 32768;
+            const source = this.#context.createBufferSource();
+            source.buffer = buffer;
+            source.connect(this.#context.destination);
+            this.#sources.add(source);
+            source.onended = () => { this.#sources.delete(source); source.disconnect(); };
+            this.#nextTime = Math.max(this.#nextTime, this.#context.currentTime + 0.02);
+            source.start(this.#nextTime);
+            this.#nextTime += buffer.duration;
+          }
+        }
+      } finally { signal.removeEventListener("abort", cancel); await reader.cancel().catch(() => {}); reader.releaseLock(); }
+    }).catch((error) => { if (!signal.aborted) this.#onError(error); }).finally(() => {
+      if (!signal.aborted) { this.#pending--; this.#pendingChars -= text.length; }
+    });
+  }
+
+  interrupt() {
+    this.#suppressedThrough = Math.max(this.#suppressedThrough, this.#caption ?? -1);
+    this.#pending = 0;
+    this.#pendingChars = 0;
+    this.#abort.abort();
+    this.#abort = new AbortController();
+    this.#queue = Promise.resolve();
+    for (const source of this.#sources) { try { source.stop(); } catch {} source.disconnect(); }
+    this.#sources.clear();
+    this.#nextTime = 0;
+    // Caption IDs are monotonic: every late delta/final for this epoch stays silent.
+  }
+
+  close() {
+    this.#closed = true;
+    this.interrupt();
+    void this.#context?.close();
+    this.#context = undefined;
+  }
+}

package/browser/InlineAgent.mjs

@@ -16,6 +16,7 @@ import {
   registerDefinitionHost,
   releaseDefinitionHost,
   releaseHostSession,
+  releaseHostSessions,
   toWasmConfig,
 } from "../internal.mjs";
 import { createBrowserHost } from "./host.mjs";
@@ -45,8 +46,10 @@ export async function create(options = {}) {
     thinking,
     reasoningMode,
     fastMode,
+    rawApiEvents,
     instructions,
     additionalInstructions,
+    beforeCompaction,
     sessionId,
     workspace,
     resume,
@@ -75,6 +78,7 @@ export async function create(options = {}) {
     websocketPreconnect,
     apiBaseUrl,
     websocketWarmup,
+    stateless,
     WebSocketImpl,
     createWebSocket,
     createResponse,
@@ -116,11 +120,14 @@ export async function create(options = {}) {
     hostManagedProtocol,
     mpp,
     onEvent: events.emit,
+    beforeCompaction,
     filesystem,
     filesystemTools,
     tools: hostTools,
     toolProviders,
     subagentSessions,
+    subagentRouting: internalRuntime?.subagentRouting,
+    onSocketTiming: internalRuntime?.onSocketTiming,
     toolMode,
     mcp: mcp === false
       ? undefined
@@ -163,8 +170,11 @@ export async function create(options = {}) {
             : "wss://openai.mpp.tempo.xyz/v1/responses"),
           apiBaseUrl,
           websocketWarmup,
+          stateless,
           subagents: subagentConfig,
+          subagentRouting: internalRuntime?.subagentRouting !== undefined,
           hostDefinitionId,
+          beforeCompaction: beforeCompaction !== undefined,
           ...config,
           durabilityHostId: durabilityOwner?.id,
         }));
@@ -176,29 +186,19 @@ export async function create(options = {}) {
             );
         if (cloudflareReservation !== undefined) {
           activateCloudflareAgentSession(cloudflareReservation);
-          const restoredSubagents = subagentSessions?.restore?.() ?? [];
-          if (restoredSubagents.length > 0) {
-            const restoredHostContextRefs = Object.fromEntries(
-              restoredSubagents.map((descriptor) => {
-                const hostContextRef = subagentSessions?.hostContextRef?.(descriptor.sessionId);
-                return [descriptor.sessionId, hostContextRef ?? null];
-              }),
-            );
-            await raw.restoreSubagents(
-              JSON.stringify(restoredSubagents),
-              JSON.stringify(restoredHostContextRefs),
-            );
-          }
         }
         return raw;
       } catch (error) {
         const cleanupErrors = [];
         if (raw !== undefined) {
-          try { await raw.shutdown(); }
+          try {
+            await raw.shutdown();
+          }
           catch (cleanupError) { cleanupErrors.push(cleanupError); }
           try { raw.free(); }
           catch (cleanupError) { cleanupErrors.push(cleanupError); }
         }
+        releaseHostSessions(host);
         try { durabilityOwner?.abandon(); }
         catch (cleanupError) { cleanupErrors.push(cleanupError); }
         try { await host.dispose(); }
@@ -212,16 +212,20 @@ export async function create(options = {}) {
         throw error;
       }
     },
+    async shutdown(raw) {
+      await raw.shutdown();
+    },
     subscribe: events.subscribe,
     adopt(raw) {
       host.retain();
       try {
-        durabilityOwner?.retain();
+        // Adopted child handles are ephemeral and do not own the root store.
+        if (raw.sessionId === stableSessionId) durabilityOwner?.retain();
         bindHostSession(host, raw.sessionId, cloudflareReservation);
         events.addSource(raw);
       } catch (error) {
         events.removeSource(raw);
-        durabilityOwner?.release();
+        if (raw.sessionId === stableSessionId) durabilityOwner?.release();
         releaseHost(host);
         throw error;
       }
@@ -230,7 +234,7 @@ export async function create(options = {}) {
       events.removeSource(raw);
       host.releaseSession(raw.sessionId);
       releaseHostSession(host, raw.sessionId);
-      durabilityOwner?.release();
+      if (raw.sessionId === stableSessionId) durabilityOwner?.release();
       releaseHost(host);
     },
     decorate: (agent) => agent.extend(agentActions()),
@@ -242,6 +246,7 @@ export async function create(options = {}) {
       thinking,
       reasoningMode,
       fastMode,
+      rawApiEvents,
       instructions,
       additionalInstructions,
       sessionId: stableSessionId,

package/browser/Transport.d.mts

@@ -26,6 +26,8 @@ export type WorkerTransport = ResponsesTransport & Readonly<{
 
 type SharedEndpointOptions = Readonly<{
   apiBaseUrl?: string | undefined;
+  /** Use HTTPS with full history replay, no stored responses, and no WebSocket warmup or preconnect. */
+  stateless?: boolean | undefined;
   websocketUrl?: string | undefined;
   /** Open the persistent socket as soon as Agent.create returns. Defaults to true for hostManaged. */
   websocketPreconnect?: boolean | undefined;

package/browser/Transport.mjs

@@ -25,12 +25,12 @@ export function chatGpt(options) {
 
 export function hostManaged(options = {}) {
   const websocketUrl = options.websocketUrl
-    ?? (options.createWebSocket ? undefined : defaultHostManagedWebSocketUrl());
+    ?? (options.stateless === true || options.createWebSocket ? undefined : defaultHostManagedWebSocketUrl());
   return createResponsesTransport({
     hostAuth: true,
     hostManagedProtocol: true,
     ...connection({ ...options, websocketUrl }),
-    websocketPreconnect: options.websocketPreconnect ?? true,
+    websocketPreconnect: options.stateless === true ? false : options.websocketPreconnect ?? true,
   });
 }
 
@@ -53,6 +53,7 @@ function connection(options = {}) {
   return {
     WebSocketImpl: options.WebSocketImpl,
     apiBaseUrl: options.apiBaseUrl,
+    stateless: options.stateless,
     createWebSocket: options.createWebSocket,
     createResponse: options.createResponse,
     websocketUrl: options.websocketUrl,

package/browser/Voice.d.mts

@@ -51,6 +51,8 @@ export type Event =
   | Readonly<{ type: "stopped" }>;
 export type Settings = Readonly<{
   voice?: VoiceName | undefined;
+  outputProvider?: "openai" | "elevenlabs" | undefined;
+  elevenLabsVoiceId?: string | undefined;
   /** Additional speaking preferences; base assistant instructions are retained. */
   instructions?: string | undefined;
   pace?: "slow" | "natural" | "fast" | undefined;
@@ -59,6 +61,8 @@ export type Settings = Readonly<{
   acknowledgements?: boolean | undefined;
 }>;
 export type Options = Settings & Readonly<{
+  /** Authenticated synthesis transport returning mono signed 16-bit little-endian PCM at 24 kHz. */
+  synthesize?(text: string, signal: AbortSignal): Promise<Response>;
   callUrl?: string | URL | undefined;
   sidebandUrl?(callId: string, sessionId: string): string | URL | Promise<string | URL>;
   captureMicrophone?(): Promise<MediaStream>;

package/browser/Voice.mjs

@@ -91,6 +91,11 @@ export function create(agent, options = {}) {
     if (destroyed) throw new Error("voice resource is destroyed");
     const selectedVoice = parameters.voice ?? options.voice ?? defaultVoice;
     if (!voices.includes(selectedVoice)) throw new TypeError(`unsupported ChatGPT voice: ${selectedVoice}`);
+    const settings = voiceSettings({ ...options, ...parameters, voice: selectedVoice });
+    validateOutputSettings(settings);
+    if (agent.type === "connect" && settings.outputProvider === "elevenlabs" && !options.synthesize) {
+      throw new TypeError("Connect ElevenLabs output requires an explicit authorized synthesis transport");
+    }
     if (session) return startPromise;
     if (stopPromise) await stopPromise.catch(() => {});
     if (destroyed) throw new Error("voice resource is destroyed");
@@ -125,7 +130,14 @@ export function create(agent, options = {}) {
       core,
       sessionId,
       voice: selectedVoice,
-      settings: voiceSettings({ ...options, ...parameters, voice: selectedVoice }),
+      synthesize: options.synthesize ?? (transport?.synthesize
+        ? (text, signal) => transport.synthesize(text, signal, settings.elevenLabsVoiceId)
+        : (text, signal) => fetch("/api/voice/elevenlabs/speech", {
+          method: "POST", credentials: "same-origin", signal,
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ voice_id: settings.elevenLabsVoiceId, text, output_format: "pcm_24000" }),
+        })),
+      settings,
       ...(transport?.call === undefined ? {} : { call: transport.call }),
       ...(transport?.sidebandUrl === undefined ? {} : { sidebandUrl: transport.sidebandUrl }),
       ...(options.callUrl === undefined ? {} : { callUrl: options.callUrl }),
@@ -186,10 +198,17 @@ export function create(agent, options = {}) {
     // Media readiness updates the UI independently; start still waits for task
     // admission, and a later rejection closes media through the same error path.
     startPromise = next.start().then(publishReady).catch(async (cause) => {
-      if (session === next) session = undefined;
-      if (activeResources.get(agent) === resource) activeResources.delete(agent);
-      cleanupWatcher();
-      await next.close().catch(() => next.abort());
+      if (session === next) {
+        session = undefined;
+        if (activeResources.get(agent) === resource) activeResources.delete(agent);
+        cleanupWatcher();
+      }
+      // Keep replacement starts behind failed startup cleanup, just like stop().
+      // A stale attempt must never detach a replacement session's event watcher.
+      const closing = next.close().catch(() => next.abort());
+      if (generation === current) stopPromise = closing;
+      await closing;
+      if (stopPromise === closing) stopPromise = undefined;
       if (destroyed || generation !== current) return;
       if (attempt === 0 && cause?.code === "peer_connection_timeout") return start(parameters, 1);
       const error = cause instanceof Error ? cause : new Error(String(cause));
@@ -299,6 +318,9 @@ function validateOptions(options) {
   if (!options || typeof options !== "object" || Array.isArray(options)) {
     throw new TypeError("Voice.create options must be an object");
   }
+  if (options.synthesize !== undefined && typeof options.synthesize !== "function") {
+    throw new TypeError("voice synthesize must be a function");
+  }
   if (options.captureMicrophone !== undefined && typeof options.captureMicrophone !== "function") {
     throw new TypeError("voice captureMicrophone must be a function");
   }
@@ -317,6 +339,16 @@ function browserLocationOrigin() {
 }
 
 function voiceSettings(options) {
-  return Object.fromEntries(["voice", "instructions", "pace", "updates", "handoffMode", "acknowledgements"]
+  return Object.fromEntries(["voice", "instructions", "pace", "updates", "handoffMode", "acknowledgements", "outputProvider", "elevenLabsVoiceId"]
     .filter((key) => options[key] !== undefined).map((key) => [key, options[key]]));
 }
+
+function validateOutputSettings(settings) {
+  if (settings.outputProvider !== undefined && !["openai", "elevenlabs"].includes(settings.outputProvider)) {
+    throw new TypeError("unsupported voice output provider");
+  }
+  if (settings.outputProvider === "elevenlabs"
+    && (typeof settings.elevenLabsVoiceId !== "string" || !/^[A-Za-z0-9_-]{1,128}$/.test(settings.elevenLabsVoiceId))) {
+    throw new TypeError("ElevenLabs output requires a valid voice ID");
+  }
+}

package/browser/VoiceSession.mjs

@@ -1,3 +1,5 @@
+import { ElevenLabsPlayback } from "./ElevenLabsPlayback.mjs";
+
 export const MICROPHONE_CAPTURE_TIMEOUT_MS = 15_000;
 export const ICE_GATHERING_TIMEOUT_MS = 15_000;
 export const REALTIME_CALL_TIMEOUT_MS = 15_000;
@@ -85,8 +87,10 @@ export class BrowserVoiceSession {
   #microphone;
   #speaker;
   #playbackEnabled = false;
+  #elevenLabs;
   #muted = false;
   #inputGeneration = 0;
+  #playbackRevision = 0;
   #meterTimer;
   #backendReady;
   #resolveBackendReady;
@@ -102,10 +106,17 @@ export class BrowserVoiceSession {
 
   constructor(options) {
     this.#options = options;
+    if (options.settings?.outputProvider === "elevenlabs") {
+      if (typeof options.synthesize !== "function") throw new TypeError("ElevenLabs output requires an authenticated synthesis transport");
+      this.#elevenLabs = new ElevenLabsPlayback(options.synthesize, (error) => {
+        if (!this.#closed) options.onTerminated(error.message);
+      });
+    }
     this.#backendReady = new Promise((resolve) => { this.#resolveBackendReady = resolve; });
   }
 
   start() {
+    if (!this.#starting) void this.#elevenLabs?.prime()?.catch((error) => this.#options.onTerminated(error.message));
     this.#starting ??= this.#start();
     return this.#starting;
   }
@@ -140,7 +151,8 @@ export class BrowserVoiceSession {
     // Only delegated work waits for admission on the direct control path.
     const coreStartup = coreReady.then(async (core) => {
       if (this.#directControl) await this.#options.beforeAgentTurn?.();
-      await core?.start();
+      const effects = await core?.start();
+      if (!this.#closed && !this.#closing.signal.aborted) await this.#apply(effects);
       return core;
     });
     this.#admission = coreStartup;
@@ -256,7 +268,7 @@ export class BrowserVoiceSession {
     const channel = this.#channel;
     channel.addEventListener("message", (event) => {
       if (this.#directControl && !this.#closed && this.#channel === channel) {
-        this.#receiveControl(event.data, () => this.#channel === channel);
+        this.#receiveControl(event.data, () => this.#channel === channel && channel.readyState === "open");
       }
     });
     channel.addEventListener("close", () => {
@@ -271,7 +283,7 @@ export class BrowserVoiceSession {
       }
       const stream = event.streams[0] ?? new MediaStream([event.track]);
       this.#speaker ??= new SpeakerPlayback(new Audio(), this.#options.onStatus);
-      this.#speaker.setEnabled(this.#playbackEnabled);
+      this.#speaker.setEnabled(this.#playbackEnabled && !this.#elevenLabs);
       this.#speaker.attach(stream);
     });
     peer.addEventListener("connectionstatechange", () => {
@@ -300,7 +312,9 @@ export class BrowserVoiceSession {
   }
 
   noteTypedInput() {
+    this.#playbackRevision++;
     this.#playbackEnabled = false;
+    this.#elevenLabs?.interrupt();
     this.#speaker?.setEnabled(false);
     return this.#applyLive(async () => {
       const core = await this.#options.core;
@@ -417,12 +431,19 @@ export class BrowserVoiceSession {
     for (const text of effects.undelivered_answers ?? []) this.#options.onUndeliveredAnswer?.(text);
     if (effects.input_generation !== undefined) {
       if (effects.input_generation < this.#inputGeneration) return;
+      if (effects.input_generation > this.#inputGeneration) {
+        this.#playbackRevision++;
+        this.#elevenLabs?.interrupt();
+      }
       this.#inputGeneration = effects.input_generation;
     }
     if (effects.playback_enabled === false) {
+      this.#playbackRevision++;
       this.#playbackEnabled = false;
+      this.#elevenLabs?.interrupt();
       this.#speaker?.setEnabled(false);
     }
+    const playbackRevision = this.#playbackRevision;
     let sent = 0;
     for (const frame of effects.frames ?? []) {
       if (this.#directControl && this.#channel?.readyState === "open") {
@@ -434,11 +455,15 @@ export class BrowserVoiceSession {
       }
     }
     if (effects.acknowledge_frames && sent > 0) await this.#core?.framesSent(sent);
-    if (!this.#closed && effects.playback_enabled === true && sent === (effects.frames?.length ?? 0)) {
+    // A live interruption can overtake asynchronous frame acknowledgement.
+    // Keep its speaker gate authoritative while retaining accepted captions.
+    const currentPlayback = playbackRevision === this.#playbackRevision;
+    if (currentPlayback && !this.#closed && effects.playback_enabled === true && sent === (effects.frames?.length ?? 0)) {
       this.#playbackEnabled = true;
-      this.#speaker?.setEnabled(true);
+      this.#speaker?.setEnabled(!this.#elevenLabs);
     }
     for (const entry of effects.transcripts ?? []) {
+      if (currentPlayback && this.#playbackEnabled && !this.#closed) this.#elevenLabs?.transcript(entry);
       this.#options.onTranscript(entry.speaker, entry.text, entry);
     }
     if (effects.status) this.#status(effects.status);
@@ -475,7 +500,7 @@ export class BrowserVoiceSession {
     let opened = false;
     sideband.addEventListener("message", (event) => {
       if (!this.#closed && generation === this.#sidebandGeneration) {
-        this.#receiveControl(event.data, () => generation === this.#sidebandGeneration);
+        this.#receiveControl(event.data, () => generation === this.#sidebandGeneration && sideband.readyState === WebSocket.OPEN);
       }
     });
     sideband.addEventListener("close", () => {
@@ -501,7 +526,11 @@ export class BrowserVoiceSession {
     this.#applyLive(async () => {
       if (!this.#directControl) await this.#admission;
       if (this.#closed || !isCurrent()) return;
-      if (await this.#core.requiresAgentAdmission(payload)) {
+      const requiresAdmission = await this.#core.requiresAgentAdmission(payload);
+      // Classification can yield while this transport closes or is replaced.
+      // Only requests accepted on the current connection may enter the queue.
+      if (this.#closed || !isCurrent()) return;
+      if (requiresAdmission) {
         // Retain accepted requests on close, but keep captions and interruptions
         // independent of the durable route and its ordered task queue.
         void this.#enqueue(async () => {
@@ -549,6 +578,7 @@ export class BrowserVoiceSession {
   }
 
   #stopBrowserMedia() {
+    this.#elevenLabs?.close();
     if (this.#meterTimer !== undefined) window.clearTimeout(this.#meterTimer);
     this.#meterTimer = undefined;
     this.#call?.abort();

package/browser/host.d.mts

@@ -75,12 +75,28 @@ export function createBrowserHost(options?: {
   mcp?: McpServers;
   codeEvaluator?: CodeEvaluator;
   toolMode?: "code" | "direct";
-  /** @internal Durable host lifecycle for Rust-owned subagent descriptors. */
+  /** @internal Live host lifecycle for ephemeral Rust-owned subagents. */
+  subagentRouting?: Pick<import('../runtime/subagent-routing.mjs').SubagentRouting, 'resolve' | 'bind'>;
   subagentSessions?: {
-    restore(): readonly SubagentToolContext[];
-    bind(sessionId: string, descriptor: SubagentToolContext): void;
-    release(sessionId: string): void;
+    bindingDescriptor?(sessionId: string, descriptor: SubagentToolContext, hostContextRef?: string): SubagentToolContext;
+    bind(sessionId: string, descriptor: SubagentToolContext, hostContextRef?: string): void;
+    release(sessionId: string, hostContextRef?: string): void;
   };
+  /** @internal Content-free summary, once when ownership closes; no public transport option. */
+  onSocketTiming?: (timing: {
+    message_count: number;
+    delivered_message_count: number;
+    buffered_message_count: number;
+    discarded_message_count: number;
+    queue_residence_total_ms: number;
+    queue_residence_max_ms: number;
+    provider_timings: Array<{
+      response_id?: string;
+      pre_inference_ms?: number;
+      engine_queue_max_ms?: number;
+      engine_service_ttft_total_ms?: number;
+    }>;
+  }) => void;
   maxQueuedMessages?: number;
   maxQueuedBytes?: number;
   maxBufferedSendBytes?: number;