solver-sdk 10.4.7 → 10.4.9

package/dist/cjs/api/chat-api/index.js

@@ -10,9 +10,31 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChatApi = void 0;
 const stream_utils_1 = require("./stream-utils");
@@ -25,6 +47,103 @@ function generateId(length = 10) {
 // Экспортируем все типы и интерфейсы для внешнего использования
 __exportStar(require("./models"), exports);
 __exportStar(require("./interfaces"), exports);
+/**
+ * 🔧 WorkAI: Internal Persistent Connection Implementation
+ */
+class PersistentSSEConnectionImpl {
+    constructor(id, sessionId, closeCallback) {
+        this.isConnected = false;
+        this.lastPing = 0;
+        this.createdAt = Date.now();
+        this.eventHandlers = new Map();
+        this.reconnectAttempts = 0;
+        this.maxReconnectAttempts = 3;
+        this.id = id;
+        this.sessionId = sessionId;
+        this.closeCallback = closeCallback;
+        this.readyPromise = new Promise((resolve, reject) => {
+            this.resolveReady = resolve;
+            this.rejectReady = reject;
+        });
+    }
+    async waitForReady() {
+        return this.readyPromise;
+    }
+    async close(reason = 'client_request') {
+        if (!this.isConnected) {
+            return;
+        }
+        this.isConnected = false;
+        this.emit('close', { reason });
+        if (this.closeCallback) {
+            await this.closeCallback(reason);
+        }
+    }
+    on(event, callback) {
+        if (!this.eventHandlers.has(event)) {
+            this.eventHandlers.set(event, new Set());
+        }
+        this.eventHandlers.get(event).add(callback);
+    }
+    off(event, callback) {
+        const handlers = this.eventHandlers.get(event);
+        if (handlers) {
+            handlers.delete(callback);
+        }
+    }
+    // Internal methods
+    markReady() {
+        this.isConnected = true;
+        this.reconnectAttempts = 0; // Reset on successful connection
+        this.resolveReady();
+    }
+    markFailed(error) {
+        this.isConnected = false;
+        this.rejectReady(error);
+        // Auto-reconnect with exponential backoff
+        this.attemptReconnect();
+    }
+    updatePing(timestamp) {
+        this.lastPing = timestamp;
+        this.emit('ping', { timestamp });
+    }
+    setReconnectCallback(callback) {
+        this.reconnectCallback = callback;
+    }
+    async attemptReconnect() {
+        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+            console.error(`❌ Max reconnect attempts (${this.maxReconnectAttempts}) reached`);
+            return;
+        }
+        this.reconnectAttempts++;
+        const backoffDelay = Math.min(1000 * Math.pow(2, this.reconnectAttempts - 1), 4000);
+        console.log(`🔄 Reconnect attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts} after ${backoffDelay}ms`);
+        this.emit('reconnecting', { attempt: this.reconnectAttempts });
+        await new Promise(resolve => setTimeout(resolve, backoffDelay));
+        if (this.reconnectCallback) {
+            try {
+                await this.reconnectCallback();
+            }
+            catch (error) {
+                console.error(`❌ Reconnect failed:`, error);
+                // Will retry again on next error
+            }
+        }
+    }
+    emit(event, data) {
+        const handlers = this.eventHandlers.get(event);
+        if (handlers) {
+            handlers.forEach(handler => {
+                try {
+                    handler(data);
+                }
+                catch (error) {
+                    console.error(`Error in event handler for ${event}:`, error);
+                }
+            });
+        }
+    }
+}
 /**
  * API для работы с чатом с поддержкой Anthropic Extended Thinking
  */
@@ -82,10 +201,62 @@ class ChatApi extends cancel_methods_1.ChatCancelMethods {
                 if (debugLevel !== 'silent') {
                     console.error(`❌ ${message}`);
                 }
+            },
+            debug: (message) => {
+                const debugLevel = this.options.debug;
+                if (debugLevel === 'verbose' || debugLevel === 'debug') {
+                    console.log(`🔍 ${message}`);
+                }
             }
         };
         this.options = options;
     }
+    /**
+     * 🔧 WorkAI: Выполняет streaming GET запрос используя нативный fetch
+     * Используется для persistent SSE connections, где axios не работает
+     *
+     * @param url - Полный URL для запроса
+     * @param headers - HTTP заголовки
+     * @returns Promise<Response> с ReadableStream body
+     *
+     * Best practice from undici docs: Node 18+ has global fetch
+     */
+    async fetchStream(url, headers) {
+        console.log(`[SDK] 🔌 fetchStream: Attempting fetch to ${url}`);
+        console.log(`[SDK] 🔌 fetchStream: globalThis.fetch available: ${typeof globalThis.fetch !== 'undefined'}`);
+        // Node 18+ has native fetch support
+        if (typeof globalThis.fetch !== 'undefined') {
+            console.log(`[SDK] 🔌 fetchStream: Using globalThis.fetch`);
+            try {
+                const response = await globalThis.fetch(url, {
+                    method: 'GET',
+                    headers
+                });
+                console.log(`[SDK] ✅ fetchStream: Response received, status: ${response.status}, hasBody: ${!!response.body}`);
+                return response;
+            }
+            catch (error) {
+                console.error(`[SDK] ❌ fetchStream: globalThis.fetch failed:`, error.message);
+                throw error;
+            }
+        }
+        // Fallback для Node 16 через dynamic import
+        console.log(`[SDK] 🔌 fetchStream: globalThis.fetch not available, trying node-fetch`);
+        try {
+            const { default: nodeFetch } = await Promise.resolve().then(() => __importStar(require('node-fetch')));
+            console.log(`[SDK] ✅ fetchStream: node-fetch imported`);
+            const response = await nodeFetch(url, {
+                method: 'GET',
+                headers
+            });
+            console.log(`[SDK] ✅ fetchStream: node-fetch response received, status: ${response.status}`);
+            return response;
+        }
+        catch (error) {
+            console.error(`[SDK] ❌ fetchStream: node-fetch failed:`, error.message);
+            throw new Error(`Fetch API unavailable: ${error.message}. Please use Node.js 18+ or install node-fetch`);
+        }
+    }
     /**
      * Отправляет сообщение в чат и получает ответ от модели
      * @param {ChatMessage[]} messages Массив сообщений для отправки
@@ -367,6 +538,35 @@ class ChatApi extends cancel_methods_1.ChatCancelMethods {
         const messages = [{ role: 'user', content: prompt }];
         yield* this.streamChat(messages, options);
     }
+    /**
+     * 🔧 WorkAI: Send continuation via persistent SSE connection
+     * Uses existing connection instead of creating new one
+     */
+    async *sendContinuationViaPersistent(connection, messages, options) {
+        if (!connection.isConnected) {
+            throw new Error('Persistent SSE connection is not active');
+        }
+        this.logger.info(`🔌 [CONTINUATION_VIA_PERSISTENT] Using connection: ${connection.id}`);
+        try {
+            const params = this.buildRequestParams(messages, {
+                ...options,
+                stream: true,
+                clientRequestId: connection.id,
+            });
+            params.beta = 'interleaved-thinking-2025-05-14';
+            const response = await this.httpClient.post('/api/v1/chat/continue', params);
+            this.logger.info(`✅ [CONTINUATION_VIA_PERSISTENT] Request sent, waiting for events via persistent SSE`);
+            // Events will arrive via the persistent SSE connection
+            // We need to yield them from connection, but connection doesn't expose events yet
+            // For now, return empty - будет реализовано когда connection будет слушать continuation события
+            // TODO: Implement event listening on PersistentSSEConnection
+            this.logger.warn('⚠️ [CONTINUATION_VIA_PERSISTENT] Event listening not yet implemented');
+        }
+        catch (error) {
+            this.logger.error(`❌ [CONTINUATION_VIA_PERSISTENT] Error: ${error.message}`);
+            throw error;
+        }
+    }
     /**
      * Отправляет continuation запрос для interleaved thinking
      */
@@ -794,97 +994,251 @@ class ChatApi extends cancel_methods_1.ChatCancelMethods {
         if (!clientRequestId) {
             throw new Error('clientRequestId is required for subscribeToResponse');
         }
+        // 🔧 WorkAI: If persistent connection provided, use it instead
+        if (options.persistentConnection && options.persistentConnection.isConnected) {
+            this.logger.info(`🔌 [PRE_SUBSCRIBE] Using persistent connection: ${clientRequestId}`);
+            // TODO: Yield events from persistent connection
+            // For now, fallback to direct subscription
+            this.logger.warn(`⚠️ [PRE_SUBSCRIBE] Persistent connection event streaming not yet implemented`);
+        }
         const endpoint = `/api/v1/chat/subscribe?clientRequestId=${encodeURIComponent(clientRequestId)}`;
         this.logger.info(`🔌 [PRE_SUBSCRIBE] Connecting to SSE: ${clientRequestId}`);
-        try {
-            // Используем request с responseType='stream' для GET запроса с SSE
-            const response = await this.httpClient.request({
-                method: 'GET',
-                url: endpoint,
-                headers: {
-                    'X-Project-ID': options.projectId,
-                    'X-Client-Ready': 'true',
-                },
-                responseType: 'stream',
-            });
-            if (!response.body) {
-                throw new Error('No response body from subscribe endpoint');
+        // 🔧 WorkAI: Retry logic for "No response body" errors
+        let lastError = null;
+        const maxRetries = 1;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            if (attempt > 0) {
+                this.logger.warn(`🔄 [RETRY_SUBSCRIBE] Attempt ${attempt + 1}/${maxRetries + 1} after 500ms`);
+                await new Promise(resolve => setTimeout(resolve, 500));
             }
-            const reader = response.body.getReader();
-            const decoder = new TextDecoder();
-            let subscribed = false;
-            // 🔧 FIX: Буфер для накопления неполных SSE строк
-            let lineBuffer = '';
             try {
-                while (true) {
-                    const { done, value } = await reader.read();
-                    if (done) {
-                        this.logger.info(`🔌 [PRE_SUBSCRIBE] SSE stream ended: ${clientRequestId}`);
-                        break;
-                    }
-                    const chunk = decoder.decode(value, { stream: true });
-                    // 🔧 FIX: Добавляем к буферу, а не парсим сразу
-                    lineBuffer += chunk;
-                    // Ищем полные строки (заканчиваются на \n)
-                    const lines = lineBuffer.split('\n');
-                    // 🔧 FIX: Последняя "строка" может быть неполной - сохраняем в буфер
-                    lineBuffer = lines.pop() || '';
-                    for (const line of lines) {
-                        if (!line.trim() || !line.startsWith('data: '))
-                            continue;
-                        const data = line.slice(6).trim();
-                        if (!data)
-                            continue;
-                        try {
-                            const event = JSON.parse(data);
-                            // Callback when subscribed
-                            if (event.type === 'subscribed' && !subscribed) {
-                                subscribed = true;
-                                this.logger.info(`🔌 [PRE_SUBSCRIBE] Subscribed successfully: ${clientRequestId}`);
-                                if (options.onSubscribed) {
-                                    options.onSubscribed();
-                                }
-                            }
-                            // Skip heartbeat events
-                            if (event.type === 'heartbeat') {
+                // Используем request с responseType='stream' для GET запроса с SSE
+                const response = await this.httpClient.request({
+                    method: 'GET',
+                    url: endpoint,
+                    headers: {
+                        'X-Project-ID': options.projectId,
+                        'X-Client-Ready': 'true',
+                    },
+                    responseType: 'stream',
+                });
+                // 🔍 DEBUG: Log response details
+                this.logger.debug(`🔌 [PRE_SUBSCRIBE] Response status: ${response.status}`);
+                this.logger.debug(`🔌 [PRE_SUBSCRIBE] Response headers: ${JSON.stringify(response.headers)}`);
+                this.logger.debug(`🔌 [PRE_SUBSCRIBE] Response body present: ${!!response.body}`);
+                if (!response.body) {
+                    this.logger.error(`❌ [PRE_SUBSCRIBE] No response body! Full response: ${JSON.stringify({
+                        status: response.status,
+                        statusText: response.statusText,
+                        headers: response.headers,
+                        bodyType: typeof response.body,
+                    })}`);
+                    throw new Error('No response body from subscribe endpoint');
+                }
+                const reader = response.body.getReader();
+                const decoder = new TextDecoder();
+                let subscribed = false;
+                // 🔧 FIX: Буфер для накопления неполных SSE строк
+                let lineBuffer = '';
+                try {
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done) {
+                            this.logger.info(`🔌 [PRE_SUBSCRIBE] SSE stream ended: ${clientRequestId}`);
+                            break;
+                        }
+                        const chunk = decoder.decode(value, { stream: true });
+                        // 🔧 FIX: Добавляем к буферу, а не парсим сразу
+                        lineBuffer += chunk;
+                        // Ищем полные строки (заканчиваются на \n)
+                        const lines = lineBuffer.split('\n');
+                        // 🔧 FIX: Последняя "строка" может быть неполной - сохраняем в буфер
+                        lineBuffer = lines.pop() || '';
+                        for (const line of lines) {
+                            if (!line.trim() || !line.startsWith('data: '))
                                 continue;
+                            const data = line.slice(6).trim();
+                            if (!data)
+                                continue;
+                            try {
+                                const event = JSON.parse(data);
+                                // Callback when subscribed
+                                if (event.type === 'subscribed' && !subscribed) {
+                                    subscribed = true;
+                                    this.logger.info(`🔌 [PRE_SUBSCRIBE] Subscribed successfully: ${clientRequestId}`);
+                                    if (options.onSubscribed) {
+                                        options.onSubscribed();
+                                    }
+                                }
+                                // Skip heartbeat events
+                                if (event.type === 'heartbeat') {
+                                    continue;
+                                }
+                                // Timeout event
+                                if (event.type === 'timeout') {
+                                    this.logger.warn(`🔌 [PRE_SUBSCRIBE] Timeout: ${clientRequestId}`);
+                                    break;
+                                }
+                                // Convert to ChatStreamChunk and yield
+                                const streamChunk = {
+                                    type: event.type,
+                                    ...event,
+                                };
+                                yield streamChunk;
+                                // End on message_stop
+                                if (event.type === 'message_stop') {
+                                    this.logger.info(`🔌 [PRE_SUBSCRIBE] Message stop received: ${clientRequestId}`);
+                                    break;
+                                }
                             }
-                            // Timeout event
-                            if (event.type === 'timeout') {
-                                this.logger.warn(`🔌 [PRE_SUBSCRIBE] Timeout: ${clientRequestId}`);
-                                break;
-                            }
-                            // Convert to ChatStreamChunk and yield
-                            const streamChunk = {
-                                type: event.type,
-                                ...event,
-                            };
-                            yield streamChunk;
-                            // End on message_stop
-                            if (event.type === 'message_stop') {
-                                this.logger.info(`🔌 [PRE_SUBSCRIBE] Message stop received: ${clientRequestId}`);
-                                break;
+                            catch (parseError) {
+                                this.logger.warn(`🔌 [PRE_SUBSCRIBE] Parse error: ${parseError}`);
                             }
                         }
-                        catch (parseError) {
-                            this.logger.warn(`🔌 [PRE_SUBSCRIBE] Parse error: ${parseError}`);
-                        }
                     }
                 }
+                finally {
+                    reader.releaseLock();
+                }
+                // Success - break retry loop
+                return;
             }
-            finally {
-                reader.releaseLock();
+            catch (error) {
+                lastError = error;
+                // 🔌 WorkAI: Graceful handling для stream abort
+                if (error.name === 'StreamAbortedError' ||
+                    (error.message && error.message.includes('aborted'))) {
+                    this.logger.info(`🔄 [PRE_SUBSCRIBE] SSE stream aborted (likely replaced): ${clientRequestId}`);
+                    // НЕ выбрасываем ошибку - это нормальное завершение
+                    return;
+                }
+                // 🔄 WorkAI: Retry for "No response body" errors
+                if (error.message && error.message.includes('No response body')) {
+                    if (attempt < maxRetries) {
+                        this.logger.warn(`⚠️ [PRE_SUBSCRIBE] No response body, will retry: ${clientRequestId}`);
+                        continue; // Try again
+                    }
+                }
+                this.logger.error(`🔌 [PRE_SUBSCRIBE] Error: ${error.message}`);
+                throw error;
             }
         }
-        catch (error) {
-            // 🔌 WorkAI: Graceful handling для stream abort
-            if (error.name === 'StreamAbortedError' ||
-                (error.message && error.message.includes('aborted'))) {
-                this.logger.info(`🔄 [PRE_SUBSCRIBE] SSE stream aborted (likely replaced): ${clientRequestId}`);
-                // НЕ выбрасываем ошибку - это нормальное завершение
-                return;
+        // If we exhausted all retries
+        if (lastError) {
+            this.logger.error(`❌ [PRE_SUBSCRIBE] All ${maxRetries + 1} attempts failed: ${lastError.message}`);
+            throw lastError;
+        }
+    }
+    /**
+     * 🔧 WorkAI: Open persistent SSE connection for chat session
+     */
+    async openPersistentSSE(sessionId, clientRequestId, options) {
+        const endpoint = `/api/v1/chat/subscribe/persistent?sessionId=${encodeURIComponent(sessionId)}&clientRequestId=${encodeURIComponent(clientRequestId)}`;
+        this.logger.info(`🔌 [PERSISTENT_SSE] Opening: ${clientRequestId}`);
+        const connection = new PersistentSSEConnectionImpl(clientRequestId, sessionId, async (reason) => {
+            try {
+                await this.httpClient.post('/api/v1/chat/subscribe/close', { sessionId, reason });
+            }
+            catch (error) {
+                this.logger.error(`❌ [PERSISTENT_SSE] Close error: ${error.message}`);
+            }
+        });
+        try {
+            // 🔧 WorkAI: Получаем auth token динамически для 401 retry support
+            console.log(`[SDK] 🔌 openPersistentSSE: Getting auth token...`);
+            let authToken = null;
+            if (typeof this.httpClient.options?.getAuthToken === 'function') {
+                try {
+                    authToken = await Promise.resolve(this.httpClient.options.getAuthToken());
+                    console.log(`[SDK] ✅ openPersistentSSE: Auth token obtained`);
+                }
+                catch (error) {
+                    console.log(`[SDK] ⚠️ openPersistentSSE: Failed to get auth token: ${error.message}`);
+                    this.logger.warn(`⚠️ [PERSISTENT_SSE] Failed to get auth token: ${error.message}`);
+                }
             }
-            this.logger.error(`🔌 [PRE_SUBSCRIBE] Error: ${error.message}`);
+            // Формируем headers с auth token
+            const headers = {
+                'X-Project-ID': options.projectId,
+            };
+            if (authToken) {
+                headers['Authorization'] = `Bearer ${authToken}`;
+            }
+            // Формируем полный URL (baseURL + endpoint)
+            const baseURL = this.httpClient.getBaseURL?.() || 'http://localhost:3000';
+            const fullUrl = `${baseURL}${endpoint}`;
+            console.log(`[SDK] 🔌 openPersistentSSE: Calling fetchStream to ${fullUrl}`);
+            // 🔧 WorkAI: Используем нативный fetch вместо axios для streaming
+            // Best practice: fetch нативно возвращает Response с ReadableStream body
+            const response = await this.fetchStream(fullUrl, headers);
+            // Проверка статуса (401 retry будет добавлен отдельно если потребуется)
+            console.log(`[SDK] 📡 openPersistentSSE: Response status: ${response.status}`);
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            if (!response.body) {
+                console.error(`[SDK] ❌ openPersistentSSE: No response body!`);
+                throw new Error('No response body from persistent SSE');
+            }
+            console.log(`[SDK] ✅ openPersistentSSE: Response body available, starting SSE parsing...`);
+            // 🔧 SSE parsing согласно best practices (ofetch + undici)
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = '';
+            // Асинхронно читаем stream
+            (async () => {
+                try {
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        // Декодируем с stream: true для поддержки multi-byte символов
+                        buffer += decoder.decode(value, { stream: true });
+                        const lines = buffer.split('\n');
+                        // Оставляем неполную строку в buffer (best practice)
+                        buffer = lines.pop() || '';
+                        for (const line of lines) {
+                            if (line.startsWith('data: ')) {
+                                try {
+                                    const event = JSON.parse(line.slice(6));
+                                    if (event.type === 'persistent_ready') {
+                                        connection.markReady();
+                                    }
+                                    else if (event.type === 'ping') {
+                                        connection.updatePing(event.timestamp);
+                                    }
+                                    else if (event.type === 'connection_closed') {
+                                        connection.isConnected = false;
+                                        break;
+                                    }
+                                }
+                                catch (e) {
+                                    // Ignore JSON parse errors for non-JSON SSE events
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    // Ignore abort errors (normal when connection closes)
+                    if (!error.message?.includes('aborted')) {
+                        connection.emit('error', error);
+                        connection.markFailed(error);
+                    }
+                }
+                finally {
+                    reader.releaseLock();
+                }
+            })();
+            // Ждем persistent_ready event с timeout
+            await Promise.race([
+                connection.waitForReady(),
+                new Promise((_, reject) => setTimeout(() => reject(new Error('Persistent SSE timeout after 10s')), 10000)),
+            ]);
+            return connection;
+        }
+        catch (error) {
+            connection.markFailed(error);
             throw error;
         }
     }