agentic-flow 1.1.2 → 1.1.4

package/dist/agents/directApiAgent.js

@@ -1,10 +1,12 @@
-// Direct Anthropic API agent with in-process tool execution (no subprocess)
+// Direct API agent with multi-provider support (Anthropic, OpenRouter, Gemini)
 import Anthropic from '@anthropic-ai/sdk';
 import { logger } from '../utils/logger.js';
 import { withRetry } from '../utils/retry.js';
 import { execSync } from 'child_process';
-// Lazy initialize Anthropic client to allow runtime API key validation
+import { ModelRouter } from '../router/router.js';
+// Lazy initialize clients
 let anthropic = null;
+let router = null;
 function getAnthropicClient() {
     if (!anthropic) {
         const apiKey = process.env.ANTHROPIC_API_KEY;
@@ -21,6 +23,26 @@ function getAnthropicClient() {
     }
     return anthropic;
 }
+function getRouter() {
+    if (!router) {
+        // Router will now auto-create config from environment variables if no file exists
+        router = new ModelRouter();
+    }
+    return router;
+}
+function getCurrentProvider() {
+    // Determine provider from environment
+    if (process.env.PROVIDER === 'gemini' || process.env.USE_GEMINI === 'true') {
+        return 'gemini';
+    }
+    if (process.env.PROVIDER === 'openrouter' || process.env.USE_OPENROUTER === 'true') {
+        return 'openrouter';
+    }
+    if (process.env.PROVIDER === 'onnx' || process.env.USE_ONNX === 'true') {
+        return 'onnx';
+    }
+    return 'anthropic';
+}
 // Define claude-flow tools as native Anthropic tool definitions
 const claudeFlowTools = [
     {
@@ -194,31 +216,95 @@ export async function directApiAgent(agent, input, onStream) {
         // Agentic loop: keep calling API until no more tool uses
         while (toolUseCount < maxToolUses) {
             logger.debug('API call iteration', { toolUseCount, messagesLength: messages.length });
-            const client = getAnthropicClient();
+            const provider = getCurrentProvider();
             let response;
             try {
-                response = await client.messages.create({
-                    model: 'claude-sonnet-4-5-20250929',
-                    max_tokens: 8192,
-                    system: agent.systemPrompt || 'You are a helpful AI assistant.',
-                    messages,
-                    tools: claudeFlowTools
-                });
+                // Use router for non-Anthropic providers
+                if (provider === 'gemini' || provider === 'openrouter') {
+                    const routerInstance = getRouter();
+                    // Convert Anthropic messages format to router format
+                    const routerMessages = messages.map(msg => ({
+                        role: msg.role,
+                        content: typeof msg.content === 'string' ? msg.content : msg.content.map((block) => {
+                            if ('text' in block)
+                                return { type: 'text', text: block.text };
+                            if ('tool_use_id' in block)
+                                return {
+                                    type: 'tool_result',
+                                    content: block.content
+                                };
+                            if ('name' in block && 'input' in block)
+                                return {
+                                    type: 'tool_use',
+                                    id: block.id,
+                                    name: block.name,
+                                    input: block.input
+                                };
+                            return { type: 'text', text: '' };
+                        }).filter((b) => b.type === 'text' || b.type === 'tool_use' || b.type === 'tool_result')
+                    }));
+                    // Add system prompt as first message if needed
+                    const messagesWithSystem = agent.systemPrompt
+                        ? [{ role: 'system', content: agent.systemPrompt }, ...routerMessages]
+                        : routerMessages;
+                    const params = {
+                        model: provider === 'gemini'
+                            ? (process.env.COMPLETION_MODEL || 'gemini-2.0-flash-exp')
+                            : (process.env.COMPLETION_MODEL || 'meta-llama/llama-3.1-8b-instruct'),
+                        messages: messagesWithSystem,
+                        maxTokens: 8192,
+                        temperature: 0.7
+                    };
+                    const routerResponse = await routerInstance.chat(params);
+                    // Convert router response to Anthropic format
+                    response = {
+                        id: routerResponse.id,
+                        model: routerResponse.model,
+                        stop_reason: routerResponse.stopReason,
+                        content: routerResponse.content.map(block => {
+                            if (block.type === 'text')
+                                return { type: 'text', text: block.text || '' };
+                            if (block.type === 'tool_use')
+                                return {
+                                    type: 'tool_use',
+                                    id: block.id || '',
+                                    name: block.name || '',
+                                    input: block.input || {}
+                                };
+                            return { type: 'text', text: '' };
+                        })
+                    };
+                }
+                else {
+                    // Use Anthropic client for Anthropic provider
+                    const client = getAnthropicClient();
+                    response = await client.messages.create({
+                        model: process.env.COMPLETION_MODEL || 'claude-sonnet-4-5-20250929',
+                        max_tokens: 8192,
+                        system: agent.systemPrompt || 'You are a helpful AI assistant.',
+                        messages,
+                        tools: claudeFlowTools
+                    });
+                }
             }
             catch (error) {
                 // Enhance authentication errors with helpful guidance
-                if (error?.status === 401) {
-                    const apiKey = process.env.ANTHROPIC_API_KEY;
-                    throw new Error(`❌ Anthropic API authentication failed (401)\n\n` +
+                if (error?.status === 401 || error?.statusCode === 401) {
+                    const providerName = provider === 'gemini' ? 'Google Gemini' : provider === 'openrouter' ? 'OpenRouter' : 'Anthropic';
+                    const apiKey = provider === 'gemini'
+                        ? process.env.GOOGLE_GEMINI_API_KEY
+                        : provider === 'openrouter'
+                            ? process.env.OPENROUTER_API_KEY
+                            : process.env.ANTHROPIC_API_KEY;
+                    throw new Error(`❌ ${providerName} API authentication failed (401)\n\n` +
                         `Your API key is invalid, expired, or lacks permissions.\n` +
                         `Current key: ${apiKey?.substring(0, 15)}...\n\n` +
-                        `Please:\n` +
-                        `  1. Check your key at: https://console.anthropic.com/settings/keys\n` +
-                        `  2. Verify it's not expired\n` +
-                        `  3. Ensure it has proper permissions\n` +
-                        `  4. Update your .env file with: ANTHROPIC_API_KEY=sk-ant-...\n\n` +
-                        `Alternative: Use OpenRouter instead (--model "meta-llama/llama-3.1-8b-instruct")\n` +
-                        `Or use local ONNX (--provider onnx)`);
+                        `Please check your ${providerName} API key and update your .env file.\n\n` +
+                        `Alternative providers:\n` +
+                        `  --provider anthropic  (Claude models)\n` +
+                        `  --provider openrouter (100+ models, 99% cost savings)\n` +
+                        `  --provider gemini     (Google models)\n` +
+                        `  --provider onnx       (free local inference)`);
                 }
                 throw error;
             }
@@ -272,9 +358,9 @@ export async function directApiAgent(agent, input, onStream) {
                 });
             }
             // Stop if no tool use or end_turn
-            if (response.stop_reason === 'end_turn' || response.content.every(b => b.type === 'text')) {
+            if (response.stop_reason === 'end_turn' || response.content.every((b) => b.type === 'text')) {
                 // Add final assistant message if it has text
-                const textContent = response.content.filter(b => b.type === 'text');
+                const textContent = response.content.filter((b) => b.type === 'text');
                 if (textContent.length > 0 && messages[messages.length - 1].role !== 'assistant') {
                     messages.push({
                         role: 'assistant',

package/dist/cli-proxy.js

@@ -3,7 +3,27 @@
  * Agentic Flow - Standalone CLI with integrated OpenRouter proxy
  * Usage: npx agentic-flow-proxy --agent coder --task "Create code" --openrouter
  */
-import "dotenv/config";
+import dotenv from "dotenv";
+import { existsSync, readFileSync } from 'fs';
+import { resolve as pathResolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+// Load .env from current directory, or search up the directory tree
+function loadEnvRecursive(startPath = process.cwd()) {
+    let currentPath = startPath;
+    const root = pathResolve('/');
+    while (currentPath !== root) {
+        const envPath = pathResolve(currentPath, '.env');
+        if (existsSync(envPath)) {
+            dotenv.config({ path: envPath });
+            return true;
+        }
+        currentPath = pathResolve(currentPath, '..');
+    }
+    // Fallback to default behavior
+    dotenv.config();
+    return false;
+}
+loadEnvRecursive();
 import { AnthropicToOpenRouterProxy } from "./proxy/anthropic-to-openrouter.js";
 import { logger } from "./utils/logger.js";
 import { parseArgs } from "./utils/cli.js";
@@ -12,18 +32,19 @@ import { directApiAgent } from "./agents/directApiAgent.js";
 import { handleConfigCommand } from "./cli/config-wizard.js";
 import { handleAgentCommand } from "./cli/agent-manager.js";
 import { ModelOptimizer } from "./utils/modelOptimizer.js";
-import { readFileSync } from 'fs';
-import { resolve, dirname } from 'path';
-import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-const packageJson = JSON.parse(readFileSync(resolve(__dirname, '../package.json'), 'utf-8'));
+const packageJson = JSON.parse(readFileSync(pathResolve(__dirname, '../package.json'), 'utf-8'));
 const VERSION = packageJson.version;
 class AgenticFlowCLI {
     proxyServer = null;
     proxyPort = 3000;
     async start() {
         const options = parseArgs();
+        if (options.version) {
+            console.log(`agentic-flow v${VERSION}`);
+            process.exit(0);
+        }
         if (options.help) {
             this.printHelp();
             process.exit(0);
@@ -193,6 +214,10 @@ class AgenticFlowCLI {
             this.printHelp();
             process.exit(1);
         }
+        // Set PROVIDER environment variable if --provider flag is used
+        if (options.provider) {
+            process.env.PROVIDER = options.provider;
+        }
         // Check for API key (unless using ONNX)
         const isOnnx = options.provider === 'onnx' || process.env.USE_ONNX === 'true' || process.env.PROVIDER === 'onnx';
         if (!isOnnx && !useOpenRouter && !useGemini && !process.env.ANTHROPIC_API_KEY) {

package/dist/router/providers/gemini.js

@@ -4,18 +4,16 @@ export class GeminiProvider {
     name = 'gemini';
     type = 'gemini';
     supportsStreaming = true;
-    supportsTools = false; // Will add function calling support later
+    supportsTools = false;
     supportsMCP = false;
-    client; // GoogleGenAI instance
+    client;
     config;
     constructor(config) {
         this.config = config;
         if (!config.apiKey) {
             throw new Error('Google Gemini API key is required');
         }
-        this.client = new GoogleGenAI({
-            apiKey: config.apiKey
-        });
+        this.client = new GoogleGenAI({ apiKey: config.apiKey });
     }
     validateCapabilities(features) {
         const supported = ['chat', 'streaming'];
@@ -23,37 +21,33 @@ export class GeminiProvider {
     }
     async chat(params) {
         try {
-            const startTime = Date.now();
-            // Convert messages format
-            const contents = this.convertMessages(params.messages);
+            // Convert messages to Gemini format
+            const contents = params.messages.map(msg => ({
+                role: msg.role === 'assistant' ? 'model' : 'user',
+                parts: [{ text: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content) }]
+            }));
             const response = await this.client.models.generateContent({
                 model: params.model || 'gemini-2.0-flash-exp',
                 contents,
-                generationConfig: {
+                config: {
                     temperature: params.temperature,
-                    maxOutputTokens: params.maxTokens || 4096
+                    maxOutputTokens: params.maxTokens || 8192
                 }
             });
-            const latency = Date.now() - startTime;
-            // Extract text from response
             const text = response.text || '';
-            const usage = {
-                inputTokens: response.usageMetadata?.promptTokenCount || 0,
-                outputTokens: response.usageMetadata?.candidatesTokenCount || 0
-            };
             return {
-                id: `gemini-${Date.now()}`,
+                id: crypto.randomUUID(),
                 model: params.model || 'gemini-2.0-flash-exp',
-                content: [{
-                        type: 'text',
-                        text
-                    }],
-                stopReason: response.candidates?.[0]?.finishReason === 'STOP' ? 'end_turn' : 'max_tokens',
-                usage,
+                content: [{ type: 'text', text }],
+                stopReason: 'end_turn',
+                usage: {
+                    inputTokens: response.usageMetadata?.promptTokenCount || 0,
+                    outputTokens: response.usageMetadata?.candidatesTokenCount || 0
+                },
                 metadata: {
                     provider: 'gemini',
-                    cost: this.calculateCost(usage),
-                    latency
+                    cost: this.calculateCost(response.usageMetadata || {}),
+                    latency: 0
                 }
             };
         }
@@ -63,25 +57,24 @@ export class GeminiProvider {
     }
     async *stream(params) {
         try {
-            // Convert messages format
-            const contents = this.convertMessages(params.messages);
-            const response = await this.client.models.generateContentStream({
+            const contents = params.messages.map(msg => ({
+                role: msg.role === 'assistant' ? 'model' : 'user',
+                parts: [{ text: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content) }]
+            }));
+            const stream = await this.client.models.generateContentStream({
                 model: params.model || 'gemini-2.0-flash-exp',
                 contents,
-                generationConfig: {
+                config: {
                     temperature: params.temperature,
-                    maxOutputTokens: params.maxTokens || 4096
+                    maxOutputTokens: params.maxTokens || 8192
                 }
             });
-            for await (const chunk of response) {
+            for await (const chunk of stream) {
                 const text = chunk.text || '';
                 if (text) {
                     yield {
                         type: 'content_block_delta',
-                        delta: {
-                            type: 'text_delta',
-                            text
-                        }
+                        delta: { type: 'text_delta', text }
                     };
                 }
             }
@@ -90,30 +83,13 @@ export class GeminiProvider {
             throw this.handleError(error);
         }
     }
-    convertMessages(messages) {
-        // Gemini expects a single prompt string for simple use cases
-        // For more complex scenarios, we'd use the chat history format
-        return messages
-            .map(msg => {
-            if (typeof msg.content === 'string') {
-                return `${msg.role === 'user' ? 'User' : 'Assistant'}: ${msg.content}`;
-            }
-            else if (Array.isArray(msg.content)) {
-                const texts = msg.content
-                    .filter((block) => block.type === 'text')
-                    .map((block) => block.text)
-                    .join('\n');
-                return `${msg.role === 'user' ? 'User' : 'Assistant'}: ${texts}`;
-            }
-            return '';
-        })
-            .filter(Boolean)
-            .join('\n\n');
-    }
     calculateCost(usage) {
-        // Gemini 2.0 Flash pricing: Free up to rate limits, then ~$0.075/MTok input, $0.30/MTok output
-        const inputCost = (usage.inputTokens / 1_000_000) * 0.075;
-        const outputCost = (usage.outputTokens / 1_000_000) * 0.30;
+        // Gemini pricing varies by model
+        const inputTokens = usage.promptTokenCount || 0;
+        const outputTokens = usage.candidatesTokenCount || 0;
+        // Flash pricing: Free tier or low cost
+        const inputCost = (inputTokens / 1_000_000) * 0.075;
+        const outputCost = (outputTokens / 1_000_000) * 0.3;
         return inputCost + outputCost;
     }
     handleError(error) {

package/dist/router/router.js

@@ -21,6 +21,7 @@ export class ModelRouter {
             process.env.AGENTIC_FLOW_ROUTER_CONFIG,
             join(homedir(), '.agentic-flow', 'router.config.json'),
             join(process.cwd(), 'router.config.json'),
+            join(process.cwd(), 'config', 'router.config.json'),
             join(process.cwd(), 'router.config.example.json')
         ].filter(Boolean);
         for (const path of paths) {
@@ -31,7 +32,43 @@ export class ModelRouter {
                 return this.substituteEnvVars(config);
             }
         }
-        throw new Error('No router configuration file found');
+        // If no config file found, create config from environment variables
+        return this.createConfigFromEnv();
+    }
+    createConfigFromEnv() {
+        // Create minimal config from environment variables
+        const config = {
+            version: '1.0',
+            defaultProvider: process.env.PROVIDER || 'anthropic',
+            routing: { mode: 'manual' },
+            providers: {}
+        };
+        // Add Anthropic if API key exists
+        if (process.env.ANTHROPIC_API_KEY) {
+            config.providers.anthropic = {
+                apiKey: process.env.ANTHROPIC_API_KEY,
+                baseUrl: process.env.ANTHROPIC_BASE_URL
+            };
+        }
+        // Add OpenRouter if API key exists
+        if (process.env.OPENROUTER_API_KEY) {
+            config.providers.openrouter = {
+                apiKey: process.env.OPENROUTER_API_KEY,
+                baseUrl: process.env.OPENROUTER_BASE_URL
+            };
+        }
+        // Add Gemini if API key exists
+        if (process.env.GOOGLE_GEMINI_API_KEY) {
+            config.providers.gemini = {
+                apiKey: process.env.GOOGLE_GEMINI_API_KEY
+            };
+        }
+        // ONNX is always available (no API key needed)
+        config.providers.onnx = {
+            modelPath: process.env.ONNX_MODEL_PATH,
+            executionProviders: ['cpu']
+        };
+        return config;
     }
     substituteEnvVars(obj) {
         if (typeof obj === 'string') {
@@ -54,15 +91,18 @@ export class ModelRouter {
         return obj;
     }
     initializeProviders() {
+        const verbose = process.env.ROUTER_VERBOSE === 'true';
         // Initialize Anthropic
         if (this.config.providers.anthropic) {
             try {
                 const provider = new AnthropicProvider(this.config.providers.anthropic);
                 this.providers.set('anthropic', provider);
-                console.log('✅ Anthropic provider initialized');
+                if (verbose)
+                    console.log('✅ Anthropic provider initialized');
             }
             catch (error) {
-                console.error('❌ Failed to initialize Anthropic:', error);
+                if (verbose)
+                    console.error('❌ Failed to initialize Anthropic:', error);
             }
         }
         // Initialize OpenRouter
@@ -70,10 +110,12 @@ export class ModelRouter {
             try {
                 const provider = new OpenRouterProvider(this.config.providers.openrouter);
                 this.providers.set('openrouter', provider);
-                console.log('✅ OpenRouter provider initialized');
+                if (verbose)
+                    console.log('✅ OpenRouter provider initialized');
             }
             catch (error) {
-                console.error('❌ Failed to initialize OpenRouter:', error);
+                if (verbose)
+                    console.error('❌ Failed to initialize OpenRouter:', error);
             }
         }
         // Initialize ONNX Local
@@ -86,10 +128,12 @@ export class ModelRouter {
                     temperature: this.config.providers.onnx.temperature || 0.7
                 });
                 this.providers.set('onnx', provider);
-                console.log('✅ ONNX Local provider initialized');
+                if (verbose)
+                    console.log('✅ ONNX Local provider initialized');
             }
             catch (error) {
-                console.error('❌ Failed to initialize ONNX:', error);
+                if (verbose)
+                    console.error('❌ Failed to initialize ONNX:', error);
             }
         }
         // Initialize Gemini
@@ -97,10 +141,12 @@ export class ModelRouter {
             try {
                 const provider = new GeminiProvider(this.config.providers.gemini);
                 this.providers.set('gemini', provider);
-                console.log('✅ Gemini provider initialized');
+                if (verbose)
+                    console.log('✅ Gemini provider initialized');
             }
             catch (error) {
-                console.error('❌ Failed to initialize Gemini:', error);
+                if (verbose)
+                    console.error('❌ Failed to initialize Gemini:', error);
             }
         }
         // TODO: Initialize other providers (OpenAI, Ollama, LiteLLM)

package/dist/utils/cli.js

@@ -28,6 +28,10 @@ export function parseArgs() {
             case '-h':
                 options.help = true;
                 break;
+            case '--version':
+            case '-v':
+                options.version = true;
+                break;
             case '--agent':
             case '-a':
                 options.mode = 'agent';

package/dist/utils/logger.js

@@ -26,6 +26,10 @@ class Logger {
         }
     }
     debug(message, data) {
+        // Skip debug logs unless DEBUG or VERBOSE environment variable is set
+        if (!process.env.DEBUG && !process.env.VERBOSE) {
+            return;
+        }
         this.log('debug', message, data);
     }
     info(message, data) {