@nuancelabs/js-sdk 0.15.0 → 0.33.2

package/index.js

@@ -4,7 +4,7 @@ function isRecord(value) {
 }
 
 // src/core/sdk-version.ts
-var SDK_HEADER = `js/${"0.15.0"}`;
+var SDK_HEADER = `js/${"0.33.2"}`;
 
 // src/utils.ts
 function normalizeHost(host) {
@@ -12,10 +12,13 @@ function normalizeHost(host) {
 }
 
 // src/api/client.ts
+var NETWORK_RETRY_DELAYS_MS = [300, 1200];
+
 class ApiError extends Error {
   status;
   code;
   retryAfterSeconds;
+  renewsAt;
   body;
   constructor(status, detail, body = null) {
     super(detail);
@@ -24,6 +27,7 @@ class ApiError extends Error {
     this.body = body;
     this.code = isRecord(body) && typeof body.code === "string" ? body.code : null;
     this.retryAfterSeconds = isRecord(body) && typeof body.retry_after_seconds === "number" ? body.retry_after_seconds : null;
+    this.renewsAt = isRecord(body) && typeof body.renews_at === "string" ? body.renews_at : null;
   }
 }
 
@@ -31,18 +35,26 @@ class NuanceApiClient {
   host;
   headersProvider;
   tokenProvider;
+  networkRetryDelaysMs;
   tokens = new Map;
   constructor(config) {
     this.host = normalizeHost(config.host);
     this.headersProvider = config.headers;
     this.tokenProvider = config.token;
+    this.networkRetryDelaysMs = config.networkRetryDelaysMs ?? NETWORK_RETRY_DELAYS_MS;
   }
   async createConversation(request) {
     const token = this.tokenProvider ? await this.tokenProvider() : undefined;
     if (token !== undefined && (typeof token !== "string" || token === "")) {
       throw new TypeError(`The token option must resolve to the session token string, but it resolved to ${token === "" ? "an empty string" : typeof token}. Return the "token" field of your endpoint's response.`);
     }
-    const conversation = await this.request("/conversation", { method: "POST", body: request, token });
+    const conversation = await this.request("/conversation", {
+      method: "POST",
+      body: request,
+      token,
+      page: pageHeaders(),
+      replaySafe: (headers) => !isApiKey(headers)
+    });
     if (token !== undefined)
       this.tokens.set(conversation.id, token);
     return conversation;
@@ -69,18 +81,21 @@ class NuanceApiClient {
   async request(path, options) {
     const headers = new Headers(await this.resolveHeaders());
     headers.set("X-Nuance-SDK", SDK_HEADER);
+    for (const [name, value] of Object.entries(options?.page ?? {})) {
+      headers.set(name, value);
+    }
     if (options?.token !== undefined) {
       headers.set("Authorization", `Bearer ${options.token}`);
     }
     if (options?.body !== undefined) {
       headers.set("Content-Type", "application/json");
     }
-    const response = await fetch(`${this.host}${path}`, {
+    const response = await this.send(`${this.host}${path}`, {
       method: options?.method ?? "GET",
       headers,
       body: options?.body !== undefined ? JSON.stringify(options.body) : undefined,
       signal: options?.signal
-    });
+    }, options?.replaySafe?.(headers) ?? true);
     if (!response.ok) {
       let detail = response.statusText;
       let body = null;
@@ -99,10 +114,51 @@ class NuanceApiClient {
     }
     return response.json();
   }
+  async send(url, init, replaySafe) {
+    for (let retry = 0;; retry++) {
+      try {
+        return await fetch(url, init);
+      } catch (error) {
+        const delayMs = this.networkRetryDelaysMs[retry];
+        if (!replaySafe || delayMs === undefined || !isNetworkFailure(error) || init.signal?.aborted) {
+          throw error;
+        }
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+        if (init.signal?.aborted)
+          throw error;
+      }
+    }
+  }
   async resolveHeaders() {
     return this.headersProvider ? await this.headersProvider() : {};
   }
 }
+function isNetworkFailure(error) {
+  return error instanceof TypeError;
+}
+function isApiKey(headers) {
+  return headers.get("Authorization")?.startsWith("Bearer nk_") ?? false;
+}
+function pageHeaders(location = globalThis.location, referrer = globalThis.document?.referrer) {
+  const headers = {};
+  const page = location && withoutQuery(location.href);
+  if (page)
+    headers["X-Nuance-Page"] = page;
+  const from = referrer && withoutQuery(referrer);
+  if (from)
+    headers["X-Nuance-Referrer"] = from;
+  return headers;
+}
+function withoutQuery(href) {
+  try {
+    const url = new URL(href);
+    if (url.protocol !== "http:" && url.protocol !== "https:")
+      return;
+    return `${url.origin}${url.pathname}`.slice(0, 512);
+  } catch {
+    return;
+  }
+}
 // src/core/active-session-error.ts
 class ActiveSessionError extends Error {
   constructor() {
@@ -110,7 +166,6 @@ class ActiveSessionError extends Error {
     this.name = "ActiveSessionError";
   }
 }
-
 // src/core/guest-limit-error.ts
 class GuestLimitError extends Error {
   reason;
@@ -120,7 +175,6 @@ class GuestLimitError extends Error {
     this.reason = reason;
   }
 }
-
 // src/core/legal-required-error.ts
 class LegalRequiredError extends Error {
   constructor() {
@@ -128,7 +182,6 @@ class LegalRequiredError extends Error {
     this.name = "LegalRequiredError";
   }
 }
-
 // src/core/maintenance-error.ts
 class MaintenanceError extends Error {
   constructor(message) {
@@ -136,7 +189,6 @@ class MaintenanceError extends Error {
     this.name = "MaintenanceError";
   }
 }
-
 // src/core/media-error.ts
 function reasonFor(cause) {
   const name = cause instanceof Error ? cause.name : "";
@@ -177,24 +229,146 @@ async function ensureMicrophoneAccess(deviceId) {
     throw new MediaAccessError(error, "microphone");
   }
 }
-
 // src/core/policy-curfew-error.ts
 class PolicyCurfewError extends Error {
   retryAfterSeconds;
   constructor(retryAfterSeconds) {
-    super("new sessions are paused after repeated policy violations");
+    super(curfewMessage(retryAfterSeconds));
     this.name = "PolicyCurfewError";
     this.retryAfterSeconds = retryAfterSeconds;
   }
 }
+function curfewMessage(retryAfterSeconds) {
+  const paused = "New conversations are paused after repeated violations of our Acceptable Use Policy.";
+  if (retryAfterSeconds === null || !(retryAfterSeconds > 0)) {
+    return `${paused} Try again later.`;
+  }
+  const hours = Math.max(1, Math.ceil(retryAfterSeconds / 3600));
+  return `${paused} Try again in about ${hours} ${hours === 1 ? "hour" : "hours"}.`;
+}
+// src/core/types.ts
+var ConversationState;
+((ConversationState2) => {
+  ConversationState2["Idle"] = "idle";
+  ConversationState2["Queued"] = "queued";
+  ConversationState2["Connecting"] = "connecting";
+  ConversationState2["Connected"] = "connected";
+  ConversationState2["Reconnecting"] = "reconnecting";
+  ConversationState2["Disconnected"] = "disconnected";
+  ConversationState2["Failed"] = "failed";
+})(ConversationState ||= {});
+// src/core/camera.ts
+function cameraFacing(track) {
+  const facing = track.getSettings().facingMode;
+  return facing === "user" || facing === "environment" ? facing : null;
+}
+function requireCameraFacing(track, facing) {
+  const requested = typeof facing === "string" ? facing : !Array.isArray(facing) ? facing?.exact : undefined;
+  if (typeof requested !== "string")
+    return;
+  if (!track || track.getSettings().facingMode !== requested)
+    throw new DOMException("Requested camera direction is unavailable", "OverconstrainedError");
+}
+var BUILT_IN = /facetime|built-?in|integrated|internal|macbook|user[- ]facing|front[- ]facing/i;
+var PHONE = /iphone|android|continuity|desk view/i;
+function classifyCamera(label, phone, facing) {
+  if (phone)
+    return facing === "environment" ? "phone_back" : "phone_front";
+  if (!label)
+    return;
+  if (PHONE.test(label))
+    return "phone_back";
+  return BUILT_IN.test(label) ? "built_in" : "external";
+}
+function onPhone() {
+  return /Android|iPhone|iPad|iPod/i.test(navigator.userAgent) || navigator.platform === "MacIntel" && navigator.maxTouchPoints > 1;
+}
+async function cameraSource(preferences) {
+  if (preferences.cameraEnabled === false)
+    return "off";
+  if (typeof navigator === "undefined")
+    return;
+  if (onPhone())
+    return classifyCamera("", true, preferences.cameraFacing);
+  try {
+    const cameras = (await navigator.mediaDevices.enumerateDevices()).filter((device) => device.kind === "videoinput");
+    const camera = cameras.find((device) => device.deviceId === preferences.cameraId) ?? cameras[0];
+    return camera ? classifyCamera(camera.label, false, null) : undefined;
+  } catch {
+    return;
+  }
+}
 
-// src/core/session-events.ts
-function sessionEventsOf(type, handler) {
-  return (change) => {
-    if (change.type === "session-event" && change.event.type === type) {
-      handler(change.event);
-    }
-  };
+// src/core/dispatch.ts
+function deliver(handler, event) {
+  try {
+    handler(event);
+  } catch (error) {
+    report(error);
+  }
+}
+function report(error) {
+  if (typeof globalThis.reportError === "function") {
+    globalThis.reportError(error);
+    return;
+  }
+  console.error("Nuance SDK: an event handler threw", error);
+}
+
+// src/core/end-reason.ts
+var FROM_V1 = {
+  client_ended: "close_requested",
+  input_end: "close_requested",
+  time_limit: "expired",
+  max_pause: "expired",
+  policy_violation: "content",
+  age_check: "age_check",
+  agent_ended: "end_call",
+  runtime_error: "error",
+  capacity_lost: "error",
+  job_ended: "error",
+  pacer_failed: "error",
+  output_not_ready: "error",
+  client_gone: "connection_lost",
+  client_stalled: "connection_lost",
+  closed: "connection_lost"
+};
+var RETIRED = {
+  remote_hangup: "end_call"
+};
+var KNOWN = new Set([
+  "close_requested",
+  "content",
+  "age_check",
+  "expired",
+  "end_call",
+  "error",
+  "connection_lost"
+]);
+function endReasonOf(reason) {
+  if (typeof reason !== "string" || reason === "")
+    return;
+  if (KNOWN.has(reason))
+    return reason;
+  return RETIRED[reason] ?? reason;
+}
+function v1EndReason(reason) {
+  if (typeof reason !== "string" || reason === "")
+    return;
+  if (KNOWN.has(reason))
+    return reason;
+  return FROM_V1[reason] ?? "error";
+}
+
+// src/core/resolvers.ts
+function resolvers() {
+  let resolve;
+  let reject;
+  const promise = new Promise((settle, fail) => {
+    resolve = settle;
+    reject = fail;
+  });
+  return { promise, resolve, reject };
 }
 
 // src/core/ticker.ts
@@ -248,11 +422,172 @@ var pageTicker = backgroundTicker(globalThis);
 // src/providers/livekit/conversation.ts
 import {
   ConnectionQuality,
-  ConnectionState as ConnectionState2,
+  ConnectionState as ConnectionState3,
+  ParticipantKind,
   Room,
-  RoomEvent as RoomEvent3
+  RoomEvent as RoomEvent4
 } from "livekit-client";
 
+// src/providers/livekit/attach.ts
+function isAttach(participant) {
+  if (participant === undefined)
+    return false;
+  return participant.identity.startsWith("attach-") || participant.attributes?.["nuance.attach"] === "1";
+}
+
+// src/providers/livekit/audio-backlog.ts
+import {
+  ConnectionState,
+  RoomEvent,
+  Track
+} from "livekit-client";
+var BACKLOG_MS = 300;
+var AUDIO_BACKLOG_TIMING = {
+  sampleMs: 500,
+  stuckSamples: 2,
+  cooldownMs: 1e4,
+  maxCooldownMs: 120000
+};
+
+class AudioBacklogWatch {
+  read;
+  drop;
+  timing;
+  now;
+  timer = null;
+  previous = null;
+  stuck = 0;
+  droppedAt = null;
+  cooldown;
+  sampling = false;
+  constructor(read, drop, timing = AUDIO_BACKLOG_TIMING, now = () => performance.now()) {
+    this.read = read;
+    this.drop = drop;
+    this.timing = timing;
+    this.now = now;
+    this.cooldown = timing.cooldownMs;
+  }
+  start() {
+    if (this.timer !== null)
+      return;
+    this.timer = setInterval(() => {
+      this.sample();
+    }, this.timing.sampleMs);
+  }
+  stop() {
+    if (this.timer !== null) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.previous = null;
+    this.stuck = 0;
+  }
+  async sample() {
+    if (this.sampling || this.timer === null)
+      return;
+    this.sampling = true;
+    try {
+      const buffer = await this.read().catch(() => null);
+      if (this.timer === null)
+        return;
+      this.observe(buffer, this.now());
+    } finally {
+      this.sampling = false;
+    }
+  }
+  observe(buffer, now) {
+    const previous = this.previous;
+    this.previous = buffer;
+    if (buffer === null || previous === null || buffer.id !== previous.id) {
+      this.stuck = 0;
+      return;
+    }
+    const emitted = buffer.emitted - previous.emitted;
+    if (emitted <= 0)
+      return;
+    const backlog = {
+      jitterBufferMs: (buffer.delay - previous.delay) / emitted * 1000,
+      targetMs: (buffer.target - previous.target) / emitted * 1000
+    };
+    const behind = backlog.jitterBufferMs - backlog.targetMs > BACKLOG_MS;
+    this.stuck = behind ? this.stuck + 1 : 0;
+    if (this.stuck < this.timing.stuckSamples)
+      return;
+    if (this.droppedAt !== null) {
+      if (now - this.droppedAt < this.cooldown)
+        return;
+      this.cooldown = Math.min(this.cooldown * 2, this.timing.maxCooldownMs);
+    }
+    this.stuck = 0;
+    this.droppedAt = now;
+    this.previous = null;
+    this.drop(backlog);
+  }
+}
+function avatarAudio(room) {
+  for (const participant of room.remoteParticipants.values()) {
+    if (isAttach(participant))
+      continue;
+    for (const publication of participant.trackPublications.values()) {
+      if (publication.kind === Track.Kind.Audio && publication.isSubscribed) {
+        return publication;
+      }
+    }
+  }
+  return null;
+}
+function readJitterBuffer(report2) {
+  let buffer = null;
+  report2?.forEach((stat) => {
+    if (stat.type !== "inbound-rtp" || stat.kind !== "audio")
+      return;
+    const {
+      id,
+      jitterBufferDelay,
+      jitterBufferTargetDelay,
+      jitterBufferEmittedCount
+    } = stat;
+    if (typeof id === "string" && typeof jitterBufferDelay === "number" && typeof jitterBufferTargetDelay === "number" && typeof jitterBufferEmittedCount === "number") {
+      buffer = {
+        id,
+        delay: jitterBufferDelay,
+        target: jitterBufferTargetDelay,
+        emitted: jitterBufferEmittedCount
+      };
+    }
+  });
+  return buffer;
+}
+async function avatarJitterBuffer(room) {
+  const track = avatarAudio(room)?.track;
+  if (!track)
+    return null;
+  return readJitterBuffer(await track.getRTCStatsReport());
+}
+var UNSUBSCRIBE_WAIT_MS = 2000;
+async function resubscribeAvatarAudio(room) {
+  const publication = avatarAudio(room);
+  if (!publication)
+    return;
+  await new Promise((resolve) => {
+    const done = () => {
+      clearTimeout(timer);
+      room.off(RoomEvent.TrackUnsubscribed, unsubscribed);
+      resolve();
+    };
+    const unsubscribed = (_track, gone) => {
+      if (gone === publication)
+        done();
+    };
+    const timer = setTimeout(done, UNSUBSCRIBE_WAIT_MS);
+    room.on(RoomEvent.TrackUnsubscribed, unsubscribed);
+    publication.setSubscribed(false);
+  });
+  if (room.state === ConnectionState.Disconnected)
+    return;
+  publication.setSubscribed(true);
+}
+
 // src/providers/livekit/tracks.ts
 class LiveKitVideoTrack {
   track;
@@ -323,6 +658,9 @@ class LiveKitAvatarParticipant {
   constructor(participant) {
     this.participant = participant;
   }
+  get identity() {
+    return this.participant?.identity ?? null;
+  }
   updateParticipant(participant, keepReady = false) {
     if (!keepReady && (participant === null || this.participant !== null && participant !== this.participant)) {
       this._ready = false;
@@ -394,7 +732,7 @@ class LiveKitAvatarParticipant {
 }
 
 // src/providers/livekit/layer-fallback.ts
-import { Track, VideoQuality } from "livekit-client";
+import { Track as Track2, VideoQuality } from "livekit-client";
 var LAYER_FALLBACK_TIMING = {
   sampleMs: 1000,
   slowFps: 12,
@@ -478,14 +816,16 @@ async function avatarVideoRate(room) {
   if (typeof document !== "undefined" && document.hidden)
     return null;
   for (const participant of room.remoteParticipants.values()) {
-    const publication = participant.getTrackPublication(Track.Source.Camera);
+    if (isAttach(participant))
+      continue;
+    const publication = participant.getTrackPublication(Track2.Source.Camera);
     const track = publication?.track;
     if (!publication?.isSubscribed || !track)
       continue;
-    const report = await track.getRTCStatsReport();
+    const report2 = await track.getRTCStatsReport();
     let width = null;
     let framesDecoded = null;
-    report?.forEach((stat) => {
+    report2?.forEach((stat) => {
       if (stat.type === "inbound-rtp" && stat.kind === "video") {
         width = typeof stat.frameWidth === "number" ? stat.frameWidth : null;
         framesDecoded = typeof stat.framesDecoded === "number" ? stat.framesDecoded : null;
@@ -502,7 +842,9 @@ async function avatarVideoRate(room) {
 }
 function pinAvatarLayer(room, layer) {
   for (const participant of room.remoteParticipants.values()) {
-    const publication = participant.getTrackPublication(Track.Source.Camera);
+    if (isAttach(participant))
+      continue;
+    const publication = participant.getTrackPublication(Track2.Source.Camera);
     if (!publication?.isSubscribed)
       continue;
     publication.setVideoQuality(layer === "low" ? VideoQuality.LOW : VideoQuality.HIGH);
@@ -512,10 +854,10 @@ function pinAvatarLayer(room, layer) {
 
 // src/providers/livekit/network-stats.ts
 import {
-  ConnectionState,
+  ConnectionState as ConnectionState2,
   ParticipantEvent,
-  RoomEvent,
-  Track as Track2
+  RoomEvent as RoomEvent2,
+  Track as Track3
 } from "livekit-client";
 
 // src/providers/livekit/mic-silence.ts
@@ -582,9 +924,9 @@ function num(value) {
 function str(value) {
   return typeof value === "string" && value ? value : null;
 }
-function entries(report) {
+function entries(report2) {
   const out = [];
-  report.forEach((entry) => {
+  report2.forEach((entry) => {
     out.push(entry);
   });
   return out;
@@ -709,7 +1051,7 @@ function buildSample(reports, hidden) {
     reports.avatarVideo,
     reports.mic,
     reports.camera
-  ].map((report) => report ? entries(report) : null);
+  ].map((report2) => report2 ? entries(report2) : null);
   const byId = new Map;
   for (const list of perReport) {
     if (list)
@@ -728,7 +1070,7 @@ function buildSample(reports, hidden) {
   }
   const inboundOf = (list) => list ? digestInbound(list.find((entry) => entry.type === "inbound-rtp"), byId) : null;
   const outboundOf = (list) => list ? digestOutbound(list.find((entry) => entry.type === "outbound-rtp" && entry.active !== false), byId) : null;
-  const avatarAudio = inboundOf(perReport[0]);
+  const avatarAudio2 = inboundOf(perReport[0]);
   const avatarVideo = inboundOf(perReport[1]);
   const mic = outboundOf(perReport[2]);
   if (mic && reports.micTrack) {
@@ -736,17 +1078,18 @@ function buildSample(reports, hidden) {
     mic.track_ready_state = reports.micTrack.readyState;
     mic.track_enabled = reports.micTrack.enabled;
   }
-  const audioPlayout = avatarAudio?.estimated_playout_timestamp_ms ?? null;
+  const audioPlayout = avatarAudio2?.estimated_playout_timestamp_ms ?? null;
   const videoPlayout = avatarVideo?.estimated_playout_timestamp_ms ?? null;
   return {
     ts: Date.now() / 1000,
     hidden,
     ...link,
     av_offset_ms: audioPlayout != null && videoPlayout != null ? audioPlayout - videoPlayout : null,
-    avatar_audio: avatarAudio,
+    avatar_audio: avatarAudio2,
     avatar_video: avatarVideo,
     mic,
-    camera: outboundOf(perReport[3])
+    camera: outboundOf(perReport[3]),
+    avatar_audio_drop: null
   };
 }
 function environment() {
@@ -775,6 +1118,7 @@ class NetworkStatsReporter {
   timer = null;
   seq = 0;
   pending = [];
+  audioDrop = null;
   stopped = false;
   onVisibility = () => {
     if (document.visibilityState === "hidden")
@@ -787,7 +1131,7 @@ class NetworkStatsReporter {
     this.resetMic();
   };
   onMicMute = (publication) => {
-    if (publication.source === Track2.Source.Microphone)
+    if (publication.source === Track3.Source.Microphone)
       this.resetMic();
   };
   constructor(room, onMicSilent = () => {}) {
@@ -803,9 +1147,17 @@ class NetworkStatsReporter {
     }, SAMPLE_MS);
     document.addEventListener("visibilitychange", this.onVisibility);
     window.addEventListener("pagehide", this.onPageHide);
-    this.room.on(RoomEvent.Reconnecting, this.onLinkChange).on(RoomEvent.Reconnected, this.onLinkChange).on(RoomEvent.Disconnected, this.onLinkChange);
+    this.room.on(RoomEvent2.Reconnecting, this.onLinkChange).on(RoomEvent2.Reconnected, this.onLinkChange).on(RoomEvent2.Disconnected, this.onLinkChange);
     this.room.localParticipant.on(ParticipantEvent.TrackMuted, this.onMicMute).on(ParticipantEvent.TrackUnmuted, this.onMicMute);
   }
+  noteAudioDrop(backlog) {
+    const round = (ms) => Math.round(ms);
+    this.audioDrop = {
+      jitter_buffer_ms: round(backlog.jitterBufferMs),
+      target_ms: round(backlog.targetMs),
+      behind_ms: round(backlog.jitterBufferMs - backlog.targetMs)
+    };
+  }
   stop() {
     if (!this.teardown())
       return Promise.resolve();
@@ -825,7 +1177,7 @@ class NetworkStatsReporter {
     }
     document.removeEventListener("visibilitychange", this.onVisibility);
     window.removeEventListener("pagehide", this.onPageHide);
-    this.room.off(RoomEvent.Reconnecting, this.onLinkChange).off(RoomEvent.Reconnected, this.onLinkChange).off(RoomEvent.Disconnected, this.onLinkChange);
+    this.room.off(RoomEvent2.Reconnecting, this.onLinkChange).off(RoomEvent2.Reconnected, this.onLinkChange).off(RoomEvent2.Disconnected, this.onLinkChange);
     this.room.localParticipant.off(ParticipantEvent.TrackMuted, this.onMicMute).off(ParticipantEvent.TrackUnmuted, this.onMicMute);
     this.resetMic();
     return true;
@@ -838,6 +1190,8 @@ class NetworkStatsReporter {
   }
   remoteTrack(source) {
     for (const participant of this.room.remoteParticipants.values()) {
+      if (isAttach(participant))
+        continue;
       const publication = participant.getTrackPublication(source);
       if (publication?.isSubscribed && hasStats(publication.track)) {
         return publication.track;
@@ -862,20 +1216,22 @@ class NetworkStatsReporter {
     if (this.stopped)
       return;
     try {
-      const [avatarAudio, avatarVideo, mic, camera] = await Promise.all([
-        this.report(this.remoteTrack(Track2.Source.Microphone)),
-        this.report(this.remoteTrack(Track2.Source.Camera)),
-        this.report(this.localTrack(Track2.Source.Microphone)),
-        this.report(this.localTrack(Track2.Source.Camera))
+      const [avatarAudio2, avatarVideo, mic, camera] = await Promise.all([
+        this.report(this.remoteTrack(Track3.Source.Microphone)),
+        this.report(this.remoteTrack(Track3.Source.Camera)),
+        this.report(this.localTrack(Track3.Source.Microphone)),
+        this.report(this.localTrack(Track3.Source.Camera))
       ]);
       if (this.stopped)
         return;
-      const micPublication = this.room.localParticipant.getTrackPublication(Track2.Source.Microphone);
+      const micPublication = this.room.localParticipant.getTrackPublication(Track3.Source.Microphone);
       const micTrack = micPublication?.track?.mediaStreamTrack ?? null;
-      const sample = avatarAudio || avatarVideo || mic || camera ? buildSample({ avatarAudio, avatarVideo, mic, camera, micTrack }, document.hidden) : null;
+      const sample = avatarAudio2 || avatarVideo || mic || camera ? buildSample({ avatarAudio: avatarAudio2, avatarVideo, mic, camera, micTrack }, document.hidden) : null;
       this.watchMic(!!micPublication && !micPublication.isMuted && micTrack !== null, micTrack, mic ? sample?.mic?.packets_sent ?? 0 : null);
       if (!sample)
         return;
+      sample.avatar_audio_drop = this.audioDrop;
+      this.audioDrop = null;
       this.pending.push(sample);
       if (this.pending.length >= BATCH)
         this.flush();
@@ -885,7 +1241,7 @@ class NetworkStatsReporter {
     const was = this.micSilence.silent;
     const silent = this.micSilence.observe({
       at: Date.now(),
-      connected: this.room.state === ConnectionState.Connected,
+      connected: this.room.state === ConnectionState2.Connected,
       live,
       packetsSent,
       readyState: track?.readyState ?? null,
@@ -911,8 +1267,90 @@ class NetworkStatsReporter {
   }
 }
 
+// src/providers/livekit/parts.ts
+var PART_TYPE = "message.part";
+var PARTS_MAX = 64;
+var TEXT_MAX = 1024 * 1024;
+var DROPPED_KEPT = 16;
+
+class Parts {
+  onDrop;
+  open = null;
+  dropped = new Set;
+  constructor(onDrop) {
+    this.onDrop = onDrop;
+  }
+  take(packet) {
+    if (packet === null) {
+      this.cut("a packet that is no event arrived between its parts");
+      return null;
+    }
+    if (packet.type !== PART_TYPE) {
+      this.cut("another event arrived between its parts");
+      return packet;
+    }
+    const { id, index, count, text } = packet;
+    if (typeof id !== "string" || typeof text !== "string" || typeof index !== "number" || typeof count !== "number" || !Number.isInteger(index) || !Number.isInteger(count) || count < 1 || count > PARTS_MAX || index < 0 || index >= count) {
+      this.cut("a part broke the framing");
+      if (typeof id === "string")
+        this.report(id, "a part broke the framing");
+      return null;
+    }
+    if (index === 0) {
+      this.cut("a new event began before its last part");
+      this.open = { id, count, next: 0, text: "" };
+    }
+    const open = this.open;
+    if (open === null) {
+      this.report(id, "its first part never arrived");
+      return null;
+    }
+    if (open.id !== id || open.next !== index || open.count !== count) {
+      this.cut("a part arrived out of turn");
+      this.report(id, "a part arrived out of turn");
+      return null;
+    }
+    open.text += text;
+    open.next += 1;
+    if (open.text.length > TEXT_MAX) {
+      this.cut("its parts carried more than 1 MiB");
+      return null;
+    }
+    if (open.next < open.count)
+      return null;
+    this.open = null;
+    try {
+      const event = JSON.parse(open.text);
+      if (isRecord(event))
+        return event;
+    } catch {}
+    this.report(open.id, "its parts joined to no JSON object");
+    return null;
+  }
+  clear() {
+    this.open = null;
+    this.dropped.clear();
+  }
+  cut(why) {
+    if (this.open === null)
+      return;
+    const { id } = this.open;
+    this.open = null;
+    this.report(id, why);
+  }
+  report(id, why) {
+    if (this.dropped.has(id))
+      return;
+    this.dropped.add(id);
+    if (this.dropped.size > DROPPED_KEPT) {
+      this.dropped.delete(this.dropped.values().next().value);
+    }
+    this.onDrop(id, why);
+  }
+}
+
 // src/providers/livekit/presentation.ts
-import { Track as Track3 } from "livekit-client";
+import { Track as Track4 } from "livekit-client";
 var PRESENTATION_TIMING = {
   sampleMs: 250,
   settleMs: 3000,
@@ -974,14 +1412,16 @@ class PresentationWatch {
 }
 async function avatarVideoSize(room) {
   for (const participant of room.remoteParticipants.values()) {
-    const publication = participant.getTrackPublication(Track3.Source.Camera);
+    if (isAttach(participant))
+      continue;
+    const publication = participant.getTrackPublication(Track4.Source.Camera);
     const track = publication?.track;
     if (!publication?.isSubscribed || !track)
       continue;
     const publishedWidth = publication.dimensions?.width ?? null;
-    const report = await track.getRTCStatsReport();
+    const report2 = await track.getRTCStatsReport();
     let width = null;
-    report?.forEach((stat) => {
+    report2?.forEach((stat) => {
       if (stat.type === "inbound-rtp" && stat.kind === "video") {
         width = typeof stat.frameWidth === "number" ? stat.frameWidth : null;
       }
@@ -992,7 +1432,7 @@ async function avatarVideoSize(room) {
 }
 
 // src/providers/livekit/ready-fallback.ts
-import { Track as Track4 } from "livekit-client";
+import { Track as Track5 } from "livekit-client";
 var READY_FALLBACK_TIMING = {
   sampleMs: 500,
   delayMs: 5000,
@@ -1055,13 +1495,15 @@ class ReadyFallback {
 }
 async function avatarFramesDecoded(room) {
   for (const participant of room.remoteParticipants.values()) {
-    const publication = participant.getTrackPublication(Track4.Source.Camera);
+    if (isAttach(participant))
+      continue;
+    const publication = participant.getTrackPublication(Track5.Source.Camera);
     const track = publication?.track;
     if (!publication?.isSubscribed || !track)
       continue;
-    const report = await track.getRTCStatsReport();
+    const report2 = await track.getRTCStatsReport();
     let frames = null;
-    report?.forEach((stat) => {
+    report2?.forEach((stat) => {
       if (stat.type === "inbound-rtp" && stat.kind === "video") {
         frames = typeof stat.framesDecoded === "number" ? stat.framesDecoded : null;
       }
@@ -1071,69 +1513,6 @@ async function avatarFramesDecoded(room) {
   return null;
 }
 
-// src/providers/livekit/sequence.ts
-class EventSequence {
-  deliver;
-  replay;
-  last = 0;
-  held = new Map;
-  replaying = false;
-  stopped = false;
-  constructor(deliver, replay) {
-    this.deliver = deliver;
-    this.replay = replay;
-  }
-  repeats(seq) {
-    return seq !== 0 && (seq <= this.last || this.held.has(seq));
-  }
-  accept(seq, item) {
-    if (this.stopped || this.repeats(seq))
-      return;
-    if (seq === 0) {
-      this.deliver(item);
-      return;
-    }
-    if (seq !== this.last + 1) {
-      this.held.set(seq, item);
-      this.requestReplay();
-      return;
-    }
-    this.last = seq;
-    this.deliver(item);
-    this.release(false);
-  }
-  catchUp() {
-    if (!this.stopped)
-      this.requestReplay();
-  }
-  stop() {
-    this.stopped = true;
-    this.held.clear();
-  }
-  requestReplay() {
-    if (this.replaying)
-      return;
-    this.replaying = true;
-    this.replay(this.last).catch(() => {
-      return;
-    }).finally(() => {
-      this.replaying = false;
-      this.release(true);
-    });
-  }
-  release(all) {
-    const pending = [...this.held.keys()].sort((a, b) => a - b);
-    for (const seq of pending) {
-      if (this.stopped || !all && seq !== this.last + 1)
-        return;
-      const item = this.held.get(seq);
-      this.held.delete(seq);
-      this.last = seq;
-      this.deliver(item);
-    }
-  }
-}
-
 // src/providers/livekit/signals.ts
 function decode(payload) {
   try {
@@ -1143,9 +1522,37 @@ function decode(payload) {
     return null;
   }
 }
+function legacyReason(cause) {
+  if (cause === "content")
+    return "policy-violation";
+  if (cause === "age_check")
+    return "age-check";
+  if (cause === "expired")
+    return "time-limit";
+  if (cause === "connection_lost")
+    return "connection-lost";
+  return "ended";
+}
+function closedEnd(decoded) {
+  if (decoded.type !== "session.closed")
+    return null;
+  const cause = endReasonOf(decoded.reason);
+  const ended = {
+    reason: legacyReason(cause),
+    byClient: cause === "close_requested"
+  };
+  if (cause !== undefined)
+    ended.endReason = cause;
+  if (typeof decoded.message === "string" && decoded.message !== "") {
+    ended.message = decoded.message;
+  }
+  return ended;
+}
 function endReason(reason) {
   if (reason === "policy_violation")
     return "policy-violation";
+  if (reason === "age_check")
+    return "age-check";
   if (reason === "time_limit")
     return "time-limit";
   if (reason === "invalid_spec" || reason === "runtime_failed") {
@@ -1153,105 +1560,21 @@ function endReason(reason) {
   }
   return "ended";
 }
-function parseSessionEvent(payload) {
-  const decoded = decode(payload);
-  if (!decoded)
-    return null;
-  const seq = Number.isSafeInteger(decoded.seq) && decoded.seq > 0 ? decoded.seq : 0;
-  return { seq, event: protocolEvent(decoded, seq) };
-}
-function protocolEvent(decoded, seq) {
-  if (decoded.type === "session.output_ready") {
-    return { type: "output-ready" };
-  }
-  if (decoded.type === "command.result") {
-    return {
-      type: "command-result",
-      id: typeof decoded.id === "string" ? decoded.id : null,
-      result: {
-        status: decoded.status === "applied" ? "applied" : "rejected",
-        error: typeof decoded.error === "string" ? decoded.error : null
-      }
-    };
-  }
-  if (decoded.type === "tool.call" && typeof decoded.call_id === "string" && typeof decoded.name === "string" && isRecord(decoded.arguments)) {
-    return {
-      type: "tool-call",
-      call: {
-        callId: decoded.call_id,
-        name: decoded.name,
-        label: typeof decoded.label === "string" ? decoded.label : "",
-        arguments: decoded.arguments
-      }
-    };
-  }
-  if (decoded.type === "session.status" && decoded.status === "ended") {
-    return {
-      type: "ended",
-      reason: endReason(decoded.reason),
-      byClient: decoded.reason === "client_ended"
-    };
-  }
-  if (decoded.type === "error" && decoded.fatal === true) {
-    const ended = {
-      type: "ended",
-      reason: endReason(decoded.code),
-      byClient: false
-    };
-    if (typeof decoded.message === "string" && decoded.message !== "") {
-      ended.message = decoded.message;
-    }
-    return ended;
-  }
-  if (decoded.type === "error" && decoded.code === "bad_command") {
-    return { type: "command-unreadable" };
-  }
-  const event = sessionEvent(decoded, seq);
-  return event ? { type: "session-event", event } : { type: "other" };
-}
-var isString = (value) => typeof value === "string";
-function defaulted(value, absent) {
-  if (value === undefined)
-    return absent;
-  return isString(value) ? value : null;
-}
-var READERS = {
-  "user.transcript": (wire) => {
-    const source = defaulted(wire.source, "asr");
-    return isString(wire.text) && source !== null ? { text: wire.text, source } : null;
-  },
-  "user.speech.started": () => ({}),
-  "user.speech.ended": () => ({}),
-  "user.turn.ended": (wire) => isString(wire.text) ? { text: wire.text } : null,
-  "agent.turn.started": (wire) => {
-    const source = defaulted(wire.source, "reply");
-    return isString(wire.turn_id) && isString(wire.opened_by) && source !== null ? { turnId: wire.turn_id, openedBy: wire.opened_by, source } : null;
-  },
-  "agent.speech.started": (wire) => isString(wire.turn_id) ? { turnId: wire.turn_id } : null,
-  "agent.text": (wire) => {
-    const turnId = wire.turn_id ?? null;
-    return (turnId === null || isString(turnId)) && isString(wire.text) ? { turnId, text: wire.text } : null;
-  },
-  "agent.turn.ended": (wire) => isString(wire.turn_id) && isString(wire.reason) && isString(wire.spoken) ? { turnId: wire.turn_id, reason: wire.reason, spoken: wire.spoken } : null,
-  floor: (wire) => isString(wire.state) ? { state: wire.state } : null
-};
-function sessionEvent(decoded, seq) {
-  const type = decoded.type;
-  if (!isString(type) || !Object.hasOwn(READERS, type))
-    return null;
-  const fields = READERS[type](decoded);
-  if (fields === null)
-    return null;
-  const atMs = Number.isFinite(decoded.at_ms) ? decoded.at_ms : null;
-  return { type, seq, atMs, ...fields };
-}
 function parseRuntimeSignal(payload) {
   const decoded = decode(payload);
   if (decoded?.type === "output_ready") {
     return { type: "output-ready" };
   }
   if (decoded?.type === "session_ended") {
-    return { type: "session-ended", reason: endReason(decoded.reason) };
+    const reason = endReason(decoded.reason);
+    const signal = { type: "session-ended", reason };
+    const cause = reason === "refused" ? undefined : v1EndReason(decoded.reason);
+    if (cause !== undefined)
+      signal.endReason = cause;
+    if (typeof decoded.message === "string" && decoded.message !== "") {
+      signal.message = decoded.message;
+    }
+    return signal;
   }
   if (decoded?.type === "link_poor") {
     return { type: "link-poor" };
@@ -1271,6 +1594,10 @@ function clockSyncPong(payload, receivedAt, now) {
   };
   return new TextEncoder().encode(JSON.stringify(reply));
 }
+function parseInterfaceEvent(payload) {
+  const decoded = decode(payload);
+  return Array.isArray(decoded) ? null : decoded;
+}
 function parseDataEvent(payload) {
   const decoded = decode(payload);
   if (!decoded)
@@ -1293,38 +1620,14 @@ function parseDataEvent(payload) {
 import {
   AudioPresets,
   ParticipantEvent as ParticipantEvent2,
-  RoomEvent as RoomEvent2,
-  Track as Track5
+  RoomEvent as RoomEvent3,
+  Track as Track6
 } from "livekit-client";
-
-// src/core/camera.ts
-function cameraFacing(track) {
-  const facing = track.getSettings().facingMode;
-  return facing === "user" || facing === "environment" ? facing : null;
-}
-function requireCameraFacing(track, facing) {
-  const requested = typeof facing === "string" ? facing : !Array.isArray(facing) ? facing?.exact : undefined;
-  if (typeof requested !== "string")
-    return;
-  if (!track || track.getSettings().facingMode !== requested)
-    throw new DOMException("Requested camera direction is unavailable", "OverconstrainedError");
-}
-
-// src/providers/livekit/user-participant.ts
 function microphonePublishOptions(resilient) {
   if (!resilient)
     return;
   return { dtx: false, audioPreset: AudioPresets.speech };
 }
-var SCREEN_CAPTURE = {
-  audio: false,
-  resolution: { width: 1920, height: 1080, frameRate: 2 },
-  contentHint: "detail"
-};
-var SCREEN_PUBLISH = {
-  screenShareEncoding: { maxBitrate: 1500000, maxFramerate: 2 },
-  simulcast: false
-};
 
 class LiveKitUserParticipant {
   room;
@@ -1332,8 +1635,6 @@ class LiveKitUserParticipant {
   onSpeakingChanged;
   onMicrophoneChanged;
   onCameraChanged;
-  onScreenShareChanged;
-  screenTrack;
   inputs = {
     audioinput: { changing: false, unavailable: false },
     videoinput: { changing: false, unavailable: false }
@@ -1348,7 +1649,7 @@ class LiveKitUserParticipant {
   lastAudioSource = null;
   _isSpeaking = false;
   speakingHandler = null;
-  constructor(room, onTracksChanged, onSpeakingChanged, onMicrophoneChanged, onCameraChanged = () => {}, initialCameraFacing, resilient = false, onScreenShareChanged = () => {}) {
+  constructor(room, onTracksChanged, onSpeakingChanged, onMicrophoneChanged, onCameraChanged = () => {}, initialCameraFacing, resilient = false) {
     this.room = room;
     this.onTracksChanged = onTracksChanged;
     this.onSpeakingChanged = onSpeakingChanged;
@@ -1356,13 +1657,11 @@ class LiveKitUserParticipant {
     this.onCameraChanged = onCameraChanged;
     this.initialCameraFacing = initialCameraFacing;
     this.microphoneOptions = microphonePublishOptions(resilient);
-    this.onScreenShareChanged = onScreenShareChanged;
-    this.room.on(RoomEvent2.ActiveDeviceChanged, this.handleDeviceChanged);
-    this.room.localParticipant.on(ParticipantEvent2.LocalTrackUnpublished, this.handleTrackUnpublished);
+    this.room.on(RoomEvent3.ActiveDeviceChanged, this.handleDeviceChanged);
   }
   updateTracks() {
     let changed = false;
-    const videoPub = this.room.localParticipant.getTrackPublication(Track5.Source.Camera);
+    const videoPub = this.room.localParticipant.getTrackPublication(Track6.Source.Camera);
     const videoSource = videoPub?.track ?? null;
     if (videoSource !== this.lastVideoSource) {
       this._videoTrack?.detach();
@@ -1370,7 +1669,7 @@ class LiveKitUserParticipant {
       this.lastVideoSource = videoSource;
       changed = true;
     }
-    const audioPub = this.room.localParticipant.getTrackPublication(Track5.Source.Microphone);
+    const audioPub = this.room.localParticipant.getTrackPublication(Track6.Source.Microphone);
     const audioSource = audioPub?.track ?? null;
     if (audioSource !== this.lastAudioSource) {
       this._audioTrack?.detach();
@@ -1452,7 +1751,7 @@ class LiveKitUserParticipant {
     }
   }
   inputTrack(kind) {
-    const publication = this.room.localParticipant.getTrackPublication(kind === "audioinput" ? Track5.Source.Microphone : Track5.Source.Camera);
+    const publication = this.room.localParticipant.getTrackPublication(kind === "audioinput" ? Track6.Source.Microphone : Track6.Source.Camera);
     return kind === "audioinput" ? publication?.audioTrack : publication?.videoTrack;
   }
   async switchInput(kind, selection) {
@@ -1519,14 +1818,9 @@ class LiveKitUserParticipant {
       this.notifyInput(kind);
     }
   };
-  handleTrackUnpublished = (publication) => {
-    if (!this.disposed && publication.source === Track5.Source.ScreenShare)
-      this.onScreenShareChanged();
-  };
   cleanup() {
     this.disposed = true;
-    this.room.off(RoomEvent2.ActiveDeviceChanged, this.handleDeviceChanged);
-    this.room.localParticipant.off(ParticipantEvent2.LocalTrackUnpublished, this.handleTrackUnpublished);
+    this.room.off(RoomEvent3.ActiveDeviceChanged, this.handleDeviceChanged);
     if (this.inputs.audioinput.changing)
       this.inputTrack("audioinput")?.stop();
     if (this.inputs.videoinput.changing)
@@ -1604,44 +1898,10 @@ class LiveKitUserParticipant {
   get isVideoEnabled() {
     return this.room.localParticipant.isCameraEnabled;
   }
-  async startScreenShare() {
-    await this.setScreenShare(true);
-  }
-  async stopScreenShare() {
-    const track = this.screenTrack;
-    this.screenTrack = undefined;
-    try {
-      if (!this.disposed)
-        await this.setScreenShare(false);
-    } finally {
-      track?.stop();
-    }
-  }
-  get isScreenSharing() {
-    return this.room.localParticipant.isScreenShareEnabled;
-  }
-  async setScreenShare(enabled) {
-    if (this.disposed)
-      throw new Error("Participant is disconnected");
-    try {
-      const publication = await this.room.localParticipant.setScreenShareEnabled(enabled, SCREEN_CAPTURE, SCREEN_PUBLISH);
-      if (this.disposed)
-        publication?.track?.stop();
-      else if (enabled)
-        this.screenTrack = publication?.track;
-    } catch (error) {
-      throw new MediaAccessError(error);
-    } finally {
-      if (!this.disposed)
-        this.onScreenShareChanged();
-    }
-  }
   releaseDevices() {
     for (const pub of this.room.localParticipant.trackPublications.values()) {
       pub.track?.stop();
     }
-    this.screenTrack?.stop();
-    this.screenTrack = undefined;
   }
   startSpeakingDetection() {
     this.stopSpeakingDetection();
@@ -1667,37 +1927,31 @@ class LiveKitUserParticipant {
 
 // src/providers/livekit/conversation.ts
 var DATA_EVENT_TOPIC = "nuance.data";
-var SESSION_TOPIC = "nuance.v1";
-var PACKET_MAX_BYTES = 14000;
+var INTERFACE_EVENT_MAX_BYTES = 64000;
 var RUNTIME_TOPIC = "runtime";
 var CLOCK_SYNC_TOPIC = "clock-sync";
 var STATS_FLUSH_TIMEOUT_MS = 300;
-var SESSION_END_TIMEOUT_MS = 300;
-var SESSION_END_ID = "client-session-end";
+var SESSION_CLOSE_TIMEOUT_MS = 300;
+var SESSION_TOPIC = "nuance.v1";
+var READY_ID = "client-ready";
+var INTERFACE_CLOSE_ID = "client-disconnect";
 var REFUSAL_REASON_WAIT_MS = 500;
-var COMMAND_TIMEOUT_MS = 5000;
-var STREAM_TIMEOUT_MS = 30000;
-var BACKGROUND_ID = /^[a-z0-9][a-z0-9_-]{0,63}$/;
 var AVATAR_RETURN_TIMEOUT_MS = 8000;
 var RUNTIME_RETURN_TIMEOUT_MS = 20000;
 var RUNTIME_RECHECK_MS = 1000;
-function contextItem(item) {
-  const name = item.name === undefined ? {} : { name: item.name };
-  return item.type === "text" ? { type: "text", text: item.text, ...name } : { type: "image", media_type: item.mediaType, data: item.data, ...name };
-}
 function isReconnecting(lkState) {
-  return lkState === ConnectionState2.Reconnecting || lkState === ConnectionState2.SignalReconnecting;
+  return lkState === ConnectionState3.Reconnecting || lkState === ConnectionState3.SignalReconnecting;
 }
 function mapConnectionState(lkState, resilient = false) {
   switch (lkState) {
-    case ConnectionState2.Connected:
+    case ConnectionState3.Connected:
       return "connected";
-    case ConnectionState2.Connecting:
+    case ConnectionState3.Connecting:
       return "connecting";
-    case ConnectionState2.Reconnecting:
-    case ConnectionState2.SignalReconnecting:
+    case ConnectionState3.Reconnecting:
+    case ConnectionState3.SignalReconnecting:
       return resilient ? "reconnecting" : "connecting";
-    case ConnectionState2.Disconnected:
+    case ConnectionState3.Disconnected:
       return "disconnected";
   }
 }
@@ -1726,27 +1980,24 @@ class LiveKitConversation {
   presentation = null;
   readyFallback = null;
   layerFallback = null;
+  audioBacklog = null;
   changeHandlers = new Set;
   userQuality = "good";
   avatarQuality = "good";
   network = "good";
   eventsRegistered = false;
+  parts = new Parts((id, why) => {
+    console.warn(`Nuance SDK: interface event ${id} was dropped: ${why}.`);
+  });
   sessionEnded = false;
   refusal = null;
-  speaksProtocol = false;
   avatarSpeaking = false;
-  sequence = this.newSequence();
   answered = null;
-  commands = new Map;
-  commandCount = 0;
-  readyOwed = false;
   everConnected = false;
   away = false;
   awayTimer = null;
   runtimeTimer = null;
   presentationPaused = false;
-  readySending = false;
-  contextSent = null;
   leaving = null;
   connectGeneration = 0;
   _id;
@@ -1754,10 +2005,12 @@ class LiveKitConversation {
   cameraEnabled;
   cameraFacing;
   tokenProvider;
-  opensOnReady;
   presentsAtFullSize;
-  initialContext;
+  opensOnReady;
+  readyOwed = false;
   resilient;
+  dropsAudioBacklog;
+  interfaceTopic;
   constructor(config) {
     this.room = new Room({
       audioCaptureDefaults: config.mediaDevices?.microphoneId ? { deviceId: { ideal: config.mediaDevices.microphoneId } } : undefined,
@@ -1777,10 +2030,11 @@ class LiveKitConversation {
     this.cameraEnabled = config.cameraEnabled ?? true;
     this.cameraFacing = config.mediaDevices?.cameraFacing;
     this.tokenProvider = config.tokenProvider;
+    this.presentsAtFullSize = config.presentsAtFullSize ?? false;
     this.opensOnReady = config.opensOnReady ?? false;
-    this.presentsAtFullSize = config.presentsAtFullSize ?? this.opensOnReady;
-    this.initialContext = config.initialContext ?? [];
     this.resilient = config.resilientReconnect ?? false;
+    this.dropsAudioBacklog = config.dropAudioBacklog ?? false;
+    this.interfaceTopic = config.interface;
   }
   get id() {
     return this._id;
@@ -1791,11 +2045,7 @@ class LiveKitConversation {
     }
     this.setState("connecting");
     this.sessionEnded = false;
-    this.speaksProtocol = false;
-    this.sequence.stop();
-    this.sequence = this.newSequence();
-    this.readyOwed = false;
-    this.contextSent = null;
+    this.parts.clear();
     this.everConnected = false;
     if (!this.eventsRegistered) {
       this.registerRoomEvents();
@@ -1822,7 +2072,7 @@ class LiveKitConversation {
         type: "speaking-changed",
         participant: "user",
         isSpeaking
-      }), () => this.emit({ type: "microphone-changed" }), () => this.emit({ type: "camera-changed" }), this.cameraFacing, this.resilient, () => this.emit({ type: "screen-share-changed" }));
+      }), () => this.emit({ type: "microphone-changed" }), () => this.emit({ type: "camera-changed" }), this.cameraFacing, this.resilient);
       this._user.startSpeakingDetection();
       try {
         await this._user.unmuteAudio();
@@ -1845,6 +2095,7 @@ class LiveKitConversation {
       this.checkForExistingAvatar();
       this.stats = new NetworkStatsReporter(this.room, (silent) => this.emit({ type: "mic-silent-changed", silent }));
       this.stats.start();
+      this.startAudioBacklog();
     } catch (error) {
       if (!await aborted())
         this.setState("failed");
@@ -1862,18 +2113,21 @@ class LiveKitConversation {
     this.stopPresentation();
     this.stopReadyFallback();
     this.stopLayerFallback();
+    this.stopAudioBacklog();
     this.clearAway();
     this.stopRefusal();
     this._user?.cleanup();
     this._user?.releaseDevices();
     await this.flushStats();
-    await this.sendSessionEnd();
-    this.sequence.stop();
+    await this.sendInterfaceClose();
     await this.room.disconnect();
     this._avatar.updateParticipant(null);
     this._user = null;
     this.setState("disconnected");
   }
+  get interface() {
+    return this.interfaceTopic;
+  }
   get state() {
     return this._state;
   }
@@ -1886,51 +2140,55 @@ class LiveKitConversation {
   get avatar() {
     return this._avatar;
   }
-  async setBackground(background) {
-    if (!BACKGROUND_ID.test(background)) {
-      throw new Error(`Not a background id: ${JSON.stringify(background)}`);
+  async sendInterfaceEvent(event) {
+    if (this.room.state !== ConnectionState3.Connected) {
+      throw new Error("Not connected — call connect() first");
     }
-    return this.command({ type: "scene.background", background });
+    const text = JSON.stringify(event);
+    const payload = new TextEncoder().encode(text);
+    if (payload.byteLength > INTERFACE_EVENT_MAX_BYTES) {
+      await this.room.localParticipant.sendText(text, {
+        topic: this.interfaceTopic
+      });
+      return;
+    }
+    await this.room.localParticipant.publishData(payload, {
+      reliable: true,
+      topic: this.interfaceTopic
+    });
   }
-  async sendText(text) {
-    const line = text.trim();
-    if (!line)
-      throw new Error("Nothing to send: the text is blank");
-    return this.command({ type: "input.text", text: line, respond: true });
+  onInterfacePacket(payload) {
+    const event = this.parts.take(parseInterfaceEvent(payload));
+    if (event !== null)
+      this.deliverInterfaceEvent(event);
   }
-  async holdAgent() {
-    await this.command({ type: "agent.stop" }).catch(() => {
+  deliverInterfaceEvent(event) {
+    this.emit({ type: "interface-event", event });
+    this.followAvatarSpeech(event);
+    const ended = closedEnd(event);
+    if (ended === null)
       return;
-    });
-    return this.command({ type: "floor.hold" });
-  }
-  async releaseAgent() {
-    return this.command({ type: "floor.release" });
-  }
-  async sendToolResult(callId, output, options = {}) {
-    return this.command({
-      type: "tool.result",
-      call_id: callId,
-      output,
-      ...options.images?.length && {
-        images: options.images.map(({ mediaType, data }) => ({
-          media_type: mediaType,
-          data
-        }))
-      },
-      is_error: options.isError ?? false,
-      final: options.final ?? true
-    });
+    if (ended.byClient)
+      this.answered?.();
+    if (this.refusal !== null) {
+      this.reportEnd("refused", ended.message);
+      return;
+    }
+    this.reportEnd(ended.reason, ended.message, ended.endReason);
+  }
+  followAvatarSpeech(event) {
+    if (event.type === "session.output_transcript.delta") {
+      this.setAvatarSpeaking(true);
+    } else if (event.type === "session.output_audio.done") {
+      this.setAvatarSpeaking(false);
+    }
   }
   onChange(handler) {
     return this.onEvent((event) => {
-      if (event.type !== "data-event" && event.type !== "screen-share-changed" && event.type !== "tool-call" && event.type !== "session-event")
+      if (event.type !== "data-event" && event.type !== "interface-event")
         handler(event);
     });
   }
-  on(type, handler) {
-    return this.onEvent(sessionEventsOf(type, handler));
-  }
   onEvent(handler) {
     this.changeHandlers.add(handler);
     return () => {
@@ -1944,41 +2202,11 @@ class LiveKitConversation {
       }
     });
   }
-  onToolCall(handler) {
+  onInterfaceEvent(handler) {
     return this.onEvent((event) => {
-      if (event.type === "tool-call")
-        handler(event.call);
-    });
-  }
-  async command(command) {
-    if (this.room.state !== ConnectionState2.Connected) {
-      throw new Error("Not connected — call connect() first");
-    }
-    if (!this.speaksProtocol) {
-      throw new Error("The runtime takes no session commands");
-    }
-    const id = `client-command-${++this.commandCount}`;
-    const answer = Promise.withResolvers();
-    this.commands.set(id, { type: command.type, settle: answer.resolve });
-    let timer;
-    const text = JSON.stringify({ ...command, id });
-    const payload = new TextEncoder().encode(text);
-    const streamed = payload.byteLength > PACKET_MAX_BYTES;
-    const sent = streamed ? this.room.localParticipant.sendText(text, { topic: SESSION_TOPIC }) : this.room.localParticipant.publishData(payload, {
-      reliable: true,
-      topic: SESSION_TOPIC
+      if (event.type === "interface-event")
+        handler(event.event);
     });
-    try {
-      return await Promise.race([
-        sent.then(() => answer.promise),
-        new Promise((_, reject) => {
-          timer = setTimeout(() => reject(new Error(`The runtime did not answer ${command.type}`)), streamed ? STREAM_TIMEOUT_MS : COMMAND_TIMEOUT_MS);
-        })
-      ]);
-    } finally {
-      clearTimeout(timer);
-      this.commands.delete(id);
-    }
   }
   emit(event) {
     for (const handler of this.changeHandlers) {
@@ -1996,8 +2224,13 @@ class LiveKitConversation {
     this.network = worst;
     this.emit({ type: "network-changed", quality: worst });
   }
-  isAvatarParticipant(_participant) {
-    return true;
+  fromRuntime(participant) {
+    if (participant === undefined)
+      return false;
+    return participant.kind === ParticipantKind.AGENT || participant.identity === this._avatar.identity;
+  }
+  isAvatarParticipant(participant) {
+    return !isAttach(participant);
   }
   checkForExistingAvatar() {
     for (const [, participant] of this.room.remoteParticipants) {
@@ -2013,27 +2246,26 @@ class LiveKitConversation {
     }
   }
   registerRoomEvents() {
-    this.room.on(RoomEvent3.ConnectionStateChanged, (lkState) => {
+    this.room.on(RoomEvent4.ConnectionStateChanged, (lkState) => {
       if (this._state === "idle")
         return;
-      if (lkState === ConnectionState2.Disconnected)
+      if (lkState === ConnectionState3.Disconnected)
         return;
       const mapped = mapConnectionState(lkState, this.resilient && this.everConnected);
       if (mapped === "connected")
         this.everConnected = true;
-      if (lkState === ConnectionState2.Reconnecting)
+      if (lkState === ConnectionState3.Reconnecting)
         this.setAvatarSpeaking(false);
       if (mapped !== this._state) {
         this.setState(mapped);
       }
-      if (lkState === ConnectionState2.Connected) {
-        this.sendOwedReady();
-        if (this.away)
-          this.awaitAvatarReturn();
+      if (lkState === ConnectionState3.Connected && this.away) {
+        this.awaitAvatarReturn();
       }
+      if (lkState === ConnectionState3.Connected)
+        this.sendOwedReady();
     });
-    this.room.on(RoomEvent3.Reconnected, () => this.catchUp());
-    this.room.on(RoomEvent3.ParticipantConnected, (participant) => {
+    this.room.on(RoomEvent4.ParticipantConnected, (participant) => {
       if (this.isAvatarParticipant(participant)) {
         const tracksChanged = this._avatar.updateParticipant(participant);
         this.emit({ type: "avatar-connected" });
@@ -2042,10 +2274,9 @@ class LiveKitConversation {
         }
         if (this.away)
           this.avatarBack();
-        this.catchUp();
       }
     });
-    this.room.on(RoomEvent3.ParticipantDisconnected, (participant) => {
+    this.room.on(RoomEvent4.ParticipantDisconnected, (participant) => {
       if (!this.isAvatarParticipant(participant))
         return;
       if (!this.resilient) {
@@ -2053,7 +2284,7 @@ class LiveKitConversation {
         return;
       }
       queueMicrotask(() => {
-        if (this.room.state === ConnectionState2.Disconnected)
+        if (this.room.state === ConnectionState3.Disconnected)
           return;
         if (isReconnecting(this.room.state)) {
           this.avatarAway();
@@ -2065,16 +2296,15 @@ class LiveKitConversation {
         }
       });
     });
-    this.room.on(RoomEvent3.Disconnected, () => {
+    this.room.on(RoomEvent4.Disconnected, () => {
       this.stats?.abandon();
       this.stats = null;
-      this.sequence.stop();
       this.setAvatarSpeaking(false);
       this.stopPresentation();
       this.stopReadyFallback();
       this.stopLayerFallback();
+      this.stopAudioBacklog();
       this.clearAway();
-      this.readyOwed = false;
       this._user?.cleanup();
       this._avatar.updateParticipant(null);
       this._user = null;
@@ -2089,7 +2319,7 @@ class LiveKitConversation {
       }
       this.setState("disconnected");
     });
-    this.room.on(RoomEvent3.ConnectionQualityChanged, (quality, participant) => {
+    this.room.on(RoomEvent4.ConnectionQualityChanged, (quality, participant) => {
       const mapped = mapConnectionQuality(quality);
       if (participant === this.room.localParticipant) {
         this.userQuality = mapped;
@@ -2100,7 +2330,15 @@ class LiveKitConversation {
       }
       this.updateNetwork();
     });
-    this.room.on(RoomEvent3.TrackSubscribed, (_track, _publication, participant) => {
+    this.room.on(RoomEvent4.TrackPublished, (publication, participant) => {
+      if (isAttach(participant))
+        publication.setSubscribed(false);
+    });
+    this.room.on(RoomEvent4.TrackSubscribed, (_track, publication, participant) => {
+      if (isAttach(participant)) {
+        publication.setSubscribed(false);
+        return;
+      }
       if (this.isAvatarParticipant(participant)) {
         if (this._avatar.updateTracks()) {
           this.emit({ type: "tracks-changed" });
@@ -2108,18 +2346,16 @@ class LiveKitConversation {
         this.armReadyFallback();
       }
     });
-    this.room.on(RoomEvent3.TrackUnsubscribed, (_track, _publication, participant) => {
+    this.room.on(RoomEvent4.TrackUnsubscribed, (_track, _publication, participant) => {
       if (this.isAvatarParticipant(participant)) {
         if (this._avatar.updateTracks()) {
           this.emit({ type: "tracks-changed" });
         }
       }
     });
-    this.room.on(RoomEvent3.DataReceived, (payload, _participant, _kind, topic) => {
-      if (topic === SESSION_TOPIC) {
-        this.handleSessionEvent(payload);
+    this.room.on(RoomEvent4.DataReceived, (payload, participant, _kind, topic) => {
+      if (isAttach(participant))
         return;
-      }
       if (topic === RUNTIME_TOPIC) {
         this.handleRuntimeSignal(payload);
         return;
@@ -2128,6 +2364,11 @@ class LiveKitConversation {
         this.handleClockSyncPing(payload);
         return;
       }
+      if (topic === this.interfaceTopic) {
+        if (this.fromRuntime(participant))
+          this.onInterfacePacket(payload);
+        return;
+      }
       if (topic !== DATA_EVENT_TOPIC)
         return;
       const event = parseDataEvent(payload);
@@ -2148,71 +2389,23 @@ class LiveKitConversation {
       return;
     });
   }
-  async sendSessionEnd() {
-    if (this.sessionEnded || !this.speaksProtocol || this.room.state !== ConnectionState2.Connected) {
+  async sendInterfaceClose() {
+    if (this.sessionEnded || this.room.state !== ConnectionState3.Connected) {
       return;
     }
     this.sessionEnded = true;
-    const answered = new Promise((resolve) => {
+    const closed = new Promise((resolve) => {
       this.answered = resolve;
     });
-    const command = new TextEncoder().encode(JSON.stringify({ type: "session.end", id: SESSION_END_ID }));
+    const close = new TextEncoder().encode(JSON.stringify({ type: "session.close", event_id: INTERFACE_CLOSE_ID }));
     await Promise.race([
-      this.room.localParticipant.publishData(command, { reliable: true, topic: SESSION_TOPIC }).then(() => answered),
-      new Promise((resolve) => setTimeout(resolve, SESSION_END_TIMEOUT_MS))
+      this.room.localParticipant.publishData(close, { reliable: true, topic: this.interfaceTopic }).then(() => closed),
+      new Promise((resolve) => setTimeout(resolve, SESSION_CLOSE_TIMEOUT_MS))
     ]).catch(() => {
       return;
     });
     this.answered = null;
   }
-  handleSessionEvent(payload) {
-    const packet = parseSessionEvent(payload);
-    if (packet === null)
-      return;
-    this.speaksProtocol = true;
-    this.sendContext();
-    const { seq, event } = packet;
-    if (this.sequence.repeats(seq))
-      return;
-    if (event.type === "command-result") {
-      if (event.id === SESSION_END_ID)
-        this.answered?.();
-      else if (event.id !== null) {
-        this.commands.get(event.id)?.settle(event.result);
-      }
-    } else if (event.type === "command-unreadable") {
-      const [oldest] = this.commands;
-      if (oldest) {
-        const [id, { type, settle }] = oldest;
-        this.commands.delete(id);
-        settle({ status: "rejected", error: `unknown command ${type}` });
-      }
-    }
-    this.sequence.accept(seq, event);
-  }
-  deliver(event) {
-    if (event.type === "output-ready") {
-      this.markAvatarReady();
-    } else if (event.type === "tool-call") {
-      this.emit({ type: "tool-call", call: event.call });
-    } else if (event.type === "ended") {
-      this.answered?.();
-      if (!event.byClient)
-        this.reportEnd(event.reason, event.message);
-    } else if (event.type === "session-event") {
-      if (event.event.type === "floor") {
-        this.setAvatarSpeaking(event.event.state === "speaking");
-      }
-      this.emit({ type: "session-event", event: event.event });
-    }
-  }
-  newSequence() {
-    return new EventSequence((event) => this.deliver(event), (afterSeq) => this.command({ type: "session.replay", after_seq: afterSeq }));
-  }
-  catchUp() {
-    if (this.speaksProtocol)
-      this.sequence.catchUp();
-  }
   handleRuntimeSignal(payload) {
     const signal = parseRuntimeSignal(payload);
     if (signal?.type === "session-ended") {
@@ -2220,7 +2413,7 @@ class LiveKitConversation {
         this.refusal ??= setTimeout(() => this.reportEnd("refused"), REFUSAL_REASON_WAIT_MS);
         return;
       }
-      this.reportEnd(signal.reason);
+      this.reportEnd(signal.reason, signal.message, signal.endReason);
     } else if (signal?.type === "output-ready") {
       this.markAvatarReady();
     } else if (signal?.type === "link-poor") {
@@ -2233,8 +2426,6 @@ class LiveKitConversation {
     }
     this.readyFallback = new ReadyFallback(() => avatarFramesDecoded(this.room), () => this._avatar.isVideoPlaying, () => {
       this.readyFallback = null;
-      if (this.opensOnReady)
-        this.speaksProtocol = true;
       this.markAvatarReady();
     });
     this.readyFallback.start();
@@ -2260,10 +2451,6 @@ class LiveKitConversation {
     this._avatar.markReady();
     this.startLayerFallback();
     this.emit({ type: "avatar-ready" });
-    if (!this.opensOnReady) {
-      this.emit({ type: "avatar-presented" });
-      return;
-    }
     if (!this.presentsAtFullSize) {
       this.markAvatarPresented();
       return;
@@ -2277,42 +2464,19 @@ class LiveKitConversation {
   }
   markAvatarPresented() {
     this.presentation = null;
-    if (this.speaksProtocol && this.room.state === ConnectionState2.Connected) {
-      this.ready().catch(() => {
-        return;
-      });
-    } else if (this.resilient && this.speaksProtocol && isReconnecting(this.room.state)) {
+    if (this.opensOnReady) {
       this.readyOwed = true;
+      this.sendOwedReady();
     }
     this.emit({ type: "avatar-presented" });
   }
-  sendContext() {
-    if (this.contextSent !== null || this.initialContext.length === 0)
-      return;
-    this.contextSent = this.command({
-      type: "session.context",
-      items: this.initialContext.map(contextItem)
-    }).then(() => {
-      return;
-    }, () => {
-      return;
-    });
-  }
-  ready() {
-    this.sendContext();
-    const ready = () => this.command({ type: "session.ready" });
-    return this.contextSent === null ? ready() : this.contextSent.then(ready);
-  }
   sendOwedReady() {
-    if (!this.readyOwed || !this.speaksProtocol || this.readySending)
-      return;
-    this.readySending = true;
-    this.ready().then(() => {
-      this.readyOwed = false;
-    }).catch(() => {
+    if (!this.readyOwed || this.room.state !== ConnectionState3.Connected)
       return;
-    }).finally(() => {
-      this.readySending = false;
+    this.readyOwed = false;
+    const ready = new TextEncoder().encode(JSON.stringify({ type: "session.ready", id: READY_ID }));
+    this.room.localParticipant.publishData(ready, { reliable: true, topic: SESSION_TOPIC }).catch(() => {
+      this.readyOwed = true;
     });
   }
   avatarLeft() {
@@ -2360,7 +2524,7 @@ class LiveKitConversation {
         this.awaitRuntimeReturn(RUNTIME_RECHECK_MS);
         return;
       }
-      if (this.room.state === ConnectionState2.Disconnected)
+      if (this.room.state === ConnectionState3.Disconnected)
         return;
       if (this.avatarInRoom())
         return;
@@ -2406,16 +2570,38 @@ class LiveKitConversation {
     this.layerFallback?.stop();
     this.layerFallback = null;
   }
+  startAudioBacklog() {
+    if (!this.dropsAudioBacklog || this.audioBacklog !== null)
+      return;
+    this.audioBacklog = new AudioBacklogWatch(() => avatarJitterBuffer(this.room), (backlog) => {
+      const behind = Math.round(backlog.jitterBufferMs - backlog.targetMs);
+      console.info(`Nuance SDK: the avatar's audio was ${behind} ms behind (jitter buffer ${Math.round(backlog.jitterBufferMs)} ms, target ${Math.round(backlog.targetMs)} ms); dropped it to live.`);
+      this.stats?.noteAudioDrop(backlog);
+      resubscribeAvatarAudio(this.room).catch(() => {
+        return;
+      });
+    });
+    this.audioBacklog.start();
+  }
+  stopAudioBacklog() {
+    this.audioBacklog?.stop();
+    this.audioBacklog = null;
+  }
   stopPresentation() {
     this.presentation?.stop();
     this.presentation = null;
   }
-  reportEnd(reason, message) {
+  reportEnd(reason, message, cause) {
     this.stopRefusal();
     if (this.sessionEnded)
       return;
     this.sessionEnded = true;
-    this.emit(message === undefined ? { type: "session-ended", reason } : { type: "session-ended", reason, message });
+    this.emit({
+      type: "session-ended",
+      reason,
+      ...cause !== undefined && { endReason: cause },
+      ...message !== undefined && { message }
+    });
   }
   stopRefusal() {
     if (this.refusal === null)
@@ -2436,16 +2622,16 @@ class LiveKitConversation {
 
 // src/conversation.ts
 var DEFAULT_HOST = "https://api.nuancelabs.ai";
+var LIVE_INTERFACE = "nuance_live";
+var LIVE_INTERFACES = new Set([LIVE_INTERFACE, "gpt_live"]);
 var QUEUE_HEARTBEAT_INTERVAL_MS = 5000;
 var HEARTBEAT_INTERVAL_MS = 5000;
 var EVENTS_RETRY_MS = 5000;
 var ADMISSION_FAILED_REQUESTS = 6;
 var BUSY_RETRY_LIMIT_MS = 60000;
 var BUSY_RETRY_DEFAULT_MS = 3000;
+var CAPACITY_RETRY_LIMIT_MS = 15000;
 var LOST_WINDOW_MS = 30000;
-function createNuanceConversation(options = {}) {
-  return new NuanceConversation(options);
-}
 var TERMINAL_STATUSES = new Set([
   "failed",
   "expired",
@@ -2474,9 +2660,15 @@ function isMaintenanceBody(body) {
 function isBusyBody(body) {
   return isRecord(body) && body.code === "busy";
 }
+function isCapacityBody(body) {
+  return isRecord(body) && body.code === "capacity_unavailable";
+}
 function isGuestLimitBody(body) {
   return isRecord(body) && body.code === "guest_limit";
 }
+function refusedByServer(error) {
+  return error instanceof ApiError || error instanceof ActiveSessionError || error instanceof LegalRequiredError || error instanceof MaintenanceError || error instanceof GuestLimitError || error instanceof PolicyCurfewError;
+}
 function isCurfewBody(body) {
   return isRecord(body) && body.code === "policy_curfew";
 }
@@ -2501,14 +2693,18 @@ class NuanceConversation {
   ticker;
   sessionOverrides;
   personality;
-  tools;
-  initialContext;
   variant;
   maxSessionSeconds;
   videoCapture;
   startOn;
+  greenScreen;
+  alphaFrames;
   mediaDevices;
   resilientReconnect;
+  dropAudioBacklog;
+  interfaceName = LIVE_INTERFACE;
+  stayConnectedOnEnd;
+  joined = false;
   delegate = null;
   delegateUnsubscribe = null;
   stopBeats = null;
@@ -2519,6 +2715,7 @@ class NuanceConversation {
   reconnectingAt = null;
   lostContact = false;
   attempt = 0;
+  toldPreparing = -1;
   lastPosition = null;
   lastEstimate = null;
   capped = false;
@@ -2541,24 +2738,28 @@ class NuanceConversation {
     this.ticker = deps.ticker ?? pageTicker;
     this.sessionOverrides = options.sessionOverrides ?? {};
     this.personality = options.personality;
-    this.tools = options.tools;
-    this.initialContext = options.initialContext ?? [];
     this.variant = options.variant;
     this.maxSessionSeconds = options.maxSessionSeconds;
     this.videoCapture = options.videoCapture;
     this.startOn = options.startOn ?? "first-frame";
+    this.greenScreen = options.greenScreen ?? false;
+    this.alphaFrames = options.alphaFrames ?? false;
     this.mediaDevices = options.mediaDevices;
     this.resilientReconnect = options.resilientReconnect ?? false;
+    this.dropAudioBacklog = options.dropAudioBacklog ?? false;
+    this.stayConnectedOnEnd = options.stayConnectedOnEnd ?? false;
   }
   async connect() {
     if (this._state === "connecting" || this._state === "queued" || this._state === "connected" || this._state === "reconnecting") {
       throw new Error(`Cannot connect while in "${this._state}" state`);
     }
     const attempt = ++this.attempt;
+    let created = false;
     this.setState("connecting");
     this.clearLimit();
     this.capped = false;
     this.ended = false;
+    this.joined = false;
     this.reconnectingAt = null;
     this.lostContact = false;
     this.lastPosition = null;
@@ -2572,21 +2773,27 @@ class NuanceConversation {
       try {
         const request = {
           session_overrides: this.sessionOverrides,
-          client_ready: this.startOn === "full-quality" || this.initialContext.length > 0
+          ...this.startOn === "full-quality" ? { client_ready: true } : {}
         };
         const timezone = this.timezone();
         if (timezone)
           request.timezone = timezone;
+        const camera = await cameraSource(mediaDevices);
+        if (camera)
+          request.camera = camera;
         if (this.personality)
           request.personality = this.personality;
-        if (this.tools)
-          request.tools = this.tools;
         if (this.variant)
           request.variant = this.variant;
         if (this.maxSessionSeconds !== undefined) {
           request.max_session_seconds = this.maxSessionSeconds;
         }
+        if (this.greenScreen)
+          request.green_screen = true;
+        if (this.alphaFrames)
+          request.alpha_frames = true;
         conversation = await this.createWhenNotBusy(request, attempt);
+        created = true;
       } catch (error) {
         if (error instanceof ApiError && error.status === 409) {
           throw new ActiveSessionError;
@@ -2622,7 +2829,7 @@ class NuanceConversation {
         if (event.type === "session-ended" && (event.reason === "connection-lost" || event.reason === "refused")) {
           const held = this.held;
           this.held = null;
-          this.endSession(event.reason, event.message);
+          this.endSession(event.reason, event.message, event.endReason, false);
           this.disconnect().catch(() => {});
           if (held !== null) {
             this.api.abandonConversation(held).catch(() => {});
@@ -2630,12 +2837,26 @@ class NuanceConversation {
           return;
         }
         if (event.type === "session-ended") {
-          this.endSession(event.reason, event.message);
+          this.endSession(event.reason, event.message, event.endReason);
           return;
         }
         this.emit(event);
       });
-      await this.delegate.connect();
+      if (this.ended && !this.stayConnectedOnEnd) {
+        await this.disconnect();
+        return;
+      }
+      try {
+        await this.delegate.connect();
+      } catch (error) {
+        if (!this.ended || this.stayConnectedOnEnd)
+          throw error;
+      }
+      this.joined = true;
+      if (this.ended && !this.stayConnectedOnEnd) {
+        await this.disconnect();
+        return;
+      }
       if (grant === null) {
         this.startHeartbeat(conversation.id, HEARTBEAT_INTERVAL_MS);
       }
@@ -2643,6 +2864,19 @@ class NuanceConversation {
       if (attempt !== this.attempt) {
         throw error;
       }
+      if (!created && refusedByServer(error)) {
+        const refused = {
+          type: "session-ended",
+          reason: "refused",
+          message: error.message,
+          error
+        };
+        for (const handler of this.changeHandlers) {
+          try {
+            handler(refused);
+          } catch {}
+        }
+      }
       await this.disconnect().catch(() => {});
       this.setState("failed");
       throw error;
@@ -2650,6 +2884,7 @@ class NuanceConversation {
   }
   async disconnect() {
     this.attempt += 1;
+    this.joined = false;
     this.clearLimit();
     this.stopHeartbeat();
     this.stopEvents?.();
@@ -2658,7 +2893,12 @@ class NuanceConversation {
     this.admitted = null;
     this.delegateUnsubscribe?.();
     this.delegateUnsubscribe = null;
-    await this.delegate?.disconnect();
+    const trailing = this.ended ? this.delegate?.onInterfaceEvent((event) => this.emit({ type: "interface-event", event })) : undefined;
+    try {
+      await this.delegate?.disconnect();
+    } finally {
+      trailing?.();
+    }
     this.delegate = null;
     await this.release();
     this.setState("disconnected");
@@ -2669,6 +2909,9 @@ class NuanceConversation {
   get id() {
     return this._id;
   }
+  get interface() {
+    return this.interfaceName;
+  }
   get user() {
     if (!this.delegate) {
       throw new Error("Not connected — call connect() first");
@@ -2681,45 +2924,18 @@ class NuanceConversation {
     }
     return this.delegate.avatar;
   }
-  async setBackground(background) {
-    if (!this.delegate) {
-      throw new Error("Not connected — call connect() first");
-    }
-    return this.delegate.setBackground(background);
-  }
-  async sendText(text) {
-    if (!this.delegate) {
-      throw new Error("Not connected — call connect() first");
-    }
-    return this.delegate.sendText(text);
-  }
-  async holdAgent() {
-    if (!this.delegate) {
-      throw new Error("Not connected — call connect() first");
-    }
-    return this.delegate.holdAgent();
-  }
-  async releaseAgent() {
+  async sendInterfaceEvent(event) {
     if (!this.delegate) {
       throw new Error("Not connected — call connect() first");
     }
-    return this.delegate.releaseAgent();
-  }
-  async sendToolResult(callId, output, options) {
-    if (!this.delegate) {
-      throw new Error("Not connected — call connect() first");
-    }
-    return this.delegate.sendToolResult(callId, output, options);
+    return this.delegate.sendInterfaceEvent(event);
   }
   onChange(handler) {
     return this.onEvent((event) => {
-      if (event.type !== "data-event" && event.type !== "screen-share-changed" && event.type !== "tool-call" && event.type !== "session-event")
+      if (event.type !== "data-event" && event.type !== "interface-event")
         handler(event);
     });
   }
-  on(type, handler) {
-    return this.onEvent(sessionEventsOf(type, handler));
-  }
   onEvent(handler) {
     this.changeHandlers.add(handler);
     return () => {
@@ -2733,10 +2949,10 @@ class NuanceConversation {
       }
     });
   }
-  onToolCall(handler) {
+  onInterfaceEvent(handler) {
     return this.onEvent((event) => {
-      if (event.type === "tool-call")
-        handler(event.call);
+      if (event.type === "interface-event")
+        handler(event.event);
     });
   }
   async waitForSlot(conversationId, attempt) {
@@ -2745,7 +2961,7 @@ class NuanceConversation {
       this.followLive(conversationId, admission.after, attempt);
       return admission.grant;
     }
-    this.admitted = Promise.withResolvers();
+    this.admitted = resolvers();
     this.startHeartbeat(conversationId, QUEUE_HEARTBEAT_INTERVAL_MS);
     await this.admitted.promise;
     return null;
@@ -2798,6 +3014,8 @@ class NuanceConversation {
           if (event.type === "queued" && event.position != null) {
             this.reportPlace(event.position, event.estimated_wait_seconds ?? null, null, event.preparing ?? false);
           }
+          if (event.type === "preparing")
+            this.reportPreparing();
         }
       }
     } finally {
@@ -2838,7 +3056,7 @@ class NuanceConversation {
             this.armLimit(event.seconds_remaining, receivedAt);
           }
           if (event.type === "ended") {
-            this.endSession(this.endReason(event.reason));
+            this.endSession(this.endReason(event.reason), undefined, v1EndReason(event.reason));
             return;
           }
         }
@@ -2853,6 +3071,8 @@ class NuanceConversation {
       return "time-limit";
     if (reason === "policy_violation")
       return "policy-violation";
+    if (reason === "age_check")
+      return "age-check";
     if (reason === "runtime_silent" || this.cutOff())
       return "connection-lost";
     return "ended";
@@ -2873,6 +3093,11 @@ class NuanceConversation {
     if (conversation.provider !== "livekit") {
       throw new Error(`Unsupported provider ${conversation.provider}`);
     }
+    const named = conversation.interface ?? null;
+    if (named === null || !LIVE_INTERFACES.has(named)) {
+      throw new Error(`The session runs on ${named ?? "nuance.v1"}, which this SDK does not speak: it needs Nuance Live (interface "nuance_live")`);
+    }
+    this.interfaceName = named;
     const connection = grant ?? await this.connectRoom(conversation.id);
     if (attempt !== this.attempt) {
       throw new DisconnectedError;
@@ -2883,10 +3108,11 @@ class NuanceConversation {
       mediaDevices,
       cameraEnabled: !this.sessionOverrides.disable_camera && mediaDevices.cameraEnabled !== false,
       videoCapture: this.videoCapture,
-      opensOnReady: conversation.provider_metadata?.client_ready === true,
       presentsAtFullSize: this.startOn === "full-quality",
-      initialContext: this.initialContext,
-      resilientReconnect: this.resilient
+      opensOnReady: conversation.provider_metadata?.client_ready === true,
+      resilientReconnect: this.resilient,
+      dropAudioBacklog: typeof this.dropAudioBacklog === "function" ? this.dropAudioBacklog() : this.dropAudioBacklog,
+      interface: this.interfaceName
     });
   }
   async connectRoom(conversationId) {
@@ -2897,18 +3123,24 @@ class NuanceConversation {
     return response.connection;
   }
   async createWhenNotBusy(request, attempt) {
-    const giveUpAt = Date.now() + BUSY_RETRY_LIMIT_MS;
+    const started = Date.now();
     for (;; ) {
       try {
         return await this.api.createConversation(request);
       } catch (error) {
-        if (!(error instanceof ApiError) || error.status !== 503 || !isBusyBody(error.body) || attempt !== this.attempt) {
+        if (!(error instanceof ApiError) || attempt !== this.attempt) {
           throw error;
         }
-        const waitMs = typeof error.body.retry_after_seconds === "number" ? error.body.retry_after_seconds * 1000 : BUSY_RETRY_DEFAULT_MS;
-        if (Date.now() + waitMs > giveUpAt)
+        const busy = error.status === 503 && isBusyBody(error.body);
+        const full = error.status === 429 && isCapacityBody(error.body);
+        if (!busy && !full)
           throw error;
-        if (this._state !== "queued")
+        const asked = error.body.retry_after_seconds;
+        const waitMs = typeof asked === "number" ? asked * 1000 : BUSY_RETRY_DEFAULT_MS;
+        const limitMs = busy ? BUSY_RETRY_LIMIT_MS : CAPACITY_RETRY_LIMIT_MS;
+        if (Date.now() + waitMs > started + limitMs)
+          throw error;
+        if (busy && this._state !== "queued")
           this.setState("queued");
         await new Promise((resolve) => setTimeout(resolve, waitMs));
         if (attempt !== this.attempt)
@@ -2979,11 +3211,21 @@ class NuanceConversation {
       this.admitted = null;
       return;
     }
+    if (state.status === "queued" && state.position == null && state.preparing) {
+      this.reportPreparing();
+      return;
+    }
     if (state.status !== "queued" || state.position == null) {
       return;
     }
     this.reportPlace(state.position, state.estimated_wait_seconds ?? null, state.pool_slots ?? null, state.preparing ?? false);
   }
+  reportPreparing() {
+    if (this.toldPreparing === this.attempt)
+      return;
+    this.toldPreparing = this.attempt;
+    this.emit({ type: "avatar-preparing" });
+  }
   reportPlace(position, estimate, poolSlots, preparing) {
     if (this._state !== "queued") {
       this.setState("queued");
@@ -3029,14 +3271,28 @@ class NuanceConversation {
     }
     await this.api.abandonConversation(held).catch(() => {});
   }
-  endSession(reason, message) {
+  endSession(reason, message, cause, leave = true) {
     if (this.ended) {
       return;
     }
     this.ended = true;
     this.clearLimit();
     this.stopHeartbeat();
-    this.emit(message === undefined ? { type: "session-ended", reason } : { type: "session-ended", reason, message });
+    this.emit({
+      type: "session-ended",
+      reason,
+      ...cause !== undefined && { endReason: cause },
+      ...message !== undefined && { message }
+    });
+    if (!leave || this.stayConnectedOnEnd)
+      return;
+    if (!this.joined) {
+      this.delegateUnsubscribe?.();
+      this.delegateUnsubscribe = null;
+      this.delegate?.disconnect().catch(() => {});
+      return;
+    }
+    this.disconnect().catch(() => {});
   }
   stopHeartbeat() {
     this.stopBeats?.();
@@ -3044,7 +3300,7 @@ class NuanceConversation {
   }
   emit(event) {
     for (const handler of this.changeHandlers) {
-      handler(event);
+      deliver(handler, event);
     }
   }
   atLimit() {
@@ -3070,17 +3326,43 @@ class NuanceConversation {
     this.emit({ type: "state-changed", state });
   }
 }
-// src/core/types.ts
-var ConversationState;
-((ConversationState2) => {
-  ConversationState2["Idle"] = "idle";
-  ConversationState2["Queued"] = "queued";
-  ConversationState2["Connecting"] = "connecting";
-  ConversationState2["Connected"] = "connected";
-  ConversationState2["Reconnecting"] = "reconnecting";
-  ConversationState2["Disconnected"] = "disconnected";
-  ConversationState2["Failed"] = "failed";
-})(ConversationState ||= {});
+
+// src/create.ts
+var KNOWN2 = {
+  host: true,
+  headers: true,
+  token: true,
+  sessionOverrides: true,
+  personality: true,
+  variant: true,
+  maxSessionSeconds: true,
+  videoCapture: true,
+  mediaDevices: true,
+  startOn: true,
+  greenScreen: true,
+  alphaFrames: true,
+  resilientReconnect: true,
+  dropAudioBacklog: true,
+  stayConnectedOnEnd: true
+};
+var MEDIA_DEVICES = new Set([
+  "microphoneId",
+  "cameraId",
+  "cameraEnabled",
+  "cameraFacing"
+]);
+function warnUnknown(options) {
+  for (const name in options) {
+    if (Object.hasOwn(KNOWN2, name))
+      continue;
+    const hint = MEDIA_DEVICES.has(name) ? ` It belongs under mediaDevices: { ${name} }.` : "";
+    console.warn(`Nuance SDK: unknown option "${name}" is ignored.${hint}`);
+  }
+}
+function createNuanceConversation(options = {}) {
+  warnUnknown(options);
+  return new NuanceConversation(options);
+}
 export {
   createNuanceConversation,
   PolicyCurfewError,