@d-id/client-sdk 2.0.5 → 2.0.6-staging.397

package/dist/livekit-manager-DlYh2os8.js

@@ -0,0 +1,484 @@
+import { c as Be, C as J, S as f, a as Je, b as Qe, A as m, d as We, l as pe, e as qe, t as Ge, f as A, g as U, h as He, D as ge, i as Xe, j as b, n as Ze } from "./index-BT-_g68F.js";
+function Ye() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone ?? "";
+  } catch {
+    return "";
+  }
+}
+function en() {
+  if (typeof navigator > "u")
+    return "";
+  const l = navigator.userAgent ?? "", C = (navigator.platform ?? "").toLowerCase();
+  let u = "Unknown";
+  /android/i.test(l) ? u = "Android" : /iphone|ipad|ipod/i.test(l) ? u = "iOS" : C.includes("win") ? u = "Windows" : C.includes("mac") ? u = "Mac OS X" : C.includes("linux") && (u = "Linux");
+  const i = u === "Android" || u === "iOS" || /Mobi/i.test(l);
+  return `${u}, ${i ? "Mobile" : "Desktop"}`;
+}
+function nn() {
+  const l = {}, C = Ye();
+  C && (l.timezone = C);
+  const u = en();
+  return u && (l.device = u), l;
+}
+function tn(l, C, u, i) {
+  const k = Be(l, `${C}/v2/agents/${u}`, i);
+  return {
+    async createStream(g) {
+      return k.post("/sessions", g);
+    }
+  };
+}
+const on = {
+  [f.ChatAnswer]: J.Answer,
+  [f.ChatPartial]: J.Partial
+}, he = 2e4, rn = [];
+async function an() {
+  try {
+    return await import("./index-BT-_g68F.js").then((l) => l.F);
+  } catch {
+    throw new Error(
+      "LiveKit client is required for this streaming manager. Please install it using: npm install livekit-client"
+    );
+  }
+}
+const cn = {
+  excellent: U.Strong,
+  good: U.Strong,
+  poor: U.Weak,
+  lost: U.Unknown,
+  unknown: U.Unknown
+}, O = (l = "Stream Error") => new qe(l);
+function me(l, C, u) {
+  var i, k;
+  throw C("Failed to connect to LiveKit room:", l), (i = u.onConnectionStateChange) == null || i.call(u, A.Fail, "internal:init-error"), (k = u.onError) == null || k.call(u, l, { sessionId: "" }), l;
+}
+async function un(l, C, u) {
+  var se;
+  const i = Je(u.debug || !1, "LiveKitStreamingManager"), { Room: k, RoomEvent: g, ConnectionState: I, Track: Y } = await an(), { callbacks: n, auth: Ce, baseURL: Se, analytics: ee } = u;
+  let a = null, E = !1;
+  const ne = Qe.Fluent;
+  let L = null;
+  const P = { isPublishing: !1, publication: null }, Q = { isPublishing: !1, publication: null };
+  let h = null, S = null, j = null, K = !1;
+  a = new k({
+    adaptiveStream: !1,
+    // Must be false to use mediaStreamTrack directly
+    dynacast: !0
+  });
+  let R = null, M = m.Idle, W = !0;
+  const y = /* @__PURE__ */ new Map();
+  let x = null;
+  const Te = tn(Ce, Se || We, l, n.onError);
+  let v, _, $, te = !0;
+  try {
+    const e = await Te.createStream({
+      transport: C.transport,
+      chat_persist: C.chat_persist ?? !0,
+      verbose: u.verbose ?? !1
+    }), { id: t, session_token: o, session_url: r, interrupt_enabled: c } = e;
+    (se = n.onStreamCreated) == null || se.call(n, { session_id: t, stream_id: t, agent_id: l }), v = t, _ = o, $ = r, te = c ?? !0, await a.prepareConnection($, _);
+  } catch (e) {
+    me(e, i, n);
+  }
+  if (!$ || !_ || !v)
+    return Promise.reject(new Error("Failed to initialize LiveKit stream"));
+  a.on(g.ConnectionStateChanged, we).on(g.ConnectionQualityChanged, Ae).on(g.ParticipantConnected, Ee).on(g.ParticipantDisconnected, Re).on(g.TrackSubscribed, Le).on(g.TrackUnsubscribed, Pe).on(g.DataReceived, Ke).on(g.MediaDevicesError, xe).on(g.TranscriptionReceived, ye).on(g.EncryptionError, Ve).on(g.TrackSubscriptionFailed, Fe);
+  function ye(e, t) {
+    t != null && t.isLocal && pe.update();
+  }
+  async function ve() {
+    const e = nn();
+    if (!(!a || Object.keys(e).length === 0))
+      try {
+        await a.localParticipant.setAttributes(e);
+      } catch (t) {
+        i("Failed to set user context attributes", t);
+      }
+  }
+  try {
+    await a.connect($, _), i("LiveKit room joined successfully"), ve(), R = setTimeout(() => {
+      var t;
+      i(
+        `Track subscription timeout - no track subscribed within ${he / 1e3} seconds after connect`
+      ), R = null;
+      const e = O("Track subscription timeout");
+      ee.track("connectivity-error", {
+        error: Ge(e),
+        sessionId: v
+      }), (t = n.onError) == null || t.call(n, e, { sessionId: v }), Z("internal:track-subscription-timeout");
+    }, he);
+  } catch (e) {
+    me(e, i, n);
+  }
+  ee.enrich({
+    "stream-type": ne
+  });
+  function we(e) {
+    var t, o, r, c;
+    switch (i("Connection state changed:", e), e) {
+      case I.Connecting:
+        i("CALLBACK: onConnectionStateChange(Connecting)"), (t = n.onConnectionStateChange) == null || t.call(n, A.Connecting, "livekit:connecting");
+        break;
+      case I.Connected:
+        i("LiveKit room connected successfully"), E = !0;
+        break;
+      case I.Disconnected:
+        i("LiveKit room disconnected"), E = !1, K = !1, P.publication = null, Q.publication = null, (o = n.onConnectionStateChange) == null || o.call(n, A.Disconnected, "livekit:disconnected");
+        break;
+      case I.Reconnecting:
+        i("LiveKit room reconnecting..."), (r = n.onConnectionStateChange) == null || r.call(n, A.Connecting, "livekit:reconnecting");
+        break;
+      case I.SignalReconnecting:
+        i("LiveKit room signal reconnecting..."), (c = n.onConnectionStateChange) == null || c.call(n, A.Connecting, "livekit:signal-reconnecting");
+        break;
+    }
+  }
+  function Ae(e, t) {
+    var o;
+    i("Connection quality:", e), t != null && t.isLocal && ((o = n.onConnectivityStateChange) == null || o.call(n, cn[e]));
+  }
+  function Ee(e) {
+    i("Participant connected:", e.identity);
+  }
+  function Re(e) {
+    i("Participant disconnected:", e.identity), Z("livekit:participant-disconnected");
+  }
+  function be() {
+    var e;
+    j !== b.Start && (i("CALLBACK: onVideoStateChange(Start)"), j = b.Start, (e = n.onVideoStateChange) == null || e.call(n, b.Start));
+  }
+  function ie(e) {
+    var t;
+    j !== b.Stop && (i("CALLBACK: onVideoStateChange(Stop)"), j = b.Stop, (t = n.onVideoStateChange) == null || t.call(n, b.Stop, e));
+  }
+  function Le(e, t, o) {
+    var c, d, s;
+    i(`Track subscribed: ${e.kind} from ${o.identity}`);
+    const r = e.mediaStreamTrack;
+    if (!r) {
+      i(`No mediaStreamTrack available for ${e.kind}`);
+      return;
+    }
+    L ? (L.addTrack(r), i(`Added ${e.kind} track to shared MediaStream`)) : (L = new MediaStream([r]), i(`Created shared MediaStream with ${e.kind} track`)), e.kind === "audio" && (S = Xe(
+      () => e.getRTCStatsReport(),
+      ({ sttLatency: p, serviceLatency: T }) => {
+        var ue, de, le;
+        const V = pe.get(!0);
+        let F = 0;
+        if (p) {
+          const fe = ((de = (ue = h == null ? void 0 : h.getReport()) == null ? void 0 : ue.webRTCStats) == null ? void 0 : de.avgRtt) ?? 0;
+          F = fe > 0 ? Math.round(fe * 1e3) : 0;
+        }
+        const D = V > 0 ? V + (p ?? 0) + F : void 0, w = D !== void 0 && T !== void 0 ? D - T : void 0;
+        (le = n.onFirstAudioDetected) == null || le.call(n, { latency: D, networkLatency: w });
+      }
+    )), e.kind === "video" && ((c = n.onStreamReady) == null || c.call(n), i("CALLBACK: onSrcObjectReady"), (d = n.onSrcObjectReady) == null || d.call(n, L), K || (K = !0, i("CALLBACK: onConnectionStateChange(Connected)"), (s = n.onConnectionStateChange) == null || s.call(n, A.Connected, "livekit:track-subscribed")), h = He(
+      () => e.getRTCStatsReport(),
+      () => E,
+      Ze,
+      (p, T) => {
+        i(`Video state change: ${p}`), p === b.Start ? (R && (clearTimeout(R), R = null, i("Track subscription timeout cleared")), be()) : p === b.Stop && ie(T);
+      }
+    ), h.start());
+  }
+  function Pe(e, t, o) {
+    i(`Track unsubscribed: ${e.kind} from ${o.identity}`), e.kind === "audio" && (S == null || S.destroy(), S = null), e.kind === "video" && (ie(h == null ? void 0 : h.getReport()), h == null || h.stop(), h = null);
+  }
+  function oe(e, t) {
+    var r;
+    const o = on[e];
+    o && ((r = n.onMessage) == null || r.call(n, o, { event: o, ...t }));
+  }
+  function q(e, t) {
+    var o, r, c, d;
+    if (e === f.ToolCallStarted) {
+      const s = t;
+      y.set(s.call_id, {
+        call: {
+          callId: s.call_id,
+          name: s.name,
+          executionMode: s.execution_mode === "async" ? "async" : "blocking"
+        },
+        interruptible: s.interruptible === !0,
+        turnId: s.turn_id ?? x
+      }), N(), z(), M = m.ToolActive, (o = n.onAgentActivityStateChange) == null || o.call(n, m.ToolActive), (r = n.onToolEvent) == null || r.call(n, f.ToolCallStarted, s);
+      return;
+    }
+    if (e === f.ToolCallDone) {
+      const s = t;
+      re(s.call_id), (c = n.onToolEvent) == null || c.call(n, f.ToolCallDone, s);
+      return;
+    }
+    if (e === f.ToolCallError) {
+      const s = t;
+      re(s.call_id), (d = n.onToolEvent) == null || d.call(n, f.ToolCallError, s);
+    }
+  }
+  function re(e) {
+    y.delete(e) && (N(), z());
+  }
+  function Me(e) {
+    let t = !1;
+    for (const [o, r] of y)
+      r.call.executionMode === "blocking" && (e !== null && r.turnId !== null && r.turnId !== e || (y.delete(o), t = !0));
+    t && (N(), z());
+  }
+  function N() {
+    var t;
+    const e = ![...y.values()].some(({ call: o }) => o.executionMode === "blocking");
+    e !== W && (W = e, (t = n.onInterruptibleChange) == null || t.call(n, e));
+  }
+  function z() {
+    var e;
+    (e = n.onRunningToolCallsChange) == null || e.call(
+      n,
+      y.size === 0 ? rn : [...y.values()].map(({ call: t }) => t)
+    );
+  }
+  function ke(e, t) {
+    var o, r, c;
+    if (e === f.StreamVideoCreated) {
+      M = m.Talking, (o = n.onAgentActivityStateChange) == null || o.call(n, m.Talking), S == null || S.arm({
+        sttLatency: (r = t == null ? void 0 : t.stt) == null ? void 0 : r.latency,
+        serviceLatency: t == null ? void 0 : t.serviceLatency
+      });
+      return;
+    }
+    if (y.size > 0) {
+      M !== m.ToolActive && (M = m.ToolActive, (c = n.onAgentActivityStateChange) == null || c.call(n, m.ToolActive));
+      return;
+    }
+  }
+  function B(e, t) {
+    var d, s, p, T;
+    const o = ((s = (d = h == null ? void 0 : h.getReport()) == null ? void 0 : d.webRTCStats) == null ? void 0 : s.avgRtt) ?? 0, r = o > 0 ? Math.round(o / 2 * 1e3) : 0, c = { ...t, downstreamNetworkLatency: r };
+    u.debug && ((p = t == null ? void 0 : t.metadata) != null && p.sentiment) && (c.sentiment = {
+      id: t.metadata.sentiment.id,
+      name: t.metadata.sentiment.sentiment
+    }), (T = n.onMessage) == null || T.call(n, e, c), ke(e, t);
+  }
+  function Ie(e, t) {
+    var o;
+    (o = n.onMessage) == null || o.call(n, J.Transcribe, { event: J.Transcribe, ...t }), queueMicrotask(() => {
+      var r;
+      (r = n.onAgentActivityStateChange) == null || r.call(n, m.Loading);
+    });
+  }
+  function _e(e, t) {
+    var o;
+    x = (t == null ? void 0 : t.turn_id) ?? null, M = m.Loading, (o = n.onAgentActivityStateChange) == null || o.call(n, m.Loading);
+  }
+  function $e(e, t) {
+    var r;
+    const o = (t == null ? void 0 : t.turn_id) ?? null;
+    x !== null && o !== null && o < x || (Me(o), M = m.Idle, (r = n.onAgentActivityStateChange) == null || r.call(n, m.Idle));
+  }
+  const De = {
+    [f.ChatAnswer]: oe,
+    [f.ChatPartial]: oe,
+    [f.ToolCallStarted]: q,
+    [f.ToolCallDone]: q,
+    [f.ToolCallError]: q,
+    [f.StreamVideoCreated]: B,
+    [f.StreamVideoDone]: B,
+    [f.StreamVideoError]: B,
+    [f.StreamVideoRejected]: B,
+    [f.ChatAudioTranscribed]: Ie,
+    [f.TurnStarted]: _e,
+    [f.TurnEnded]: $e
+  };
+  function Ke(e, t, o, r) {
+    const c = new TextDecoder().decode(e);
+    try {
+      const d = JSON.parse(c), s = r || d.subject;
+      if (i("Data received:", { subject: s, data: d }), !s) return;
+      const p = De[s];
+      p == null || p(s, d);
+    } catch (d) {
+      i("Failed to parse data channel message:", d);
+    }
+  }
+  function xe(e) {
+    var t;
+    i("Media devices error:", e), (t = n.onError) == null || t.call(n, O(), { sessionId: v });
+  }
+  function Ve(e) {
+    var t;
+    i("Encryption error:", e), (t = n.onError) == null || t.call(n, O(), { sessionId: v });
+  }
+  function Fe(e, t, o) {
+    i("Track subscription failed:", { trackSid: e, participant: t, reason: o });
+  }
+  function Ue(e, t, o) {
+    for (const [r, c] of o)
+      if (c.source === t && c.track) {
+        const d = c.track.mediaStreamTrack;
+        if (d === e || (d == null ? void 0 : d.id) === e.id)
+          return c;
+      }
+    return null;
+  }
+  async function ae(e, t, o, r, c, d) {
+    var V, F, D;
+    if (!E || !a)
+      throw i(`Room is not connected, cannot publish ${r} stream`), new Error("Room is not connected");
+    if (e.isPublishing) {
+      i(`${r} publish already in progress, skipping`);
+      return;
+    }
+    const s = o(t);
+    if (s.length === 0)
+      throw new Error(`No ${r} track found in the provided MediaStream`);
+    const p = s[0], T = Ue(p, r, c());
+    if (T) {
+      i(`${r} track is already published, skipping`, {
+        trackId: p.id,
+        publishedTrackId: (F = (V = T.track) == null ? void 0 : V.mediaStreamTrack) == null ? void 0 : F.id
+      }), e.publication = T;
+      return;
+    }
+    if ((D = e.publication) != null && D.track) {
+      const w = e.publication.track.mediaStreamTrack;
+      w !== p && (w == null ? void 0 : w.id) !== p.id && (i(`Unpublishing existing ${r} track before publishing new one`), await d());
+    }
+    i(`Publishing ${r} track from provided MediaStream`, { trackId: p.id }), e.isPublishing = !0;
+    try {
+      e.publication = await a.localParticipant.publishTrack(p, { source: r }), i(`${r} track published successfully`, { trackSid: e.publication.trackSid });
+    } catch (w) {
+      throw i(`Failed to publish ${r} track:`, w), w;
+    } finally {
+      e.isPublishing = !1;
+    }
+  }
+  async function ce(e, t) {
+    if (!(!e.publication || !e.publication.track))
+      try {
+        a && (await a.localParticipant.unpublishTrack(e.publication.track, !1), i(`${t} track unpublished`));
+      } catch (o) {
+        i(`Error unpublishing ${t} track:`, o);
+      } finally {
+        e.publication = null;
+      }
+  }
+  async function Oe(e) {
+    return ae(
+      P,
+      e,
+      (t) => t.getAudioTracks(),
+      Y.Source.Microphone,
+      () => a.localParticipant.audioTrackPublications,
+      G
+    );
+  }
+  async function G() {
+    return ce(P, "Microphone");
+  }
+  async function je(e) {
+    if (!E || !a)
+      throw i("Cannot replace microphone track: room is not connected"), new Error("Room is not connected");
+    if (e.kind !== "audio")
+      throw i("Cannot replace microphone track: not an audio track", { kind: e.kind }), new Error("Microphone track must be an audio track");
+    if (P.isPublishing)
+      throw i("Cannot replace microphone track: publish in progress"), new Error("Microphone publish in progress");
+    const t = P.publication;
+    if (!t || !t.track)
+      throw i("Cannot replace microphone track: no publication to replace"), new Error("No microphone publication to replace");
+    try {
+      P.isPublishing = !0, await t.track.replaceTrack(e), i("Microphone track replaced", { trackId: e.id, trackSid: t.trackSid });
+    } finally {
+      P.isPublishing = !1;
+    }
+  }
+  async function Ne(e) {
+    return ae(
+      Q,
+      e,
+      (t) => t.getVideoTracks(),
+      Y.Source.Camera,
+      () => a.localParticipant.videoTrackPublications,
+      H
+    );
+  }
+  async function H() {
+    return ce(Q, "Camera");
+  }
+  function ze() {
+    L && (L.getTracks().forEach((e) => e.stop()), L = null);
+  }
+  async function X(e, t) {
+    var o, r;
+    if (!E || !a) {
+      i("Room is not connected for sending messages"), (o = n.onError) == null || o.call(n, O(), {
+        sessionId: v
+      });
+      return;
+    }
+    try {
+      await a.localParticipant.sendText(t, { topic: e }), i("Message sent successfully:", t);
+    } catch (c) {
+      i("Failed to send message:", c), (r = n.onError) == null || r.call(n, O(), { sessionId: v });
+    }
+  }
+  async function Z(e) {
+    var t, o;
+    R && (clearTimeout(R), R = null), S == null || S.destroy(), S = null, a && ((t = n.onConnectionStateChange) == null || t.call(n, A.Disconnecting, e), await Promise.all([G(), H()]), await a.disconnect()), ze(), E = !1, K = !1, y.size > 0 && (y.clear(), N(), z()), x = null, (o = n.onAgentActivityStateChange) == null || o.call(n, m.Idle), M = m.Idle;
+  }
+  return {
+    speak(e) {
+      const t = typeof e == "string" ? e : JSON.stringify(e);
+      return X(ge.Speak, t);
+    },
+    disconnect: () => Z("user:disconnect"),
+    async reconnect() {
+      var e, t;
+      if ((a == null ? void 0 : a.state) === I.Connected) {
+        i("Room is already connected");
+        return;
+      }
+      if (!a || !$ || !_)
+        throw i("Cannot reconnect: missing room, URL or token"), new Error("Cannot reconnect: session not available");
+      i("Reconnecting to LiveKit room, state:", a.state), K = !1, (e = n.onConnectionStateChange) == null || e.call(n, A.Connecting, "user:reconnect");
+      try {
+        if (await a.connect($, _), i("Room reconnected"), E = !0, a.remoteParticipants.size === 0) {
+          if (i("Waiting for agent to join..."), !await new Promise((r) => {
+            const c = setTimeout(() => {
+              a == null || a.off(g.ParticipantConnected, d), r(!1);
+            }, 5e3), d = () => {
+              clearTimeout(c), a == null || a.off(g.ParticipantConnected, d), r(!0);
+            };
+            a == null || a.on(g.ParticipantConnected, d);
+          }))
+            throw i("Agent did not join within timeout"), await a.disconnect(), new Error("Agent did not rejoin the room");
+          i("Agent joined, reconnection successful");
+        }
+      } catch (o) {
+        throw i("Failed to reconnect:", o), (t = n.onConnectionStateChange) == null || t.call(n, A.Fail, "user:reconnect-failed"), o;
+      }
+    },
+    sendDataChannelMessage: X,
+    publishMicrophoneStream: Oe,
+    unpublishMicrophoneStream: G,
+    replaceMicrophoneTrack: je,
+    publishCameraStream: Ne,
+    unpublishCameraStream: H,
+    interrupt(e) {
+      e !== "text" && X(ge.Interrupt, "");
+    },
+    registerRpcMethod(e, t) {
+      a == null || a.registerRpcMethod(e, t);
+    },
+    unregisterRpcMethod(e) {
+      a == null || a.unregisterRpcMethod(e);
+    },
+    sessionId: v,
+    streamId: v,
+    streamType: ne,
+    interruptAvailable: te,
+    isInterruptible: W
+  };
+}
+export {
+  un as createLiveKitStreamingManager,
+  me as handleInitError
+};

package/dist/src/index.d.ts

@@ -2,4 +2,5 @@ export * from './errors';
 export * from './services/agent-manager';
 export * from './types';
 export { parseMessageParts } from './utils/content-parser';
+export { isAwaitingTool } from './utils/tool-calls';
 export { SDK_VERSION } from './version';

package/dist/src/services/streaming-manager/advanced.test.d.ts

@@ -1,5 +1 @@
-/**
- * Advanced functionality tests for streaming manager
- * Tests complex scenarios, edge cases, and advanced features
- */
 export {};

package/dist/src/services/streaming-manager/common.d.ts

@@ -1,4 +1,5 @@
 import { CreateSessionV2Options, CreateStreamOptions, Interrupt, PayloadType, StreamType } from '../../types';
+import { DataChannelTopic } from '../../types/stream/data-channel';
 
 export declare const createStreamingLogger: (debug: boolean, prefix: string) => (message: string, extra?: any) => false | void;
 /**
@@ -16,16 +17,13 @@ export type StreamingManager<T extends CreateStreamOptions | CreateSessionV2Opti
      */
     disconnect(): Promise<void>;
     /**
-     * Method to send data channel messages to the server
-     * @param payload The message payload to send
+     * The single send primitive: every message leaving the client goes out through here.
+     * V2 routes on the topic; V1 has no topic concept and ignores it.
+     * The promise tracks the send attempt and never rejects - failures go to `callbacks.onError`.
+     * @param topic Data-channel topic to send on
+     * @param payload The message payload to send, already serialized
      */
-    sendDataChannelMessage(payload: string): void;
-    /**
-     * Method to send text messages to the server
-     * @param payload The message payload to send
-     * supported only for livekit manager
-     */
-    sendTextMessage?(payload: string): Promise<void>;
+    sendDataChannelMessage(topic: DataChannelTopic, payload: string): Promise<void>;
     /**
      * Publish a microphone stream to the DataChannel
      * Can be called after connection to add microphone input
@@ -81,10 +79,7 @@ export type StreamingManager<T extends CreateStreamOptions | CreateSessionV2Opti
      */
     isInterruptible: boolean;
     /**
-     * Send an interrupt for the current stream segment.
-     * Each implementation owns the validation/transport details (e.g. V1
-     * sends a `stream/interrupt` payload over the data channel; V2 sends
-     * `did.interrupt` and ignores `text` interrupts to avoid races).
+     * Send an interrupt for the current stream segment
      */
     interrupt(type: Interrupt['type']): void;
     /**

package/dist/src/services/streaming-manager/edge-cases.test.d.ts

@@ -1,5 +1 @@
-/**
- * Edge cases and branch coverage tests for streaming manager
- * Tests detailed edge cases, error conditions, and branch coverage scenarios
- */
 export {};

package/dist/src/services/streaming-manager/livekit-manager.d.ts

@@ -1,11 +1,6 @@
 import { CreateSessionV2Options, CreateStreamOptions, StreamingManagerOptions } from '../../types';
 import { StreamingManager } from './common';
 
-export declare enum DataChannelTopic {
-    Chat = "lk.chat",
-    Speak = "did.speak",
-    Interrupt = "did.interrupt"
-}
 export declare function handleInitError(error: unknown, log: (message?: any, ...optionalParams: any[]) => void, callbacks: StreamingManagerOptions['callbacks']): void;
 export declare function createLiveKitStreamingManager<T extends CreateSessionV2Options>(agentId: string, sessionOptions: CreateSessionV2Options, options: StreamingManagerOptions): Promise<StreamingManager<T> & {
     reconnect(): Promise<void>;

package/dist/src/services/streaming-manager/webrtc-core.test.d.ts

@@ -1,5 +1 @@
-/**
- * Core functionality tests for streaming manager
- * Tests basic streaming manager creation, connection, and operations
- */
 export {};

package/dist/src/types/entities/agents/manager.d.ts

@@ -1,6 +1,6 @@
 import { STTTokenResponse } from '../..';
 import { Auth } from '../../auth';
-import { AgentActivityState, ClientToolHandler, CompatibilityMode, ConnectionState, ConnectivityState, SendStreamPayloadResponse, StreamEvents, StreamType, StreamingState } from '../../stream';
+import { AgentActivityState, ClientToolHandler, CompatibilityMode, ConnectionState, ConnectivityState, PublicDataChannelTopic, SendStreamPayloadResponse, StreamEvents, StreamType, StreamingState } from '../../stream';
 import { SupportedStreamScript } from '../../stream-script';
 import { ManagerCallbacks as StreamManagerCallbacks } from '../../stream/stream';
 import { Agent } from './agent';
@@ -103,6 +103,12 @@ interface ManagerCallbacks {
      * @param interruptible - Whether the agent can be interrupted by the user
      */
     onInterruptibleChange?: StreamManagerCallbacks['onInterruptibleChange'];
+    /**
+     * Optional callback function that will be triggered when the set of running tool calls changes,
+     * including an empty array on disconnect.
+     * @param calls - The tool calls currently running
+     */
+    onRunningToolCallsChange?: StreamManagerCallbacks['onRunningToolCallsChange'];
 }
 interface StreamOptions {
     /**
@@ -280,6 +286,19 @@ export interface AgentManager {
      * Only available for Fluent streams and when there's an active video to interrupt
      */
     interrupt: (interrupt: Interrupt) => void;
+    /**
+     * Switch the STT language mid-session
+     * Only available for Expressive (V4) agents
+     * @param language - Language name or BCP-47 code (e.g. "English" or "en-US")
+     */
+    setSttLanguage: (language: string) => Promise<void>;
+    /**
+     * Send a JSON payload to the agent over a data-channel topic
+     * Only available for Expressive (V4) agents
+     * @param topic - Data-channel topic to send on (see `PublicDataChannelTopic`)
+     * @param payload - Plain object, serialized as JSON
+     */
+    sendDataChannelMessage: (topic: PublicDataChannelTopic, payload: Record<string, unknown>) => Promise<void>;
     /**
      * Register a handler for a client tool. When the agent's LLM calls this tool,
      * the handler executes on the client and returns the result to the LLM.

package/dist/src/types/stream/data-channel.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Data-channel topics messages can be sent on.
+ * V2 (LiveKit) routes by topic; V1 (WebRTC) has no topic concept and ignores it.
+ *
+ * Internal on purpose: this module is deliberately left out of the `stream`
+ * barrel so the topics driven by dedicated methods (`chat`, `speak`,
+ * `interrupt`, `setSttLanguage`) never reach the package's public API.
+ * Customers get `PublicDataChannelTopic` instead.
+ */
+export declare enum DataChannelTopic {
+    Chat = "lk.chat",
+    Speak = "did.speak",
+    Interrupt = "did.interrupt",
+    SttLanguage = "did.stt-language",
+    Presentation = "did.presentation"
+}

package/dist/src/types/stream/stream.d.ts

@@ -3,6 +3,7 @@ import { VideoRTCStatsReport } from '../../services/streaming-manager/stats/repo
 import { Auth } from '../auth';
 import { ChatProgressCallback } from '../entities/agents/manager';
 import { CreateClipStreamRequest, CreateTalkStreamRequest, SendClipStreamPayload, SendTalkStreamPayload } from './api';
+import { DataChannelTopic } from './data-channel';
 import { ICreateStreamRequestResponse, IceCandidate, SendStreamPayloadResponse, Status } from './rtc';
 
 export type CompatibilityMode = 'on' | 'off' | 'auto';
@@ -41,6 +42,20 @@ export declare enum StreamEvents {
     TurnStarted = "turn/started",
     TurnEnded = "turn/ended"
 }
+/**
+ * Topics a customer can send on via `agentManager.sendDataChannelMessage`.
+ * The remaining `DataChannelTopic` members are driven by their own methods
+ * (`chat`, `speak`, `interrupt`, `setSttLanguage`), which own the payload shape
+ * and bookkeeping those topics expect, so they stay internal.
+ *
+ * A const object rather than a second enum: it borrows the value from
+ * `DataChannelTopic`, so there is one source of truth for the wire string and
+ * no cast is needed where the topic reaches the transport.
+ */
+export declare const PublicDataChannelTopic: {
+    readonly Presentation: DataChannelTopic.Presentation;
+};
+export type PublicDataChannelTopic = (typeof PublicDataChannelTopic)[keyof typeof PublicDataChannelTopic];
 export declare enum ConnectionState {
     New = "new",
     Fail = "fail",
@@ -72,6 +87,7 @@ export interface ManagerCallbacks {
     onStreamReady?: () => void;
     onToolEvent?: ToolEventCallback;
     onInterruptibleChange?: (interruptible: boolean) => void;
+    onRunningToolCallsChange?: (calls: readonly RunningToolCall[]) => void;
     onFirstAudioDetected?: (metrics: AudioDetectionMetrics) => void;
 }
 export interface AudioDetectionMetrics {
@@ -181,12 +197,25 @@ export interface StreamInterruptPayload {
     timestamp: number;
 }
 export type ClientToolHandler = (args: Record<string, unknown>) => Promise<string>;
+export type ToolExecutionMode = 'blocking' | 'async';
+/** A tool call currently running in the session. */
+export interface RunningToolCall {
+    callId: string;
+    name: string;
+    /**
+     * 'blocking' - the agent waits for the result before it can continue.
+     * 'async' - the agent keeps talking while the call runs.
+     */
+    executionMode: ToolExecutionMode;
+}
 export interface ToolCallStartedPayload {
     call_id: string;
     name: string;
     input: Record<string, unknown>;
     output: Record<string, unknown>;
     interruptible: boolean;
+    execution_mode?: ToolExecutionMode;
+    turn_id?: number | null;
     timestamp: string;
 }
 export interface ToolCallDonePayload {