orquesta-cli 0.2.84 → 0.2.86

package/dist/cli.js

@@ -41,6 +41,36 @@ async function readPromptFromStdin() {
     }
     return Buffer.concat(chunks).toString('utf-8').trim();
 }
+async function ensureBatutaFromEnv() {
+    const token = process.env['ORQUESTA_TOKEN'];
+    if (!token)
+        return;
+    const apiUrl = (process.env['ORQUESTA_API_URL'] || 'https://getorquesta.com').replace(/\/+$/, '');
+    if (configManager.getAllEndpoints().some((e) => e.id === 'batuta-proxy')) {
+        await configManager.removeEndpoint('batuta-proxy');
+    }
+    await configManager.addEndpoint({
+        id: 'batuta-proxy',
+        name: 'Batuta',
+        baseUrl: `${apiUrl}/api/v1`,
+        apiKey: token,
+        provider: 'batuta',
+        models: [{
+                id: 'batuta-auto',
+                name: 'Batuta Auto (smart routing)',
+                maxTokens: 200000,
+                enabled: true,
+                healthStatus: 'healthy',
+                lastHealthCheck: new Date(),
+            }],
+        createdAt: new Date(),
+        updatedAt: new Date(),
+    });
+    if (!configManager.getCurrentEndpoint()) {
+        await configManager.setCurrentEndpoint('batuta-proxy');
+        await configManager.setCurrentModel('batuta-auto');
+    }
+}
 async function resolveHookToken(explicitToken) {
     await configManager.initialize();
     const saved = configManager.getOrquestaConfig();
@@ -129,6 +159,7 @@ program
         return;
     }
     await configManager.initialize();
+    await ensureBatutaFromEnv();
     if (shouldShowOnboarding()) {
         await runOnboarding();
     }

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.84",
+  "version": "0.2.86",
   "description": "Orquesta CLI - AI-powered coding assistant with team collaboration",
   "type": "module",
   "main": "dist/index.js",