@d-id/client-sdk 1.1.11 → 1.1.12

package/dist/livekit-manager-DZ_BAT5P.js

@@ -0,0 +1,123 @@
+import { c as x, a as N, S as O, C as g, b as U, d as P, e as V, A as w, f as q, T as J } from "./index-BHt2AhLb.js";
+function Q(u, T, h, i) {
+  const p = x(u, `${T}/v2/agents/${h}`, i);
+  return {
+    async createStream(d) {
+      return p.post("/streams", d);
+    }
+  };
+}
+async function W() {
+  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"
+    );
+  }
+}
+async function H(u, T, h) {
+  var E, K, I;
+  const i = N(h.debug || !1, "LiveKitStreamingManager"), {
+    Room: p,
+    RoomEvent: d,
+    ConnectionState: C,
+    RemoteParticipant: z,
+    RemoteTrack: B
+  } = await W(), { callbacks: e, auth: j, baseURL: F, analytics: M } = h;
+  let a = null, v = !1, y = null, c = null;
+  const L = O.Fluent;
+  a = new p({
+    adaptiveStream: !0,
+    dynacast: !0
+  }), a.on(d.ConnectionStateChanged, (n) => {
+    var t, o, r, s, S;
+    switch (i("Connection state changed:", n), n) {
+      case C.Connecting:
+        (t = e.onConnectionStateChange) == null || t.call(e, g.Connecting);
+        break;
+      case C.Connected:
+        i("LiveKit room connected successfully"), v = !0, (o = e.onConnectionStateChange) == null || o.call(e, g.Connected);
+        break;
+      case C.Disconnected:
+        i("LiveKit room disconnected"), v = !1, (r = e.onConnectionStateChange) == null || r.call(e, g.Disconnected);
+        break;
+      case C.Reconnecting:
+        i("LiveKit room reconnecting..."), (s = e.onConnectionStateChange) == null || s.call(e, g.Connecting);
+        break;
+      case C.SignalReconnecting:
+        i("LiveKit room signal reconnecting..."), (S = e.onConnectionStateChange) == null || S.call(e, g.Connecting);
+        break;
+    }
+  }), a.on(d.ConnectionQualityChanged, (n, t) => {
+    var o;
+    t != null && t.isLocal && n === "poor" && (i("Connection quality is poor"), (o = e.onConnectivityStateChange) == null || o.call(e, U.Weak));
+  }), a.on(d.ParticipantConnected, (n) => {
+    i("Participant connected:", n.identity);
+  }), a.on(d.TrackSubscribed, (n, t, o) => {
+    var r, s;
+    i(`Track subscribed: ${n.kind} from ${o.identity}`), c ? c.addTrack(n.mediaStreamTrack) : c = new MediaStream([n.mediaStreamTrack]), (r = e.onSrcObjectReady) == null || r.call(e, c), n.kind === "video" && ((s = e.onVideoStateChange) == null || s.call(e, P.Start));
+  }), a.on(d.TrackUnsubscribed, (n, t, o) => {
+    var r;
+    i(`Track unsubscribed: ${n.kind} from ${o.identity}`), n.kind === "video" && ((r = e.onVideoStateChange) == null || r.call(e, P.Stop));
+  }), a.on(d.DataReceived, (n, t) => {
+    var r, s, S, D, $;
+    const o = new TextDecoder().decode(n);
+    i("Data received:", o);
+    try {
+      const m = JSON.parse(o);
+      m.subject === V.StreamStarted && ((r = m.metadata) != null && r.videoId) ? (y = m.metadata.videoId, (s = e.onVideoIdChange) == null || s.call(e, y), (S = e.onAgentActivityStateChange) == null || S.call(e, w.Talking)) : m.subject === V.StreamDone && (y = null, (D = e.onVideoIdChange) == null || D.call(e, y), ($ = e.onAgentActivityStateChange) == null || $.call(e, w.Idle));
+    } catch (m) {
+      i("Failed to parse data channel message:", m);
+    }
+  }), (E = e.onConnectionStateChange) == null || E.call(e, g.New);
+  const _ = Q(j, F || q, u, e.onError);
+  let f, A;
+  try {
+    const n = await _.createStream({
+      transport: J.Livekit
+    }), { agent_id: t, session_id: o, session_token: r, session_url: s } = n;
+    f = t, A = o, await a.connect(s, r), i("LiveKit room joined successfully");
+  } catch (n) {
+    throw i("Failed to connect to LiveKit room:", n), (K = e.onConnectionStateChange) == null || K.call(e, g.Fail), (I = e.onError) == null || I.call(e, n, { streamId: "" }), n;
+  }
+  M.enrich({
+    "stream-type": L
+  });
+  async function R(n) {
+    var t, o;
+    if (!v || !a) {
+      i("Room is not connected for sending messages"), (t = e.onError) == null || t.call(e, new Error("Room is not connected for sending messages"), {
+        streamId: f
+      });
+      return;
+    }
+    try {
+      await a.localParticipant.publishData(new TextEncoder().encode(n), { reliable: !0 });
+    } catch (r) {
+      i("Error sending data channel message", r), (o = e.onError) == null || o.call(e, r, { streamId: f });
+    }
+  }
+  return {
+    speak(n) {
+      const t = JSON.stringify({
+        type: "speak",
+        payload: n
+      });
+      return R(t);
+    },
+    async disconnect() {
+      var n, t;
+      a && (await a.disconnect(), a = null), c && (c.getTracks().forEach((o) => o.stop()), c = null), v = !1, (n = e.onConnectionStateChange) == null || n.call(e, g.Completed), (t = e.onAgentActivityStateChange) == null || t.call(e, w.Idle);
+    },
+    sendDataChannelMessage: R,
+    sessionId: A,
+    streamId: f,
+    streamType: L,
+    interruptAvailable: !0,
+    triggersAvailable: !1
+  };
+}
+export {
+  H as createLiveKitStreamingManager
+};

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

@@ -1,5 +1,6 @@
 import { Agent, AgentPayload, Auth, Chat, ChatPayload, ChatResponse, RatingEntity, RatingPayload, STTTokenResponse } from '../types/index';
 import { RequestOptions } from './apiClient';
+
 export declare function createAgentsApi(auth: Auth, host?: string, onError?: (error: Error, errorData: object) => void): {
     create(payload: AgentPayload, options?: RequestOptions): Promise<Agent>;
     getAgents(tag?: string, options?: RequestOptions): Promise<Agent[]>;

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

@@ -1,10 +1,11 @@
 import { Auth } from '../types/auth';
+
 export type RequestOptions = RequestInit & {
     skipErrorHandler?: boolean;
 };
 export declare function createClient(auth: Auth, host?: string, onError?: (error: Error, errorData: object) => void): {
     get<T = any>(url: string, options?: RequestOptions): Promise<T>;
-    post<T_1 = any>(url: string, body?: any, options?: RequestOptions): Promise<T_1>;
-    delete<T_2 = any>(url: string, body?: any, options?: RequestOptions): Promise<T_2>;
-    patch<T_3 = any>(url: string, body?: any, options?: RequestOptions): Promise<T_3>;
+    post<T = any>(url: string, body?: any, options?: RequestOptions): Promise<T>;
+    delete<T = any>(url: string, body?: any, options?: RequestOptions): Promise<T>;
+    patch<T = any>(url: string, body?: any, options?: RequestOptions): Promise<T>;
 };

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

@@ -1,4 +1,5 @@
 import { Auth, CreateDocumentPayload, DocumentData, KnowledgeData, KnowledgePayload, QueryResult, RecordData } from '../types/index';
+
 export declare function createKnowledgeApi(auth: Auth, host?: string, onError?: (error: Error, errorData: object) => void): {
     createKnowledge(payload: KnowledgePayload, options?: RequestInit): Promise<KnowledgeData>;
     getKnowledgeBase(options?: RequestInit): Promise<KnowledgeData[]>;

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

@@ -1,2 +1,3 @@
 import { Auth, RtcApi } from '../../types/index';
+
 export declare function createStreamApi(auth: Auth, host: string, agentId: string, onError?: (error: Error, errorData: object) => void): RtcApi;

package/dist/src/api/streams/streamsApiV2.d.ts

@@ -0,0 +1,5 @@
+import { Auth, CreateStreamV2Options, CreateStreamV2Response } from '../../types';
+
+export declare function createStreamApiV2(auth: Auth, host: string, agentId: string, onError?: (error: Error, errorData: object) => void): {
+    createStream(options: CreateStreamV2Options): Promise<CreateStreamV2Response>;
+};

package/dist/src/auth/get-auth-header.d.ts

@@ -1,3 +1,4 @@
 import { Auth } from '../types/auth';
+
 export declare function getExternalId(): string;
 export declare function getAuthHeader(auth: Auth): string;

package/dist/src/errors/chat/chat-creation-failed.d.ts

@@ -1,5 +1,6 @@
 import { ChatMode } from '../../types';
 import { BaseError } from '../base-error';
+
 export declare class ChatCreationFailed extends BaseError {
     constructor(mode: ChatMode, persistent: boolean);
 }

package/dist/src/errors/chat/chat-mode-downgraded.d.ts

@@ -1,5 +1,6 @@
 import { ChatMode } from '../../types';
 import { BaseError } from '../base-error';
+
 export declare class ChatModeDowngraded extends BaseError {
     constructor(mode: ChatMode);
 }

package/dist/src/errors/validation-error.d.ts

@@ -1,4 +1,5 @@
 import { BaseError } from './base-error';
+
 export declare class ValidationError extends BaseError {
     key?: string;
     constructor(message: string, key?: string);

package/dist/src/errors/ws-error.d.ts

@@ -1,4 +1,5 @@
 import { BaseError } from './base-error';
+
 export declare class WsError extends BaseError {
     constructor(message: string);
 }

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

@@ -1,6 +1,7 @@
 import { StreamingManager } from '../streaming-manager';
 import { Agent, AgentManagerOptions, AgentsAPI, Chat, CreateStreamOptions } from '../../types';
 import { Analytics } from '../analytics/mixpanel';
+
 type ConnectToManagerOptions = AgentManagerOptions & {
     callbacks: AgentManagerOptions['callbacks'] & {
         onVideoIdChange?: (videoId: string | null) => void;

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

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

package/dist/src/services/agent-manager/index.d.ts

@@ -1,6 +1,7 @@
 import { Agent, AgentManager, AgentManagerOptions, Auth, Chat, ChatMode, CreateStreamOptions, Message } from '../../types';
 import { SocketManager } from '../socket-manager';
 import { StreamingManager } from '../streaming-manager';
+
 export interface AgentManagerItems {
     chat?: Chat;
     streamingManager?: StreamingManager<CreateStreamOptions>;

package/dist/src/services/agent-manager/index.test.d.ts

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

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

@@ -3,6 +3,7 @@ export interface AnalyticsOptions {
     agentId: string;
     isEnabled?: boolean;
     distinctId?: string;
+    mixpanelAdditionalProperties?: Record<string, any>;
 }
 export interface Analytics {
     token: string;

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

@@ -1,6 +1,6 @@
-import type { Agent, AgentsAPI, Chat } from '../../types';
-import { ChatMode } from '../../types';
+import { Agent, AgentsAPI, Chat, ChatMode } from '../../types';
 import { Analytics } from '../analytics/mixpanel';
+
 export declare function getRequestHeaders(chatMode?: ChatMode): Record<string, Record<string, string>>;
 export declare function createChat(agent: Agent, agentsApi: AgentsAPI, analytics: Analytics, chatMode?: ChatMode, persist?: boolean, chat?: Chat): Promise<{
     chat: Chat | undefined;

package/dist/src/services/chat/intial-messages.d.ts

@@ -1,2 +1,3 @@
 import { Message } from '../../types';
+
 export declare function getInitialMessages(initialMessages?: Message[]): Message[];

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

@@ -1,4 +1,5 @@
 import { 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>;

package/dist/src/services/socket-manager/index.d.ts

@@ -1,5 +1,6 @@
 import { ChatProgressCallback } from '../../types';
 import { Auth } from '../../types/auth';
+
 export interface SocketManager {
     socket?: WebSocket;
     disconnect: () => void;

package/dist/src/services/socket-manager/message-queue.d.ts

@@ -1,6 +1,7 @@
 import { Agent, AgentManagerOptions, ChatProgress, StreamEvents } from '../../types';
 import { AgentManagerItems } from '../agent-manager';
 import { Analytics } from '../analytics/mixpanel';
+
 export interface ChatEventQueue {
     [sequence: number]: string;
     answer?: string;

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

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

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

@@ -0,0 +1,5 @@
+/**
+ * Business flow tests for streaming manager
+ * Tests critical end-to-end workflows and configurations
+ */
+export {};

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

@@ -0,0 +1,43 @@
+import { CreateStreamOptions, PayloadType, StreamType } from '../../types';
+
+export declare const createStreamingLogger: (debug: boolean, prefix: string) => (message: string, extra?: any) => false | void;
+/**
+ * Shared type for all streaming managers (LiveKit, WebRTC, etc.)
+ * This type represents the return value of any streaming manager implementation
+ */
+export type StreamingManager<T extends CreateStreamOptions> = {
+    /**
+     * Method to send request to server to get clip or talk depending on payload
+     * @param payload The payload to send to the streaming service
+     */
+    speak(payload: PayloadType<T>): Promise<any>;
+    /**
+     * Method to close the streaming connection
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Method to send data channel messages to the server
+     * @param payload The message payload to send
+     */
+    sendDataChannelMessage(payload: string): void;
+    /**
+     * Session identifier information, should be returned in the body of all streaming requests
+     */
+    sessionId: string;
+    /**
+     * Id of current streaming session
+     */
+    streamId: string;
+    /**
+     * Type of streaming implementation being used
+     */
+    streamType: StreamType;
+    /**
+     * Whether interrupt functionality is available for this stream
+     */
+    interruptAvailable: boolean;
+    /**
+     * Whether triggers functionality is available for this stream
+     */
+    triggersAvailable: boolean;
+};

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

@@ -0,0 +1,5 @@
+/**
+ * Disconnect and cleanup tests for streaming manager
+ * Tests disconnection workflows, cleanup, and error handling
+ */
+export {};

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

@@ -0,0 +1,5 @@
+/**
+ * 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/factory.d.ts

@@ -0,0 +1,3 @@
+import { Agent, CreateStreamOptions, StreamingManagerOptions } from '../../types';
+
+export declare function createStreamingManager<T extends CreateStreamOptions>(agent: Agent, streamOptions: T, options: StreamingManagerOptions): Promise<import('./common').StreamingManager<T>>;

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

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

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

@@ -1,27 +1,4 @@
-import { CreateStreamOptions, PayloadType, StreamType, StreamingManagerOptions } from '../../types/index';
-export declare function createStreamingManager<T extends CreateStreamOptions>(agentId: string, agent: T, { debug, callbacks, auth, baseURL, analytics }: StreamingManagerOptions): Promise<{
-    /**
-     * Method to send request to server to get clip or talk depend on you payload
-     * @param payload
-     */
-    speak(payload: PayloadType<T>): Promise<import('../../types/index').SendStreamPayloadResponse>;
-    /**
-     * Method to close RTC connection
-     */
-    disconnect(): Promise<void>;
-    /**
-     * Method to send data channel messages to the server
-     */
-    sendDataChannelMessage(payload: string): void;
-    /**
-     * Session identifier information, should be returned in the body of all streaming requests
-     */
-    sessionId: string;
-    /**
-     * Id of current RTC stream
-     */
-    streamId: string;
-    streamType: StreamType;
-    interruptAvailable: boolean | undefined;
-}>;
-export type StreamingManager<T extends CreateStreamOptions> = Awaited<ReturnType<typeof createStreamingManager<T>>>;
+export { createStreamingManager } from './factory';
+export type { StreamingManager } from './common';
+export type { LiveKitStreamingManager } from './livekit-manager';
+export * from './webrtc-manager';

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

@@ -0,0 +1,5 @@
+import { CreateStreamOptions, StreamingManagerOptions } from '../../types';
+import { StreamingManager } from './common';
+
+export declare function createLiveKitStreamingManager<T extends CreateStreamOptions>(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 @@
-/// <reference types="node" />
 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;

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

@@ -1,4 +1,5 @@
 import { AnalyticsRTCStatsReport, SlimRTCStatsReport } from '../../../types';
+
 export interface VideoRTCStatsReport {
     webRTCStats: {
         anomalies: AnalyticsRTCStatsReport[];

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

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

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

@@ -0,0 +1,12 @@
+import { ConnectionState, CreateStreamOptions, StreamEvents, StreamingManagerOptions } from '../../types';
+import { createStreamingLogger, StreamingManager } from './common';
+
+type DataChannelPayload = string | Record<string, unknown>;
+export declare function mapConnectionState(state: RTCIceConnectionState): ConnectionState;
+export declare const createParseDataChannelMessage: (log: ReturnType<typeof createStreamingLogger>) => (message: string) => {
+    subject: StreamEvents;
+    data: DataChannelPayload;
+};
+export declare function createWebRTCStreamingManager<T extends CreateStreamOptions>(agentId: string, streamOptions: T, { debug, callbacks, auth, baseURL, analytics }: StreamingManagerOptions): Promise<StreamingManager<T>>;
+export type WebRTCStreamingManager<T extends CreateStreamOptions> = StreamingManager<T>;
+export {};

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

@@ -0,0 +1,5 @@
+/**
+ * Utility function tests for streaming manager
+ * Tests helper functions like mapConnectionState and parseDataChannelMessage
+ */
+export {};

package/dist/src/test-utils/factories/agent-manager.factory.d.ts

@@ -0,0 +1,3 @@
+import { AgentManagerOptions } from '../../types';
+
+export declare const AgentManagerOptionsFactory: import('rosie').IFactory<AgentManagerOptions>;

package/dist/src/test-utils/factories/agent.factory.d.ts

@@ -0,0 +1,4 @@
+import { Agent } from '../../types';
+
+export declare const AgentFactory: import('rosie').IFactory<Agent>;
+export declare const StreamingAgentFactory: import('rosie').IFactory<any>;

package/dist/src/test-utils/factories/agents-api.factory.d.ts

@@ -0,0 +1 @@
+export declare const AgentsApiFactory: import('rosie').IFactory<any>;

package/dist/src/test-utils/factories/analytics.factory.d.ts

@@ -0,0 +1 @@
+export declare const AnalyticsFactory: import('rosie').IFactory<any>;

package/dist/src/test-utils/factories/chat.factory.d.ts

@@ -0,0 +1 @@
+export declare const ChatFactory: import('rosie').IFactory<any>;

package/dist/src/test-utils/factories/index.d.ts

@@ -0,0 +1,8 @@
+export { AgentManagerOptionsFactory } from './agent-manager.factory';
+export { AgentFactory, StreamingAgentFactory } from './agent.factory';
+export { AgentsApiFactory } from './agents-api.factory';
+export { AnalyticsFactory } from './analytics.factory';
+export { ChatFactory } from './chat.factory';
+export { SocketManagerFactory } from './socket-manager.factory';
+export { StreamApiFactory } from './stream-api.factory';
+export { StreamingManagerFactory, StreamingManagerOptionsFactory } from './streaming-manager.factory';

package/dist/src/test-utils/factories/socket-manager.factory.d.ts

@@ -0,0 +1 @@
+export declare const SocketManagerFactory: import('rosie').IFactory<any>;

package/dist/src/test-utils/factories/stream-api.factory.d.ts

@@ -0,0 +1 @@
+export declare const StreamApiFactory: import('rosie').IFactory<any>;

package/dist/src/test-utils/factories/streaming-manager.factory.d.ts

@@ -0,0 +1,4 @@
+import { StreamingManagerOptions } from '../../types';
+
+export declare const StreamingManagerFactory: import('rosie').IFactory<any>;
+export declare const StreamingManagerOptionsFactory: import('rosie').IFactory<StreamingManagerOptions>;

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

@@ -2,6 +2,7 @@ import { Chat, ChatPayload, ChatResponse } from './chat';
 import { Knowledge } from './knowledge';
 import { LLM } from './llm';
 import { Presenter } from './presenter';
+
 export declare enum UserPlan {
     TRIAL = "trial",
     BASIC = "basic",

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

@@ -2,9 +2,10 @@ import { STTTokenResponse } from '../..';
 import { Auth } from '../../auth';
 import { AgentActivityState, CompatibilityMode, ConnectionState, ConnectivityState, SendStreamPayloadResponse, StreamEvents, StreamType, StreamingState } from '../../stream';
 import { SupportedStreamScript } from '../../stream-script';
-import type { ManagerCallbacks as StreamManagerCallbacks } from '../../stream/stream';
+import { ManagerCallbacks as StreamManagerCallbacks } from '../../stream/stream';
 import { Agent } from './agent';
 import { ChatMode, ChatResponse, Interrupt, Message, RatingEntity } from './chat';
+
 /**
  * Types of events provided in Chat Progress Callback
  */
@@ -132,6 +133,7 @@ export interface AgentManagerOptions {
     debug?: boolean;
     enableAnalitics?: boolean;
     mixpanelKey?: string;
+    mixpanelAdditionalProperties?: Record<string, any>;
     /**
      * Unique ID of agent user used in analytics. Pass it to override the default way to get distinctId
      */
@@ -154,6 +156,10 @@ export interface AgentManager {
      * Get if the stream supports interrupt
      */
     getIsInterruptAvailable: () => boolean;
+    /**
+     * Get if the stream supports triggers
+     */
+    getIsTriggersAvailable: () => boolean;
     /**
      * Array of starter messages that will be sent to the agent when the chat starts
      */

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

@@ -1,7 +1,8 @@
 import { ExtendedTextToSpeechProviders } from '../../voice/tts';
 import { Rect } from '../../face-rect';
-export type videoType = 'talk' | 'clip';
-export type Presenter = TalkPresenter | ClipPresenter;
+
+export type videoType = 'talk' | 'clip' | 'expressive';
+export type Presenter = TalkPresenter | ClipPresenter | ExpresivePresenter;
 export interface BasePresenter {
     type: videoType;
     voice?: ExtendedTextToSpeechProviders & {
@@ -24,3 +25,6 @@ export interface ClipPresenter extends BasePresenter {
     presenter_id: string;
     is_greenscreen?: boolean;
 }
+export interface ExpresivePresenter extends BasePresenter {
+    type: 'expressive';
+}

package/dist/src/types/entities/knowledge/document.d.ts

@@ -1,4 +1,5 @@
 import { KnowledgeType } from './knowledge';
+
 export declare enum Subject {
     KnowledgeProcessing = "knowledge/processing",
     KnowledgeIndexing = "knowledge/indexing",

package/dist/src/types/entities/knowledge/record.d.ts

@@ -1,4 +1,5 @@
 import { KnowledgeType } from './knowledge';
+
 export interface RecordData {
     created_at: string;
     modified_at: string;

package/dist/src/types/entities/video.d.ts

@@ -1,5 +1,6 @@
 export declare enum VideoType {
     Clip = "clip",
-    Talk = "talk"
+    Talk = "talk",
+    Expressive = "expressive"
 }
 export declare const mapVideoType: (type: string) => VideoType;

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

@@ -1,5 +1,6 @@
 import { StickyRequest, StreamScript } from '../..';
 import { CompatibilityMode } from '../stream';
+
 interface Logo {
     /**
      * https url to an ARGB jpg/png image, a default logo is used otherwise

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

@@ -1,5 +1,6 @@
 import { StreamScript } from '../..';
 import { CompatibilityMode } from '../stream';
+
 export interface CreateTalkStreamRequest {
     driver_url?: string;
     face?: {

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

@@ -1,3 +1,4 @@
 export * from './api';
 export * from './rtc';
 export * from './stream';
+export * from './streams-v2';

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

@@ -35,6 +35,7 @@ export interface ICreateStreamRequestResponse extends StickyRequest {
     ice_servers: IceServer[];
     fluent?: boolean;
     interrupt_enabled?: boolean;
+    triggers_enabled?: boolean;
 }
 export interface IceCandidate {
     /**

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 { CreateClipStreamRequest, CreateTalkStreamRequest, SendClipStreamPayload, SendTalkStreamPayload } from './api';
 import { ICreateStreamRequestResponse, IceCandidate, SendStreamPayloadResponse, Status } from './rtc';
+
 export type CompatibilityMode = 'on' | 'off' | 'auto';
 export declare enum StreamingState {
     Start = "START",

package/dist/src/types/stream/streams-v2.d.ts

@@ -0,0 +1,12 @@
+export declare enum Transport {
+    Livekit = "livekit"
+}
+export interface CreateStreamV2Options {
+    transport: Transport.Livekit;
+}
+export interface CreateStreamV2Response {
+    agent_id: 'string';
+    session_id: 'string';
+    session_url: 'string';
+    session_token: 'string';
+}

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

@@ -1,5 +1,6 @@
 import { Message } from './entities';
 import { StreamTextToSpeechProviders } from './voice/tts';
+
 export type StreamScriptType = 'text' | 'audio';
 export interface BaseStreamScript {
     type: StreamScriptType;