orquesta-cli 0.2.100 → 0.2.102

package/dist/core/llm/llm-client.d.ts

@@ -44,7 +44,7 @@ export declare class LLMClient {
     private model;
     private modelName;
     private triedBatutaFallback;
-    private currentAbortController;
+    private activeControllers;
     private isInterrupted;
     onStreamingContent: ((token: string) => void) | null;
     private static readonly DEFAULT_MAX_RETRIES;

package/dist/core/llm/llm-client.js

@@ -123,7 +123,7 @@ export class LLMClient {
     model;
     modelName;
     triedBatutaFallback = false;
-    currentAbortController = null;
+    activeControllers = new Set();
     isInterrupted = false;
     onStreamingContent = null;
     static DEFAULT_MAX_RETRIES = 3;
@@ -220,6 +220,8 @@ export class LLMClient {
             maxRetries
         });
         const url = '/chat/completions';
+        let controller = null;
+        let gapTimedOut = false;
         try {
             logger.flow('Starting message preprocessing');
             const modelId = options.model || this.model;
@@ -251,13 +253,14 @@ export class LLMClient {
                 logger.llmRequest(processedMessages, modelId, options.tools);
             }
             logger.startTimer('llm-api-call');
-            this.currentAbortController = new AbortController();
+            controller = new AbortController();
+            this.activeControllers.add(controller);
             let response;
             if (this.onStreamingContent) {
                 const streamRequestBody = { ...requestBody, stream: true };
                 const streamResp = await this.axiosInstance.post(url, streamRequestBody, {
                     responseType: 'stream',
-                    signal: this.currentAbortController.signal,
+                    signal: controller.signal,
                     headers: buildPerRequestHeaders(),
                 });
                 captureBatutaHeaders(streamResp.headers);
@@ -270,62 +273,80 @@ export class LLMClient {
                 const toolCallsMap = new Map();
                 let responseId = '';
                 let responseModel = '';
-                for await (const chunk of stream) {
-                    if (this.isInterrupted) {
-                        throw new Error('INTERRUPTED');
-                    }
-                    buffer += chunk.toString();
-                    const lines = buffer.split('\n');
-                    buffer = lines.pop() || '';
-                    for (const line of lines) {
-                        const trimmed = line.trim();
-                        if (!trimmed || trimmed === 'data: [DONE]')
-                            continue;
-                        if (!trimmed.startsWith('data: '))
-                            continue;
+                const GAP_MS = Number(process.env['ORQUESTA_STREAM_GAP_MS']) || 45000;
+                let lastChunkAt = Date.now();
+                const gapTimer = setInterval(() => {
+                    if (Date.now() - lastChunkAt > GAP_MS) {
+                        gapTimedOut = true;
+                        clearInterval(gapTimer);
                         try {
-                            const data = JSON.parse(trimmed.slice(6));
-                            if (data.id)
-                                responseId = data.id;
-                            if (data.model)
-                                responseModel = data.model;
-                            const choice = data.choices?.[0];
-                            if (!choice)
+                            controller?.abort();
+                        }
+                        catch { }
+                    }
+                }, 5000);
+                gapTimer.unref?.();
+                try {
+                    for await (const chunk of stream) {
+                        lastChunkAt = Date.now();
+                        if (this.isInterrupted) {
+                            throw new Error('INTERRUPTED');
+                        }
+                        buffer += chunk.toString();
+                        const lines = buffer.split('\n');
+                        buffer = lines.pop() || '';
+                        for (const line of lines) {
+                            const trimmed = line.trim();
+                            if (!trimmed || trimmed === 'data: [DONE]')
                                 continue;
-                            if (choice.finish_reason)
-                                finishReason = choice.finish_reason;
-                            const delta = choice.delta;
-                            if (!delta)
+                            if (!trimmed.startsWith('data: '))
                                 continue;
-                            if (delta.role)
-                                role = delta.role;
-                            if (delta.content) {
-                                contentAccum += delta.content;
-                                this.onStreamingContent(delta.content);
-                            }
-                            if (delta.reasoning) {
-                                reasoningAccum += delta.reasoning;
-                            }
-                            if (delta.tool_calls) {
-                                for (const tc of delta.tool_calls) {
-                                    const idx = tc.index ?? 0;
-                                    if (!toolCallsMap.has(idx)) {
-                                        toolCallsMap.set(idx, { id: tc.id || '', type: 'function', function: { name: '', arguments: '' } });
+                            try {
+                                const data = JSON.parse(trimmed.slice(6));
+                                if (data.id)
+                                    responseId = data.id;
+                                if (data.model)
+                                    responseModel = data.model;
+                                const choice = data.choices?.[0];
+                                if (!choice)
+                                    continue;
+                                if (choice.finish_reason)
+                                    finishReason = choice.finish_reason;
+                                const delta = choice.delta;
+                                if (!delta)
+                                    continue;
+                                if (delta.role)
+                                    role = delta.role;
+                                if (delta.content) {
+                                    contentAccum += delta.content;
+                                    this.onStreamingContent(delta.content);
+                                }
+                                if (delta.reasoning) {
+                                    reasoningAccum += delta.reasoning;
+                                }
+                                if (delta.tool_calls) {
+                                    for (const tc of delta.tool_calls) {
+                                        const idx = tc.index ?? 0;
+                                        if (!toolCallsMap.has(idx)) {
+                                            toolCallsMap.set(idx, { id: tc.id || '', type: 'function', function: { name: '', arguments: '' } });
+                                        }
+                                        const existing = toolCallsMap.get(idx);
+                                        if (tc.id)
+                                            existing.id = tc.id;
+                                        if (tc.function?.name)
+                                            existing.function.name += tc.function.name;
+                                        if (tc.function?.arguments)
+                                            existing.function.arguments += tc.function.arguments;
                                     }
-                                    const existing = toolCallsMap.get(idx);
-                                    if (tc.id)
-                                        existing.id = tc.id;
-                                    if (tc.function?.name)
-                                        existing.function.name += tc.function.name;
-                                    if (tc.function?.arguments)
-                                        existing.function.arguments += tc.function.arguments;
                                 }
                             }
+                            catch { }
                         }
-                        catch { }
                     }
                 }
-                this.currentAbortController = null;
+                finally {
+                    clearInterval(gapTimer);
+                }
                 const toolCalls = Array.from(toolCallsMap.values())
                     .filter(tc => tc.id && tc.function.name)
                     .map(tc => ({ id: tc.id, type: 'function', function: { name: tc.function.name, arguments: tc.function.arguments } }));
@@ -350,10 +371,9 @@ export class LLMClient {
             }
             else {
                 const httpResp = await this.axiosInstance.post(url, requestBody, {
-                    signal: this.currentAbortController.signal,
+                    signal: controller.signal,
                     headers: buildPerRequestHeaders(),
                 });
-                this.currentAbortController = null;
                 response = { data: httpResp.data, status: httpResp.status, statusText: httpResp.statusText, headers: httpResp.headers };
                 captureBatutaHeaders(response.headers);
             }
@@ -397,7 +417,11 @@ export class LLMClient {
             return response.data;
         }
         catch (error) {
-            this.currentAbortController = null;
+            if (gapTimedOut) {
+                logger.flow('Stream stalled — gap watchdog aborted the request');
+                logger.exit('chatCompletion', { success: false, stalled: true });
+                throw new Error('Upstream stalled: no streaming data received within the gap window. Try again or switch endpoint.');
+            }
             if (axios.isCancel(error) || (error instanceof Error && error.name === 'CanceledError')) {
                 logger.flow('API call canceled (user interrupt)');
                 logger.exit('chatCompletion', { success: false, aborted: true });
@@ -444,14 +468,21 @@ export class LLMClient {
                 body: options,
             });
         }
+        finally {
+            if (controller)
+                this.activeControllers.delete(controller);
+        }
     }
     abort() {
         logger.flow('LLM interrupt - Stopping all operations');
         this.isInterrupted = true;
-        if (this.currentAbortController) {
-            this.currentAbortController.abort();
-            this.currentAbortController = null;
+        for (const controller of this.activeControllers) {
+            try {
+                controller.abort();
+            }
+            catch { }
         }
+        this.activeControllers.clear();
     }
     checkInterrupted() {
         return this.isInterrupted;
@@ -460,7 +491,7 @@ export class LLMClient {
         this.isInterrupted = false;
     }
     isRequestActive() {
-        return this.currentAbortController !== null;
+        return this.activeControllers.size > 0;
     }
     isConnectionError(error) {
         if (!axios.isAxiosError(error))
@@ -521,6 +552,7 @@ export class LLMClient {
     }
     async *chatCompletionStream(options) {
         const url = '/chat/completions';
+        let controller = null;
         try {
             const modelId = options.model || this.model;
             const processedMessages = options.messages ?
@@ -543,10 +575,11 @@ export class LLMClient {
                 max_tokens: requestBody.max_tokens,
             });
             logger.verbose('Full Streaming Request Body', requestBody);
-            this.currentAbortController = new AbortController();
+            controller = new AbortController();
+            this.activeControllers.add(controller);
             const response = await this.axiosInstance.post(url, requestBody, {
                 responseType: 'stream',
-                signal: this.currentAbortController.signal,
+                signal: controller.signal,
                 headers: buildPerRequestHeaders(),
             });
             captureBatutaHeaders(response.headers);
@@ -594,7 +627,8 @@ export class LLMClient {
                 }
             }
             finally {
-                this.currentAbortController = null;
+                if (controller)
+                    this.activeControllers.delete(controller);
             }
             logger.debug('Streaming response completed', { chunkCount });
         }
@@ -605,6 +639,10 @@ export class LLMClient {
                 body: options,
             });
         }
+        finally {
+            if (controller)
+                this.activeControllers.delete(controller);
+        }
     }
     async sendMessage(userMessage, systemPrompt) {
         logger.enter('sendMessage', {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orquesta-cli",
-  "version": "0.2.100",
+  "version": "0.2.102",
   "description": "Orquesta CLI - AI-powered coding assistant with team collaboration",
   "type": "module",
   "main": "dist/index.js",