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

package/dist/core/ConvaiClient.js

@@ -5,19 +5,13 @@ import { AudioManager } from "./AudioManager.js";
 import { VideoManager } from "./VideoManager.js";
 import { ScreenShareManager } from "./ScreenShareManager.js";
 import { MessageHandler } from "./MessageHandler.js";
-import { CharacterRoster } from "./CharacterRoster.js";
-import { buildJoinRequestBody, buildRosterConnectFields, isRosterConfig, validateJoinOptions, validateProtocolTopology, validateRosterConfig, } from "./rosterRequest.js";
-import { ConvaiRoomError, roomErrorFromResponse } from "./ConvaiRoomError.js";
 import { SDK_VERSION } from "../version.js";
 import { EventEmitter } from "./EventEmitter.js";
 import { MemoryManager } from "./MemoryManager.js";
-import { CharacterVersionManager } from "./CharacterVersionManager.js";
-import { resolveCharacterReference, } from "./characterReference.js";
 import { ConnectionStateHandler } from "./ConnectionStateHandler.js";
-import { buildActionConnectConfig, buildBlendshapeConnectConfig, buildEmotionConnectConfig, serializeProtocolCapabilities, validateActionProtocolSelection, validateModelOutputVersionSelection, } from "./connectRequest.js";
+import { buildBlendshapeConnectConfig, serializeClientTools, serializeProtocolCapabilities, validateActionProtocolSelection, validateBotLlmTextModeSelection, 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
@@ -28,33 +22,6 @@ 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
  */
@@ -114,16 +81,7 @@ export class ConvaiClient extends EventEmitter {
         this._apiKey = null;
         this._authToken = null;
         this._characterId = null;
-        this._characterVersion = null;
-        this._characterReference = null;
-        this._characterVersionManager = null;
-        this._characterVersionManagerKey = null;
         this._characterSessionId = "-1";
-        /** Roster state for multi-character rooms. Empty for single-character sessions. */
-        this._roster = new CharacterRoster();
-        /** Roster commands awaiting their ack, keyed by command id. */
-        this._pendingRosterCommands = new Map();
-        this._rosterCommandSeq = 0;
         this._requestTraceId = null;
         this._isBotReady = false;
         this._participantSid = "";
@@ -137,7 +95,6 @@ export class ConvaiClient extends EventEmitter {
         this._endUserMetadata = null;
         this._wsSession = null;
         this._activeTransport = null;
-        this._sseSession = null;
         this._logRtviMessages = true;
         this._isDisconnecting = false;
         this._isPublishedChatSession = false;
@@ -145,7 +102,6 @@ export class ConvaiClient extends EventEmitter {
         this._clientReadyRetryTimer = null;
         this._clientReadyTimeoutTimer = null;
         this._clientReadyMsgId = null;
-        this._pendingActionResultAcks = new Map();
         // Conversation session tracking
         this._conversationSessionId = 0;
         this._conversationStartTime = 0;
@@ -155,23 +111,6 @@ export class ConvaiClient extends EventEmitter {
         if (config) {
             this._storedConfig = config;
             this._logRtviMessages = config.logRtviMessages !== false;
-            // Derive the version readouts from the config eagerly, as
-            // characterVersions already is, so a React consumer destructuring
-            // characterReference off the hook sees the selector on first render
-            // rather than null until connect(). A malformed selector is left for
-            // connect() to reject -- the constructor has never thrown on config and
-            // starting to would be a behaviour change.
-            if (config.characterId && !isRosterConfig(config)) {
-                try {
-                    const ref = resolveCharacterReference(config.characterId, config.characterVersion);
-                    this._characterId = ref.characterId;
-                    this._characterVersion = ref.version;
-                    this._characterReference = ref.reference;
-                }
-                catch {
-                    /* reported by connect() */
-                }
-            }
         }
         // Initialize room with no reconnect policy
         this._room = new Room({
@@ -189,8 +128,6 @@ export class ConvaiClient extends EventEmitter {
             endUserId: null,
             endUserMetadata: null,
             metrics: [],
-            characters: [],
-            activeMembershipId: null,
             disconnectReason: null,
         };
         // Default audio settings for optimal interruption handling
@@ -236,42 +173,6 @@ export class ConvaiClient extends EventEmitter {
     get characterId() {
         return this._characterId;
     }
-    get characterVersion() {
-        return this._characterVersion;
-    }
-    get characterReference() {
-        return this._characterReference;
-    }
-    /**
-     * Character version manager for the configured character. Built from the
-     * live connection when there is one, otherwise from the stored config, so
-     * versions can be listed and released before connecting. Null without an
-     * API key (the Character REST platform does not accept realtime auth tokens).
-     */
-    get characterVersions() {
-        const apiKey = this._apiKey ?? this._storedConfig?.apiKey ?? null;
-        const rawCharacterId = this._characterId ?? this._storedConfig?.characterId ?? null;
-        if (!apiKey || !rawCharacterId)
-            return null;
-        let characterId = rawCharacterId;
-        try {
-            characterId = resolveCharacterReference(rawCharacterId).characterId;
-        }
-        catch {
-            // A malformed id is reported by connect(); use it verbatim here.
-        }
-        const baseUrl = this._storedConfig?.characterApiUrl ?? undefined;
-        const key = `${apiKey}\u0000${characterId}\u0000${baseUrl ?? ""}`;
-        if (this._characterVersionManagerKey !== key) {
-            this._characterVersionManager = new CharacterVersionManager({
-                apiKey,
-                characterId,
-                baseUrl,
-            });
-            this._characterVersionManagerKey = key;
-        }
-        return this._characterVersionManager;
-    }
     get room() {
         return this._room;
     }
@@ -284,45 +185,6 @@ 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.
-     */
-    get roomSession() {
-        return this._roster.roomSession;
-    }
-    /**
-     * Character instances in a multi-character room, in roster order. Empty for a
-     * single-character session, so `length` distinguishes the two.
-     */
-    get characters() {
-        return this._roster.characters;
-    }
-    /** Membership currently receiving user turns, or null. */
-    get activeMembershipId() {
-        return this._roster.activeMembershipId;
-    }
-    /**
-     * Start or stop the server streaming per-turn usage/cost breakdowns as
-     * `usageUpdate` events. Informational only; server-side usage tracking and
-     * billing are unaffected either way.
-     */
-    toggleUsageUpdates(enabled) {
-        if (!this.isTransportReady())
-            return;
-        this.publishMessage("usage-toggle", { enabled });
-    }
-    /** Insert a transcript line locally. Nothing is sent; nothing is billed. */
-    appendMessage(message) {
-        if (!message?.content?.trim()) {
-            throw new Error("appendMessage requires non-empty content");
-        }
-        return this._messageHandler.appendLocalMessage(message);
-    }
-    /** Trace id of the /connect that produced this session; quote it to backend support. */
     get requestTraceId() {
         return this._requestTraceId;
     }
@@ -352,60 +214,12 @@ export class ConvaiClient extends EventEmitter {
      */
     setupEventListeners() {
         // Room event listeners
-        // Per-membership audio binding. In a roster room every character is its
-        // own participant with identity `character:{membership_id}`; the guide's
-        // rule is to bind a track to the exact member or drop it, never to fall
-        // back to the active character. Single-character rooms keep the legacy
-        // behaviour: the track is surfaced with no attribution.
-        this._room.on(RoomEvent.TrackSubscribed, (track, _publication, participant) => {
-            if (track.kind !== "audio")
-                return;
-            const identity = participant.identity;
-            if (!this._roster.isMultiCharacter) {
-                this.emit("characterAudioTrack", {
-                    membershipId: null,
-                    characterId: this._characterId,
-                    participantIdentity: identity,
-                    track: track.mediaStreamTrack,
-                });
-                return;
-            }
-            const membershipId = identity.startsWith("character:")
-                ? identity.slice("character:".length)
-                : null;
-            const member = membershipId ? this._roster.find(membershipId) : undefined;
-            if (!member) {
-                // Unattributable in a roster room: quarantine rather than guess.
-                if (this._logRtviMessages) {
-                    console.warn(`[ConvaiClient] dropped audio track from unattributed participant "${identity}"`);
-                }
-                return;
-            }
-            this.emit("characterAudioTrack", {
-                membershipId: member.membershipId,
-                characterId: member.characterId,
-                participantIdentity: identity,
-                track: track.mediaStreamTrack,
-            });
-        });
         this._room.on(RoomEvent.Disconnected, (reason) => {
             this._connectionStateHandler.handleDisconnected(reason);
         });
         this._room.on(RoomEvent.ConnectionStateChanged, this._connectionStateHandler.handleConnectionStateChanged.bind(this._connectionStateHandler));
         // Message handler events
-        this._messageHandler.on("botReady", (about) => {
-            // Each roster member sends its own bot-ready. Feed the roster before the
-            // de-dupe below, which only guards the single consumer-facing event --
-            // otherwise every member after the first would be dropped.
-            if (this._roster.applyBotReady(about)) {
-                this.updateState({
-                    characters: this._roster.characters,
-                    activeMembershipId: this._roster.activeMembershipId,
-                });
-                const membershipId = about?.membership_id;
-                if (membershipId)
-                    this.emit("characterReady", this._roster.find(membershipId));
-            }
+        this._messageHandler.on("botReady", () => {
             // Server may send multiple bot-ready frames (one per client-ready
             // we retried). Only surface the first to consumers per connect.
             if (this._isBotReady) {
@@ -416,17 +230,8 @@ export class ConvaiClient extends EventEmitter {
             this.updateState({ isConnected: true });
             this.emit("botReady");
         });
-        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._messageHandler.on("messagesChange", (messages) => {
+            this.emit("message", messages[messages.length - 1]);
             this.emit("messagesChange", messages);
         });
         this._messageHandler.on("userTranscriptionChange", (transcription) => {
@@ -508,9 +313,6 @@ export class ConvaiClient extends EventEmitter {
         this._messageHandler.on("llmNoResponse", () => {
             this.emit("llmNoResponse");
         });
-        this._messageHandler.on("botTurnCompleted", (data) => {
-            this.emit("botTurnCompleted", data);
-        });
         // Forward bot-output event (aggregated output with spoken status)
         this._messageHandler.on("botOutput", (data) => {
             this.emit("botOutput", data);
@@ -536,29 +338,13 @@ export class ConvaiClient extends EventEmitter {
         this._messageHandler.on("actionResponse", (data) => {
             this.emit("actionResponse", data);
         });
-        this._messageHandler.on("usageUpdate", (data) => {
-            this.emit("usageUpdate", data);
-        });
-        this._messageHandler.on("characterStatus", (status) => {
-            if (this._roster.applyCharacterStatus(status)) {
-                this.updateState({
-                    characters: this._roster.characters,
-                    activeMembershipId: this._roster.activeMembershipId,
-                });
-            }
-            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);
         });
         this._messageHandler.on("interactionCreated", (data) => {
@@ -609,10 +395,6 @@ export class ConvaiClient extends EventEmitter {
      */
     publishMessage(type, data, id) {
         const message = id === undefined ? { type, data } : { type, id, data };
-        if (this._activeTransport === "sse" && this._sseSession?.isConnected) {
-            this._sseSession.sendMessage(type, data, id);
-            return;
-        }
         if (this._activeTransport === "websocket" && this._wsSession?.isConnected) {
             this._wsSession.sendMessage(type, data);
         }
@@ -622,37 +404,10 @@ 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.
      */
     isTransportReady() {
-        if (this._activeTransport === "sse") {
-            return this._sseSession?.isConnected ?? false;
-        }
         if (this._activeTransport === "websocket") {
             return this._wsSession?.isConnected ?? false;
         }
@@ -675,10 +430,19 @@ export class ConvaiClient extends EventEmitter {
             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.
+        // Add default URL if not provided
+        const configWithDefaults = {
+            url: "https://realtime-api.convai.com",
+            ...finalConfig,
+        };
+        this._logRtviMessages = configWithDefaults.logRtviMessages !== false;
+        this._messageHandler.setRtviMessageLogging(this._logRtviMessages);
         this._messageHandler.setModelOutputVersion(1);
+        const hasApiKey = Boolean(configWithDefaults.apiKey);
+        const hasAuthToken = Boolean(configWithDefaults.authToken);
+        if ((!hasApiKey && !hasAuthToken) || !configWithDefaults.characterId) {
+            throw new Error("Either apiKey or authToken is required, and characterId is required");
+        }
         this.updateState({ isConnecting: true });
         this._requestTraceId = null;
         try {
@@ -686,87 +450,23 @@ export class ConvaiClient extends EventEmitter {
             this._apiKey = configWithDefaults.apiKey ?? null;
             this._authToken = configWithDefaults.authToken ?? null;
             this._characterId = configWithDefaults.characterId;
-            this._characterVersion = configWithDefaults.characterVersion ?? null;
-            this._characterReference = configWithDefaults.characterReference;
             // Determine connection type based on enableVideo
             const connType = configWithDefaults.enableVideo ? "video" : "audio";
             this._connectionType = connType;
-            const transportType = configWithDefaults.transport ??
-                (configWithDefaults.interactionApiUrl ? "sse" : "livekit");
-            if (transportType === "sse" && !configWithDefaults.interactionApiUrl) {
-                throw new Error("interactionApiUrl is required when using the SSE transport");
-            }
-            if (transportType === "sse" && configWithDefaults.enableVideo) {
-                throw new Error("The SSE transport supports text interactions only");
-            }
+            const transportType = configWithDefaults.transport ?? "livekit";
             this._activeTransport = transportType;
             const effectiveVisionInputConfig = resolveVisionInputConfig(configWithDefaults);
+            // Prepare request body with required parameters
             // An explicit stateOfMind in the config wins; otherwise carry whatever
             // updateEmotion() last set, including before the first connect.
             const stateOfMind = configWithDefaults.stateOfMind !== undefined
                 ? normalizeStateOfMind(configWithDefaults.stateOfMind) ?? null
                 : this._stateOfMind;
             this._stateOfMind = stateOfMind;
-            if (transportType === "sse") {
-                this._sseSession = new SSESession({
-                    interactionApiUrl: configWithDefaults.interactionApiUrl,
-                    authorization: configWithDefaults.authToken ?? configWithDefaults.apiKey,
-                    characterId: configWithDefaults.characterReference,
-                    getCharacterSessionId: () => this._characterSessionId,
-                    takeStateOfMind: () => {
-                        const stateOfMind = this._stateOfMind;
-                        this._stateOfMind = null;
-                        if (this._storedConfig?.stateOfMind !== undefined) {
-                            this._storedConfig = { ...this._storedConfig, stateOfMind: null };
-                        }
-                        return stateOfMind;
-                    },
-                    onCharacterSessionId: (characterSessionId) => {
-                        this._characterSessionId = characterSessionId;
-                        this.emit("characterSessionId", characterSessionId);
-                        this._storedConfig = {
-                            ...this._storedConfig,
-                            characterSessionId,
-                        };
-                    },
-                    endUserId: configWithDefaults.endUserId,
-                    endUserMetadata: configWithDefaults.endUserMetadata,
-                    enableEmotion: configWithDefaults.enableEmotion,
-                    emotionConfig: configWithDefaults.emotionConfig,
-                    actionConfig: configWithDefaults.actionConfig,
-                    capabilities: configWithDefaults.capabilities,
-                    dynamicInfo: configWithDefaults.dynamicInfo,
-                    keepInContext: configWithDefaults.keepInContext,
-                    narrativeTemplateKeys: configWithDefaults.narrativeTemplateKeys,
-                    sceneDescription: configWithDefaults.sceneDescription,
-                    respondModes: configWithDefaults.respondModes,
-                    useResponseLifecycleContract: configWithDefaults.useResponseLifecycleContract,
-                    invocationMetadata: configWithDefaults.invocationMetadata,
-                    debug: configWithDefaults.debug,
-                    onMessage: (payload) => this._messageHandler.handleDataReceivedPublic(payload),
-                    onError: (error) => this.emit("error", error),
-                });
-                this._sseSession.connect();
-                this._connectionType = "audio";
-                this._isBotReady = true;
-                this.updateState({
-                    isConnected: true,
-                    isConnecting: false,
-                    endUserId: configWithDefaults.endUserId ?? null,
-                    endUserMetadata: configWithDefaults.endUserMetadata ?? null,
-                });
-                this.emit("connect");
-                this.emit("botReady");
-                return;
-            }
-            // 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)
-                    : { character_id: configWithDefaults.characterReference }),
+                character_id: configWithDefaults.characterId,
                 ...(stateOfMind ? { state_of_mind: stateOfMind } : {}),
                 ...(configWithDefaults.endUserId && {
                     end_user_id: configWithDefaults.endUserId,
@@ -780,8 +480,21 @@ export class ConvaiClient extends EventEmitter {
                 }),
                 connection_type: connType,
                 ...buildBlendshapeConnectConfig(configWithDefaults),
-                ...(buildEmotionConnectConfig(configWithDefaults) && {
-                    emotion_config: buildEmotionConnectConfig(configWithDefaults),
+                llm_provider: "dynamic",
+                ...(configWithDefaults.enableEmotion === true && {
+                    emotion_config: (() => {
+                        const cfg = configWithDefaults.emotionConfig;
+                        const provider = cfg?.provider ?? "llm";
+                        if (provider === "nrclex") {
+                            return {
+                                provider,
+                                min_word_threshold: cfg.min_word_threshold ?? 3,
+                                low_intensity_threshold: cfg.low_intensity_threshold ?? 0.33,
+                                high_intensity_threshold: cfg.high_intensity_threshold ?? 0.66,
+                            };
+                        }
+                        return { provider };
+                    })(),
                 }),
                 default_tts_enabled: configWithDefaults.ttsEnabled !== undefined
                     ? configWithDefaults.ttsEnabled
@@ -790,25 +503,25 @@ 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),
                 }),
-                ...(serializedCapabilities && { capabilities: serializedCapabilities }),
-                ...(configWithDefaults.sceneDescription && {
-                    scene_description: configWithDefaults.sceneDescription,
-                }),
-                // A roster room owns its members' sessions; the singular resume id is
-                // a compatibility mirror and must not go back on the wire.
-                ...(!isRoster &&
-                    characterSessionIdToSend &&
+                ...(characterSessionIdToSend &&
                     characterSessionIdToSend !== "-1" && {
                     character_session_id: characterSessionIdToSend,
                 }),
-                ...(buildActionConnectConfig(configWithDefaults) && {
-                    action_config: buildActionConnectConfig(configWithDefaults),
+                ...(configWithDefaults.actionConfig && {
+                    action_config: {
+                        actions: configWithDefaults.actionConfig.actions,
+                        objects: configWithDefaults.actionConfig.objects,
+                        characters: configWithDefaults.actionConfig.characters,
+                        ...(configWithDefaults.actionConfig.current_attention_object && {
+                            current_attention_object: configWithDefaults.actionConfig.current_attention_object,
+                        }),
+                        ...(configWithDefaults.actionConfig.tools && {
+                            tools: serializeClientTools(configWithDefaults.actionConfig.tools),
+                        }),
+                    },
                 }),
                 ...(configWithDefaults.dynamicInfo && {
                     dynamic_info: {
@@ -825,12 +538,6 @@ export class ConvaiClient extends EventEmitter {
                 ...(configWithDefaults.debug !== undefined && {
                     debug: configWithDefaults.debug,
                 }),
-                ...(configWithDefaults.preserveLinksInOutput !== undefined && {
-                    preserve_links_in_output: configWithDefaults.preserveLinksInOutput,
-                }),
-                ...(configWithDefaults.useResponseLifecycleContract !== undefined && {
-                    use_response_lifecycle_contract: configWithDefaults.useResponseLifecycleContract,
-                }),
                 invocation_metadata: {
                     source: configWithDefaults.invocationMetadata?.source ?? "web_sdk",
                     client_version: configWithDefaults.invocationMetadata?.clientVersion ??
@@ -849,676 +556,217 @@ export class ConvaiClient extends EventEmitter {
             else if (configWithDefaults.apiKey) {
                 connectHeaders["X-API-Key"] = configWithDefaults.apiKey;
             }
-            // HTTP POST /connect — same request for both transports. A roster room
-            // may still be provisioning from an identical concurrent create, which
-            // the runtime answers with a retryable 409; the wrapper replays the
-            // identical payload and is a straight pass-through otherwise.
-            const connectOnce = async () => {
-                const response = await fetch(`${configWithDefaults.url}/connect`, {
-                    method: "POST",
-                    headers: connectHeaders,
-                    body: JSON.stringify(requestBody),
-                });
-                if (!response.ok) {
-                    const errorText = await response.text();
-                    let errorMessage = `HTTP ${response.status}`;
-                    try {
-                        const errorData = JSON.parse(errorText);
-                        const raw = errorData.message ?? errorData.error ?? errorData.detail;
-                        if (typeof raw === "string") {
-                            errorMessage = raw;
-                        }
-                        else if (Array.isArray(raw)) {
-                            // FastAPI/Pydantic 422 — detail is an array of validation error objects
-                            errorMessage = raw
-                                .map((e) => [e.loc?.join("."), e.msg].filter(Boolean).join(": "))
-                                .join("; ") || errorMessage;
-                        }
-                        else if (raw != null) {
-                            errorMessage = JSON.stringify(raw);
-                        }
-                        else if (errorText) {
-                            errorMessage = `${errorMessage}: ${errorText}`;
-                        }
+            // HTTP POST /connect — same request for both transports
+            const response = await fetch(`${configWithDefaults.url}/connect`, {
+                method: "POST",
+                headers: connectHeaders,
+                body: JSON.stringify(requestBody),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                let errorMessage = `HTTP ${response.status}`;
+                try {
+                    const errorData = JSON.parse(errorText);
+                    const raw = errorData.message ?? errorData.error ?? errorData.detail;
+                    if (typeof raw === "string") {
+                        errorMessage = raw;
                     }
-                    catch {
-                        if (errorText)
-                            errorMessage = `${errorMessage}: ${errorText}`;
+                    else if (Array.isArray(raw)) {
+                        // FastAPI/Pydantic 422 — detail is an array of validation error objects
+                        errorMessage = raw
+                            .map((e) => [e.loc?.join("."), e.msg].filter(Boolean).join(": "))
+                            .join("; ") || errorMessage;
                     }
-                    // A roster room's failures are named and machine-actionable, and the
-                    // trace id is what backend support correlates on, so they get a typed
-                    // error. Single-character behaviour is unchanged.
-                    if (isRoster) {
-                        let parsed = errorText;
-                        try {
-                            parsed = JSON.parse(errorText);
-                        }
-                        catch {
-                            /* keep the raw text as the detail */
-                        }
-                        throw roomErrorFromResponse(response.status, parsed);
+                    else if (raw != null) {
+                        errorMessage = JSON.stringify(raw);
                     }
-                    throw new Error(errorMessage);
-                }
-                return await response.json();
-            };
-            const connectionData = isRoster
-                ? await this._withProvisioningRetry(configWithDefaults, connectOnce)
-                : await connectOnce();
-            return await this.consumeConnectionData(connectionData, configWithDefaults);
-        }
-        catch (error) {
-            await this.cleanupWebSocketSessionAfterConnectFailure();
-            this.updateState({
-                isConnected: false,
-                isConnecting: false,
-            });
-            this.emit("error", error);
-            throw error;
-        }
-    }
-    /**
-     * Complete a connection from an already-fetched /connect response body.
-     *
-     * `connect()` fetches /connect and then calls this internally. Call it
-     * directly when the response was obtained elsewhere — a server-side session
-     * manager, or the embed's connect-proxy flow, where the API key must never
-     * reach the browser.
-     *
-     * @example
-     * // Server (customer's backend): holds the API key, calls Convai's
-     * // /connect, and relays the response body verbatim.
-     * // Browser: never sees the API key, only the relayed response.
-     * const data = await fetch('/api/convai-connect', {
-     *   method: 'POST',
-     *   headers: { 'Content-Type': 'application/json' },
-     *   body: JSON.stringify({ characterId: 'your-character-id' }),
-     * }).then(r => r.json())
-     * 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");
-        }
-        this._storedConfig = { ...finalConfig };
-        // 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, {
-            requireCredential: false,
-        });
-        // Symmetric with connect(): the catch below emits isConnecting: false, so
-        // without this a UI bound to stateChange never sees a connecting state on
-        // the proxy path -- and on failure receives a transition out of a state it
-        // was never told about. consumeConnectionData() clears the flag on success.
-        this.updateState({ isConnecting: true });
-        try {
-            return await this.consumeConnectionData(data, configWithDefaults);
-        }
-        catch (error) {
-            await this.cleanupWebSocketSessionAfterConnectFailure();
-            this.updateState({
-                isConnected: false,
-                isConnecting: false,
-            });
-            this.emit("error", error);
-            throw error;
-        }
-    }
-    /** Correlate roster acks back to the promise that issued the command. */
-    _handleRosterServerResponse(response) {
-        const eventType = response.event_type;
-        if (eventType !== "interaction-target" &&
-            eventType !== "character-roster-update") {
-            return;
-        }
-        const extras = response.extras ?? null;
-        const commandId = extras?.command_id;
-        const pending = commandId
-            ? this._pendingRosterCommands.get(commandId)
-            : undefined;
-        if (response.status === "error") {
-            // Adopt the server's epochs even from a rejection -- a stale-epoch error
-            // carries the authoritative value, and that is what makes a retry
-            // meaningful.
-            this._roster.adoptEpochs(extras);
-            this._pushRosterState();
-            if (pending && commandId) {
-                this._pendingRosterCommands.delete(commandId);
-                clearTimeout(pending.timer);
-                pending.reject(Object.assign(new Error(response.message ?? `${eventType} was rejected`), { code: extras?.code ?? null, extras }));
-            }
-            return;
-        }
-        // Apply the change whether or not this client asked for it: another
-        // participant's switch reaches us through the same event.
-        let change;
-        if (eventType === "interaction-target") {
-            change = this._roster.applyInteractionTarget(extras);
-            this._pushRosterState();
-            this.emit("activeCharacterChange", change);
-        }
-        else {
-            change = this._roster.applyRosterUpdate(extras);
-            this._pushRosterState();
-            this.emit("rosterChange", change);
-        }
-        if (pending && commandId) {
-            this._pendingRosterCommands.delete(commandId);
-            clearTimeout(pending.timer);
-            pending.resolve(change);
-        }
-    }
-    /**
-     * Settle every in-flight roster command.
-     *
-     * Without this a caller who disconnects mid-command keeps a live 10s timer
-     * and gets a rejection long after the session ended -- an unhandled rejection
-     * if they stopped awaiting when they tore the client down. The roster is
-     * reset alongside, so the command could not be applied meaningfully anyway.
-     */
-    _failPendingRosterCommands(reason) {
-        for (const [, pending] of this._pendingRosterCommands) {
-            clearTimeout(pending.timer);
-            pending.reject(new Error(reason));
-        }
-        this._pendingRosterCommands.clear();
-    }
-    _pushRosterState() {
-        this.updateState({
-            characters: this._roster.characters,
-            activeMembershipId: this._roster.activeMembershipId,
-        });
-    }
-    /** Publish a roster command and settle when its ack arrives. */
-    _sendRosterCommand(type, build) {
-        if (!this._roster.isMultiCharacter) {
-            return Promise.reject(new Error(`Cannot send ${type}: this session was not created with a characters array`));
-        }
-        if (!this.isTransportReady()) {
-            return Promise.reject(new Error(`Cannot send ${type}: not connected`));
-        }
-        const commandId = `${type}-${++this._rosterCommandSeq}-${Date.now()}`;
-        return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                this._pendingRosterCommands.delete(commandId);
-                reject(new Error(`${type} was not acknowledged within ${ConvaiClient.ROSTER_COMMAND_TIMEOUT_MS}ms. ` +
-                    `The outcome is unknown -- acks can be suppressed as duplicates. ` +
-                    `Reconcile from the next authoritative room state before sending a conflicting command.`));
-            }, ConvaiClient.ROSTER_COMMAND_TIMEOUT_MS);
-            this._pendingRosterCommands.set(commandId, { resolve, reject, timer });
-            this.publishMessage(type, build(commandId), commandId);
-        });
-    }
-    /**
-     * Route subsequent user turns to a different character instance.
-     *
-     * Pass null to close every gate, so no member consumes the user until a
-     * target is set again.
-     */
-    async setInteractionTarget(membershipId) {
-        if (!this._roster.isMultiCharacter) {
-            throw new Error("Cannot send interaction-target: this session was not created with a characters array");
-        }
-        if (membershipId !== null) {
-            if (!membershipId) {
-                throw new Error("setInteractionTarget requires a membershipId, or null to close all gates");
-            }
-            const instance = this._roster.find(membershipId);
-            if (this._roster.isMultiCharacter && !instance) {
-                throw new Error(`Unknown membershipId "${membershipId}". Address instances by membershipId, not characterId.`);
-            }
-            if (instance && !instance.isReady) {
-                throw new Error(`Membership "${membershipId}" has not sent bot-ready yet; the runtime refuses an unready target`);
-            }
-        }
-        const send = () => this._sendRosterCommand("interaction-target", (commandId) => this._roster.buildInteractionTarget(membershipId, commandId));
-        try {
-            return (await send());
-        }
-        catch (error) {
-            // Another participant switched first. The roster adopted the server's
-            // epoch when the rejection arrived, so exactly one retry is now fenced
-            // correctly; a second would mean we are losing a race we should report.
-            if (error?.code !== "stale_route_epoch")
-                throw error;
-            return (await send());
-        }
-    }
-    /** Add or remove character instances on a live room, without reconnecting. */
-    async updateCharacterRoster(options) {
-        // Report the wrong-session-shape first. Otherwise a single-character
-        // client, whose roster is empty, trips the "cannot be emptied" rule below
-        // and gets an error about a room it never had.
-        if (!this._roster.isMultiCharacter) {
-            throw new Error("Cannot send character-roster-update: this session was not created with a characters array");
-        }
-        const add = options?.add ?? [];
-        const remove = options?.remove ?? [];
-        if (add.length === 0 && remove.length === 0) {
-            throw new Error("updateCharacterRoster requires at least one add or remove");
-        }
-        if (add.some((c) => !c?.characterId?.trim())) {
-            throw new Error("Every entry in add requires a characterId");
-        }
-        if (remove.length && remove.length >= this._roster.characters.length && add.length === 0) {
-            throw new Error("A roster room cannot be emptied; add a replacement or keep one member");
-        }
-        // Removing the active member needs an explicit, ready replacement --
-        // the runtime answers `replacement_target_required` otherwise, and
-        // `replacement_target_unavailable` for one that has not sent bot-ready.
-        const active = this._roster.activeMembershipId;
-        const effective = !options.replacementTarget && active && remove.includes(active)
-            ? { ...options, replacementTarget: this._roster.pickReplacement(remove) }
-            : options;
-        return (await this._sendRosterCommand("character-roster-update", (commandId) => this._roster.buildRosterUpdate(effective, commandId)));
-    }
-    /**
-     * Run a room request, retrying only the conflicts that mean "still working".
-     *
-     * The runtime answers a create that collides with an in-flight identical
-     * create with 409 `ROSTER_PROVISIONING_IN_PROGRESS`, and the documented
-     * recovery is to retry the same key with bounded backoff. Left to callers,
-     * every integration reimplements that, usually without a cap. The payload is
-     * replayed verbatim -- changing it would turn the retry into a fingerprint
-     * mismatch.
-     */
-    async _withProvisioningRetry(config, run) {
-        const setting = config.rosterProvisioningRetry;
-        if (setting === false)
-            return run();
-        const attempts = Math.max(1, setting?.attempts ?? ConvaiClient.ROSTER_RETRY_ATTEMPTS);
-        const initialDelayMs = Math.max(0, setting?.initialDelayMs ?? ConvaiClient.ROSTER_RETRY_INITIAL_MS);
-        let lastError;
-        for (let attempt = 0; attempt < attempts; attempt++) {
-            try {
-                return await run();
-            }
-            catch (error) {
-                lastError = error;
-                const retryable = error instanceof ConvaiRoomError && error.isRetryable;
-                if (!retryable || attempt === attempts - 1)
-                    throw error;
-                // Jitter so a lobby of clients waking on the same room does not
-                // retry in lockstep.
-                const base = initialDelayMs * 2 ** attempt;
-                const jittered = base * (0.8 + Math.random() * 0.4);
-                await new Promise((resolve) => setTimeout(resolve, jittered));
-            }
-        }
-        throw lastError;
-    }
-    /**
-     * Join a multi-character room that already exists.
-     *
-     * A join supplies a locator and the joining human, and nothing else: the
-     * roster is server-owned, so resending topology is rejected. It never spawns,
-     * removes or repairs a character -- only room creation does that.
-     *
-     * Capacity counts distinct speakers derived from `endUserId`, and defaults to
-     * one, so raise `maxNumParticipants` at creation before expecting a second
-     * human to get in.
-     *
-     * @example
-     * ```ts
-     * const client = new ConvaiClient({ apiKey: 'YOUR_API_KEY' })
-     * await client.joinRoom({
-     *   roomSessionId: 'the-room-session-id',
-     *   endUserId: 'player-99',
-     * })
-     * ```
-     */
-    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) {
-            throw new Error("Either apiKey or authToken is required to join a room");
-        }
-        this._logRtviMessages = stored.logRtviMessages !== false;
-        this._messageHandler.setRtviMessageLogging(this._logRtviMessages);
-        this.updateState({ isConnecting: true });
-        try {
-            const connectionData = await this._withProvisioningRetry(stored, async () => {
-                const response = await fetch(`${url}/connect`, {
-                    method: "POST",
-                    headers: {
-                        "Content-Type": "application/json",
-                        ...(stored.apiKey
-                            ? { "X-API-Key": stored.apiKey }
-                            : { "API-AUTH-TOKEN": stored.authToken }),
-                    },
-                    body: JSON.stringify(buildJoinRequestBody(options)),
-                });
-                if (!response.ok) {
-                    const text = await response.text();
-                    let parsed = text;
-                    try {
-                        parsed = JSON.parse(text);
+                    else if (errorText) {
+                        errorMessage = `${errorMessage}: ${errorText}`;
                     }
-                    catch {
-                        /* keep the raw text as the detail */
-                    }
-                    throw roomErrorFromResponse(response.status, parsed);
                 }
-                return (await response.json());
-            });
-            // The join response carries the persisted roster, so the joining client
-            // learns the topology it never sent.
-            const rosterCharacters = connectionData.characters;
-            const initialCharacterId = rosterCharacters?.[0]?.character_id;
-            const joinConfig = {
-                ...stored,
-                characters: undefined,
-                characterId: initialCharacterId ?? stored.characterId,
-                endUserId: options.endUserId,
-                ...(options.endUserMetadata
-                    ? { endUserMetadata: options.endUserMetadata }
-                    : {}),
-            };
-            this._storedConfig = joinConfig;
-            const configWithDefaults = this.applyConfigDefaults(joinConfig, {
-                requireCredential: false,
-            });
-            return await this.consumeConnectionData(connectionData, configWithDefaults);
-        }
-        catch (error) {
-            await this.cleanupWebSocketSessionAfterConnectFailure();
-            this.updateState({ isConnected: false, isConnecting: false });
-            this.emit("error", error);
-            throw error;
-        }
-    }
-    /**
-     * Add default URL, apply RTVI-logging config, and validate that either an
-     * API key or auth token plus a character ID are present.
-     * Shared by connect() and connectWithConnectionData() so both derive
-     * `configWithDefaults` identically.
-     *
-     * `connect()` performs its own /connect fetch and always needs a credential
-     * to do so, so it uses the default `requireCredential: true`.
-     * `connectWithConnectionData()` consumes a response obtained elsewhere (e.g.
-     * a proxy that holds the credential server-side) and passes
-     * `requireCredential: false` — a character ID is still required either way.
-     */
-    applyConfigDefaults(finalConfig, opts = {}) {
-        const { requireCredential = true } = opts;
-        // Add default URL if not provided
-        const configWithDefaults = {
-            url: "https://realtime-api.convai.com",
-            ...finalConfig,
-        };
-        this._logRtviMessages = configWithDefaults.logRtviMessages !== false;
-        this._messageHandler.setRtviMessageLogging(this._logRtviMessages);
-        const hasApiKey = Boolean(configWithDefaults.apiKey);
-        const hasAuthToken = Boolean(configWithDefaults.authToken);
-        const missingCredential = requireCredential && !hasApiKey && !hasAuthToken;
-        // Runs for every topology: the v2 protocol constraints rule out
-        // sharedSessionKey and extra human capacity in single-character rooms too.
-        validateProtocolTopology(configWithDefaults);
-        const roster = isRosterConfig(configWithDefaults);
-        if (missingCredential || (!roster && !configWithDefaults.characterId)) {
-            throw new Error("Either apiKey or authToken is required, and characterId is required");
-        }
-        // A roster names its members individually; every roster rule is checked
-        // before a request is built.
-        if (roster) {
-            validateRosterConfig(configWithDefaults);
-            const initial = configWithDefaults.characters[0].characterId.trim();
-            return {
-                ...configWithDefaults,
-                // Singular readouts mirror characters[0], exactly as the wire's own
-                // top-level session_id/character_session_id aliases do.
-                characterId: initial,
-                characterVersion: null,
-                characterReference: initial,
-            };
-        }
-        // Split the character id from its version selector. The bare UUID names
-        // the character everywhere inside the SDK (memory, character info); the
-        // joined reference is what the runtime receives.
-        const reference = resolveCharacterReference(configWithDefaults.characterId, configWithDefaults.characterVersion);
-        return {
-            ...configWithDefaults,
-            characterId: reference.characterId,
-            characterVersion: reference.version,
-            characterReference: reference.reference,
-        };
-    }
-    /**
-     * Consume a /connect response and bring up the transport.
-     * `connect()` calls this after its own fetch; external callers use it
-     * when the response came from a proxy.
-     */
-    async consumeConnectionData(connectionData, configWithDefaults) {
-        // Store connection config (mirrors connect()'s pre-fetch setup so this
-        // method is self-sufficient when called directly, without connect()
-        // having run first).
-        //
-        // Known race, judged acceptable: when called from connect(), that method
-        // sets these same fields once, before the /connect fetch, then awaits
-        // the network round trip. If disconnect() -> clearAllManagers() lands in
-        // that await window, the pre-split code left these fields null (nothing
-        // re-set them post-fetch), whereas re-deriving them here re-arms them
-        // once the response arrives. Checked `_isDisconnecting` as a guard: it
-        // doesn't cover this window — it's flipped back to false (in a
-        // `finally`) before clearAllManagers() runs on the websocket path, and
-        // disconnect()'s LiveKit-room path never sets it at all — so it can't
-        // reliably detect "a disconnect landed mid-connect" here. Even
-        // pre-split, connect() never checked for a concurrent disconnect after
-        // the fetch resolved; it always went on to establish a new room/session
-        // regardless. Re-arming these fields keeps them consistent with the
-        // connection actually being brought up in that case, rather than
-        // silently stale. Building a proper cancellation token for
-        // connect()-vs-disconnect() races is out of scope for this additive
-        // split.
-        this._apiKey = configWithDefaults.apiKey ?? null;
-        this._authToken = configWithDefaults.authToken ?? null;
-        this._characterId = configWithDefaults.characterId;
-        this._characterVersion = configWithDefaults.characterVersion ?? null;
-        this._characterReference = configWithDefaults.characterReference;
-        const connType = configWithDefaults.enableVideo ? "video" : "audio";
-        this._connectionType = connType;
-        const transportType = configWithDefaults.transport ?? "livekit";
-        this._activeTransport = transportType;
-        const effectiveVisionInputConfig = resolveVisionInputConfig(configWithDefaults);
-        // Capture session identifiers from /connect response
-        if (connectionData.character_session_id) {
-            this._characterSessionId = connectionData.character_session_id;
-            // Emitted here rather than in connect(), so the proxy-auth path
-            // (connectWithConnectionData) surfaces the session id too -- both routes
-            // establish it at exactly this point.
-            this.emit("characterSessionId", connectionData.character_session_id);
-            this._storedConfig = {
-                ...this._storedConfig,
-                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)) {
-            this.updateState({
-                characters: this._roster.characters,
-                activeMembershipId: this._roster.activeMembershipId,
-            });
-        }
-        if (connectionData.end_user_id) {
-            this._endUserId = connectionData.end_user_id;
-        }
-        if (connectionData.end_user_metadata) {
-            this._endUserMetadata = connectionData.end_user_metadata;
-        }
-        if (transportType === "websocket") {
-            // ── WebSocket (Pipecat) transport path ────────────────────────────
-            // Server returns the WebSocket URL in room_url (same field as LiveKit).
-            const wsUrl = connectionData.room_url;
-            if (!wsUrl) {
-                throw new Error("No WebSocket URL returned from /connect endpoint (expected room_url)");
+                catch {
+                    if (errorText)
+                        errorMessage = `${errorMessage}: ${errorText}`;
+                }
+                throw new Error(errorMessage);
             }
-            if (!_wsFactory) {
-                throw new Error("[ConvaiClient] WebSocket transport is not registered. " +
-                    "Add `import '@convai/web-sdk/vanilla/websocket'` before calling connect().");
+            const connectionData = await response.json();
+            const selectedCapabilities = connectionData.capabilities ?? {};
+            const requestedCapabilities = configWithDefaults.capabilities;
+            validateActionProtocolSelection(requestedCapabilities?.actionProtocolVersion, selectedCapabilities.action_protocol_version);
+            validateBotLlmTextModeSelection(requestedCapabilities?.botLlmTextMode, selectedCapabilities.bot_llm_text_mode);
+            this._messageHandler.setModelOutputVersion(validateModelOutputVersionSelection(requestedCapabilities?.modelOutputVersion, selectedCapabilities.model_output_version));
+            // Capture session identifiers from /connect response
+            if (connectionData.character_session_id) {
+                this._characterSessionId = connectionData.character_session_id;
+                this._storedConfig = {
+                    ...this._storedConfig,
+                    characterSessionId: connectionData.character_session_id,
+                };
             }
-            // Always enable mic at construction so WavMediaManager initializes the
-            // audio stream during connect(). If startWithAudioOn is false, we mute
-            // after the connection is established (enableMic(false) works once the
-            // stream exists, but not before it is initialized).
-            this._wsSession = _wsFactory((payload) => this._messageHandler.handleDataReceivedPublic(payload), true);
-            const webSocketVisionEnabled = configWithDefaults.enableVideo === true &&
-                effectiveVisionInputConfig?.enabled !== false;
-            if (webSocketVisionEnabled) {
-                this._videoManager.setWebSocketVisionMessageSender((type, data) => {
-                    if (this._activeTransport !== "websocket" ||
-                        !this._wsSession?.isConnected) {
-                        return;
-                    }
-                    this._wsSession.sendMessage(type, data);
-                });
+            if (connectionData.end_user_id) {
+                this._endUserId = connectionData.end_user_id;
             }
-            else {
-                this._videoManager.setWebSocketVisionDisabled();
+            if (connectionData.end_user_metadata) {
+                this._endUserMetadata = connectionData.end_user_metadata;
             }
-            const wsSession = this._wsSession;
-            wsSession.on("botAudioTrack", (track) => {
-                this.emit("botAudioTrack", track);
-            });
-            wsSession.on("disconnected", () => {
-                if (this._wsSession !== wsSession || this._isDisconnecting) {
-                    return;
+            if (transportType === "websocket") {
+                // ── WebSocket (Pipecat) transport path ────────────────────────────
+                // Server returns the WebSocket URL in room_url (same field as LiveKit).
+                const wsUrl = connectionData.room_url;
+                if (!wsUrl) {
+                    throw new Error("No WebSocket URL returned from /connect endpoint (expected room_url)");
                 }
-                this._connectionStateHandler.handleDisconnected();
-                this.clearAllManagers();
-            });
-            this._audioManager.setWebSocketSession(this._wsSession);
-            // Wait for WebSocket transport to connect (fires before bot-ready)
-            await new Promise((resolve, reject) => {
-                let settled = false;
-                const cleanupConnectListeners = () => {
-                    wsSession.off("connected", onConnected);
-                    wsSession.off("error", onError);
-                    wsSession.off("disconnected", onDisconnected);
-                };
-                const settle = (callback) => {
-                    if (settled) {
+                if (!_wsFactory) {
+                    throw new Error("[ConvaiClient] WebSocket transport is not registered. " +
+                        "Add `import '@convai/web-sdk/vanilla/websocket'` before calling connect().");
+                }
+                // Always enable mic at construction so WavMediaManager initializes the
+                // audio stream during connect(). If startWithAudioOn is false, we mute
+                // after the connection is established (enableMic(false) works once the
+                // stream exists, but not before it is initialized).
+                this._wsSession = _wsFactory((payload) => this._messageHandler.handleDataReceivedPublic(payload), true);
+                const webSocketVisionEnabled = configWithDefaults.enableVideo === true &&
+                    effectiveVisionInputConfig?.enabled !== false;
+                if (webSocketVisionEnabled) {
+                    this._videoManager.setWebSocketVisionMessageSender((type, data) => {
+                        if (this._activeTransport !== "websocket" ||
+                            !this._wsSession?.isConnected) {
+                            return;
+                        }
+                        this._wsSession.sendMessage(type, data);
+                    });
+                }
+                else {
+                    this._videoManager.setWebSocketVisionDisabled();
+                }
+                const wsSession = this._wsSession;
+                wsSession.on("botAudioTrack", (track) => {
+                    this.emit("botAudioTrack", track);
+                });
+                wsSession.on("disconnected", () => {
+                    if (this._wsSession !== wsSession || this._isDisconnecting) {
                         return;
                     }
-                    settled = true;
-                    cleanupConnectListeners();
-                    callback();
-                };
-                const onConnected = () => {
-                    settle(resolve);
-                };
-                const onError = (err) => {
-                    settle(() => {
-                        reject(err instanceof Error ? err : new Error(String(err)));
-                    });
-                };
-                const onDisconnected = () => {
-                    settle(() => {
-                        reject(new Error("WebSocket disconnected before connect completed"));
-                    });
-                };
-                wsSession.on("connected", onConnected);
-                wsSession.on("error", onError);
-                wsSession.on("disconnected", onDisconnected);
-                // connectWithUrl calls initDevices() then connect({ wsUrl }) — matches sandbox flow
-                wsSession.connectWithUrl(wsUrl).catch((err) => {
-                    settle(() => {
-                        reject(err instanceof Error ? err : new Error(String(err)));
+                    this._connectionStateHandler.handleDisconnected();
+                    this.clearAllManagers();
+                });
+                this._audioManager.setWebSocketSession(this._wsSession);
+                // Wait for WebSocket transport to connect (fires before bot-ready)
+                await new Promise((resolve, reject) => {
+                    let settled = false;
+                    const cleanupConnectListeners = () => {
+                        wsSession.off("connected", onConnected);
+                        wsSession.off("error", onError);
+                        wsSession.off("disconnected", onDisconnected);
+                    };
+                    const settle = (callback) => {
+                        if (settled) {
+                            return;
+                        }
+                        settled = true;
+                        cleanupConnectListeners();
+                        callback();
+                    };
+                    const onConnected = () => {
+                        settle(resolve);
+                    };
+                    const onError = (err) => {
+                        settle(() => {
+                            reject(err instanceof Error ? err : new Error(String(err)));
+                        });
+                    };
+                    const onDisconnected = () => {
+                        settle(() => {
+                            reject(new Error("WebSocket disconnected before connect completed"));
+                        });
+                    };
+                    wsSession.on("connected", onConnected);
+                    wsSession.on("error", onError);
+                    wsSession.on("disconnected", onDisconnected);
+                    // connectWithUrl calls initDevices() then connect({ wsUrl }) — matches sandbox flow
+                    wsSession.connectWithUrl(wsUrl).catch((err) => {
+                        settle(() => {
+                            reject(err instanceof Error ? err : new Error(String(err)));
+                        });
                     });
                 });
-            });
-            // For WebSocket, mic is already streaming after connect.
-            // Only mute if the caller explicitly sets startWithAudioOn: false.
-            // Defaulting to on matches the sandbox behavior and ensures the bot
-            // sees audio when it initializes (avoids server "tap mic to talk" prompt).
-            if (configWithDefaults.startWithAudioOn === false) {
-                this._wsSession.enableMic(false);
-                this._audioManager.syncWsAudioState(false);
+                // For WebSocket, mic is already streaming after connect.
+                // Only mute if the caller explicitly sets startWithAudioOn: false.
+                // Defaulting to on matches the sandbox behavior and ensures the bot
+                // sees audio when it initializes (avoids server "tap mic to talk" prompt).
+                if (configWithDefaults.startWithAudioOn === false) {
+                    this._wsSession.enableMic(false);
+                    this._audioManager.syncWsAudioState(false);
+                }
+                else {
+                    this._audioManager.syncWsAudioState(true);
+                }
+                if (webSocketVisionEnabled &&
+                    configWithDefaults.enableVideo &&
+                    configWithDefaults.startWithVideoOn) {
+                    await this._videoManager.enableVideo();
+                }
             }
             else {
-                this._audioManager.syncWsAudioState(true);
+                this._videoManager.setWebSocketVisionMessageSender(null);
+                // ── LiveKit transport path (default) ─────────────────────────────
+                await this._room.connect(connectionData.room_url, connectionData.token, {
+                    rtcConfig: {
+                        iceTransportPolicy: "relay",
+                    },
+                });
+                if (configWithDefaults.startWithAudioOn) {
+                    await this._room.localParticipant.setMicrophoneEnabled(true, {
+                        echoCancellation: this._audioSettings.echoCancellation,
+                        noiseSuppression: this._audioSettings.noiseSuppression,
+                        autoGainControl: this._audioSettings.autoGainControl,
+                        sampleRate: this._audioSettings.sampleRate,
+                        channelCount: this._audioSettings.channelCount,
+                    });
+                }
+                if (configWithDefaults.enableVideo &&
+                    configWithDefaults.startWithVideoOn) {
+                    await this._room.localParticipant.setCameraEnabled(true);
+                }
+                this._audioManager.syncStateFromRoom({ emit: true });
+                this._participantSid = this._room.localParticipant.sid;
             }
-            if (webSocketVisionEnabled &&
-                configWithDefaults.enableVideo &&
-                configWithDefaults.startWithVideoOn) {
-                await this._videoManager.enableVideo();
+            // Apply custom mapper to blendshape queue if provided
+            if (configWithDefaults.blendshapeConfig?.customMapper) {
+                this.blendshapeQueue.setMapper(configWithDefaults.blendshapeConfig.customMapper);
             }
-        }
-        else {
-            this._videoManager.setWebSocketVisionMessageSender(null);
-            // ── LiveKit transport path (default) ─────────────────────────────
-            await this._room.connect(connectionData.room_url, connectionData.token, {
-                rtcConfig: {
-                    // Defaults to "relay" (TURN-only) for reliable NAT traversal
-                    // against Convai's hosted LiveKit. Set iceTransportPolicy: "all"
-                    // when pointing at a LiveKit without TURN (e.g. local dev).
-                    iceTransportPolicy: configWithDefaults.iceTransportPolicy ?? "relay",
-                },
+            this.updateState({
+                isConnected: true,
+                isConnecting: false,
+                endUserId: this._endUserId,
+                endUserMetadata: this._endUserMetadata,
             });
-            if (configWithDefaults.startWithAudioOn) {
-                await this._room.localParticipant.setMicrophoneEnabled(true, {
-                    echoCancellation: this._audioSettings.echoCancellation,
-                    noiseSuppression: this._audioSettings.noiseSuppression,
-                    autoGainControl: this._audioSettings.autoGainControl,
-                    sampleRate: this._audioSettings.sampleRate,
-                    channelCount: this._audioSettings.channelCount,
-                });
-            }
-            if (configWithDefaults.enableVideo &&
-                configWithDefaults.startWithVideoOn) {
-                await this._room.localParticipant.setCameraEnabled(true);
+            // Initialize memory manager if we have authentication and endUserId
+            if (this._endUserId) {
+                if (this._apiKey) {
+                    // Use API key authentication
+                    this._memoryManager = new MemoryManager(this._apiKey, this._characterId, this._endUserId, undefined, // Use default base URL
+                    false);
+                }
+                else if (this._authToken) {
+                    // Use auth token authentication
+                    this._memoryManager = new MemoryManager(this._authToken, this._characterId, this._endUserId, undefined, // Use default base URL
+                    true);
+                }
             }
-            this._audioManager.syncStateFromRoom({ emit: true });
-            this._participantSid = this._room.localParticipant.sid;
-        }
-        // Apply custom mapper to blendshape queue if provided
-        if (configWithDefaults.blendshapeConfig?.customMapper) {
-            this.blendshapeQueue.setMapper(configWithDefaults.blendshapeConfig.customMapper);
+            this.emit("connect");
+            this._startClientReadyHandshake();
         }
-        this.updateState({
-            isConnected: true,
-            isConnecting: false,
-            endUserId: this._endUserId,
-            endUserMetadata: this._endUserMetadata,
-        });
-        // Initialize memory manager if we have authentication and endUserId
-        if (this._endUserId) {
-            if (this._apiKey) {
-                // Use API key authentication
-                this._memoryManager = new MemoryManager(this._apiKey, this._characterId, this._endUserId, undefined, // Use default base URL
-                false);
-            }
-            else if (this._authToken) {
-                // Use auth token authentication
-                this._memoryManager = new MemoryManager(this._authToken, this._characterId, this._endUserId, undefined, // Use default base URL
-                true);
-            }
+        catch (error) {
+            await this.cleanupWebSocketSessionAfterConnectFailure();
+            this.updateState({
+                isConnected: false,
+                isConnecting: false,
+            });
+            this.emit("error", error);
+            throw error;
         }
-        this.emit("connect");
-        this._startClientReadyHandshake();
     }
     async cleanupWebSocketSessionAfterConnectFailure() {
         if (this._activeTransport !== "websocket" || !this._wsSession) {
@@ -1579,7 +827,6 @@ export class ConvaiClient extends EventEmitter {
         this._characterSessionId = "-1";
         this._endUserId = null;
         this._endUserMetadata = null;
-        this._requestTraceId = null;
         this._memoryManager = null;
         this._connectionType = "text";
         this._activeTransport = "livekit";
@@ -1604,95 +851,58 @@ export class ConvaiClient extends EventEmitter {
                 }),
                 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;
+            let response;
+            let exchangeRetried = false;
             try {
-                connectionData = await requestConnection(true);
+                response = await exchangeGrant();
             }
             catch (error) {
                 throwIfAborted();
-                if (!(error instanceof RetryablePublishedChatExchangeError)) {
-                    throw error;
+                // A response can be lost 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.
+                exchangeRetried = true;
+                response = await exchangeGrant();
+            }
+            if (!exchangeRetried && response.status >= 500) {
+                throwIfAborted();
+                response = await exchangeGrant();
+            }
+            throwIfAborted();
+            if (!response.ok) {
+                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}`;
                 }
-                // 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);
+                throw new Error(errorMessage);
             }
+            const connectionData = await response.json();
             throwIfAborted();
+            if (typeof connectionData.room_url !== "string" ||
+                typeof connectionData.token !== "string" ||
+                typeof connectionData.character_session_id !== "string") {
+                throw new Error("Published chat returned an invalid connection response");
+            }
             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",
-                },
+                rtcConfig: { iceTransportPolicy: "relay" },
             });
             throwIfAborted();
             this._audioManager.syncStateFromRoom({ emit: true });
@@ -1783,16 +993,7 @@ export class ConvaiClient extends EventEmitter {
      */
     async disconnect() {
         this._stopClientReadyHandshake();
-        // Unconditional: the branches below each depend on a transport being
-        // matched, and none of them runs when there is nothing to tear down. A
-        // command in flight must still be settled either way.
-        this._failPendingRosterCommands("Disconnected before the roster command was acknowledged; its outcome is unknown");
-        if (this._activeTransport === "sse" && this._sseSession) {
-            await this._sseSession.disconnect();
-            this._connectionStateHandler.resetConnectionState();
-            this.clearAllManagers();
-        }
-        else if (this._activeTransport === "websocket" && this._wsSession) {
+        if (this._activeTransport === "websocket" && this._wsSession) {
             this._isDisconnecting = true;
             try {
                 await this._wsSession.disconnect();
@@ -1819,15 +1020,6 @@ export class ConvaiClient extends EventEmitter {
                 this.clearAllManagers();
             }
         }
-        else if (this._state.isConnected || this._state.isConnecting) {
-            // No transport matched, but the client believes it is (or is becoming)
-            // connected -- a connect() that failed after flipping isConnecting, or
-            // was torn down underneath us. Without this branch disconnect() was a
-            // silent no-op here and the flags stayed stuck, so a UI bound to
-            // stateChange kept showing a session that did not exist.
-            this._connectionStateHandler.resetConnectionState();
-            this.clearAllManagers();
-        }
     }
     /**
      * Clear all manager states
@@ -1836,14 +1028,9 @@ export class ConvaiClient extends EventEmitter {
         this._connectionType = null;
         this._activeTransport = null;
         this._wsSession = null;
-        this._failPendingRosterCommands("Disconnected before the roster command was acknowledged; its outcome is unknown");
-        this._roster.reset();
-        this._sseSession = null;
         this._apiKey = null;
         this._authToken = null;
         this._characterId = null;
-        this._characterVersion = null;
-        this._characterReference = null;
         this._endUserId = null;
         this._endUserMetadata = null;
         this._memoryManager = null; // Clear memory manager on disconnect
@@ -1866,15 +1053,7 @@ export class ConvaiClient extends EventEmitter {
      * Reset the session ID to start a new conversation
      */
     resetSession() {
-        // In a roster room the singular session id is a compatibility mirror of
-        // characters[0], and character sessions are server-owned -- there is no
-        // client-side reset for them. Throwing names the situation; a silent no-op
-        // would look like it worked.
-        if (this._roster.isMultiCharacter) {
-            throw new Error("resetSession() is not supported in a multi-character room; character sessions are server-owned");
-        }
         this._characterSessionId = "-1";
-        this.emit("characterSessionId", "-1");
         this._messageHandler.reset();
         // Clear metrics and disconnect reason when resetting session
         this.updateState({ metrics: [], disconnectReason: null });
@@ -1882,7 +1061,7 @@ export class ConvaiClient extends EventEmitter {
     /**
      * Send a text message to the character
      */
-    sendUserTextMessage(text, options = {}) {
+    sendUserTextMessage(text, options) {
         if (!this.isTransportReady())
             return;
         if (!text || !text.trim())
@@ -1907,48 +1086,10 @@ export class ConvaiClient extends EventEmitter {
                 userMessage: text.trim(),
                 timestamp: this._conversationStartTime,
             });
-            const userTextMessage = {
+            this.publishMessage("user_text_message", {
                 text: text.trim(),
                 participant_sid: this._participantSid || this._room.localParticipant?.sid,
-            };
-            const stateOfMind = normalizeStateOfMind(options.stateOfMind) ?? null;
-            if (stateOfMind)
-                this._stateOfMind = stateOfMind;
-            if (this._activeTransport === "sse") {
-                const requestedDynamicInfo = options.dynamicInfo?.trim();
-                if (requestedDynamicInfo) {
-                    this._sseSession?.updateDynamicInfo(requestedDynamicInfo);
-                }
-                const messages = [];
-                const dynamicInfo = this._sseSession?.getDynamicInfo()?.trim();
-                if (dynamicInfo) {
-                    messages.push({
-                        type: "update-dynamic-info",
-                        data: { dynamic_info: { text: dynamicInfo } },
-                    });
-                }
-                if (stateOfMind) {
-                    messages.push({ type: "update-emotion", data: { state_of_mind: stateOfMind } });
-                }
-                messages.push({
-                    type: "user_text_message",
-                    data: userTextMessage,
-                    ...(logicalTurnId !== undefined ? { id: logicalTurnId } : {}),
-                });
-                this._sseSession?.sendMessages(messages);
-            }
-            else {
-                if (stateOfMind) {
-                    this.publishMessage("update-emotion", {
-                        state_of_mind: stateOfMind,
-                        participant_sid: this._participantSid || this._room.localParticipant?.sid,
-                    });
-                }
-                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.
+            }, logicalTurnId);
             this._messageHandler.addUserTextMessage(text);
         }
         catch (error) {
@@ -1959,123 +1100,6 @@ export class ConvaiClient extends EventEmitter {
      * 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");
         }
@@ -2095,17 +1119,17 @@ export class ConvaiClient extends EventEmitter {
         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 {
+        const payload = {
             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,
+            ...((result.characterSessionId ?? this._characterSessionId) &&
+                (result.characterSessionId ?? this._characterSessionId) !== "-1" && {
+                character_session_id: result.characterSessionId ?? this._characterSessionId,
             }),
         };
+        this.publishMessage("action-result", payload);
     }
     /**
      * Send a trigger message to invoke specific character actions
@@ -2207,16 +1231,8 @@ export class ConvaiClient extends EventEmitter {
     updateDynamicInfo(dynamicInfo) {
         if (!this.isTransportReady() || !dynamicInfo?.trim())
             return;
-        const nextDynamicInfo = dynamicInfo.trim();
-        if (this._storedConfig) {
-            this._storedConfig = { ...this._storedConfig, dynamicInfo: nextDynamicInfo };
-        }
-        if (this._activeTransport === "sse" && this._sseSession) {
-            this._sseSession.updateDynamicInfo(nextDynamicInfo);
-            return;
-        }
         this.publishMessage("update-dynamic-info", {
-            dynamic_info: { text: nextDynamicInfo },
+            dynamic_info: { text: dynamicInfo },
             participant_sid: this._participantSid || this._room.localParticipant?.sid,
         });
     }
@@ -2264,22 +1280,6 @@ export class ConvaiClient extends EventEmitter {
         if (shouldPreemptLipsync) {
             this.startTrackedConversation(`[context-update:${options.mode ?? "append"}]`);
         }
-        if (this._activeTransport === "sse" && this._sseSession) {
-            const data = {
-                ...(hasText && { text: options.text.trim() }),
-                ...(options.mode && { mode: options.mode }),
-                ...(options.run_llm && { run_llm: options.run_llm }),
-                ...(options.respond_mode && { respond_mode: options.respond_mode }),
-                ...(hasAttention && { current_attention_object: options.current_attention_object }),
-            };
-            if (options.run_llm === "false") {
-                this._sseSession.queueMessage("context-update", data);
-            }
-            else {
-                this._sseSession.sendMessage("context-update", data);
-            }
-            return;
-        }
         this.publishMessage("context-update", {
             ...(hasText && { text: options.text.trim() }),
             ...(options.mode && { mode: options.mode }),
@@ -2341,8 +1341,6 @@ export class ConvaiClient extends EventEmitter {
         }
         if (!this.isTransportReady())
             return;
-        if (this._activeTransport === "sse")
-            return;
         this.publishMessage("update-emotion", {
             state_of_mind: normalized,
             participant_sid: this._participantSid || this._room.localParticipant?.sid,
@@ -2424,10 +1422,6 @@ export class ConvaiClient extends EventEmitter {
      * the session from being disconnected due to inactivity.
      */
     resetIdleTimer() {
-        // SSE requests are one-turn streams; there is no persistent server-side
-        // realtime session for an idle timer to keep alive.
-        if (this._activeTransport === "sse")
-            return;
         if (!this.isTransportReady())
             return;
         this.publishMessage("reset-idle-timer", {
@@ -2437,18 +1431,4 @@ 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.
- *
- * A timeout is *not* a failure. Every character participant observes the
- * broadcast and duplicate forwards are response-suppressed after one actor
- * answers, so a lost ack is an expected outcome. The contract's rule is to
- * treat it as unknown and reconcile from the next authoritative snapshot,
- * which is what the rejection below tells the caller to do.
- */
-ConvaiClient.ROSTER_COMMAND_TIMEOUT_MS = 10000;
-/** Default bounded retry while a roster room is still provisioning. */
-ConvaiClient.ROSTER_RETRY_ATTEMPTS = 4;
-ConvaiClient.ROSTER_RETRY_INITIAL_MS = 500;
 //# sourceMappingURL=ConvaiClient.js.map