@d-id/client-sdk 1.1.18 → 1.1.19-staging.87

package/dist/livekit-manager-CNKaXUpT.js

@@ -0,0 +1,195 @@
+import { c as H, a as X, S as Y, d as Z, T as k, C as u, b as p, A as K, e as F, f as b, g as ee } from "./index-DcoRNuxp.js";
+function ne(c, f, s, i) {
+  const h = H(c, `${f}/v2/agents/${s}`, i);
+  return {
+    async createStream(a) {
+      return h.post("/streams", a);
+    }
+  };
+}
+async function te() {
+  try {
+    return await import("./livekit-client.esm-C1GRQdZY.js");
+  } catch {
+    throw new Error(
+      "LiveKit client is required for this streaming manager. Please install it using: npm install livekit-client"
+    );
+  }
+}
+const ie = {
+  excellent: p.Strong,
+  good: p.Strong,
+  poor: p.Weak,
+  lost: p.Unknown,
+  unknown: p.Unknown
+}, A = JSON.stringify({
+  kind: "InternalServerError",
+  description: "Stream Error"
+});
+function _(c, f, s, i) {
+  var h, a;
+  throw f("Failed to connect to LiveKit room:", c), i(), (h = s.onConnectionStateChange) == null || h.call(s, u.Fail), (a = s.onError) == null || a.call(s, c, { streamId: "" }), c;
+}
+async function se(c, f, s) {
+  var D, P;
+  const i = X(s.debug || !1, "LiveKitStreamingManager"), {
+    Room: h,
+    RoomEvent: a,
+    ConnectionState: v,
+    RemoteParticipant: oe,
+    RemoteTrack: re
+  } = await te(), { callbacks: e, auth: I, baseURL: N, analytics: U } = s;
+  let g = null, y = !1;
+  const R = Y.Fluent;
+  let w = !0, C = null;
+  g = new h({
+    adaptiveStream: !1,
+    // Must be false to use mediaStreamTrack directly
+    dynacast: !0
+  });
+  const x = ne(I, N || Z, c, e.onError);
+  let m, L, E, T;
+  try {
+    const n = await x.createStream({
+      transport_provider: k.Livekit,
+      chat_id: f.chat_id
+    }), { session_id: t, session_token: o, session_url: r } = n;
+    (D = e.onStreamCreated) == null || D.call(e, { stream_id: t, session_id: t, agent_id: c }), m = t, L = t, E = o, T = r, await g.prepareConnection(T, E);
+  } catch (n) {
+    _(n, i, e, () => {
+      w = !1;
+    });
+  }
+  if (!T || !E || !m || !L)
+    return Promise.reject(new Error("Failed to initialize LiveKit stream"));
+  g.on(a.ConnectionStateChanged, j).on(a.ConnectionQualityChanged, O).on(a.ActiveSpeakersChanged, J).on(a.ParticipantConnected, Q).on(a.TrackSubscribed, V).on(a.TrackUnsubscribed, q).on(a.DataReceived, z).on(a.MediaDevicesError, W).on(a.EncryptionError, l).on(a.TrackSubscriptionFailed, B), (P = e.onConnectionStateChange) == null || P.call(e, u.New);
+  try {
+    await g.connect(T, E), i("LiveKit room joined successfully"), w = !1;
+  } catch (n) {
+    _(n, i, e, () => {
+      w = !1;
+    });
+  }
+  U.enrich({
+    "stream-type": R
+  });
+  function j(n) {
+    var t, o, r, d, S;
+    switch (i("Connection state changed:", n), n) {
+      case v.Connecting:
+        (t = e.onConnectionStateChange) == null || t.call(e, u.Connecting);
+        break;
+      case v.Connected:
+        i("LiveKit room connected successfully"), y = !0, w ? queueMicrotask(() => {
+          var $;
+          ($ = e.onConnectionStateChange) == null || $.call(e, u.Connected);
+        }) : (o = e.onConnectionStateChange) == null || o.call(e, u.Connected);
+        break;
+      case v.Disconnected:
+        i("LiveKit room disconnected"), y = !1, (r = e.onConnectionStateChange) == null || r.call(e, u.Disconnected);
+        break;
+      case v.Reconnecting:
+        i("LiveKit room reconnecting..."), (d = e.onConnectionStateChange) == null || d.call(e, u.Connecting);
+        break;
+      case v.SignalReconnecting:
+        i("LiveKit room signal reconnecting..."), (S = e.onConnectionStateChange) == null || S.call(e, u.Connecting);
+        break;
+    }
+  }
+  function O(n, t) {
+    var o;
+    i("Connection quality:", n), t != null && t.isLocal && ((o = e.onConnectivityStateChange) == null || o.call(e, ie[n]));
+  }
+  function J(n) {
+    var o, r;
+    i("Active speakers changed:", n), n[0] ? (o = e.onAgentActivityStateChange) == null || o.call(e, K.Talking) : (r = e.onAgentActivityStateChange) == null || r.call(e, K.Idle);
+  }
+  function Q(n) {
+    i("Participant connected:", n.identity);
+  }
+  function V(n, t, o) {
+    var d, S;
+    i(`Track subscribed: ${n.kind} from ${o.identity}`);
+    const r = n.mediaStreamTrack;
+    if (!r) {
+      i(`No mediaStreamTrack available for ${n.kind}`);
+      return;
+    }
+    C ? (C.addTrack(r), i(`Added ${n.kind} track to shared MediaStream`)) : (C = new MediaStream([r]), i(`Created shared MediaStream with ${n.kind} track`)), n.kind === "video" && ((d = e.onSrcObjectReady) == null || d.call(e, C), (S = e.onVideoStateChange) == null || S.call(e, F.Start));
+  }
+  function q(n, t, o) {
+    var r;
+    i(`Track unsubscribed: ${n.kind} from ${o.identity}`), n.kind === "video" && ((r = e.onVideoStateChange) == null || r.call(e, F.Stop));
+  }
+  function z(n, t) {
+    var r;
+    const o = new TextDecoder().decode(n);
+    i("Data received:", o);
+    try {
+      const d = JSON.parse(o);
+      if (d.subject === b.ChatAnswer) {
+        const S = ee.Answer;
+        (r = e.onMessage) == null || r.call(e, S, {
+          event: S,
+          ...d
+        });
+      }
+    } catch (d) {
+      i("Failed to parse data channel message:", d);
+    }
+  }
+  function W(n) {
+    var t;
+    i("Media devices error:", n), (t = e.onError) == null || t.call(e, new Error(A), { streamId: m });
+  }
+  function l(n) {
+    var t;
+    i("Encryption error:", n), (t = e.onError) == null || t.call(e, new Error(A), { streamId: m });
+  }
+  function B(n, t, o) {
+    i("Track subscription failed:", { trackSid: n, participant: t, reason: o });
+  }
+  function G() {
+    C && (C.getTracks().forEach((n) => n.stop()), C = null);
+  }
+  async function M(n) {
+    var t, o;
+    if (!y || !g) {
+      i("Room is not connected for sending messages"), (t = e.onError) == null || t.call(e, new Error(A), {
+        streamId: m
+      });
+      return;
+    }
+    try {
+      await g.localParticipant.sendText(n, {
+        topic: "lk.chat"
+      }), i("Message sent successfully:", n);
+    } catch (r) {
+      i("Failed to send message:", r), (o = e.onError) == null || o.call(e, new Error(A), { streamId: m });
+    }
+  }
+  return {
+    speak(n) {
+      const t = JSON.stringify({
+        type: "speak",
+        payload: n
+      });
+      return M(t);
+    },
+    async disconnect() {
+      var n, t;
+      g && (await g.disconnect(), g = null), G(), y = !1, (n = e.onConnectionStateChange) == null || n.call(e, u.Completed), (t = e.onAgentActivityStateChange) == null || t.call(e, K.Idle);
+    },
+    sendDataChannelMessage: M,
+    sendTextMessage: M,
+    sessionId: L,
+    streamId: m,
+    streamType: R,
+    interruptAvailable: !0,
+    triggersAvailable: !1
+  };
+}
+export {
+  se as createLiveKitStreamingManager,
+  _ as handleInitError
+};

package/dist/src/services/agent-manager/connect-to-manager.d.ts

@@ -1,10 +1,12 @@
 import { StreamingManager } from '../streaming-manager';
-import { Agent, AgentManagerOptions, AgentsAPI, Chat, CreateStreamOptions, CreateStreamV2Options } from '../../types';
+import { Agent, AgentManagerOptions, AgentsAPI, Chat, ChatProgressCallback, CreateStreamOptions, CreateStreamV2Options } from '../../types';
 import { Analytics } from '../analytics/mixpanel';
 
 type ConnectToManagerOptions = AgentManagerOptions & {
     callbacks: AgentManagerOptions['callbacks'] & {
         onVideoIdChange?: (videoId: string | null) => void;
+        /** Internal callback for livekit-manager data channel events */
+        onMessage?: ChatProgressCallback;
     };
     chatId?: string;
 };

package/dist/src/services/analytics/mixpanel.d.ts

@@ -13,7 +13,7 @@ export interface Analytics {
     agentId: string;
     owner_id?: string;
     getRandom(): string;
-    track(event: string, props?: Record<string, any>): Promise<any>;
+    track(event: string, props?: Record<string, any>, eventTimestamp?: number): Promise<any>;
     linkTrack(mixpanelEvent: string, props: Record<string, any>, event: string, dependencies: string[]): any;
     enrich(props: Record<string, any>): void;
     additionalProperties: Record<string, any>;

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

@@ -20,6 +20,12 @@ export type StreamingManager<T extends CreateStreamOptions | CreateStreamV2Optio
      * @param payload The message payload to send
      */
     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>;
     /**
      * Session identifier information, should be returned in the body of all streaming requests
      */

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

@@ -1,5 +1,6 @@
 import { CreateStreamOptions, CreateStreamV2Options, StreamingManagerOptions } from '../../types';
 import { StreamingManager } from './common';
 
+export declare function handleInitError(error: unknown, log: (message?: any, ...optionalParams: any[]) => void, callbacks: StreamingManagerOptions['callbacks'], markInitialConnectionDone: () => void): void;
 export declare function createLiveKitStreamingManager<T extends CreateStreamV2Options>(agentId: string, agent: T, options: StreamingManagerOptions): Promise<StreamingManager<T>>;
 export type LiveKitStreamingManager<T extends CreateStreamOptions> = StreamingManager<T>;

package/dist/src/services/streaming-manager/stats/poll.d.ts

@@ -1,4 +1,4 @@
 import { ConnectivityState, StreamingState } from '../../../types';
 import { VideoRTCStatsReport } from './report';
 
-export declare function pollStats(peerConnection: RTCPeerConnection, getIsConnected: () => boolean, onConnected: () => void, onVideoStateChange?: (state: StreamingState, statsReport?: VideoRTCStatsReport) => void, onConnectivityStateChange?: (state: ConnectivityState) => void, warmup?: boolean): NodeJS.Timeout;
+export declare function pollStats(peerConnection: RTCPeerConnection, getIsConnected: () => boolean, onConnected: () => void, onVideoStateChange?: (state: StreamingState, statsReport?: VideoRTCStatsReport) => void, onConnectivityStateChange?: (state: ConnectivityState) => void): NodeJS.Timeout;

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

@@ -1,6 +1,7 @@
 import { Analytics } from '../../services/analytics/mixpanel';
 import { VideoRTCStatsReport } from '../../services/streaming-manager/stats/report';
 import { Auth } from '../auth';
+import { ChatProgressCallback } from '../entities/agents/manager';
 import { CreateClipStreamRequest, CreateTalkStreamRequest, SendClipStreamPayload, SendTalkStreamPayload } from './api';
 import { ICreateStreamRequestResponse, IceCandidate, SendStreamPayloadResponse, Status } from './rtc';
 
@@ -46,7 +47,7 @@ export declare enum StreamType {
     Fluent = "fluent"
 }
 export interface ManagerCallbacks {
-    onMessage?: (event: string, data: string) => void;
+    onMessage?: ChatProgressCallback;
     onConnectionStateChange?: (state: ConnectionState) => void;
     onVideoStateChange?: (state: StreamingState, report?: VideoRTCStatsReport) => void;
     onSrcObjectReady?: (value: MediaStream) => void;

package/dist/src/utils/defer.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Defers function execution until browser is idle to avoid blocking critical path.
+ * Uses requestIdleCallback when available, falls back to setTimeout.
+ *
+ * @param fn - Function to execute when browser is idle
+ */
+export declare function defer(fn: () => void): void;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@d-id/client-sdk",
   "private": false,
-  "version": "1.1.18",
+  "version": "1.1.19-staging.87",
   "type": "module",
   "description": "d-id client sdk",
   "repository": {