@d-id/client-sdk 3.0.0-staging.412 → 3.0.0-staging.414

package/dist/livekit-manager-BM3JMzT5.js

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

package/dist/src/api/agents.d.ts

@@ -1,4 +1,4 @@
-import { Agent, Auth, Chat, ChatPayload, ChatResponse, RatingEntity, RatingPayload, STTTokenResponse, SubmitFeedbackResponse } from '../types/index';
+import { Agent, Auth, Chat, ChatPayload, ChatResponse, Rating, RatingPayload, SttTokenResponse, SubmitFeedbackResponse } from '../types/index';
 import { RequestOptions } from './apiClient';
 
 export declare function createAgentsApi(auth: Auth, host?: string, onError?: (error: Error, errorData: Record<string, unknown>) => void, externalId?: string): {
@@ -7,12 +7,12 @@ export declare function createAgentsApi(auth: Auth, host?: string, onError?: (er
         persist: boolean;
     }, options?: RequestOptions): Promise<Chat>;
     chat(agentId: string, chatId: string, payload: ChatPayload, options?: RequestOptions): Promise<ChatResponse>;
-    createRating(agentId: string, chatId: string, payload: RatingPayload, options?: RequestOptions): Promise<RatingEntity>;
-    updateRating(agentId: string, chatId: string, ratingId: string, payload: Partial<RatingPayload>, options?: RequestOptions): Promise<RatingEntity>;
-    deleteRating(agentId: string, chatId: string, ratingId: string, options?: RequestOptions): Promise<RatingEntity>;
+    createRating(agentId: string, chatId: string, payload: RatingPayload, options?: RequestOptions): Promise<Rating>;
+    updateRating(agentId: string, chatId: string, ratingId: string, payload: Partial<RatingPayload>, options?: RequestOptions): Promise<Rating>;
+    deleteRating(agentId: string, chatId: string, ratingId: string, options?: RequestOptions): Promise<Rating>;
     submitFeedback(agentId: string, chatId: string, payload: {
         rating: number;
         answer?: string;
     }, options?: RequestOptions): Promise<SubmitFeedbackResponse>;
-    getSTTToken(agentId: string, options?: RequestOptions): Promise<STTTokenResponse>;
+    getSttToken(agentId: string, options?: RequestOptions): Promise<SttTokenResponse>;
 };

package/dist/src/api/streams/streamApi.test.d.ts

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

package/dist/src/index.d.ts

@@ -3,18 +3,18 @@ export type { Auth, BasicAuth, BearerToken, ClientKeyAuth } from './types/auth';
 export type { Agent, AgentAvatar, EndOfCallFeedbackConfig } from './types/entities/agents/agent';
 export type { AgentManager, AgentManagerCallbacks, AgentManagerOptions, StreamOptions, } from './types/entities/agents/manager';
 export { AvatarType } from './types/entities/avatar';
-export type { STTTokenResponse } from './types/voice/stt';
-export { AgentActivityState, ConnectionState, ConnectivityState, PublicDataChannelTopic, StreamEndReason, StreamEvents, StreamingState, } from './types/stream/stream';
+export type { SttTokenResponse } from './types/voice/stt';
+export { AgentActivityState, ConnectionState, ConnectivityState, DataChannelTopic, StreamEndReason, StreamingState, ToolCallEvent, } from './types/stream/stream';
 export type { ClientToolHandler, RunningToolCall, StreamCreatedInfo, ToolCallDonePayload, ToolCallErrorPayload, ToolCallStartedPayload, ToolEventCallback, ToolExecutionMode, } from './types/stream/stream';
-export type { SendStreamPayloadResponse } from './types/stream/rtc';
+export type { SpeakResponse } from './types/stream/rtc';
 export { StreamType } from './types/stream/stream';
 export type { CompatibilityMode } from './types/stream/stream';
-export type { AudioStreamScript, SupportedStreamScript, TextStreamScript } from './types/stream-script';
+export type { AudioStreamScript, SpeakScript, TextStreamScript } from './types/stream-script';
 export { ChatMode } from './types/entities/agents/chat';
-export type { ChatResponse, Interrupt, Message, MessagePart, MessageSentiment, RatingEntity, RetrievalMetadata, SubmitFeedbackResponse, } from './types/entities/agents/chat';
+export type { ChatResponse, InterruptOptions, Message, MessagePart, MessageSentiment, Rating, RetrievalMetadata, SubmitFeedbackResponse, } from './types/entities/agents/chat';
 export { parseMessageParts } from './utils/content-parser';
 export { isAwaitingTool } from './utils/tool-calls';
 export { Providers, VoiceAccess } from './types/voice/tts';
-export type { AmazonTtsProvider, AzureOpenAiTtsProvider, ElevenlabsTtsProvider, MicrosoftTtsProvider, StreamTextToSpeechProviders, Voice, VoiceConfigElevenlabs, VoiceConfigMicrosoft, } from './types/voice/tts';
+export type { AmazonTtsProvider, AzureOpenAiTtsProvider, ElevenlabsTtsProvider, MicrosoftTtsProvider, TtsProvider, Voice, VoiceConfigElevenlabs, VoiceConfigMicrosoft, } from './types/voice/tts';
 export { BaseError, ChatCreationFailed, ChatModeDowngraded, HttpError, NetworkError, StreamError, ValidationError, WsError, isDIDError, } from './errors';
 export type { ErrorJson } from './errors';

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

@@ -1,5 +1,5 @@
-import { CreateSessionV2Options, CreateStreamOptions, Interrupt, PayloadType, StreamType } from '../../types';
-import { DataChannelTopic } from '../../types/stream/data-channel';
+import { CreateSessionV2Options, CreateStreamOptions, InterruptOptions, PayloadType, StreamType } from '../../types';
+import { InternalDataChannelTopic } from '../../types/stream/data-channel';
 
 export declare const createStreamingLogger: (debug: boolean, prefix: string) => (message: string, extra?: any) => false | void;
 /**
@@ -23,7 +23,7 @@ export type StreamingManager<T extends CreateStreamOptions | CreateSessionV2Opti
      * @param topic Data-channel topic to send on
      * @param payload The message payload to send, already serialized
      */
-    sendDataChannelMessage(topic: DataChannelTopic, payload: string): Promise<void>;
+    sendDataChannelMessage(topic: InternalDataChannelTopic, payload: string): Promise<void>;
     /**
      * Publish a microphone stream to the DataChannel
      * Can be called after connection to add microphone input
@@ -86,7 +86,7 @@ export type StreamingManager<T extends CreateStreamOptions | CreateSessionV2Opti
      * interrupt type is one this transport drops), and `false` when the transport could not carry
      * it because the connection or the data channel is not up.
      */
-    interrupt(type: Interrupt['type']): boolean;
+    interrupt(type: InterruptOptions['type']): boolean;
     /**
      * Register an RPC method handler on the LiveKit room.
      * Used internally by the agent-manager for client tool delegation.

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

@@ -2,13 +2,13 @@
  * A rating stored against one message of a chat, as the Agents API returns it.
  *
  * Produced by {@link AgentManager.rate | rate()} and returned again by
- * {@link AgentManager.deleteRate | deleteRate()}. Keep {@link RatingEntity.id | id} if the user may
+ * {@link AgentManager.deleteRate | deleteRate()}. Keep {@link Rating.id | id} if the user may
  * change their mind: pass it back to {@link AgentManager.rate | rate()} as `rateId` to update the
  * rating, or to {@link AgentManager.deleteRate | deleteRate()} to remove it.
  *
  * @category Chat
  */
-export interface RatingEntity {
+export interface Rating {
     /**
      * Id of this rating.
      *
@@ -56,10 +56,10 @@ export interface RatingEntity {
     message_id: string;
 }
 /**
- * Request payload for rating a chat message, derived from `RatingEntity`.
+ * Request payload for rating a chat message, derived from `Rating`.
  * @internal Implementation type; not part of the public SDK surface.
  */
-export type RatingPayload = Omit<RatingEntity, 'owner_id' | 'id' | 'created_at' | 'modified_at' | 'created_by' | 'external_id' | 'agent_id' | 'chat_id'>;
+export type RatingPayload = Omit<Rating, 'owner_id' | 'id' | 'created_at' | 'modified_at' | 'created_by' | 'external_id' | 'agent_id' | 'chat_id'>;
 /**
  * What the Agents API stored when end-of-call feedback was submitted.
  *
@@ -188,7 +188,7 @@ export interface Message {
      */
     parts: MessagePart[];
     /** When the message was added, as an ISO 8601 timestamp. */
-    created_at?: string;
+    createdAt?: string;
     /**
      * The knowledge citations the answer was drawn from, as {@link RetrievalMetadata} entries.
      *
@@ -267,14 +267,14 @@ export interface ChatPayload {
  */
 export interface RetrievalMetadata {
     /** Id of this match. Sent back with a rating as the second half of a
-     * {@link RatingEntity.matches} pair. */
+     * {@link Rating.matches} pair. */
     id: string;
     /** The matched passage itself, as stored in the knowledge base. */
     data: string;
     /** Title of the document the passage comes from. */
     title: string;
     /** Id of the source document. Sent back with a rating as the first half of a
-     * {@link RatingEntity.matches} pair. */
+     * {@link Rating.matches} pair. */
     document_id: string;
     /** Id of the knowledge base the document belongs to — the agent's {@link Agent.knowledge}. */
     knowledge_id: string;
@@ -311,7 +311,7 @@ export declare enum ChatMode {
      * {@link AgentManager.chat | chat()} still returns answers through
      * {@link AgentManagerCallbacks.onNewMessage | onNewMessage}, and
      * {@link AgentManager.speak | speak()} adds a text script to the transcript but streams no
-     * video: it resolves with a `duration` of `0` and an empty `video_id`.
+     * video: it resolves with a `duration` of `0` and an empty `videoId`.
      */
     TextOnly = "TextOnly",
     /**
@@ -461,7 +461,7 @@ export interface Chat {
  *
  * @category Chat
  */
-export interface Interrupt {
+export interface InterruptOptions {
     /**
      * The cause: `text` when the user typed over the answer, `audio` when they started speaking,
      * `click` when they pressed a stop control, and `manual` for an interruption the application