@d-id/client-sdk 3.0.0-staging.413 → 3.0.0-staging.415

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

@@ -1,182 +0,0 @@
-/**
- * The JSON-safe payload {@link BaseError.toJson | toJson()} produces, for logs and error reports.
- *
- * Only the fields the SDK deliberately exposes are present, so the payload can be forwarded to a
- * logging service as it is. Subclasses add their own keys: {@link HttpError} adds `httpStatus` and,
- * when the failing call is known, `endpoint` and `method`; {@link NetworkError} adds `endpoint`,
- * `method`, `durationMs`, `online` and `visibility`.
- *
- * @example An HttpError from a request that was refused
- * ```json
- * {
- *     "kind": "InsufficientCreditsError",
- *     "message": "Account has insufficient credits",
- *     "httpStatus": 402,
- *     "endpoint": "/agt_x/chat/cht_y",
- *     "method": "POST"
- * }
- * ```
- * @category Errors
- */
-export interface ErrorJson {
-    /**
-     * Stable machine-readable code for the failure — the error's {@link BaseError.kind | kind}.
-     */
-    kind: string;
-    /**
-     * Human-readable description of the failure — the error's `message`.
-     */
-    message: string;
-    /**
-     * Message of the error that caused this one, truncated to 256 characters.
-     *
-     * Present only when {@link BaseError.originalError | originalError} is an `Error` and its
-     * message differs from {@link ErrorJson.message | message}. A cause that is not an `Error` is
-     * never serialized, so an arbitrary object carrying credentials cannot end up in the payload.
-     */
-    cause?: string;
-    /**
-     * Additional fields contributed by a subclass, such as `httpStatus` on {@link HttpError}.
-     */
-    [key: string]: any;
-}
-/**
- * Base class of every error the SDK itself raises.
- *
- * Catching `BaseError` catches everything the SDK classified; branch on
- * {@link BaseError.kind | kind}, which is stable, rather than on the message, which is not.
- * Errors reach the application two ways, and each subclass says which applies: some are thrown to
- * the caller of the method, so they reject the promise it returned; others are handed to
- * {@link AgentManagerCallbacks.onError | onError} because no call of yours was in flight when they
- * happened. {@link HttpError} and {@link NetworkError} do both — the request that failed rejects,
- * and the callback is notified as well.
- *
- * Not everything that reaches the application is one of these. The streaming transport is the main
- * exception: a failure LiveKit raises inside a media call on an Expressive (V4) agent — no
- * microphone publication to replace, a room that is not connected — rejects with a plain `Error`,
- * and so do a few low-level guards inside {@link AgentManager.connect | connect()}, such as a
- * `livekit-client` package that is not installed, a transport the SDK does not recognise, or a
- * stream the server created without a session id. An unknown
- * {@link AgentManagerOptions.auth | auth} type is a plain `Error` too. So keep the
- * `else throw error` branch in a handler built on {@link isDIDError}.
- *
- * Subclasses: {@link HttpError}, {@link NetworkError}, {@link WsError}, {@link StreamError},
- * {@link ValidationError}, {@link ChatCreationFailed} and {@link ChatModeDowngraded}. When the
- * caught value is typed `unknown`, {@link isDIDError} narrows it to this class.
- *
- * @category Errors
- */
-export declare class BaseError extends Error {
-    /**
-     * Stable machine-readable code for this failure, and the value to branch on.
-     *
-     * Every subclass redeclares it as the literal it always carries, so a `switch` on `kind`
-     * narrows the caught error to that class: `'NetworkError'` on {@link NetworkError},
-     * `'WSError'` on {@link WsError}, `'StreamError'` on {@link StreamError},
-     * `'ValidationError'` on {@link ValidationError}, `'ChatCreationFailed'` on
-     * {@link ChatCreationFailed} and `'ChatModeDowngraded'` on {@link ChatModeDowngraded}.
-     * {@link HttpError} is the one that stays a plain `string`, because it reuses the server's
-     * own classification when the response carries one and is `'HttpError'` otherwise. On a
-     * `BaseError` built directly it is whatever the caller passed, and `'Error'` when nothing
-     * was.
-     */
-    readonly kind: string;
-    /**
-     * The error or value that caused this one, when the SDK was wrapping something else.
-     *
-     * For a {@link NetworkError} this is the browser's own `fetch` rejection. It is not
-     * serialized as-is: {@link BaseError.toJson | toJson()} takes only an `Error` cause's
-     * message.
-     */
-    readonly originalError?: unknown | undefined;
-    /**
-     * Creates an SDK error. The SDK builds these itself; applications normally only catch them.
-     *
-     * @param message - Human-readable description of the failure, used as the `Error` message.
-     * @param kind - Stable machine-readable code for the failure.
-     * @param originalError - The underlying error or value this one wraps, when there is one.
-     */
-    constructor(message: string, 
-    /**
-     * Stable machine-readable code for this failure, and the value to branch on.
-     *
-     * Every subclass redeclares it as the literal it always carries, so a `switch` on `kind`
-     * narrows the caught error to that class: `'NetworkError'` on {@link NetworkError},
-     * `'WSError'` on {@link WsError}, `'StreamError'` on {@link StreamError},
-     * `'ValidationError'` on {@link ValidationError}, `'ChatCreationFailed'` on
-     * {@link ChatCreationFailed} and `'ChatModeDowngraded'` on {@link ChatModeDowngraded}.
-     * {@link HttpError} is the one that stays a plain `string`, because it reuses the server's
-     * own classification when the response carries one and is `'HttpError'` otherwise. On a
-     * `BaseError` built directly it is whatever the caller passed, and `'Error'` when nothing
-     * was.
-     */
-    kind?: string, 
-    /**
-     * The error or value that caused this one, when the SDK was wrapping something else.
-     *
-     * For a {@link NetworkError} this is the browser's own `fetch` rejection. It is not
-     * serialized as-is: {@link BaseError.toJson | toJson()} takes only an `Error` cause's
-     * message.
-     */
-    originalError?: unknown | undefined);
-    /**
-     * Serializes the error into the JSON-safe {@link ErrorJson} payload for logging or reporting.
-     *
-     * The payload always carries {@link BaseError.kind | kind} and the message. The cause's message
-     * is added only when {@link BaseError.originalError | originalError} is an `Error` and says
-     * something the message does not, truncated to 256 characters; any other cause is dropped.
-     * Subclasses extend the payload with the fields listed on their own pages.
-     *
-     * @returns The error as plain, JSON-serializable data.
-     * @example An HttpError from a request that was refused
-     * ```json
-     * {
-     *     "kind": "InsufficientCreditsError",
-     *     "message": "Account has insufficient credits",
-     *     "httpStatus": 402,
-     *     "endpoint": "/agt_x/chat/cht_y",
-     *     "method": "POST"
-     * }
-     * ```
-     * @example A NetworkError from a request that never left the browser
-     * ```json
-     * {
-     *     "kind": "NetworkError",
-     *     "message": "Network request failed",
-     *     "cause": "Failed to fetch",
-     *     "endpoint": "/agt_x/chat/cht_y",
-     *     "method": "POST",
-     *     "durationMs": 12,
-     *     "online": false,
-     *     "visibility": "visible"
-     * }
-     * ```
-     */
-    toJson(): ErrorJson;
-}
-/**
- * Type guard that reports whether a caught value is an error raised by the SDK.
- *
- * It accepts any `Error` carrying a string `kind`, which every {@link BaseError} has, so it also
- * recognizes SDK errors that crossed a bundle boundary, where `instanceof BaseError` can fail
- * because two copies of the class are loaded. Narrowing with it gives typed access to
- * {@link BaseError.kind | kind}, {@link BaseError.originalError | originalError} and
- * {@link BaseError.toJson | toJson()}.
- *
- * @param error - The caught value to test.
- * @returns `true` when `error` is a {@link BaseError}.
- * @example
- * ```ts
- * try {
- *     await agentManager.chat('What is the distance to the moon?');
- * } catch (error) {
- *     if (isDIDError(error)) {
- *         console.error(error.kind, error.toJson());
- *     } else {
- *         throw error;
- *     }
- * }
- * ```
- * @category Errors
- */
-export declare function isDIDError(error: unknown): error is BaseError;

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

@@ -1,30 +0,0 @@
-import { ChatMode } from '../../types';
-import { BaseError } from '../base-error';
-
-/**
- * A chat could not be created for the session.
- *
- * {@link AgentManager.chat | chat()} creates a chat on the first message when the session does not
- * have one yet; this error is thrown when that call comes back without one, so it rejects the
- * promise `chat()` returned and the user's message is not sent. It is not delivered to
- * {@link AgentManagerCallbacks.onError | onError} — catch it around `chat()`. A failing request
- * surfaces as {@link HttpError} or {@link NetworkError} instead; this error is the case where the
- * request succeeded but produced no chat.
- *
- * The message names the {@link ChatMode} in effect and whether a persistent chat was asked for, for
- * example `Failed to create persistent chat, mode: Functional`.
- * {@link BaseError.kind | kind} is `'ChatCreationFailed'`.
- *
- * @category Errors
- */
-export declare class ChatCreationFailed extends BaseError {
-    /**
-     * Always `'ChatCreationFailed'`. Branch on it to tell this failure from the other SDK errors.
-     */
-    readonly kind: 'ChatCreationFailed';
-    /**
-     * Builds the error from the attempt that failed.
-     * @internal The SDK builds this itself; applications catch the error rather than construct it.
-     */
-    constructor(mode: ChatMode, persistent: boolean);
-}

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

@@ -1,35 +0,0 @@
-import { ChatMode } from '../../types';
-import { BaseError } from '../base-error';
-
-/**
- * The server put the session into a different chat mode from the one that was requested, and the
- * new mode cannot stream video.
- *
- * Raised while {@link AgentManager.connect | connect()} runs, when the chat the server created came
- * back in a mode other than the requested {@link AgentManagerOptions.mode | mode} and that mode is
- * not {@link ChatMode.Functional | Functional} — {@link ChatMode.TextOnly | TextOnly} or
- * {@link ChatMode.Maintenance | Maintenance}, for instance. The comparison only runs when `mode` was
- * set in the options, so a session that never asked for a mode never sees this error. The SDK
- * disconnects the stream it had just opened and `connect()` resolves anyway, so no video will play
- * and {@link AgentManagerCallbacks.onSrcObjectReady | onSrcObjectReady} will not fire again: the
- * session continues as a text chat.
- *
- * It is delivered to {@link AgentManagerCallbacks.onError | onError} and never thrown, so
- * `connect()` does not reject on it.
- * {@link AgentManagerCallbacks.onModeChange | onModeChange} fires with the new mode just before it.
- * Treat it as a signal to switch the interface to text, not as a connection failure.
- * {@link BaseError.kind | kind} is `'ChatModeDowngraded'`.
- *
- * @category Errors
- */
-export declare class ChatModeDowngraded extends BaseError {
-    /**
-     * Always `'ChatModeDowngraded'`. Branch on it to tell this failure from the other SDK errors.
-     */
-    readonly kind: 'ChatModeDowngraded';
-    /**
-     * Builds the error from the mode the session ended up in.
-     * @internal The SDK builds this itself; applications catch the error rather than construct it.
-     */
-    constructor(mode: ChatMode);
-}

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

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

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

@@ -1,74 +0,0 @@
-import { BaseError, ErrorJson } from './base-error';
-import { RequestMeta } from './request-meta';
-
-/**
- * A request to the Agents API came back with a non-2xx status.
- *
- * Raised for every REST call the SDK makes on the application's behalf: fetching the agent in
- * {@link createAgentManager}, creating the stream and the chat during
- * {@link AgentManager.connect | connect()}, sending a message with
- * {@link AgentManager.chat | chat()}, and the rating and feedback calls. The same error is both
- * handed to {@link AgentManagerCallbacks.onError | onError} and thrown, so it also rejects the
- * promise of whichever method made the request — catch it around that call, or handle it centrally
- * in the callback. For the message-send request behind {@link AgentManager.chat | chat()} the
- * callback may not fire; the error is still thrown. Typical cases are `401` or `403` for a client
- * key that is not authorized for the agent or the calling domain, and `404` for an unknown agent
- * id; an account that is out of credits comes back with {@link BaseError.kind | kind}
- * `'InsufficientCreditsError'`. A `429` is retried twice, one second apart (three attempts in
- * total), before it surfaces.
- *
- * {@link BaseError.kind | kind} is the server's own classification when the response body is D-ID's
- * `{ kind, description }` envelope — the `'InsufficientCreditsError'` above is one — and
- * `'HttpError'` otherwise, so a message-independent branch on a specific API failure is possible.
- *
- * The message is the envelope's `description` when the body is that JSON, and the raw body
- * otherwise — truncated to 256 characters either way, because a gateway can answer a 5xx with a
- * whole HTML page.
- *
- * @category Errors
- */
-export declare class HttpError extends BaseError {
-    /**
-     * The server's own classification of the failure, and `'HttpError'` when the response body was
-     * not D-ID's `{ kind, description }` envelope.
-     *
-     * The only {@link BaseError.kind | kind} in the SDK that is not a fixed literal, so it stays
-     * typed `string`: an account out of credits comes back as `'InsufficientCreditsError'`, for
-     * instance. Use {@link HttpError.status | status} for the transport-level branch and this for
-     * the API-level one.
-     */
-    readonly kind: string;
-    /**
-     * HTTP status code of the response, such as `401`, `404` or `500`.
-     */
-    readonly status: number;
-    /**
-     * Path of the request that failed, relative to the API client's base path — for example
-     * `/agt_x/chat/cht_y` for a message sent to a chat.
-     *
-     * Absent when the error was constructed without call context. {@link NetworkError.endpoint}
-     * is the same value on a transport failure.
-     */
-    readonly endpoint?: string;
-    /**
-     * HTTP method of the request that failed, such as `GET` or `POST`.
-     *
-     * Absent when the error was constructed without call context.
-     */
-    readonly method?: string;
-    /**
-     * Builds the error from the failing response.
-     * @internal The SDK builds this itself; applications catch the error rather than construct it.
-     */
-    constructor(status: number, body: string, meta?: RequestMeta);
-    /**
-     * Serializes the error, adding the failing call to what
-     * {@link BaseError.toJson | BaseError.toJson()} already returns.
-     *
-     * Adds `httpStatus` from {@link HttpError.status | status}, and `endpoint` and `method` when the
-     * call context is known. The raw `status` property is serialized as `httpStatus`.
-     *
-     * @returns The error as plain, JSON-serializable data.
-     */
-    toJson(): ErrorJson;
-}

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

@@ -1,9 +0,0 @@
-export * from './base-error';
-export * from './chat/chat-creation-failed';
-export * from './chat/chat-mode-downgraded';
-export * from './http-error';
-export * from './network-error';
-export * from './request-meta';
-export * from './stream-error';
-export * from './validation-error';
-export * from './ws-error';

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

@@ -1,72 +0,0 @@
-import { BaseError, ErrorJson } from './base-error';
-import { RequestMeta } from './request-meta';
-
-/**
- * A request to the Agents API never reached the server, so no response came back.
- *
- * This is the transport failure counterpart of {@link HttpError}, where the server did answer: the
- * browser's `fetch` rejected outright because the device is offline, DNS or TLS failed, the
- * connection was refused or the request was blocked, for instance by CORS or an extension. Like
- * {@link HttpError} it is both handed to {@link AgentManagerCallbacks.onError | onError} and
- * thrown, so it also rejects the promise of the method that made the request; for the message-send
- * request behind {@link AgentManager.chat | chat()} the callback may not fire, but the error is
- * still thrown. A request the SDK cancelled itself is not reported this way — the browser's own
- * `AbortError` is rethrown unchanged.
- *
- * The message is always `'Network request failed'`; the browser's own wording, such as
- * `'Failed to fetch'`, is kept in {@link BaseError.originalError | originalError} and appears as
- * `cause` in {@link NetworkError.toJson | toJson()}. The remaining properties record what was
- * happening at the time, which is usually what distinguishes a dropped connection from a tab that
- * was backgrounded.
- *
- * @category Errors
- */
-export declare class NetworkError extends BaseError {
-    /**
-     * Always `'NetworkError'`. Branch on it to tell this failure from the other SDK errors.
-     */
-    readonly kind: 'NetworkError';
-    /**
-     * Path of the request that failed, relative to the API client's base path — for example
-     * `/agt_x/chat/cht_y`.
-     */
-    readonly endpoint?: string;
-    /**
-     * HTTP method of the request that failed, such as `GET` or `POST`.
-     */
-    readonly method?: string;
-    /**
-     * How long the request ran before it failed, in milliseconds.
-     *
-     * A value close to zero usually means the request never left the browser; a large one points
-     * at a connection that was established and then lost.
-     */
-    readonly durationMs?: number;
-    /**
-     * The browser's `navigator.onLine` at the moment of the failure — `false` when the device
-     * reported itself offline.
-     */
-    readonly online?: boolean;
-    /**
-     * The page's `document.visibilityState` at the moment of the failure.
-     *
-     * `'hidden'` means the tab was in the background, where browsers throttle or suspend network
-     * activity.
-     */
-    readonly visibility?: DocumentVisibilityState;
-    /**
-     * Wraps a rejected `fetch` together with what was known about the call.
-     * @internal The SDK builds this itself; applications catch the error rather than construct it.
-     */
-    constructor(originalError?: unknown, meta?: RequestMeta);
-    /**
-     * Serializes the error, adding the captured context to what
-     * {@link BaseError.toJson | BaseError.toJson()} already returns.
-     *
-     * Each of `endpoint`, `method`, `durationMs`, `online` and `visibility` is included only when it
-     * was captured.
-     *
-     * @returns The error as plain, JSON-serializable data.
-     */
-    toJson(): ErrorJson;
-}

package/dist/src/errors/request-meta.d.ts

@@ -1,12 +0,0 @@
-/**
- * Request context recorded on an error: what was requested, how long it took and what the tab
- * could see of the network at the time. Shared by `HttpError` and `NetworkError`.
- * @internal Implementation type; not part of the public SDK surface.
- */
-export interface RequestMeta {
-    endpoint?: string;
-    method?: string;
-    durationMs?: number;
-    online?: boolean;
-    visibility?: DocumentVisibilityState;
-}

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

@@ -1,37 +0,0 @@
-import { BaseError } from './base-error';
-
-/**
- * Something went wrong inside the live audio and video stream.
- *
- * Unlike {@link HttpError} and {@link NetworkError}, which come from REST calls, this one comes
- * from the transport carrying the agent's video, so it is only ever delivered to
- * {@link AgentManagerCallbacks.onError | onError} — no call of yours is necessarily in flight when
- * it happens, and nothing throws it. The SDK raises it when:
- *
- * - no media track is subscribed within the timeout after the LiveKit room used by Expressive (V4)
- *   agents connects, after which the SDK disconnects the stream;
- * - the LiveKit room reports a media-device or encryption failure;
- * - a message cannot be put on the data channel — the WebRTC channel used by Talks (V2) and Clips
- *   (V3) is not open, or the LiveKit room is not connected or rejects the send;
- * - the server reports that the stream itself failed, with the message
- *   `Stream failed with event <event>`.
- *
- * Most of these leave the session unusable, so the useful response is to tell the user and call
- * {@link AgentManager.reconnect | reconnect()}. {@link BaseError.kind | kind} is `'StreamError'`.
- * The message describes the failure, and is the plain `'Stream Error'` when the transport gave no
- * detail; the underlying error, where there was one, is kept as
- * {@link BaseError.originalError | originalError}.
- *
- * @category Errors
- */
-export declare class StreamError extends BaseError {
-    /**
-     * Always `'StreamError'`. Branch on it to tell this failure from the other SDK errors.
-     */
-    readonly kind: 'StreamError';
-    /**
-     * Wraps a streaming failure.
-     * @internal The SDK builds this itself; applications catch the error rather than construct it.
-     */
-    constructor(message: string, originalError?: unknown);
-}

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

@@ -1,67 +0,0 @@
-import { BaseError } from './base-error';
-
-/**
- * A method was called with arguments, or in a state, that the SDK will not send to the Agents
- * API.
- *
- * This is one of the two SDK errors that only ever reach the caller and are never delivered to
- * {@link AgentManagerCallbacks.onError | onError} (the other is {@link ChatCreationFailed}): it is
- * the direct answer to the call you just made, and every method that raises it rejects the promise
- * it returned, so `await` the call inside a `try`/`catch` or attach a `.catch()`. The SDK raises it
- * from
- * {@link AgentManager.chat | chat()} when the message is empty or 2000 characters or longer, when
- * the session's {@link ChatMode} has chat disabled or is in maintenance, and when the chat or the
- * stream has not been initialized yet; from {@link AgentManager.speak | speak()} when it is called
- * before {@link AgentManager.connect | connect()}; and from
- * {@link AgentManager.rate | rate()}, {@link AgentManager.deleteRate | deleteRate()} and
- * {@link AgentManager.submitFeedback | submitFeedback()} when no chat has started, plus, for
- * `rate()` alone, when no message with the given id is in the transcript. It is also raised from
- * {@link createAgentManager} and {@link AgentManager.changeMode | changeMode()} when an Expressive
- * (V4) agent is asked for {@link ChatMode.Off} or {@link ChatMode.DirectPlayback}, which only Talks
- * (V2) and Clips (V3) agents support. The five Expressive-only media methods —
- * {@link AgentManager.publishMicrophoneStream | publishMicrophoneStream()},
- * {@link AgentManager.replaceMicrophoneTrack | replaceMicrophoneTrack()},
- * {@link AgentManager.publishCameraStream | publishCameraStream()},
- * {@link AgentManager.setSttLanguage | setSttLanguage()} and
- * {@link AgentManager.sendDataChannelMessage | sendDataChannelMessage()} — raise it the other way
- * round: when the session is a Talks (V2) or Clips (V3) one, or
- * {@link AgentManager.connect | connect()} has not run yet.
- *
- * Nothing was sent to the Agents API when this is raised, so the session stays usable: fix the
- * argument or wait for {@link ConnectionState.Connected | 'connected'} and call again.
- * {@link BaseError.kind | kind} is `'ValidationError'`.
- *
- * @category Errors
- */
-export declare class ValidationError extends BaseError {
-    /**
-     * Name of the field the failure is about.
-     *
-     * The SDK does not populate it — every validation it raises passes the message alone — so it
-     * is only set on a `ValidationError` an application constructed itself. It is also left out
-     * of {@link BaseError.toJson | toJson()}, so a serialized validation error carries only its
-     * kind and message.
-     */
-    readonly key?: string | undefined;
-    /**
-     * Always `'ValidationError'`. Branch on it to tell this failure from the other SDK errors.
-     */
-    readonly kind: 'ValidationError';
-    /**
-     * Builds a validation failure. The SDK does this itself before it performs a request.
-     *
-     * @param message - What was wrong with the call, such as `'Message cannot be empty'`.
-     * @param key - Name of the field the failure is about. The SDK's own validations leave it
-     * unset.
-     */
-    constructor(message: string, 
-    /**
-     * Name of the field the failure is about.
-     *
-     * The SDK does not populate it — every validation it raises passes the message alone — so it
-     * is only set on a `ValidationError` an application constructed itself. It is also left out
-     * of {@link BaseError.toJson | toJson()}, so a serialized validation error carries only its
-     * kind and message.
-     */
-    key?: string | undefined);
-}

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

@@ -1,34 +0,0 @@
-import { BaseError } from './base-error';
-
-/**
- * The web socket the SDK uses for chat notifications failed to connect.
- *
- * Talks (V2) and Clips (V3) sessions open a web socket alongside the video stream; the agent's
- * answer arrives over it as `partial` and `answer` events, which is what drives
- * {@link AgentManagerCallbacks.onNewMessage | onNewMessage}. This error is raised when that socket
- * emits an `error` event, once per failed attempt while
- * {@link AgentManager.connect | connect()} is retrying. It is only delivered to
- * {@link AgentManagerCallbacks.onError | onError} and never thrown, so there is nothing to catch
- * around `connect()` for it; if every attempt fails, `connect()` rejects with the browser's own
- * socket event instead.
- *
- * The socket is not opened at all for Expressive (V4) agents, which receive the same events over
- * the LiveKit data channel, nor in {@link ChatMode.DirectPlayback | DirectPlayback} mode, so the
- * error cannot occur in either case.
- *
- * {@link BaseError.kind | kind} is `'WSError'`, and the message is
- * `'Websocket failed to connect'`.
- *
- * @category Errors
- */
-export declare class WsError extends BaseError {
-    /**
-     * Always `'WSError'` — note the capitalization, which does not match the class name.
-     */
-    readonly kind: 'WSError';
-    /**
-     * Wraps a web socket failure, built from the socket's `error` event.
-     * @internal The SDK builds this itself; applications catch the error rather than construct it.
-     */
-    constructor(message: string);
-}

package/dist/src/index.d.ts

@@ -1,20 +0,0 @@
-export { createAgentManager } from './services/agent-manager';
-export type { Auth, BasicAuth, BearerToken, ClientKeyAuth } from './types/auth';
-export type { Agent, AgentAvatar, EndOfCallFeedbackConfig } from './types/entities/agents/agent';
-export type { AgentManager, AgentManagerCallbacks, AgentManagerOptions, StreamOptions, } from './types/entities/agents/manager';
-export { AvatarType } from './types/entities/avatar';
-export type { STTTokenResponse } from './types/voice/stt';
-export { AgentActivityState, ConnectionState, ConnectivityState, PublicDataChannelTopic, StreamEndReason, StreamEvents, StreamingState, } from './types/stream/stream';
-export type { ClientToolHandler, RunningToolCall, StreamCreatedInfo, ToolCallDonePayload, ToolCallErrorPayload, ToolCallStartedPayload, ToolEventCallback, ToolExecutionMode, } from './types/stream/stream';
-export type { SendStreamPayloadResponse } from './types/stream/rtc';
-export { StreamType } from './types/stream/stream';
-export type { CompatibilityMode } from './types/stream/stream';
-export type { AudioStreamScript, SupportedStreamScript, TextStreamScript } from './types/stream-script';
-export { ChatMode } from './types/entities/agents/chat';
-export type { ChatResponse, Interrupt, Message, MessagePart, MessageSentiment, RatingEntity, RetrievalMetadata, SubmitFeedbackResponse, } from './types/entities/agents/chat';
-export { parseMessageParts } from './utils/content-parser';
-export { isAwaitingTool } from './utils/tool-calls';
-export { Providers, VoiceAccess } from './types/voice/tts';
-export type { AmazonTtsProvider, AzureOpenAiTtsProvider, ElevenlabsTtsProvider, MicrosoftTtsProvider, StreamTextToSpeechProviders, Voice, VoiceConfigElevenlabs, VoiceConfigMicrosoft, } from './types/voice/tts';
-export { BaseError, ChatCreationFailed, ChatModeDowngraded, HttpError, NetworkError, StreamError, ValidationError, WsError, isDIDError, } from './errors';
-export type { ErrorJson } from './errors';

package/dist/src/public-api.test.d.ts

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

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

@@ -1,19 +0,0 @@
-import { StreamingManager } from '../streaming-manager';
-import { Agent, AgentManagerOptions, AgentsAPI, AudioDetectionMetrics, Chat, ChatProgressCallback, CreateSessionV2Options, CreateStreamOptions, StreamingManagerOptions } from '../../types';
-import { Analytics } from '../analytics/mixpanel';
-
-type ConnectToManagerOptions = AgentManagerOptions & {
-    callbacks: AgentManagerOptions['callbacks'] & {
-        onVideoIdChange?: (videoId: string | null) => void;
-        /** Internal callback for livekit-manager data channel events */
-        onMessage?: ChatProgressCallback;
-        onFirstAudioDetected?: (metrics: AudioDetectionMetrics) => void;
-    };
-    chatId?: string;
-    rpcMethods?: StreamingManagerOptions['rpcMethods'];
-};
-export declare function initializeStreamAndChat(agent: Agent, options: ConnectToManagerOptions, agentsApi: AgentsAPI, analytics: Analytics, chat?: Chat): Promise<{
-    chat?: Chat;
-    streamingManager?: StreamingManager<CreateStreamOptions | CreateSessionV2Options>;
-}>;
-export {};

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

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