@orchagent/cli 0.2.25 → 0.2.26

package/dist/commands/run.js

@@ -234,6 +234,58 @@ async function downloadDependenciesRecursively(config, depStatuses, visited = ne
         }
     }
 }
+/**
+ * Detect all available LLM providers from environment and server.
+ * Returns array of provider configs for fallback support.
+ */
+async function detectAllLlmKeys(supportedProviders, config) {
+    const providers = [];
+    const seen = new Set();
+    // Check environment variables for all providers
+    for (const provider of supportedProviders) {
+        if (provider === 'any') {
+            // Check all known providers
+            for (const [p, envVar] of Object.entries(llm_1.PROVIDER_ENV_VARS)) {
+                const key = process.env[envVar];
+                if (key && !seen.has(p)) {
+                    seen.add(p);
+                    providers.push({ provider: p, apiKey: key, model: (0, llm_1.getDefaultModel)(p) });
+                }
+            }
+        }
+        else {
+            const envVar = llm_1.PROVIDER_ENV_VARS[provider];
+            if (envVar) {
+                const key = process.env[envVar];
+                if (key && !seen.has(provider)) {
+                    seen.add(provider);
+                    providers.push({ provider, apiKey: key, model: (0, llm_1.getDefaultModel)(provider) });
+                }
+            }
+        }
+    }
+    // Also check server keys if available
+    if (config?.apiKey) {
+        try {
+            const { fetchLlmKeys } = await Promise.resolve().then(() => __importStar(require('../lib/api')));
+            const serverKeys = await fetchLlmKeys(config);
+            for (const serverKey of serverKeys) {
+                if (!seen.has(serverKey.provider)) {
+                    seen.add(serverKey.provider);
+                    providers.push({
+                        provider: serverKey.provider,
+                        apiKey: serverKey.api_key,
+                        model: serverKey.model || (0, llm_1.getDefaultModel)(serverKey.provider),
+                    });
+                }
+            }
+        }
+        catch {
+            // Server fetch failed, continue with what we have
+        }
+    }
+    return providers;
+}
 async function executePromptLocally(agentData, inputData, skillPrompts = [], config, providerOverride) {
     // If provider override specified, validate and use only that provider
     if (providerOverride) {
@@ -243,6 +295,44 @@ async function executePromptLocally(agentData, inputData, skillPrompts = [], con
     const providersToCheck = providerOverride
         ? [providerOverride]
         : agentData.supported_providers;
+    // Combine skill prompts with agent prompt (skills first, then agent)
+    let basePrompt = agentData.prompt || '';
+    if (skillPrompts.length > 0) {
+        basePrompt = [...skillPrompts, basePrompt].join('\n\n---\n\n');
+    }
+    // Build the prompt with input data (matches server behavior)
+    const prompt = (0, llm_1.buildPrompt)(basePrompt, inputData);
+    // When no provider override, detect all available providers for fallback support
+    if (!providerOverride) {
+        const allProviders = await detectAllLlmKeys(providersToCheck, config);
+        if (allProviders.length === 0) {
+            const providers = providersToCheck.join(', ');
+            throw new errors_1.CliError(`No LLM key found for: ${providers}\n` +
+                `Set an environment variable (e.g., OPENAI_API_KEY) or configure in web dashboard`);
+        }
+        // Apply agent default models to each provider config
+        const providersWithModels = allProviders.map((p) => ({
+            ...p,
+            model: agentData.default_models?.[p.provider] || p.model,
+        }));
+        // Show which provider is being used (primary)
+        const primary = providersWithModels[0];
+        if (providersWithModels.length > 1) {
+            process.stderr.write(`Running with ${primary.provider} (${primary.model}), ` +
+                `${providersWithModels.length - 1} fallback(s) available...\n`);
+        }
+        else {
+            process.stderr.write(`Running with ${primary.provider} (${primary.model})...\n`);
+        }
+        // Use fallback if multiple providers, otherwise single call
+        if (providersWithModels.length > 1) {
+            return await (0, llm_1.callLlmWithFallback)(providersWithModels, prompt, agentData.output_schema);
+        }
+        else {
+            return await (0, llm_1.callLlm)(primary.provider, primary.apiKey, primary.model, prompt, agentData.output_schema);
+        }
+    }
+    // Provider override: use single provider (existing behavior)
     const detected = await (0, llm_1.detectLlmKey)(providersToCheck, config);
     if (!detected) {
         const providers = providersToCheck.join(', ');
@@ -254,13 +344,6 @@ async function executePromptLocally(agentData, inputData, skillPrompts = [], con
     const model = serverModel || agentData.default_models?.[provider] || (0, llm_1.getDefaultModel)(provider);
     // Show which provider is being used (helpful for debugging rate limits)
     process.stderr.write(`Running with ${provider} (${model})...\n`);
-    // Combine skill prompts with agent prompt (skills first, then agent)
-    let basePrompt = agentData.prompt || '';
-    if (skillPrompts.length > 0) {
-        basePrompt = [...skillPrompts, basePrompt].join('\n\n---\n\n');
-    }
-    // Build the prompt with input data (matches server behavior)
-    const prompt = (0, llm_1.buildPrompt)(basePrompt, inputData);
     // Call the LLM directly
     const response = await (0, llm_1.callLlm)(provider, key, model, prompt, agentData.output_schema);
     return response;

package/dist/lib/api.js

@@ -59,6 +59,8 @@ exports.previewAgentVersion = previewAgentVersion;
 exports.reportInstall = reportInstall;
 const errors_1 = require("./errors");
 const DEFAULT_TIMEOUT_MS = 15000;
+const MAX_RETRIES = 3;
+const BASE_DELAY_MS = 1000;
 async function safeFetch(url, options) {
     try {
         return await fetch(url, {
@@ -74,6 +76,39 @@ async function safeFetch(url, options) {
         throw new errors_1.NetworkError(url, err instanceof Error ? err : undefined);
     }
 }
+async function safeFetchWithRetry(url, options) {
+    let lastError;
+    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+        try {
+            const response = await safeFetch(url, options);
+            // Don't retry client errors (except 429)
+            if (response.status >= 400 && response.status < 500 && response.status !== 429) {
+                return response;
+            }
+            // Retry on 5xx or 429
+            if (response.status >= 500 || response.status === 429) {
+                if (attempt < MAX_RETRIES) {
+                    const delay = BASE_DELAY_MS * Math.pow(2, attempt - 1);
+                    const jitter = Math.random() * 500;
+                    process.stderr.write(`Request failed (${response.status}), retrying in ${Math.round((delay + jitter) / 1000)}s...\n`);
+                    await new Promise(r => setTimeout(r, delay + jitter));
+                    continue;
+                }
+            }
+            return response;
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt < MAX_RETRIES) {
+                const delay = BASE_DELAY_MS * Math.pow(2, attempt - 1);
+                const jitter = Math.random() * 500;
+                process.stderr.write(`Network error, retrying in ${Math.round((delay + jitter) / 1000)}s...\n`);
+                await new Promise(r => setTimeout(r, delay + jitter));
+            }
+        }
+    }
+    throw lastError ?? new errors_1.NetworkError(url);
+}
 class ApiError extends Error {
     status;
     payload;
@@ -108,7 +143,7 @@ async function request(config, method, path, options = {}) {
     if (!config.apiKey) {
         throw new ApiError('Missing API key. Run `orchagent login` first.', 401);
     }
-    const response = await safeFetch(buildUrl(config.apiUrl, path), {
+    const response = await safeFetchWithRetry(buildUrl(config.apiUrl, path), {
         method,
         headers: {
             Authorization: `Bearer ${config.apiKey}`,
@@ -122,7 +157,7 @@ async function request(config, method, path, options = {}) {
     return (await response.json());
 }
 async function publicRequest(config, path) {
-    const response = await safeFetch(buildUrl(config.apiUrl, path));
+    const response = await safeFetchWithRetry(buildUrl(config.apiUrl, path));
     if (!response.ok) {
         throw await parseError(response);
     }

package/dist/lib/llm.js

@@ -39,15 +39,28 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_MODELS = exports.PROVIDER_ENV_VARS = void 0;
+exports.DEFAULT_MODELS = exports.PROVIDER_ENV_VARS = exports.LlmError = void 0;
+exports.isRateLimitError = isRateLimitError;
 exports.detectLlmKeyFromEnv = detectLlmKeyFromEnv;
 exports.detectLlmKey = detectLlmKey;
 exports.getDefaultModel = getDefaultModel;
 exports.buildPrompt = buildPrompt;
 exports.callLlm = callLlm;
+exports.callLlmWithFallback = callLlmWithFallback;
 exports.validateProvider = validateProvider;
 const errors_1 = require("./errors");
 const llm_errors_1 = require("./llm-errors");
+class LlmError extends errors_1.CliError {
+    statusCode;
+    constructor(message, statusCode) {
+        super(message);
+        this.statusCode = statusCode;
+    }
+}
+exports.LlmError = LlmError;
+function isRateLimitError(error) {
+    return error instanceof LlmError && error.statusCode === 429;
+}
 // Environment variable names for each provider
 exports.PROVIDER_ENV_VARS = {
     openai: 'OPENAI_API_KEY',
@@ -169,6 +182,27 @@ async function callLlm(provider, apiKey, model, prompt, outputSchema) {
     }
     throw new errors_1.CliError(`Unsupported provider: ${provider}`);
 }
+/**
+ * Call LLM with automatic fallback to next provider on rate limit.
+ * Tries each provider in order until one succeeds.
+ */
+async function callLlmWithFallback(providers, prompt, outputSchema) {
+    let lastError;
+    for (const { provider, apiKey, model } of providers) {
+        try {
+            return await callLlm(provider, apiKey, model, prompt, outputSchema);
+        }
+        catch (error) {
+            lastError = error;
+            if (isRateLimitError(error)) {
+                process.stderr.write(`${provider} rate-limited, trying next provider...\n`);
+                continue;
+            }
+            throw error; // Don't retry non-rate-limit errors
+        }
+    }
+    throw lastError ?? new errors_1.CliError('All LLM providers failed');
+}
 async function callOpenAI(apiKey, model, prompt, outputSchema) {
     const body = {
         model,
@@ -187,7 +221,8 @@ async function callOpenAI(apiKey, model, prompt, outputSchema) {
     });
     if (!response.ok) {
         const text = await response.text();
-        throw (0, llm_errors_1.parseLlmError)('openai', text, response.status);
+        const parsed = (0, llm_errors_1.parseLlmError)('openai', text, response.status);
+        throw new LlmError(parsed.message, response.status);
     }
     const data = (await response.json());
     const content = data.choices?.[0]?.message?.content || '';
@@ -214,7 +249,8 @@ async function callAnthropic(apiKey, model, prompt, _outputSchema) {
     });
     if (!response.ok) {
         const text = await response.text();
-        throw (0, llm_errors_1.parseLlmError)('anthropic', text, response.status);
+        const parsed = (0, llm_errors_1.parseLlmError)('anthropic', text, response.status);
+        throw new LlmError(parsed.message, response.status);
     }
     const data = (await response.json());
     const content = data.content?.[0]?.text || '';
@@ -236,7 +272,8 @@ async function callGemini(apiKey, model, prompt, _outputSchema) {
     });
     if (!response.ok) {
         const text = await response.text();
-        throw (0, llm_errors_1.parseLlmError)('gemini', text, response.status);
+        const parsed = (0, llm_errors_1.parseLlmError)('gemini', text, response.status);
+        throw new LlmError(parsed.message, response.status);
     }
     const data = (await response.json());
     const content = data.candidates?.[0]?.content?.parts?.[0]?.text || '';
@@ -264,10 +301,11 @@ async function callOllama(endpoint, model, prompt, _outputSchema) {
     });
     if (!response.ok) {
         if (response.status === 404) {
-            throw new errors_1.CliError(`Model '${model}' not found. Run: ollama pull ${model}`);
+            throw new LlmError(`Model '${model}' not found. Run: ollama pull ${model}`, 404);
         }
         const text = await response.text();
-        throw (0, llm_errors_1.parseLlmError)('ollama', text, response.status);
+        const parsed = (0, llm_errors_1.parseLlmError)('ollama', text, response.status);
+        throw new LlmError(parsed.message, response.status);
     }
     const data = await response.json();
     const content = data.choices?.[0]?.message?.content || '';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orchagent/cli",
-  "version": "0.2.25",
+  "version": "0.2.26",
   "description": "Command-line interface for the orchagent AI agent marketplace",
   "license": "MIT",
   "author": "orchagent <hello@orchagent.io>",