orquesta-cli 0.1.16 → 0.1.17

package/dist/cli.js

@@ -13,6 +13,8 @@ import { initializeOptionalTools } from './tools/registry.js';
 import { sessionManager } from './core/session/session-manager.js';
 import { connectWithToken, showConnectionStatus, disconnectFromOrquesta, switchProject } from './setup/first-run-setup.js';
 import { syncOrquestaConfigs } from './orquesta/config-sync.js';
+import { scanProviders, scanProvider, toEndpointConfig } from './core/config/auto-detect.js';
+import { PROVIDERS } from './core/config/providers.js';
 const require = createRequire(import.meta.url);
 const packageJson = require('../package.json');
 const program = new Command();
@@ -34,6 +36,8 @@ program
     .option('--status', 'Show Orquesta connection status and exit')
     .option('--disconnect', 'Disconnect from Orquesta and exit')
     .option('--sync', 'Sync configurations with Orquesta and exit')
+    .option('--scan', 'Scan for available LLM providers (env vars + local ports)')
+    .option('--add-provider <providerId>', 'Add a specific provider by ID (e.g., openai, anthropic, ollama)')
     .action(async (options) => {
     if (options.eval) {
         await runEvalMode();
@@ -59,6 +63,85 @@ program
             process.exit(1);
         }
     }
+    if (options.scan) {
+        const ora = (await import('ora')).default;
+        const spinner = ora({ text: chalk.cyan('Scanning for LLM providers...'), color: 'cyan' }).start();
+        try {
+            const result = await scanProviders();
+            spinner.stop();
+            if (result.detected.length === 0) {
+                console.log(chalk.yellow('\nNo LLM providers detected.'));
+                console.log(chalk.dim('Set environment variables (e.g., OPENAI_API_KEY) or start a local provider (Ollama, LM Studio).'));
+                console.log(chalk.dim('\nSupported providers:'));
+                for (const p of PROVIDERS) {
+                    const envHint = p.envVars.length > 0 ? chalk.dim(` (${p.envVars[0]})`) : p.isLocal ? chalk.dim(` (port ${p.localPort})`) : '';
+                    console.log(chalk.white(`  ${p.name}${envHint}`));
+                }
+            }
+            else {
+                console.log(chalk.green(`\nDetected ${result.detected.length} provider(s):\n`));
+                for (const d of result.detected) {
+                    const modelCount = d.discoveredModels.length;
+                    console.log(chalk.white(`  ${d.provider.name}`));
+                    console.log(chalk.dim(`    Source: ${d.source}`));
+                    console.log(chalk.dim(`    Models: ${modelCount} discovered`));
+                    if (modelCount > 0) {
+                        const shown = d.discoveredModels.slice(0, 5);
+                        for (const m of shown) {
+                            console.log(chalk.dim(`      - ${m.name} (${m.id})`));
+                        }
+                        if (modelCount > 5)
+                            console.log(chalk.dim(`      ... and ${modelCount - 5} more`));
+                    }
+                    console.log();
+                }
+                if (result.notFound.length > 0) {
+                    console.log(chalk.dim(`Not found: ${result.notFound.join(', ')}`));
+                }
+                console.log(chalk.cyan('\nUse --add-provider <id> to add a detected provider as an endpoint.'));
+            }
+        }
+        catch (error) {
+            spinner.fail(chalk.red('Scan failed'));
+            console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+        }
+        return;
+    }
+    if (options.addProvider) {
+        const ora = (await import('ora')).default;
+        const spinner = ora({ text: chalk.cyan(`Detecting ${options.addProvider}...`), color: 'cyan' }).start();
+        try {
+            const detected = await scanProvider(options.addProvider);
+            if (!detected) {
+                spinner.fail(chalk.red(`Provider '${options.addProvider}' not found or not available`));
+                const provider = PROVIDERS.find(p => p.id === options.addProvider);
+                if (provider && provider.envVars.length > 0) {
+                    console.log(chalk.dim(`Set ${provider.envVars[0]} environment variable and try again.`));
+                }
+                else if (provider?.isLocal) {
+                    console.log(chalk.dim(`Start ${provider.name} on port ${provider.localPort} and try again.`));
+                }
+                process.exit(1);
+            }
+            const endpointConfig = toEndpointConfig(detected);
+            await configManager.addEndpoint(endpointConfig);
+            if (!configManager.getCurrentModel() && endpointConfig.models.length > 0) {
+                await configManager.setCurrentEndpoint(endpointConfig.id);
+                await configManager.setCurrentModel(endpointConfig.models[0].id);
+            }
+            spinner.succeed(chalk.green(`Added ${detected.provider.name} with ${detected.discoveredModels.length} model(s)`));
+            console.log(chalk.dim(`  Endpoint: ${endpointConfig.baseUrl}`));
+            if (detected.discoveredModels.length > 0) {
+                console.log(chalk.dim(`  Models: ${detected.discoveredModels.slice(0, 5).map(m => m.id).join(', ')}${detected.discoveredModels.length > 5 ? ` (+${detected.discoveredModels.length - 5} more)` : ''}`));
+            }
+        }
+        catch (error) {
+            spinner.fail(chalk.red('Failed to add provider'));
+            console.error(chalk.red(error instanceof Error ? error.message : String(error)));
+            process.exit(1);
+        }
+        return;
+    }
     if (options.sync) {
         if (!configManager.hasOrquestaConnection()) {
             console.log(chalk.yellow('Not connected to Orquesta. Use --token to connect first.'));
@@ -196,6 +279,8 @@ program.on('command:*', () => {
     console.log(chalk.white('  --status                Show Orquesta connection status\n'));
     console.log(chalk.white('  --sync                  Sync configurations with Orquesta\n'));
     console.log(chalk.white('  --disconnect            Disconnect from Orquesta\n'));
+    console.log(chalk.white('  --scan                  Scan for available LLM providers\n'));
+    console.log(chalk.white('  --add-provider <id>     Add a provider (e.g., openai, anthropic, ollama)\n'));
     console.log(chalk.white('  --verbose               Enable verbose logging\n'));
     console.log(chalk.white('  --debug                 Enable debug logging\n'));
     console.log(chalk.white('\nUse /help in interactive mode for more help.\n'));

package/dist/core/config/auto-detect.d.ts

@@ -0,0 +1,17 @@
+import { ProviderDefinition } from './providers.js';
+import { EndpointConfig, ModelInfo } from '../../types/index.js';
+export interface DetectedProvider {
+    provider: ProviderDefinition;
+    apiKey?: string;
+    source: string;
+    discoveredModels: ModelInfo[];
+}
+export interface ScanResult {
+    detected: DetectedProvider[];
+    notFound: string[];
+}
+export declare function scanProviders(): Promise<ScanResult>;
+export declare function scanProvider(providerId: string, apiKey?: string): Promise<DetectedProvider | null>;
+export declare function toEndpointConfig(detected: DetectedProvider): EndpointConfig;
+export declare function fetchModels(provider: ProviderDefinition, apiKey: string): Promise<ModelInfo[]>;
+//# sourceMappingURL=auto-detect.d.ts.map

package/dist/core/config/auto-detect.js

@@ -0,0 +1,123 @@
+import axios from 'axios';
+import { PROVIDERS, buildAuthHeaders } from './providers.js';
+export async function scanProviders() {
+    const detected = [];
+    const notFound = [];
+    for (const provider of PROVIDERS.filter((p) => !p.isLocal)) {
+        const apiKey = findEnvVar(provider.envVars);
+        if (apiKey) {
+            const models = await fetchModels(provider, apiKey).catch(() => []);
+            detected.push({
+                provider,
+                apiKey,
+                source: provider.envVars.find((v) => process.env[v]) || provider.envVars[0] || provider.id,
+                discoveredModels: models.length > 0 ? models : fallbackModels(provider),
+            });
+        }
+        else {
+            notFound.push(provider.id);
+        }
+    }
+    const localProbes = PROVIDERS.filter((p) => p.isLocal).map(async (provider) => {
+        const running = await probeLocal(provider);
+        if (running) {
+            const models = await fetchModels(provider, '').catch(() => []);
+            detected.push({
+                provider,
+                source: 'local-probe',
+                discoveredModels: models.length > 0 ? models : fallbackModels(provider),
+            });
+        }
+        else {
+            notFound.push(provider.id);
+        }
+    });
+    await Promise.all(localProbes);
+    return { detected, notFound };
+}
+export async function scanProvider(providerId, apiKey) {
+    const provider = PROVIDERS.find((p) => p.id === providerId);
+    if (!provider)
+        return null;
+    const key = apiKey || findEnvVar(provider.envVars) || '';
+    if (provider.requiresApiKey && !key)
+        return null;
+    if (provider.isLocal) {
+        const running = await probeLocal(provider);
+        if (!running)
+            return null;
+    }
+    const models = await fetchModels(provider, key).catch(() => []);
+    return {
+        provider,
+        apiKey: key || undefined,
+        source: apiKey ? 'manual' : provider.isLocal ? 'local-probe' : (provider.envVars.find((v) => process.env[v]) || 'manual'),
+        discoveredModels: models.length > 0 ? models : fallbackModels(provider),
+    };
+}
+export function toEndpointConfig(detected) {
+    return {
+        id: `ep_${detected.provider.id}_${Date.now()}`,
+        name: detected.provider.name,
+        baseUrl: detected.provider.baseUrl,
+        apiKey: detected.apiKey,
+        provider: detected.provider.id,
+        models: detected.discoveredModels,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+    };
+}
+function findEnvVar(envVars) {
+    for (const name of envVars) {
+        const value = process.env[name];
+        if (value && value.trim().length > 0)
+            return value.trim();
+    }
+    return undefined;
+}
+async function probeLocal(provider) {
+    const url = provider.healthCheckPath || `${provider.baseUrl}/models`;
+    try {
+        const resp = await axios.get(url, { timeout: 2000 });
+        return resp.status >= 200 && resp.status < 400;
+    }
+    catch {
+        return false;
+    }
+}
+export async function fetchModels(provider, apiKey) {
+    if (!provider.modelsEndpoint)
+        return [];
+    const url = `${provider.baseUrl}${provider.modelsEndpoint}`;
+    const headers = buildAuthHeaders(provider, apiKey);
+    const resp = await axios.get(url, { headers, timeout: 10000 });
+    const data = resp.data;
+    const models = data?.data || data?.models || [];
+    if (!Array.isArray(models) || models.length === 0)
+        return [];
+    return models
+        .filter((m) => {
+        const id = (m.id || m.model || '').toLowerCase();
+        if (/embed|tts|whisper|dall-e|moderation|audio/.test(id))
+            return false;
+        return true;
+    })
+        .slice(0, 50)
+        .map((m) => ({
+        id: m.id || m.model || m.name,
+        name: m.name || m.display_name || m.id || m.model,
+        maxTokens: m.context_length || m.context_window || m.max_tokens || 4096,
+        enabled: true,
+        healthStatus: 'healthy',
+    }));
+}
+function fallbackModels(provider) {
+    return provider.knownModels.map((m) => ({
+        id: m.id,
+        name: m.name,
+        maxTokens: m.maxTokens,
+        enabled: true,
+        healthStatus: 'healthy',
+    }));
+}
+//# sourceMappingURL=auto-detect.js.map

package/dist/core/config/providers.d.ts

@@ -0,0 +1,29 @@
+export type AuthMethod = 'bearer' | 'x-api-key' | 'none';
+export type ModelCapability = 'vision' | 'tools' | 'json_mode' | 'extended_thinking' | 'streaming';
+export interface KnownModel {
+    id: string;
+    name: string;
+    maxTokens: number;
+    capabilities?: ModelCapability[];
+}
+export interface ProviderDefinition {
+    id: string;
+    name: string;
+    baseUrl: string;
+    authMethod: AuthMethod;
+    envVars: string[];
+    requiresApiKey: boolean;
+    isLocal: boolean;
+    localPort?: number;
+    modelsEndpoint?: string;
+    knownModels: KnownModel[];
+    openaiCompatible: boolean;
+    extraHeaders?: Record<string, string>;
+    healthCheckPath?: string;
+}
+export declare const PROVIDERS: ProviderDefinition[];
+export declare function getProvider(id: string): ProviderDefinition | undefined;
+export declare function detectProviderFromUrl(baseUrl: string): ProviderDefinition | undefined;
+export declare function modelHasCapability(providerId: string, modelId: string, capability: ModelCapability): boolean;
+export declare function buildAuthHeaders(provider: ProviderDefinition, apiKey: string): Record<string, string>;
+//# sourceMappingURL=providers.d.ts.map

package/dist/core/config/providers.js

@@ -0,0 +1,277 @@
+export const PROVIDERS = [
+    {
+        id: 'openai',
+        name: 'OpenAI',
+        baseUrl: 'https://api.openai.com/v1',
+        authMethod: 'bearer',
+        envVars: ['OPENAI_API_KEY'],
+        requiresApiKey: true,
+        isLocal: false,
+        modelsEndpoint: '/models',
+        openaiCompatible: true,
+        knownModels: [
+            { id: 'gpt-4o', name: 'GPT-4o', maxTokens: 128000, capabilities: ['vision', 'tools', 'json_mode', 'streaming'] },
+            { id: 'gpt-4o-mini', name: 'GPT-4o Mini', maxTokens: 128000, capabilities: ['vision', 'tools', 'json_mode', 'streaming'] },
+            { id: 'gpt-4-turbo', name: 'GPT-4 Turbo', maxTokens: 128000, capabilities: ['vision', 'tools', 'json_mode', 'streaming'] },
+            { id: 'o1', name: 'o1', maxTokens: 200000, capabilities: ['extended_thinking', 'streaming'] },
+            { id: 'o1-mini', name: 'o1 Mini', maxTokens: 128000, capabilities: ['extended_thinking', 'streaming'] },
+            { id: 'o3-mini', name: 'o3 Mini', maxTokens: 200000, capabilities: ['extended_thinking', 'tools', 'streaming'] },
+        ],
+    },
+    {
+        id: 'anthropic',
+        name: 'Anthropic',
+        baseUrl: 'https://api.anthropic.com/v1',
+        authMethod: 'x-api-key',
+        envVars: ['ANTHROPIC_API_KEY'],
+        requiresApiKey: true,
+        isLocal: false,
+        modelsEndpoint: '/models',
+        openaiCompatible: false,
+        extraHeaders: { 'anthropic-version': '2023-06-01' },
+        knownModels: [
+            { id: 'claude-opus-4-6', name: 'Claude Opus 4.6', maxTokens: 200000, capabilities: ['vision', 'tools', 'extended_thinking', 'streaming'] },
+            { id: 'claude-sonnet-4-6', name: 'Claude Sonnet 4.6', maxTokens: 200000, capabilities: ['vision', 'tools', 'extended_thinking', 'streaming'] },
+            { id: 'claude-haiku-4-5-20251001', name: 'Claude Haiku 4.5', maxTokens: 200000, capabilities: ['vision', 'tools', 'streaming'] },
+            { id: 'claude-sonnet-4-5-20250514', name: 'Claude Sonnet 4.5', maxTokens: 200000, capabilities: ['vision', 'tools', 'extended_thinking', 'streaming'] },
+        ],
+    },
+    {
+        id: 'google',
+        name: 'Google Gemini',
+        baseUrl: 'https://generativelanguage.googleapis.com/v1beta/openai',
+        authMethod: 'bearer',
+        envVars: ['GEMINI_API_KEY', 'GOOGLE_API_KEY'],
+        requiresApiKey: true,
+        isLocal: false,
+        modelsEndpoint: '/models',
+        openaiCompatible: true,
+        knownModels: [
+            { id: 'gemini-2.0-flash', name: 'Gemini 2.0 Flash', maxTokens: 1048576, capabilities: ['vision', 'tools', 'json_mode', 'streaming'] },
+            { id: 'gemini-2.0-pro', name: 'Gemini 2.0 Pro', maxTokens: 1048576, capabilities: ['vision', 'tools', 'json_mode', 'streaming'] },
+            { id: 'gemini-1.5-pro', name: 'Gemini 1.5 Pro', maxTokens: 2097152, capabilities: ['vision', 'tools', 'json_mode', 'streaming'] },
+            { id: 'gemini-1.5-flash', name: 'Gemini 1.5 Flash', maxTokens: 1048576, capabilities: ['vision', 'tools', 'json_mode', 'streaming'] },
+        ],
+    },
+    {
+        id: 'mistral',
+        name: 'Mistral AI',
+        baseUrl: 'https://api.mistral.ai/v1',
+        authMethod: 'bearer',
+        envVars: ['MISTRAL_API_KEY'],
+        requiresApiKey: true,
+        isLocal: false,
+        modelsEndpoint: '/models',
+        openaiCompatible: true,
+        knownModels: [
+            { id: 'mistral-large-latest', name: 'Mistral Large', maxTokens: 128000, capabilities: ['vision', 'tools', 'json_mode', 'streaming'] },
+            { id: 'mistral-small-latest', name: 'Mistral Small', maxTokens: 128000, capabilities: ['tools', 'json_mode', 'streaming'] },
+            { id: 'codestral-latest', name: 'Codestral', maxTokens: 256000, capabilities: ['tools', 'streaming'] },
+            { id: 'magistral-small-latest', name: 'Magistral Small', maxTokens: 128000, capabilities: ['tools', 'streaming'] },
+            { id: 'magistral-medium-latest', name: 'Magistral Medium', maxTokens: 128000, capabilities: ['tools', 'streaming'] },
+        ],
+    },
+    {
+        id: 'groq',
+        name: 'Groq',
+        baseUrl: 'https://api.groq.com/openai/v1',
+        authMethod: 'bearer',
+        envVars: ['GROQ_API_KEY'],
+        requiresApiKey: true,
+        isLocal: false,
+        modelsEndpoint: '/models',
+        openaiCompatible: true,
+        knownModels: [
+            { id: 'llama-3.3-70b-versatile', name: 'Llama 3.3 70B', maxTokens: 128000, capabilities: ['tools', 'json_mode', 'streaming'] },
+            { id: 'llama-3.1-8b-instant', name: 'Llama 3.1 8B', maxTokens: 128000, capabilities: ['tools', 'json_mode', 'streaming'] },
+            { id: 'mixtral-8x7b-32768', name: 'Mixtral 8x7B', maxTokens: 32768, capabilities: ['tools', 'streaming'] },
+            { id: 'gemma2-9b-it', name: 'Gemma 2 9B', maxTokens: 8192, capabilities: ['streaming'] },
+        ],
+    },
+    {
+        id: 'together',
+        name: 'Together AI',
+        baseUrl: 'https://api.together.xyz/v1',
+        authMethod: 'bearer',
+        envVars: ['TOGETHER_API_KEY'],
+        requiresApiKey: true,
+        isLocal: false,
+        modelsEndpoint: '/models',
+        openaiCompatible: true,
+        knownModels: [
+            { id: 'meta-llama/Llama-3.3-70B-Instruct-Turbo', name: 'Llama 3.3 70B Turbo', maxTokens: 128000, capabilities: ['tools', 'streaming'] },
+            { id: 'Qwen/Qwen2.5-72B-Instruct-Turbo', name: 'Qwen 2.5 72B Turbo', maxTokens: 128000, capabilities: ['tools', 'streaming'] },
+            { id: 'deepseek-ai/DeepSeek-V3', name: 'DeepSeek V3', maxTokens: 128000, capabilities: ['tools', 'streaming'] },
+            { id: 'mistralai/Mixtral-8x22B-Instruct-v0.1', name: 'Mixtral 8x22B', maxTokens: 65536, capabilities: ['tools', 'streaming'] },
+        ],
+    },
+    {
+        id: 'fireworks',
+        name: 'Fireworks AI',
+        baseUrl: 'https://api.fireworks.ai/inference/v1',
+        authMethod: 'bearer',
+        envVars: ['FIREWORKS_API_KEY'],
+        requiresApiKey: true,
+        isLocal: false,
+        openaiCompatible: true,
+        knownModels: [
+            { id: 'accounts/fireworks/models/llama-v3p3-70b-instruct', name: 'Llama 3.3 70B', maxTokens: 128000, capabilities: ['tools', 'streaming'] },
+            { id: 'accounts/fireworks/models/deepseek-v3', name: 'DeepSeek V3', maxTokens: 128000, capabilities: ['tools', 'streaming'] },
+            { id: 'accounts/fireworks/models/qwen2p5-72b-instruct', name: 'Qwen 2.5 72B', maxTokens: 128000, capabilities: ['tools', 'streaming'] },
+        ],
+    },
+    {
+        id: 'deepseek',
+        name: 'DeepSeek',
+        baseUrl: 'https://api.deepseek.com/v1',
+        authMethod: 'bearer',
+        envVars: ['DEEPSEEK_API_KEY'],
+        requiresApiKey: true,
+        isLocal: false,
+        modelsEndpoint: '/models',
+        openaiCompatible: true,
+        knownModels: [
+            { id: 'deepseek-chat', name: 'DeepSeek Chat (V3)', maxTokens: 128000, capabilities: ['tools', 'json_mode', 'streaming'] },
+            { id: 'deepseek-reasoner', name: 'DeepSeek Reasoner', maxTokens: 64000, capabilities: ['extended_thinking', 'streaming'] },
+        ],
+    },
+    {
+        id: 'xai',
+        name: 'xAI (Grok)',
+        baseUrl: 'https://api.x.ai/v1',
+        authMethod: 'bearer',
+        envVars: ['XAI_API_KEY'],
+        requiresApiKey: true,
+        isLocal: false,
+        modelsEndpoint: '/models',
+        openaiCompatible: true,
+        knownModels: [
+            { id: 'grok-4', name: 'Grok 4', maxTokens: 131072, capabilities: ['vision', 'tools', 'streaming'] },
+            { id: 'grok-3', name: 'Grok 3', maxTokens: 131072, capabilities: ['vision', 'tools', 'streaming'] },
+            { id: 'grok-3-mini', name: 'Grok 3 Mini', maxTokens: 131072, capabilities: ['tools', 'streaming'] },
+        ],
+    },
+    {
+        id: 'perplexity',
+        name: 'Perplexity',
+        baseUrl: 'https://api.perplexity.ai',
+        authMethod: 'bearer',
+        envVars: ['PERPLEXITY_API_KEY'],
+        requiresApiKey: true,
+        isLocal: false,
+        openaiCompatible: true,
+        knownModels: [
+            { id: 'sonar-pro', name: 'Sonar Pro', maxTokens: 200000, capabilities: ['streaming'] },
+            { id: 'sonar', name: 'Sonar', maxTokens: 128000, capabilities: ['streaming'] },
+            { id: 'sonar-reasoning-pro', name: 'Sonar Reasoning Pro', maxTokens: 128000, capabilities: ['extended_thinking', 'streaming'] },
+            { id: 'sonar-reasoning', name: 'Sonar Reasoning', maxTokens: 128000, capabilities: ['extended_thinking', 'streaming'] },
+        ],
+    },
+    {
+        id: 'openrouter',
+        name: 'OpenRouter',
+        baseUrl: 'https://openrouter.ai/api/v1',
+        authMethod: 'bearer',
+        envVars: ['OPENROUTER_API_KEY'],
+        requiresApiKey: true,
+        isLocal: false,
+        modelsEndpoint: '/models',
+        openaiCompatible: true,
+        knownModels: [
+            { id: 'anthropic/claude-sonnet-4', name: 'Claude Sonnet 4', maxTokens: 200000, capabilities: ['vision', 'tools', 'streaming'] },
+            { id: 'openai/gpt-4o', name: 'GPT-4o', maxTokens: 128000, capabilities: ['vision', 'tools', 'json_mode', 'streaming'] },
+            { id: 'google/gemini-2.0-flash-001', name: 'Gemini 2.0 Flash', maxTokens: 1048576, capabilities: ['vision', 'tools', 'streaming'] },
+            { id: 'meta-llama/llama-3.3-70b-instruct', name: 'Llama 3.3 70B', maxTokens: 128000, capabilities: ['tools', 'streaming'] },
+            { id: 'deepseek/deepseek-chat', name: 'DeepSeek Chat', maxTokens: 128000, capabilities: ['tools', 'streaming'] },
+        ],
+    },
+    {
+        id: 'ollama',
+        name: 'Ollama',
+        baseUrl: 'http://localhost:11434/v1',
+        authMethod: 'none',
+        envVars: [],
+        requiresApiKey: false,
+        isLocal: true,
+        localPort: 11434,
+        modelsEndpoint: '/models',
+        openaiCompatible: true,
+        healthCheckPath: 'http://localhost:11434/',
+        knownModels: [
+            { id: 'llama3.3', name: 'Llama 3.3', maxTokens: 128000, capabilities: ['tools', 'streaming'] },
+            { id: 'codellama', name: 'Code Llama', maxTokens: 16384, capabilities: ['streaming'] },
+            { id: 'mistral', name: 'Mistral 7B', maxTokens: 32000, capabilities: ['tools', 'streaming'] },
+            { id: 'deepseek-coder-v2', name: 'DeepSeek Coder V2', maxTokens: 128000, capabilities: ['tools', 'streaming'] },
+            { id: 'qwen2.5-coder', name: 'Qwen 2.5 Coder', maxTokens: 128000, capabilities: ['tools', 'streaming'] },
+        ],
+    },
+    {
+        id: 'lmstudio',
+        name: 'LM Studio',
+        baseUrl: 'http://localhost:1234/v1',
+        authMethod: 'none',
+        envVars: [],
+        requiresApiKey: false,
+        isLocal: true,
+        localPort: 1234,
+        modelsEndpoint: '/models',
+        openaiCompatible: true,
+        knownModels: [],
+    },
+    {
+        id: 'vllm',
+        name: 'vLLM',
+        baseUrl: 'http://localhost:8000/v1',
+        authMethod: 'none',
+        envVars: [],
+        requiresApiKey: false,
+        isLocal: true,
+        localPort: 8000,
+        modelsEndpoint: '/models',
+        openaiCompatible: true,
+        knownModels: [],
+    },
+];
+export function getProvider(id) {
+    return PROVIDERS.find((p) => p.id === id);
+}
+export function detectProviderFromUrl(baseUrl) {
+    const url = baseUrl.toLowerCase();
+    for (const provider of PROVIDERS) {
+        const providerHost = new URL(provider.baseUrl).hostname;
+        if (url.includes(providerHost))
+            return provider;
+    }
+    for (const provider of PROVIDERS.filter((p) => p.isLocal && p.localPort)) {
+        if (url.includes(`:${provider.localPort}`))
+            return provider;
+    }
+    return undefined;
+}
+export function modelHasCapability(providerId, modelId, capability) {
+    const provider = getProvider(providerId);
+    if (!provider)
+        return false;
+    const model = provider.knownModels.find((m) => m.id === modelId);
+    return model?.capabilities?.includes(capability) ?? false;
+}
+export function buildAuthHeaders(provider, apiKey) {
+    const headers = { 'Content-Type': 'application/json' };
+    switch (provider.authMethod) {
+        case 'bearer':
+            if (apiKey)
+                headers['Authorization'] = `Bearer ${apiKey}`;
+            break;
+        case 'x-api-key':
+            if (apiKey)
+                headers['x-api-key'] = apiKey;
+            break;
+        case 'none':
+            break;
+    }
+    if (provider.extraHeaders) {
+        Object.assign(headers, provider.extraHeaders);
+    }
+    return headers;
+}
+//# sourceMappingURL=providers.js.map

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

@@ -1,5 +1,6 @@
 import axios from 'axios';
 import { configManager } from '../config/config-manager.js';
+import { getProvider, buildAuthHeaders } from '../config/providers.js';
 import { NetworkError, APIError, TimeoutError, ConnectionError, } from '../../errors/network.js';
 import { LLMError, TokenLimitError, RateLimitError, ContextLengthError, } from '../../errors/llm.js';
 import { logger, isLLMLogEnabled } from '../../utils/logger.js';
@@ -23,12 +24,20 @@ export class LLMClient {
         this.apiKey = endpoint.apiKey || '';
         this.model = currentModel.id;
         this.modelName = currentModel.name;
-        this.axiosInstance = axios.create({
-            baseURL: this.baseUrl,
-            headers: {
+        let headers;
+        const providerDef = endpoint.provider ? getProvider(endpoint.provider) : undefined;
+        if (providerDef) {
+            headers = buildAuthHeaders(providerDef, this.apiKey);
+        }
+        else {
+            headers = {
                 'Content-Type': 'application/json',
                 ...(this.apiKey && { Authorization: `Bearer ${this.apiKey}` }),
-            },
+            };
+        }
+        this.axiosInstance = axios.create({
+            baseURL: this.baseUrl,
+            headers,
             timeout: 600000,
         });
     }
@@ -151,7 +160,14 @@ export class LLMClient {
                 throw new Error('INTERRUPTED');
             }
             if (currentAttempt < maxRetries && this.isRetryableError(error)) {
-                const delay = Math.pow(2, currentAttempt - 1) * 1000;
+                let delay = Math.pow(2, currentAttempt - 1) * 1000;
+                if (axios.isAxiosError(error) && error.response?.status === 429) {
+                    const retryAfter = error.response.headers['retry-after'];
+                    if (retryAfter) {
+                        const retryAfterMs = (parseInt(retryAfter, 10) || 1) * 1000;
+                        delay = Math.max(delay, retryAfterMs);
+                    }
+                }
                 logger.debug(`LLM call failed (${currentAttempt}/${maxRetries}), retrying after ${delay}ms...`, {
                     error: error.message,
                     attempt: currentAttempt,

package/dist/orquesta/config-sync.js

@@ -123,7 +123,12 @@ export async function pushConfigsToOrquesta() {
                 Authorization: `Bearer ${orquestaConfig.token}`,
                 'Content-Type': 'application/json',
             },
-            body: JSON.stringify({ endpoints }),
+            body: JSON.stringify({
+                endpoints: endpoints.map(ep => ({
+                    ...ep,
+                    metadata: { provider: ep.provider },
+                })),
+            }),
         });
         if (!response.ok) {
             const errorData = (await response.json());

package/dist/orquesta/connection.d.ts

@@ -1,7 +1,6 @@
 export declare class OrquestaConnection {
     private token;
-    private supabase;
-    private channel;
+    private socket;
     private connectionInfo;
     private connected;
     private heartbeatInterval;
@@ -22,6 +21,7 @@ export declare class OrquestaConnection {
         data: Record<string, unknown>;
     }): Promise<void>;
     private validateToken;
+    private connectSocket;
     private subscribeToChannel;
     private startHeartbeat;
 }

package/dist/orquesta/connection.js

@@ -1,14 +1,10 @@
-import { createClient } from '@supabase/supabase-js';
+import { io } from 'socket.io-client';
 import * as os from 'os';
-import WebSocket from 'ws';
-if (typeof globalThis.WebSocket === 'undefined') {
-    globalThis.WebSocket = WebSocket;
-}
 const ORQUESTA_API = process.env['ORQUESTA_API_URL'] || 'https://orquesta.live';
+const ORQUESTA_WS = process.env['ORQUESTA_WS_URL'] || 'wss://ws.orquesta.live';
 export class OrquestaConnection {
     token;
-    supabase = null;
-    channel = null;
+    socket = null;
     connectionInfo = null;
     connected = false;
     heartbeatInterval = null;
@@ -18,7 +14,7 @@ export class OrquestaConnection {
     async connect() {
         try {
             const validation = await this.validateToken();
-            if (!validation.valid || !validation.supabaseUrl || !validation.supabaseAnonKey) {
+            if (!validation.valid) {
                 return {
                     success: false,
                     error: validation.error || 'Invalid response from server'
@@ -28,19 +24,9 @@ export class OrquestaConnection {
                 projectId: validation.projectId,
                 projectName: validation.projectName,
                 tokenName: validation.tokenName,
-                supabaseUrl: validation.supabaseUrl,
-                supabaseAnonKey: validation.supabaseAnonKey,
                 channelName: validation.channelName,
             };
-            this.supabase = createClient(validation.supabaseUrl, validation.supabaseAnonKey, {
-                realtime: {
-                    params: {
-                        eventsPerSecond: 50,
-                    },
-                    timeout: 30000,
-                    heartbeatIntervalMs: 15000,
-                },
-            });
+            await this.connectSocket();
             await this.subscribeToChannel();
             this.startHeartbeat();
             this.connected = true;
@@ -63,9 +49,13 @@ export class OrquestaConnection {
             clearInterval(this.heartbeatInterval);
             this.heartbeatInterval = null;
         }
-        if (this.channel) {
-            await this.channel.unsubscribe();
-            this.channel = null;
+        if (this.socket) {
+            if (this.connectionInfo) {
+                this.socket.emit('unsubscribe', { channel: this.connectionInfo.channelName });
+            }
+            this.socket.removeAllListeners();
+            this.socket.disconnect();
+            this.socket = null;
         }
         if (this.token) {
             try {
@@ -91,17 +81,18 @@ export class OrquestaConnection {
         };
     }
     async sendSessionEvent(event) {
-        if (!this.channel || !this.connected) {
+        if (!this.socket || !this.connected || !this.connectionInfo) {
             console.warn('Not connected to Orquesta - session event not sent');
             return;
         }
-        await this.channel.send({
-            type: 'broadcast',
+        this.socket.emit('broadcast', {
+            channel: this.connectionInfo.channelName,
             event: event.type,
             payload: {
                 ...event.data,
                 timestamp: Date.now(),
             },
+            self: true,
         });
     }
     async validateToken() {
@@ -123,9 +114,39 @@ export class OrquestaConnection {
         }
         return data;
     }
+    connectSocket() {
+        return new Promise((resolve, reject) => {
+            this.socket = io(ORQUESTA_WS, {
+                auth: { agentToken: this.token },
+                transports: ['websocket'],
+                reconnection: true,
+                reconnectionAttempts: Infinity,
+                reconnectionDelay: 1000,
+                reconnectionDelayMax: 30000,
+            });
+            const onConnect = () => {
+                this.socket?.off('connect_error', onError);
+                resolve();
+            };
+            const onError = (err) => {
+                this.socket?.off('connect', onConnect);
+                this.socket?.disconnect();
+                this.socket = null;
+                reject(new Error(`Socket.io connection failed: ${err.message}`));
+            };
+            this.socket.once('connect', onConnect);
+            this.socket.once('connect_error', onError);
+            this.socket.on('reconnect', () => {
+                if (this.connectionInfo) {
+                    this.subscribeToChannel().catch(() => {
+                    });
+                }
+            });
+        });
+    }
     async subscribeToChannel() {
-        if (!this.supabase || !this.connectionInfo) {
-            throw new Error('Supabase client not initialized');
+        if (!this.socket || !this.connectionInfo) {
+            throw new Error('Socket not initialized');
         }
         const agentInfo = {
             hostname: os.hostname(),
@@ -134,28 +155,16 @@ export class OrquestaConnection {
             type: 'orquesta-cli',
             workingDirectory: process.cwd(),
         };
-        this.channel = this.supabase.channel(this.connectionInfo.channelName, {
-            config: {
-                broadcast: { self: true, ack: true },
-                presence: { key: agentInfo.hostname },
-            },
-        });
-        this.channel.on('broadcast', { event: 'team_message' }, ({ payload }) => {
+        this.socket.emit('subscribe', { channel: this.connectionInfo.channelName });
+        this.socket.on('team_message', (payload) => {
             console.log('Team message:', payload);
         });
-        return new Promise((resolve, reject) => {
-            this.channel.subscribe(async (status) => {
-                if (status === 'SUBSCRIBED') {
-                    await this.channel.track({
-                        ...agentInfo,
-                        connectedAt: new Date().toISOString(),
-                    });
-                    resolve();
-                }
-                else if (status === 'CHANNEL_ERROR' || status === 'TIMED_OUT') {
-                    reject(new Error(`Channel subscription failed: ${status}`));
-                }
-            });
+        this.socket.emit('presence:join', {
+            channel: this.connectionInfo.channelName,
+            user: {
+                ...agentInfo,
+                connectedAt: new Date().toISOString(),
+            },
         });
     }
     startHeartbeat() {

package/dist/setup/first-run-setup.js

@@ -2,6 +2,7 @@ import chalk from 'chalk';
 import ora from 'ora';
 import { configManager } from '../core/config/config-manager.js';
 import { syncOrquestaConfigs, fetchOrquestaProjects } from '../orquesta/config-sync.js';
+import { scanProviders, toEndpointConfig } from '../core/config/auto-detect.js';
 export function needsFirstRunSetup() {
     return !configManager.hasEndpoints() && !configManager.hasOrquestaConnection();
 }
@@ -9,8 +10,39 @@ export async function runFirstRunSetup(token) {
     if (token) {
         return await connectWithToken(token);
     }
+    if (!configManager.hasEndpoints()) {
+        await autoDetectProviders();
+    }
     return { connected: false, skipped: true };
 }
+async function autoDetectProviders() {
+    const spinner = ora({
+        text: chalk.cyan('Scanning for LLM providers...'),
+        color: 'cyan',
+    }).start();
+    try {
+        const result = await scanProviders();
+        if (result.detected.length === 0) {
+            spinner.info(chalk.yellow('No LLM providers detected. Use /config to add endpoints or --scan for details.'));
+            return;
+        }
+        let addedCount = 0;
+        for (const detected of result.detected) {
+            const endpoint = toEndpointConfig(detected);
+            await configManager.addEndpoint(endpoint);
+            addedCount++;
+            if (addedCount === 1 && endpoint.models.length > 0) {
+                await configManager.setCurrentEndpoint(endpoint.id);
+                await configManager.setCurrentModel(endpoint.models[0].id);
+            }
+        }
+        const names = result.detected.map(d => d.provider.name).join(', ');
+        spinner.succeed(chalk.green(`Auto-detected ${addedCount} provider(s): ${names}`));
+    }
+    catch {
+        spinner.info(chalk.dim('Provider auto-detection skipped (network error).'));
+    }
+}
 export async function connectWithToken(token, projectId) {
     const spinner = ora({
         text: chalk.cyan('Validating token...'),

package/dist/types/index.d.ts

@@ -3,6 +3,7 @@ export interface EndpointConfig {
     name: string;
     baseUrl: string;
     apiKey?: string;
+    provider?: string;
     models: ModelInfo[];
     healthCheckInterval?: number;
     priority?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orquesta-cli",
-  "version": "0.1.16",
+  "version": "0.1.17",
   "description": "Orquesta CLI - AI-powered coding assistant with team collaboration",
   "type": "module",
   "main": "dist/index.js",
@@ -88,7 +88,6 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.32.1",
-    "@supabase/supabase-js": "^2.39.0",
     "axios": "^1.6.2",
     "chalk": "^4.1.2",
     "commander": "^11.1.0",
@@ -99,6 +98,7 @@
     "inquirer": "^8.2.6",
     "ora": "^5.4.1",
     "semver": "^7.7.3",
+    "socket.io-client": "^4.8.3",
     "ws": "^8.18.3"
   },
   "devDependencies": {