agentic-flow 1.1.5 → 1.1.8

package/dist/agents/claudeAgent.js

@@ -1,73 +1,207 @@
-// Generic agent that uses .claude/agents definitions
+// Generic agent that uses .claude/agents definitions with multi-provider SDK routing
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import { logger } from "../utils/logger.js";
 import { withRetry } from "../utils/retry.js";
 import { claudeFlowSdkServer } from "../mcp/claudeFlowSdkServer.js";
+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'; // Default
+}
+function getModelForProvider(provider) {
+    switch (provider) {
+        case 'gemini':
+            return {
+                model: process.env.COMPLETION_MODEL || 'gemini-2.0-flash-exp',
+                apiKey: process.env.GOOGLE_GEMINI_API_KEY || process.env.ANTHROPIC_API_KEY || '',
+                baseURL: process.env.PROXY_URL || undefined
+            };
+        case 'openrouter':
+            return {
+                model: process.env.COMPLETION_MODEL || 'meta-llama/llama-3.1-8b-instruct',
+                apiKey: process.env.OPENROUTER_API_KEY || process.env.ANTHROPIC_API_KEY || '',
+                baseURL: process.env.PROXY_URL || undefined
+            };
+        case 'onnx':
+            return {
+                model: 'onnx-local',
+                apiKey: 'local',
+                baseURL: process.env.PROXY_URL || undefined
+            };
+        case 'anthropic':
+        default:
+            // For anthropic provider, require ANTHROPIC_API_KEY
+            const apiKey = process.env.ANTHROPIC_API_KEY;
+            if (!apiKey) {
+                throw new Error('ANTHROPIC_API_KEY is required but not set for Anthropic provider');
+            }
+            return {
+                model: process.env.COMPLETION_MODEL || 'claude-sonnet-4-5-20250929',
+                apiKey,
+                // No baseURL for direct Anthropic
+            };
+    }
+}
 export async function claudeAgent(agent, input, onStream, modelOverride) {
     const startTime = Date.now();
-    logger.info('Starting Claude agent', {
+    const provider = getCurrentProvider();
+    logger.info('Starting Claude Agent SDK with multi-provider support', {
         agent: agent.name,
+        provider,
         input: input.substring(0, 100),
         model: modelOverride || 'default'
     });
     return withRetry(async () => {
-        // Quad MCP server setup: in-SDK + claude-flow + flow-nexus + agentic-payments
-        const result = query({
-            prompt: input,
-            options: {
+        // Get model configuration for the selected provider
+        const modelConfig = getModelForProvider(provider);
+        const finalModel = modelOverride || modelConfig.model;
+        // Configure environment for Claude Agent SDK with proxy routing
+        // The SDK internally uses Anthropic client which reads ANTHROPIC_BASE_URL and ANTHROPIC_API_KEY
+        const envOverrides = {};
+        if (provider === 'gemini' && process.env.GOOGLE_GEMINI_API_KEY) {
+            // For Gemini: Route through translation proxy
+            // Proxy runs on port 3001 and translates Anthropic API → Gemini API
+            envOverrides.ANTHROPIC_API_KEY = 'proxy-key'; // Proxy handles real auth
+            envOverrides.ANTHROPIC_BASE_URL = process.env.GEMINI_PROXY_URL || 'http://localhost:3001';
+            logger.info('Using Gemini proxy', {
+                proxyUrl: envOverrides.ANTHROPIC_BASE_URL,
+                model: finalModel
+            });
+        }
+        else if (provider === 'openrouter' && process.env.OPENROUTER_API_KEY) {
+            // For OpenRouter: Route through translation proxy
+            // Proxy runs on port 3000 and translates Anthropic API → OpenRouter API
+            envOverrides.ANTHROPIC_API_KEY = 'proxy-key'; // Proxy handles real auth
+            envOverrides.ANTHROPIC_BASE_URL = process.env.OPENROUTER_PROXY_URL || 'http://localhost:3000';
+            logger.info('Using OpenRouter proxy', {
+                proxyUrl: envOverrides.ANTHROPIC_BASE_URL,
+                model: finalModel
+            });
+        }
+        else if (provider === 'onnx') {
+            // For ONNX: Local inference (TODO: implement ONNX proxy)
+            envOverrides.ANTHROPIC_API_KEY = 'local';
+            if (modelConfig.baseURL) {
+                envOverrides.ANTHROPIC_BASE_URL = modelConfig.baseURL;
+            }
+        }
+        // For Anthropic provider, use existing ANTHROPIC_API_KEY (no proxy needed)
+        logger.info('Multi-provider configuration', {
+            provider,
+            model: finalModel,
+            hasApiKey: !!envOverrides.ANTHROPIC_API_KEY || !!process.env.ANTHROPIC_API_KEY,
+            hasBaseURL: !!envOverrides.ANTHROPIC_BASE_URL
+        });
+        try {
+            // MCP server setup - enable in-SDK server and optional external servers
+            const mcpServers = {};
+            // Enable in-SDK MCP server for custom tools
+            if (process.env.ENABLE_CLAUDE_FLOW_SDK === 'true') {
+                mcpServers['claude-flow-sdk'] = claudeFlowSdkServer;
+            }
+            // Optional external MCP servers (disabled by default to avoid subprocess failures)
+            // Enable by setting ENABLE_CLAUDE_FLOW_MCP=true or ENABLE_FLOW_NEXUS_MCP=true
+            if (process.env.ENABLE_CLAUDE_FLOW_MCP === 'true') {
+                mcpServers['claude-flow'] = {
+                    type: 'stdio',
+                    command: 'npx',
+                    args: ['claude-flow@alpha', 'mcp', 'start'],
+                    env: {
+                        ...process.env,
+                        MCP_AUTO_START: 'true',
+                        PROVIDER: provider
+                    }
+                };
+            }
+            if (process.env.ENABLE_FLOW_NEXUS_MCP === 'true') {
+                mcpServers['flow-nexus'] = {
+                    type: 'stdio',
+                    command: 'npx',
+                    args: ['flow-nexus@latest', 'mcp', 'start'],
+                    env: {
+                        ...process.env,
+                        FLOW_NEXUS_AUTO_START: 'true'
+                    }
+                };
+            }
+            if (process.env.ENABLE_AGENTIC_PAYMENTS_MCP === 'true') {
+                mcpServers['agentic-payments'] = {
+                    type: 'stdio',
+                    command: 'npx',
+                    args: ['-y', 'agentic-payments', 'mcp'],
+                    env: {
+                        ...process.env,
+                        AGENTIC_PAYMENTS_AUTO_START: 'true'
+                    }
+                };
+            }
+            const queryOptions = {
                 systemPrompt: agent.systemPrompt,
-                model: modelOverride, // Support custom models like OpenRouter
+                model: finalModel, // Claude Agent SDK handles model selection
                 permissionMode: 'bypassPermissions', // Auto-approve all tool usage for Docker automation
-                mcpServers: {
-                    // In-SDK server: 6 basic tools (memory + swarm)
-                    'claude-flow-sdk': claudeFlowSdkServer,
-                    // Full MCP server: 101 tools via subprocess (neural, analysis, workflow, github, daa, system)
-                    'claude-flow': {
-                        command: 'npx',
-                        args: ['claude-flow@alpha', 'mcp', 'start'],
-                        env: {
-                            ...process.env,
-                            MCP_AUTO_START: 'true'
-                        }
-                    },
-                    // Flow Nexus MCP server: 96 cloud tools (sandboxes, swarms, neural, workflows)
-                    'flow-nexus': {
-                        command: 'npx',
-                        args: ['flow-nexus@latest', 'mcp', 'start'],
-                        env: {
-                            ...process.env,
-                            FLOW_NEXUS_AUTO_START: 'true'
-                        }
-                    },
-                    // Agentic Payments MCP server: Payment authorization and multi-agent consensus
-                    'agentic-payments': {
-                        command: 'npx',
-                        args: ['-y', 'agentic-payments', 'mcp'],
-                        env: {
-                            ...process.env,
-                            AGENTIC_PAYMENTS_AUTO_START: 'true'
-                        }
-                    }
-                }
-                // allowedTools: removed to enable ALL tools from all servers
+                // Enable all built-in tools by default (Read, Write, Edit, Bash, Glob, Grep, WebFetch, WebSearch)
+                // Based on SDK types, allowedTools and disallowedTools control which tools are available
+                // If not specified, all tools are enabled by default
+                allowedTools: [
+                    'Read',
+                    'Write',
+                    'Edit',
+                    'Bash',
+                    'Glob',
+                    'Grep',
+                    'WebFetch',
+                    'WebSearch',
+                    'NotebookEdit',
+                    'TodoWrite'
+                ],
+                // Add MCP servers if configured
+                mcpServers: Object.keys(mcpServers).length > 0 ? mcpServers : undefined
+            };
+            // Add environment overrides if present
+            if (Object.keys(envOverrides).length > 0) {
+                queryOptions.env = {
+                    ...process.env,
+                    ...envOverrides
+                };
             }
-        });
-        let output = '';
-        for await (const msg of result) {
-            if (msg.type === 'assistant') {
-                const chunk = msg.message.content?.map((c) => c.type === 'text' ? c.text : '').join('') || '';
-                output += chunk;
-                if (onStream && chunk) {
-                    onStream(chunk);
+            const result = query({
+                prompt: input,
+                options: queryOptions
+            });
+            let output = '';
+            for await (const msg of result) {
+                if (msg.type === 'assistant') {
+                    const chunk = msg.message.content?.map((c) => c.type === 'text' ? c.text : '').join('') || '';
+                    output += chunk;
+                    if (onStream && chunk) {
+                        onStream(chunk);
+                    }
                 }
             }
+            const duration = Date.now() - startTime;
+            logger.info('Claude Agent SDK completed', {
+                agent: agent.name,
+                provider,
+                duration,
+                outputLength: output.length
+            });
+            return { output, agent: agent.name };
+        }
+        catch (error) {
+            logger.error('Claude Agent SDK execution failed', {
+                provider,
+                model: finalModel,
+                error: error.message
+            });
+            throw error;
         }
-        const duration = Date.now() - startTime;
-        logger.info('Claude agent completed', {
-            agent: agent.name,
-            duration,
-            outputLength: output.length
-        });
-        return { output, agent: agent.name };
     });
 }

package/dist/agents/directApiAgent.js

@@ -253,8 +253,7 @@ export async function directApiAgent(agent, input, onStream) {
                             : (process.env.COMPLETION_MODEL || 'meta-llama/llama-3.1-8b-instruct'),
                         messages: messagesWithSystem,
                         maxTokens: 8192,
-                        temperature: 0.7,
-                        provider: provider // Force the router to use this specific provider
+                        temperature: 0.7
                     };
                     const routerResponse = await routerInstance.chat(params);
                     // Convert router response to Anthropic format

package/dist/agents/sdkAgent.js

@@ -0,0 +1,151 @@
+// Claude Agent SDK with multi-provider proxy routing
+// Architecture: SDK → Proxy Router → Multi-provider (Anthropic/OpenRouter/Gemini/ONNX)
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { logger } from '../utils/logger.js';
+import { withRetry } from '../utils/retry.js';
+import { ModelRouter } from '../router/router.js';
+import { claudeFlowSdkServer } from '../mcp/claudeFlowSdkServer.js';
+// Lazy initialize router
+let router = null;
+function getRouter() {
+    if (!router) {
+        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'; // Default
+}
+/**
+ * Get model configuration for the specified provider
+ * Returns model name, API key, and optional proxy URL for routing
+ */
+function getModelForProvider(provider) {
+    switch (provider) {
+        case 'gemini':
+            return {
+                model: process.env.COMPLETION_MODEL || 'gemini-2.0-flash-exp',
+                apiKey: process.env.GOOGLE_GEMINI_API_KEY || process.env.ANTHROPIC_API_KEY || '',
+                baseURL: process.env.PROXY_URL || undefined // Optional: Proxy routes SDK calls to Gemini
+            };
+        case 'openrouter':
+            return {
+                model: process.env.COMPLETION_MODEL || 'meta-llama/llama-3.1-8b-instruct',
+                apiKey: process.env.OPENROUTER_API_KEY || process.env.ANTHROPIC_API_KEY || '',
+                baseURL: process.env.PROXY_URL || undefined // Optional: Proxy routes SDK calls to OpenRouter
+            };
+        case 'onnx':
+            return {
+                model: 'onnx-local',
+                apiKey: 'local', // Not needed for local inference
+                baseURL: process.env.PROXY_URL || undefined // Optional: Proxy routes to ONNX runtime
+            };
+        case 'anthropic':
+        default:
+            const apiKey = process.env.ANTHROPIC_API_KEY;
+            if (!apiKey) {
+                throw new Error('ANTHROPIC_API_KEY is required but not set');
+            }
+            if (!apiKey.startsWith('sk-ant-')) {
+                throw new Error(`Invalid ANTHROPIC_API_KEY format. Expected: sk-ant-...\\n` +
+                    `Got: ${apiKey.substring(0, 10)}...`);
+            }
+            return {
+                model: process.env.COMPLETION_MODEL || 'claude-sonnet-4-5-20250929',
+                apiKey,
+                // No baseURL for direct Anthropic - SDK uses official endpoint
+            };
+    }
+}
+/**
+ * Main agent execution using Claude Agent SDK
+ * The SDK handles tool calling, streaming, and conversation management
+ * The proxy router enables multi-provider support (Anthropic/OpenRouter/Gemini/ONNX)
+ */
+export async function sdkAgent(agent, input, onStream) {
+    const startTime = Date.now();
+    const provider = getCurrentProvider();
+    logger.info('Starting Claude Agent SDK with multi-provider routing', {
+        agent: agent.name,
+        provider,
+        input: input.substring(0, 100)
+    });
+    return withRetry(async () => {
+        // Get the model configuration for the selected provider
+        const modelConfig = getModelForProvider(provider);
+        logger.info('Provider configuration', {
+            provider,
+            model: modelConfig.model,
+            hasProxy: !!modelConfig.baseURL,
+            proxyUrl: modelConfig.baseURL
+        });
+        // Build Claude Agent SDK options
+        const queryOptions = {
+            systemPrompt: agent.systemPrompt || 'You are a helpful AI assistant.',
+            model: modelConfig.model,
+            permissionMode: 'bypassPermissions', // Auto-approve tools for automation
+            // Configure SDK's Anthropic client
+            // If baseURL is set, it acts as a proxy that routes to different providers
+            anthropicOptions: {
+                apiKey: modelConfig.apiKey,
+                ...(modelConfig.baseURL && { baseURL: modelConfig.baseURL })
+            },
+            // Attach MCP servers for tool access (111 tools from claude-flow)
+            mcpServers: {
+                // In-SDK server: Basic memory + coordination tools
+                'claude-flow-sdk': claudeFlowSdkServer,
+                // Full MCP server: 101 advanced tools
+                'claude-flow': {
+                    command: 'npx',
+                    args: ['claude-flow@alpha', 'mcp', 'start'],
+                    env: {
+                        ...process.env,
+                        MCP_AUTO_START: 'true',
+                        PROVIDER: provider // Pass provider to MCP tools
+                    }
+                }
+            }
+        };
+        // Execute with Claude Agent SDK
+        // The SDK handles:
+        // - Tool calling loops
+        // - Streaming
+        // - Error handling
+        // - Conversation management
+        let output = '';
+        const result = query({
+            prompt: input,
+            options: queryOptions
+        });
+        for await (const msg of result) {
+            if (msg.type === 'assistant') {
+                const chunk = msg.message.content
+                    ?.map((c) => c.type === 'text' ? c.text : '')
+                    .join('') || '';
+                output += chunk;
+                if (onStream && chunk) {
+                    onStream(chunk);
+                }
+            }
+        }
+        const duration = Date.now() - startTime;
+        logger.info('Claude Agent SDK completed', {
+            agent: agent.name,
+            provider,
+            model: modelConfig.model,
+            duration,
+            outputLength: output.length
+        });
+        return { output, agent: agent.name };
+    });
+}

package/dist/cli-proxy.js

@@ -28,7 +28,7 @@ import { AnthropicToOpenRouterProxy } from "./proxy/anthropic-to-openrouter.js";
 import { logger } from "./utils/logger.js";
 import { parseArgs } from "./utils/cli.js";
 import { getAgent, listAgents } from "./utils/agentLoader.js";
-import { directApiAgent } from "./agents/directApiAgent.js";
+import { claudeAgent } from "./agents/claudeAgent.js";
 import { handleConfigCommand } from "./cli/config-wizard.js";
 import { handleAgentCommand } from "./cli/agent-manager.js";
 import { ModelOptimizer } from "./utils/modelOptimizer.js";
@@ -286,8 +286,8 @@ class AgenticFlowCLI {
         }
         console.log('⏳ Running...\n');
         const streamHandler = options.stream ? (chunk) => process.stdout.write(chunk) : undefined;
-        // Use directApiAgent (works without Claude Code installed) instead of claudeAgent (requires Claude Code)
-        const result = await directApiAgent(agent, task, streamHandler);
+        // Use claudeAgent with Claude Agent SDK - handles multi-provider routing
+        const result = await claudeAgent(agent, task, streamHandler);
         if (!options.stream) {
             console.log('\n✅ Completed!\n');
             console.log('═══════════════════════════════════════\n');