orquesta-cli 0.2.85 → 0.2.87

package/dist/core/config/config-manager.js

@@ -322,22 +322,23 @@ export class ConfigManager {
                 added++;
             }
         }
+        const serverDefaultId = orquestaEndpoints.find((e) => e.is_default === true)?.id;
+        const serverDefault = serverDefaultId ? config.endpoints.find((e) => e.id === serverDefaultId) : undefined;
+        const batuta = config.endpoints.find((e) => e.provider === 'batuta' || e.id === 'batuta-proxy');
         const currentExists = !!config.currentEndpoint && config.endpoints.some((e) => e.id === config.currentEndpoint);
-        if (!currentExists && config.endpoints.length > 0) {
-            const fallback = config.endpoints.find((e) => e.provider === 'batuta' || e.id === 'batuta-proxy') ||
-                config.endpoints[0];
-            config.currentEndpoint = fallback.id;
-            const enabledModel = fallback.models.find((m) => m.enabled) || fallback.models[0];
-            if (enabledModel)
-                config.currentModel = enabledModel.id;
+        const preferred = serverDefault || batuta || (!currentExists ? config.endpoints[0] : undefined);
+        if (preferred) {
+            config.currentEndpoint = preferred.id;
+            const m = preferred.models.find((x) => x.enabled) || preferred.models[0];
+            if (m)
+                config.currentModel = m.id;
         }
         else if (currentExists) {
             const ep = config.endpoints.find((e) => e.id === config.currentEndpoint);
-            const modelExists = ep.models.some((m) => m.id === config.currentModel);
-            if (!modelExists) {
-                const enabledModel = ep.models.find((m) => m.enabled) || ep.models[0];
-                if (enabledModel)
-                    config.currentModel = enabledModel.id;
+            if (!ep.models.some((m) => m.id === config.currentModel)) {
+                const m = ep.models.find((x) => x.enabled) || ep.models[0];
+                if (m)
+                    config.currentModel = m.id;
             }
         }
         await this.saveConfig();

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

@@ -43,6 +43,7 @@ export declare class LLMClient {
     private apiKey;
     private model;
     private modelName;
+    private triedBatutaFallback;
     private currentAbortController;
     private isInterrupted;
     onStreamingContent: ((token: string) => void) | null;
@@ -54,6 +55,8 @@ export declare class LLMClient {
     checkInterrupted(): boolean;
     resetInterrupt(): void;
     isRequestActive(): boolean;
+    private isConnectionError;
+    private switchToBatutaProxy;
     private isRetryableError;
     private sleep;
     chatCompletionStream(options: Partial<LLMRequestOptions>): AsyncGenerator<LLMStreamChunk, void, unknown>;

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

@@ -106,6 +106,7 @@ export class LLMClient {
     apiKey;
     model;
     modelName;
+    triedBatutaFallback = false;
     currentAbortController = null;
     isInterrupted = false;
     onStreamingContent = null;
@@ -407,6 +408,11 @@ export class LLMClient {
                     currentAttempt: currentAttempt + 1,
                 });
             }
+            if (!this.triedBatutaFallback && this.isConnectionError(error) && this.switchToBatutaProxy()) {
+                this.triedBatutaFallback = true;
+                logger.flow('Primary endpoint unreachable — falling back to Batuta');
+                return this.chatCompletion(options, { maxRetries, currentAttempt: 1 });
+            }
             logger.flow('API call failed - Error handling');
             if (currentAttempt > 1) {
                 logger.error(`LLM call final failure after ${maxRetries} retries`, {
@@ -439,6 +445,33 @@ export class LLMClient {
     isRequestActive() {
         return this.currentAbortController !== null;
     }
+    isConnectionError(error) {
+        if (!axios.isAxiosError(error))
+            return false;
+        const e = error;
+        if (e.response)
+            return false;
+        const codes = ['ECONNREFUSED', 'ETIMEDOUT', 'ECONNRESET', 'ECONNABORTED', 'ENOTFOUND', 'EHOSTUNREACH'];
+        return (e.code ? codes.includes(e.code) : false) || /timeout|network/i.test(e.message || '');
+    }
+    switchToBatutaProxy() {
+        const ep = configManager.getAllEndpoints().find(e => e.id === 'batuta-proxy' || e.provider === 'batuta');
+        if (!ep || !ep.apiKey || ep.baseUrl === this.baseUrl)
+            return false;
+        const model = ep.models?.find(m => m.enabled) || ep.models?.[0];
+        if (!model)
+            return false;
+        this.baseUrl = ep.baseUrl;
+        this.apiKey = ep.apiKey;
+        this.model = model.id;
+        this.modelName = model.name;
+        const providerDef = ep.provider ? getProvider(ep.provider) : undefined;
+        const headers = providerDef
+            ? buildAuthHeaders(providerDef, this.apiKey)
+            : { 'Content-Type': 'application/json', ...(this.apiKey && { Authorization: `Bearer ${this.apiKey}` }) };
+        this.axiosInstance = axios.create({ baseURL: this.baseUrl, headers, timeout: 600000 });
+        return true;
+    }
     isRetryableError(error) {
         if (error instanceof Error && error.message === 'INTERRUPTED') {
             return false;

package/package.json

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