solver-sdk 10.4.8 → 10.5.0

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");
@@ -36,6 +58,10 @@ class PersistentSSEConnectionImpl {
         this.eventHandlers = new Map();
         this.reconnectAttempts = 0;
         this.maxReconnectAttempts = 3;
+        // 🔧 WorkAI: Chat events queue for persistent connection
+        this.chatEventsQueue = [];
+        this.chatEventsResolvers = [];
+        this.chatEventsCompleted = false;
         this.id = id;
         this.sessionId = sessionId;
         this.closeCallback = closeCallback;
@@ -121,6 +147,52 @@ class PersistentSSEConnectionImpl {
             });
         }
     }
+    // 🔧 WorkAI: Queue chat event for async generator
+    queueChatEvent(event) {
+        if (this.chatEventsResolvers.length > 0) {
+            // Someone is waiting - resolve immediately
+            const resolver = this.chatEventsResolvers.shift();
+            resolver(event);
+        }
+        else {
+            // Queue for later
+            this.chatEventsQueue.push(event);
+        }
+        // Also emit for listeners
+        this.emit('chat_event', event);
+    }
+    // 🔧 WorkAI: Stream chat events as async generator
+    async *streamChatEvents() {
+        while (!this.chatEventsCompleted || this.chatEventsQueue.length > 0) {
+            // Check queue first
+            if (this.chatEventsQueue.length > 0) {
+                yield this.chatEventsQueue.shift();
+                continue;
+            }
+            // Wait for next event
+            const event = await new Promise((resolve) => {
+                if (this.chatEventsCompleted) {
+                    resolve(null);
+                }
+                else {
+                    this.chatEventsResolvers.push(resolve);
+                }
+            });
+            if (event === null) {
+                break;
+            }
+            yield event;
+        }
+    }
+    // 🔧 WorkAI: Mark chat events stream as complete
+    completeChatEvents() {
+        this.chatEventsCompleted = true;
+        // Resolve all pending resolvers with null
+        while (this.chatEventsResolvers.length > 0) {
+            const resolver = this.chatEventsResolvers.shift();
+            resolver(null);
+        }
+    }
 }
 /**
  * API для работы с чатом с поддержкой Anthropic Extended Thinking
@@ -189,6 +261,52 @@ class ChatApi extends cancel_methods_1.ChatCancelMethods {
         };
         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 Массив сообщений для отправки
@@ -926,139 +1044,143 @@ 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
+        // 🔧 WorkAI: If persistent connection provided and connected, yield events from it
         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`);
+            // Call onSubscribed callback immediately since connection already exists
+            if (options.onSubscribed) {
+                options.onSubscribed();
+            }
+            // Stream events from persistent connection
+            try {
+                for await (const event of options.persistentConnection.streamChatEvents()) {
+                    if (event === null) {
+                        break; // Stream completed
+                    }
+                    // Events from persistent connection are already in ChatStreamChunk format
+                    yield event;
+                }
+                this.logger.info(`🔌 [PERSISTENT_STREAM] Completed streaming from persistent connection`);
+                return; // Successfully streamed from persistent connection
+            }
+            catch (error) {
+                // 🚨 КРИТИЧНО: ошибка streaming из persistent connection
+                this.logger.error(`❌ [PERSISTENT_STREAM] CRITICAL ERROR streaming from persistent connection: ${error.message} | ` +
+                    `stack=${error.stack} | clientRequestId=${clientRequestId} | connectionId=${options.persistentConnection.id}`);
+                // 🚨 НЕ ДЕЛАЕМ FALLBACK! Если persistent connection сломан - это должно быть видно!
+                throw new Error(`Persistent SSE stream failed: ${error.message}. ` +
+                    `This indicates a problem with persistent connection lifecycle. ` +
+                    `Check backend routing and connection management.`);
+            }
         }
         const endpoint = `/api/v1/chat/subscribe?clientRequestId=${encodeURIComponent(clientRequestId)}`;
+        // 🚨 КРИТИЧНО: Если дошли сюда БЕЗ persistent connection - это проблема!
+        this.logger.error(`❌ [PRE_SUBSCRIBE] FALLBACK to regular /subscribe endpoint! ` +
+            `This means persistent connection is NOT working. ` +
+            `Multiple continuations WILL fail with "No response body" errors.`);
         this.logger.info(`🔌 [PRE_SUBSCRIBE] Connecting to SSE: ${clientRequestId}`);
-        // 🔧 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));
+        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',
+            });
+            // 🔍 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 {
-                // Используем 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;
+                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();
                                 }
                             }
-                            catch (parseError) {
-                                this.logger.warn(`🔌 [PRE_SUBSCRIBE] Parse error: ${parseError}`);
+                            // 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;
+                            }
+                        }
+                        catch (parseError) {
+                            this.logger.warn(`🔌 [PRE_SUBSCRIBE] Parse error: ${parseError}`);
                         }
                     }
                 }
-                finally {
-                    reader.releaseLock();
-                }
-                // Success - break retry loop
-                return;
             }
-            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;
+            finally {
+                reader.releaseLock();
             }
         }
-        // If we exhausted all retries
-        if (lastError) {
-            this.logger.error(`❌ [PRE_SUBSCRIBE] All ${maxRetries + 1} attempts failed: ${lastError.message}`);
-            throw lastError;
+        catch (error) {
+            // 🚨 КРИТИЧНО: Ошибка при fallback на /subscribe
+            this.logger.error(`❌ [PRE_SUBSCRIBE] Failed to subscribe to /subscribe endpoint: ${error.message} | ` +
+                `stack=${error.stack} | clientRequestId=${clientRequestId}`);
+            // 🔌 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; // Это нормально
+            }
+            // Для всех остальных ошибок - прокидываем наверх
+            throw error;
         }
     }
     /**
@@ -1076,45 +1198,93 @@ class ChatApi extends cancel_methods_1.ChatCancelMethods {
             }
         });
         try {
-            const response = await this.httpClient.request({
-                method: 'GET',
-                url: endpoint,
-                headers: { 'X-Project-ID': options.projectId },
-                responseType: 'stream',
-            });
-            if (!response.body)
+            // 🔧 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}`);
+                }
+            }
+            // Формируем 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')
+                                    // Handle connection lifecycle events
+                                    if (event.type === 'persistent_ready') {
                                         connection.markReady();
-                                    else if (event.type === 'ping')
+                                    }
+                                    else if (event.type === 'ping') {
                                         connection.updatePing(event.timestamp);
+                                    }
                                     else if (event.type === 'connection_closed') {
                                         connection.isConnected = false;
+                                        connection.completeChatEvents();
                                         break;
                                     }
+                                    // 🔧 WorkAI: Queue chat events (message_start, content_block_delta, etc.)
+                                    else if (event.type && event.type.startsWith('message_') ||
+                                        event.type === 'content_block_start' ||
+                                        event.type === 'content_block_delta' ||
+                                        event.type === 'content_block_stop' ||
+                                        event.type === 'error') {
+                                        connection.queueChatEvent(event);
+                                    }
+                                }
+                                catch (e) {
+                                    // Ignore JSON parse errors for non-JSON SSE events
                                 }
-                                catch (e) { }
                             }
                         }
                     }
                 }
                 catch (error) {
+                    // Ignore abort errors (normal when connection closes)
                     if (!error.message?.includes('aborted')) {
                         connection.emit('error', error);
                         connection.markFailed(error);
@@ -1124,9 +1294,10 @@ class ChatApi extends cancel_methods_1.ChatCancelMethods {
                     reader.releaseLock();
                 }
             })();
+            // Ждем persistent_ready event с timeout
             await Promise.race([
                 connection.waitForReady(),
-                new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout')), 10000)),
+                new Promise((_, reject) => setTimeout(() => reject(new Error('Persistent SSE timeout after 10s')), 10000)),
             ]);
             return connection;
         }