orquesta-cli 0.2.75 → 0.2.76

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

@@ -89,6 +89,11 @@ export declare class LLMClient {
         latency?: number;
         error?: string;
     }[]>>;
+    static healthCheckCurrent(): Promise<{
+        healthy: boolean;
+        latency?: number;
+        error?: string;
+    }>;
     static testConnection(baseUrl: string, apiKey: string, model: string): Promise<{
         success: boolean;
         latency?: number;

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

@@ -1213,6 +1213,52 @@ export class LLMClient {
         }
         return results;
     }
+    static async healthCheckCurrent() {
+        const endpoint = configManager.getCurrentEndpoint();
+        const model = configManager.getCurrentModel();
+        if (!endpoint || !model) {
+            return { healthy: false, error: 'No endpoint/model configured' };
+        }
+        const startTime = Date.now();
+        try {
+            const axiosInstance = axios.create({
+                baseURL: endpoint.baseUrl,
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...(endpoint.apiKey && { Authorization: `Bearer ${endpoint.apiKey}` }),
+                },
+                timeout: 10000,
+            });
+            const response = await axiosInstance.post('/chat/completions', {
+                model: model.id,
+                messages: [{ role: 'user', content: 'ping' }],
+                max_tokens: 1,
+            });
+            const latency = Date.now() - startTime;
+            if (response.status === 200 && response.data.choices?.[0]?.message) {
+                return { healthy: true, latency };
+            }
+            return { healthy: false, latency, error: 'Invalid response' };
+        }
+        catch (error) {
+            const latency = Date.now() - startTime;
+            const axiosError = error;
+            let errorMessage = 'Unknown error';
+            if (axiosError.response) {
+                errorMessage = `HTTP ${axiosError.response.status}`;
+            }
+            else if (axiosError.code === 'ECONNREFUSED') {
+                errorMessage = 'Connection refused';
+            }
+            else if (axiosError.code === 'ETIMEDOUT' || axiosError.code === 'ECONNABORTED') {
+                errorMessage = 'Timeout';
+            }
+            else if (axiosError.request) {
+                errorMessage = 'Network error';
+            }
+            return { healthy: false, latency, error: errorMessage };
+        }
+    }
     static async testConnection(baseUrl, apiKey, model) {
         const startTime = Date.now();
         try {

package/dist/ui/components/PlanExecuteApp.js

@@ -470,30 +470,24 @@ export const PlanExecuteApp = ({ llmClient: initialLlmClient, modelInfo, resumeL
             logger.startTimer('app-init');
             try {
                 setInitStep('health');
-                logger.flow('Running health check + docs init in parallel');
+                logger.flow('Kicking off background health probe + docs init');
                 setHealthStatus('checking');
-                const healthPromise = (async () => {
+                void (async () => {
                     if (configManager.hasEndpoints()) {
-                        const healthResults = await LLMClient.healthCheckAll();
-                        let hasHealthy = false;
-                        for (const [endpointId, modelResults] of healthResults) {
-                            logger.vars({ name: 'endpointId', value: endpointId }, { name: 'healthyModels', value: modelResults.filter(r => r.healthy).length });
-                            if (modelResults.some((r) => r.healthy)) {
-                                hasHealthy = true;
-                            }
-                        }
-                        logger.state('Health status', 'checking', hasHealthy ? 'healthy' : 'unhealthy');
-                        setHealthStatus(hasHealthy ? 'healthy' : 'unhealthy');
-                        await configManager.updateAllHealthStatus(healthResults);
+                        const result = await LLMClient.healthCheckCurrent();
+                        logger.state('Health status', 'checking', result.healthy ? 'healthy' : 'unhealthy');
+                        setHealthStatus(result.healthy ? 'healthy' : 'unhealthy');
                     }
                     else {
                         setHealthStatus('unknown');
                     }
-                })();
-                const docsPromise = initializeDocsDirectory().catch((err) => {
+                })().catch((err) => {
+                    logger.warn('Background health probe failed', { error: err });
+                    setHealthStatus('unknown');
+                });
+                await initializeDocsDirectory().catch((err) => {
                     logger.warn('Docs directory initialization warning', { error: err });
                 });
-                await Promise.all([healthPromise, docsPromise]);
                 setInitStep('config');
                 logger.flow('Checking configuration');
                 if (!configManager.hasEndpoints()) {

package/package.json

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