@d-id/client-sdk 2.0.5 → 2.0.6

package/dist/livekit-manager-BPAUUVXy.js

@@ -0,0 +1,521 @@
+import { c as Je, C as Q, S as g, a as Qe, b as We, A as m, d as qe, l as fe, e as Ge, t as He, f as A, g as N, h as Xe, i as Ze, j as R, n as Ye } from "./index-BLArKcFJ.js";
+function en() {
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone ?? "";
+  } catch {
+    return "";
+  }
+}
+function nn() {
+  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 tn() {
+  const l = {}, C = en();
+  C && (l.timezone = C);
+  const u = nn();
+  return u && (l.device = u), l;
+}
+function on(l, C, u, i) {
+  const k = Je(l, `${C}/v2/agents/${u}`, i);
+  return {
+    async createStream(f) {
+      return k.post("/sessions", f);
+    }
+  };
+}
+const rn = {
+  [g.ChatAnswer]: Q.Answer,
+  [g.ChatPartial]: Q.Partial
+}, he = 2e4, an = [];
+async function cn() {
+  try {
+    return await import("./index-BLArKcFJ.js").then((l) => l.z);
+  } catch {
+    throw new Error(
+      "LiveKit client is required for this streaming manager. Please install it using: npm install livekit-client"
+    );
+  }
+}
+const sn = {
+  excellent: N.Strong,
+  good: N.Strong,
+  poor: N.Weak,
+  lost: N.Unknown,
+  unknown: N.Unknown
+}, x = (l = "Stream Error") => new Ge(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 dn(l, C, u) {
+  var ue;
+  const i = Qe(u.debug || !1, "LiveKitStreamingManager"), { Room: k, RoomEvent: f, ConnectionState: I, Track: Y } = await cn(), { callbacks: n, auth: Ce, baseURL: Se, analytics: ee } = u;
+  let a = null, E = !1;
+  const ne = We.Fluent;
+  let P = null;
+  const b = { isPublishing: !1, publication: null }, W = { isPublishing: !1, publication: null };
+  let h = null, S = null, U = null, D = !1;
+  a = new k({
+    adaptiveStream: !1,
+    // Must be false to use mediaStreamTrack directly
+    dynacast: !0
+  });
+  let L = null, M = m.Idle, q = !0;
+  const v = /* @__PURE__ */ new Map();
+  let V = null;
+  const Te = on(Ce, Se || qe, l, n.onError);
+  let T, _, $, 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;
+    (ue = n.onStreamCreated) == null || ue.call(n, { session_id: t, stream_id: t, agent_id: l }), T = t, _ = o, $ = r, te = c ?? !0, await a.prepareConnection($, _);
+  } catch (e) {
+    me(e, i, n);
+  }
+  if (!$ || !_ || !T)
+    return Promise.reject(new Error("Failed to initialize LiveKit stream"));
+  a.on(f.ConnectionStateChanged, we).on(f.ConnectionQualityChanged, Ae).on(f.ParticipantConnected, Ee).on(f.ParticipantDisconnected, Le).on(f.TrackSubscribed, Pe).on(f.TrackUnsubscribed, be).on(f.DataReceived, xe).on(f.MediaDevicesError, De).on(f.TranscriptionReceived, ye).on(f.EncryptionError, Ve).on(f.TrackSubscriptionFailed, Fe);
+  function ye(e, t) {
+    t != null && t.isLocal && fe.update();
+  }
+  async function ve() {
+    const e = tn();
+    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(), L = setTimeout(() => {
+      var t;
+      i(
+        `Track subscription timeout - no track subscribed within ${he / 1e3} seconds after connect`
+      ), L = null;
+      const e = x("Track subscription timeout");
+      ee.track("connectivity-error", {
+        error: He(e),
+        sessionId: T
+      }), (t = n.onError) == null || t.call(n, e, { sessionId: T }), 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, D = !1, b.publication = null, W.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, sn[e]));
+  }
+  function Ee(e) {
+    i("Participant connected:", e.identity);
+  }
+  function Le(e) {
+    i("Participant disconnected:", e.identity), Z("livekit:participant-disconnected");
+  }
+  function Re() {
+    var e;
+    U !== R.Start && (i("CALLBACK: onVideoStateChange(Start)"), U = R.Start, (e = n.onVideoStateChange) == null || e.call(n, R.Start));
+  }
+  function ie(e) {
+    var t;
+    U !== R.Stop && (i("CALLBACK: onVideoStateChange(Stop)"), U = R.Stop, (t = n.onVideoStateChange) == null || t.call(n, R.Stop, e));
+  }
+  function Pe(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;
+    }
+    P ? (P.addTrack(r), i(`Added ${e.kind} track to shared MediaStream`)) : (P = new MediaStream([r]), i(`Created shared MediaStream with ${e.kind} track`)), e.kind === "audio" && (S = Ze(
+      () => e.getRTCStatsReport(),
+      ({ sttLatency: p, serviceLatency: y }) => {
+        var de, le, ge;
+        const F = fe.get(!0);
+        let O = 0;
+        if (p) {
+          const pe = ((le = (de = h == null ? void 0 : h.getReport()) == null ? void 0 : de.webRTCStats) == null ? void 0 : le.avgRtt) ?? 0;
+          O = pe > 0 ? Math.round(pe * 1e3) : 0;
+        }
+        const K = F > 0 ? F + (p ?? 0) + O : void 0, w = K !== void 0 && y !== void 0 ? K - y : void 0;
+        (ge = n.onFirstAudioDetected) == null || ge.call(n, { latency: K, networkLatency: w });
+      }
+    )), e.kind === "video" && ((c = n.onStreamReady) == null || c.call(n), i("CALLBACK: onSrcObjectReady"), (d = n.onSrcObjectReady) == null || d.call(n, P), D || (D = !0, i("CALLBACK: onConnectionStateChange(Connected)"), (s = n.onConnectionStateChange) == null || s.call(n, A.Connected, "livekit:track-subscribed")), h = Xe(
+      () => e.getRTCStatsReport(),
+      () => E,
+      Ye,
+      (p, y) => {
+        i(`Video state change: ${p}`), p === R.Start ? (L && (clearTimeout(L), L = null, i("Track subscription timeout cleared")), Re()) : p === R.Stop && ie(y);
+      }
+    ), h.start());
+  }
+  function be(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 = rn[e];
+    o && ((r = n.onMessage) == null || r.call(n, o, { event: o, ...t }));
+  }
+  function G(e, t) {
+    var o, r, c, d;
+    if (e === g.ToolCallStarted) {
+      const s = t;
+      v.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 ?? V
+      }), j(), z(), M = m.ToolActive, (o = n.onAgentActivityStateChange) == null || o.call(n, m.ToolActive), (r = n.onToolEvent) == null || r.call(n, g.ToolCallStarted, s);
+      return;
+    }
+    if (e === g.ToolCallDone) {
+      const s = t;
+      re(s.call_id), (c = n.onToolEvent) == null || c.call(n, g.ToolCallDone, s);
+      return;
+    }
+    if (e === g.ToolCallError) {
+      const s = t;
+      re(s.call_id), (d = n.onToolEvent) == null || d.call(n, g.ToolCallError, s);
+    }
+  }
+  function re(e) {
+    v.delete(e) && (j(), z());
+  }
+  function Me(e) {
+    let t = !1;
+    for (const [o, r] of v)
+      r.call.executionMode === "blocking" && (e !== null && r.turnId !== null && r.turnId !== e || (v.delete(o), t = !0));
+    t && (j(), z());
+  }
+  function j() {
+    var t;
+    const e = ![...v.values()].some(({ call: o }) => o.executionMode === "blocking");
+    e !== q && (q = e, (t = n.onInterruptibleChange) == null || t.call(n, e));
+  }
+  function z() {
+    var e;
+    (e = n.onRunningToolCallsChange) == null || e.call(
+      n,
+      v.size === 0 ? an : [...v.values()].map(({ call: t }) => t)
+    );
+  }
+  function ke(e, t) {
+    var o, r, c;
+    if (e === g.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 (v.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, y;
+    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
+    }), (y = n.onMessage) == null || y.call(n, e, c), ke(e, t);
+  }
+  function Ie(e, t) {
+    var o;
+    (o = n.onMessage) == null || o.call(n, Q.Transcribe, { event: Q.Transcribe, ...t }), queueMicrotask(() => {
+      var r;
+      (r = n.onAgentActivityStateChange) == null || r.call(n, m.Loading);
+    });
+  }
+  function _e(e, t) {
+    var o;
+    V = (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;
+    V !== null && o !== null && o < V || (Me(o), M = m.Idle, (r = n.onAgentActivityStateChange) == null || r.call(n, m.Idle));
+  }
+  const Ke = {
+    [g.ChatAnswer]: oe,
+    [g.ChatPartial]: oe,
+    [g.ToolCallStarted]: G,
+    [g.ToolCallDone]: G,
+    [g.ToolCallError]: G,
+    [g.StreamVideoCreated]: B,
+    [g.StreamVideoDone]: B,
+    [g.StreamVideoError]: B,
+    [g.StreamVideoRejected]: B,
+    [g.ChatAudioTranscribed]: Ie,
+    [g.TurnStarted]: _e,
+    [g.TurnEnded]: $e
+  };
+  function xe(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 = Ke[s];
+      p == null || p(s, d);
+    } catch (d) {
+      i("Failed to parse data channel message:", d);
+    }
+  }
+  function De(e) {
+    var t;
+    i("Media devices error:", e), (t = n.onError) == null || t.call(n, x(), { sessionId: T });
+  }
+  function Ve(e) {
+    var t;
+    i("Encryption error:", e), (t = n.onError) == null || t.call(n, x(), { sessionId: T });
+  }
+  function Fe(e, t, o) {
+    i("Track subscription failed:", { trackSid: e, participant: t, reason: o });
+  }
+  function Oe(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 F, O, K;
+    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], y = Oe(p, r, c());
+    if (y) {
+      i(`${r} track is already published, skipping`, {
+        trackId: p.id,
+        publishedTrackId: (O = (F = y.track) == null ? void 0 : F.mediaStreamTrack) == null ? void 0 : O.id
+      }), e.publication = y;
+      return;
+    }
+    if ((K = e.publication) != null && K.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 Ne(e) {
+    return ae(
+      b,
+      e,
+      (t) => t.getAudioTracks(),
+      Y.Source.Microphone,
+      () => a.localParticipant.audioTrackPublications,
+      H
+    );
+  }
+  async function H() {
+    return ce(b, "Microphone");
+  }
+  async function Ue(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 (b.isPublishing)
+      throw i("Cannot replace microphone track: publish in progress"), new Error("Microphone publish in progress");
+    const t = b.publication;
+    if (!t || !t.track)
+      throw i("Cannot replace microphone track: no publication to replace"), new Error("No microphone publication to replace");
+    try {
+      b.isPublishing = !0, await t.track.replaceTrack(e), i("Microphone track replaced", { trackId: e.id, trackSid: t.trackSid });
+    } finally {
+      b.isPublishing = !1;
+    }
+  }
+  async function je(e) {
+    return ae(
+      W,
+      e,
+      (t) => t.getVideoTracks(),
+      Y.Source.Camera,
+      () => a.localParticipant.videoTrackPublications,
+      X
+    );
+  }
+  async function X() {
+    return ce(W, "Camera");
+  }
+  function ze() {
+    P && (P.getTracks().forEach((e) => e.stop()), P = null);
+  }
+  async function J(e, t) {
+    var o, r;
+    if (!E || !a) {
+      i("Room is not connected for sending messages"), (o = n.onError) == null || o.call(n, x(), {
+        sessionId: T
+      });
+      return;
+    }
+    try {
+      await a.localParticipant.sendText(e, { topic: t }), i("Message sent successfully:", e);
+    } catch (c) {
+      i("Failed to send message:", c), (r = n.onError) == null || r.call(n, x(), { sessionId: T });
+    }
+  }
+  async function se(e) {
+    var t;
+    try {
+      const r = JSON.parse(e).topic;
+      return J("", r);
+    } catch (o) {
+      i("Failed to send data channel message:", o), (t = n.onError) == null || t.call(n, x(), { sessionId: T });
+    }
+  }
+  function Be(e) {
+    return J(
+      e,
+      "lk.chat"
+      /* Chat */
+    );
+  }
+  async function Z(e) {
+    var t, o;
+    L && (clearTimeout(L), L = null), S == null || S.destroy(), S = null, a && ((t = n.onConnectionStateChange) == null || t.call(n, A.Disconnecting, e), await Promise.all([H(), X()]), await a.disconnect()), ze(), E = !1, D = !1, v.size > 0 && (v.clear(), j(), z()), V = 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 J(
+        t,
+        "did.speak"
+        /* Speak */
+      );
+    },
+    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), D = !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(f.ParticipantConnected, d), r(!1);
+            }, 5e3), d = () => {
+              clearTimeout(c), a == null || a.off(f.ParticipantConnected, d), r(!0);
+            };
+            a == null || a.on(f.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: se,
+    sendTextMessage: Be,
+    publishMicrophoneStream: Ne,
+    unpublishMicrophoneStream: H,
+    replaceMicrophoneTrack: Ue,
+    publishCameraStream: je,
+    unpublishCameraStream: X,
+    interrupt(e) {
+      e !== "text" && se(JSON.stringify({
+        topic: "did.interrupt"
+        /* Interrupt */
+      }));
+    },
+    /**
+     * 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").
+     * @returns Promise that resolves after the send attempt completes; failures are reported via onError.
+     */
+    setSttLanguage(e) {
+      return J(
+        JSON.stringify({ language: e }),
+        "did.stt-language"
+        /* SttLanguage */
+      );
+    },
+    registerRpcMethod(e, t) {
+      a == null || a.registerRpcMethod(e, t);
+    },
+    unregisterRpcMethod(e) {
+      a == null || a.unregisterRpcMethod(e);
+    },
+    sessionId: T,
+    streamId: T,
+    streamType: ne,
+    interruptAvailable: te,
+    isInterruptible: q
+  };
+}
+export {
+  dn 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/common.d.ts

@@ -87,6 +87,13 @@ export type StreamingManager<T extends CreateStreamOptions | CreateSessionV2Opti
      * `did.interrupt` and ignores `text` interrupts to avoid races).
      */
     interrupt(type: Interrupt['type']): void;
+    /**
+     * Switch the STT language mid-session.
+     * Only available for Expressive (V4) agents.
+     * supported only for livekit manager
+     * @param language Language name or BCP-47 code (e.g. "English" or "en-US")
+     */
+    setSttLanguage?(language: string): Promise<void>;
     /**
      * Register an RPC method handler on the LiveKit room.
      * Used internally by the agent-manager for client tool delegation.

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

@@ -4,7 +4,8 @@ import { StreamingManager } from './common';
 export declare enum DataChannelTopic {
     Chat = "lk.chat",
     Speak = "did.speak",
-    Interrupt = "did.interrupt"
+    Interrupt = "did.interrupt",
+    SttLanguage = "did.stt-language"
 }
 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> & {

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

@@ -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,12 @@ 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>;
     /**
      * 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/stream.d.ts

@@ -72,6 +72,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 +182,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 {

package/dist/src/utils/tool-calls.d.ts

@@ -0,0 +1,8 @@
+import { RunningToolCall } from '../types';
+
+/**
+ * Whether the agent is waiting on a tool call before it can continue.
+ * True while any running call is 'blocking'. False when nothing is running,
+ * or when everything running is 'async' and the agent is still available.
+ */
+export declare function isAwaitingTool(calls: readonly RunningToolCall[]): boolean;

package/dist/src/utils/tool-calls.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@d-id/client-sdk",
   "private": false,
-  "version": "2.0.5",
+  "version": "2.0.6",
   "type": "module",
   "description": "d-id client sdk",
   "repository": {