@convai/web-sdk 1.8.0-beta.6 → 1.8.0-beta.8

package/dist/core/ConvaiClient.js

@@ -14,10 +14,11 @@ import { MemoryManager } from "./MemoryManager.js";
 import { CharacterVersionManager } from "./CharacterVersionManager.js";
 import { resolveCharacterReference, } from "./characterReference.js";
 import { ConnectionStateHandler } from "./ConnectionStateHandler.js";
-import { buildActionConnectConfig, buildBlendshapeConnectConfig, buildEmotionConnectConfig, serializeActionProtocolCapabilities, } from "./connectRequest.js";
+import { buildActionConnectConfig, buildBlendshapeConnectConfig, buildEmotionConnectConfig, serializeProtocolCapabilities, validateActionProtocolSelection, validateModelOutputVersionSelection, } from "./connectRequest.js";
 import { shouldPreemptForContextUpdateResponse, shouldPreemptForExplicitRespondMode, } from "./contextUpdateRequest.js";
 import { resolveVisionInputConfig, serializeVisionInputConfig, } from "./visionRequest.js";
 import { SSESession } from "./SSESession.js";
+import { isJsonValue } from "./modelOutput.js";
 import { isValidLogicalTurnId } from "./logicalTurn.js";
 // Module-level registry — populated by importing @convai/web-sdk/vanilla/websocket
 let _wsFactory = null;
@@ -27,6 +28,33 @@ function normalizeStateOfMind(value) {
     const normalized = value.trim().toLowerCase();
     return normalized === "neutral" || normalized === "" ? null : normalized;
 }
+/**
+ * Rejection from {@link ConvaiClient.sendActionResultAndWait} after local
+ * validation succeeds. Inspect `reason` rather than parsing the message.
+ */
+export class ActionResultAckError extends Error {
+    constructor(message, options) {
+        super(message);
+        this.name =
+            options.reason === "aborted"
+                ? "AbortError"
+                : options.reason === "timeout"
+                    ? "TimeoutError"
+                    : "ActionResultAckError";
+        this.reason = options.reason;
+        this.toolCallId = options.toolCallId;
+        this.errorCode = options.errorCode;
+        this.response = options.response;
+        this.cause = options.cause;
+    }
+}
+/**
+ * Marks a publication exchange failure that is safe to retry with the same
+ * logical connect attempt. The launch grant itself is single-use, so callers
+ * must never mint or submit a second grant for this recovery path.
+ */
+class RetryablePublishedChatExchangeError extends Error {
+}
 /**
  * Custom reconnect policy that disables automatic reconnection
  */
@@ -96,6 +124,7 @@ export class ConvaiClient extends EventEmitter {
         /** Roster commands awaiting their ack, keyed by command id. */
         this._pendingRosterCommands = new Map();
         this._rosterCommandSeq = 0;
+        this._requestTraceId = null;
         this._isBotReady = false;
         this._participantSid = "";
         this._storedConfig = null;
@@ -111,10 +140,12 @@ export class ConvaiClient extends EventEmitter {
         this._sseSession = null;
         this._logRtviMessages = true;
         this._isDisconnecting = false;
+        this._isPublishedChatSession = false;
         // RTVI client-ready handshake (race-proof bot-ready delivery)
         this._clientReadyRetryTimer = null;
         this._clientReadyTimeoutTimer = null;
         this._clientReadyMsgId = null;
+        this._pendingActionResultAcks = new Map();
         // Conversation session tracking
         this._conversationSessionId = 0;
         this._conversationStartTime = 0;
@@ -193,6 +224,9 @@ export class ConvaiClient extends EventEmitter {
     get connectionType() {
         return this._connectionType;
     }
+    get isPublishedChatSession() {
+        return this._isPublishedChatSession;
+    }
     get apiKey() {
         return this._apiKey;
     }
@@ -250,6 +284,9 @@ export class ConvaiClient extends EventEmitter {
     get characterSessionId() {
         return this._characterSessionId;
     }
+    on(event, callback) {
+        return super.on(event, callback);
+    }
     /**
      * Server-owned snapshot of a multi-character room, or null for a
      * single-character session. Carries the room id, epochs and roster.
@@ -285,6 +322,10 @@ export class ConvaiClient extends EventEmitter {
         }
         return this._messageHandler.appendLocalMessage(message);
     }
+    /** Trace id of the /connect that produced this session; quote it to backend support. */
+    get requestTraceId() {
+        return this._requestTraceId;
+    }
     get isBotReady() {
         return this._isBotReady;
     }
@@ -375,8 +416,17 @@ export class ConvaiClient extends EventEmitter {
             this.updateState({ isConnected: true });
             this.emit("botReady");
         });
-        this._messageHandler.on("messagesChange", (messages) => {
-            this.emit("message", messages[messages.length - 1]);
+        this._messageHandler.on("messagesChange", (messages, updatedMessage, updatedMessages) => {
+            // Most updates target the tail. Correlated v2 chunks can update an
+            // earlier streaming row. A v2 stop can finalize several rows at once.
+            if (updatedMessages?.length) {
+                for (const message of updatedMessages) {
+                    this.emit("message", message);
+                }
+            }
+            else {
+                this.emit("message", updatedMessage ?? messages[messages.length - 1]);
+            }
             this.emit("messagesChange", messages);
         });
         this._messageHandler.on("userTranscriptionChange", (transcription) => {
@@ -498,6 +548,15 @@ export class ConvaiClient extends EventEmitter {
             }
             this.emit("characterStatus", status);
         });
+        this._messageHandler.on("modelOutput", (data) => {
+            this.emit("modelOutput", data);
+        });
+        this._messageHandler.on("botLlmTextRaw", (data) => {
+            this.emit("botLlmTextRaw", data);
+        });
+        this._messageHandler.on("modelOutputProtocolError", (data) => {
+            this.emit("modelOutputProtocolError", data);
+        });
         this._messageHandler.on("serverResponse", (response) => {
             this._handleRosterServerResponse(response);
             this.emit("serverResponse", response);
@@ -563,6 +622,30 @@ export class ConvaiClient extends EventEmitter {
             this._room.localParticipant.publishData(encodedData, { reliable: true });
         }
     }
+    /**
+     * Publish exactly one message while retaining the transport's local completion
+     * signal. Server acceptance is still proved separately by `serverResponse`.
+     */
+    async publishMessageAndWaitForLocalPublication(type, data, id) {
+        const message = id === undefined ? { type, data } : { type, id, data };
+        if (this._activeTransport === "websocket") {
+            if (!this._wsSession?.isConnected) {
+                throw new Error("The action-result WebSocket transport is no longer available");
+            }
+            this._wsSession.sendMessage(type, data);
+            return;
+        }
+        if (this._activeTransport === "livekit" &&
+            this._room?.localParticipant &&
+            this._room.state !== "disconnected") {
+            const encodedData = new TextEncoder().encode(JSON.stringify(message));
+            await this._room.localParticipant.publishData(encodedData, {
+                reliable: true,
+            });
+            return;
+        }
+        throw new Error("The action-result transport is no longer available");
+    }
     /**
      * Returns true when a message can be sent on the active transport.
      */
@@ -586,13 +669,18 @@ export class ConvaiClient extends EventEmitter {
         }
         // Store config for reconnection
         this._storedConfig = { ...finalConfig };
+        this._isPublishedChatSession = false;
         // Use characterSessionId from config when reconnecting (so we resume the same session)
         if (finalConfig.characterSessionId &&
             finalConfig.characterSessionId !== "-1") {
             this._characterSessionId = finalConfig.characterSessionId;
         }
         const configWithDefaults = this.applyConfigDefaults(finalConfig);
+        // A fresh connect starts on the v1 model-output contract; the /connect
+        // response upgrades it once the server confirms the negotiated version.
+        this._messageHandler.setModelOutputVersion(1);
         this.updateState({ isConnecting: true });
+        this._requestTraceId = null;
         try {
             // Store connection config
             this._apiKey = configWithDefaults.apiKey ?? null;
@@ -674,6 +762,7 @@ export class ConvaiClient extends EventEmitter {
             // Prepare request body with required parameters
             const characterSessionIdToSend = configWithDefaults.characterSessionId ?? this._characterSessionId;
             const isRoster = isRosterConfig(configWithDefaults);
+            const serializedCapabilities = serializeProtocolCapabilities(configWithDefaults.capabilities);
             const requestBody = {
                 ...(isRoster
                     ? buildRosterConnectFields(configWithDefaults)
@@ -686,6 +775,9 @@ export class ConvaiClient extends EventEmitter {
                     end_user_metadata: configWithDefaults.endUserMetadata,
                 }),
                 transport: transportType,
+                ...(serializedCapabilities && {
+                    capabilities: serializedCapabilities,
+                }),
                 connection_type: connType,
                 ...buildBlendshapeConnectConfig(configWithDefaults),
                 ...(buildEmotionConnectConfig(configWithDefaults) && {
@@ -698,12 +790,13 @@ export class ConvaiClient extends EventEmitter {
                 ...(effectiveVisionInputConfig && {
                     vision_input_config: serializeVisionInputConfig(effectiveVisionInputConfig),
                 }),
+                ...(configWithDefaults.visionPromptMode !== undefined && {
+                    vision_prompt_mode: configWithDefaults.visionPromptMode,
+                }),
                 ...(configWithDefaults.respondModes && {
                     respond_modes: this.serializeRespondModes(configWithDefaults.respondModes),
                 }),
-                ...(serializeActionProtocolCapabilities(configWithDefaults.capabilities) && {
-                    capabilities: serializeActionProtocolCapabilities(configWithDefaults.capabilities),
-                }),
+                ...(serializedCapabilities && { capabilities: serializedCapabilities }),
                 ...(configWithDefaults.sceneDescription && {
                     scene_description: configWithDefaults.sceneDescription,
                 }),
@@ -844,6 +937,10 @@ export class ConvaiClient extends EventEmitter {
      * await client.connectWithConnectionData(data)
      */
     async connectWithConnectionData(data, config) {
+        // A client can be reused after a published session. This is a normal
+        // credentialed/proxy connection path, so never leave published-only UI
+        // semantics (fresh grant requirement, text-only controls) enabled.
+        this._isPublishedChatSession = false;
         const finalConfig = config || this._storedConfig;
         if (!finalConfig) {
             throw new Error("No configuration provided. Pass config to connectWithConnectionData() or store it in the client");
@@ -1080,6 +1177,10 @@ export class ConvaiClient extends EventEmitter {
      */
     async joinRoom(options) {
         validateJoinOptions(options);
+        // joinRoom is a credentialed Workspace connection, not a publication.
+        // Reset this before further validation so a rejected normal attempt also
+        // cannot leave a reused client in published-session mode.
+        this._isPublishedChatSession = false;
         const stored = this._storedConfig ?? {};
         const url = stored.url ?? "https://realtime-api.convai.com";
         if (!stored.apiKey && !stored.authToken) {
@@ -1244,6 +1345,16 @@ export class ConvaiClient extends EventEmitter {
                 characterSessionId: connectionData.character_session_id,
             };
         }
+        // The server answers a capability request with what it actually selected.
+        // A silent downgrade would leave the client parsing v2 frames as v1 (or the
+        // reverse), so each selection is validated and the model-output version the
+        // message handler decodes is set from the server's answer, not the request.
+        const selectedCapabilities = connectionData.capabilities ?? {};
+        const requestedCapabilities = configWithDefaults.capabilities;
+        validateActionProtocolSelection(requestedCapabilities?.actionProtocolVersion, selectedCapabilities.action_protocol_version);
+        this._messageHandler.setModelOutputVersion(validateModelOutputVersionSelection(requestedCapabilities?.modelOutputVersion, selectedCapabilities.model_output_version));
+        this._requestTraceId =
+            connectionData.request_trace_id ?? null;
         // Seed the roster before the transport comes up, so the first bot-ready and
         // any early roster change already have instances to match against.
         if (this._roster.applyConnectResponse(connectionData)) {
@@ -1425,6 +1536,189 @@ export class ConvaiClient extends EventEmitter {
         }
         this.clearAllManagers();
     }
+    /**
+     * Connect to a published text-chat revision without publisher credentials.
+     *
+     * The launch grant is single-use and is never retained for reconnect. This
+     * path is LiveKit data-only: it does not enable microphone, camera, TTS,
+     * video, or lipsync.
+     */
+    async connectWithPublicationGrant(launchToken, options = {}) {
+        if (typeof launchToken !== "string" ||
+            launchToken.length < 32 ||
+            launchToken.length > 512) {
+            throw new Error("A valid publication launch token is required");
+        }
+        if (this._state.isConnected || this._state.isConnecting) {
+            throw new Error("Disconnect the current session before connecting again");
+        }
+        const throwIfAborted = () => {
+            if (options.signal?.aborted) {
+                throw new DOMException("The operation was aborted", "AbortError");
+            }
+        };
+        throwIfAborted();
+        let abortDisconnect = null;
+        const disconnectOnAbort = () => {
+            abortDisconnect ?? (abortDisconnect = this.disconnect().catch(() => undefined));
+        };
+        const apiUrl = (options.url ?? "https://realtime-api.convai.com").replace(/\/+$/, "");
+        const connectAttemptId = options.connectAttemptId ??
+            (typeof crypto !== "undefined" && "randomUUID" in crypto
+                ? `published_${crypto.randomUUID().replace(/-/g, "")}`
+                : `published_${Date.now()}_${Math.random().toString(36).slice(2)}`);
+        if (!/^[a-zA-Z0-9_-]{1,128}$/.test(connectAttemptId)) {
+            throw new Error("A valid published chat connect attempt id is required");
+        }
+        this._storedConfig = null;
+        this._isPublishedChatSession = true;
+        this._requestTraceId = null;
+        this._apiKey = null;
+        this._authToken = null;
+        this._characterId = null;
+        this._characterSessionId = "-1";
+        this._endUserId = null;
+        this._endUserMetadata = null;
+        this._requestTraceId = null;
+        this._memoryManager = null;
+        this._connectionType = "text";
+        this._activeTransport = "livekit";
+        // Published chat does not negotiate protocol capabilities. A client may
+        // have previously connected to a v2 character, so restore the default v1
+        // handling before accepting this text-only session's legacy envelopes.
+        this._messageHandler.setModelOutputVersion(1);
+        this.updateState({ isConnecting: true });
+        try {
+            options.signal?.addEventListener("abort", disconnectOnAbort, {
+                once: true,
+            });
+            const exchangeGrant = () => fetch(`${apiUrl}/published-chat/connect`, {
+                method: "POST",
+                // A published launch token is bearer-like. Never include any ambient
+                // cookies when the host happens to be same-origin with Core.
+                credentials: "omit",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    launch_token: launchToken,
+                    connect_attempt_id: connectAttemptId,
+                }),
+                signal: options.signal,
+            });
+            const readConnectionResponse = async (response, retryTransientFailure) => {
+                if (!response.ok) {
+                    if (retryTransientFailure && response.status >= 500) {
+                        throw new RetryablePublishedChatExchangeError();
+                    }
+                    const errorText = await response.text();
+                    let errorMessage = `HTTP ${response.status}`;
+                    try {
+                        const errorData = JSON.parse(errorText);
+                        this._requestTraceId =
+                            errorData.request_trace_id ?? errorData.requestTraceId ?? null;
+                        const raw = errorData.message ?? errorData.error ?? errorData.detail;
+                        errorMessage =
+                            typeof raw === "string"
+                                ? raw
+                                : raw == null
+                                    ? errorMessage
+                                    : JSON.stringify(raw);
+                    }
+                    catch {
+                        if (errorText)
+                            errorMessage = `${errorMessage}: ${errorText}`;
+                    }
+                    throw new Error(errorMessage);
+                }
+                let connectionData;
+                try {
+                    connectionData = await response.json();
+                }
+                catch {
+                    if (retryTransientFailure) {
+                        throw new RetryablePublishedChatExchangeError();
+                    }
+                    throw new Error("Published chat returned an invalid connection response");
+                }
+                throwIfAborted();
+                if (typeof connectionData !== "object" ||
+                    connectionData === null ||
+                    typeof connectionData.room_url !== "string" ||
+                    typeof connectionData.token !== "string" ||
+                    typeof connectionData.character_session_id !==
+                        "string") {
+                    if (retryTransientFailure) {
+                        throw new RetryablePublishedChatExchangeError();
+                    }
+                    throw new Error("Published chat returned an invalid connection response");
+                }
+                return connectionData;
+            };
+            const requestConnection = async (retryTransientFailure) => {
+                let response;
+                try {
+                    response = await exchangeGrant();
+                }
+                catch (error) {
+                    throwIfAborted();
+                    if (retryTransientFailure) {
+                        throw new RetryablePublishedChatExchangeError();
+                    }
+                    throw error;
+                }
+                return readConnectionResponse(response, retryTransientFailure);
+            };
+            let connectionData;
+            try {
+                connectionData = await requestConnection(true);
+            }
+            catch (error) {
+                throwIfAborted();
+                if (!(error instanceof RetryablePublishedChatExchangeError)) {
+                    throw error;
+                }
+                // A response can be lost or corrupted after Core consumed the
+                // single-use grant. Retry exactly once with the same attempt key;
+                // Core/Character API replay that logical attempt instead of creating
+                // a second session.
+                connectionData = await requestConnection(false);
+            }
+            throwIfAborted();
+            this._requestTraceId = connectionData.request_trace_id ?? null;
+            this._characterSessionId = connectionData.character_session_id;
+            this._endUserId = connectionData.end_user_id ?? null;
+            this._endUserMetadata = connectionData.end_user_metadata ?? null;
+            await this._room.connect(connectionData.room_url, connectionData.token, {
+                rtcConfig: {
+                    // Hosted Core has TURN, so relay is the safe default. On-prem
+                    // deployments without TURN may explicitly allow host/srflx paths.
+                    iceTransportPolicy: options.iceTransportPolicy ?? "relay",
+                },
+            });
+            throwIfAborted();
+            this._audioManager.syncStateFromRoom({ emit: true });
+            this._participantSid = this._room.localParticipant.sid;
+            this.updateState({
+                isConnected: true,
+                isConnecting: false,
+                endUserId: this._endUserId,
+                endUserMetadata: this._endUserMetadata,
+            });
+            this.emit("connect");
+            this._startClientReadyHandshake();
+        }
+        catch (error) {
+            if (options.signal?.aborted) {
+                abortDisconnect ?? (abortDisconnect = this.disconnect().catch(() => undefined));
+                await abortDisconnect;
+            }
+            this.updateState({ isConnected: false, isConnecting: false });
+            this.emit("error", error);
+            throw error;
+        }
+        finally {
+            options.signal?.removeEventListener("abort", disconnectOnAbort);
+        }
+    }
     /**
      * RTVI client-ready handshake. Server-side gates bot-ready emission on
      * receipt of client-ready (and re-emits bot-ready on every client-ready),
@@ -1652,11 +1946,167 @@ export class ConvaiClient extends EventEmitter {
                 }
                 this.publishMessage("user_text_message", userTextMessage, logicalTurnId);
             }
+            // The submitted line is appended locally on every transport, so it shows
+            // without waiting for a server echo. Sessions that do echo it back as a
+            // final user-transcription are deduplicated in the message handler.
+            this._messageHandler.addUserTextMessage(text);
         }
         catch (error) {
             throw error;
         }
     }
+    /**
+     * Return a correlated terminal result for a client-executed tool call.
+     */
+    sendActionResult(result) {
+        const payload = this.buildActionResultPayload(result);
+        this.publishMessage("action-result", payload);
+    }
+    /**
+     * Publish one correlated terminal result and wait for Core's exact
+     * `server-response` acknowledgement. This method performs one publication;
+     * callers own any idempotent retry policy.
+     */
+    async sendActionResultAndWait(result, options = {}) {
+        const timeoutMs = options.timeoutMs ?? ConvaiClient.ACTION_RESULT_ACK_TIMEOUT_MS;
+        if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+            throw new Error("Action result acknowledgement timeout must be greater than zero");
+        }
+        if (options.signal?.aborted) {
+            throw new ActionResultAckError("Action result acknowledgement was aborted", {
+                reason: "aborted",
+                toolCallId: result.id,
+            });
+        }
+        const payload = this.buildActionResultPayload(result);
+        const toolCallId = payload.id;
+        if (this._pendingActionResultAcks.has(toolCallId)) {
+            throw new ActionResultAckError(`An action result acknowledgement is already pending for ${toolCallId}`, {
+                reason: "duplicate_in_flight",
+                toolCallId,
+            });
+        }
+        const reservation = Symbol(toolCallId);
+        this._pendingActionResultAcks.set(toolCallId, reservation);
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            let timeout = null;
+            let unsubscribe = null;
+            const cleanup = () => {
+                if (timeout !== null) {
+                    clearTimeout(timeout);
+                    timeout = null;
+                }
+                if (unsubscribe) {
+                    unsubscribe();
+                    unsubscribe = null;
+                }
+                options.signal?.removeEventListener("abort", handleAbort);
+                if (this._pendingActionResultAcks.get(toolCallId) === reservation) {
+                    this._pendingActionResultAcks.delete(toolCallId);
+                }
+            };
+            const resolveOnce = (ack) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                resolve(ack);
+            };
+            const rejectOnce = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                reject(error);
+            };
+            const handleAbort = () => {
+                rejectOnce(new ActionResultAckError("Action result acknowledgement was aborted", {
+                    reason: "aborted",
+                    toolCallId,
+                }));
+            };
+            const handleServerResponse = (response) => {
+                if (!response || typeof response !== "object")
+                    return;
+                const candidate = response;
+                if (candidate.event_type !== "action-result")
+                    return;
+                const extras = candidate.extras;
+                if (!extras || extras.tool_call_id !== toolCallId)
+                    return;
+                const message = typeof candidate.message === "string" ? candidate.message : null;
+                if (candidate.status === "success") {
+                    resolveOnce({
+                        toolCallId,
+                        status: "success",
+                        message,
+                        idempotent: extras.idempotent === true,
+                    });
+                    return;
+                }
+                if (candidate.status !== "error")
+                    return;
+                const errorCode = typeof extras.error_code === "string" ? extras.error_code : undefined;
+                rejectOnce(new ActionResultAckError(message ?? errorCode ?? "Core rejected the action result", {
+                    reason: "server_error",
+                    toolCallId,
+                    ...(errorCode ? { errorCode } : {}),
+                    response: candidate,
+                }));
+            };
+            // Register every terminal observer before publication so a synchronous
+            // WebSocket acknowledgement cannot outrun its waiter.
+            unsubscribe = this.on("serverResponse", handleServerResponse);
+            options.signal?.addEventListener("abort", handleAbort, { once: true });
+            timeout = setTimeout(() => {
+                rejectOnce(new ActionResultAckError(`Timed out waiting for action result acknowledgement for ${toolCallId}`, {
+                    reason: "timeout",
+                    toolCallId,
+                }));
+            }, timeoutMs);
+            void this.publishMessageAndWaitForLocalPublication("action-result", payload).catch((cause) => {
+                const detail = cause instanceof Error ? `: ${cause.message}` : "";
+                rejectOnce(new ActionResultAckError(`Failed to publish action result ${toolCallId}${detail}`, {
+                    reason: "publication_error",
+                    toolCallId,
+                    cause,
+                }));
+            });
+        });
+    }
+    buildActionResultPayload(result) {
+        if (!this.isTransportReady()) {
+            throw new Error("Cannot send an action result before the session is ready");
+        }
+        if (!result.id.trim())
+            throw new Error("Action result id is required");
+        if (result.status !== "completed" &&
+            result.status !== "error" &&
+            result.status !== "cancelled") {
+            throw new Error("Unsupported action result status");
+        }
+        if (result.status === "completed" && result.error !== undefined) {
+            throw new Error("Completed action results cannot include error");
+        }
+        if (result.output !== undefined && !isJsonValue(result.output)) {
+            throw new Error("Action result output must contain only finite JSON values");
+        }
+        if (result.error !== undefined && !isJsonValue(result.error)) {
+            throw new Error("Action result error must contain only finite JSON values");
+        }
+        const characterSessionId = result.characterSessionId ?? this._characterSessionId;
+        return {
+            id: result.id,
+            status: result.status,
+            ...(result.output !== undefined && { output: result.output }),
+            ...(result.error !== undefined && { error: result.error }),
+            ...(characterSessionId &&
+                characterSessionId !== "-1" && {
+                character_session_id: characterSessionId,
+            }),
+        };
+    }
     /**
      * Send a trigger message to invoke specific character actions
      */
@@ -1987,6 +2437,7 @@ export class ConvaiClient extends EventEmitter {
 }
 ConvaiClient.CLIENT_READY_RETRY_MS = 500;
 ConvaiClient.CLIENT_READY_TIMEOUT_MS = 45000;
+ConvaiClient.ACTION_RESULT_ACK_TIMEOUT_MS = 10000;
 /**
  * How long to wait for a roster command's ack.
  *