@nextpa/chat-core 0.1.0

package/dist/services/realtime/vertexai/vertexai-provider.js

@@ -0,0 +1,561 @@
+import { mapToolsForGoogle } from '../google/google-tool-mapper';
+import { GoogleAudioHandler } from '../google/google-audio';
+import { logger } from '../../../utils/logger';
+const AUDIO_MIME_TYPE = 'audio/pcm;rate=16000';
+const DEFAULT_VOICE = 'Kore';
+const MAX_TOOL_CALL_HISTORY = 5;
+const PLAYBACK_CHECK_INTERVAL_MS = 100;
+const PLAYBACK_SETTLED_CHECKS = 3;
+const DEFAULT_MAX_WAIT_MS = 20000;
+export class VertexAiRealtimeProvider {
+    ws = null;
+    audioHandler;
+    eventHandlers = new Map();
+    _status = 'disconnected';
+    pendingFunctionCalls = new Map();
+    awaitingToolResponse = false;
+    isSetupComplete = false;
+    modelResponding = false;
+    userSpeaking = false;
+    pendingCommands = [];
+    outputTranscriptBuffer = '';
+    inputTranscriptBuffer = '';
+    lastCompletedToolCalls = [];
+    sentFrames = 0;
+    droppedFrames = 0;
+    constructor() {
+        this.audioHandler = new GoogleAudioHandler();
+    }
+    get status() {
+        return this._status;
+    }
+    async connect(config) {
+        if (!config.proxyUrl) {
+            throw new Error('VertexAI provider requires proxyUrl in config');
+        }
+        if (!config.proxyBearerToken) {
+            throw new Error('VertexAI provider requires proxyBearerToken in config');
+        }
+        this._status = 'connecting';
+        this.emit('connectionStateChanged', 'connecting');
+        const wsUrl = config.proxyUrl;
+        logger.debug('[VertexAI] Connecting to proxy:', wsUrl, 'model:', config.model);
+        this.ws = new WebSocket(wsUrl, [
+            `nextpa.bearer.${config.proxyBearerToken}`,
+            'nextpa.voice.v1',
+        ]);
+        this.ws.onopen = () => {
+            logger.debug('[VertexAI] WebSocket opened, sending setup');
+            this._status = 'connected';
+            this.emit('connectionStateChanged', 'connected');
+            this.sendSetupMessage(config);
+        };
+        this.ws.onmessage = async (event) => {
+            try {
+                let text;
+                if (event.data instanceof Blob) {
+                    text = await event.data.text();
+                }
+                else {
+                    text = event.data;
+                }
+                const message = JSON.parse(text);
+                this.handleServerMessage(message);
+            }
+            catch (err) {
+                logger.error('[VertexAI] Failed to parse server message:', err);
+            }
+        };
+        this.ws.onerror = (event) => {
+            logger.error('[VertexAI] WebSocket error:', event);
+            this.emit('error', { message: 'Vertex AI proxy connection error' });
+        };
+        this.ws.onclose = (event) => {
+            logger.warn('[VertexAI] WebSocket closed, code:', event.code, 'reason:', event.reason, '- modelResponding:', this.modelResponding, 'pendingToolCalls:', this.pendingFunctionCalls.size, 'lastToolCalls:', this.lastCompletedToolCalls.join(' | ') || 'none');
+            this._status = 'disconnected';
+            this.resetSessionState();
+            this.audioHandler.stop();
+            this.emit('connectionStateChanged', 'disconnected');
+        };
+        this.sentFrames = 0;
+        this.droppedFrames = 0;
+        this.audioHandler.onAudioData = (base64Pcm) => this.handleMicFrame(base64Pcm);
+        this.audioHandler.onSpeechStarted = () => {
+            if (this.userSpeaking)
+                return;
+            this.userSpeaking = true;
+            this.emit('userSpeechStarted');
+        };
+        this.audioHandler.onSpeechEnded = () => {
+            if (!this.userSpeaking)
+                return;
+            this.userSpeaking = false;
+            this.emit('userSpeechEnded');
+        };
+        this.audioHandler.onAudioLevel = (level) => this.emit('userAudioLevel', level);
+        logger.debug('[VertexAI] Starting audio capture');
+        await this.audioHandler.startCapture();
+    }
+    handleMicFrame(base64Pcm) {
+        const canSend = this.ws && this.isSetupComplete && this._status === 'connected'
+            && this.pendingFunctionCalls.size === 0;
+        if (canSend) {
+            this.sendJson({
+                realtime_input: {
+                    media_chunks: [{
+                            data: base64Pcm,
+                            mime_type: AUDIO_MIME_TYPE,
+                        }],
+                },
+            });
+            this.sentFrames++;
+            if (this.sentFrames === 1 || this.sentFrames % 100 === 0) {
+                logger.debug('[VertexAI] Sent mic frame', this.sentFrames, '(dropped so far:', this.droppedFrames, ')');
+            }
+        }
+        else {
+            this.droppedFrames++;
+            if (this.droppedFrames === 1 || this.droppedFrames % 50 === 0) {
+                logger.debug('[VertexAI] DROPPED mic frame', this.droppedFrames, 'reason:', this.describeDropReason());
+            }
+        }
+    }
+    describeDropReason() {
+        if (this.ws) {
+            if (this.isSetupComplete) {
+                if (this._status === 'connected') {
+                    return 'pending-tool-calls';
+                }
+                return `status=${this._status}`;
+            }
+            return 'setup-incomplete';
+        }
+        return 'no-ws';
+    }
+    close() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        this.audioHandler.stop();
+        this._status = 'disconnected';
+        this.resetSessionState();
+    }
+    resumeAudio() {
+        this.audioHandler.resume();
+    }
+    mute(muted) {
+        this.audioHandler.setMuted(muted);
+    }
+    interrupt() {
+        // Gemini Live has no client-side response-cancel; dropping the queued
+        // playback stops the talking immediately, which is what the user wants.
+        this.audioHandler.clearPlaybackQueue();
+        this.emit('interrupted');
+    }
+    requestResponse() {
+        if (!this.isSetupComplete) {
+            this.pendingCommands.push({ type: 'requestResponse' });
+            return;
+        }
+        this.executeRequestResponse();
+    }
+    sendToolResult(callId, name, output) {
+        if (!this.isSetupComplete) {
+            this.pendingCommands.push({ type: 'sendToolResult', payload: { callId, name, output } });
+            return;
+        }
+        this.executeSendToolResult(callId, name, output);
+    }
+    sendText(text) {
+        if (!this.ws)
+            return;
+        if (!this.isSetupComplete) {
+            this.pendingCommands.push({ type: 'sendText', payload: text });
+            return;
+        }
+        this.sendJson({
+            client_content: {
+                turns: [{ role: 'user', parts: [{ text }] }],
+                turn_complete: true,
+            },
+        });
+    }
+    waitForAudioPlaybackEnd(timeoutMs = DEFAULT_MAX_WAIT_MS) {
+        return new Promise((resolve) => {
+            if (!this.audioHandler.isPlaybackActive) {
+                resolve('no active playback');
+                return;
+            }
+            let settledCount = 0;
+            const interval = setInterval(() => {
+                if (this.audioHandler.isPlaybackActive) {
+                    settledCount = 0;
+                }
+                else {
+                    settledCount++;
+                    if (settledCount >= PLAYBACK_SETTLED_CHECKS) {
+                        clearInterval(interval);
+                        resolve('playback complete');
+                    }
+                }
+            }, PLAYBACK_CHECK_INTERVAL_MS);
+            setTimeout(() => {
+                clearInterval(interval);
+                resolve('max wait reached');
+            }, timeoutMs);
+        });
+    }
+    async refreshAudioDevice() {
+        logger.debug('[VertexAI] Refreshing audio device');
+        await this.audioHandler.restartCapture();
+    }
+    on(event, handler) {
+        if (!this.eventHandlers.has(event)) {
+            this.eventHandlers.set(event, new Set());
+        }
+        this.eventHandlers.get(event).add(handler);
+        return () => this.off(event, handler);
+    }
+    off(event, handler) {
+        this.eventHandlers.get(event)?.delete(handler);
+    }
+    sendJson(data) {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(data));
+        }
+    }
+    sendSetupMessage(config) {
+        const toolDeclarations = mapToolsForGoogle(config.tools);
+        // languageCodes pin the ASR + TTS to a specific BCP-47 locale so
+        // Gemini doesn't drift into Spanish/Hindi on quiet inputs (observed
+        // live during M3-i easybell trunk testing). Empty when the tenant
+        // has no configured locale — Gemini auto-detects then.
+        const transcriptionLanguageCodes = config.transcription?.language
+            ? [config.transcription.language]
+            : undefined;
+        const setup = {
+            model: config.model,
+            generationConfig: {
+                responseModalities: ['AUDIO'],
+                speechConfig: {
+                    voiceConfig: {
+                        prebuiltVoiceConfig: {
+                            voiceName: config.voice || DEFAULT_VOICE,
+                        },
+                    },
+                },
+            },
+            realtimeInputConfig: {
+                automaticActivityDetection: {
+                    // LOW start sensitivity needs clearer speech to open a turn,
+                    // so background noise on mobile no longer trips the VAD.
+                    // (Gemini's own default is LOW; HIGH was over-eager here.)
+                    startOfSpeechSensitivity: 'START_SENSITIVITY_LOW',
+                    endOfSpeechSensitivity: 'END_SENSITIVITY_HIGH',
+                    prefixPaddingMs: 100,
+                    silenceDurationMs: 500,
+                },
+            },
+            inputAudioTranscription: transcriptionLanguageCodes
+                ? { languageCodes: transcriptionLanguageCodes }
+                : {},
+            outputAudioTranscription: transcriptionLanguageCodes
+                ? { languageCodes: transcriptionLanguageCodes }
+                : {},
+        };
+        if (config.instructions) {
+            setup.systemInstruction = { parts: [{ text: config.instructions }] };
+        }
+        if (toolDeclarations.length > 0) {
+            setup.tools = [{ functionDeclarations: toolDeclarations }];
+        }
+        this.sendJson({ setup });
+    }
+    emit(event, ...args) {
+        const handlers = this.eventHandlers.get(event);
+        if (!handlers)
+            return;
+        for (const handler of handlers) {
+            handler(...args);
+        }
+    }
+    resetSessionState() {
+        this.ws = null;
+        this.isSetupComplete = false;
+        this.awaitingToolResponse = false;
+        this.modelResponding = false;
+        this.userSpeaking = false;
+        this.pendingFunctionCalls.clear();
+        this.pendingCommands = [];
+        this.outputTranscriptBuffer = '';
+        this.inputTranscriptBuffer = '';
+        this.lastCompletedToolCalls = [];
+    }
+    executeRequestResponse() {
+        if (!this.ws)
+            return;
+        if (this.awaitingToolResponse) {
+            logger.debug('[VertexAI] Skipping requestResponse - auto-continues after tool response');
+            this.awaitingToolResponse = false;
+            return;
+        }
+        if (this.pendingFunctionCalls.size > 0 || this.modelResponding) {
+            logger.debug('[VertexAI] Skipping requestResponse - model busy');
+            return;
+        }
+        this.sendJson({
+            client_content: {
+                turns: [{ role: 'user', parts: [{ text: '.' }] }],
+                turn_complete: true,
+            },
+        });
+    }
+    executeSendToolResult(callId, name, output) {
+        if (!this.ws)
+            return;
+        this.awaitingToolResponse = true;
+        const funcName = this.pendingFunctionCalls.get(callId)?.name ?? name;
+        const rawOutput = output;
+        let parsedResult;
+        try {
+            const parsed = JSON.parse(rawOutput);
+            parsedResult =
+                typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)
+                    ? parsed
+                    : { output: parsed };
+        }
+        catch {
+            parsedResult = { output: rawOutput };
+        }
+        try {
+            this.sendJson({
+                tool_response: {
+                    function_responses: [{
+                            name: funcName,
+                            response: parsedResult,
+                        }],
+                },
+            });
+            logger.debug('[VertexAI] Tool response sent for', funcName, 'size:', rawOutput.length);
+            this.lastCompletedToolCalls.push(`${funcName}(${rawOutput.slice(0, 100)})`);
+            if (this.lastCompletedToolCalls.length > MAX_TOOL_CALL_HISTORY) {
+                this.lastCompletedToolCalls.shift();
+            }
+        }
+        catch (error) {
+            logger.error('[VertexAI] Failed to send tool response for', funcName, error);
+            this.emit('error', { message: `Tool response failed for ${funcName}: ${error}` });
+        }
+        finally {
+            this.pendingFunctionCalls.delete(callId);
+            if (this.pendingFunctionCalls.size === 0) {
+                this.modelResponding = false;
+                this.audioHandler.resumeCapture();
+            }
+        }
+    }
+    finalizeInputTranscript() {
+        if (this.inputTranscriptBuffer) {
+            this.emit('userTranscriptCompleted', this.inputTranscriptBuffer);
+            this.inputTranscriptBuffer = '';
+        }
+    }
+    handleServerMessage(message) {
+        logger.debug('[VertexAI] message keys:', Object.keys(message).join(', '));
+        if (message.setupComplete !== undefined) {
+            logger.debug('[VertexAI] Setup complete');
+            this.isSetupComplete = true;
+            this.emit('sessionReady');
+            this.flushPendingCommands();
+            return;
+        }
+        const voiceActivity = (message.voiceActivity ?? message.voice_activity);
+        if (voiceActivity) {
+            this.handleVoiceActivity(voiceActivity);
+        }
+        if (message.usageMetadata) {
+            this.extractAndEmitUsage(message.usageMetadata);
+        }
+        if (message.serverContent) {
+            this.handleServerContent(message.serverContent);
+        }
+        if (message.toolCall) {
+            this.ensureSpeechStopped();
+            this.handleToolCall(message.toolCall);
+        }
+        if (message.toolCallCancellation) {
+            logger.debug('[VertexAI] Tool call cancelled, clearing', this.pendingFunctionCalls.size, 'pending calls');
+            this.pendingFunctionCalls.clear();
+            this.modelResponding = false;
+            this.audioHandler.resumeCapture();
+            this.audioHandler.clearPlaybackQueue();
+        }
+        if (message.goAway) {
+            const goAway = message.goAway;
+            const timeLeft = goAway.timeLeft;
+            logger.warn('[VertexAI] Server disconnecting soon, timeLeft:', timeLeft);
+            this.emit('serverDisconnecting', timeLeft);
+        }
+    }
+    extractAndEmitUsage(metadata) {
+        logger.debug('[VertexAI] Raw usage metadata:', JSON.stringify(metadata));
+        const inputTokens = metadata.promptTokenCount ?? 0;
+        const outputTokens = metadata.responseTokenCount ?? metadata.candidatesTokenCount ?? 0;
+        const totalTokens = metadata.totalTokenCount ?? (inputTokens + outputTokens);
+        const promptDetails = metadata.promptTokensDetails;
+        const responseDetails = metadata.responseTokensDetails ??
+            metadata.candidatesTokensDetails;
+        const findModality = (details, modality) => details?.find((d) => d.modality === modality)?.tokenCount ?? undefined;
+        const providerUsage = {
+            inputTokens,
+            outputTokens,
+            totalTokens,
+            cachedTokens: metadata.cachedContentTokenCount ?? undefined,
+            audioInputTokens: findModality(promptDetails, 'AUDIO'),
+            audioOutputTokens: findModality(responseDetails, 'AUDIO'),
+            textInputTokens: findModality(promptDetails, 'TEXT'),
+            textOutputTokens: findModality(responseDetails, 'TEXT'),
+        };
+        this.emit('usageUpdated', providerUsage);
+    }
+    flushPendingCommands() {
+        const commands = this.pendingCommands;
+        this.pendingCommands = [];
+        for (const cmd of commands) {
+            switch (cmd.type) {
+                case 'requestResponse':
+                    this.executeRequestResponse();
+                    break;
+                case 'sendToolResult': {
+                    const p = cmd.payload;
+                    this.executeSendToolResult(p.callId, p.name, p.output);
+                    break;
+                }
+                case 'sendText':
+                    this.sendText(cmd.payload);
+                    break;
+            }
+        }
+    }
+    handleVoiceActivity(activity) {
+        const type = activity.voiceActivityType ?? activity.voice_activity_type;
+        if ((type === 'ACTIVITY_START') && !this.userSpeaking) {
+            logger.debug('[VertexAI] Voice activity: ACTIVITY_START');
+            this.userSpeaking = true;
+            this.emit('userSpeechStarted');
+        }
+        else if ((type === 'ACTIVITY_END') && this.userSpeaking) {
+            logger.debug('[VertexAI] Voice activity: ACTIVITY_END');
+            this.ensureSpeechStopped();
+        }
+    }
+    handleServerContent(content) {
+        const inputTranscription = content.inputTranscription;
+        const outputTranscriptionRaw = content.outputTranscription;
+        const hasContent = inputTranscription || outputTranscriptionRaw || content.modelTurn || content.turnComplete;
+        if (!hasContent && !this.modelResponding && !this.userSpeaking) {
+            logger.debug('[VertexAI] Speech activity detected (empty serverContent fallback)');
+            this.userSpeaking = true;
+            this.emit('userSpeechStarted');
+        }
+        if (inputTranscription?.text) {
+            logger.debug('[VertexAI] inputTranscription text:', inputTranscription.text.slice(0, 80));
+            if (!this.userSpeaking) {
+                this.userSpeaking = true;
+                this.emit('userSpeechStarted');
+            }
+            this.inputTranscriptBuffer += inputTranscription.text;
+            this.emit('userTranscriptDelta', inputTranscription.text);
+        }
+        if (inputTranscription?.finished) {
+            logger.debug('[VertexAI] inputTranscription finished');
+            this.finalizeInputTranscript();
+            this.userSpeaking = false;
+            this.emit('userSpeechStopped');
+        }
+        const isFirstModelResponse = !!content.modelTurn && !this.modelResponding;
+        if (content.modelTurn) {
+            this.handleModelTurn(content);
+        }
+        if (outputTranscriptionRaw?.text) {
+            if (isFirstModelResponse) {
+                this.deferAssistantTranscript(outputTranscriptionRaw.text);
+            }
+            else {
+                this.outputTranscriptBuffer += outputTranscriptionRaw.text;
+                this.emit('assistantTranscriptDelta', outputTranscriptionRaw.text);
+            }
+        }
+        if (content.turnComplete) {
+            this.handleTurnComplete();
+        }
+        if (content.interrupted) {
+            this.handleInterrupted();
+        }
+    }
+    static THINKING_RENDER_DELAY_MS = 150;
+    deferAssistantTranscript(text) {
+        setTimeout(() => {
+            this.outputTranscriptBuffer += text;
+            this.emit('assistantTranscriptDelta', text);
+        }, VertexAiRealtimeProvider.THINKING_RENDER_DELAY_MS);
+    }
+    ensureSpeechStopped() {
+        if (this.inputTranscriptBuffer) {
+            this.finalizeInputTranscript();
+        }
+        this.userSpeaking = false;
+        this.emit('userSpeechStopped');
+    }
+    handleModelTurn(content) {
+        if (!this.modelResponding) {
+            logger.debug('[VertexAI] Model turn started');
+        }
+        this.modelResponding = true;
+        this.ensureSpeechStopped();
+        const modelTurn = content.modelTurn;
+        if (modelTurn?.parts) {
+            for (const part of modelTurn.parts) {
+                if (part.inlineData?.mimeType?.startsWith('audio/') && part.inlineData.data) {
+                    this.audioHandler.playAudio(part.inlineData.data);
+                }
+            }
+        }
+    }
+    handleTurnComplete() {
+        logger.debug('[VertexAI] Turn complete');
+        this.modelResponding = false;
+        if (this.outputTranscriptBuffer) {
+            this.emit('assistantTranscriptDone', this.outputTranscriptBuffer);
+        }
+        this.outputTranscriptBuffer = '';
+        this.emit('audioDone');
+    }
+    handleInterrupted() {
+        logger.debug('[VertexAI] Model interrupted');
+        this.modelResponding = false;
+        this.finalizeInputTranscript();
+        this.outputTranscriptBuffer = '';
+        this.audioHandler.clearPlaybackQueue();
+        this.emit('interrupted');
+        if (!this.userSpeaking) {
+            this.userSpeaking = true;
+            this.emit('userSpeechStarted');
+        }
+    }
+    handleToolCall(toolCall) {
+        if (!toolCall.functionCalls)
+            return;
+        this.modelResponding = true;
+        this.audioHandler.pauseCapture();
+        for (const fc of toolCall.functionCalls) {
+            const callId = fc.id || `call_${Date.now()}`;
+            const name = fc.name ?? '';
+            const args = JSON.stringify(fc.args || {});
+            logger.debug('[VertexAI] Tool call received:', name, 'args:', args);
+            this.pendingFunctionCalls.set(callId, { name, args });
+            this.emit('functionCall', { callId, name, arguments: args });
+        }
+    }
+}

package/dist/services/realtime/voice-session-tracker.d.ts

@@ -0,0 +1,10 @@
+import type { WidgetApiClient } from '../../services/api';
+export declare class VoiceSessionTracker {
+    private sessionId;
+    private heartbeatTimer;
+    private api;
+    private active;
+    private readonly handleVisibilityChange;
+    startTracking(api: WidgetApiClient, sessionId: string): Promise<void>;
+    stopTracking(): Promise<void>;
+}

package/dist/services/realtime/voice-session-tracker.js

@@ -0,0 +1,62 @@
+import { logger } from '../../utils/logger';
+const LOG_PREFIX = '[VoiceSessionTracker]';
+const HEARTBEAT_INTERVAL_MS = 30_000;
+export class VoiceSessionTracker {
+    sessionId = null;
+    heartbeatTimer = null;
+    api = null;
+    active = false;
+    handleVisibilityChange = () => {
+        if (document.visibilityState === 'hidden' && this.active && this.sessionId) {
+            this.api?.sendVoiceSessionBeacon(this.sessionId);
+            logger.debug(`${LOG_PREFIX} Beacon sent on visibility hidden`);
+        }
+    };
+    async startTracking(api, sessionId) {
+        if (this.active) {
+            await this.stopTracking();
+        }
+        this.api = api;
+        this.sessionId = sessionId;
+        this.active = true;
+        try {
+            await api.startVoiceSession(sessionId);
+            logger.debug(`${LOG_PREFIX} Session started: ${sessionId}`);
+        }
+        catch (error) {
+            logger.error(`${LOG_PREFIX} Failed to start session`, error);
+        }
+        this.heartbeatTimer = setInterval(async () => {
+            if (!this.active || !this.sessionId || !this.api)
+                return;
+            try {
+                await this.api.sendVoiceHeartbeat(this.sessionId);
+            }
+            catch (error) {
+                logger.error(`${LOG_PREFIX} Heartbeat failed`, error);
+            }
+        }, HEARTBEAT_INTERVAL_MS);
+        document.addEventListener('visibilitychange', this.handleVisibilityChange);
+    }
+    async stopTracking() {
+        if (!this.active)
+            return;
+        this.active = false;
+        document.removeEventListener('visibilitychange', this.handleVisibilityChange);
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+        if (this.sessionId && this.api) {
+            try {
+                await this.api.endVoiceSession(this.sessionId);
+                logger.debug(`${LOG_PREFIX} Session ended: ${this.sessionId}`);
+            }
+            catch (error) {
+                logger.error(`${LOG_PREFIX} Failed to end session`, error);
+            }
+        }
+        this.sessionId = null;
+        this.api = null;
+    }
+}

package/dist/services/signalr.d.ts

@@ -0,0 +1,37 @@
+import * as signalR from '@microsoft/signalr';
+export interface SignalREvents {
+    onStopConversation?: () => void;
+    onOpenUrl?: (url: string) => void;
+    onOpenFile?: (url: string) => void;
+    onError?: (title: string, message: string) => void;
+    onConnected?: () => void;
+    onDisconnected?: () => void;
+}
+export interface TextChatSignalRHandlers {
+    onStreamDelta?: (delta: string, messageId: string) => void;
+    onStreamCompleted?: (fullText: string, messageId: string) => void;
+    onToolCall?: (toolName: string, status: string, result?: string, agentLabel?: string) => void;
+}
+export interface PageInteractionSignalRHandlers {
+    onPageInteractionRequest?: (requestJson: string) => void;
+}
+export declare class SignalRService {
+    private connection;
+    private events;
+    private textChatHandlers;
+    private pageInteractionHandlers;
+    private registrationInfo;
+    get isConnected(): boolean;
+    setEventHandlers(events: SignalREvents): void;
+    setTextChatHandlers(handlers: TextChatSignalRHandlers): void;
+    clearTextChatHandlers(): void;
+    setPageInteractionHandlers(handlers: PageInteractionSignalRHandlers): void;
+    clearPageInteractionHandlers(): void;
+    getConnection(): signalR.HubConnection | null;
+    setRegistrationInfo(clientId: string, tenantId: string, userId: string): void;
+    connect(baseUrl: string, token: string): Promise<void>;
+    disconnect(): Promise<void>;
+    private registerClient;
+    private setupEventHandlers;
+    private handleNotification;
+}