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

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

@@ -1,13 +1,14 @@
 import { STTTokenResponse } from '../..';
 import { Auth } from '../../auth';
-import { AgentActivityState, ClientToolHandler, CompatibilityMode, ConnectionState, ConnectivityState, PublicDataChannelTopic, SendStreamPayloadResponse, StreamEvents, StreamType, StreamingState } from '../../stream';
+import { AgentActivityState, ClientToolHandler, CompatibilityMode, ConnectionState, ConnectivityState, PublicDataChannelTopic, SendStreamPayloadResponse, StreamCreatedInfo, StreamEvents, StreamType, StreamingState } from '../../stream';
 import { SupportedStreamScript } from '../../stream-script';
-import { ManagerCallbacks as StreamManagerCallbacks } from '../../stream/stream';
+import { StreamingManagerCallbacks as StreamManagerCallbacks } from '../../stream/stream';
 import { Agent } from './agent';
 import { ChatMode, ChatResponse, Interrupt, Message, RatingEntity, SubmitFeedbackResponse } from './chat';
 
 /**
  * Types of events provided in Chat Progress Callback
+ * @internal Implementation type; not part of the public SDK surface.
  */
 export declare enum ChatProgress {
     /**
@@ -35,282 +36,861 @@ export declare enum ChatProgress {
      */
     Complete = "done"
 }
+/**
+ * Callback signature for {@link ChatProgress} events emitted internally during a chat exchange.
+ * @internal Implementation type; not part of the public SDK surface.
+ */
 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
-     * @param reason - a `StreamEndReason` when the server ended the stream, otherwise a diagnostic string
-     */
-    onConnectionStateChange?(state: ConnectionState, reason?: string): void;
-    /**
-     * Optional callback function that will be triggered each time video events happen
-     * @param state
-     */
-    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
-     * @param srcObject
+/**
+ * Handlers the SDK calls as the connection, the video stream and the chat change state.
+ *
+ * Pass the object as {@link AgentManagerOptions.callbacks}. Only
+ * {@link AgentManagerCallbacks.onSrcObjectReady | onSrcObjectReady} is required — without it there
+ * is nothing to render the agent into. Every handler is called from the SDK's own event handling,
+ * so keep the work inside short.
+ *
+ * The handlers fall into four groups: the connection
+ * ({@link AgentManagerCallbacks.onConnectionStateChange | onConnectionStateChange},
+ * {@link AgentManagerCallbacks.onConnectivityStateChange | onConnectivityStateChange},
+ * {@link AgentManagerCallbacks.onError | onError}), the video stream
+ * ({@link AgentManagerCallbacks.onSrcObjectReady | onSrcObjectReady},
+ * {@link AgentManagerCallbacks.onStreamCreated | onStreamCreated},
+ * {@link AgentManagerCallbacks.onVideoStateChange | onVideoStateChange},
+ * {@link AgentManagerCallbacks.onAgentActivityStateChange | onAgentActivityStateChange},
+ * {@link AgentManagerCallbacks.onInterruptibleChange | onInterruptibleChange}), the chat
+ * ({@link AgentManagerCallbacks.onNewChat | onNewChat}, {@link AgentManagerCallbacks.onNewMessage | onNewMessage},
+ * {@link AgentManagerCallbacks.onModeChange | onModeChange}) and client tools
+ * ({@link AgentManagerCallbacks.onToolEvent | onToolEvent},
+ * {@link AgentManagerCallbacks.onRunningToolCallsChange | onRunningToolCallsChange}). A handler that
+ * lives outside the object can be typed with an indexed access such as
+ * `AgentManagerCallbacks['onNewMessage']`.
+ *
+ * @category Callbacks & Events
+ */
+export interface AgentManagerCallbacks {
+    /**
+     * Called every time the connection to the agent's stream changes state.
+     *
+     * Triggered by {@link AgentManager.connect | connect()},
+     * {@link AgentManager.reconnect | reconnect()} and
+     * {@link AgentManager.disconnect | disconnect()}.
+     * {@link ConnectionState.Connected | 'connected'} is the point at which
+     * {@link AgentManager.chat | chat()} and {@link AgentManager.speak | speak()} can be called.
+     *
+     * @param state - The state just reached: one of `new`, `connecting`, `connected`, `completed`,
+     * `disconnecting`, `disconnected`, `closed` or `fail`. See {@link ConnectionState}.
+     * @param reason - Why that state was reached. On `disconnected` it is a
+     * {@link StreamEndReason} value when the server ended the stream on purpose, which is how you
+     * tell a deliberate end from a dropped connection. Talks (V2) and Clips (V3) agents report
+     * only `ok`, `unknown_error`, `network_issue` and `inactivity`; `message_limit`, `time_limit`
+     * and `ended_by_agent` come from Expressive (V4) agents. A close reason the SDK does not
+     * recognise is forwarded as-is, so compare `reason` against the enum rather than parsing it;
+     * any other value is an opaque transport diagnostic.
+     * {@link AgentManager.reconnect | reconnect()} still works after a deliberate end; it starts a
+     * new stream rather than resuming the old one.
      * @example
-     * const videoRef = useRef<HTMLVideoElement>(null);
-     * onSrcObjectReady(value) { videoRef.current.srcObject = value }
-     */
-    onSrcObjectReady(srcObject: MediaStream): void;
-    /**
-     * Optional callback function that will be triggered each time new message is received
-     * @param messages - array of messages
-     */
-    onNewMessage?(messages: Message[], type: 'answer' | 'partial' | 'user'): void;
-    /**
-     * Optional callback function that will be triggered each time new chat is created
-     * @param chatId - id of the new chat
-     */
-    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;
-    /**
-     * Optional callback function that will be triggered each time a new stream is created
-     * @param stream - object containing stream_id, session_id and agent_id
-     */
-    onStreamCreated?: StreamManagerCallbacks['onStreamCreated'];
-    /**
-     * Optional callback function that will be triggered when tool-call events occur during the call
-     * (tool-call/started, tool-call/done, tool-call/error).
-     * The payload shape is discriminated by the event argument.
+     * ```ts
+     * onConnectionStateChange(state, reason) {
+     *     console.log('onConnectionStateChange(): ', state, reason);
+     *
+     *     if (state === 'connected') {
+     *         console.log("I'm ready to go!");
+     *     }
+     * }
+     * ```
+     */
+    onConnectionStateChange?: (state: ConnectionState, reason?: string) => void;
+    /**
+     * Called when the streamed video starts and stops, so the video element can switch source.
+     *
+     * Triggered by {@link AgentManager.chat | chat()} and {@link AgentManager.speak | speak()}. On
+     * `STOP` point the element at the agent's idle video ({@link Agent.idle_video}); on `START` put
+     * the stream handed to {@link AgentManagerCallbacks.onSrcObjectReady | onSrcObjectReady} back
+     * on it.
+     *
+     * @param state - {@link StreamingState.Start | START} while the agent is speaking,
+     * {@link StreamingState.Stop | STOP} once it has finished.
+     * @example
+     * ```ts
+     * onVideoStateChange(state) {
+     *     console.log('onVideoStateChange(): ', state);
+     *
+     *     if (state === 'STOP') {
+     *         videoElement.srcObject = undefined;
+     *         videoElement.src = agentManager.agent.idle_video ?? '';
+     *     } else {
+     *         videoElement.src = '';
+     *         videoElement.srcObject = srcObject;
+     *     }
+     * }
+     * ```
+     */
+    onVideoStateChange?: (state: StreamingState) => void;
+    /**
+     * Called with the media stream carrying the agent's video and audio. Required.
+     *
+     * This is the one callback the SDK cannot work without: assign the value to the `srcObject` of
+     * your `<video>` element, and keep a reference to it, because
+     * {@link AgentManagerCallbacks.onVideoStateChange | onVideoStateChange} has to put it back
+     * after the idle video has been shown. Triggered by
+     * {@link AgentManager.connect | connect()}, {@link AgentManager.reconnect | reconnect()} and
+     * {@link AgentManager.disconnect | disconnect()}.
+     *
+     * @param srcObject - The live media stream to render.
+     * @example
+     * ```ts
+     * let srcObject;
+     *
+     * const callbacks = {
+     *     onSrcObjectReady(value) {
+     *         videoElement.srcObject = value;
+     *         srcObject = value;
+     *     },
+     * };
+     * ```
+     */
+    onSrcObjectReady: (srcObject: MediaStream) => void;
+    /**
+     * Called with the whole chat transcript every time a message is added or updated.
+     *
+     * Triggered by {@link AgentManager.chat | chat()}, by {@link AgentManager.speak | speak()} for
+     * text scripts, and as the agent's answer streams in. It also fires once while the manager is
+     * created, with whatever {@link AgentManagerOptions.initialMessages | initialMessages} were
+     * given, and again on every {@link AgentManager.connect | connect()} after the first — both
+     * with type `answer`. The array is a fresh copy on each call, oldest message first; every
+     * {@link Message} carries an `id`, a `role` of `user` or `assistant` (the agent), its `content`
+     * and a `created_at` timestamp.
+     *
+     * @param messages - The chat so far.
+     * @param type - `partial` while the agent's answer is still streaming in, `answer` for the full
+     * answer spoken in the streamed video, `user` when the message just added is the user's own
+     * (a message passed to {@link AgentManager.chat | chat()}, or a transcribed utterance).
+     * @example
+     * ```ts
+     * onNewMessage(messages, type) {
+     *     console.log(messages, type);
+     *
+     *     if (type === 'answer') {
+     *         console.log(messages[messages.length - 1].content);
+     *     }
+     * }
+     * ```
+     */
+    onNewMessage?: (messages: Message[], type: 'answer' | 'partial' | 'user') => void;
+    /**
+     * Called when a chat is created for this session.
+     *
+     * A chat is created while {@link AgentManager.connect | connect()} runs, and lazily on the
+     * first {@link AgentManager.chat | chat()} when none exists yet. Store the id if you want to
+     * correlate the conversation with your own records.
+     *
+     * @param chatId - Id of the chat that was just created.
+     */
+    onNewChat?: (chatId: string) => void;
+    /**
+     * Called when the chat mode changes.
+     *
+     * Fires after {@link AgentManager.changeMode | changeMode()}, and when the server answers with
+     * a different mode than the one requested (for example {@link ChatMode.Maintenance}).
+     *
+     * @param mode - The {@link ChatMode} now in effect.
+     */
+    onModeChange?: (mode: ChatMode) => void;
+    /**
+     * Called when the quality of the user's internet connection changes.
+     *
+     * The state is derived from jitter-buffer delay and freeze count on the video stream for
+     * Talks (V2) and Clips (V3) agents, and from LiveKit's reported connection quality for
+     * Expressive (V4) agents, so it reflects what the session is actually getting rather than the
+     * browser's online flag.
+     *
+     * @param state - {@link ConnectivityState.Strong | STRONG},
+     * {@link ConnectivityState.Weak | WEAK} or {@link ConnectivityState.Unknown | UNKNOWN}.
+     * @example
+     * ```ts
+     * onConnectivityStateChange(state) {
+     *     console.log('onConnectivityStateChange(): ', state);
+     * }
+     * ```
+     */
+    onConnectivityStateChange?: (state: ConnectivityState) => void;
+    /**
+     * Called when the SDK fails, so the application can surface the problem.
+     *
+     * Receives failures from the Agents API requests, the stream and the web socket — an
+     * {@link HttpError} when a request comes back non-2xx, a {@link NetworkError} when it never
+     * reaches the server, a {@link WsError} when the web socket itself fails, and also
+     * {@link ChatModeDowngraded} and {@link StreamError}. Two errors do not arrive here:
+     * {@link ValidationError} and {@link ChatCreationFailed} are thrown to whoever called the
+     * method ({@link AgentManager.chat | chat()}, {@link AgentManager.speak | speak()} and the
+     * rating methods), so they surface as a rejected promise rather than through this callback.
+     *
+     * @param error - The error that occurred.
+     * @param errorData - Extra context about the failure, such as the request URL and options.
+     * @example
+     * ```ts
+     * onError(error, errorData) {
+     *     console.log('Error:', error, 'Error Data', errorData);
+     * }
+     * ```
+     */
+    onError?: (error: Error, errorData?: Record<string, unknown>) => void;
+    /**
+     * Called when the agent moves between idle, loading, talking and running a tool.
+     *
+     * Use it to drive a typing indicator or to disable input while the agent is busy. The full set
+     * of states is reported for Expressive (V4) agents only. Talks (V2) and Clips (V3) agents
+     * report just {@link AgentActivityState.Talking | Talking} and
+     * {@link AgentActivityState.Idle | Idle}, and only on fluent streams, plus a final
+     * {@link AgentActivityState.Idle | Idle} when the connection closes.
+     *
+     * @param state - The {@link AgentActivityState} the agent has moved to.
+     */
+    onAgentActivityStateChange?: (state: AgentActivityState) => void;
+    /**
+     * Called once per session when the stream has been created on the server.
+     *
+     * Fires before the connection reaches {@link ConnectionState.Connected | 'connected'}. The ids
+     * are useful when correlating a session with D-ID support or with your own logs.
+     *
+     * @param stream - The new stream's `stream_id`, `session_id` and `agent_id`.
+     */
+    onStreamCreated?: (stream: StreamCreatedInfo) => void;
+    /**
+     * Called when the agent starts, finishes or fails a tool call.
+     *
+     * Expressive (V4) agents only. The handler takes two arguments and returns nothing: `event`,
+     * one of {@link StreamEvents.ToolCallStarted}, {@link StreamEvents.ToolCallDone} or
+     * {@link StreamEvents.ToolCallError}; and `data`, the payload that event narrows to —
+     * {@link ToolCallStartedPayload}, {@link ToolCallDonePayload} or
+     * {@link ToolCallErrorPayload} respectively. The overloads that do the narrowing are on
+     * {@link ToolEventCallback}, with an example handler.
      */
     onToolEvent?: StreamManagerCallbacks['onToolEvent'];
     /**
-     * Optional callback function that will be triggered when the interruptible state changes
-     * @param interruptible - Whether the agent can be interrupted by the user
+     * Called when the agent becomes interruptible, or stops being interruptible.
+     *
+     * Expressive (V4) agents only, and about whether interrupting is allowed *right now*: it goes
+     * `false` while a `blocking` client tool call is outstanding, because the agent is suspended
+     * waiting for it, and back to `true` when the call finishes. That is a different question from
+     * {@link AgentManager.getIsInterruptAvailable | getIsInterruptAvailable()}, which says whether
+     * the session supports interrupting at all. Use this one to enable or disable an interrupt
+     * button. Talks (V2) and Clips (V3) agents never report a change.
      */
     onInterruptibleChange?: StreamManagerCallbacks['onInterruptibleChange'];
     /**
-     * Optional callback function that will be triggered when the set of running tool calls changes,
-     * including an empty array on disconnect.
-     * @param calls - The tool calls currently running
+     * Called whenever the set of tool calls running in the session changes.
+     *
+     * Expressive (V4) agents only. Fires with an empty array on disconnect, so a spinner driven by
+     * this callback always clears. Each entry is a {@link RunningToolCall}.
      */
     onRunningToolCallsChange?: StreamManagerCallbacks['onRunningToolCallsChange'];
 }
-interface StreamOptions {
+/**
+ * Transport settings applied when the stream is created.
+ *
+ * Talks (V2) and Clips (V3) agents only. Expressive (V4) agents manage transport settings
+ * automatically and ignore these options. Pass the object as
+ * {@link AgentManagerOptions.streamOptions}; every field is optional.
+ *
+ * @category Streaming Options
+ */
+export 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.
+     * Which video codec the stream negotiates.
+     *
+     * See {@link CompatibilityMode}.
+     *
      * @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.
+     * Whether the stream plays a warmup video while the connection settles.
+     *
+     * With it on the server plays a short warmup video as soon as the connection is up, and the
+     * SDK holds back {@link ConnectionState.Connected | 'connected'} — and so the resolution of
+     * {@link AgentManager.connect | connect()} — until that video has played out. Without it,
+     * `'connected'` is reported as soon as the data channel opens. The application sees nothing of
+     * the warmup video itself beyond the delay; it is not distinguishable from any other. A fluent
+     * stream ignores the option — the warmup only runs on legacy streams (see
+     * {@link StreamOptions.fluent | fluent}).
+     *
      * @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
+     * How long the session may sit idle between messages before the server ends it, in seconds.
+     *
+     * Up to 300, and only for accounts whose plan allows it. When the session does time out,
+     * {@link AgentManagerCallbacks.onConnectionStateChange | onConnectionStateChange} reports
+     * {@link ConnectionState.Disconnected | 'disconnected'} with the reason
+     * {@link StreamEndReason.Inactivity | 'inactivity'}. Leave it out and the server decides.
      */
     sessionTimeout?: number;
     /**
-     * Desired stream resolution for the session
-     * @minimum 150
-     * @maximum 1080
-     */
-    outputResolution?: number;
-    /**
-     * Whether to request fluent stream.
+     * Whether to request a fluent stream.
+     *
+     * `true` streams one video for both the idle and talking states; `false` uses the legacy mode,
+     * where the application swaps between two video elements. Clips (V3) agents built on a Pro
+     * avatar; always on for Expressive (V4). A fluent stream is also what makes
+     * {@link AgentManager.interrupt | interrupt()} available.
+     *
      * @default false
      */
     fluent?: boolean;
 }
+/**
+ * Everything {@link createAgentManager} needs to reach an agent and report back to the application.
+ *
+ * {@link AgentManagerOptions.auth | auth} and {@link AgentManagerOptions.callbacks | callbacks} are
+ * required; the rest have defaults that suit a browser application talking to D-ID production.
+ *
+ * @category Agent Manager
+ */
 export interface AgentManagerOptions {
-    auth: Auth;
-    callbacks: ManagerCallbacks;
-    mode?: ChatMode;
-    baseURL?: string;
-    wsURL?: string;
-    debug?: boolean;
-    verbose?: boolean;
-    /**
-     * Whether to enable analytics (Mixpanel) tracking.
-     * @default true
-     * @deprecated Use `enableAnalytics` instead. This misspelled prop is kept for backwards compatibility.
-     */
-    enableAnalitics?: boolean;
-    /**
-     * Whether to enable analytics (Mixpanel) tracking.
-     * Takes precedence over the deprecated `enableAnalitics` prop when both are set.
-     * @default true
-     */
-    enableAnalytics?: boolean;
-    mixpanelKey?: string;
-    mixpanelAdditionalProperties?: Record<string, any>;
-    externalId?: string;
-    streamOptions?: StreamOptions;
-    initialMessages?: Message[];
-    persistentChat?: boolean;
-    microphoneStream?: MediaStream;
-}
-export interface AgentManager {
     /**
-     * Agent instance you are working with.
-     * To know more about agents go to https://docs.d-id.com/reference/agents
+     * Credentials used for every request the SDK makes on the application's behalf.
+     *
+     * Use `{ type: 'key', clientKey }` in a browser: a client key is scoped to one agent and to
+     * the domains you allowed, so it is the only shape that is safe to ship in a page. See
+     * {@link Auth}.
      */
-    agent: Agent;
-    /**
-     * Get the current stream type of the agent
-     */
-    getStreamType: () => StreamType | undefined;
-    /**
-     * Get if the stream supports interrupt
-     */
-    getIsInterruptAvailable: () => boolean;
-    /**
-     * Array of starter messages that will be sent to the agent when the chat starts
-     */
-    starterMessages: string[];
-    /**
-     * 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>;
+    auth: Auth;
     /**
-     * Method to close all connections with agent, stream and web socket
+     * Handlers the SDK calls as the connection, the video stream and the chat change state.
+     *
+     * See {@link AgentManagerCallbacks}.
+     * {@link AgentManagerCallbacks.onSrcObjectReady | onSrcObjectReady} is mandatory — it is what
+     * connects the streamed media to your video element; the rest are optional.
      */
-    disconnect: () => Promise<void>;
+    callbacks: AgentManagerCallbacks;
     /**
-     * Publish a microphone stream to the data channel
-     * Can be called after connection to add microphone input
-     * @param stream The MediaStream containing the microphone audio track
-     * supported only for livekit manager
+     * How the agent answers: with a streamed video, as text only, or not at all.
+     *
+     * See {@link ChatMode}. It can be changed later with
+     * {@link AgentManager.changeMode | changeMode()}. {@link ChatMode.Off} and
+     * {@link ChatMode.DirectPlayback} are supported on Talks (V2) and Clips (V3) agents only.
+     *
+     * @default ChatMode.Functional
+     * @throws {@link ValidationError} From {@link createAgentManager}, when the agent is Expressive
+     * (V4) and the mode is {@link ChatMode.Off} or {@link ChatMode.DirectPlayback}.
      */
-    publishMicrophoneStream?: (stream: MediaStream) => Promise<void>;
+    mode?: ChatMode;
     /**
-     * Unpublish the currently published microphone stream
-     * Can be called after connection to remove microphone input
-     * supported only for livekit manager
+     * Base URL of the D-ID Agents API. Used by D-ID to point the SDK at a test environment.
+     *
+     * @internal
      */
-    unpublishMicrophoneStream?: () => Promise<void>;
+    baseURL?: string;
     /**
-     * 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.
+     * URL of the D-ID notifications web socket. Used by D-ID to point the SDK at a test environment.
+     *
+     * @internal
      */
-    replaceMicrophoneTrack?: (track: MediaStreamTrack) => Promise<void>;
+    wsURL?: string;
     /**
-     * Publish a camera video stream to the LiveKit room.
-     * Can be called after connection to enable vision.
-     * supported only for livekit manager
+     * Whether the SDK logs its streaming lifecycle to the browser console.
+     *
+     * It is also switched on for everyone when the agent's `ui_debug_mode` advanced setting is
+     * enabled, regardless of the value passed here.
+     *
+     * @default false
      */
-    publishCameraStream?: (stream: MediaStream) => Promise<void>;
+    debug?: boolean;
     /**
-     * Unpublish the currently published camera stream.
-     * Can be called after connection to disable vision.
-     * supported only for livekit manager
+     * Whether the stream is created in verbose mode, which logs more server-side detail.
+     *
+     * Independent of {@link AgentManagerOptions.debug | debug}: this one is sent to the streaming
+     * service rather than controlling console output. Expressive (V4) agents only.
+     *
+     * @default false
      */
-    unpublishCameraStream?: () => Promise<void>;
+    verbose?: boolean;
     /**
-     * Method to send a chat message to existing chat with the agent
-     * @param messages
+     * Whether the SDK reports usage analytics. Set it to `false` to send nothing.
+     *
+     * It is on unless you turn it off. The SDK posts an event to Mixpanel for each step of a
+     * session — connect, reconnect and disconnect, every message sent and answered, every
+     * {@link AgentManager.speak | speak()}, mode change, rating, feedback, tool call, video start
+     * and stop, interrupt and error. Each event carries the agent id, the visitor id derived from
+     * {@link AgentManagerOptions.externalId | externalId}, the page URL, the screen size, the user
+     * agent, the SDK version and whatever
+     * {@link AgentManagerOptions.mixpanelAdditionalProperties | mixpanelAdditionalProperties}
+     * added. Conversation text is included too: the agent's answer on `agent-message-received`,
+     * and the script on `agent-speak`.
+     *
+     * The events go to D-ID's own Mixpanel project unless
+     * {@link AgentManagerOptions.mixpanelKey | mixpanelKey} points them at yours. Events that fail
+     * to post are buffered in memory (at most 50) and retried when the tab comes back online or
+     * becomes visible.
+     *
+     * @default true
      */
-    chat: (userMessage: string) => Promise<ChatResponse>;
+    enableAnalytics?: boolean;
     /**
-     * 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
+     * Mixpanel project token the SDK's analytics events are sent to.
+     *
+     * Defaults to D-ID's own project. Set it to send the SDK's events to your Mixpanel project
+     * instead.
      */
-    rate: (messageId: string, score: 1 | -1, rateId?: string) => Promise<RatingEntity>;
+    mixpanelKey?: string;
     /**
-     * Method to delete rating from answer in chat
-     * @param id - id of Rating entity.
+     * Extra properties merged into every analytics event the SDK sends.
+     *
+     * A flat object — use it to tag events with your own identifiers. More properties can be added
+     * later with {@link AgentManager.enrichAnalytics | enrichAnalytics()}.
      */
-    deleteRate: (id: string) => Promise<RatingEntity>;
+    mixpanelAdditionalProperties?: Record<string, unknown>;
     /**
-     * Method to submit end-of-call feedback for the chat
-     * @param rating - integer score from 1 to 5
-     * @param answer - optional free-text answer
+     * Your own identifier for the end user.
+     *
+     * It is stored in `localStorage`, sent as part of the `type: 'key'` authorization header and
+     * attached to analytics, so the same visitor is recognised across page loads. When it is
+     * omitted the SDK generates an id and reuses it.
      */
-    submitFeedback: (rating: number, answer?: string) => Promise<SubmitFeedbackResponse>;
+    externalId?: string;
     /**
-     * Method to make your agent read the text you provide or reproduce sound
-     * @param payload
+     * Transport settings applied when the stream is created.
+     *
+     * See {@link StreamOptions}. Talks (V2) and Clips (V3) agents only. Expressive (V4) agents
+     * manage transport settings automatically.
      */
-    speak: (payload: SupportedStreamScript | string) => Promise<SendStreamPayloadResponse>;
+    streamOptions?: StreamOptions;
     /**
-     * Method to change the mode of the chat
-     * @param mode - ChatMode
+     * Messages the chat starts with, for example a transcript restored from your own storage.
+     *
+     * They are delivered to {@link AgentManagerCallbacks.onNewMessage | onNewMessage} so the UI can
+     * render them. On Talks (V2) and Clips (V3) agents they are also sent as context with the next
+     * {@link AgentManager.chat | chat()} request. See {@link Message}.
+     *
+     * {@link Message.parts | parts} is a required field, but it does not have to be filled: pass an
+     * empty array and the SDK builds the parts from `content` with {@link parseMessageParts}, so a
+     * transcript restored from `content` alone still renders. A non-empty array is kept as given.
+     *
+     * @example Restoring rows that carry only the message text
+     * ```ts
+     * const initialMessages = stored.map(({ id, role, content }) => ({ id, role, content, parts: [] }));
+     * ```
      */
-    changeMode(mode: ChatMode): void;
+    initialMessages?: Message[];
     /**
-     * Method to enrich analytics properties
-     * @param properties flat json object with properties that will be added to analytics events fired from the sdk
+     * Whether the server keeps the chat so it can be resumed in a later session.
+     *
+     * Without persistence a chat lives only as long as the connection.
+     * {@link AgentManager.reconnect | reconnect()} normally continues the same chat either way —
+     * see the caveat there for Expressive (V4) agents.
+     *
+     * Off unless you set it, on every agent type.
+     *
+     * @default false
      */
-    enrichAnalytics: (properties: Record<string, any>) => void;
+    persistentChat?: boolean;
+}
+/**
+ * A live connection to one agent: its profile, its chat, and the video stream it answers on.
+ *
+ * Created by {@link createAgentManager}. Nothing happens on the wire until
+ * {@link AgentManager.connect | connect()} resolves; after that
+ * {@link AgentManager.chat | chat()} makes the agent answer with its own LLM and
+ * {@link AgentManager.speak | speak()} makes it say exactly what you give it. Call
+ * {@link AgentManager.disconnect | disconnect()} when the user leaves.
+ *
+ * Two properties, {@link AgentManager.agent | agent} and
+ * {@link AgentManager.starterMessages | starterMessages}, are readable as soon as the manager
+ * exists; everything else is a method. Some methods work only with some avatar types: each one
+ * says so, and {@link AgentAvatar} is where the session's tier is read from.
+ *
+ * Every method that reaches the Agents API can reject with an {@link HttpError} when the request
+ * comes back non-2xx, or a {@link NetworkError} when it never reaches the server; the individual
+ * `@throws` entries below name the errors that are specific to each method.
+ *
+ * @category Agent Manager
+ */
+export interface AgentManager {
     /**
-     * Method to interrupt the current video stream
-     * Only available for Fluent streams and when there's an active video to interrupt
+     * The agent this manager is connected to, as the Agents API returned it.
+     *
+     * Fetched once while the manager is created, so it is available before
+     * {@link AgentManager.connect | connect()}. Useful for rendering the agent's name, thumbnail
+     * and {@link Agent.idle_video | idle_video}. See {@link Agent}.
      */
-    interrupt: (interrupt: Interrupt) => void;
+    agent: Agent;
     /**
-     * Switch the STT language mid-session
-     * Only available for Expressive (V4) agents
-     * @param language - Language name or BCP-47 code (e.g. "English" or "en-US")
+     * Returns the kind of stream the current session negotiated.
+     *
+     * @returns {@link StreamType.Fluent} for a fluent stream (one video for the idle and talking
+     * states), {@link StreamType.Legacy} for the two-element legacy mode, or `undefined` before
+     * {@link AgentManager.connect | connect()} has established a session.
      */
-    setSttLanguage: (language: string) => Promise<void>;
+    getStreamType(): StreamType | undefined;
     /**
-     * Send a JSON payload to the agent over a data-channel topic
-     * Only available for Expressive (V4) agents
-     * @param topic - Data-channel topic to send on (see `PublicDataChannelTopic`)
-     * @param payload - Plain object, serialized as JSON
+     * Returns whether the current stream supports interrupting the agent mid-answer.
+     *
+     * True on a fluent stream — a Clips (V3) agent built on a Pro avatar, or any Expressive (V4)
+     * agent — once connected. This says the stream supports interrupting at all;
+     * {@link AgentManagerCallbacks.onInterruptibleChange | onInterruptibleChange} says whether
+     * interrupting is allowed right now.
+     *
+     * @returns `true` when {@link AgentManager.interrupt | interrupt()} can do anything.
      */
-    sendDataChannelMessage: (topic: PublicDataChannelTopic, payload: Record<string, unknown>) => Promise<void>;
+    getIsInterruptAvailable(): boolean;
     /**
-     * Register a handler for a client tool. When the agent's LLM calls this tool,
-     * the handler executes on the client and returns the result to the LLM.
-     * @param name - Tool name (must match the tool name defined in the agent config)
-     * @param handler - Async function receiving args, must return a JSON string (max 15KiB)
+     * The agent's starter messages.
+     *
+     * Suggested openers to offer the user as buttons; empty when the agent defines none. Available
+     * before {@link AgentManager.connect | connect()}.
      */
-    registerClientTool: (name: string, handler: ClientToolHandler) => void;
+    starterMessages: string[];
     /**
-     * Remove a previously registered client tool handler.
-     * @param name - Tool name to unregister
-     */
-    unregisterClientTool: (name: string) => void;
+     * Fetches a short-lived token for the D-ID speech-to-text service.
+     *
+     * The SDK sends the request whenever it is called, connected or not; the service decides
+     * whether to issue a token for the agent.
+     *
+     * @returns The {@link STTTokenResponse} for this agent.
+     * @throws {@link HttpError} When the service does not answer with a token, or the request comes
+     * back non-2xx for any other reason.
+     * @throws {@link NetworkError} When the request never reaches the server.
+     */
+    getSTTToken(): Promise<STTTokenResponse>;
+    /**
+     * Opens a new session with the agent: a new WebRTC connection, a new web socket and a new chat.
+     *
+     * Resolves once the connection reaches {@link ConnectionState.Connected | 'connected'}, by
+     * which point {@link AgentManagerCallbacks.onSrcObjectReady | onSrcObjectReady} has been called
+     * with the media stream to render. Calling it again starts a fresh conversation; to keep the
+     * current one use {@link AgentManager.reconnect | reconnect()}.
+     *
+     * @returns Resolves when the agent is connected and ready.
+     * @throws {@link HttpError} When creating the stream or the chat comes back non-2xx — a client
+     * key that is not authorized for the agent or the calling domain, or an account out of
+     * credits. The SDK tries the initialization up to three times first, except on `429` and on an
+     * out-of-credits response.
+     * @throws {@link NetworkError} When those requests never reach the server.
+     * @example
+     * ```ts
+     * await agentManager.connect();
+     * ```
+     */
+    connect(): Promise<void>;
+    /**
+     * Reopens the stream when the session expires, and continues the conversation on the same chat.
+     *
+     * The chat id normally does not change, so the agent keeps its context. It starts a new stream
+     * — including after the server ended the previous one deliberately — rather than resuming the
+     * old one. On Expressive (V4) agents the transport is asked to reconnect first; if that fails
+     * the SDK falls back to a disconnect and a fresh connect, which starts a new chat id.
+     *
+     * @returns Resolves when the new stream is connected.
+     * @throws {@link HttpError} When creating the new stream comes back non-2xx.
+     * @throws {@link NetworkError} When that request never reaches the server.
+     */
+    reconnect(): Promise<void>;
+    /**
+     * Closes the existing connection and chat with the agent: the stream and the web socket.
+     *
+     * Call it when the user leaves the page or the conversation, so the session does not keep
+     * running. After it resolves, {@link AgentManager.connect | connect()} is needed before the
+     * agent can be used again.
+     *
+     * @returns Resolves once everything is closed.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Publishes a microphone audio track to the session so the agent can hear the user.
+     *
+     * Call it after {@link AgentManager.connect | connect()} to enable voice input. Expressive (V4)
+     * agents only; on Talks (V2) and Clips (V3) agents, and before `connect()`, the returned
+     * promise rejects with a {@link ValidationError}.
+     *
+     * @param stream - A `MediaStream` whose audio track is published to the session.
+     * @returns Resolves once the track is published.
+     * @throws {@link ValidationError} When the session is not an Expressive (V4) one, or
+     * {@link AgentManager.connect | connect()} has not run yet.
+     * @example
+     * ```ts
+     * const micStream = await navigator.mediaDevices.getUserMedia({ audio: true });
+     * await agentManager.publishMicrophoneStream(micStream);
+     * ```
+     */
+    publishMicrophoneStream(stream: MediaStream): Promise<void>;
+    /**
+     * Stops and removes the currently published microphone track from the session.
+     *
+     * The counterpart of {@link AgentManager.publishMicrophoneStream | publishMicrophoneStream()} —
+     * use it to mute the user for the rest of the session. Expressive (V4) agents only; on Talks
+     * (V2) and Clips (V3) agents, and when nothing is published, it resolves without doing
+     * anything.
+     *
+     * @returns Resolves once the track is removed.
+     * @example
+     * ```ts
+     * await agentManager.unpublishMicrophoneStream();
+     * ```
+     */
+    unpublishMicrophoneStream(): Promise<void>;
+    /**
+     * Swaps the live microphone track without unpublishing it.
+     *
+     * Use it when the user picks a different input device: the publication is preserved — its
+     * LiveKit publication id (SID) and SSRC stay the same, though the `MediaStreamTrack` id
+     * changes — so the server sees continuous audio across the swap rather than a stop and a
+     * restart. Rejects with a plain `Error` from the transport when there is no active publication
+     * — fall back to {@link AgentManager.publishMicrophoneStream | publishMicrophoneStream()} in
+     * that case. Expressive (V4) agents only; on Talks (V2) and Clips (V3) agents, and before
+     * {@link AgentManager.connect | connect()}, the returned promise rejects with a
+     * {@link ValidationError}.
+     *
+     * @param track - The audio track to send from now on.
+     * @returns Resolves once the transport has switched to the new track.
+     * @throws {@link ValidationError} When the session is not an Expressive (V4) one, or
+     * {@link AgentManager.connect | connect()} has not run yet.
+     */
+    replaceMicrophoneTrack(track: MediaStreamTrack): Promise<void>;
+    /**
+     * Publishes a camera video track to the session so the agent can see the user.
+     *
+     * Call it after {@link AgentManager.connect | connect()} to enable vision. Expressive (V4)
+     * agents only; on Talks (V2) and Clips (V3) agents, and before `connect()`, the returned
+     * promise rejects with a {@link ValidationError}.
+     *
+     * @param stream - A `MediaStream` whose video track is published to the session.
+     * @returns Resolves once the track is published.
+     * @throws {@link ValidationError} When the session is not an Expressive (V4) one, or
+     * {@link AgentManager.connect | connect()} has not run yet.
+     */
+    publishCameraStream(stream: MediaStream): Promise<void>;
+    /**
+     * Stops and removes the currently published camera track from the session.
+     *
+     * Call it to disable vision. Expressive (V4) agents only; on Talks (V2) and Clips (V3) agents,
+     * and when nothing is published, it resolves without doing anything.
+     *
+     * @returns Resolves once the track is removed.
+     */
+    unpublishCameraStream(): Promise<void>;
+    /**
+     * Sends a message to the agent and gets a streamed video based on its answer (LLM).
+     *
+     * The answer arrives through {@link AgentManagerCallbacks.onNewMessage | onNewMessage} — first
+     * as `partial` chunks, then as the full `answer` — while the video plays it. The chat is
+     * created on the first call if the session does not have one yet.
+     *
+     * @param userMessage - The user's message text to send to the agent.
+     * @returns The {@link ChatResponse} for this turn.
+     * @throws {@link ValidationError} When the message is empty or too long, when the chat mode has
+     * chat disabled or is in maintenance, or when the manager is not connected yet.
+     * @throws {@link ChatCreationFailed} On Talks (V2) and Clips (V3) agents, when the session has
+     * no chat yet and the Agents API answers the creation request without one.
+     * @throws {@link HttpError} On Talks (V2) and Clips (V3) agents, and in
+     * {@link ChatMode.Playground}, when the message request comes back non-2xx. Expressive (V4)
+     * agents send the message over the data channel instead, so no HTTP request is made.
+     * @throws {@link NetworkError} On Talks (V2) and Clips (V3) agents, and in
+     * {@link ChatMode.Playground}, when that request never reaches the server.
+     * @example
+     * ```ts
+     * const chat = await agentManager.chat('What is the distance to the moon?');
+     * ```
+     */
+    chat(userMessage: string): Promise<ChatResponse>;
+    /**
+     * Rates one of the agent's answers in the chat, for future analytics and insights.
+     *
+     * Pass `rateId` to change a rating the user already gave instead of adding another.
+     *
+     * @param messageId - Id of the message being rated.
+     * @param score - 1 for a positive rating, -1 for a negative one.
+     * @param rateId - Id of an existing rating to update; omit to create a new one.
+     * @returns The created or updated {@link RatingEntity}.
+     * @throws {@link ValidationError} When no chat has started, or when no message with that id is
+     * in the transcript.
+     * @throws {@link HttpError} When the rating request comes back non-2xx.
+     * @throws {@link NetworkError} When the rating request never reaches the server.
+     */
+    rate(messageId: string, score: 1 | -1, rateId?: string): Promise<RatingEntity>;
+    /**
+     * Removes a rating the user gave to an answer in the chat.
+     *
+     * @param id - Id of the rating to remove, as returned by
+     * {@link AgentManager.rate | rate()}.
+     * @returns The {@link RatingEntity} that was deleted.
+     * @throws {@link ValidationError} When no chat has started.
+     * @throws {@link HttpError} When the delete request comes back non-2xx.
+     * @throws {@link NetworkError} When the delete request never reaches the server.
+     */
+    deleteRate(id: string): Promise<RatingEntity>;
+    /**
+     * Submits end-of-call feedback for the whole conversation.
+     *
+     * Separate from {@link AgentManager.rate | rate()}, which scores a single answer. Collect it
+     * when the user ends the call, using the agent's end-of-call feedback configuration.
+     *
+     * @param rating - The user's score for the conversation, a whole number from 1 to 5.
+     * @param answer - The user's free-text answer to the follow-up question, when one was asked.
+     * @returns The stored {@link SubmitFeedbackResponse}.
+     * @throws {@link ValidationError} When no chat has started.
+     * @throws {@link HttpError} When the feedback request comes back non-2xx.
+     * @throws {@link NetworkError} When the feedback request never reaches the server.
+     */
+    submitFeedback(rating: number, answer?: string): Promise<SubmitFeedbackResponse>;
+    /**
+     * Makes the agent stream back a video based on the text or audio file you provide.
+     *
+     * Unlike {@link AgentManager.chat | chat()} the agent's LLM is not involved, so this is how you
+     * script greetings and canned lines. Pass a plain string as a shorthand for a text script. See
+     * {@link SupportedStreamScript}, {@link TextStreamScript} and {@link AudioStreamScript}. Text
+     * scripts also accept an optional `sentiment`, for Expressive (V4) agents only; if the
+     * requested sentiment is not supported by the agent, the default sentiment is used.
+     *
+     * @see [Create a video stream](https://docs.d-id.com/reference/createvideoagentstream) — the request
+     * sent for Talks (V2) and Clips (V3) agents.
+     * @see [Control the Agent](https://docs.d-id.com/docs/livekit-commands) — the `did.speak` command
+     * sent over the data channel for Expressive (V4) agents.
+     * @param payload - A text or audio script, or a string treated as the text to speak.
+     * @returns The {@link SendStreamPayloadResponse} for the video that was produced, or the same
+     * response with `duration` `0` and an empty `video_id` when the call produced no discrete video
+     * — on Expressive (V4) agents, and in a text-only chat mode.
+     * @throws {@link ValidationError} When the manager is not connected to a stream yet.
+     * @throws {@link HttpError} On Talks (V2) and Clips (V3) agents, when the Agents API answers
+     * the request non-2xx. Expressive (V4) agents send the script over the data channel instead,
+     * so no HTTP request is made.
+     * @throws {@link NetworkError} On Talks (V2) and Clips (V3) agents, when that request never
+     * reaches the server.
+     * @example Text
+     * ```ts
+     * const speak = await agentManager.speak({
+     *     type: 'text',
+     *     input: "Hi! I'm Alice!",
+     * });
+     * ```
+     * @example Text with sentiment (Expressive (V4) agents)
+     * ```ts
+     * const speak = await agentManager.speak({
+     *     type: 'text',
+     *     input: "Hi! I'm Alice!",
+     *     sentiment: 'friendly',
+     * });
+     * ```
+     * @example Audio file
+     * ```ts
+     * const speak = await agentManager.speak({
+     *     type: 'audio',
+     *     audio_url: 'https://www.yourwebsite.com/audio.mp3',
+     * });
+     * ```
+     */
+    speak(payload: SupportedStreamScript | string): Promise<SendStreamPayloadResponse>;
+    /**
+     * Switches the chat to another mode.
+     *
+     * Anything other than {@link ChatMode.Functional} disconnects the stream, since those modes do
+     * not produce video, which is why this is asynchronous: the returned promise resolves once that
+     * disconnect has finished. {@link AgentManagerCallbacks.onModeChange | onModeChange} fires once
+     * the change has been applied; passing the mode already in effect does nothing.
+     *
+     * @param mode - The {@link ChatMode} to switch to.
+     * @returns A promise resolved when the mode is in effect and any disconnect it caused has
+     * completed.
+     * @throws {@link ValidationError} Rejects on Expressive (V4) agents for {@link ChatMode.Off} and
+     * {@link ChatMode.DirectPlayback}, which those agents do not support.
+     */
+    changeMode(mode: ChatMode): Promise<void>;
+    /**
+     * Adds properties to every analytics event the SDK sends from now on.
+     *
+     * The same thing
+     * {@link AgentManagerOptions.mixpanelAdditionalProperties | mixpanelAdditionalProperties} does
+     * at creation time, for values you only learn later.
+     *
+     * @param properties - A flat JSON object whose properties are added to every analytics event
+     * the SDK sends from now on.
+     */
+    enrichAnalytics(properties: Record<string, unknown>): void;
+    /**
+     * Interrupts the current video stream mid-playback, so the user can talk over the agent.
+     *
+     * Supported on a fluent stream — a Clips (V3) agent built on a Pro avatar, or any Expressive
+     * (V4) agent. It never throws: on every agent type it returns without doing anything when
+     * interrupting is not available for the session, when it is not allowed right now, and — on
+     * Talks (V2) and Clips (V3) agents — when the stream is not a fluent stream or no video is
+     * playing. Check {@link AgentManager.getIsInterruptAvailable | getIsInterruptAvailable()}
+     * before offering the control at all; on Expressive (V4) agents
+     * {@link AgentManagerCallbacks.onInterruptibleChange | onInterruptibleChange} tracks whether it
+     * is allowed right now.
+     *
+     * The interrupted message is marked as such in the next
+     * {@link AgentManagerCallbacks.onNewMessage | onNewMessage} — but only when an interrupt was
+     * actually sent. A call that finds nothing to interrupt leaves the message untouched and fires
+     * no callback.
+     *
+     * @param interrupt - What caused the interruption, as an {@link Interrupt}: `text`, `audio`,
+     * `click` or `manual`. Expressive (V4) agents drop `text` interrupts, because the orchestrator
+     * does not cancel the in-flight answer for them.
+     */
+    interrupt(interrupt: Interrupt): void;
+    /**
+     * Switches the speech-to-text language in the middle of a session.
+     *
+     * Expressive (V4) agents only, after {@link AgentManager.connect | connect()}; otherwise the
+     * returned promise rejects with a {@link ValidationError}.
+     *
+     * @param language - The language to transcribe in, as a name or a BCP-47 code — `"English"` or
+     * `"en-US"`.
+     * @returns Resolves once the new language has been sent to the agent. A room that has dropped
+     * since {@link AgentManager.connect | connect()} reports a {@link StreamError} through
+     * {@link AgentManagerCallbacks.onError | onError} and the promise still resolves.
+     * @throws {@link ValidationError} When the session is not an Expressive (V4) one, or
+     * {@link AgentManager.connect | connect()} has not run yet.
+     */
+    setSttLanguage(language: string): Promise<void>;
+    /**
+     * Sends a JSON payload to the agent over a data-channel topic.
+     *
+     * Use it for application-specific messages that are not speech, such as telling a presentation
+     * to change slide. Expressive (V4) agents only, after {@link AgentManager.connect | connect()};
+     * otherwise the returned promise rejects with a {@link ValidationError}.
+     *
+     * @param topic - Data-channel topic to send on. {@link PublicDataChannelTopic} is exported from
+     * the package root and lists every topic this method accepts.
+     * @param payload - A plain object, sent as JSON.
+     * @returns Resolves once the payload has been sent. A room that has dropped since
+     * {@link AgentManager.connect | connect()} reports a {@link StreamError} through
+     * {@link AgentManagerCallbacks.onError | onError} and the promise still resolves.
+     * @throws {@link ValidationError} When the session is not an Expressive (V4) one, or
+     * {@link AgentManager.connect | connect()} has not run yet.
+     * @example
+     * ```ts
+     * import { PublicDataChannelTopic } from '@d-id/client-sdk';
+     *
+     * await agentManager.sendDataChannelMessage(PublicDataChannelTopic.Presentation, {
+     *     type: 'navigate',
+     *     slide: 3,
+     * });
+     * ```
+     */
+    sendDataChannelMessage(topic: PublicDataChannelTopic, payload: Record<string, unknown>): Promise<void>;
+    /**
+     * Registers a handler for a client tool, run in the browser when the agent's LLM calls it.
+     *
+     * The handler executes on the client and its result is returned to the LLM. Register the
+     * handlers before {@link AgentManager.connect | connect()} so the agent can call
+     * them from the moment the session starts; registering the same name again replaces the
+     * handler. Progress is reported through
+     * {@link AgentManagerCallbacks.onToolEvent | onToolEvent}.
+     *
+     * @param name - Name of the tool, which must match the one defined in the agent's
+     * configuration.
+     * @param handler - The function that runs when the agent calls the tool. It receives the
+     * arguments the LLM produced and must resolve to a JSON string of at most 15 KiB. See
+     * {@link ClientToolHandler}.
+     */
+    registerClientTool(name: string, handler: ClientToolHandler): void;
+    /**
+     * Removes a previously registered client tool handler.
+     *
+     * After this the agent's calls to that tool fail rather than reaching your code.
+     *
+     * @param name - Name of the tool whose handler should be removed.
+     */
+    unregisterClientTool(name: string): void;
 }
-export {};