solver-sdk 1.6.8 → 1.7.0

package/dist/esm/utils/code-solver-websocket-client.js

@@ -34,6 +34,24 @@ export class CodeSolverWebSocketClient {
         this.activeProjectId = null;
         /** Обработчики событий мышления */
         this.thinkingEventHandlers = new Map();
+        /** Таймеры для ping/pong */
+        this.pingIntervals = new Map();
+        /** Статистика ping/pong */
+        this.pingStats = new Map();
+        /** Количество последовательных таймаутов */
+        this.pingTimeouts = new Map();
+        /** Задержка по умолчанию между ping-сообщениями (30 секунд) */
+        this.defaultPingInterval = 30000;
+        /** Порог таймаута (количество пропущенных pong) */
+        this.timeoutThreshold = 3;
+        /** Хранилище обработчиков ping/pong */
+        this.pingPongEventHandlers = new Map();
+        /** Токены сессий для разных пространств имен */
+        this.sessionTokens = new Map();
+        /** Состояние подключения для разных пространств имен */
+        this.connectionState = new Map();
+        /** Таймер для проверки здоровья соединений */
+        this.healthCheckTimer = null;
         this.baseURL = baseURL.replace(/^http/, 'ws');
         this.options = {
             ...options,
@@ -176,54 +194,6 @@ export class CodeSolverWebSocketClient {
         this.clients.set(namespace, client);
         return client;
     }
-    /**
-     * Подключается к пространству имен рассуждений
-     * @param reasoningId ID рассуждения (опционально)
-     * @returns Promise с результатом подключения
-     */
-    async connectToReasoning(reasoningId) {
-        try {
-            this.logger('info', 'Подключение к пространству имен рассуждений', { reasoningId });
-            // Если указан ID рассуждения, сохраняем его
-            if (reasoningId) {
-                this.activeReasoningId = reasoningId;
-            }
-            // Подключаемся к пространству имен рассуждений
-            const client = await this.connect(WebSocketNamespace.REASONING);
-            // Аутентифицируемся с увеличенным таймаутом
-            try {
-                const authResult = await client.emitWithAck(WsEvents.AUTHENTICATE, {
-                    token: this.options.apiKey,
-                    reasoningId: this.activeReasoningId
-                }, 10000);
-                this.logger('debug', 'Результат аутентификации в namespace рассуждений', authResult);
-            }
-            catch (error) {
-                this.logger('error', 'Ошибка аутентификации в namespace рассуждений', error);
-                return false;
-            }
-            // Если у нас есть ID рассуждения, присоединяемся к нему
-            if (this.activeReasoningId) {
-                try {
-                    const joinResult = await client.emitWithAck(WsEvents.JOIN_REASONING, {
-                        reasoningId: this.activeReasoningId,
-                        token: this.options.apiKey
-                    }, 10000);
-                    this.logger('debug', 'Результат присоединения к рассуждению', joinResult);
-                    return true;
-                }
-                catch (error) {
-                    this.logger('error', 'Ошибка присоединения к рассуждению', error);
-                    return false;
-                }
-            }
-            return true;
-        }
-        catch (error) {
-            this.logger('error', 'Ошибка подключения к пространству имен рассуждений', error);
-            return false;
-        }
-    }
     /**
      * Подключается к пространству имен индексации
      * @param projectId ID проекта (опционально)
@@ -354,11 +324,17 @@ export class CodeSolverWebSocketClient {
     }
     /**
      * Отключается от всех пространств имен
+     * Отключает автоматический механизм ping/pong
      */
     disconnectAll() {
+        // Отключаем ping/pong для всех соединений
+        this.disablePingPong();
+        // Отключаемся от всех namespace
         for (const [namespace, client] of this.clients.entries()) {
-            client.close();
-            this.clients.delete(namespace);
+            if (client) {
+                client.close();
+                this.clients.delete(namespace);
+            }
         }
         // Сбрасываем активные сессии
         this.activeReasoningId = null;
@@ -695,5 +671,959 @@ export class CodeSolverWebSocketClient {
             }
         }
     }
+    /**
+     * Включить автоматическую отправку ping-сообщений и сбор статистики
+     * @param {number} interval - Интервал между ping-сообщениями в миллисекундах
+     * @param {number} timeoutThreshold - Количество пропущенных pong-сообщений, после которого соединение считается потерянным
+     * @returns {boolean} - Успешность включения ping/pong
+     */
+    enablePingPong(interval = this.defaultPingInterval, timeoutThreshold = 3) {
+        // Сохраняем порог таймаута
+        this.timeoutThreshold = timeoutThreshold;
+        // Для каждого активного соединения
+        for (const [namespace, client] of this.clients.entries()) {
+            try {
+                // Проверяем, активно ли соединение
+                if (!client || !this.isConnected(namespace)) {
+                    this.logger('warn', `Невозможно включить ping/pong для неактивного соединения в ${namespace}`);
+                    continue;
+                }
+                // Останавливаем существующий таймер, если есть
+                this.disablePingPong(namespace);
+                // Инициализируем статистику, если не была создана
+                if (!this.pingStats.has(namespace)) {
+                    this.pingStats.set(namespace, {
+                        namespace,
+                        socketId: client.getSocketId(),
+                        pingSent: 0,
+                        pongReceived: 0,
+                        averageRtt: 0,
+                        minRtt: Number.MAX_SAFE_INTEGER,
+                        maxRtt: 0,
+                        lastRtt: 0,
+                        lastPongTimestamp: Date.now(),
+                        isConnected: true
+                    });
+                }
+                // Сбрасываем счетчик таймаутов
+                this.pingTimeouts.set(namespace, 0);
+                // Устанавливаем обработчик для события connection_pong
+                client.on(WsEvents.CONNECTION_PONG, (data) => {
+                    // Обновляем статистику
+                    const stats = this.pingStats.get(namespace);
+                    if (stats) {
+                        stats.pongReceived++;
+                        stats.lastPongTimestamp = Date.now();
+                        stats.isConnected = true;
+                        // Рассчитываем RTT, если есть метка времени эхо
+                        if (data && data.echo) {
+                            const rtt = Date.now() - data.echo;
+                            stats.lastRtt = rtt;
+                            // Обновляем min и max
+                            stats.minRtt = Math.min(stats.minRtt, rtt);
+                            stats.maxRtt = Math.max(stats.maxRtt, rtt);
+                            // Обновляем среднее значение
+                            stats.averageRtt = (stats.averageRtt * (stats.pongReceived - 1) + rtt) / stats.pongReceived;
+                        }
+                        // Сбрасываем счетчик таймаутов
+                        this.pingTimeouts.set(namespace, 0);
+                    }
+                    // Логируем получение pong
+                    this.logger('debug', `Получен pong для ${namespace}`, {
+                        rtt: stats?.lastRtt,
+                        socketId: client.getSocketId()
+                    });
+                });
+                // Устанавливаем интервал отправки ping
+                const pingInterval = setInterval(() => {
+                    if (this.isConnected(namespace)) {
+                        // Формируем данные ping
+                        const pingData = { timestamp: Date.now() };
+                        // Отправляем ping
+                        const sent = this.send(namespace, WsEvents.CONNECTION_PING, pingData);
+                        // Если успешно отправлено, обновляем статистику
+                        if (sent) {
+                            const stats = this.pingStats.get(namespace);
+                            if (stats) {
+                                stats.pingSent++;
+                            }
+                            this.logger('debug', `Отправлен ping для ${namespace}`, pingData);
+                        }
+                        else {
+                            this.logger('warn', `Не удалось отправить ping для ${namespace}`);
+                        }
+                        // Проверяем таймаут
+                        const timeouts = this.pingTimeouts.get(namespace) || 0;
+                        const stats = this.pingStats.get(namespace);
+                        // Если разница между отправленными и полученными превышает порог,
+                        // или последний pong был получен слишком давно
+                        if ((stats && stats.pingSent - stats.pongReceived > this.timeoutThreshold) ||
+                            (stats && Date.now() - stats.lastPongTimestamp > interval * this.timeoutThreshold)) {
+                            // Увеличиваем счетчик таймаутов
+                            this.pingTimeouts.set(namespace, timeouts + 1);
+                            if (timeouts + 1 >= this.timeoutThreshold) {
+                                // Соединение потеряно
+                                this.logger('error', `Соединение потеряно (таймаут ping/pong) для ${namespace}`);
+                                // Установка флага неактивного соединения
+                                if (stats) {
+                                    stats.isConnected = false;
+                                }
+                                // На прямую отправку события через socket
+                                this.send(namespace, 'connection_timeout', {
+                                    namespace,
+                                    socketId: client.getSocketId(),
+                                    timeouts: timeouts + 1,
+                                    threshold: this.timeoutThreshold
+                                });
+                                // Также вызываем обработчики событий
+                                const timeoutHandlers = this.pingPongEventHandlers.get('connection_timeout') || [];
+                                timeoutHandlers.forEach(handler => {
+                                    try {
+                                        handler({
+                                            namespace,
+                                            socketId: client.getSocketId(),
+                                            timeouts: timeouts + 1,
+                                            threshold: this.timeoutThreshold
+                                        });
+                                    }
+                                    catch (error) {
+                                        this.logger('error', `Ошибка при обработке события connection_timeout`, error);
+                                    }
+                                });
+                            }
+                        }
+                    }
+                }, interval);
+                // Сохраняем интервал
+                this.pingIntervals.set(namespace, pingInterval);
+                this.logger('info', `Включен механизм ping/pong для ${namespace} с интервалом ${interval}ms`);
+            }
+            catch (error) {
+                this.logger('error', `Ошибка при включении ping/pong для ${namespace}`, error);
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Отключить автоматическую отправку ping-сообщений
+     * @param {WebSocketNamespace} [namespace] - Пространство имен для отключения (если не указано - отключается везде)
+     */
+    disablePingPong(namespace) {
+        if (namespace) {
+            // Отключаем для указанного namespace
+            const interval = this.pingIntervals.get(namespace);
+            if (interval) {
+                clearInterval(interval);
+                this.pingIntervals.delete(namespace);
+                this.logger('info', `Отключен механизм ping/pong для ${namespace}`);
+            }
+        }
+        else {
+            // Отключаем для всех namespace
+            for (const [ns, interval] of this.pingIntervals.entries()) {
+                clearInterval(interval);
+                this.pingIntervals.delete(ns);
+                this.logger('info', `Отключен механизм ping/pong для ${ns}`);
+            }
+        }
+    }
+    /**
+     * Получить статистику ping/pong
+     * @param {WebSocketNamespace} [namespace] - Пространство имен для получения статистики
+     * @returns {PingPongStats | PingPongStats[] | null} - Статистика ping/pong
+     */
+    getPingStats(namespace) {
+        if (namespace) {
+            // Возвращаем статистику для указанного namespace
+            return this.pingStats.get(namespace) || null;
+        }
+        else {
+            // Возвращаем статистику для всех namespace
+            return Array.from(this.pingStats.values());
+        }
+    }
+    /**
+     * Добавляет обработчик для событий ping/pong
+     * @param {string} eventType - Тип события (connection_timeout)
+     * @param {(data: any) => void} handler - Обработчик события
+     */
+    onPingPongEvent(eventType, handler) {
+        if (!this.pingPongEventHandlers.has(eventType)) {
+            this.pingPongEventHandlers.set(eventType, []);
+        }
+        const handlers = this.pingPongEventHandlers.get(eventType);
+        if (handlers) {
+            handlers.push(handler);
+        }
+    }
+    /**
+     * Удаляет обработчик для событий ping/pong
+     * @param {string} eventType - Тип события
+     * @param {(data: any) => void} [handler] - Обработчик события (если не указан, удаляются все обработчики)
+     */
+    offPingPongEvent(eventType, handler) {
+        if (!handler) {
+            // Если обработчик не указан, удаляем все обработчики для этого типа события
+            this.pingPongEventHandlers.delete(eventType);
+        }
+        else {
+            // Если обработчик указан, удаляем только его
+            const handlers = this.pingPongEventHandlers.get(eventType);
+            if (handlers) {
+                const index = handlers.findIndex(h => h === handler);
+                if (index !== -1) {
+                    handlers.splice(index, 1);
+                }
+            }
+        }
+    }
+    /**
+     * Возвращает функцию-обработчик для pong-ответов, которая рассчитывает RTT
+     * @returns {(data: any) => void} Функция-обработчик
+     */
+    getPongHandler() {
+        return (data) => {
+            if (data && data.echo) {
+                const rtt = Date.now() - data.echo;
+                console.log(`[PONG] RTT: ${rtt}ms, namespace: ${data.namespace || 'unknown'}`);
+                return rtt;
+            }
+            return -1;
+        };
+    }
+    /**
+     * Выполняет диагностику соединения и возвращает подробный отчет
+     * @param {WebSocketNamespace} namespace Пространство имен
+     * @returns {ConnectionDiagnostics} Объект с диагностической информацией
+     */
+    diagnoseConnection(namespace) {
+        const client = this.clients.get(namespace);
+        const stats = this.pingStats.get(namespace);
+        const connectionState = this.getConnectionState(namespace);
+        const sessionToken = this.getSessionToken(namespace);
+        return {
+            namespace,
+            isConnected: client?.isConnected() || false,
+            socketId: client?.getSocketId() || null,
+            lastActivity: stats?.lastPongTimestamp || 0,
+            rtt: {
+                current: stats?.lastRtt || -1,
+                min: stats?.minRtt === Number.MAX_SAFE_INTEGER ? -1 : (stats?.minRtt || -1),
+                max: stats?.maxRtt || -1,
+                avg: stats?.averageRtt || -1
+            },
+            pingSent: stats?.pingSent || 0,
+            pongReceived: stats?.pongReceived || 0,
+            missedPongs: (stats?.pingSent || 0) - (stats?.pongReceived || 0),
+            timeoutCount: this.pingTimeouts.get(namespace) || 0,
+            reconnectAttempts: connectionState.reconnectAttempts,
+            lastConnectTime: connectionState.lastConnectTime,
+            sessionRecovery: {
+                hasSessionToken: !!sessionToken,
+                tokenLength: sessionToken?.length || 0,
+                wasRecovered: !!sessionToken && (stats?.pongReceived || 0) > 0
+            }
+        };
+    }
+    /**
+     * Выполняет диагностику всех активных соединений
+     * @returns {Record<string, ConnectionDiagnostics>} Объект с диагностической информацией по всем соединениям
+     */
+    diagnoseAllConnections() {
+        const result = {};
+        // Проверяем каждое возможное пространство имен
+        for (const namespace of Object.values(WebSocketNamespace)) {
+            if (this.clients.has(namespace)) {
+                result[String(namespace)] = this.diagnoseConnection(namespace);
+            }
+        }
+        return result;
+    }
+    /**
+     * Рассчитывает задержку для переподключения на основе количества попыток и стратегии
+     * @param {WebSocketNamespace} namespace Пространство имен
+     * @returns {number} Задержка в миллисекундах
+     */
+    calculateReconnectDelay(namespace) {
+        const state = this.getConnectionState(namespace);
+        const attempts = state.reconnectAttempts;
+        const strategy = this.options.reconnectStrategy || 'exponential';
+        const baseDelay = this.options.retryDelay || 1000;
+        const maxDelay = this.options.maxRetryDelay || 30000;
+        if (strategy === 'exponential') {
+            // Экспоненциальный рост с фактором 1.5
+            const calculatedDelay = Math.min(baseDelay * Math.pow(1.5, attempts), maxDelay);
+            // Добавляем случайный фактор (jitter) для предотвращения штормов переподключений
+            return calculatedDelay * (0.8 + Math.random() * 0.4);
+        }
+        else {
+            // Линейный рост
+            return Math.min(baseDelay * (attempts + 1), maxDelay);
+        }
+    }
+    /**
+     * Принудительно переподключает соединение для указанного пространства имен
+     * @param {WebSocketNamespace} namespace Пространство имен
+     * @param {boolean} immediate Выполнить переподключение немедленно, без задержки
+     * @returns {Promise<boolean>} Успешность операции
+     */
+    async reconnectNamespace(namespace, immediate = false) {
+        const client = this.clients.get(namespace);
+        try {
+            // Если клиент уже существует, закрываем его
+            if (client) {
+                this.logger('info', `Принудительное переподключение для ${namespace}`);
+                try {
+                    // Отключаем ping/pong для этого namespace
+                    this.disablePingPong(namespace);
+                    // Закрываем соединение
+                    client.close();
+                }
+                catch (e) {
+                    this.logger('warn', `Ошибка при закрытии соединения с ${namespace}: ${e instanceof Error ? e.message : String(e)}`);
+                }
+                // Удаляем клиент из кэша
+                this.clients.delete(namespace);
+            }
+            else {
+                this.logger('info', `Инициируем новое подключение для ${namespace}`);
+            }
+            // Устанавливаем состояние переподключения
+            this.setConnectionState(namespace, false, true);
+            // Инкрементируем счетчик попыток
+            this.incrementReconnectAttempts(namespace);
+            // Рассчитываем задержку, если не требуется немедленное переподключение
+            if (!immediate) {
+                const delay = this.calculateReconnectDelay(namespace);
+                this.logger('info', `Переподключение для ${namespace} через ${delay}ms (попытка ${this.getConnectionState(namespace).reconnectAttempts})`);
+                // Ждем рассчитанное время
+                await new Promise(resolve => setTimeout(resolve, delay));
+            }
+            // Выполняем подключение с соответствующими параметрами
+            let params = {};
+            // Проверяем тип пространства имен и добавляем соответствующие параметры
+            if (namespace === WebSocketNamespace.REASONING && this.activeReasoningId) {
+                params.reasoningId = this.activeReasoningId;
+            }
+            else if ((namespace === WebSocketNamespace.INDEXING || namespace === WebSocketNamespace.DEPENDENCIES) && this.activeProjectId) {
+                params.projectId = this.activeProjectId;
+            }
+            // Подключаемся
+            await this.connect(namespace, params);
+            // Если это пространство имен рассуждений и есть активное рассуждение,
+            // пытаемся присоединиться к нему
+            if (namespace === WebSocketNamespace.REASONING && this.activeReasoningId) {
+                await this.connectToReasoning(this.activeReasoningId);
+            }
+            else if (namespace === WebSocketNamespace.INDEXING && this.activeProjectId) {
+                await this.connectToIndexing(this.activeProjectId);
+            }
+            else if (namespace === WebSocketNamespace.DEPENDENCIES && this.activeProjectId) {
+                await this.connectToDependencies(this.activeProjectId);
+            }
+            return true;
+        }
+        catch (error) {
+            this.logger('error', `Ошибка при переподключении к ${namespace}: ${error instanceof Error ? error.message : String(error)}`);
+            return false;
+        }
+    }
+    /**
+     * Настраивает периодическую проверку здоровья соединения
+     * @param {number} [interval=30000] Интервал проверки в миллисекундах
+     */
+    setupConnectionHealthCheck(interval = 30000) {
+        // Останавливаем существующую проверку, если она есть
+        if (this.healthCheckTimer) {
+            clearInterval(this.healthCheckTimer);
+        }
+        this.healthCheckTimer = setInterval(() => {
+            for (const namespace of Object.values(WebSocketNamespace)) {
+                const typedNamespace = namespace;
+                const client = this.clients.get(typedNamespace);
+                if (!client)
+                    continue;
+                // Проверяем соединение через WebSocket клиент
+                if (!client.isConnected()) {
+                    this.logger('warn', `Соединение с ${namespace} не активно, инициируем переподключение`);
+                    this.reconnectNamespace(typedNamespace, false).catch(() => { });
+                    continue;
+                }
+                // Проверяем статистику ping/pong
+                const stats = this.pingStats.get(typedNamespace);
+                if (stats) {
+                    const now = Date.now();
+                    // Если последний pong был получен слишком давно
+                    if (now - stats.lastPongTimestamp > interval * 2) {
+                        this.logger('warn', `Долгое отсутствие активности для ${namespace}, проверка соединения...`);
+                        // Отправляем проверочный ping
+                        this.send(typedNamespace, 'connection_health_check', { timestamp: now, echo: now });
+                        // Устанавливаем таймаут для проверки ответа
+                        setTimeout(() => {
+                            const currentStats = this.pingStats.get(typedNamespace);
+                            if (currentStats && now - currentStats.lastPongTimestamp > interval * 2) {
+                                this.logger('error', `Соединение не отвечает для ${namespace}, инициируем переподключение`);
+                                this.reconnectNamespace(typedNamespace, false).catch(() => { });
+                            }
+                        }, 5000); // Ждем 5 секунд на ответ
+                    }
+                }
+            }
+        }, interval);
+        this.logger('info', 'Настроена периодическая проверка здоровья соединения с интервалом ' + interval + 'ms');
+    }
+    /**
+     * Сохраняет токен сессии для пространства имен
+     * @param {WebSocketNamespace} namespace Пространство имен
+     * @param {string} token Токен сессии
+     */
+    saveSessionToken(namespace, token) {
+        if (this.options.enableSessionPersistence !== false) {
+            this.sessionTokens.set(namespace, token);
+            this.logger('info', `Сохранен токен сессии для ${namespace}`, { tokenLength: token.length });
+        }
+    }
+    /**
+     * Получает сохраненный токен сессии для пространства имен
+     * @param {WebSocketNamespace} namespace Пространство имен
+     * @returns {string | null} Токен сессии или null, если не найден
+     */
+    getSessionToken(namespace) {
+        if (this.options.enableSessionPersistence === false) {
+            return null;
+        }
+        return this.sessionTokens.get(namespace) || null;
+    }
+    /**
+     * Удаляет сохраненный токен сессии для пространства имен
+     * @param {WebSocketNamespace} namespace Пространство имен
+     */
+    clearSessionToken(namespace) {
+        this.sessionTokens.delete(namespace);
+        this.logger('info', `Удален токен сессии для ${namespace}`);
+    }
+    /**
+     * Устанавливает состояние подключения для пространства имен
+     * @param {WebSocketNamespace} namespace Пространство имен
+     * @param {boolean} connected Состояние подключения
+     * @param {boolean} reconnecting Состояние переподключения
+     */
+    setConnectionState(namespace, connected, reconnecting = false) {
+        const state = this.getConnectionState(namespace);
+        state.connected = connected;
+        state.reconnecting = reconnecting;
+        if (connected) {
+            state.lastConnectTime = Date.now();
+            state.reconnectAttempts = 0;
+        }
+        this.connectionState.set(namespace, state);
+    }
+    /**
+     * Увеличивает счетчик попыток переподключения для пространства имен
+     * @param {WebSocketNamespace} namespace Пространство имен
+     * @returns {number} Новое количество попыток
+     */
+    incrementReconnectAttempts(namespace) {
+        const state = this.getConnectionState(namespace);
+        state.reconnectAttempts++;
+        state.reconnecting = true;
+        this.connectionState.set(namespace, state);
+        return state.reconnectAttempts;
+    }
+    /**
+     * Получает состояние подключения для пространства имен
+     * @param {WebSocketNamespace} namespace Пространство имен
+     * @returns {object} Состояние подключения
+     */
+    getConnectionState(namespace) {
+        return this.connectionState.get(namespace) || {
+            lastConnectTime: 0,
+            reconnectAttempts: 0,
+            connected: false,
+            reconnecting: false
+        };
+    }
+    /**
+     * Устанавливает ID активной сессии рассуждения
+     * @param {string} reasoningId ID сессии рассуждения
+     * @returns {boolean} Успешность установки
+     */
+    setActiveReasoningId(reasoningId) {
+        if (!reasoningId) {
+            this.logger('error', 'Попытка установить пустой reasoningId');
+            return false;
+        }
+        this.activeReasoningId = reasoningId;
+        this.logger('info', `Установлен активный reasoningId: ${reasoningId}`);
+        // Если мы уже подключены к пространству имен рассуждений, проверяем, нужно ли присоединиться
+        const client = this.clients.get(WebSocketNamespace.REASONING);
+        if (client && client.isConnected()) {
+            // Пробуем присоединиться к рассуждению асинхронно, но не ждем результата
+            this.logger('debug', `Автоматическое присоединение к рассуждению: ${reasoningId}`);
+            client.emitWithAck(WsEvents.JOIN_REASONING, {
+                reasoningId,
+                token: this.options.apiKey
+            }, 10000).catch(err => {
+                this.logger('warn', `Не удалось автоматически присоединиться к рассуждению: ${err.message}`);
+            });
+        }
+        return true;
+    }
+    /**
+     * Устанавливает ID активного проекта
+     * @param {string} projectId ID проекта
+     * @returns {boolean} Успешность установки
+     */
+    setActiveProjectId(projectId) {
+        if (!projectId) {
+            this.logger('error', 'Попытка установить пустой projectId');
+            return false;
+        }
+        this.activeProjectId = projectId;
+        this.logger('info', `Установлен активный projectId: ${projectId}`);
+        return true;
+    }
+    /**
+     * Устанавливает ID активной сессии рассуждения с расширенными возможностями
+     * @param {string} reasoningId ID сессии рассуждения
+     * @param {boolean} waitForJoin Дождаться результата присоединения
+     * @param {boolean} createIfNotExists Создать новое рассуждение, если ID не существует
+     * @returns {Promise<boolean>} Результат операции
+     */
+    async setActiveReasoningIdAsync(reasoningId, waitForJoin = false, createIfNotExists = false) {
+        if (!reasoningId && !createIfNotExists) {
+            this.logger('error', 'Попытка установить пустой reasoningId');
+            return false;
+        }
+        // Если указан createIfNotExists и нет reasoningId, создаем новое рассуждение
+        if (createIfNotExists && !reasoningId) {
+            try {
+                reasoningId = await this.createNewReasoning();
+                this.logger('info', `Создано новое рассуждение с ID: ${reasoningId}`);
+            }
+            catch (error) {
+                this.logger('error', 'Не удалось создать новое рассуждение', error);
+                return false;
+            }
+        }
+        // Отключаемся от предыдущего рассуждения, если оно отличается
+        if (this.activeReasoningId && this.activeReasoningId !== reasoningId) {
+            this.logger('debug', `Отписываемся от предыдущего рассуждения: ${this.activeReasoningId}`);
+            this.unsubscribeFromThinking(this.activeReasoningId);
+        }
+        this.activeReasoningId = reasoningId;
+        this.logger('info', `Установлен активный reasoningId: ${reasoningId}`);
+        // Если соединение уже установлено, присоединяемся к рассуждению
+        const client = this.clients.get(WebSocketNamespace.REASONING);
+        if (client && client.isConnected()) {
+            try {
+                if (waitForJoin) {
+                    this.logger('debug', `Ожидание присоединения к рассуждению: ${reasoningId}`);
+                    const joinResult = await client.emitWithAck(WsEvents.JOIN_REASONING, {
+                        reasoningId,
+                        token: this.options.apiKey
+                    }, 10000);
+                    if (joinResult.success === true) {
+                        this.logger('info', `Успешно присоединились к рассуждению: ${reasoningId}`);
+                        return true;
+                    }
+                    else {
+                        this.logger('warn', `Не удалось присоединиться к рассуждению: ${reasoningId}`, joinResult.error);
+                        return false;
+                    }
+                }
+                else {
+                    // Асинхронное присоединение
+                    this.logger('debug', `Асинхронное присоединение к рассуждению: ${reasoningId}`);
+                    client.emitWithAck(WsEvents.JOIN_REASONING, {
+                        reasoningId,
+                        token: this.options.apiKey
+                    }, 10000).then(result => {
+                        if (result.success === true) {
+                            this.logger('info', `Успешно присоединились к рассуждению: ${reasoningId}`);
+                        }
+                        else {
+                            this.logger('warn', `Не удалось присоединиться к рассуждению: ${reasoningId}`, result.error);
+                        }
+                    }).catch(err => {
+                        this.logger('warn', `Ошибка при присоединении к рассуждению: ${reasoningId}`, err);
+                    });
+                }
+            }
+            catch (error) {
+                this.logger('error', `Ошибка при присоединении к рассуждению: ${reasoningId}`, error);
+                if (waitForJoin)
+                    return false;
+            }
+        }
+        else if (waitForJoin) {
+            // Если ждем присоединения, но соединение отсутствует
+            this.logger('warn', `Нет активного соединения с сервером для присоединения к рассуждению: ${reasoningId}`);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Создает новое рассуждение на сервере
+     * @private
+     * @returns {Promise<string>} ID нового рассуждения
+     */
+    async createNewReasoning() {
+        // Подключаемся, если еще не подключены
+        if (!this.isConnectedToReasoning()) {
+            this.logger('debug', 'Подключение к пространству имен рассуждений для создания нового рассуждения');
+            const connected = await this.connectToReasoning();
+            if (!connected) {
+                throw new Error('Не удалось подключиться к пространству имен рассуждений');
+            }
+        }
+        const client = this.clients.get(WebSocketNamespace.REASONING);
+        if (!client) {
+            throw new Error('Не удалось получить клиент для пространства имен рассуждений');
+        }
+        this.logger('debug', 'Отправка запроса на создание нового рассуждения');
+        const result = await client.emitWithAck(WsEvents.CREATE_REASONING, {
+            token: this.options.apiKey
+        }, 10000);
+        if (!result.reasoningId) {
+            throw new Error(`Сервер не вернул ID рассуждения: ${JSON.stringify(result)}`);
+        }
+        return result.reasoningId;
+    }
+    /**
+     * Проверяет существование рассуждения на сервере
+     * @param {string} reasoningId ID рассуждения для проверки
+     * @returns {Promise<boolean>} Существует ли рассуждение
+     */
+    async checkReasoningExists(reasoningId) {
+        if (!reasoningId) {
+            return false;
+        }
+        // Подключаемся, если еще не подключены
+        if (!this.isConnectedToReasoning()) {
+            const connected = await this.connectToReasoning();
+            if (!connected) {
+                this.logger('warn', 'Не удалось подключиться к пространству имен рассуждений для проверки существования');
+                return false;
+            }
+        }
+        const client = this.clients.get(WebSocketNamespace.REASONING);
+        if (!client) {
+            this.logger('warn', 'Не удалось получить клиент для пространства имен рассуждений');
+            return false;
+        }
+        try {
+            this.logger('debug', `Проверка существования рассуждения: ${reasoningId}`);
+            // Используем более правильный подход для проверки существования сессии
+            // Пытаемся присоединиться, и если успешно - значит сессия существует
+            const result = await client.emitWithAck(WsEvents.JOIN_REASONING, {
+                reasoningId,
+                token: this.options.apiKey
+            }, 10000);
+            return result.success === true;
+        }
+        catch (error) {
+            this.logger('warn', `Ошибка при проверке существования рассуждения: ${reasoningId}`, error);
+            return false;
+        }
+    }
+    /**
+     * Подключается к пространству имен рассуждений
+     * @param reasoningId ID рассуждения (опционально)
+     * @param options Дополнительные настройки подключения
+     * @returns Promise с результатом подключения
+     */
+    async connectToReasoning(reasoningId, options = {}) {
+        try {
+            // Значения опций по умолчанию
+            const { autoJoin = true, createIfNotExists = false, checkExistence = false, saveSession = this.options.enableSessionPersistence !== false } = options;
+            this.logger('info', 'Подключение к пространству имен рассуждений', {
+                reasoningId,
+                options: { autoJoin, createIfNotExists, checkExistence, saveSession }
+            });
+            // Если указан ID рассуждения, обрабатываем его
+            if (reasoningId) {
+                // Если нужно проверить существование
+                if (checkExistence) {
+                    const client = this.clients.get(WebSocketNamespace.REASONING);
+                    // Если уже подключены, проверяем существование
+                    if (client && client.isConnected()) {
+                        const exists = await this.checkReasoningExists(reasoningId);
+                        if (!exists) {
+                            if (createIfNotExists) {
+                                this.logger('info', `Рассуждение ${reasoningId} не существует, создаем новое`);
+                                reasoningId = await this.createNewReasoning();
+                            }
+                            else {
+                                this.logger('warn', `Рассуждение ${reasoningId} не существует`);
+                                return false;
+                            }
+                        }
+                    }
+                }
+                // Устанавливаем ID активного рассуждения
+                this.activeReasoningId = reasoningId;
+            }
+            else if (createIfNotExists) {
+                // Если нет ID, но нужно создать, создаем новое рассуждение
+                this.logger('info', 'Создание нового рассуждения');
+                try {
+                    // Сначала подключаемся к пространству имен
+                    const client = await this.connect(WebSocketNamespace.REASONING);
+                    // Затем создаем новое рассуждение
+                    const newReasoningId = await this.createNewReasoning();
+                    this.activeReasoningId = newReasoningId;
+                    this.logger('info', `Создано новое рассуждение: ${newReasoningId}`);
+                }
+                catch (error) {
+                    this.logger('error', 'Ошибка при создании нового рассуждения', error);
+                    return false;
+                }
+            }
+            // Подключаемся к пространству имен рассуждений
+            const client = await this.connect(WebSocketNamespace.REASONING);
+            // Аутентифицируемся с увеличенным таймаутом
+            try {
+                const authResult = await client.emitWithAck(WsEvents.AUTHENTICATE, {
+                    token: this.options.apiKey,
+                    reasoningId: this.activeReasoningId
+                }, 10000);
+                this.logger('debug', 'Результат аутентификации в namespace рассуждений', authResult);
+                // Если сервер вернул токен сессии и нужно его сохранить
+                if (saveSession && authResult.sessionToken) {
+                    this.saveSessionToken(WebSocketNamespace.REASONING, authResult.sessionToken);
+                }
+            }
+            catch (error) {
+                this.logger('error', 'Ошибка аутентификации в namespace рассуждений', error);
+                return false;
+            }
+            // Если у нас есть ID рассуждения и включено автоматическое присоединение
+            if (this.activeReasoningId && autoJoin) {
+                try {
+                    const joinResult = await client.emitWithAck(WsEvents.JOIN_REASONING, {
+                        reasoningId: this.activeReasoningId,
+                        token: this.options.apiKey
+                    }, 10000);
+                    this.logger('debug', 'Результат присоединения к рассуждению', joinResult);
+                    if (joinResult.success !== true) {
+                        this.logger('warn', `Не удалось присоединиться к рассуждению: ${this.activeReasoningId}`, joinResult.error);
+                        return false;
+                    }
+                }
+                catch (error) {
+                    this.logger('error', 'Ошибка присоединения к рассуждению', error);
+                    return false;
+                }
+            }
+            // Включаем автоматический ping/pong, если настроено
+            if (this.options.enableAutoPing !== false) {
+                this.enablePingPong(this.options.pingInterval, this.options.pingTimeoutThreshold);
+            }
+            return true;
+        }
+        catch (error) {
+            this.logger('error', 'Ошибка подключения к пространству имен рассуждений', error);
+            return false;
+        }
+    }
+    /**
+     * Получает текущий статус сессии рассуждения
+     * @param {string} reasoningId ID сессии рассуждения (опционально, по умолчанию активная)
+     * @returns {Promise<{exists: boolean, isActive: boolean, metadata?: any}>} Статус сессии
+     */
+    async getReasoningStatus(reasoningId) {
+        const targetId = reasoningId || this.activeReasoningId;
+        if (!targetId) {
+            return { exists: false, isActive: false };
+        }
+        if (!this.isConnectedToReasoning()) {
+            const connected = await this.connectToReasoning(undefined, { autoJoin: false });
+            if (!connected) {
+                this.logger('warn', 'Не удалось подключиться к пространству имен рассуждений');
+                return { exists: false, isActive: false };
+            }
+        }
+        const client = this.clients.get(WebSocketNamespace.REASONING);
+        if (!client) {
+            return { exists: false, isActive: false };
+        }
+        try {
+            // Используем событие GET_REASONING_STATUS для получения статуса
+            // Если сервер не поддерживает это событие, используем более простую проверку
+            try {
+                const status = await client.emitWithAck('get_reasoning_status', {
+                    reasoningId: targetId,
+                    token: this.options.apiKey
+                }, 10000);
+                return {
+                    exists: status.exists === true,
+                    isActive: status.isActive === true,
+                    metadata: status.metadata || {}
+                };
+            }
+            catch (e) {
+                // Если произошла ошибка (скорее всего, сервер не поддерживает этот метод),
+                // используем проверку через JOIN_REASONING
+                const result = await client.emitWithAck(WsEvents.JOIN_REASONING, {
+                    reasoningId: targetId,
+                    token: this.options.apiKey
+                }, 10000);
+                return {
+                    exists: result.success === true,
+                    isActive: result.success === true,
+                    metadata: result.data
+                };
+            }
+        }
+        catch (error) {
+            this.logger('warn', `Ошибка при получении статуса рассуждения: ${targetId}`, error);
+            return { exists: false, isActive: false };
+        }
+    }
+    /**
+     * Присоединяется к сессии рассуждения
+     * @param {string} reasoningId ID сессии рассуждения
+     * @param {boolean} setActive Установить как активное рассуждение
+     * @returns {Promise<boolean>} Результат операции
+     */
+    async joinReasoning(reasoningId, setActive = true) {
+        if (!reasoningId) {
+            this.logger('error', 'Попытка присоединиться к пустому reasoningId');
+            return false;
+        }
+        // Если нужно установить как активное, делаем это
+        if (setActive) {
+            this.activeReasoningId = reasoningId;
+        }
+        // Если не подключены, подключаемся сначала
+        if (!this.isConnectedToReasoning()) {
+            const connected = await this.connectToReasoning(reasoningId);
+            if (!connected) {
+                this.logger('warn', `Не удалось подключиться к пространству имен рассуждений для ${reasoningId}`);
+                return false;
+            }
+            return true; // connectToReasoning уже выполнил join
+        }
+        // Если уже подключены, отправляем join запрос
+        const client = this.clients.get(WebSocketNamespace.REASONING);
+        if (!client) {
+            this.logger('warn', 'Не удалось получить клиент для пространства имен рассуждений');
+            return false;
+        }
+        try {
+            const joinResult = await client.emitWithAck(WsEvents.JOIN_REASONING, {
+                reasoningId,
+                token: this.options.apiKey
+            }, 10000);
+            this.logger('debug', `Результат присоединения к рассуждению ${reasoningId}`, joinResult);
+            return joinResult.success === true;
+        }
+        catch (error) {
+            this.logger('error', `Ошибка при присоединении к рассуждению ${reasoningId}`, error);
+            return false;
+        }
+    }
+    /**
+     * Подключается к пространству имен рассуждений с расширенными опциями
+     * @param reasoningId ID рассуждения (опционально)
+     * @param options Дополнительные настройки подключения
+     * @returns Promise с результатом подключения
+     */
+    async connectToReasoningEx(reasoningId, options = {}) {
+        try {
+            // Значения опций по умолчанию
+            const { autoJoin = true, createIfNotExists = false, checkExistence = false, saveSession = this.options.enableSessionPersistence !== false } = options;
+            this.logger('info', 'Подключение к пространству имен рассуждений', {
+                reasoningId,
+                options: { autoJoin, createIfNotExists, checkExistence, saveSession }
+            });
+            // Если указан ID рассуждения, обрабатываем его
+            if (reasoningId) {
+                // Если нужно проверить существование
+                if (checkExistence) {
+                    const client = this.clients.get(WebSocketNamespace.REASONING);
+                    // Если уже подключены, проверяем существование
+                    if (client && client.isConnected()) {
+                        const exists = await this.checkReasoningExists(reasoningId);
+                        if (!exists) {
+                            if (createIfNotExists) {
+                                this.logger('info', `Рассуждение ${reasoningId} не существует, создаем новое`);
+                                reasoningId = await this.createNewReasoning();
+                            }
+                            else {
+                                this.logger('warn', `Рассуждение ${reasoningId} не существует`);
+                                return false;
+                            }
+                        }
+                    }
+                }
+                // Устанавливаем ID активного рассуждения
+                this.activeReasoningId = reasoningId;
+            }
+            else if (createIfNotExists) {
+                // Если нет ID, но нужно создать, создаем новое рассуждение
+                this.logger('info', 'Создание нового рассуждения');
+                try {
+                    // Сначала подключаемся к пространству имен
+                    const client = await this.connect(WebSocketNamespace.REASONING);
+                    // Затем создаем новое рассуждение
+                    const newReasoningId = await this.createNewReasoning();
+                    this.activeReasoningId = newReasoningId;
+                    this.logger('info', `Создано новое рассуждение: ${newReasoningId}`);
+                }
+                catch (error) {
+                    this.logger('error', 'Ошибка при создании нового рассуждения', error);
+                    return false;
+                }
+            }
+            // Подключаемся к пространству имен рассуждений
+            const client = await this.connect(WebSocketNamespace.REASONING);
+            // Аутентифицируемся с увеличенным таймаутом
+            try {
+                const authResult = await client.emitWithAck(WsEvents.AUTHENTICATE, {
+                    token: this.options.apiKey,
+                    reasoningId: this.activeReasoningId
+                }, 10000);
+                this.logger('debug', 'Результат аутентификации в namespace рассуждений', authResult);
+                // Если сервер вернул токен сессии и нужно его сохранить
+                if (saveSession && authResult.sessionToken) {
+                    this.saveSessionToken(WebSocketNamespace.REASONING, authResult.sessionToken);
+                }
+            }
+            catch (error) {
+                this.logger('error', 'Ошибка аутентификации в namespace рассуждений', error);
+                return false;
+            }
+            // Если у нас есть ID рассуждения и включено автоматическое присоединение
+            if (this.activeReasoningId && autoJoin) {
+                try {
+                    const joinResult = await client.emitWithAck(WsEvents.JOIN_REASONING, {
+                        reasoningId: this.activeReasoningId,
+                        token: this.options.apiKey
+                    }, 10000);
+                    this.logger('debug', 'Результат присоединения к рассуждению', joinResult);
+                    if (joinResult.success !== true) {
+                        this.logger('warn', `Не удалось присоединиться к рассуждению: ${this.activeReasoningId}`, joinResult.error);
+                        return false;
+                    }
+                }
+                catch (error) {
+                    this.logger('error', 'Ошибка присоединения к рассуждению', error);
+                    return false;
+                }
+            }
+            // Включаем автоматический ping/pong, если настроено
+            if (this.options.enableAutoPing !== false) {
+                this.enablePingPong(this.options.pingInterval, this.options.pingTimeoutThreshold);
+            }
+            return true;
+        }
+        catch (error) {
+            this.logger('error', 'Ошибка подключения к пространству имен рассуждений', error);
+            return false;
+        }
+    }
 }
 //# sourceMappingURL=code-solver-websocket-client.js.map