solver-sdk 1.0.3 → 1.0.6

package/dist/umd/code-solver-sdk.js

@@ -1,1915 +0,0 @@
-(function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('axios'), require('event-source-polyfill')) :
-    typeof define === 'function' && define.amd ? define(['exports', 'axios', 'event-source-polyfill'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.CodeSolverSDK = {}, global.axios, global.EventSourcePolyfill));
-})(this, (function (exports, axios, eventSourcePolyfill) { 'use strict';
-
-    /**
-     * Определение типа среды выполнения
-     * @returns 'browser' | 'node'
-     */
-    function getEnvironment$1() {
-        return (typeof window !== 'undefined' && typeof window.document !== 'undefined')
-            ? 'browser'
-            : 'node';
-    }
-    /**
-     * HTTP клиент для выполнения запросов к API
-     *
-     * Предоставляет методы для работы с REST API, включая обработку ошибок,
-     * повторные попытки и таймауты.
-     */
-    class HttpClient {
-        /**
-         * Создает новый HTTP клиент
-         * @param {string} baseURL Базовый URL для запросов
-         * @param {HttpClientOptions} [options] Опции для HTTP клиента
-         */
-        constructor(baseURL, options = {}) {
-            this.baseURL = baseURL;
-            this.options = {
-                headers: {
-                    'Content-Type': 'application/json',
-                    'Accept': 'application/json',
-                    ...(options.headers || {})
-                },
-                timeout: options.timeout || 30000,
-                retry: options.retry || {
-                    maxRetries: 3,
-                    retryDelay: 1000,
-                    maxRetryDelay: 10000,
-                    retryStatusCodes: [408, 429, 500, 502, 503, 504]
-                },
-                httpsAgent: options.httpsAgent
-            };
-            this.environment = getEnvironment$1();
-            // Создаем Axios инстанс с базовыми настройками
-            this.axiosInstance = axios.create({
-                baseURL: this.baseURL,
-                timeout: this.options.timeout,
-                headers: this.options.headers,
-                ...(this.environment === 'node' && this.options.httpsAgent ? { httpsAgent: this.options.httpsAgent } : {})
-            });
-            // Добавляем интерцептор для обработки ошибок и повторных попыток
-            this.setupInterceptors();
-        }
-        /**
-         * Настраивает интерцепторы Axios
-         */
-        setupInterceptors() {
-            // Интерцептор для ответов
-            this.axiosInstance.interceptors.response.use((response) => response.data, async (error) => {
-                const { config, response } = error;
-                // Если нет конфига запроса или это уже повторный запрос, или skipRetry установлен, возвращаем ошибку
-                if (!config || config._retryCount || config.skipRetry) {
-                    return Promise.reject(error);
-                }
-                config._retryCount = config._retryCount || 0;
-                const retryConfig = this.options.retry;
-                // Проверяем, нужно ли делать повторную попытку для данного статуса
-                const shouldRetry = response &&
-                    retryConfig.retryStatusCodes?.includes(response.status) &&
-                    config._retryCount < (retryConfig.maxRetries || 3);
-                if (shouldRetry) {
-                    config._retryCount += 1;
-                    // Вычисляем время задержки перед повторной попыткой
-                    const delay = Math.min((retryConfig.retryDelay || 1000) * Math.pow(2, config._retryCount - 1), retryConfig.maxRetryDelay || 10000);
-                    // Ждем перед повторной попыткой
-                    await new Promise(resolve => setTimeout(resolve, delay));
-                    // Делаем повторную попытку
-                    return this.axiosInstance(config);
-                }
-                // Если не нужно делать повторную попытку, возвращаем ошибку
-                return Promise.reject(error);
-            });
-        }
-        /**
-         * Выполняет HTTP запрос
-         * @param {RequestOptions} options Опции запроса
-         * @returns {Promise<T>} Ответ от API
-         */
-        async request(options) {
-            const axiosConfig = {
-                url: options.url,
-                method: options.method,
-                data: options.data,
-                params: options.params,
-                headers: {
-                    ...this.options.headers,
-                    ...(options.headers || {})
-                },
-                timeout: options.timeout || this.options.timeout
-            };
-            // Если указано не делать повторные попытки, добавляем специальный флаг
-            if (options.noRetry) {
-                axiosConfig.skipRetry = true;
-            }
-            try {
-                return await this.axiosInstance.request(axiosConfig);
-            }
-            catch (error) {
-                throw this.handleError(error);
-            }
-        }
-        /**
-         * Выполняет GET запрос
-         * @param {string} url URL для запроса
-         * @param {Record<string, any>} [params] Query параметры
-         * @param {Record<string, string>} [headers] HTTP заголовки
-         * @returns {Promise<T>} Ответ от API
-         */
-        async get(url, params, headers) {
-            return this.request({
-                url,
-                method: 'GET',
-                params,
-                headers
-            });
-        }
-        /**
-         * Выполняет POST запрос
-         * @param {string} url URL для запроса
-         * @param {any} [data] Данные для отправки
-         * @param {Record<string, string>} [headers] HTTP заголовки
-         * @returns {Promise<T>} Ответ от API
-         */
-        async post(url, data, headers) {
-            return this.request({
-                url,
-                method: 'POST',
-                data,
-                headers
-            });
-        }
-        /**
-         * Выполняет PUT запрос
-         * @param {string} url URL для запроса
-         * @param {any} [data] Данные для отправки
-         * @param {Record<string, string>} [headers] HTTP заголовки
-         * @returns {Promise<T>} Ответ от API
-         */
-        async put(url, data, headers) {
-            return this.request({
-                url,
-                method: 'PUT',
-                data,
-                headers
-            });
-        }
-        /**
-         * Выполняет DELETE запрос
-         * @param {string} url URL для запроса
-         * @param {Record<string, any>} [params] Query параметры
-         * @param {Record<string, string>} [headers] HTTP заголовки
-         * @returns {Promise<T>} Ответ от API
-         */
-        async delete(url, params, headers) {
-            return this.request({
-                url,
-                method: 'DELETE',
-                params,
-                headers
-            });
-        }
-        /**
-         * Выполняет PATCH запрос
-         * @param {string} url URL для запроса
-         * @param {any} [data] Данные для отправки
-         * @param {Record<string, string>} [headers] HTTP заголовки
-         * @returns {Promise<T>} Ответ от API
-         */
-        async patch(url, data, headers) {
-            return this.request({
-                url,
-                method: 'PATCH',
-                data,
-                headers
-            });
-        }
-        /**
-         * Обрабатывает ошибки от Axios
-         * @param {any} error Ошибка от Axios
-         * @returns {Error} Обработанная ошибка
-         */
-        handleError(error) {
-            let enhancedError;
-            if (error.response) {
-                // Ошибка от сервера с кодом ответа
-                const { status, data } = error.response;
-                const message = data?.message || data?.error || `HTTP ошибка ${status}`;
-                enhancedError = new Error(message);
-                enhancedError.status = status;
-                enhancedError.data = data;
-                enhancedError.isApiError = true;
-            }
-            else if (error.request) {
-                // Запрос был сделан, но ответ не получен
-                enhancedError = new Error('Нет ответа от сервера. Проверьте подключение к интернету.');
-                enhancedError.request = error.request;
-                enhancedError.isNetworkError = true;
-            }
-            else {
-                // Произошла ошибка при настройке запроса
-                enhancedError = new Error(error.message || 'Произошла неизвестная ошибка');
-                enhancedError.isUnknownError = true;
-            }
-            // Сохраняем оригинальную ошибку для отладки
-            enhancedError.originalError = error;
-            // Пытаемся обработать ошибку через глобальный обработчик
-            try {
-                // eslint-disable-next-line @typescript-eslint/no-var-requires
-                const { CodeSolverSDK } = require('../code-solver-sdk.js');
-                if (typeof CodeSolverSDK.handleError === 'function') {
-                    CodeSolverSDK.handleError(enhancedError);
-                }
-            }
-            catch (e) {
-                // Игнорируем ошибки при импорте или вызове обработчика
-            }
-            return enhancedError;
-        }
-    }
-
-    /**
-     * API для работы с проектами
-     */
-    class ProjectsApi {
-        /**
-         * Создает новый экземпляр API для работы с проектами
-         * @param {HttpClient} httpClient HTTP клиент
-         */
-        constructor(httpClient) {
-            this.httpClient = httpClient;
-        }
-        /**
-         * Получает список всех проектов
-         * @returns {Promise<Project[]>} Список проектов
-         */
-        async getAllProjects() {
-            return this.httpClient.get('/api/v1/projects');
-        }
-        /**
-         * Получает проект по ID
-         * @param {string} projectId ID проекта
-         * @returns {Promise<Project>} Проект
-         */
-        async getProject(projectId) {
-            return this.httpClient.get(`/api/v1/projects/${projectId}`);
-        }
-        /**
-         * Создает новый проект
-         * @param {string} name Название проекта
-         * @param {string} path Путь к проекту
-         * @param {ProjectOptions} [options] Дополнительные опции проекта
-         * @returns {Promise<Project>} Созданный проект
-         */
-        async createProject(name, path, options) {
-            return this.httpClient.post('/api/v1/projects', {
-                name,
-                path,
-                ...options
-            });
-        }
-        /**
-         * Обновляет проект
-         * @param {string} projectId ID проекта
-         * @param {Partial<ProjectUpdateData>} data Данные для обновления
-         * @returns {Promise<Project>} Обновленный проект
-         */
-        async updateProject(projectId, data) {
-            return this.httpClient.put(`/api/v1/projects/${projectId}`, data);
-        }
-        /**
-         * Удаляет проект
-         * @param {string} projectId ID проекта
-         * @returns {Promise<void>}
-         */
-        async deleteProject(projectId) {
-            return this.httpClient.delete(`/api/v1/projects/${projectId}`);
-        }
-        /**
-         * Запускает индексацию проекта
-         * @param {string} projectId ID проекта
-         * @returns {Promise<IndexingResponse>} Информация о начатой индексации
-         */
-        async indexProject(projectId) {
-            return this.httpClient.post(`/api/v1/projects/${projectId}/index`);
-        }
-        /**
-         * Останавливает индексацию проекта
-         * @param {string} projectId ID проекта
-         * @returns {Promise<void>}
-         */
-        async stopIndexing(projectId) {
-            return this.httpClient.post(`/api/v1/projects/${projectId}/cancel-indexing`);
-        }
-        /**
-         * Получает статус индексации проекта
-         * @param {string} projectId ID проекта
-         * @returns {Promise<IndexingStatus>} Статус индексации
-         */
-        async getIndexingStatus(projectId) {
-            return this.httpClient.get(`/api/v1/projects/${projectId}/indexing-status`);
-        }
-    }
-
-    /**
-     * API для поиска кода
-     */
-    class SearchApi {
-        /**
-         * Создает новый экземпляр API для поиска кода
-         * @param {HttpClient} httpClient HTTP клиент
-         */
-        constructor(httpClient) {
-            this.httpClient = httpClient;
-        }
-        /**
-         * Выполняет поиск кода в проекте
-         * @param {string} projectId Идентификатор проекта
-         * @param {SearchCodeParams} params Параметры поиска
-         * @returns {Promise<SearchResults>} Результаты поиска
-         */
-        async searchCode(projectId, params) {
-            return this.httpClient.post(`/api/v1/search/project/${projectId}`, params);
-        }
-        /**
-         * Выполняет семантический поиск кода в проекте
-         * @param {string} projectId Идентификатор проекта
-         * @param {SearchCodeParams} params Параметры поиска
-         * @returns {Promise<SearchResults>} Результаты поиска
-         */
-        async semanticSearch(projectId, params) {
-            return this.httpClient.post(`/api/v1/search/project/${projectId}`, { ...params, semantic: true });
-        }
-        /**
-         * Получает популярные поисковые запросы
-         * @param {string} projectId Идентификатор проекта
-         * @param {number} [limit=10] Лимит результатов
-         * @returns {Promise<string[]>} Популярные поисковые запросы
-         */
-        async getPopularQueries(projectId, limit = 10) {
-            return this.httpClient.get(`/api/projects/${projectId}/popular-queries`, { limit });
-        }
-        /**
-         * Получает подсказки для автозаполнения поискового запроса
-         * @param {string} projectId Идентификатор проекта
-         * @param {string} query Начало поискового запроса
-         * @param {number} [limit=5] Лимит результатов
-         * @returns {Promise<string[]>} Подсказки для автозаполнения
-         */
-        async getQuerySuggestions(projectId, query, limit = 5) {
-            return this.httpClient.get(`/api/projects/${projectId}/query-suggestions`, { query, limit });
-        }
-    }
-
-    /**
-     * API для работы с контекстом
-     */
-    class ContextApi {
-        /**
-         * Создает новый экземпляр API для работы с контекстом
-         * @param {HttpClient} httpClient HTTP клиент
-         */
-        constructor(httpClient) {
-            this.httpClient = httpClient;
-        }
-        /**
-         * Определяет контекст для запроса
-         * @param {DetectContextParams} params Параметры определения контекста
-         * @returns {Promise<AutoContext>} Определенный контекст
-         */
-        async detectContext(params) {
-            return this.httpClient.post('/api/context/detect', params);
-        }
-        /**
-         * Получает содержимое файла
-         * @param {string} projectId Идентификатор проекта
-         * @param {string} filePath Путь к файлу
-         * @returns {Promise<string>} Содержимое файла
-         */
-        async getFileContent(projectId, filePath) {
-            return this.httpClient.get(`/api/projects/${projectId}/files`, { path: filePath });
-        }
-        /**
-         * Получает содержимое фрагмента файла
-         * @param {string} projectId Идентификатор проекта
-         * @param {string} filePath Путь к файлу
-         * @param {number} startLine Начальная строка
-         * @param {number} endLine Конечная строка
-         * @returns {Promise<CodeSnippet>} Фрагмент кода
-         */
-        async getFileSnippet(projectId, filePath, startLine, endLine) {
-            return this.httpClient.get(`/api/projects/${projectId}/snippets`, {
-                path: filePath,
-                startLine,
-                endLine
-            });
-        }
-        /**
-         * Получает структуру директории
-         * @param {string} projectId Идентификатор проекта
-         * @param {string} [dirPath='/'] Путь к директории
-         * @returns {Promise<Array<{name: string, type: 'file' | 'directory', path: string}>>} Структура директории
-         */
-        async getDirectoryStructure(projectId, dirPath = '/') {
-            return this.httpClient.get(`/api/projects/${projectId}/directory`, { path: dirPath });
-        }
-    }
-
-    /**
-     * API для работы с рассуждениями
-     */
-    class ReasoningApi {
-        /**
-         * Создает новый экземпляр API для работы с рассуждениями
-         * @param {HttpClient} httpClient HTTP клиент
-         */
-        constructor(httpClient) {
-            this.httpClient = httpClient;
-        }
-        /**
-         * Получает список рассуждений
-         * @param {GetReasoningsParams} [params] Параметры для получения списка
-         * @returns {Promise<Reasoning[]>} Список рассуждений
-         */
-        async getReasonings(params) {
-            return this.httpClient.get('/api/reasonings', params);
-        }
-        /**
-         * Получает рассуждение по ID
-         * @param {string} reasoningId ID рассуждения
-         * @returns {Promise<Reasoning>} Рассуждение
-         */
-        async getReasoning(reasoningId) {
-            return this.httpClient.get(`/api/v1/reasoning/${reasoningId}`);
-        }
-        /**
-         * Создает новое рассуждение
-         * @param {ReasoningOptions} options Опции для рассуждения
-         * @returns {Promise<Reasoning>} Созданное рассуждение
-         */
-        async createReasoning(options) {
-            return this.httpClient.post('/api/v1/reasoning/create', options);
-        }
-        /**
-         * Запускает рассуждение
-         * @param {string} reasoningId ID рассуждения
-         * @returns {Promise<Reasoning>} Обновленное рассуждение
-         */
-        async startReasoning(reasoningId) {
-            return this.httpClient.post(`/api/v1/reasoning/start/${reasoningId}`);
-        }
-        /**
-         * Останавливает рассуждение
-         * @param {string} reasoningId ID рассуждения
-         * @returns {Promise<Reasoning>} Обновленное рассуждение
-         */
-        async stopReasoning(reasoningId) {
-            return this.httpClient.post(`/api/v1/reasoning/cancel/${reasoningId}`);
-        }
-        /**
-         * Удаляет рассуждение
-         * @param {string} reasoningId ID рассуждения
-         * @returns {Promise<void>}
-         */
-        async deleteReasoning(reasoningId) {
-            return this.httpClient.delete(`/api/v1/reasoning/${reasoningId}`);
-        }
-        /**
-         * Получает ход мыслей рассуждения
-         * @param {string} reasoningId ID рассуждения
-         * @returns {Promise<ThinkingStep[]>} Ход мыслей
-         */
-        async getThinking(reasoningId) {
-            return this.httpClient.get(`/api/v1/reasoning/${reasoningId}/thinking`);
-        }
-        /**
-         * Получает все рассуждения проекта
-         * @param {string} projectId ID проекта
-         * @returns {Promise<Reasoning[]>} Список рассуждений
-         */
-        async getAllReasonings(projectId) {
-            return this.httpClient.get(`/api/v1/reasoning/project/${projectId}`);
-        }
-    }
-
-    /**
-     * API для модификации кода
-     */
-    class CodeModificationApi {
-        /**
-         * Создает новый экземпляр API для модификации кода
-         * @param {HttpClient} httpClient HTTP клиент
-         */
-        constructor(httpClient) {
-            this.httpClient = httpClient;
-        }
-        /**
-         * Выполняет модификацию кода
-         * @param {CodeModificationParams} params Параметры модификации
-         * @returns {Promise<CodeModificationResult>} Результат модификации
-         */
-        async modifyCode(params) {
-            return this.httpClient.post('/api/code-modifications', params);
-        }
-        /**
-         * Применяет результат модификации к файлу
-         * @param {string} modificationId Идентификатор модификации
-         * @returns {Promise<CodeModificationResult>} Обновленный результат модификации
-         */
-        async applyModification(modificationId) {
-            return this.httpClient.post(`/api/code-modifications/${modificationId}/apply`);
-        }
-        /**
-         * Отменяет применение модификации
-         * @param {string} modificationId Идентификатор модификации
-         * @returns {Promise<CodeModificationResult>} Обновленный результат модификации
-         */
-        async revertModification(modificationId) {
-            return this.httpClient.post(`/api/code-modifications/${modificationId}/revert`);
-        }
-        /**
-         * Получает модификацию по идентификатору
-         * @param {string} modificationId Идентификатор модификации
-         * @returns {Promise<CodeModificationResult>} Результат модификации
-         */
-        async getModification(modificationId) {
-            return this.httpClient.get(`/api/code-modifications/${modificationId}`);
-        }
-        /**
-         * Получает список модификаций для проекта
-         * @param {string} projectId Идентификатор проекта
-         * @param {object} [params] Параметры запроса
-         * @param {number} [params.limit] Лимит результатов
-         * @param {number} [params.offset] Смещение для пагинации
-         * @returns {Promise<CodeModificationResult[]>} Список результатов модификации
-         */
-        async getModifications(projectId, params) {
-            return this.httpClient.get(`/api/projects/${projectId}/code-modifications`, params);
-        }
-    }
-
-    /**
-     * Базовый класс для WebSocket клиентов
-     */
-    class WebSocketClient {
-        /**
-         * Создает новый WebSocket клиент
-         * @param {string} url URL для подключения
-         * @param {WebSocketClientOptions} [options] Опции клиента
-         */
-        constructor(url, options = {}) {
-            /** Экземпляр WebSocket */
-            this.webSocket = null;
-            /** Счетчик попыток переподключения */
-            this.retryCount = 0;
-            /** Флаг, указывающий, что соединение было закрыто намеренно */
-            this.intentionallyClosed = false;
-            /** Таймер переподключения */
-            this.reconnectTimer = null;
-            /** Таймер таймаута соединения */
-            this.connectionTimeoutTimer = null;
-            /** Обработчики событий */
-            this.eventHandlers = {};
-            /** Очередь сообщений для отправки после подключения */
-            this.messageQueue = [];
-            /** Состояние соединения */
-            this.connected = false;
-            this.url = url;
-            this.options = {
-                headers: options.headers || {},
-                connectionTimeout: options.connectionTimeout || 30000,
-                protocols: options.protocols || [],
-                maxRetries: options.maxRetries || 5,
-                retryDelay: options.retryDelay || 1000,
-                maxRetryDelay: options.maxRetryDelay || 30000,
-                autoReconnect: options.autoReconnect !== undefined ? options.autoReconnect : true
-            };
-            // Определяем среду выполнения
-            this.isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
-        }
-        /**
-         * Подключается к WebSocket серверу
-         * @returns {Promise<void>}
-         */
-        connect() {
-            // Если соединение уже установлено, возвращаем Promise.resolve
-            if (this.webSocket && this.webSocket.readyState === WebSocket.OPEN) {
-                return Promise.resolve();
-            }
-            // Сбрасываем флаг намеренного закрытия
-            this.intentionallyClosed = false;
-            return new Promise((resolve, reject) => {
-                try {
-                    // Создаем новый экземпляр WebSocket
-                    if (this.isBrowser) {
-                        // Браузерное окружение
-                        this.webSocket = new WebSocket(this.url, this.options.protocols);
-                    }
-                    else {
-                        // Node.js окружение
-                        try {
-                            // Динамически импортируем ws модуль в Node.js
-                            const WebSocketImpl = require('ws');
-                            this.webSocket = new WebSocketImpl(this.url, {
-                                headers: this.options.headers,
-                                protocol: this.options.protocols
-                            });
-                        }
-                        catch (error) {
-                            reject(new Error('Не удалось загрузить модуль ws в Node.js: ' + error.message));
-                            return;
-                        }
-                    }
-                    // Устанавливаем таймаут соединения
-                    this.connectionTimeoutTimer = setTimeout(() => {
-                        if (this.webSocket && this.webSocket.readyState !== WebSocket.OPEN) {
-                            reject(new Error('Таймаут подключения WebSocket'));
-                            this.close();
-                        }
-                    }, this.options.connectionTimeout);
-                    // Обработчик открытия соединения
-                    this.webSocket.onopen = () => {
-                        clearTimeout(this.connectionTimeoutTimer);
-                        this.retryCount = 0;
-                        this.connected = true;
-                        // Отправляем сообщения из очереди
-                        while (this.messageQueue.length > 0) {
-                            const message = this.messageQueue.shift();
-                            if (message && this.webSocket && this.webSocket.readyState === WebSocket.OPEN) {
-                                this.webSocket.send(message);
-                            }
-                        }
-                        resolve();
-                        this.dispatchEvent('open', {});
-                    };
-                    // Обработчик сообщений
-                    this.webSocket.onmessage = (event) => {
-                        try {
-                            // Пытаемся распарсить сообщение как JSON
-                            let data = event.data;
-                            if (typeof data === 'string') {
-                                try {
-                                    data = JSON.parse(data);
-                                }
-                                catch (e) {
-                                    // Если не удалось распарсить, оставляем как есть
-                                }
-                            }
-                            this.dispatchEvent('message', data);
-                        }
-                        catch (e) {
-                            console.error('Ошибка при обработке сообщения WebSocket:', e);
-                        }
-                    };
-                    // Обработчик закрытия соединения
-                    this.webSocket.onclose = (event) => {
-                        clearTimeout(this.connectionTimeoutTimer);
-                        this.connected = false;
-                        this.dispatchEvent('close', { code: event.code, reason: event.reason });
-                        // Если соединение было закрыто намеренно, не пытаемся переподключиться
-                        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'));
-                        }
-                    };
-                }
-                catch (error) {
-                    reject(error);
-                }
-            });
-        }
-        /**
-         * Переподключается к WebSocket серверу
-         * @private
-         */
-        reconnect() {
-            // Увеличиваем счетчик попыток
-            this.retryCount++;
-            // Если превышено максимальное количество попыток, не пытаемся переподключиться
-            if (this.retryCount > (this.options.maxRetries || 5)) {
-                this.dispatchEvent('maxRetries', { retries: this.retryCount });
-                return;
-            }
-            // Вычисляем задержку перед переподключением с экспоненциальным ростом
-            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 соединение
-         * @param {number} [code=1000] Код закрытия
-         * @param {string} [reason] Причина закрытия
-         */
-        close(code = 1000, reason) {
-            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;
-            }
-            this.connected = false;
-        }
-        /**
-         * Отправляет сообщение через WebSocket
-         * @param {string | object} message Сообщение для отправки
-         * @returns {boolean} Успешно ли отправлено сообщение
-         */
-        send(message) {
-            const data = typeof message === 'string' ? message : JSON.stringify(message);
-            if (this.webSocket && this.webSocket.readyState === WebSocket.OPEN) {
-                this.webSocket.send(data);
-                return true;
-            }
-            else {
-                // Если соединение не установлено, добавляем сообщение в очередь
-                this.messageQueue.push(data);
-                // Если соединение не установлено и не закрыто намеренно, пытаемся подключиться
-                if ((!this.webSocket || this.webSocket.readyState === WebSocket.CLOSED) && !this.intentionallyClosed) {
-                    this.connect().catch(() => { });
-                }
-                return false;
-            }
-        }
-        /**
-         * Проверяет, установлено ли соединение
-         * @returns {boolean} Установлено ли соединение
-         */
-        isConnected() {
-            return this.webSocket !== null && this.webSocket.readyState === WebSocket.OPEN;
-        }
-        /**
-         * Добавляет обработчик события
-         * @param {string} eventType Тип события
-         * @param {WebSocketEventHandler} handler Обработчик события
-         */
-        on(eventType, handler) {
-            if (!this.eventHandlers[eventType]) {
-                this.eventHandlers[eventType] = [];
-            }
-            this.eventHandlers[eventType].push(handler);
-        }
-        /**
-         * Удаляет обработчик события
-         * @param {string} eventType Тип события
-         * @param {WebSocketEventHandler} [handler] Обработчик события (если не указан, удаляются все обработчики)
-         */
-        off(eventType, handler) {
-            if (!this.eventHandlers[eventType]) {
-                return;
-            }
-            if (!handler) {
-                // Если обработчик не указан, удаляем все обработчики для данного события
-                delete this.eventHandlers[eventType];
-            }
-            else {
-                // Если обработчик указан, удаляем только его
-                this.eventHandlers[eventType] = this.eventHandlers[eventType].filter(h => h !== handler);
-                // Если обработчиков больше нет, удаляем массив
-                if (this.eventHandlers[eventType].length === 0) {
-                    delete this.eventHandlers[eventType];
-                }
-            }
-        }
-        /**
-         * Вызывает обработчики для указанного события
-         * @param {string} eventType Тип события
-         * @param {any} data Данные события
-         */
-        dispatchEvent(eventType, data) {
-            if (!this.eventHandlers[eventType]) {
-                return;
-            }
-            for (const handler of this.eventHandlers[eventType]) {
-                try {
-                    handler(data);
-                }
-                catch (e) {
-                    console.error(`Ошибка в обработчике события ${eventType}:`, e);
-                }
-            }
-        }
-    }
-
-    /**
-     * Пространства имен для WebSocket
-     */
-    exports.WebSocketNamespace = void 0;
-    (function (WebSocketNamespace) {
-        /** Пространство имен для рассуждений */
-        WebSocketNamespace["REASONING"] = "reasoning";
-        /** Пространство имен для индексации */
-        WebSocketNamespace["INDEXING"] = "indexing";
-        /** Пространство имен для уведомлений */
-        WebSocketNamespace["NOTIFICATIONS"] = "notifications";
-    })(exports.WebSocketNamespace || (exports.WebSocketNamespace = {}));
-    /**
-     * WebSocket клиент для работы с Code Solver API
-     */
-    class CodeSolverWebSocketClient {
-        /**
-         * Создает новый WebSocket клиент для Code Solver API
-         * @param {string} baseURL Базовый URL API
-         * @param {CodeSolverWebSocketOptions} [options] Опции клиента
-         */
-        constructor(baseURL, options = {}) {
-            /** WebSocket клиенты для разных пространств имен */
-            this.clients = new Map();
-            /** Активная сессия рассуждения */
-            this.activeReasoningId = null;
-            /** Активная сессия индексации */
-            this.activeProjectId = null;
-            this.baseURL = baseURL.replace(/^http/, 'ws');
-            this.options = {
-                ...options,
-                headers: {
-                    ...(options.headers || {}),
-                    ...(options.apiKey ? { 'Authorization': `Bearer ${options.apiKey}` } : {})
-                }
-            };
-        }
-        /**
-         * Подключается к пространству имен WebSocket
-         * @param {WebSocketNamespace} namespace Пространство имен
-         * @param {Record<string, any>} [params] Параметры подключения
-         * @returns {Promise<WebSocketClient>} WebSocket клиент
-         */
-        async connect(namespace, params = {}) {
-            // Если клиент уже существует, возвращаем его
-            if (this.clients.has(namespace)) {
-                const client = this.clients.get(namespace);
-                // Если клиент уже подключен, возвращаем его
-                if (client.isConnected()) {
-                    return client;
-                }
-            }
-            // Формируем URL для подключения
-            const url = new URL(`${this.baseURL}/${namespace}`);
-            // Добавляем параметры к URL
-            Object.entries(params).forEach(([key, value]) => {
-                url.searchParams.append(key, String(value));
-            });
-            // Создаем новый WebSocket клиент
-            const client = new WebSocketClient(url.toString(), this.options);
-            // Подключаемся к серверу
-            await client.connect();
-            // Сохраняем клиент
-            this.clients.set(namespace, client);
-            return client;
-        }
-        /**
-         * Подключается к сессии рассуждения
-         * @param {string} [reasoningId] Идентификатор рассуждения
-         * @returns {Promise<void>}
-         */
-        async connectToReasoning(reasoningId) {
-            // Если reasoningId не указан, используем активный
-            const id = reasoningId || this.activeReasoningId;
-            if (!id) {
-                throw new Error('Необходимо указать идентификатор рассуждения');
-            }
-            // Сохраняем активный идентификатор рассуждения
-            this.activeReasoningId = id;
-            // Подключаемся к пространству имен
-            await this.connect(exports.WebSocketNamespace.REASONING, { reasoningId: id });
-        }
-        /**
-         * Подключается к сессии индексации проекта
-         * @param {string} [projectId] Идентификатор проекта
-         * @returns {Promise<void>}
-         */
-        async connectToIndexing(projectId) {
-            // Если projectId не указан, используем активный
-            const id = projectId || this.activeProjectId;
-            if (!id) {
-                throw new Error('Необходимо указать идентификатор проекта');
-            }
-            // Сохраняем активный идентификатор проекта
-            this.activeProjectId = id;
-            // Подключаемся к пространству имен
-            await this.connect(exports.WebSocketNamespace.INDEXING, { projectId: id });
-        }
-        /**
-         * Подключается к уведомлениям
-         * @returns {Promise<void>}
-         */
-        async connectToNotifications() {
-            // Подключаемся к пространству имен
-            await this.connect(exports.WebSocketNamespace.NOTIFICATIONS);
-        }
-        /**
-         * Отключается от пространства имен
-         * @param {WebSocketNamespace} namespace Пространство имен
-         */
-        disconnect(namespace) {
-            const client = this.clients.get(namespace);
-            if (client) {
-                client.close();
-                this.clients.delete(namespace);
-            }
-            // Сбрасываем активные сессии
-            if (namespace === exports.WebSocketNamespace.REASONING) {
-                this.activeReasoningId = null;
-            }
-            else if (namespace === exports.WebSocketNamespace.INDEXING) {
-                this.activeProjectId = null;
-            }
-        }
-        /**
-         * Отключается от всех пространств имен
-         */
-        disconnectAll() {
-            for (const [namespace, client] of this.clients.entries()) {
-                client.close();
-                this.clients.delete(namespace);
-            }
-            // Сбрасываем активные сессии
-            this.activeReasoningId = null;
-            this.activeProjectId = null;
-        }
-        /**
-         * Добавляет обработчик события для пространства имен
-         * @param {string} eventType Тип события
-         * @param {Function} handler Обработчик события
-         * @param {WebSocketNamespace} [namespace] Пространство имен (если не указано, добавляется ко всем активным)
-         */
-        on(eventType, handler, namespace) {
-            if (namespace) {
-                // Если указано пространство имен, добавляем обработчик только к нему
-                const client = this.clients.get(namespace);
-                if (!client) {
-                    throw new Error(`Не подключен к пространству имен ${namespace}`);
-                }
-                client.on(eventType, handler);
-            }
-            else {
-                // Если пространство имен не указано, добавляем обработчик ко всем активным пространствам
-                for (const client of this.clients.values()) {
-                    client.on(eventType, handler);
-                }
-            }
-        }
-        /**
-         * Удаляет обработчик события для пространства имен
-         * @param {string} eventType Тип события
-         * @param {Function} [handler] Обработчик события (если не указан, удаляются все обработчики)
-         * @param {WebSocketNamespace} [namespace] Пространство имен (если не указано, удаляется из всех активных)
-         */
-        off(eventType, handler, namespace) {
-            if (namespace) {
-                // Если указано пространство имен, удаляем обработчик только из него
-                const client = this.clients.get(namespace);
-                if (!client) {
-                    return;
-                }
-                client.off(eventType, handler);
-            }
-            else {
-                // Если пространство имен не указано, удаляем обработчик из всех активных пространств
-                for (const client of this.clients.values()) {
-                    client.off(eventType, handler);
-                }
-            }
-        }
-        /**
-         * Отправляет сообщение в пространство имен
-         * @param {WebSocketNamespace} namespace Пространство имен
-         * @param {string} eventType Тип события
-         * @param {any} [data] Данные сообщения
-         * @returns {boolean} Успешно ли отправлено сообщение
-         */
-        send(namespace, eventType, data) {
-            const client = this.clients.get(namespace);
-            if (!client) {
-                throw new Error(`Не подключен к пространству имен ${namespace}`);
-            }
-            return client.send({
-                event: eventType,
-                data
-            });
-        }
-        /**
-         * Отправляет сообщение в активную сессию рассуждения
-         * @param {string} eventType Тип события
-         * @param {any} [data] Данные сообщения
-         * @returns {boolean} Успешно ли отправлено сообщение
-         */
-        sendToReasoning(eventType, data) {
-            if (!this.activeReasoningId) {
-                throw new Error('Не подключен к сессии рассуждения');
-            }
-            return this.send(exports.WebSocketNamespace.REASONING, eventType, data);
-        }
-        /**
-         * Отправляет сообщение в активную сессию индексации
-         * @param {string} eventType Тип события
-         * @param {any} [data] Данные сообщения
-         * @returns {boolean} Успешно ли отправлено сообщение
-         */
-        sendToIndexing(eventType, data) {
-            if (!this.activeProjectId) {
-                throw new Error('Не подключен к сессии индексации');
-            }
-            return this.send(exports.WebSocketNamespace.INDEXING, eventType, data);
-        }
-        /**
-         * Отправляет сообщение в уведомления
-         * @param {string} eventType Тип события
-         * @param {any} [data] Данные сообщения
-         * @returns {boolean} Успешно ли отправлено сообщение
-         */
-        sendToNotifications(eventType, data) {
-            return this.send(exports.WebSocketNamespace.NOTIFICATIONS, eventType, data);
-        }
-        /**
-         * Проверяет, подключен ли клиент к указанному пространству имен
-         * @param {WebSocketNamespace} namespace Пространство имен
-         * @returns {boolean} Статус подключения
-         */
-        isConnected(namespace) {
-            const client = this.clients.get(namespace);
-            return client ? client.isConnected() : false;
-        }
-        /**
-         * Проверяет, подключен ли клиент к пространству имен рассуждений
-         * @returns {boolean} Статус подключения
-         */
-        isConnectedToReasoning() {
-            return this.isConnected(exports.WebSocketNamespace.REASONING);
-        }
-        /**
-         * Проверяет, подключен ли клиент к пространству имен индексации
-         * @returns {boolean} Статус подключения
-         */
-        isConnectedToIndexing() {
-            return this.isConnected(exports.WebSocketNamespace.INDEXING);
-        }
-        /**
-         * Проверяет, подключен ли клиент к пространству имен уведомлений
-         * @returns {boolean} Статус подключения
-         */
-        isConnectedToNotifications() {
-            return this.isConnected(exports.WebSocketNamespace.NOTIFICATIONS);
-        }
-    }
-
-    /**
-     * API для работы с агентами
-     */
-    class AgentsApi {
-        /**
-         * Создает новый экземпляр API для работы с агентами
-         * @param {HttpClient} httpClient HTTP клиент
-         */
-        constructor(httpClient) {
-            this.httpClient = httpClient;
-        }
-        /**
-         * Получает список всех агентов проекта
-         * @param {string} projectId Идентификатор проекта
-         * @returns {Promise<Agent[]>} Список агентов
-         */
-        async getAgents(projectId) {
-            return this.httpClient.get(`/api/projects/${projectId}/agents`);
-        }
-        /**
-         * Получает агента по идентификатору
-         * @param {string} agentId Идентификатор агента
-         * @returns {Promise<Agent>} Агент
-         */
-        async getAgent(agentId) {
-            return this.httpClient.get(`/api/agents/${agentId}`);
-        }
-        /**
-         * Создает нового агента
-         * @param {CreateAgentParams} params Параметры создания агента
-         * @returns {Promise<Agent>} Созданный агент
-         */
-        async createAgent(params) {
-            return this.httpClient.post('/api/agents', params);
-        }
-        /**
-         * Обновляет агента
-         * @param {string} agentId Идентификатор агента
-         * @param {Partial<Pick<Agent, 'name' | 'description' | 'settings'>>} data Данные для обновления
-         * @returns {Promise<Agent>} Обновленный агент
-         */
-        async updateAgent(agentId, data) {
-            return this.httpClient.put(`/api/agents/${agentId}`, data);
-        }
-        /**
-         * Удаляет агента
-         * @param {string} agentId Идентификатор агента
-         * @returns {Promise<void>}
-         */
-        async deleteAgent(agentId) {
-            return this.httpClient.delete(`/api/agents/${agentId}`);
-        }
-        /**
-         * Запускает агента
-         * @param {string} agentId Идентификатор агента
-         * @param {object} [params] Параметры запуска
-         * @returns {Promise<Agent>} Обновленный агент
-         */
-        async startAgent(agentId, params) {
-            return this.httpClient.post(`/api/agents/${agentId}/start`, params);
-        }
-        /**
-         * Останавливает агента
-         * @param {string} agentId Идентификатор агента
-         * @returns {Promise<Agent>} Обновленный агент
-         */
-        async stopAgent(agentId) {
-            return this.httpClient.post(`/api/agents/${agentId}/stop`);
-        }
-        /**
-         * Получает задачи агента
-         * @param {string} agentId Идентификатор агента
-         * @returns {Promise<AgentTask[]>} Список задач
-         */
-        async getAgentTasks(agentId) {
-            return this.httpClient.get(`/api/agents/${agentId}/tasks`);
-        }
-        /**
-         * Создает новую задачу для агента
-         * @param {string} agentId Идентификатор агента
-         * @param {object} params Параметры задачи
-         * @param {string} params.description Описание задачи
-         * @param {object} [params.context] Контекст задачи
-         * @returns {Promise<AgentTask>} Созданная задача
-         */
-        async createAgentTask(agentId, params) {
-            return this.httpClient.post(`/api/agents/${agentId}/tasks`, params);
-        }
-    }
-
-    // Версия SDK
-    const SDK_VERSION = '1.0.0';
-    /**
-     * Определение типа среды выполнения
-     * @returns 'browser' | 'node' | 'unknown'
-     */
-    function getEnvironment() {
-        if (typeof window !== 'undefined' && typeof window.document !== 'undefined') {
-            return 'browser';
-        }
-        else if (typeof process !== 'undefined' && process.versions && process.versions.node) {
-            return 'node';
-        }
-        return 'unknown';
-    }
-    /**
-     * Основной класс SDK для работы с Code Solver API
-     * Поддерживает работу как в браузере, так и в Node.js
-     */
-    class CodeSolverSDK {
-        /**
-         * Создает новый экземпляр SDK
-         * @param {CodeSolverSDKOptions} options Опции SDK
-         */
-        constructor(options) {
-            /** WebSocket клиент для работы с реалтайм API */
-            this.wsClient = null;
-            this._options = {
-                ...options,
-                mode: options.mode || 'auto'
-            };
-            // Определяем среду выполнения
-            this.environment = this._options.mode === 'auto'
-                ? getEnvironment()
-                : this._options.mode === 'browser' ? 'browser' : 'node';
-            // Инициализируем HTTP клиент
-            this.httpClient = new HttpClient(this._options.baseURL, {
-                headers: {
-                    ...(this._options.apiKey ? { 'Authorization': `Bearer ${this._options.apiKey}` } : {}),
-                    ...(this._options.headers || {})
-                },
-                timeout: this._options.timeout,
-                httpsAgent: this.environment === 'node' ? this._options.httpsAgent : undefined
-            });
-            // Инициализируем API клиенты
-            this._agents = new AgentsApi(this.httpClient);
-            this._context = new ContextApi(this.httpClient);
-            this._projects = new ProjectsApi(this.httpClient);
-            this._search = new SearchApi(this.httpClient);
-            this._reasoning = new ReasoningApi(this.httpClient);
-            this._codeModification = new CodeModificationApi(this.httpClient);
-        }
-        /**
-         * Проверяет доступность API
-         * @returns {Promise<boolean>} Доступен ли API
-         */
-        async checkHealth() {
-            try {
-                await this.httpClient.get('/health');
-                return true;
-            }
-            catch (error) {
-                return false;
-            }
-        }
-        /**
-         * Получает WebSocket клиент
-         * @returns {CodeSolverWebSocketClient} WebSocket клиент
-         */
-        getWebSocketClient() {
-            if (!this.wsClient) {
-                this.wsClient = new CodeSolverWebSocketClient(this._options.baseURL, {
-                    apiKey: this._options.apiKey,
-                    headers: this._options.headers
-                });
-            }
-            return this.wsClient;
-        }
-        /**
-         * API для работы с агентами
-         */
-        get agents() {
-            return this._agents;
-        }
-        /**
-         * API для работы с контекстом
-         */
-        get context() {
-            return this._context;
-        }
-        /**
-         * API для работы с проектами
-         */
-        get projects() {
-            return this._projects;
-        }
-        /**
-         * API для поиска кода
-         */
-        get search() {
-            return this._search;
-        }
-        /**
-         * API для работы с рассуждениями
-         */
-        get reasoning() {
-            return this._reasoning;
-        }
-        /**
-         * API для модификации кода
-         */
-        get codeModification() {
-            return this._codeModification;
-        }
-        /**
-         * Опции SDK
-         */
-        get options() {
-            return this._options;
-        }
-        /**
-         * Получает текущую среду выполнения
-         * @returns {string} Среда выполнения ('browser', 'node', 'unknown')
-         */
-        getEnvironment() {
-            return this.environment;
-        }
-        /**
-         * Закрывает все соединения и освобождает ресурсы
-         */
-        dispose() {
-            if (this.wsClient) {
-                this.wsClient.disconnectAll();
-                this.wsClient = null;
-            }
-        }
-        /**
-         * Устанавливает глобальный обработчик ошибок SDK
-         * @param {(error: Error) => void} handler Функция-обработчик ошибок
-         */
-        static setErrorHandler(handler) {
-            CodeSolverSDK.errorHandler = handler;
-        }
-        /**
-         * Обрабатывает ошибку через глобальный обработчик, если он установлен
-         * @param {Error} error Ошибка для обработки
-         */
-        static handleError(error) {
-            if (CodeSolverSDK.errorHandler) {
-                CodeSolverSDK.errorHandler(error);
-            }
-            else {
-                console.error('[CodeSolverSDK]', error);
-            }
-        }
-        /**
-         * Возвращает текущую версию SDK
-         * @returns {string} Версия SDK
-         */
-        static getVersion() {
-            return SDK_VERSION;
-        }
-        /**
-         * Возвращает текущую версию SDK
-         * @returns {string} Версия SDK
-         */
-        getVersion() {
-            return SDK_VERSION;
-        }
-        /**
-         * Устанавливает новый API ключ для SDK
-         * @param {string} apiKey Новый API ключ
-         */
-        setApiKey(apiKey) {
-            if (!apiKey) {
-                throw new Error('API ключ не может быть пустым');
-            }
-            // Обновляем опции
-            this._options.apiKey = apiKey;
-            // Пересоздаем HTTP клиент с новым API ключом
-            const newHttpClient = new HttpClient(this._options.baseURL, {
-                headers: {
-                    ...this._options.headers,
-                    'Authorization': `Bearer ${apiKey}`
-                },
-                timeout: this._options.timeout,
-                httpsAgent: this.environment === 'node' ? this._options.httpsAgent : undefined
-            });
-            // Обновляем ссылки на клиент и API
-            this.httpClient = newHttpClient;
-            this._agents = new AgentsApi(newHttpClient);
-            this._context = new ContextApi(newHttpClient);
-            this._projects = new ProjectsApi(newHttpClient);
-            this._search = new SearchApi(newHttpClient);
-            this._reasoning = new ReasoningApi(newHttpClient);
-            this._codeModification = new CodeModificationApi(newHttpClient);
-            // Если есть WebSocket клиент, пересоздаем его
-            if (this.wsClient) {
-                const isConnected = this.wsClient.isConnectedToReasoning() || this.wsClient.isConnectedToIndexing();
-                this.wsClient.disconnectAll();
-                this.wsClient = new CodeSolverWebSocketClient(this._options.baseURL, {
-                    apiKey,
-                    headers: this._options.headers
-                });
-                // Если был подключен, восстанавливаем соединение
-                if (isConnected) {
-                    this.connect().catch(() => { });
-                }
-            }
-        }
-        /**
-         * Подключается к WebSocket серверу
-         * @returns {Promise<boolean>} Promise с результатом подключения
-         */
-        async connect() {
-            try {
-                const wsClient = this.getWebSocketClient();
-                // Подключаемся к обоим пространствам имен
-                await wsClient.connectToReasoning();
-                await wsClient.connectToIndexing();
-                return true;
-            }
-            catch (error) {
-                CodeSolverSDK.handleError(error);
-                return false;
-            }
-        }
-        /**
-         * Отключается от WebSocket сервера
-         * @returns {Promise<void>} Promise без результата
-         */
-        async disconnect() {
-            if (this.wsClient) {
-                await this.wsClient.disconnectAll();
-            }
-        }
-        /**
-         * Проверяет, подключен ли SDK к WebSocket серверу
-         * @returns {boolean} Статус подключения
-         */
-        isConnected() {
-            if (!this.wsClient)
-                return false;
-            return this.wsClient.isConnectedToReasoning() || this.wsClient.isConnectedToIndexing();
-        }
-        /**
-         * Проверяет доступность API (алиас для checkHealth)
-         * @returns {Promise<boolean>} Promise с результатом проверки
-         */
-        async isHealthy() {
-            return this.checkHealth();
-        }
-        /**
-         * Проверяет доступность всех сервисов API
-         * @returns {Promise<{[key: string]: boolean}>} Статус каждого сервиса
-         */
-        async checkServices() {
-            try {
-                const results = {
-                    api: false,
-                    websocket: false,
-                    database: false,
-                    search: false
-                };
-                try {
-                    // Проверка API
-                    results.api = await this.checkHealth();
-                    // Проверка других компонентов через запрос статуса
-                    const response = await this.httpClient.get('/api/v1/status');
-                    if (response && typeof response === 'object') {
-                        results.database = Boolean(response.database?.connected);
-                        results.search = Boolean(response.search?.connected);
-                        // Проверка WebSocket соединения
-                        if (this.wsClient) {
-                            results.websocket = this.wsClient.isConnectedToReasoning() ||
-                                this.wsClient.isConnectedToIndexing();
-                        }
-                        else {
-                            try {
-                                const wsClient = this.getWebSocketClient();
-                                await wsClient.connectToReasoning();
-                                results.websocket = true;
-                                await wsClient.disconnect(exports.WebSocketNamespace.REASONING);
-                            }
-                            catch (e) {
-                                results.websocket = false;
-                            }
-                        }
-                    }
-                }
-                catch (error) {
-                    // Игнорируем ошибки при проверке
-                }
-                return results;
-            }
-            catch (error) {
-                return {
-                    api: false,
-                    websocket: false,
-                    database: false,
-                    search: false
-                };
-            }
-        }
-        /**
-         * Закрывает соединение с сервером (алиас для dispose)
-         */
-        close() {
-            this.dispose();
-            return Promise.resolve();
-        }
-    }
-    /** Глобальный обработчик ошибок */
-    CodeSolverSDK.errorHandler = null;
-
-    // В браузере будем использовать нативный EventSource или полифилл
-    const BrowserEventSource = typeof EventSource !== 'undefined' ? EventSource : eventSourcePolyfill.EventSourcePolyfill;
-    // Проверяем, находимся ли мы в браузере
-    const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
-    /**
-     * Клиент для работы с Server-Sent Events (SSE)
-     * Поддерживает работу как в браузере, так и в Node.js
-     */
-    class SseClient {
-        /**
-         * Создает новый SSE клиент
-         * @param {string} url URL для подключения
-         * @param {SseClientOptions} [options] Опции клиента
-         */
-        constructor(url, options = {}) {
-            /** Экземпляр EventSource */
-            this.eventSource = null;
-            /** Счетчик попыток переподключения */
-            this.retryCount = 0;
-            /** Флаг, указывающий, что соединение было закрыто намеренно */
-            this.intentionallyClosed = false;
-            /** Таймер переподключения */
-            this.reconnectTimer = null;
-            /** Таймер таймаута соединения */
-            this.connectionTimeoutTimer = null;
-            /** Обработчики событий */
-            this.eventHandlers = {};
-            this.url = url;
-            this.options = {
-                headers: options.headers || {},
-                connectionTimeout: options.connectionTimeout || 30000,
-                maxRetries: options.maxRetries || 5,
-                retryDelay: options.retryDelay || 1000,
-                maxRetryDelay: options.maxRetryDelay || 30000
-            };
-        }
-        /**
-         * Подключается к SSE эндпоинту
-         * @returns {Promise<void>}
-         */
-        connect() {
-            // Если соединение уже установлено, возвращаем Promise.resolve
-            if (this.eventSource && this.eventSource.readyState === 1) {
-                return Promise.resolve();
-            }
-            // Сбрасываем флаг намеренного закрытия
-            this.intentionallyClosed = false;
-            return new Promise((resolve, reject) => {
-                try {
-                    // Создаем новый экземпляр EventSource
-                    const EventSourceImpl = isBrowser ? BrowserEventSource : require('eventsource');
-                    this.eventSource = new EventSourceImpl(this.url, {
-                        headers: this.options.headers,
-                        withCredentials: true
-                    });
-                    // Устанавливаем таймаут соединения
-                    this.connectionTimeoutTimer = setTimeout(() => {
-                        if (this.eventSource && this.eventSource.readyState !== 1) {
-                            reject(new Error('Таймаут подключения SSE'));
-                            this.close();
-                        }
-                    }, this.options.connectionTimeout);
-                    // Проверяем, что this.eventSource не null
-                    if (!this.eventSource) {
-                        reject(new Error('Не удалось создать EventSource'));
-                        return;
-                    }
-                    // Обработчик открытия соединения
-                    this.eventSource.onopen = () => {
-                        clearTimeout(this.connectionTimeoutTimer);
-                        this.retryCount = 0;
-                        resolve();
-                        this.dispatchEvent('open', {});
-                    };
-                    // Обработчик сообщений
-                    this.eventSource.onmessage = (event) => {
-                        try {
-                            const data = JSON.parse(event.data);
-                            this.dispatchEvent('message', data);
-                            // Также вызываем специальный обработчик для конкретного типа события,
-                            // если такой тип указан в данных
-                            if (data && data.type) {
-                                this.dispatchEvent(data.type, data);
-                            }
-                        }
-                        catch (error) {
-                            this.dispatchEvent('error', { error, message: 'Ошибка при обработке сообщения SSE' });
-                        }
-                    };
-                    // Обработчик ошибок
-                    this.eventSource.onerror = (error) => {
-                        clearTimeout(this.connectionTimeoutTimer);
-                        if (this.intentionallyClosed) {
-                            return;
-                        }
-                        // Если соединение уже установлено и произошла ошибка, просто сообщаем об ошибке
-                        if (this.eventSource && this.eventSource.readyState === 1) {
-                            this.dispatchEvent('error', { error, message: 'Ошибка SSE соединения' });
-                            return;
-                        }
-                        // Если это первая попытка подключения, отклоняем Promise
-                        if (this.retryCount === 0) {
-                            reject(new Error('Ошибка подключения SSE'));
-                        }
-                        // Запускаем процесс переподключения
-                        this.reconnect();
-                    };
-                    // Настраиваем обработчики для всех добавленных событий
-                    for (const eventType in this.eventHandlers) {
-                        if (eventType !== 'message' && eventType !== 'open' && eventType !== 'error') {
-                            this.eventSource.addEventListener(eventType, (event) => {
-                                try {
-                                    const data = JSON.parse(event.data);
-                                    this.dispatchEvent(eventType, data);
-                                }
-                                catch (e) {
-                                    this.dispatchEvent(eventType, event.data);
-                                }
-                            });
-                        }
-                    }
-                }
-                catch (error) {
-                    reject(error);
-                }
-            });
-        }
-        /**
-         * Закрывает SSE соединение
-         */
-        close() {
-            this.intentionallyClosed = true;
-            // Очищаем таймеры
-            clearTimeout(this.reconnectTimer);
-            clearTimeout(this.connectionTimeoutTimer);
-            // Закрываем соединение
-            if (this.eventSource) {
-                this.eventSource.close();
-                this.eventSource = null;
-            }
-            this.dispatchEvent('close', {});
-        }
-        /**
-         * Добавляет обработчик события
-         * @param {string} eventType Тип события
-         * @param {SseEventHandler} handler Обработчик события
-         */
-        on(eventType, handler) {
-            if (!this.eventHandlers[eventType]) {
-                this.eventHandlers[eventType] = [];
-                // Если соединение уже установлено, добавляем обработчик события
-                if (this.eventSource && this.eventSource.readyState === 1 &&
-                    eventType !== 'message' && eventType !== 'open' && eventType !== 'error') {
-                    this.eventSource.addEventListener(eventType, (event) => {
-                        try {
-                            const data = JSON.parse(event.data);
-                            this.dispatchEvent(eventType, data);
-                        }
-                        catch (e) {
-                            this.dispatchEvent(eventType, event.data);
-                        }
-                    });
-                }
-            }
-            this.eventHandlers[eventType].push(handler);
-        }
-        /**
-         * Удаляет обработчик события
-         * @param {string} eventType Тип события
-         * @param {SseEventHandler} [handler] Обработчик события (если не указан, удаляются все обработчики)
-         */
-        off(eventType, handler) {
-            if (!this.eventHandlers[eventType]) {
-                return;
-            }
-            if (!handler) {
-                // Если обработчик не указан, удаляем все обработчики для данного события
-                delete this.eventHandlers[eventType];
-            }
-            else {
-                // Если обработчик указан, удаляем только его
-                this.eventHandlers[eventType] = this.eventHandlers[eventType].filter(h => h !== handler);
-                // Если обработчиков больше нет, удаляем массив
-                if (this.eventHandlers[eventType].length === 0) {
-                    delete this.eventHandlers[eventType];
-                }
-            }
-        }
-        /**
-         * Вызывает обработчики для указанного события
-         * @param {string} eventType Тип события
-         * @param {any} data Данные события
-         */
-        dispatchEvent(eventType, data) {
-            if (!this.eventHandlers[eventType]) {
-                return;
-            }
-            for (const handler of this.eventHandlers[eventType]) {
-                try {
-                    handler(data);
-                }
-                catch (e) {
-                    console.error(`Ошибка в обработчике события ${eventType}:`, e);
-                }
-            }
-        }
-        /**
-         * Переподключается к SSE эндпоинту с экспоненциальной задержкой
-         * @private
-         */
-        reconnect() {
-            // Увеличиваем счетчик попыток
-            this.retryCount++;
-            // Если превышено максимальное количество попыток, прекращаем
-            if (this.retryCount > (this.options.maxRetries || 5)) {
-                this.dispatchEvent('maxRetries', { retries: this.retryCount });
-                return;
-            }
-            // Вычисляем задержку перед переподключением с экспоненциальным ростом
-            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);
-        }
-    }
-
-    /**
-     * События индексации
-     */
-    var IndexingEvent;
-    (function (IndexingEvent) {
-        /** Начало индексации */
-        IndexingEvent["START"] = "indexing_start";
-        /** Прогресс индексации */
-        IndexingEvent["PROGRESS"] = "indexing_progress";
-        /** Завершение индексации */
-        IndexingEvent["COMPLETE"] = "indexing_complete";
-        /** Ошибка индексации */
-        IndexingEvent["ERROR"] = "indexing_error";
-    })(IndexingEvent || (IndexingEvent = {}));
-    /**
-     * WebSocket клиент для работы с индексацией
-     */
-    class IndexingWebSocketClient extends WebSocketClient {
-        /**
-         * Создает новый WebSocket клиент для индексации
-         * @param {string} url URL для подключения
-         * @param {IndexingWebSocketOptions} [options] Опции клиента
-         */
-        constructor(url, options = {}) {
-            // Сохраняем базовый URL
-            const baseUrl = url;
-            // Формируем URL с параметрами для проекта если он указан
-            let targetUrl = url;
-            if (options.projectId) {
-                const urlWithParams = new URL(url);
-                urlWithParams.searchParams.append('projectId', options.projectId);
-                urlWithParams.searchParams.append('type', 'indexing');
-                targetUrl = urlWithParams.toString();
-            }
-            super(targetUrl, {
-                ...options,
-                headers: {
-                    ...(options.headers || {}),
-                    ...(options.apiKey ? { 'Authorization': `Bearer ${options.apiKey}` } : {})
-                }
-            });
-            /** Идентификатор проекта */
-            this.projectId = null;
-            this.baseUrl = baseUrl;
-            this.projectId = options.projectId || null;
-        }
-        /**
-         * Устанавливает идентификатор проекта
-         * @param {string} projectId Идентификатор проекта
-         */
-        setProjectId(projectId) {
-            this.projectId = projectId;
-        }
-        /**
-         * Подключается к WebSocket для отслеживания индексации
-         * @param {string} [projectId] Идентификатор проекта (если не был указан в конструкторе)
-         * @returns {Promise<void>}
-         */
-        async connect(projectId) {
-            const targetProjectId = projectId || this.projectId;
-            if (!targetProjectId) {
-                throw new Error('Project ID is required for indexing WebSocket connection');
-            }
-            // Сохраняем ID проекта
-            this.projectId = targetProjectId;
-            // Если проект изменился и клиент уже подключен, отключаемся
-            if (projectId && this.isConnected()) {
-                this.close();
-            }
-            // Выполняем соединение
-            await super.connect();
-        }
-        /**
-         * Подписывается на события начала индексации
-         * @param {(data: {projectId: string}) => void} handler Обработчик события
-         */
-        onStart(handler) {
-            this.on(IndexingEvent.START, handler);
-        }
-        /**
-         * Подписывается на события прогресса индексации
-         * @param {(data: IndexingProgressData) => void} handler Обработчик события
-         */
-        onProgress(handler) {
-            this.on(IndexingEvent.PROGRESS, handler);
-        }
-        /**
-         * Подписывается на события завершения индексации
-         * @param {(data: IndexingCompleteData) => void} handler Обработчик события
-         */
-        onComplete(handler) {
-            this.on(IndexingEvent.COMPLETE, handler);
-        }
-        /**
-         * Подписывается на события ошибок индексации
-         * @param {(data: IndexingErrorData) => void} handler Обработчик события
-         */
-        onError(handler) {
-            this.on(IndexingEvent.ERROR, handler);
-        }
-    }
-
-    /**
-     * Общие типы данных для SDK
-     */
-    /**
-     * Уровень логирования
-     */
-    exports.LogLevel = void 0;
-    (function (LogLevel) {
-        LogLevel["DEBUG"] = "debug";
-        LogLevel["INFO"] = "info";
-        LogLevel["WARN"] = "warn";
-        LogLevel["ERROR"] = "error";
-    })(exports.LogLevel || (exports.LogLevel = {}));
-
-    // Экспорт основного класса SDK
-    // Версия SDK
-    const VERSION = '1.0.0';
-    // Простой пример использования SDK
-    /**
-     * Пример использования SDK:
-     *
-     * ```typescript
-     * // ESM импорт (браузер, современный Node.js)
-     * import { CodeSolverSDK } from 'code-solver-sdk';
-     *
-     * // CommonJS импорт (Node.js)
-     * // const { CodeSolverSDK } = require('code-solver-sdk');
-     *
-     * const sdk = new CodeSolverSDK({
-     *   baseURL: 'https://api.example.com',
-     *   apiKey: 'your-api-key'  // если требуется
-     * });
-     *
-     * // Пример работы с проектами
-     * async function example() {
-     *   // Проверка доступности API
-     *   const isHealthy = await sdk.checkHealth();
-     *   console.log('API доступен:', isHealthy);
-     *
-     *   // Получение списка проектов
-     *   const projects = await sdk.projects.getAllProjects();
-     *   console.log('Проекты:', projects);
-     *
-     *   // Создание нового проекта
-     *   const newProject = await sdk.projects.createProject('Мой проект', '/path/to/project');
-     *   console.log('Новый проект:', newProject);
-     *
-     *   // Запуск индексации
-     *   await sdk.projects.indexProject(newProject.id);
-     *
-     *   // Поиск кода
-     *   const searchResults = await sdk.search.searchCode(newProject.id, {
-     *     query: 'function example',
-     *     limit: 10
-     *   });
-     *   console.log('Результаты поиска:', searchResults);
-     *
-     *   // Работа с рассуждениями
-     *   const reasoning = await sdk.reasoning.createReasoning({
-     *     projectId: newProject.id,
-     *     query: 'Объясни, как работает этот проект'
-     *   });
-     *
-     *   // Запуск процесса рассуждения
-     *   await sdk.reasoning.startReasoning(reasoning.id);
-     *
-     *   // Подключение через WebSocket
-     *   const wsClient = sdk.getWebSocketClient();
-     *   await wsClient.connectToReasoning();
-     *
-     *   // Обработка событий
-     *   wsClient.on('thinking', (data) => {
-     *     console.log('Размышление:', data.content);
-     *   });
-     *
-     *   wsClient.on('complete', (data) => {
-     *     console.log('Завершено:', data.content);
-     *     wsClient.disconnectAll();
-     *   });
-     * }
-     * ```
-     */
-
-    exports.AgentsApi = AgentsApi;
-    exports.CodeModificationApi = CodeModificationApi;
-    exports.CodeSolverSDK = CodeSolverSDK;
-    exports.CodeSolverWebSocketClient = CodeSolverWebSocketClient;
-    exports.ContextApi = ContextApi;
-    exports.HttpClient = HttpClient;
-    exports.IndexingWebSocketClient = IndexingWebSocketClient;
-    exports.ProjectsApi = ProjectsApi;
-    exports.ReasoningApi = ReasoningApi;
-    exports.SearchApi = SearchApi;
-    exports.SseClient = SseClient;
-    exports.VERSION = VERSION;
-    exports.WebSocketClient = WebSocketClient;
-    exports.default = CodeSolverSDK;
-
-    Object.defineProperty(exports, '__esModule', { value: true });
-
-}));
-//# sourceMappingURL=code-solver-sdk.js.map