solver-sdk 1.6.9 → 1.7.0

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

@@ -46,6 +46,12 @@ export class CodeSolverWebSocketClient {
         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,
@@ -188,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 проекта (опционально)
@@ -934,5 +892,738 @@ export class CodeSolverWebSocketClient {
             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