@runwayml/avatars 0.16.0-beta.0

package/dist/index.cjs

@@ -0,0 +1,928 @@
+'use strict';
+
+var livekitClient = require('livekit-client');
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/error.ts
+var AvatarError = class extends Error {
+  constructor(code, message, cause) {
+    super(message);
+    __publicField(this, "code");
+    __publicField(this, "cause");
+    this.name = "AvatarError";
+    this.code = code;
+    this.cause = cause;
+  }
+};
+function toAvatarError(code, fallbackMessage, err) {
+  if (err instanceof AvatarError) return err;
+  const cause = err instanceof Error ? err : void 0;
+  const message = cause?.message ?? fallbackMessage;
+  return new AvatarError(code, message, cause);
+}
+
+// src/api/config.ts
+var DEFAULT_BASE_URL = "https://api.dev.runwayml.com";
+
+// src/api/consume.ts
+async function consumeSession(options) {
+  const { sessionId, sessionKey, baseUrl = DEFAULT_BASE_URL } = options;
+  const url = `${baseUrl}/v1/realtime_sessions/${sessionId}/consume`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${sessionKey}`
+    }
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new AvatarError(
+      "CONSUME_FAILED",
+      `Failed to consume session: ${response.status} ${errorText}`
+    );
+  }
+  return response.json();
+}
+
+// src/utils/flatDeltaAccumulator.ts
+var FlatDeltaAccumulator = class {
+  constructor() {
+    __publicField(this, "turns", /* @__PURE__ */ new Map());
+    __publicField(this, "finalized", /* @__PURE__ */ new Set());
+  }
+  ingest(delta, participantIdentity) {
+    const id = `runway-transcription-${delta.role}-${delta.turn}`;
+    const prev = this.turns.get(id);
+    const text = (prev?.text ?? "") + delta.textDelta;
+    const identity = prev?.participantIdentity ?? participantIdentity;
+    this.turns.set(id, { text, participantIdentity: identity });
+    const prefix = `runway-transcription-${delta.role}-`;
+    const finalized = [];
+    for (const [key, turn] of this.turns) {
+      if (key === id || !key.startsWith(prefix)) continue;
+      if (this.finalized.has(key)) continue;
+      this.finalized.add(key);
+      finalized.push({
+        id: key,
+        text: turn.text,
+        participantIdentity: turn.participantIdentity
+      });
+    }
+    return {
+      finalized,
+      active: { id, text, participantIdentity: identity }
+    };
+  }
+  reset() {
+    this.turns.clear();
+    this.finalized.clear();
+  }
+};
+
+// src/utils/parseClientEvent.ts
+function isAckMessage(args) {
+  return "status" in args && args.status === "event_sent";
+}
+function parseClientEvent(payload) {
+  try {
+    const message = JSON.parse(new TextDecoder().decode(payload));
+    if (message?.type === "client_event" && typeof message.tool === "string" && message.args != null && typeof message.args === "object" && !isAckMessage(message.args)) {
+      return message;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+// src/utils/parseTranscription.ts
+function tryDecodeJSON(payload) {
+  try {
+    const text = new TextDecoder().decode(payload).trim();
+    if (!text.startsWith("{")) return null;
+    const parsed = JSON.parse(text);
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function tryParseSegmentArray(root, participant) {
+  const type = root.type;
+  const typeAllowed = type === void 0 || type === "transcription" || type === "transcript" || type === "voice_transcript";
+  if (!typeAllowed) return null;
+  let segments = root.segments;
+  if (!Array.isArray(segments) && root.data && typeof root.data === "object") {
+    segments = root.data.segments;
+  }
+  if (!Array.isArray(segments)) return null;
+  const identity = participant?.identity ?? "unknown";
+  const out = [];
+  for (const item of segments) {
+    if (!item || typeof item !== "object") continue;
+    const seg = item;
+    if (typeof seg.id !== "string" || typeof seg.text !== "string") continue;
+    out.push({
+      id: seg.id,
+      text: seg.text,
+      final: typeof seg.final === "boolean" ? seg.final : true,
+      participantIdentity: typeof seg.participantIdentity === "string" ? seg.participantIdentity : identity
+    });
+  }
+  return out.length > 0 ? out : null;
+}
+function tryParseFlatDelta(root) {
+  if (root.type !== "transcription") return null;
+  if (typeof root.text !== "string") return null;
+  return {
+    role: typeof root.role === "string" ? root.role : "assistant",
+    turn: typeof root.turn === "number" ? root.turn : 0,
+    textDelta: root.text
+  };
+}
+
+// src/emitter.ts
+var Emitter = class {
+  constructor() {
+    __publicField(this, "listeners", /* @__PURE__ */ new Map());
+  }
+  on(event, handler) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(event, set);
+    }
+    set.add(handler);
+    return this;
+  }
+  once(event, handler) {
+    const wrapper = ((...args) => {
+      this.off(event, wrapper);
+      handler(...args);
+    });
+    return this.on(event, wrapper);
+  }
+  off(event, handler) {
+    this.listeners.get(event)?.delete(handler);
+    return this;
+  }
+  emit(event, ...args) {
+    const set = this.listeners.get(event);
+    if (!set) return;
+    for (const handler of set) {
+      try {
+        handler(...args);
+      } catch (err) {
+        console.error(`[@runwayml/avatars] Error in ${String(event)} handler:`, err);
+      }
+    }
+  }
+  removeAllListeners(event) {
+    if (event) {
+      this.listeners.delete(event);
+    } else {
+      this.listeners.clear();
+    }
+    return this;
+  }
+};
+
+// src/transcript-accumulator.ts
+var DEFAULT_BUFFER_SIZE = 100;
+var TranscriptAccumulator = class extends Emitter {
+  constructor(options) {
+    super();
+    __publicField(this, "map", /* @__PURE__ */ new Map());
+    __publicField(this, "flatAcc", new FlatDeltaAccumulator());
+    __publicField(this, "interim");
+    __publicField(this, "bufferSize");
+    __publicField(this, "snapshot", []);
+    this.interim = options?.interim ?? false;
+    this.bufferSize = options?.bufferSize ?? DEFAULT_BUFFER_SIZE;
+  }
+  get entries() {
+    return this.snapshot;
+  }
+  /**
+   * Ingest a native transcription segment (from `RoomEvent.TranscriptionReceived`).
+   */
+  ingestNative(segments, participantIdentity) {
+    let changed = false;
+    for (const segment of segments) {
+      if (!this.interim && !segment.final) continue;
+      this.map.set(segment.id, {
+        id: segment.id,
+        text: segment.text,
+        final: segment.final,
+        participantIdentity,
+        channel: "native"
+      });
+      changed = true;
+    }
+    if (changed) this.flush();
+  }
+  /**
+   * Ingest a raw data-channel payload (from `RoomEvent.DataReceived`).
+   * Handles both segment arrays and flat deltas.
+   */
+  ingestDataChannel(payload, participantIdentity) {
+    const json = tryDecodeJSON(payload);
+    if (!json) return;
+    const segments = tryParseSegmentArray(json, {
+      identity: participantIdentity
+    });
+    if (segments) {
+      let changed2 = false;
+      for (const entry of segments) {
+        if (!this.interim && !entry.final) continue;
+        this.map.set(entry.id, { ...entry, channel: "custom" });
+        changed2 = true;
+      }
+      if (changed2) this.flush();
+      return;
+    }
+    const delta = tryParseFlatDelta(json);
+    if (!delta) return;
+    const { finalized, active } = this.flatAcc.ingest(
+      delta,
+      participantIdentity
+    );
+    let changed = false;
+    for (const turn of finalized) {
+      this.map.set(turn.id, { ...turn, final: true, channel: "custom" });
+      changed = true;
+    }
+    if (this.interim) {
+      this.map.set(active.id, { ...active, final: false, channel: "custom" });
+      changed = true;
+    }
+    if (changed) this.flush();
+  }
+  dispose() {
+    this.map.clear();
+    this.flatAcc.reset();
+    this.snapshot = [];
+    this.removeAllListeners();
+  }
+  flush() {
+    const values = Array.from(this.map.values());
+    this.snapshot = values.length > this.bufferSize ? values.slice(-this.bufferSize) : values;
+    this.emit("update", this.snapshot);
+  }
+};
+
+// src/types.ts
+var AvatarEvent = {
+  StateChanged: "stateChanged",
+  Transcript: "transcript",
+  ClientEvent: "clientEvent",
+  Error: "error",
+  AvatarVideoReady: "avatarVideoReady",
+  AvatarAudioReady: "avatarAudioReady",
+  ScreenShareReady: "screenShareReady",
+  LocalVideoReady: "localVideoReady",
+  MediaChanged: "mediaChanged",
+  UserSpeechStarted: "userSpeechStarted",
+  UserSpeechEnded: "userSpeechEnded",
+  AvatarSpeechStarted: "avatarSpeechStarted",
+  AvatarSpeechEnded: "avatarSpeechEnded",
+  ConnectionQualityChanged: "connectionQualityChanged",
+  MicPermissionChanged: "micPermissionChanged",
+  ActiveSpeakersChanged: "activeSpeakersChanged"
+};
+
+// src/client.ts
+function toLKQuality(q) {
+  switch (q) {
+    case livekitClient.ConnectionQuality.Excellent:
+      return "excellent";
+    case livekitClient.ConnectionQuality.Good:
+      return "good";
+    case livekitClient.ConnectionQuality.Poor:
+      return "poor";
+    case livekitClient.ConnectionQuality.Lost:
+      return "lost";
+    default:
+      return "unknown";
+  }
+}
+function toSessionState(cs) {
+  switch (cs) {
+    case livekitClient.ConnectionState.Connecting:
+      return "connecting";
+    case livekitClient.ConnectionState.Connected:
+      return "active";
+    case livekitClient.ConnectionState.Reconnecting:
+      return "reconnecting";
+    case livekitClient.ConnectionState.Disconnected:
+      return "ended";
+    default:
+      return "ended";
+  }
+}
+var AvatarSession = class extends Emitter {
+  constructor(sessionId) {
+    super();
+    __publicField(this, "room", null);
+    __publicField(this, "_sessionId");
+    __publicField(this, "_state", "idle");
+    __publicField(this, "_error", null);
+    __publicField(this, "_micEnabled", false);
+    __publicField(this, "_cameraEnabled", false);
+    __publicField(this, "_screenShareActive", false);
+    __publicField(this, "attachedVideoElement", null);
+    __publicField(this, "attachedAudioElement", null);
+    __publicField(this, "avatarVideoTrack", null);
+    __publicField(this, "avatarAudioTrack", null);
+    __publicField(this, "_localVideoTrack", null);
+    __publicField(this, "autoAudioElement", null);
+    __publicField(this, "flatDeltaAcc", new FlatDeltaAccumulator());
+    __publicField(this, "_userSpeaking", false);
+    __publicField(this, "_avatarSpeaking", false);
+    __publicField(this, "_connectedAt", null);
+    __publicField(this, "mic");
+    __publicField(this, "camera");
+    __publicField(this, "screenShare");
+    this._sessionId = sessionId;
+    const self = this;
+    this.mic = {
+      get isEnabled() {
+        return self._micEnabled;
+      },
+      enable: () => this.setMic(true),
+      disable: () => this.setMic(false),
+      toggle: () => this.setMic(!this._micEnabled),
+      setDevice: (deviceId) => this.switchDevice("audioinput", deviceId)
+    };
+    this.camera = {
+      get isEnabled() {
+        return self._cameraEnabled;
+      },
+      enable: () => this.setCamera(true),
+      disable: () => this.setCamera(false),
+      toggle: () => this.setCamera(!this._cameraEnabled),
+      setDevice: (deviceId) => this.switchDevice("videoinput", deviceId)
+    };
+    this.screenShare = {
+      get isActive() {
+        return self._screenShareActive;
+      },
+      start: () => this.setScreenShare(true),
+      stop: () => this.setScreenShare(false),
+      toggle: () => this.setScreenShare(!this._screenShareActive)
+    };
+  }
+  get state() {
+    return this._state;
+  }
+  get sessionId() {
+    return this._sessionId;
+  }
+  get error() {
+    return this._error;
+  }
+  get localVideoTrack() {
+    return this._localVideoTrack;
+  }
+  get duration() {
+    if (!this._connectedAt) return 0;
+    return Date.now() - this._connectedAt;
+  }
+  waitFor(event) {
+    return new Promise((resolve) => {
+      this.once(event, ((...args) => {
+        resolve(args[0]);
+      }));
+    });
+  }
+  streamTo(element) {
+    this.attachedVideoElement = element;
+    if (this.avatarVideoTrack) {
+      element.srcObject = new MediaStream([this.avatarVideoTrack]);
+      element.play().catch(() => {
+      });
+    }
+  }
+  stopStreaming() {
+    if (this.attachedVideoElement) {
+      this.attachedVideoElement.srcObject = null;
+    }
+    this.attachedVideoElement = null;
+  }
+  attachAudio(element) {
+    this.attachedAudioElement = element;
+    if (this.avatarAudioTrack) {
+      element.srcObject = new MediaStream([this.avatarAudioTrack]);
+      element.play().catch(() => {
+      });
+    }
+  }
+  detachAudio() {
+    if (this.attachedAudioElement) {
+      this.attachedAudioElement.srcObject = null;
+    }
+    this.attachedAudioElement = null;
+  }
+  async end() {
+    if (!this.room) return;
+    this.setState("ending");
+    try {
+      const encoder = new TextEncoder();
+      const data = encoder.encode(JSON.stringify({ type: "END_CALL" }));
+      await this.room.localParticipant.publishData(data, { reliable: true });
+    } catch {
+    }
+    this.cleanup();
+  }
+  transcript(options) {
+    const acc = new TranscriptAccumulator(options);
+    const handleTranscript = (entry) => {
+      acc.ingestNative(
+        [{ id: entry.id, text: entry.text, final: entry.final }],
+        entry.participantIdentity
+      );
+    };
+    this.on(AvatarEvent.Transcript, handleTranscript);
+    const originalDispose = acc.dispose.bind(acc);
+    acc.dispose = () => {
+      this.off(AvatarEvent.Transcript, handleTranscript);
+      originalDispose();
+    };
+    return acc;
+  }
+  onClientEvent(toolOrName, handler) {
+    const name = typeof toolOrName === "string" ? toolOrName : toolOrName.name;
+    const wrappedHandler = (event) => {
+      if (event.tool === name) {
+        handler(event.args);
+      }
+    };
+    this.on(AvatarEvent.ClientEvent, wrappedHandler);
+    return () => this.off(AvatarEvent.ClientEvent, wrappedHandler);
+  }
+  /** @internal Called by `streamTo` and `connect` entry points. */
+  async _connect(serverUrl, token, options) {
+    this.setState("connecting");
+    const room = new livekitClient.Room({
+      adaptiveStream: false,
+      dynacast: false
+    });
+    try {
+      this.room = room;
+      this.bindRoomEvents(room);
+      await room.connect(serverUrl, token, { autoSubscribe: true });
+      await this.enableInitialMedia(room, options);
+    } catch (err) {
+      room.removeAllListeners();
+      room.disconnect().catch(() => {
+      });
+      this.room = null;
+      const error = toAvatarError("CONNECTION_FAILED", "Failed to connect to session", err);
+      this.setError(error);
+      throw error;
+    }
+  }
+  async publishScreenShare(stream) {
+    if (!this.room) return;
+    const videoTrack = stream.getVideoTracks()[0];
+    if (videoTrack) {
+      await this.room.localParticipant.publishTrack(videoTrack, {
+        source: livekitClient.Track.Source.ScreenShare
+      });
+    }
+    const audioTrack = stream.getAudioTracks()[0];
+    if (audioTrack) {
+      await this.room.localParticipant.publishTrack(audioTrack, {
+        source: livekitClient.Track.Source.ScreenShareAudio
+      });
+    }
+  }
+  bindRoomEvents(room) {
+    room.on(livekitClient.RoomEvent.ConnectionStateChanged, (state) => {
+      this.setState(toSessionState(state));
+    });
+    room.on(livekitClient.RoomEvent.Disconnected, () => {
+      this.setState("ended");
+    });
+    room.on(livekitClient.RoomEvent.Reconnected, () => {
+      this.reattachTracks();
+    });
+    room.on(
+      livekitClient.RoomEvent.TrackSubscribed,
+      (track, publication) => {
+        if (track.kind === "video" && publication.source === livekitClient.Track.Source.Camera) {
+          const mediaTrack = track.mediaStreamTrack;
+          this.avatarVideoTrack = mediaTrack;
+          this.emit(AvatarEvent.AvatarVideoReady, mediaTrack);
+          this.syncVideoElement(mediaTrack);
+        }
+        if (track.kind === "audio" && publication.source === livekitClient.Track.Source.Microphone) {
+          const mediaTrack = track.mediaStreamTrack;
+          this.avatarAudioTrack = mediaTrack;
+          this.emit(AvatarEvent.AvatarAudioReady, mediaTrack);
+          if (this.attachedAudioElement) {
+            this.attachedAudioElement.srcObject = new MediaStream([mediaTrack]);
+            this.attachedAudioElement.play().catch(() => {
+            });
+          } else {
+            this.autoPlayAudio(mediaTrack);
+          }
+        }
+        if (track.kind === "video" && publication.source === livekitClient.Track.Source.ScreenShare) {
+          this.emit(AvatarEvent.ScreenShareReady, track.mediaStreamTrack);
+        }
+      }
+    );
+    room.on(livekitClient.RoomEvent.TrackUnsubscribed, (_track, publication) => {
+      if (publication.source === livekitClient.Track.Source.Camera) {
+        this.avatarVideoTrack = null;
+      }
+      if (publication.source === livekitClient.Track.Source.Microphone) {
+        this.avatarAudioTrack = null;
+      }
+    });
+    room.on(
+      livekitClient.RoomEvent.DataReceived,
+      (payload, participant) => {
+        const event = parseClientEvent(payload);
+        if (event) {
+          this.emit(AvatarEvent.ClientEvent, event);
+          return;
+        }
+        const identity = participant?.identity ?? "unknown";
+        const json = tryDecodeJSON(payload);
+        if (!json) return;
+        const segments = tryParseSegmentArray(json, { identity });
+        if (segments) {
+          for (const entry of segments) {
+            this.emit(AvatarEvent.Transcript, { ...entry, channel: "custom" });
+          }
+          return;
+        }
+        const delta = tryParseFlatDelta(json);
+        if (delta) {
+          const { finalized, active } = this.flatDeltaAcc.ingest(
+            delta,
+            identity
+          );
+          for (const turn of finalized) {
+            this.emit(AvatarEvent.Transcript, {
+              ...turn,
+              final: true,
+              channel: "custom"
+            });
+          }
+          this.emit(AvatarEvent.Transcript, {
+            ...active,
+            final: false,
+            channel: "custom"
+          });
+        }
+      }
+    );
+    room.on(
+      livekitClient.RoomEvent.TranscriptionReceived,
+      (segments, participant) => {
+        const identity = participant?.identity ?? "unknown";
+        for (const segment of segments) {
+          this.emit(AvatarEvent.Transcript, {
+            id: segment.id,
+            text: segment.text,
+            final: segment.final,
+            participantIdentity: identity,
+            channel: "native"
+          });
+        }
+      }
+    );
+    room.on(livekitClient.RoomEvent.MediaDevicesError, (error) => {
+      this.emit(AvatarEvent.Error, error);
+    });
+    room.on(livekitClient.RoomEvent.ActiveSpeakersChanged, (speakers) => {
+      const localIdentity = room.localParticipant.identity;
+      const localSpeaking = speakers.some((p) => p.identity === localIdentity);
+      const remoteSpeaking = speakers.some((p) => p.identity !== localIdentity);
+      if (localSpeaking && !this._userSpeaking) {
+        this._userSpeaking = true;
+        this.emit(AvatarEvent.UserSpeechStarted);
+      } else if (!localSpeaking && this._userSpeaking) {
+        this._userSpeaking = false;
+        this.emit(AvatarEvent.UserSpeechEnded);
+      }
+      if (remoteSpeaking && !this._avatarSpeaking) {
+        this._avatarSpeaking = true;
+        this.emit(AvatarEvent.AvatarSpeechStarted);
+      } else if (!remoteSpeaking && this._avatarSpeaking) {
+        this._avatarSpeaking = false;
+        this.emit(AvatarEvent.AvatarSpeechEnded);
+      }
+      const active = [];
+      if (localSpeaking) active.push("user");
+      if (remoteSpeaking) active.push("avatar");
+      this.emit(AvatarEvent.ActiveSpeakersChanged, active);
+    });
+    room.on(
+      livekitClient.RoomEvent.ConnectionQualityChanged,
+      (quality, _participant) => {
+        this.emit(AvatarEvent.ConnectionQualityChanged, toLKQuality(quality));
+      }
+    );
+  }
+  reattachTracks() {
+    if (this.avatarVideoTrack) {
+      this.syncVideoElement(this.avatarVideoTrack);
+    }
+    if (this.avatarAudioTrack) {
+      if (this.attachedAudioElement) {
+        this.attachedAudioElement.srcObject = new MediaStream([this.avatarAudioTrack]);
+        this.attachedAudioElement.play().catch(() => {
+        });
+      } else {
+        this.autoPlayAudio(this.avatarAudioTrack);
+      }
+    }
+  }
+  syncVideoElement(track) {
+    if (this.attachedVideoElement) {
+      this.attachedVideoElement.srcObject = new MediaStream([track]);
+      this.attachedVideoElement.play().catch(() => {
+      });
+    }
+  }
+  async enableInitialMedia(room, options) {
+    if (typeof navigator === "undefined" || !navigator.mediaDevices?.getUserMedia) {
+      console.warn(
+        "[@runwayml/avatars] mediaDevices not available (requires secure context). Skipping mic/camera."
+      );
+      return;
+    }
+    const { audio = true, video = true } = options;
+    if (audio) {
+      this.emit(AvatarEvent.MicPermissionChanged, "pending");
+      try {
+        await room.localParticipant.setMicrophoneEnabled(true);
+        this._micEnabled = true;
+        this.emit(AvatarEvent.MicPermissionChanged, "granted");
+      } catch (err) {
+        this.emit(AvatarEvent.MicPermissionChanged, "denied");
+        this.emit(AvatarEvent.Error, toAvatarError("MEDIA_PERMISSION_DENIED", "Microphone access denied", err));
+      }
+    }
+    if (video) {
+      try {
+        await room.localParticipant.setCameraEnabled(true);
+        this._cameraEnabled = true;
+        this.emitLocalVideoTrack(room);
+      } catch (err) {
+        this.emit(AvatarEvent.Error, toAvatarError("MEDIA_PERMISSION_DENIED", "Camera access denied", err));
+      }
+    }
+    this.emit(AvatarEvent.MediaChanged);
+  }
+  async setMic(enabled) {
+    if (!this.room || !navigator.mediaDevices?.getUserMedia) return;
+    try {
+      await this.room.localParticipant.setMicrophoneEnabled(enabled);
+      this._micEnabled = enabled;
+      this.emit(AvatarEvent.MediaChanged);
+    } catch (err) {
+      this.emit(AvatarEvent.Error, toAvatarError("MEDIA_DEVICE_ERROR", "Failed to toggle microphone", err));
+    }
+  }
+  async setCamera(enabled) {
+    if (!this.room || !navigator.mediaDevices?.getUserMedia) return;
+    try {
+      await this.room.localParticipant.setCameraEnabled(enabled);
+      this._cameraEnabled = enabled;
+      if (enabled) {
+        this.emitLocalVideoTrack(this.room);
+      } else {
+        this._localVideoTrack = null;
+      }
+      this.emit(AvatarEvent.MediaChanged);
+    } catch (err) {
+      this.emit(AvatarEvent.Error, toAvatarError("MEDIA_DEVICE_ERROR", "Failed to toggle camera", err));
+    }
+  }
+  emitLocalVideoTrack(room) {
+    const pub = room.localParticipant.getTrackPublication(livekitClient.Track.Source.Camera);
+    const mediaTrack = pub?.track?.mediaStreamTrack;
+    if (mediaTrack) {
+      this._localVideoTrack = mediaTrack;
+      this.emit(AvatarEvent.LocalVideoReady, mediaTrack);
+      return;
+    }
+    const onPublished = () => {
+      const retryPub = room.localParticipant.getTrackPublication(livekitClient.Track.Source.Camera);
+      const retryTrack = retryPub?.track?.mediaStreamTrack;
+      if (retryTrack) {
+        this._localVideoTrack = retryTrack;
+        this.emit(AvatarEvent.LocalVideoReady, retryTrack);
+        room.off(livekitClient.RoomEvent.LocalTrackPublished, onPublished);
+      }
+    };
+    room.on(livekitClient.RoomEvent.LocalTrackPublished, onPublished);
+  }
+  async setScreenShare(active) {
+    if (!this.room || !navigator.mediaDevices?.getDisplayMedia) return;
+    try {
+      await this.room.localParticipant.setScreenShareEnabled(active);
+      this._screenShareActive = active;
+      this.emit(AvatarEvent.MediaChanged);
+    } catch (err) {
+      this.emit(AvatarEvent.Error, toAvatarError("SCREEN_SHARE_FAILED", "Failed to toggle screen share", err));
+    }
+  }
+  async switchDevice(kind, deviceId) {
+    if (!this.room) return;
+    try {
+      await this.room.switchActiveDevice(kind, deviceId);
+      this.emit(AvatarEvent.MediaChanged);
+    } catch (err) {
+      this.emit(AvatarEvent.Error, toAvatarError("MEDIA_DEVICE_ERROR", `Failed to switch ${kind}`, err));
+    }
+  }
+  autoPlayAudio(track) {
+    if (!this.autoAudioElement) {
+      this.autoAudioElement = document.createElement("audio");
+      this.autoAudioElement.autoplay = true;
+    }
+    this.autoAudioElement.srcObject = new MediaStream([track]);
+    this.autoAudioElement.play().catch(() => {
+    });
+  }
+  setError(error) {
+    this._error = error;
+    this.setState("error");
+    this.emit(AvatarEvent.Error, error);
+  }
+  setState(state) {
+    if (this._state === state) return;
+    this._state = state;
+    if (state === "active" && !this._connectedAt) {
+      this._connectedAt = Date.now();
+    }
+    this.emit(AvatarEvent.StateChanged, state);
+  }
+  cleanup() {
+    this.stopStreaming();
+    this.detachAudio();
+    if (this.autoAudioElement) {
+      this.autoAudioElement.srcObject = null;
+      this.autoAudioElement.remove();
+      this.autoAudioElement = null;
+    }
+    this.avatarVideoTrack = null;
+    this.avatarAudioTrack = null;
+    this._localVideoTrack = null;
+    if (this.room) {
+      this.room.removeAllListeners();
+      this.room.disconnect();
+      this.room = null;
+    }
+    this._micEnabled = false;
+    this._cameraEnabled = false;
+    this._screenShareActive = false;
+    this._userSpeaking = false;
+    this._avatarSpeaking = false;
+    this._connectedAt = null;
+    this.flatDeltaAcc.reset();
+    this.setState("ended");
+  }
+};
+async function resolveCredentials(options) {
+  const { url: serverUrl, token } = await consumeSession({
+    sessionId: options.sessionId,
+    sessionKey: options.sessionKey,
+    baseUrl: options.baseUrl
+  });
+  return { serverUrl, token };
+}
+async function streamTo(options) {
+  const { credentials, target, audio, video } = options;
+  const { sessionId, sessionKey, baseUrl } = credentials;
+  const { serverUrl, token } = await resolveCredentials({ sessionId, sessionKey, baseUrl });
+  const session = new AvatarSession(sessionId);
+  session.streamTo(target);
+  await session._connect(serverUrl, token, { audio, video });
+  return session;
+}
+async function connect(options) {
+  const { credentials, audio, video } = options;
+  const { sessionId, sessionKey, baseUrl } = credentials;
+  const { serverUrl, token } = await resolveCredentials({ sessionId, sessionKey, baseUrl });
+  const session = new AvatarSession(sessionId);
+  await session._connect(serverUrl, token, { audio, video });
+  return session;
+}
+
+// src/tools.ts
+var toolSchemas = /* @__PURE__ */ new WeakMap();
+var asyncSchemaWarned = /* @__PURE__ */ new WeakSet();
+function getClientToolSchema(tool) {
+  return toolSchemas.get(tool);
+}
+function validateClientToolArgs(tool, args) {
+  const schema = toolSchemas.get(tool);
+  if (!schema) {
+    return args;
+  }
+  const result = schema["~standard"].validate(args);
+  if (result instanceof Promise) {
+    if (!asyncSchemaWarned.has(tool) && typeof console !== "undefined") {
+      asyncSchemaWarned.add(tool);
+      console.warn(
+        `[@runwayml/avatars-react] Async Standard Schema validation is not supported for client events (tool "${tool.name}"); subsequent events for this tool will be dropped silently.`
+      );
+    }
+    return null;
+  }
+  return isSuccess(result) ? result.value : null;
+}
+function isSuccess(result) {
+  return result.issues == null;
+}
+function clientTool(name, config) {
+  const tool = {
+    type: "client_event",
+    name,
+    description: config.description
+  };
+  if ("schema" in config) {
+    toolSchemas.set(tool, config.schema);
+  }
+  return tool;
+}
+
+// src/api/page-actions.ts
+var clickTool = clientTool("click", {
+  description: "Clicks an interactive element on the page by its target ID",
+  args: {}
+});
+var scrollToTool = clientTool("scroll_to", {
+  description: "Scrolls the page to an element by its target ID",
+  args: {}
+});
+var highlightTool = clientTool("highlight", {
+  description: "Highlights an element on the page to draw attention to it by its target ID",
+  args: {}
+});
+var pageActionTools = [
+  {
+    ...clickTool,
+    parameters: [
+      {
+        name: "target",
+        type: "string",
+        description: "The ID or data-avatar-target value of the element to click"
+      }
+    ]
+  },
+  {
+    ...scrollToTool,
+    parameters: [
+      {
+        name: "target",
+        type: "string",
+        description: "The ID or data-avatar-target value of the element to scroll to"
+      }
+    ]
+  },
+  {
+    ...highlightTool,
+    parameters: [
+      {
+        name: "target",
+        type: "string",
+        description: "The ID or data-avatar-target value of the element to highlight"
+      },
+      {
+        name: "duration",
+        type: "number",
+        description: "How long to highlight in milliseconds. Defaults to 2000"
+      }
+    ]
+  }
+];
+
+exports.AvatarError = AvatarError;
+exports.AvatarEvent = AvatarEvent;
+exports.AvatarSession = AvatarSession;
+exports.FlatDeltaAccumulator = FlatDeltaAccumulator;
+exports.TranscriptAccumulator = TranscriptAccumulator;
+exports.clientTool = clientTool;
+exports.connect = connect;
+exports.consumeSession = consumeSession;
+exports.getClientToolSchema = getClientToolSchema;
+exports.pageActionTools = pageActionTools;
+exports.parseClientEvent = parseClientEvent;
+exports.streamTo = streamTo;
+exports.tryDecodeJSON = tryDecodeJSON;
+exports.tryParseFlatDelta = tryParseFlatDelta;
+exports.tryParseSegmentArray = tryParseSegmentArray;
+exports.validateClientToolArgs = validateClientToolArgs;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map