solver-sdk 1.6.3 → 1.6.5

package/dist/cjs/utils/websocket-client.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebSocketClient = void 0;
+// Импортируем Socket.IO клиент
+const socket_io_client_1 = require("socket.io-client");
 /**
- * Базовый класс для WebSocket клиентов
+ * Базовый класс для WebSocket клиентов, реализованный на базе Socket.IO
  */
 class WebSocketClient {
     /**
@@ -11,8 +13,8 @@ class WebSocketClient {
      * @param {WebSocketClientOptions} [options] Опции клиента
      */
     constructor(url, options = {}) {
-        /** Экземпляр WebSocket */
-        this.webSocket = null;
+        /** Экземпляр Socket.IO */
+        this.socket = null;
         /** Счетчик попыток переподключения */
         this.retryCount = 0;
         /** Флаг, указывающий, что соединение было закрыто намеренно */
@@ -33,6 +35,11 @@ class WebSocketClient {
         this.socketId = null;
         /** Хранилище ожидающих callback-функций */
         this._pendingCallbacks = new Map();
+        /**
+         * Тип для хранения отложенных обработчиков событий
+         * @private
+         */
+        this._pendingCallbackHandlers = new Map();
         this.url = url;
         this.options = {
             headers: options.headers || {},
@@ -82,12 +89,12 @@ class WebSocketClient {
         });
     }
     /**
-     * Подключается к WebSocket серверу
+     * Подключается к WebSocket серверу используя Socket.IO клиент
      * @returns {Promise<void>}
      */
     connect() {
         // Если соединение уже установлено, возвращаем Promise.resolve
-        if (this.webSocket && this.webSocket.readyState === WebSocket.OPEN) {
+        if (this.socket && this.socket.connected) {
             this.logger('info', 'Соединение уже установлено');
             return Promise.resolve();
         }
@@ -95,366 +102,216 @@ class WebSocketClient {
         this.intentionallyClosed = false;
         return new Promise((resolve, reject) => {
             try {
-                // Проверяем, содержит ли URL параметры Socket.IO
+                // Формируем корректный URL с namespace для Socket.IO
                 let wsUrl = this.url;
-                // Проверяем, является ли это Socket.IO подключением
-                if (wsUrl.includes('/socket.io/') || wsUrl.includes('?EIO=')) {
-                    // Убедимся, что в URL есть параметры для Socket.IO версии 4
-                    if (!wsUrl.includes('EIO=')) {
-                        // Добавляем разделитель: ? или &
-                        const separator = wsUrl.includes('?') ? '&' : '?';
-                        wsUrl += `${separator}EIO=4&transport=websocket`;
-                    }
-                    // Добавляем timestamp для предотвращения кеширования
-                    if (!wsUrl.includes('t=')) {
-                        const separator = wsUrl.includes('?') ? '&' : '?';
-                        wsUrl += `${separator}t=${Date.now()}`;
-                    }
-                }
-                this.logger('info', 'Выполняется подключение', { url: wsUrl });
-                // Создаем новый экземпляр WebSocket
-                if (this.isBrowser) {
-                    // Браузерное окружение
-                    this.webSocket = new WebSocket(wsUrl, this.options.protocols);
-                }
-                else {
-                    // Node.js окружение
-                    try {
-                        // Динамически импортируем ws модуль в Node.js
-                        const WebSocketImpl = require('ws');
-                        this.webSocket = new WebSocketImpl(wsUrl, {
-                            headers: this.options.headers,
-                            protocol: this.options.protocols,
-                            rejectUnauthorized: process.env.NODE_TLS_REJECT_UNAUTHORIZED === "0" ? false : (this.options.rejectUnauthorized === false ? false : true)
-                        });
-                    }
-                    catch (error) {
-                        const errorMsg = `Не удалось загрузить модуль ws в Node.js: ${error.message}`;
-                        this.logger('error', errorMsg);
-                        reject(new Error(errorMsg));
-                        return;
-                    }
+                let namespaceStr = this.namespace;
+                // Для Socket.IO не нужно добавлять параметры в URL, они будут добавлены библиотекой
+                this.logger('info', 'Выполняется подключение', { url: wsUrl, namespace: namespaceStr });
+                // Настройки для Socket.IO клиента
+                const socketOptions = {
+                    transports: ['websocket'], // Используем только WebSocket транспорт
+                    reconnection: this.options.autoReconnect, // Автоматическое переподключение
+                    reconnectionAttempts: this.options.maxRetries, // Количество попыток
+                    reconnectionDelay: this.options.retryDelay, // Задержка между попытками
+                    timeout: this.options.connectionTimeout, // Таймаут соединения
+                    forceNew: true, // Создавать новое соединение
+                    extraHeaders: this.options.headers, // HTTP заголовки
+                    rejectUnauthorized: this.options.rejectUnauthorized // Проверка сертификатов
+                };
+                // Если указан API ключ, добавляем его в query и auth
+                if (this.options.apiKey) {
+                    socketOptions.auth = { token: this.options.apiKey };
+                    socketOptions.query = { token: this.options.apiKey };
                 }
+                // Создаем Socket.IO клиент с namespace
+                this.socket = (0, socket_io_client_1.io)(wsUrl + namespaceStr, socketOptions);
                 // Устанавливаем таймаут соединения
                 this.connectionTimeoutTimer = setTimeout(() => {
-                    if (this.webSocket && this.webSocket.readyState !== WebSocket.OPEN) {
-                        reject(new Error('Таймаут подключения WebSocket'));
+                    if (this.socket && !this.socket.connected) {
+                        const error = new Error('Таймаут подключения WebSocket');
+                        this.logger('error', 'Превышен таймаут подключения', { timeout: this.options.connectionTimeout });
+                        reject(error);
                         this.close();
                     }
                 }, this.options.connectionTimeout);
-                // Обработчик открытия соединения
-                this.webSocket.onopen = () => {
+                // Обработчик успешного подключения
+                this.socket.on('connect', () => {
                     clearTimeout(this.connectionTimeoutTimer);
                     this.retryCount = 0;
                     this.connected = true;
-                    this.logger('info', 'WebSocket соединение установлено');
+                    this.socketId = this.socket?.id || null;
+                    this.logger('info', 'WebSocket соединение установлено', { socketId: this.socketId });
                     // Отправляем сообщения из очереди
                     while (this.messageQueue.length > 0) {
                         const message = this.messageQueue.shift();
-                        if (message && this.webSocket && this.webSocket.readyState === WebSocket.OPEN) {
-                            this.webSocket.send(message);
-                        }
-                    }
-                    // Запускаем таймер для ping в Socket.IO
-                    this.setupPingPongTimer();
-                    resolve();
-                    this.dispatchEvent('open', {});
-                };
-                // Обработчик сообщений
-                this.webSocket.onmessage = (event) => {
-                    try {
-                        // Пытаемся распарсить сообщение как JSON
-                        let data = event.data;
-                        // Обработка сообщений Socket.IO
-                        if (typeof data === 'string') {
-                            // Обработка Engine.IO - Ping/Pong (2/3)
-                            if (data === '2') {
-                                // Engine.IO ping, отправляем понг
-                                if (this.webSocket && this.webSocket.readyState === WebSocket.OPEN) {
-                                    this.webSocket.send('3');
-                                }
-                                this.dispatchEvent('ping', {});
-                                return;
-                            }
-                            else if (data === '3') {
-                                // Engine.IO pong
-                                this.dispatchEvent('pong', {});
-                                return;
-                            }
-                            // Обработка открытия соединения Socket.IO
-                            if (data.startsWith('0')) {
-                                try {
-                                    const authData = JSON.parse(data.substring(1));
-                                    this.dispatchEvent('socket.io_open', authData);
-                                    // Вызываем обработчик открытия соединения Socket.IO
-                                    this.handleSocketIOOpen(authData);
-                                    return;
-                                }
-                                catch (e) {
-                                    // Игнорируем ошибки парсинга
-                                }
-                            }
-                            // Обработка Socket.IO событий (42)
-                            if (data.startsWith('42')) {
-                                // Формат: 42/namespace,[event,data]
-                                let namespace = '';
-                                let eventData = data.substring(2);
-                                // Извлекаем namespace, если есть
-                                if (eventData.startsWith('/')) {
-                                    const namespaceEnd = eventData.indexOf(',');
-                                    if (namespaceEnd !== -1) {
-                                        namespace = eventData.substring(0, namespaceEnd);
-                                        eventData = eventData.substring(namespaceEnd + 1);
-                                    }
-                                }
-                                try {
-                                    const parsedData = JSON.parse(eventData);
-                                    if (Array.isArray(parsedData) && parsedData.length >= 1) {
-                                        const event = parsedData[0];
-                                        const eventPayload = parsedData.length > 1 ? parsedData[1] : null;
-                                        // Запускаем обработчик для данного события
-                                        this.dispatchEvent(event, eventPayload);
-                                        // Также отправляем общее событие socket.io с информацией о полученном событии
-                                        this.dispatchEvent('socket.io_event', {
-                                            event,
-                                            data: eventPayload,
-                                            namespace
-                                        });
-                                        // Обработка специальных событий для стриминга
-                                        if (event === 'text_delta' && eventPayload?.delta?.text) {
-                                            this.dispatchEvent('streaming_delta', { type: 'text', content: eventPayload.delta.text });
-                                        }
-                                        else if (event === 'thinking_delta' && eventPayload?.delta?.thinking) {
-                                            this.dispatchEvent('streaming_delta', { type: 'thinking', content: eventPayload.delta.thinking });
-                                        }
-                                        else if (event === 'message_stop') {
-                                            this.dispatchEvent('streaming_complete', {});
-                                        }
-                                    }
-                                }
-                                catch (e) {
-                                    this.dispatchEvent('error', { message: `Ошибка парсинга Socket.IO данных: ${e instanceof Error ? e.message : 'Неизвестная ошибка'}` });
-                                }
-                                return;
-                            }
-                            // Определяем тип пакета Socket.IO по первому символу
-                            const packetType = data.charAt(0);
-                            // Если это пакет данных (тип 0-6)
-                            if (packetType >= '0' && packetType <= '6') {
-                                // Отправляем особое событие для Socket.IO пакетов
-                                this.dispatchEvent('socket.io_raw', {
-                                    type: packetType,
-                                    data: data.substring(1)
-                                });
-                                // Пытаемся обработать содержимое
-                                if (data.length > 1) {
-                                    try {
-                                        // Обработка пакета с namespace
-                                        let jsonStart = 1;
-                                        let namespace = '';
-                                        // Если есть namespace, извлекаем его
-                                        if (data.charAt(1) === '/') {
-                                            const namespaceEnd = data.indexOf('{', 1);
-                                            if (namespaceEnd !== -1) {
-                                                namespace = data.substring(1, namespaceEnd);
-                                                jsonStart = namespaceEnd;
-                                            }
-                                        }
-                                        // Пытаемся преобразовать оставшуюся часть в JSON
-                                        const jsonStr = data.substring(jsonStart);
-                                        if (jsonStr) {
-                                            try {
-                                                const parsedData = JSON.parse(jsonStr);
-                                                this.dispatchEvent('message', parsedData);
-                                            }
-                                            catch (e) {
-                                                // Если не можем преобразовать в JSON, отправляем как есть
-                                                this.dispatchEvent('message', jsonStr);
-                                            }
-                                        }
-                                    }
-                                    catch (e) {
-                                        // Игнорируем ошибки парсинга
-                                    }
-                                }
+                        if (message && this.socket && this.socket.connected) {
+                            if (typeof message === 'object' && message.event) {
+                                this.socket.emit(message.event, message.data);
                             }
                             else {
-                                // Если это не Socket.IO пакет, пытаемся обработать как обычное сообщение
-                                try {
-                                    const parsedData = JSON.parse(data);
-                                    this.dispatchEvent('message', parsedData);
-                                }
-                                catch (e) {
-                                    // Если не можем преобразовать в JSON, отправляем как есть
-                                    this.dispatchEvent('message', data);
-                                }
+                                // Поддержка старого формата сообщений
+                                this.socket.send(message);
                             }
                         }
-                        else {
-                            // Если данные не строка (например, ArrayBuffer), отправляем как есть
-                            this.dispatchEvent('message', data);
-                        }
                     }
-                    catch (e) {
-                        console.error('Ошибка при обработке сообщения WebSocket:', e);
-                        this.dispatchEvent('error', { message: `Ошибка при обработке сообщения: ${e instanceof Error ? e.message : 'Неизвестная ошибка'}` });
+                    resolve();
+                    this.dispatchEvent('open', {});
+                });
+                // Обработчик ошибок соединения
+                this.socket.on('connect_error', (error) => {
+                    clearTimeout(this.connectionTimeoutTimer);
+                    this.logger('error', 'Ошибка соединения WebSocket', {
+                        message: error.message,
+                        name: error.name,
+                        stack: error.stack
+                    });
+                    this.dispatchEvent('error', error);
+                    if (!this.connected) {
+                        reject(new Error('Ошибка подключения WebSocket'));
                     }
-                };
+                });
                 // Обработчик закрытия соединения
-                this.webSocket.onclose = (event) => {
+                this.socket.on('disconnect', (reason) => {
                     clearTimeout(this.connectionTimeoutTimer);
                     this.connected = false;
-                    this.dispatchEvent('close', { code: event.code, reason: event.reason });
+                    this.logger('info', `WebSocket соединение закрыто: ${reason}`);
+                    // Формируем объект события для совместимости с WebSocket API
+                    const closeEvent = {
+                        code: this.getCloseCodeFromReason(reason),
+                        reason: reason
+                    };
+                    this.dispatchEvent('close', closeEvent);
                     // Если соединение было закрыто намеренно, не пытаемся переподключиться
                     if (this.intentionallyClosed) {
                         return;
                     }
-                    // Если включено автоматическое переподключение, пытаемся переподключиться
-                    if (this.options.autoReconnect) {
-                        this.reconnect();
-                    }
-                };
-                // Обработчик ошибок
-                this.webSocket.onerror = (error) => {
-                    this.dispatchEvent('error', error);
-                    // Если соединение не установлено и это первая попытка, отклоняем Promise
-                    if (!this.connected && this.retryCount === 0) {
-                        clearTimeout(this.connectionTimeoutTimer);
-                        reject(new Error('Ошибка подключения WebSocket'));
-                    }
-                };
+                });
+                // Обработчик всех сообщений, используем 'message' для совместимости
+                this.socket.onAny((eventName, ...args) => {
+                    // Отправляем в обработчик события по имени события
+                    this.dispatchEvent(eventName, args.length === 1 ? args[0] : args);
+                    // Также отправляем событие message для совместимости
+                    this.dispatchEvent('message', {
+                        event: eventName,
+                        data: args.length === 1 ? args[0] : args
+                    });
+                });
             }
             catch (error) {
+                clearTimeout(this.connectionTimeoutTimer);
+                this.logger('error', 'Ошибка при создании Socket.IO клиента', error);
                 reject(error);
             }
         });
     }
     /**
-     * Настраивает таймер для ping/pong сообщений Socket.IO
-     */
-    setupPingPongTimer() {
-        // Если URL содержит параметры Socket.IO, настраиваем автоматический ping/pong
-        if (this.url.includes('EIO=4') && this.url.includes('transport=websocket')) {
-            // Типичный интервал ping для Socket.IO - 25 секунд
-            const pingInterval = 25000;
-            // Периодически отправляем ping
-            const pingTimer = setInterval(() => {
-                if (this.webSocket && this.webSocket.readyState === WebSocket.OPEN) {
-                    // Socket.IO ping - это просто строка "2"
-                    this.webSocket.send('2');
-                }
-                else {
-                    // Если соединение закрыто, останавливаем таймер
-                    clearInterval(pingTimer);
-                }
-            }, pingInterval);
-            // Останавливаем таймер при закрытии соединения
-            this.on('close', () => clearInterval(pingTimer));
-        }
-    }
-    /**
-     * Переподключается к WebSocket серверу
+     * Получает код закрытия WebSocket из строки причины Socket.IO
+     * @param {string} reason Причина закрытия Socket.IO
+     * @returns {number} Код закрытия WebSocket
      * @private
      */
-    reconnect() {
-        // Увеличиваем счетчик попыток
-        this.retryCount++;
-        // Если превышено максимальное количество попыток, не пытаемся переподключиться
-        if (this.retryCount > (this.options.maxRetries || 5)) {
-            this.dispatchEvent('maxRetries', { retries: this.retryCount });
-            return;
+    getCloseCodeFromReason(reason) {
+        switch (reason) {
+            case 'io server disconnect':
+                return 1000; // Нормальное закрытие соединения сервером
+            case 'io client disconnect':
+                return 1000; // Нормальное закрытие соединения клиентом
+            case 'ping timeout':
+                return 1001; // Выход из соединения по таймауту
+            case 'transport close':
+                return 1006; // Аномальное закрытие соединения
+            case 'transport error':
+                return 1002; // Протокольная ошибка
+            default:
+                return 1000; // По умолчанию - нормальное закрытие
         }
-        // Вычисляем задержку перед переподключением с экспоненциальным ростом
-        const delay = Math.min((this.options.retryDelay || 1000) * Math.pow(2, this.retryCount - 1), this.options.maxRetryDelay || 30000);
-        // Пытаемся переподключиться после задержки
-        this.reconnectTimer = setTimeout(() => {
-            this.dispatchEvent('reconnect', { attempt: this.retryCount });
-            this.connect().catch(() => { });
-        }, delay);
     }
     /**
-     * Закрывает WebSocket соединение
+     * Закрывает соединение WebSocket
      * @param {number} [code=1000] Код закрытия
-     * @param {string} [reason] Причина закрытия
+     * @param {string} [reason='Closed by client'] Причина закрытия
      */
-    close(code = 1000, reason) {
+    close(code = 1000, reason = 'Closed by client') {
         this.intentionallyClosed = true;
-        // Очищаем таймеры
         clearTimeout(this.reconnectTimer);
         clearTimeout(this.connectionTimeoutTimer);
-        // Очищаем очередь сообщений
-        this.messageQueue = [];
-        // Закрываем соединение
-        if (this.webSocket) {
-            if (this.webSocket.readyState === WebSocket.OPEN) {
-                this.webSocket.close(code, reason);
-            }
-            this.webSocket = null;
+        if (this.socket) {
+            this.logger('info', 'Закрытие WebSocket соединения', { code, reason });
+            // Отключаем Socket.IO клиент
+            this.socket.disconnect();
+            this.socket = null;
         }
         this.connected = false;
     }
     /**
-     * Отправляет сообщение через WebSocket
-     * @param {string | object} message Сообщение для отправки
+     * Отправляет сообщение в WebSocket
+     * @param {any} data Данные для отправки
      * @returns {boolean} Успешно ли отправлено сообщение
      */
-    send(message) {
-        // Если это объект с type='2' (Socket.IO EVENT), обрабатываем как Socket.IO сообщение
-        if (typeof message === 'object' && message.type === '2') {
-            const socketIOMessage = message;
-            let packet;
-            // Формат сообщения для Socket.IO протокола 4
-            if (socketIOMessage.event && socketIOMessage.data) {
-                // Format: 42namespace,[event,data]
-                const namespace = socketIOMessage.nsp ? socketIOMessage.nsp : '';
-                const namespaceStr = namespace && !namespace.startsWith('/') ? '/' + namespace : namespace;
-                const eventData = [socketIOMessage.event];
-                if (socketIOMessage.data !== undefined) {
-                    eventData.push(socketIOMessage.data);
-                }
-                // 4 - Engine.IO message type
-                // 2 - Socket.IO EVENT type
-                packet = `42${namespaceStr}${namespaceStr ? ',' : ''}${JSON.stringify(eventData)}`;
-            }
-            else {
-                // Обратная совместимость со старым форматом
-                packet = `${socketIOMessage.type}${socketIOMessage.nsp ? socketIOMessage.nsp : ''}${JSON.stringify(socketIOMessage.data)}`;
-            }
-            if (this.webSocket && this.webSocket.readyState === WebSocket.OPEN) {
-                this.webSocket.send(packet);
+    send(data) {
+        try {
+            // Если соединение еще не установлено, добавляем сообщение в очередь
+            if (!this.socket || !this.socket.connected) {
+                this.messageQueue.push(data);
                 return true;
             }
-            else {
-                // Если соединение не установлено, добавляем сообщение в очередь
-                this.messageQueue.push(packet);
-                if ((!this.webSocket || this.webSocket.readyState === WebSocket.CLOSED) && !this.intentionallyClosed) {
-                    this.connect().catch(() => { });
+            // Обработка разных типов сообщений для совместимости
+            if (typeof data === 'object') {
+                if (data.event) {
+                    // Формат { event: 'event_name', data: {} }
+                    this.socket.emit(data.event, data.data);
+                }
+                else if (data.type && data.type === '2' && data.data && Array.isArray(data.data)) {
+                    // Socket.IO тип пакета '2' - событие с данными
+                    // Формат { type: '2', nsp: '/namespace', data: ['event_name', {}] }
+                    const eventName = data.data[0];
+                    const eventData = data.data.length > 1 ? data.data[1] : null;
+                    this.socket.emit(eventName, eventData);
+                }
+                else {
+                    // Обычные объекты отправляем через 'message'
+                    this.socket.emit('message', data);
                 }
-                return false;
             }
-        }
-        // Стандартная отправка
-        const data = typeof message === 'string' ? message : JSON.stringify(message);
-        if (this.webSocket && this.webSocket.readyState === WebSocket.OPEN) {
-            this.webSocket.send(data);
+            else {
+                // Строки, бинарные данные и т.д.
+                this.socket.send(data);
+            }
             return true;
         }
-        else {
-            // Если соединение не установлено, добавляем сообщение в очередь
-            this.messageQueue.push(data);
-            // Если соединение не установлено и не закрыто намеренно, пытаемся подключиться
-            if ((!this.webSocket || this.webSocket.readyState === WebSocket.CLOSED) && !this.intentionallyClosed) {
-                this.connect().catch(() => { });
-            }
+        catch (error) {
+            this.logger('error', 'Ошибка при отправке сообщения', error);
             return false;
         }
     }
     /**
-     * Проверяет, установлено ли соединение
-     * @returns {boolean} Установлено ли соединение
+     * Отправляет событие с данными и ожидает ответа с помощью Promise
+     * @param {string} event Название события
+     * @param {any} data Данные события
+     * @param {number} [timeout=5000] Таймаут ожидания ответа в мс
+     * @returns {Promise<any>} Promise с ответом
      */
-    isConnected() {
-        return this.webSocket !== null && this.webSocket.readyState === WebSocket.OPEN;
+    emitWithAck(event, data, timeout = 5000) {
+        return new Promise((resolve, reject) => {
+            if (!this.socket || !this.socket.connected) {
+                reject(new Error('WebSocket не подключен'));
+                return;
+            }
+            try {
+                // Используем встроенный механизм acknowledgements в Socket.IO
+                this.socket.timeout(timeout).emit(event, data, (err, response) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve(response);
+                    }
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
     }
     /**
      * Добавляет обработчик события
@@ -466,6 +323,12 @@ class WebSocketClient {
             this.eventHandlers[eventType] = [];
         }
         this.eventHandlers[eventType].push(handler);
+        // Если соединение уже установлено, добавляем обработчик для Socket.IO
+        if (this.socket && this.socket.connected && eventType !== 'open' && eventType !== 'close') {
+            // Не добавляем обработчики для 'open' и 'close', так как они обрабатываются
+            // через 'connect' и 'disconnect' в методе connect()
+            this.socket.on(eventType, handler);
+        }
     }
     /**
      * Удаляет обработчик события
@@ -476,23 +339,31 @@ class WebSocketClient {
         if (!this.eventHandlers[eventType]) {
             return;
         }
-        if (!handler) {
-            // Если обработчик не указан, удаляем все обработчики для данного события
-            delete this.eventHandlers[eventType];
+        if (handler) {
+            // Удаляем конкретный обработчик
+            const index = this.eventHandlers[eventType].indexOf(handler);
+            if (index !== -1) {
+                this.eventHandlers[eventType].splice(index, 1);
+            }
+            // Также удаляем обработчик из Socket.IO, если соединение установлено
+            if (this.socket && this.socket.connected) {
+                this.socket.off(eventType, handler);
+            }
         }
         else {
-            // Если обработчик указан, удаляем только его
-            this.eventHandlers[eventType] = this.eventHandlers[eventType].filter(h => h !== handler);
-            // Если обработчиков больше нет, удаляем массив
-            if (this.eventHandlers[eventType].length === 0) {
-                delete this.eventHandlers[eventType];
+            // Удаляем все обработчики для данного типа события
+            delete this.eventHandlers[eventType];
+            // Также удаляем все обработчики из Socket.IO, если соединение установлено
+            if (this.socket && this.socket.connected) {
+                this.socket.off(eventType);
             }
         }
     }
     /**
-     * Вызывает обработчики для указанного события
+     * Отправляет событие в обработчики
      * @param {string} eventType Тип события
      * @param {any} data Данные события
+     * @private
      */
     dispatchEvent(eventType, data) {
         if (!this.eventHandlers[eventType]) {
@@ -502,250 +373,54 @@ class WebSocketClient {
             try {
                 handler(data);
             }
-            catch (e) {
-                console.error(`Ошибка в обработчике события ${eventType}:`, e);
-            }
-        }
-    }
-    /**
-     * Обработка полученного сообщения от сервера
-     * @param message Сообщение от сервера
-     */
-    handleMessage(message) {
-        try {
-            if (!message) {
-                this.dispatchEvent('error', { message: 'Получено пустое сообщение' });
-                return;
-            }
-            // Проверяем, является ли сообщение пингом Socket.IO (2)
-            if (message === '2') {
-                // Отправляем понг (3)
-                this.send('3');
-                this.dispatchEvent('debug', 'Получен ping, отправлен pong');
-                return;
-            }
-            // Если это сообщение Socket.IO с данными
-            if (message.startsWith('42')) {
-                // Формат: 42[event,data]
-                const eventDataStr = message.substring(2);
-                try {
-                    const [event, data] = JSON.parse(eventDataStr);
-                    // Проверяем, есть ли это ack-ответ для callback
-                    if (event.endsWith('_ack') || event.endsWith('_response') ||
-                        event.endsWith('_success') || event.endsWith('_error')) {
-                        const baseEvent = event.split('_')[0]; // Получаем базовое имя события
-                        // Проверяем, есть ли у нас отложенный callback для этого события
-                        const callbackEntries = Array.from(this._pendingCallbacks.entries())
-                            .filter(([key]) => key.startsWith(`${baseEvent}_ack_`));
-                        if (callbackEntries.length > 0) {
-                            const [callbackId, callback] = callbackEntries[0];
-                            this._pendingCallbacks.delete(callbackId);
-                            // Вызываем callback с полученными данными
-                            try {
-                                callback(data);
-                            }
-                            catch (callbackError) {
-                                this.logger('error', `Ошибка при вызове callback для ${baseEvent}: ${callbackError instanceof Error ? callbackError.message : String(callbackError)}`);
-                            }
-                            // Не продолжаем обработку, так как это ack-сообщение уже обработано
-                            return;
-                        }
-                    }
-                    // Вызываем соответствующий обработчик события
-                    this.dispatchEvent(event, data);
-                    // Добавляем специальную обработку для событий стриминга
-                    if (event === 'text_delta' && data.delta?.text) {
-                        this.dispatchEvent('streaming_delta', { type: 'text', content: data.delta.text });
-                    }
-                    else if (event === 'thinking_delta' && data.delta?.thinking) {
-                        this.dispatchEvent('streaming_delta', { type: 'thinking', content: data.delta.thinking });
-                    }
-                    else if (event === 'message_stop') {
-                        this.dispatchEvent('streaming_complete', {});
-                    }
-                }
-                catch (error) {
-                    const errorMessage = error instanceof Error ? error.message : 'Неизвестная ошибка';
-                    this.dispatchEvent('error', { message: `Ошибка разбора данных события: ${errorMessage}` });
-                }
-                return;
-            }
-            // Пытаемся преобразовать сообщение в JSON
-            try {
-                const parsedMessage = JSON.parse(message);
-                // Если это объект с типом event и данными, это может быть событие
-                if (parsedMessage.event && parsedMessage.data) {
-                    const { event, data } = parsedMessage;
-                    this.dispatchEvent(event, data);
-                }
-                else {
-                    this.dispatchEvent('message', parsedMessage);
-                }
-            }
             catch (error) {
-                // Если не удалось преобразовать в JSON, обрабатываем как текстовое сообщение
-                this.dispatchEvent('message', message);
+                this.logger('error', `Ошибка в обработчике события '${eventType}'`, error);
             }
         }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Неизвестная ошибка';
-            this.dispatchEvent('error', { message: `Ошибка при обработке сообщения: ${errorMessage}` });
-        }
     }
     /**
-     * Отправляет событие Socket.IO через WebSocket соединение
-     * @param {string} event Имя события
-     * @param {any} data Данные события
-     * @param {(response: any) => void} [callback] Функция обратного вызова для получения ответа
-     * @param {string} [namespace=''] Namespace для Socket.IO
-     * @returns {boolean} Успешно ли отправлено сообщение
+     * Возвращает текущий статус соединения
+     * @returns {boolean} Подключен ли клиент
      */
-    sendSocketIOEvent(event, data, callback, namespace = '') {
-        // Проверяем наличие callback-функции
-        const hasCallback = typeof callback === 'function';
-        this.logger('debug', `Отправка Socket.IO события ${event}`, {
-            hasData: !!data,
-            namespace,
-            hasCallback
-        });
-        // Формируем объект для отправки через метод send в стандартном формате Socket.IO
-        if (hasCallback) {
-            // Socket.IO ожидает callback как последний аргумент emit, поэтому
-            // мы должны отправить особое сообщение, указывающее, что нужно использовать callback
-            // Это важно: не добавляйте callback в data!
-            try {
-                // Для Socket.IO клиента (веб-браузер)
-                if (this.isBrowser && this.webSocket) {
-                    // @ts-ignore - вызываем нативный метод emit у Socket.IO, если он доступен
-                    if (this.webSocket.emit) {
-                        const namespacedEvent = namespace ? `${namespace}#${event}` : event;
-                        // @ts-ignore
-                        return this.webSocket.emit(namespacedEvent, data, callback);
-                    }
-                }
-                // Формат данных для Socket.IO: [event, data, ack] в формате пакета типа 2 (EVENT)
-                const socketIOPacket = {
-                    type: '2', // Socket.IO EVENT
-                    event,
-                    data,
-                    namespace,
-                    useCallback: true // Специальный флаг для внутренней обработки
-                };
-                // Сохраняем callback для последующего использования
-                const callbackId = `${event}_ack_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-                this._pendingCallbacks.set(callbackId, callback);
-                // Устанавливаем таймаут для автоматического удаления callback
-                setTimeout(() => {
-                    if (this._pendingCallbacks.has(callbackId)) {
-                        const cb = this._pendingCallbacks.get(callbackId);
-                        this._pendingCallbacks.delete(callbackId);
-                        if (typeof cb === 'function') {
-                            cb({
-                                success: false,
-                                error: `Таймаут ожидания ответа на событие ${event}`,
-                                timeout: true
-                            });
-                        }
-                    }
-                }, 10000); // 10-секундный таймаут
-                // Отправляем объект с данными и callbackId
-                return this.send({
-                    ...socketIOPacket,
-                    callbackId
-                });
-            }
-            catch (error) {
-                this.logger('error', `Ошибка при отправке Socket.IO события ${event} с callback: ${error instanceof Error ? error.message : String(error)}`);
-                return false;
-            }
-        }
-        else {
-            // Стандартная отправка без callback
-            const socketIOMessage = {
-                type: '2',
-                event,
-                data,
-                nsp: namespace
-            };
-            return this.send(socketIOMessage);
-        }
+    isConnected() {
+        return this.socket !== null && this.socket.connected;
     }
     /**
-     * Обработка подключения к пространству имен Socket.IO
+     * Выполняет принудительное переподключение
+     * @returns {Promise<void>} Promise без результата
      */
-    handleNamespaceConnection() {
-        if (!this.namespace) {
-            return;
-        }
-        // Отправляем запрос на подключение к namespace
-        this.logger('info', `Подключение к пространству имен ${this.namespace}`);
-        const connectMessage = `40${this.namespace}`;
-        if (this.webSocket && this.webSocket.readyState === WebSocket.OPEN) {
-            this.webSocket.send(connectMessage);
-        }
-        else {
-            this.messageQueue.push(connectMessage);
+    async reconnect() {
+        // Если соединение уже установлено, сначала закрываем его
+        if (this.socket && this.socket.connected) {
+            this.close();
         }
+        // Сбрасываем флаг намеренного закрытия для возможности переподключения
+        this.intentionallyClosed = false;
+        // Устанавливаем новое соединение
+        return this.connect();
     }
     /**
-     * Отправка аутентификационного сообщения
+     * Отправляет событие (алиас для более удобного использования)
+     * @param {string} eventName Название события
+     * @param {any} data Данные события
+     * @returns {boolean} Успешно ли отправлено событие
      */
-    authenticate() {
-        if (!this.options.apiKey) {
-            this.logger('warn', 'API ключ не предоставлен, аутентификация пропущена');
-            return;
-        }
-        const apiKeySafe = this.options.apiKey.length > 8
-            ? `${this.options.apiKey.substring(0, 4)}...${this.options.apiKey.substring(this.options.apiKey.length - 4)}`
-            : '[короткий ключ]';
-        this.logger('info', 'Отправка аутентификационного сообщения', {
-            namespace: this.namespace,
-            apiKey: apiKeySafe,
-            authenticated: this.authenticated,
-            socketState: this.webSocket ? this.webSocket.readyState : 'нет соединения'
-        });
-        // Отправляем событие authenticate с API ключом
-        this.sendSocketIOEvent('authenticate', { apiKey: this.options.apiKey }, undefined, this.namespace);
+    emit(eventName, data) {
+        return this.send({ event: eventName, data });
     }
     /**
-     * Обработка открытия соединения Socket.IO
-     * @param data Данные открытия соединения
+     * Возвращает ID сокета, если соединение установлено
+     * @returns {string|null} ID сокета или null, если соединение не установлено
      */
-    handleSocketIOOpen(data) {
-        this.logger('info', 'Socket.IO соединение открыто', {
-            pingInterval: data.pingInterval,
-            pingTimeout: data.pingTimeout,
-            sid: data.sid
-        });
-        // Если указано пространство имен, подключаемся к нему
-        if (this.namespace) {
-            this.handleNamespaceConnection();
-        }
-        // Добавляем обработчик успешного подключения к пространству имен
-        this.on('socket.io_event', (eventData) => {
-            // Если это событие connect и мы еще не аутентифицированы
-            if (!this.authenticated && eventData.event === 'connect') {
-                this.logger('info', `Подключено к пространству имен ${eventData.namespace || '/'}`, {
-                    namespace: eventData.namespace || '/',
-                    event: eventData.event,
-                    data: eventData.data
-                });
-                // Аутентифицируем соединение
-                this.authenticate();
-                this.authenticated = true;
-            }
-        });
-        // Сохраняем ID сокета, если он пришел
-        if (data && data.sid) {
-            this.socketId = data.sid;
-        }
+    getSocketId() {
+        return this.socket?.id || null;
     }
     /**
-     * Получает ID текущего сокета
-     * @returns {string|null} ID сокета или null, если соединение не установлено
+     * Устанавливает функцию логирования
+     * @param {Function} loggerFn Функция для логирования
      */
-    getSocketId() {
-        return this.socketId;
+    setLogger(loggerFn) {
+        this.logger = loggerFn;
     }
     /**
      * Регистрирует обработчик события, который будет вызван один раз и удален
@@ -754,6 +429,11 @@ class WebSocketClient {
      * @returns {void}
      */
     once(event, handler) {
+        // Если есть нативная реализация в Socket.IO, используем её
+        if (this.socket && this.socket.connected) {
+            this.socket.once(event, handler);
+            return;
+        }
         // Создаем обертку, которая удалит обработчик после первого вызова
         const wrapperHandler = (data) => {
             // Удаляем обработчик
@@ -764,6 +444,46 @@ class WebSocketClient {
         // Регистрируем обертку
         this.on(event, wrapperHandler);
     }
+    /**
+     * Отправляет событие Socket.IO через WebSocket соединение
+     * @param {string} event Имя события
+     * @param {any} data Данные события
+     * @param {(response: any) => void} [callback] Функция обратного вызова для получения ответа
+     * @param {string} [namespace=''] Namespace для Socket.IO
+     * @returns {boolean} Успешно ли отправлено сообщение
+     */
+    sendSocketIOEvent(event, data, callback, namespace = '') {
+        // Если нет соединения, сразу возвращаем false
+        if (!this.socket || !this.socket.connected) {
+            this.logger('error', 'Нельзя отправить событие: WebSocket не подключен');
+            return false;
+        }
+        try {
+            // Проверяем, нужно ли использовать другой namespace
+            let targetSocket = this.socket;
+            // Если указан другой namespace, используем его
+            if (namespace && namespace !== this.namespace) {
+                const nsSocket = (0, socket_io_client_1.io)(this.url + namespace, {
+                    forceNew: false,
+                    auth: { token: this.options.apiKey }
+                });
+                targetSocket = nsSocket;
+            }
+            // Отправляем событие с callback, если он указан
+            if (callback) {
+                targetSocket.emit(event, data, callback);
+            }
+            else {
+                targetSocket.emit(event, data);
+            }
+            this.logger('debug', `Отправлено Socket.IO событие ${event}`, { hasData: !!data, namespace });
+            return true;
+        }
+        catch (error) {
+            this.logger('error', `Ошибка при отправке Socket.IO события ${event}`, error);
+            return false;
+        }
+    }
 }
 exports.WebSocketClient = WebSocketClient;
 //# sourceMappingURL=websocket-client.js.map