solver-sdk 1.0.3 → 1.0.5

package/dist/esm/index.js

@@ -1,1830 +1,24 @@
-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/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
- */
-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
+export { CodeSolverSDK } from './code-solver-sdk.js';
+// Экспорт API классов
+export { ProjectsApi } from './api/projects-api.js';
+export { SearchApi } from './api/search-api.js';
+export { ReasoningApi } from './api/reasoning-api.js';
+export { ContextApi } from './api/context-api.js';
+export { CodeModificationApi } from './api/code-modification-api.js';
+export { AgentsApi } from './api/agents-api.js';
+// Экспорт утилит
+export { HttpClient } from './utils/http-client.js';
+export { SseClient } from './utils/sse-client.js';
+export { WebSocketClient } from './utils/websocket-client.js';
+export { IndexingWebSocketClient } from './utils/indexing-websocket-client.js';
+export { CodeSolverWebSocketClient, WebSocketNamespace } from './utils/code-solver-websocket-client.js';
+// Экспорт типов
+export * from './models/types.js';
 // Версия SDK
-const VERSION = '1.0.0';
+export const VERSION = '1.0.0';
+// Экспорт по умолчанию для удобства использования
+export { CodeSolverSDK as default } from './code-solver-sdk.js';
 // Простой пример использования SDK
 /**
  * Пример использования SDK:
@@ -1889,7 +83,5 @@ const VERSION = '1.0.0';
  *   });
  * }
  * ```
- */
-
-export { AgentsApi, CodeModificationApi, CodeSolverSDK, CodeSolverWebSocketClient, ContextApi, HttpClient, IndexingWebSocketClient, LogLevel, ProjectsApi, ReasoningApi, SearchApi, SseClient, VERSION, WebSocketClient, WebSocketNamespace, CodeSolverSDK as default };
-//# sourceMappingURL=index.js.map
+ */ 
+//# sourceMappingURL=index.js.map