@d-id/client-sdk 1.1.61 → 1.1.63-staging.289

package/dist/livekit-manager-DylcG4TH.js

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

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

@@ -1,5 +1,5 @@
 import { StreamingManager } from '../streaming-manager';
-import { Agent, AgentManagerOptions, AgentsAPI, AudioDetectionMetrics, Chat, ChatProgressCallback, CreateSessionV2Options, CreateStreamOptions, Interrupt } from '../../types';
+import { Agent, AgentManagerOptions, AgentsAPI, AudioDetectionMetrics, Chat, ChatProgressCallback, CreateSessionV2Options, CreateStreamOptions } from '../../types';
 import { Analytics } from '../analytics/mixpanel';
 
 type ConnectToManagerOptions = AgentManagerOptions & {
@@ -7,8 +7,6 @@ type ConnectToManagerOptions = AgentManagerOptions & {
         onVideoIdChange?: (videoId: string | null) => void;
         /** Internal callback for livekit-manager data channel events */
         onMessage?: ChatProgressCallback;
-        /** Internal callback for when interrupt is detected by streaming manager */
-        onInterruptDetected?: (interrupt: Interrupt) => void;
         onFirstAudioDetected?: (metrics: AudioDetectionMetrics) => void;
     };
     chatId?: string;

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

@@ -1,4 +1,4 @@
-import { CreateSessionV2Options, CreateStreamOptions, PayloadType, StreamType } from '../../types';
+import { CreateSessionV2Options, CreateStreamOptions, Interrupt, PayloadType, StreamType } from '../../types';
 
 export declare const createStreamingLogger: (debug: boolean, prefix: string) => (message: string, extra?: any) => false | void;
 /**
@@ -39,6 +39,15 @@ export type StreamingManager<T extends CreateStreamOptions | CreateSessionV2Opti
      * supported only for livekit manager
      */
     unpublishMicrophoneStream?(): Promise<void>;
+    /**
+     * Replace the currently published microphone MediaStreamTrack without
+     * unpublishing. Preserves the LiveKit publication (SSRC, trackSid) so the
+     * server sees continuous audio. Resolves once LiveKit has switched the
+     * underlying RTCRtpSender's track. Rejects if no publication exists —
+     * caller should fall back to `publishMicrophoneStream` in that case.
+     * supported only for livekit manager
+     */
+    replaceMicrophoneTrack?(track: MediaStreamTrack): Promise<void>;
     /**
      * Publish a camera video stream to the LiveKit room.
      * Can be called after connection to enable vision.
@@ -71,6 +80,13 @@ export type StreamingManager<T extends CreateStreamOptions | CreateSessionV2Opti
      * Whether the current stream segment can be interrupted by the user
      */
     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).
+     */
+    interrupt(type: Interrupt['type']): void;
     /**
      * 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/manager.d.ts

@@ -203,6 +203,16 @@ export interface AgentManager {
      * supported only for livekit manager
      */
     unpublishMicrophoneStream?: () => Promise<void>;
+    /**
+     * Replace the live microphone track on the current publication without
+     * unpublishing. Preserves the LiveKit publication (SSRC, trackSid) so the
+     * server sees continuous audio across mic device swaps. Resolves once
+     * LiveKit has switched the underlying RTCRtpSender's track.
+     * Rejects if there is no active publication — callers should fall back to
+     * `publishMicrophoneStream` in that case.
+     * Supported only for the LiveKit streaming manager.
+     */
+    replaceMicrophoneTrack?: (track: MediaStreamTrack) => Promise<void>;
     /**
      * Publish a camera video stream to the LiveKit room.
      * Can be called after connection to enable vision.

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

@@ -1,7 +1,6 @@
 import { Analytics } from '../../services/analytics/mixpanel';
 import { VideoRTCStatsReport } from '../../services/streaming-manager/stats/report';
 import { Auth } from '../auth';
-import { Interrupt } from '../entities';
 import { ChatProgressCallback } from '../entities/agents/manager';
 import { CreateClipStreamRequest, CreateTalkStreamRequest, SendClipStreamPayload, SendTalkStreamPayload } from './api';
 import { ICreateStreamRequestResponse, IceCandidate, SendStreamPayloadResponse, Status } from './rtc';
@@ -69,7 +68,6 @@ export interface ManagerCallbacks {
         agent_id: string;
     }) => void;
     onStreamReady?: () => void;
-    onInterruptDetected?: (interrupt: Interrupt) => void;
     onToolEvent?: ToolEventCallback;
     onInterruptibleChange?: (interruptible: boolean) => void;
     onFirstAudioDetected?: (metrics: AudioDetectionMetrics) => void;

package/package.json

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

package/dist/src/services/interrupt/index.d.ts

@@ -1,6 +0,0 @@
-import { CreateSessionV2Options, CreateStreamOptions, StreamType } from '../../types';
-import { StreamingManager } from '../streaming-manager';
-
-export declare function validateInterrupt(streamingManager: StreamingManager<CreateStreamOptions> | undefined, streamType: StreamType | undefined, videoId: string | null): void;
-export declare function sendInterrupt(streamingManager: StreamingManager<CreateStreamOptions>, videoId: string): Promise<void>;
-export declare function sendInterruptV2(streamingManager: StreamingManager<CreateSessionV2Options>): Promise<void>;