solver-sdk 1.0.1

package/dist/esm/index.js

@@ -0,0 +1,1882 @@
+import axios from 'axios';
+import { EventSourcePolyfill } from 'event-source-polyfill';
+
+/**
+ * Определение типа среды выполнения
+ * @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/projects');
+    }
+    /**
+     * Получает проект по идентификатору
+     * @param {string} projectId Идентификатор проекта
+     * @returns {Promise<Project>} Проект
+     */
+    async getProject(projectId) {
+        return this.httpClient.get(`/api/projects/${projectId}`);
+    }
+    /**
+     * Создает новый проект
+     * @param {string} name Название проекта
+     * @param {string} path Путь к проекту
+     * @returns {Promise<Project>} Созданный проект
+     */
+    async createProject(name, path) {
+        return this.httpClient.post('/api/projects', { name, path });
+    }
+    /**
+     * Обновляет проект
+     * @param {string} projectId Идентификатор проекта
+     * @param {Partial<Pick<Project, 'name' | 'path'>>} data Данные для обновления
+     * @returns {Promise<Project>} Обновленный проект
+     */
+    async updateProject(projectId, data) {
+        return this.httpClient.put(`/api/projects/${projectId}`, data);
+    }
+    /**
+     * Удаляет проект
+     * @param {string} projectId Идентификатор проекта
+     * @returns {Promise<void>}
+     */
+    async deleteProject(projectId) {
+        return this.httpClient.delete(`/api/projects/${projectId}`);
+    }
+    /**
+     * Запускает индексацию проекта
+     * @param {string} projectId Идентификатор проекта
+     * @returns {Promise<Project>} Обновленный проект
+     */
+    async indexProject(projectId) {
+        return this.httpClient.post(`/api/projects/${projectId}/index`);
+    }
+    /**
+     * Останавливает индексацию проекта
+     * @param {string} projectId Идентификатор проекта
+     * @returns {Promise<Project>} Обновленный проект
+     */
+    async stopIndexing(projectId) {
+        return this.httpClient.post(`/api/projects/${projectId}/stop-indexing`);
+    }
+    /**
+     * Получает статус индексации проекта
+     * @param {string} projectId Идентификатор проекта
+     * @returns {Promise<Project>} Проект с обновленным статусом индексации
+     */
+    async getIndexingStatus(projectId) {
+        return this.httpClient.get(`/api/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/projects/${projectId}/search`, params);
+    }
+    /**
+     * Выполняет семантический поиск кода в проекте
+     * @param {string} projectId Идентификатор проекта
+     * @param {SearchCodeParams} params Параметры поиска
+     * @returns {Promise<SearchResults>} Результаты поиска
+     */
+    async semanticSearch(projectId, params) {
+        return this.httpClient.post(`/api/projects/${projectId}/semantic-search`, params);
+    }
+    /**
+     * Получает популярные поисковые запросы
+     * @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);
+    }
+    /**
+     * Получает рассуждение по идентификатору
+     * @param {string} reasoningId Идентификатор рассуждения
+     * @returns {Promise<Reasoning>} Рассуждение
+     */
+    async getReasoning(reasoningId) {
+        return this.httpClient.get(`/api/reasonings/${reasoningId}`);
+    }
+    /**
+     * Создает новое рассуждение
+     * @param {CreateReasoningParams} params Параметры рассуждения
+     * @returns {Promise<Reasoning>} Созданное рассуждение
+     */
+    async createReasoning(params) {
+        return this.httpClient.post('/api/reasonings', params);
+    }
+    /**
+     * Запускает процесс рассуждения
+     * @param {string} reasoningId Идентификатор рассуждения
+     * @returns {Promise<Reasoning>} Рассуждение
+     */
+    async startReasoning(reasoningId) {
+        return this.httpClient.post(`/api/reasonings/${reasoningId}/start`);
+    }
+    /**
+     * Останавливает процесс рассуждения
+     * @param {string} reasoningId Идентификатор рассуждения
+     * @returns {Promise<Reasoning>} Рассуждение
+     */
+    async stopReasoning(reasoningId) {
+        return this.httpClient.post(`/api/reasonings/${reasoningId}/stop`);
+    }
+    /**
+     * Удаляет рассуждение
+     * @param {string} reasoningId Идентификатор рассуждения
+     * @returns {Promise<void>}
+     */
+    async deleteReasoning(reasoningId) {
+        return this.httpClient.delete(`/api/reasonings/${reasoningId}`);
+    }
+    /**
+     * Получает промежуточные мысли рассуждения
+     * @param {string} reasoningId Идентификатор рассуждения
+     * @returns {Promise<string[]>} Промежуточные мысли
+     */
+    async getThinking(reasoningId) {
+        return this.httpClient.get(`/api/reasonings/${reasoningId}/thinking`);
+    }
+}
+
+/**
+ * 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
+ */
+var WebSocketNamespace;
+(function (WebSocketNamespace) {
+    /** Пространство имен для рассуждений */
+    WebSocketNamespace["REASONING"] = "reasoning";
+    /** Пространство имен для индексации */
+    WebSocketNamespace["INDEXING"] = "indexing";
+    /** Пространство имен для уведомлений */
+    WebSocketNamespace["NOTIFICATIONS"] = "notifications";
+})(WebSocketNamespace || (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(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(WebSocketNamespace.INDEXING, { projectId: id });
+    }
+    /**
+     * Подключается к уведомлениям
+     * @returns {Promise<void>}
+     */
+    async connectToNotifications() {
+        // Подключаемся к пространству имен
+        await this.connect(WebSocketNamespace.NOTIFICATIONS);
+    }
+    /**
+     * Отключается от пространства имен
+     * @param {WebSocketNamespace} namespace Пространство имен
+     */
+    disconnect(namespace) {
+        const client = this.clients.get(namespace);
+        if (client) {
+            client.close();
+            this.clients.delete(namespace);
+        }
+        // Сбрасываем активные сессии
+        if (namespace === WebSocketNamespace.REASONING) {
+            this.activeReasoningId = null;
+        }
+        else if (namespace === 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(WebSocketNamespace.REASONING, eventType, data);
+    }
+    /**
+     * Отправляет сообщение в активную сессию индексации
+     * @param {string} eventType Тип события
+     * @param {any} [data] Данные сообщения
+     * @returns {boolean} Успешно ли отправлено сообщение
+     */
+    sendToIndexing(eventType, data) {
+        if (!this.activeProjectId) {
+            throw new Error('Не подключен к сессии индексации');
+        }
+        return this.send(WebSocketNamespace.INDEXING, eventType, data);
+    }
+    /**
+     * Отправляет сообщение в уведомления
+     * @param {string} eventType Тип события
+     * @param {any} [data] Данные сообщения
+     * @returns {boolean} Успешно ли отправлено сообщение
+     */
+    sendToNotifications(eventType, data) {
+        return this.send(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(WebSocketNamespace.REASONING);
+    }
+    /**
+     * Проверяет, подключен ли клиент к пространству имен индексации
+     * @returns {boolean} Статус подключения
+     */
+    isConnectedToIndexing() {
+        return this.isConnected(WebSocketNamespace.INDEXING);
+    }
+    /**
+     * Проверяет, подключен ли клиент к пространству имен уведомлений
+     * @returns {boolean} Статус подключения
+     */
+    isConnectedToNotifications() {
+        return this.isConnected(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(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;
+// Проверяем, находимся ли мы в браузере
+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
+ */
+/**
+ * Уровень логирования
+ */
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["DEBUG"] = "debug";
+    LogLevel["INFO"] = "info";
+    LogLevel["WARN"] = "warn";
+    LogLevel["ERROR"] = "error";
+})(LogLevel || (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();
+ *   });
+ * }
+ * ```
+ */
+
+export { AgentsApi, CodeModificationApi, CodeSolverSDK, CodeSolverWebSocketClient, ContextApi, HttpClient, IndexingWebSocketClient, LogLevel, ProjectsApi, ReasoningApi, SearchApi, SseClient, VERSION, WebSocketClient, WebSocketNamespace, CodeSolverSDK as default };
+//# sourceMappingURL=index.js.map