@d-id/client-sdk 1.0.29-beta.55 → 1.1.0-beta.10

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

@@ -1,10 +1,17 @@
-import { Agent, AgentPayload, Auth, Chat, ChatPayload, ChatResponse } from '../types/index';
-export declare function createAgentsApi(auth: Auth, host?: string): {
-    create(payload: AgentPayload, options?: RequestInit): Promise<Agent>;
-    getAgents(tag?: string, options?: RequestInit): Promise<Agent[]>;
-    getById(id: string, options?: RequestInit): Promise<Agent>;
-    delete(id: string, options?: RequestInit): Promise<any>;
-    update(id: string, payload: AgentPayload, options?: RequestInit): Promise<Agent>;
-    newChat(agentId: string, options?: RequestInit): Promise<Chat>;
-    chat(agentId: string, chatId: string, payload: ChatPayload, options?: RequestInit): Promise<ChatResponse>;
+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[]>;
+    getById(id: string, options?: RequestOptions): Promise<Agent>;
+    delete(id: string, options?: RequestOptions): Promise<any>;
+    update(id: string, payload: AgentPayload, options?: RequestOptions): Promise<Agent>;
+    newChat(agentId: string, payload: {
+        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>;
+    getSTTToken(agentId: string, options?: RequestOptions): Promise<STTTokenResponse>;
 };

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

@@ -0,0 +1,10 @@
+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>;
+};

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

@@ -1,5 +1,5 @@
 import { Auth, CreateDocumentPayload, DocumentData, KnowledgeData, KnowledgePayload, QueryResult, RecordData } from '../types/index';
-export declare function createKnowledgeApi(auth: Auth, host?: string): {
+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[]>;
     getKnowledge(knowledgeId: string, options?: RequestInit): Promise<KnowledgeData>;

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

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

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

@@ -0,0 +1,2 @@
+export * from './clipStream';
+export * from './talkStream';

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

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

package/dist/src/auth/{getAuthHeader.d.ts → get-auth-header.d.ts}

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

package/dist/src/config/consts.d.ts

@@ -0,0 +1,2 @@
+export declare const CONNECTION_RETRY_TIMEOUT_MS: number;
+export declare const PLAYGROUND_HEADER = "X-Playground-Chat";

package/dist/src/{environment.d.ts → config/environment.d.ts}

@@ -2,5 +2,4 @@ export declare const nodeEnv: string;
 export declare const didApiUrl: string;
 export declare const didSocketApiUrl: string;
 export declare const mixpanelKey: string;
-export declare const clientKey: string;
 export declare const agentId: string;

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

@@ -0,0 +1,12 @@
+interface BaseErrorParams {
+    kind: string;
+    description?: string;
+    error?: Error;
+}
+export declare class BaseError extends Error {
+    kind: string;
+    description?: string;
+    error?: Error;
+    constructor({ kind, description, error }: BaseErrorParams);
+}
+export {};

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

@@ -0,0 +1,5 @@
+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

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

package/dist/src/errors/index.d.ts

@@ -0,0 +1,4 @@
+export * from './chat/chat-creation-failed';
+export * from './chat/chat-mode-downgraded';
+export * from './validation-error';
+export * from './ws-error';

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

@@ -0,0 +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

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

package/dist/src/index.d.ts

@@ -1,2 +1,3 @@
-export * from './createAgentManager';
-export * from './types/index';
+export * from './errors';
+export * from './services/agent-manager';
+export * from './types';

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

@@ -0,0 +1,7 @@
+import { StreamingManager } from '../streaming-manager';
+import { Agent, AgentManagerOptions, AgentsAPI, Chat, CreateStreamOptions } from '../../types';
+import { Analytics } from '../analytics/mixpanel';
+export declare function initializeStreamAndChat(agent: Agent, options: AgentManagerOptions, agentsApi: AgentsAPI, analytics: Analytics, chat?: Chat): Promise<{
+    chat?: Chat;
+    streamingManager?: StreamingManager<CreateStreamOptions>;
+}>;

package/dist/src/{createAgentManager.d.ts → services/agent-manager/index.d.ts}

@@ -1,6 +1,13 @@
-import { Agent, AgentManager, AgentManagerOptions } from './types/index';
-import { Auth } from '.';
-export declare function getAgent(agentId: string, auth: Auth, baseURL?: string): Promise<Agent>;
+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>;
+    socketManager?: SocketManager;
+    messages: Message[];
+    chatMode: ChatMode;
+}
 /**
  * Creates a new Agent Manager instance for interacting with an agent, chat, and related connections.
  *
@@ -13,4 +20,5 @@ export declare function getAgent(agentId: string, auth: Auth, baseURL?: string):
  * @example
  * const agentManager = await createAgentManager('id-agent123', { auth: { type: 'key', clientKey: '123', externalId: '123' } });
  */
-export declare function createAgentManager(agent: string | Agent, options: AgentManagerOptions): Promise<AgentManager>;
+export declare function createAgentManager(agent: string, options: AgentManagerOptions): Promise<AgentManager>;
+export declare function getAgent(agentId: string, auth: Auth, baseURL?: string): Promise<Agent>;

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

@@ -0,0 +1,21 @@
+import { Agent } from '../../types';
+export interface AnalyticsOptions {
+    token: string;
+    agent: Agent;
+    isEnabled?: boolean;
+    distinctId?: string;
+}
+export interface Analytics {
+    token: string;
+    distinct_id?: string;
+    isEnabled: boolean;
+    chatId?: string;
+    agentId: string;
+    owner_id: string;
+    getRandom(): string;
+    track(event: string, props?: Record<string, any>): Promise<any>;
+    linkTrack(mixpanelEvent: string, props: Record<string, any>, event: string, dependencies: string[]): any;
+    enrich(props: Record<string, any>): void;
+    additionalProperties: Record<string, any>;
+}
+export declare function initializeAnalytics(config: AnalyticsOptions): Analytics;

package/dist/src/services/analytics/timestamp-tracker.d.ts

@@ -0,0 +1,5 @@
+export declare const timestampTracker: {
+    reset: () => number;
+    update: () => number;
+    get: (delta?: boolean) => number;
+};

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

@@ -0,0 +1,7 @@
+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;
+    chatMode: ChatMode | undefined;
+}>;

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

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

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

@@ -0,0 +1,11 @@
+import { ChatProgressCallback } from '../../types';
+import { Auth } from '../../types/auth';
+export interface SocketManager {
+    socket?: WebSocket;
+    disconnect: () => void;
+    subscribeToEvents: (data: any) => void;
+}
+export declare function createSocketManager(auth: Auth, host: string, callbacks: {
+    onMessage: ChatProgressCallback;
+    onError?: (error: Error) => void;
+}): Promise<SocketManager>;

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

@@ -0,0 +1,11 @@
+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;
+}
+export declare function createMessageEventQueue(analytics: Analytics, items: AgentManagerItems, options: AgentManagerOptions, agentEntity: Agent, onStreamDone: () => void): {
+    clearQueue: () => {};
+    onMessage: (event: ChatProgress | StreamEvents, data: any) => void;
+};

package/dist/src/{createStreamingManager.d.ts → services/streaming-manager/index.d.ts}

@@ -1,10 +1,10 @@
-import { CreateStreamOptions, PayloadType, StreamingManagerOptions } from './types/index';
-export declare function createStreamingManager<T extends CreateStreamOptions>(agent: T, { debug, callbacks, auth, baseURL }: StreamingManagerOptions): Promise<{
+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>;
+    speak(payload: PayloadType<T>): Promise<import('../../types/index').SendStreamPayloadResponse>;
     /**
      * Method to close RTC connection
      */
@@ -17,5 +17,6 @@ export declare function createStreamingManager<T extends CreateStreamOptions>(ag
      * Id of current RTC stream
      */
     streamId: string;
+    streamType: StreamType;
 }>;
 export type StreamingManager<T extends CreateStreamOptions> = Awaited<ReturnType<typeof createStreamingManager<T>>>;

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

@@ -0,0 +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

@@ -0,0 +1,17 @@
+import { AnalyticsRTCStatsReport, SlimRTCStatsReport } from '../../../types';
+export interface VideoRTCStatsReport {
+    webRTCStats: {
+        anomalies: AnalyticsRTCStatsReport[];
+        aggregateReport: AnalyticsRTCStatsReport;
+        minRtt: number;
+        maxRtt: number;
+        avgRtt: number;
+        minJitterDelayInInterval: number;
+        maxJitterDelayInInterval: number;
+        avgJitterDelayInInterval: number;
+    };
+    codec: string;
+    resolution: string;
+}
+export declare function formatStats(stats: RTCStatsReport): SlimRTCStatsReport;
+export declare function createVideoStatsReport(stats: SlimRTCStatsReport[], interval: number, previousStats?: SlimRTCStatsReport): VideoRTCStatsReport;

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

@@ -19,6 +19,14 @@ export declare enum PlanGroup {
     LAUNCH = "deid-api-launch",
     SCALE = "deid-api-scale"
 }
+export declare enum AgentStatus {
+    Created = "created",
+    Started = "started",
+    Done = "done",
+    Error = "error",
+    Rejected = "rejected",
+    Ready = "ready"
+}
 export interface Agent {
     id: string;
     username?: string;
@@ -36,8 +44,10 @@ export interface Agent {
     preview_name?: string;
     preview_description?: string;
     preview_thumbnail?: string;
+    logo?: string;
     preview_url?: string;
-    idle_video?: string;
+    owner_id?: string;
+    status?: AgentStatus;
 }
 export type AgentPayload = Omit<Agent, 'type' | 'created_at' | 'modified_at' | 'id' | 'owner_id' | 'metadata' | 'idle_video_url'>;
 export interface AgentsAPI {
@@ -46,6 +56,8 @@ export interface AgentsAPI {
     getById(id: string, options?: RequestInit): Promise<Agent>;
     delete(id: string, options?: RequestInit): Promise<void>;
     update(id: string, payload: AgentPayload, options?: RequestInit): Promise<Agent>;
-    newChat(agentId: string, options?: RequestInit): Promise<Chat>;
+    newChat(agentId: string, payload: {
+        persist: boolean;
+    }, options?: RequestInit): Promise<Chat>;
     chat(agentId: string, chatId: string, payload: ChatPayload, options?: RequestInit): Promise<ChatResponse>;
 }

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

@@ -15,18 +15,22 @@ export interface RatingEntity {
     score: 1 | -1;
     created_at: string;
     modified_at: string;
+    message_id: string;
 }
-export type RatingPayload = Omit<RatingEntity, 'owner_id' | 'id' | 'created_at' | 'modified_at' | 'created_by' | 'external_id'>;
+export type RatingPayload = Omit<RatingEntity, 'owner_id' | 'id' | 'created_at' | 'modified_at' | 'created_by' | 'external_id' | 'agent_id' | 'chat_id'>;
 export interface Message {
+    id: string;
     role?: 'system' | 'assistant' | 'user' | 'function' | 'tool';
     content: string;
     created_at?: string;
     matches?: ChatResponse['matches'];
+    context?: string;
 }
 export interface ChatPayload {
     messages: Message[];
-    streamId: string;
-    sessionId: string;
+    streamId?: string;
+    sessionId?: string;
+    chatMode?: ChatMode;
 }
 export interface IRetrivalMetadata {
     id: string;
@@ -39,13 +43,16 @@ export interface IRetrivalMetadata {
 export declare enum ChatMode {
     Functional = "Functional",
     TextOnly = "TextOnly",
-    Maintenance = "Maintenance"
+    Maintenance = "Maintenance",
+    Playground = "Playground",
+    DirectPlayback = "DirectPlayback"
 }
 export interface ChatResponse {
     result?: string;
     documentIds?: string[];
     matches?: IRetrivalMetadata[];
     chatMode?: ChatMode;
+    context?: string;
 }
 export interface Chat {
     id: string;
@@ -56,4 +63,5 @@ export interface Chat {
     messages: Message[];
     agent_id__created_at: string;
     agent_id__modified_at: string;
+    chat_mode?: ChatMode;
 }

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

@@ -2,9 +2,11 @@ export type KnowledgeProvider = 'pinecone' | 'redis';
 export interface KnowledgeEmbedder {
     provider: string;
     model: string;
+    is_limited_language?: boolean;
 }
 export interface Knowledge {
     id: string;
     provider: KnowledgeProvider;
+    starter_message?: string[];
     embedder?: KnowledgeEmbedder;
 }

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

@@ -1,19 +1,22 @@
-export type LLMType = 'knowledge' | 'custom';
-export type LLM = KnowledgeLLM | CustomLLM;
-export interface BaseLLM {
-    type: LLMType;
-    instructions?: string;
-}
-export interface KnowledgeLLM extends BaseLLM {
-    type: 'knowledge';
-    knowledge_id: string;
-    store?: string;
+export type LLMProvider = 'openai' | 'custom';
+export type AgentTemplate = 'rag-grounded' | 'rag-ungrounded' | 'assistant';
+export interface PromptCustomization {
+    role?: string;
+    personality?: string;
+    topics_to_avoid?: string[];
+    max_response_length?: number;
+    knowledge_source?: 'base_knowledge' | 'documents' | null;
 }
-export interface CustomLLM extends BaseLLM {
-    type: 'custom';
-    api_key?: string;
-    model?: string;
-    provider?: string;
-    version?: string;
-    config?: string;
+export interface LLM {
+    provider: LLMProvider;
+    prompt_version?: 'v1' | 'v2' | null;
+    instructions?: string;
+    template?: AgentTemplate;
+    prompt_customization?: PromptCustomization;
+    temperature?: number;
+    custom?: {
+        api_key?: string;
+        url?: string;
+        streaming?: boolean;
+    };
 }

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

@@ -1,8 +1,9 @@
-import { SupportedStreamScipt } from '../../StreamScript';
+import { STTTokenResponse } from '../..';
 import { Auth } from '../../auth';
-import { SendStreamPayloadResponse, StreamingState } from '../../stream';
+import { AgentActivityState, CompatibilityMode, ConnectionState, ConnectivityState, SendStreamPayloadResponse, StreamEvents, StreamType, StreamingState } from '../../stream';
+import { SupportedStreamScript } from '../../stream-script';
 import { Agent } from './agent';
-import { ChatResponse, Message, RatingEntity } from './chat';
+import { ChatMode, ChatResponse, Message, RatingEntity } from './chat';
 /**
  * Types of events provided in Chat Progress Callback
  */
@@ -28,20 +29,20 @@ export declare enum ChatProgress {
      */
     Complete = "done"
 }
-export type ChatProgressCallback = (progress: ChatProgress, data: string) => void;
-export type ConnectionStateChangeCallback = (state: RTCIceConnectionState) => void;
+export type ChatProgressCallback = (progress: ChatProgress | StreamEvents, data: any) => void;
+export type ConnectionStateChangeCallback = (state: ConnectionState) => void;
 export type VideoStateChangeCallback = (state: StreamingState, data: any) => void;
 interface ManagerCallbacks {
     /**
      * Optional callback will be triggered each time the RTC connection changes state
      * @param state
      */
-    onConnectionStateChange?(state: RTCIceConnectionState): void;
+    onConnectionStateChange?(state: ConnectionState): void;
     /**
      * Optional callback function that will be triggered each time video events happen
      * @param state
      */
-    onVideoStateChange?(state: StreamingState, data?: any): void;
+    onVideoStateChange?(state: StreamingState): void;
     /**
      * Callback function that will be triggered each time the video stream starts or stops to update html element on webpage
      * Required callback for SDK
@@ -52,22 +53,86 @@ interface ManagerCallbacks {
      */
     onSrcObjectReady(srcObject: MediaStream): void;
     /**
-     * Optional callback function that will be triggered each time any changes happen in the chat
-     * @param progress
+     * Optional callback function that will be triggered each time new message is received
+     * @param messages - array of messages
      */
-    onChatEvents?(progress: ChatProgress, data: any): void;
+    onNewMessage?(messages: Message[], type: 'answer' | 'partial' | 'user'): void;
     /**
-     * Optional callback function that will be triggered when the agent is ready
-     * @param agent - Agent instance you are working with
+     * Optional callback function that will be triggered each time new chat is created
+     * @param chatId - id of the new chat
      */
-    onAgentReady?(agent: Agent): void;
+    onNewChat?(chatId: string): void;
+    /**
+     * Optional callback function that will be triggered each time the chat mode changes
+     * @param mode - ChatMode
+     */
+    onModeChange?(mode: ChatMode): void;
+    /**
+     * Optional callback function that will be triggered each time the user internet connectivity state change by realtime estimated bitrate
+     * @param state - ConnectivityState
+     */
+    onConnectivityStateChange?(state: ConnectivityState): void;
+    /**
+     * Optional callback function that will be triggered on fetch request errors
+     */
+    onError?: (error: Error, errorData?: object) => void;
+    /**
+     * Optional callback function that will be triggered each time the agent activity state changes
+     * @param state - AgentActivityState
+     */
+    onAgentActivityStateChange?(state: AgentActivityState): void;
+}
+interface StreamOptions {
+    /**
+     * Defines the video codec to be used in the stream.
+     * When set to on: VP8 will be used.
+     * When set to off: H264 will be used
+     * When set to auto the codec will be selected according to the browser.
+     * @default auto
+     */
+    compatibilityMode?: CompatibilityMode;
+    /**
+     * Whether to stream wamrup video on the connection.
+     * If set to true, will stream a warmup video when connection is established.
+     * At the end of the warmup video, a message containing "stream/ready" will be sent on the data channel.
+     * @default false
+     */
+    streamWarmup?: boolean;
+    /**
+     * Maximum duration (in seconds) between messages before session times out.
+     * Can only be used with proper permissions
+     * @maximum 300
+     * @example 180
+     */
+    sessionTimeout?: number;
+    /**
+     * Desired stream resolution for the session
+     * @minimum 150
+     * @maximum 1080
+     */
+    outputResolution?: number;
+    /**
+     * Whether to request fluent stream.
+     * @default false
+     */
+    fluent?: boolean;
 }
 export interface AgentManagerOptions {
+    auth: Auth;
     callbacks: ManagerCallbacks;
+    mode: ChatMode;
     baseURL?: string;
     wsURL?: string;
     debug?: boolean;
-    auth: Auth;
+    enableAnalitics?: boolean;
+    mixpanelKey?: string;
+    /**
+     * Unique ID of agent user used in analytics. Pass it to override the default way to get distinctId
+     */
+    distinctId?: string;
+    streamOptions?: StreamOptions;
+    initialMessages?: Message[];
+    persistentChat?: boolean;
 }
 export interface AgentManager {
     /**
@@ -75,35 +140,43 @@ export interface AgentManager {
      * To know more about agents go to https://docs.d-id.com/reference/agents
      */
     agent: Agent;
+    /**
+     * Get the current stream type of the agent
+     */
+    getStreamType: () => StreamType | undefined;
     /**
      * Array of starter messages that will be sent to the agent when the chat starts
      */
     starterMessages: string[];
     /**
-     * Method to be reconnected to chat
-     * Since chat uses an RTC connection to communicate with the agent, it could be dropped and to continue to chat you need to reconnect
+     * Get a token for the Speech to Text service
+     * Only available after a chat has started and the agent has been connected
+     */
+    getSTTToken: () => Promise<STTTokenResponse | undefined>;
+    /**
+     * Method to connect to stream and chat
+     */
+    connect: () => Promise<void>;
+    /**
+     * Method to reconnect to stream and continue chat
      */
     reconnect: () => Promise<void>;
     /**
      * Method to close all connections with agent, stream and web socket
      */
     disconnect: () => Promise<void>;
-    /**
-     * ID of chat you are working on now
-     */
-    chatId: string;
     /**
      * Method to send a chat message to existing chat with the agent
      * @param messages
      */
-    chat: (messages: Message[]) => Promise<ChatResponse>;
+    chat: (userMessage: string) => Promise<ChatResponse>;
     /**
      * Method to rate the answer in chat
      * @param score: 1 | -1 - score of the answer. 1 for positive, -1 for negative
      * @param matches - array of matches that were used to find the answer
      * @param id - id of Rating entity. Leave it empty to create a new, one or pass it to work with the existing one
      */
-    rate: (score: 1 | -1, Message: Message, id?: string) => Promise<RatingEntity>;
+    rate: (messageId: string, score: 1 | -1, rateId?: string) => Promise<RatingEntity>;
     /**
      * Method to delete rating from answer in chat
      * @param id - id of Rating entity.
@@ -113,6 +186,16 @@ export interface AgentManager {
      * Method to make your agent read the text you provide or reproduce sound
      * @param payload
      */
-    speak: (payload: SupportedStreamScipt) => Promise<SendStreamPayloadResponse>;
+    speak: (payload: SupportedStreamScript | string) => Promise<SendStreamPayloadResponse>;
+    /**
+     * Method to change the mode of the chat
+     * @param mode - ChatMode
+     */
+    changeMode(mode: ChatMode): void;
+    /**
+     * Method to enrich analytics properties
+     * @param properties flat json object with properties that will be added to analytics events fired from the sdk
+     */
+    enrichAnalytics: (properties: Record<string, any>) => void;
 }
 export {};