agentic-flow 1.2.6 → 1.3.0

package/dist/agents/claudeAgent.js

@@ -26,7 +26,7 @@ function getModelForProvider(provider) {
             };
         case 'openrouter':
             return {
-                model: process.env.COMPLETION_MODEL || 'meta-llama/llama-3.1-8b-instruct',
+                model: process.env.COMPLETION_MODEL || 'deepseek/deepseek-chat',
                 apiKey: process.env.OPENROUTER_API_KEY || process.env.ANTHROPIC_API_KEY || '',
                 baseURL: process.env.PROXY_URL || undefined
             };
@@ -103,13 +103,13 @@ export async function claudeAgent(agent, input, onStream, modelOverride) {
         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') {
+            // Enable in-SDK MCP server for custom tools (enabled by default)
+            if (process.env.ENABLE_CLAUDE_FLOW_SDK !== 'false') {
                 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') {
+            // External MCP servers (enabled by default for full 213-tool access)
+            // Disable by setting ENABLE_CLAUDE_FLOW_MCP=false
+            if (process.env.ENABLE_CLAUDE_FLOW_MCP !== 'false') {
                 mcpServers['claude-flow'] = {
                     type: 'stdio',
                     command: 'npx',
@@ -121,7 +121,7 @@ export async function claudeAgent(agent, input, onStream, modelOverride) {
                     }
                 };
             }
-            if (process.env.ENABLE_FLOW_NEXUS_MCP === 'true') {
+            if (process.env.ENABLE_FLOW_NEXUS_MCP !== 'false') {
                 mcpServers['flow-nexus'] = {
                     type: 'stdio',
                     command: 'npx',
@@ -132,7 +132,7 @@ export async function claudeAgent(agent, input, onStream, modelOverride) {
                     }
                 };
             }
-            if (process.env.ENABLE_AGENTIC_PAYMENTS_MCP === 'true') {
+            if (process.env.ENABLE_AGENTIC_PAYMENTS_MCP !== 'false') {
                 mcpServers['agentic-payments'] = {
                     type: 'stdio',
                     command: 'npx',

package/dist/agents/directApiAgent.js

@@ -250,7 +250,7 @@ export async function directApiAgent(agent, input, onStream) {
                     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'),
+                            : (process.env.COMPLETION_MODEL || 'deepseek/deepseek-chat'),
                         messages: messagesWithSystem,
                         maxTokens: 8192,
                         temperature: 0.7

package/dist/cli/claude-code-wrapper.js

@@ -39,7 +39,7 @@ function getProxyConfig(provider, customPort) {
                 provider: 'openrouter',
                 port,
                 baseUrl,
-                model: process.env.COMPLETION_MODEL || 'mistralai/mistral-small-3.1-24b-instruct',
+                model: process.env.COMPLETION_MODEL || 'deepseek/deepseek-chat',
                 apiKey: process.env.OPENROUTER_API_KEY || '',
                 requiresProxy: true
             };
@@ -120,7 +120,7 @@ async function startProxyServer(config) {
         proxy = new AnthropicToOpenRouterProxy({
             openrouterApiKey: config.apiKey,
             openrouterBaseUrl: process.env.ANTHROPIC_PROXY_BASE_URL,
-            defaultModel: config.model || 'mistralai/mistral-small-3.1-24b-instruct'
+            defaultModel: config.model || 'deepseek/deepseek-chat'
         });
     }
     // Start proxy

package/dist/cli-proxy.js

@@ -32,6 +32,7 @@ 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";
+import { detectModelCapabilities } from "./utils/modelCapabilities.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const packageJson = JSON.parse(readFileSync(pathResolve(__dirname, '../package.json'), 'utf-8'));
@@ -264,11 +265,13 @@ class AgenticFlowCLI {
         const defaultModel = modelOverride ||
             process.env.COMPLETION_MODEL ||
             process.env.REASONING_MODEL ||
-            'meta-llama/llama-3.1-8b-instruct';
+            'deepseek/deepseek-chat';
+        const capabilities = detectModelCapabilities(defaultModel);
         const proxy = new AnthropicToOpenRouterProxy({
             openrouterApiKey: openrouterKey,
             openrouterBaseUrl: process.env.ANTHROPIC_PROXY_BASE_URL,
-            defaultModel
+            defaultModel,
+            capabilities: capabilities
         });
         // Start proxy in background
         proxy.start(this.proxyPort);
@@ -281,7 +284,13 @@ class AgenticFlowCLI {
         }
         console.log(`🔗 Proxy Mode: OpenRouter`);
         console.log(`🔧 Proxy URL: http://localhost:${this.proxyPort}`);
-        console.log(`🤖 Default Model: ${defaultModel}\n`);
+        console.log(`🤖 Default Model: ${defaultModel}`);
+        if (capabilities.requiresEmulation) {
+            console.log(`\n⚙️  Detected: Model lacks native tool support`);
+            console.log(`🔧 Using ${capabilities.emulationStrategy.toUpperCase()} emulation pattern`);
+            console.log(`📊 Expected reliability: ${capabilities.emulationStrategy === 'react' ? '70-85%' : '50-70%'}`);
+        }
+        console.log('');
         // Wait for proxy to be ready
         await new Promise(resolve => setTimeout(resolve, 1500));
     }
@@ -416,7 +425,7 @@ Get your key at: https://openrouter.ai/keys
 `);
                 process.exit(1);
             }
-            const finalModel = model || process.env.COMPLETION_MODEL || 'meta-llama/llama-3.1-8b-instruct';
+            const finalModel = model || process.env.COMPLETION_MODEL || 'deepseek/deepseek-chat';
             console.log(`🚀 Starting OpenRouter → Anthropic Proxy
 📍 Port: ${port}
 🤖 Model: ${finalModel}
@@ -551,9 +560,17 @@ EXAMPLES:
         console.log(`📝 Description: ${agent.description}\n`);
         console.log(`🎯 Task: ${task}\n`);
         if (useOpenRouter) {
-            const model = options.model || process.env.COMPLETION_MODEL || 'meta-llama/llama-3.1-8b-instruct';
+            const model = options.model || process.env.COMPLETION_MODEL || 'deepseek/deepseek-chat';
             console.log(`🔧 Provider: OpenRouter (via proxy)`);
-            console.log(`🔧 Model: ${model}\n`);
+            console.log(`🔧 Model: ${model}`);
+            // Show tool capability information
+            const capabilities = detectModelCapabilities(model);
+            if (capabilities.requiresEmulation) {
+                console.log(`⚙️  Tool Emulation: ${capabilities.emulationStrategy.toUpperCase()} pattern`);
+                console.log(`📊 Note: This model uses prompt-based tool emulation`);
+                console.log(`   Tools are handled by Claude Agent SDK (limited to SDK tools)`);
+            }
+            console.log('');
         }
         else if (useGemini) {
             const model = options.model || 'gemini-2.0-flash-exp';

package/dist/cli-standalone-proxy.js

@@ -153,7 +153,7 @@ Get your key at: https://openrouter.ai/keys
 `);
             process.exit(1);
         }
-        const model = options.model || process.env.COMPLETION_MODEL || 'meta-llama/llama-3.1-8b-instruct';
+        const model = options.model || process.env.COMPLETION_MODEL || 'deepseek/deepseek-chat';
         console.log(`🚀 Starting OpenRouter → Anthropic Proxy
 📍 Port: ${options.port}
 🤖 Model: ${model}

package/dist/proxy/anthropic-to-openrouter.js

@@ -3,16 +3,28 @@
 import express from 'express';
 import { logger } from '../utils/logger.js';
 import { getMaxTokensForModel } from './provider-instructions.js';
+import { detectModelCapabilities } from '../utils/modelCapabilities.js';
+import { ToolEmulator, executeEmulation } from './tool-emulation.js';
 export class AnthropicToOpenRouterProxy {
     app;
     openrouterApiKey;
     openrouterBaseUrl;
     defaultModel;
+    capabilities;
     constructor(config) {
         this.app = express();
         this.openrouterApiKey = config.openrouterApiKey;
         this.openrouterBaseUrl = config.openrouterBaseUrl || 'https://openrouter.ai/api/v1';
         this.defaultModel = config.defaultModel || 'meta-llama/llama-3.1-8b-instruct';
+        this.capabilities = config.capabilities;
+        // Debug logging
+        if (this.capabilities) {
+            logger.info('Proxy initialized with capabilities', {
+                model: this.defaultModel,
+                requiresEmulation: this.capabilities.requiresEmulation,
+                strategy: this.capabilities.emulationStrategy
+            });
+        }
         this.setupMiddleware();
         this.setupRoutes();
     }
@@ -66,99 +78,10 @@ export class AnthropicToOpenRouterProxy {
                             : JSON.stringify(firstMsg.content).substring(0, 200)
                     });
                 }
-                // Convert Anthropic format to OpenAI format
-                const openaiReq = this.convertAnthropicToOpenAI(anthropicReq);
-                // VERBOSE LOGGING: Log converted OpenAI request
-                logger.info('=== CONVERTED OPENAI REQUEST ===', {
-                    anthropicModel: anthropicReq.model,
-                    openaiModel: openaiReq.model,
-                    messageCount: openaiReq.messages.length,
-                    systemPrompt: openaiReq.messages[0]?.content?.substring(0, 300),
-                    toolCount: openaiReq.tools?.length || 0,
-                    toolNames: openaiReq.tools?.map(t => t.function.name) || [],
-                    maxTokens: openaiReq.max_tokens,
-                    apiKeyPresent: !!this.openrouterApiKey,
-                    apiKeyPrefix: this.openrouterApiKey?.substring(0, 10)
-                });
-                // Forward to OpenRouter
-                const response = await fetch(`${this.openrouterBaseUrl}/chat/completions`, {
-                    method: 'POST',
-                    headers: {
-                        'Authorization': `Bearer ${this.openrouterApiKey}`,
-                        'Content-Type': 'application/json',
-                        'HTTP-Referer': 'https://github.com/ruvnet/agentic-flow',
-                        'X-Title': 'Agentic Flow'
-                    },
-                    body: JSON.stringify(openaiReq)
-                });
-                if (!response.ok) {
-                    const error = await response.text();
-                    logger.error('OpenRouter API error', { status: response.status, error });
-                    return res.status(response.status).json({
-                        error: {
-                            type: 'api_error',
-                            message: error
-                        }
-                    });
-                }
-                // VERBOSE LOGGING: Log OpenRouter response status
-                logger.info('=== OPENROUTER RESPONSE RECEIVED ===', {
-                    status: response.status,
-                    statusText: response.statusText,
-                    headers: Object.fromEntries(response.headers.entries())
-                });
-                // Handle streaming vs non-streaming
-                if (anthropicReq.stream) {
-                    logger.info('Handling streaming response...');
-                    // Stream response
-                    res.setHeader('Content-Type', 'text/event-stream');
-                    res.setHeader('Cache-Control', 'no-cache');
-                    res.setHeader('Connection', 'keep-alive');
-                    const reader = response.body?.getReader();
-                    if (!reader) {
-                        throw new Error('No response body');
-                    }
-                    const decoder = new TextDecoder();
-                    while (true) {
-                        const { done, value } = await reader.read();
-                        if (done)
-                            break;
-                        const chunk = decoder.decode(value);
-                        const anthropicChunk = this.convertOpenAIStreamToAnthropic(chunk);
-                        res.write(anthropicChunk);
-                    }
-                    res.end();
-                }
-                else {
-                    logger.info('Handling non-streaming response...');
-                    // Non-streaming response
-                    const openaiRes = await response.json();
-                    // VERBOSE LOGGING: Log raw OpenAI response
-                    logger.info('=== RAW OPENAI RESPONSE ===', {
-                        id: openaiRes.id,
-                        model: openaiRes.model,
-                        choices: openaiRes.choices?.length,
-                        finishReason: openaiRes.choices?.[0]?.finish_reason,
-                        hasToolCalls: !!(openaiRes.choices?.[0]?.message?.tool_calls),
-                        toolCallCount: openaiRes.choices?.[0]?.message?.tool_calls?.length || 0,
-                        toolCallNames: openaiRes.choices?.[0]?.message?.tool_calls?.map((tc) => tc.function.name) || [],
-                        contentPreview: openaiRes.choices?.[0]?.message?.content?.substring(0, 300),
-                        usage: openaiRes.usage
-                    });
-                    const anthropicRes = this.convertOpenAIToAnthropic(openaiRes);
-                    // VERBOSE LOGGING: Log converted Anthropic response
-                    logger.info('=== CONVERTED ANTHROPIC RESPONSE ===', {
-                        id: anthropicRes.id,
-                        model: anthropicRes.model,
-                        role: anthropicRes.role,
-                        stopReason: anthropicRes.stop_reason,
-                        contentBlocks: anthropicRes.content?.length,
-                        contentTypes: anthropicRes.content?.map((c) => c.type),
-                        toolUseCount: anthropicRes.content?.filter((c) => c.type === 'tool_use').length,
-                        textPreview: anthropicRes.content?.find((c) => c.type === 'text')?.text?.substring(0, 200),
-                        usage: anthropicRes.usage
-                    });
-                    res.json(anthropicRes);
+                // Route to appropriate handler based on capabilities
+                const result = await this.handleRequest(anthropicReq, res);
+                if (result) {
+                    res.json(result);
                 }
             }
             catch (error) {
@@ -182,6 +105,168 @@ export class AnthropicToOpenRouterProxy {
             });
         });
     }
+    async handleRequest(anthropicReq, res) {
+        let model = anthropicReq.model || this.defaultModel;
+        // If SDK is requesting a Claude model but we're using OpenRouter with a different default,
+        // override to use the CLI-specified model
+        if (model.startsWith('claude-') && this.defaultModel && !this.defaultModel.startsWith('claude-')) {
+            logger.info(`Overriding SDK Claude model ${model} with CLI-specified ${this.defaultModel}`);
+            model = this.defaultModel;
+            anthropicReq.model = model;
+        }
+        const capabilities = this.capabilities || detectModelCapabilities(model);
+        // Check if emulation is required
+        if (capabilities.requiresEmulation && anthropicReq.tools && anthropicReq.tools.length > 0) {
+            logger.info(`Using tool emulation for model: ${model}`);
+            return this.handleEmulatedRequest(anthropicReq, capabilities);
+        }
+        return this.handleNativeRequest(anthropicReq, res);
+    }
+    async handleNativeRequest(anthropicReq, res) {
+        // Convert Anthropic format to OpenAI format
+        const openaiReq = this.convertAnthropicToOpenAI(anthropicReq);
+        // VERBOSE LOGGING: Log converted OpenAI request
+        logger.info('=== CONVERTED OPENAI REQUEST ===', {
+            anthropicModel: anthropicReq.model,
+            openaiModel: openaiReq.model,
+            messageCount: openaiReq.messages.length,
+            systemPrompt: openaiReq.messages[0]?.content?.substring(0, 300),
+            toolCount: openaiReq.tools?.length || 0,
+            toolNames: openaiReq.tools?.map(t => t.function.name) || [],
+            maxTokens: openaiReq.max_tokens,
+            apiKeyPresent: !!this.openrouterApiKey,
+            apiKeyPrefix: this.openrouterApiKey?.substring(0, 10)
+        });
+        // Forward to OpenRouter
+        const response = await fetch(`${this.openrouterBaseUrl}/chat/completions`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this.openrouterApiKey}`,
+                'Content-Type': 'application/json',
+                'HTTP-Referer': 'https://github.com/ruvnet/agentic-flow',
+                'X-Title': 'Agentic Flow'
+            },
+            body: JSON.stringify(openaiReq)
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            logger.error('OpenRouter API error', { status: response.status, error });
+            res.status(response.status).json({
+                error: {
+                    type: 'api_error',
+                    message: error
+                }
+            });
+            return null;
+        }
+        // VERBOSE LOGGING: Log OpenRouter response status
+        logger.info('=== OPENROUTER RESPONSE RECEIVED ===', {
+            status: response.status,
+            statusText: response.statusText,
+            headers: Object.fromEntries(response.headers.entries())
+        });
+        // Handle streaming vs non-streaming
+        if (anthropicReq.stream) {
+            logger.info('Handling streaming response...');
+            // Stream response
+            res.setHeader('Content-Type', 'text/event-stream');
+            res.setHeader('Cache-Control', 'no-cache');
+            res.setHeader('Connection', 'keep-alive');
+            const reader = response.body?.getReader();
+            if (!reader) {
+                throw new Error('No response body');
+            }
+            const decoder = new TextDecoder();
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                const chunk = decoder.decode(value);
+                const anthropicChunk = this.convertOpenAIStreamToAnthropic(chunk);
+                res.write(anthropicChunk);
+            }
+            res.end();
+            return null; // Already sent response
+        }
+        else {
+            logger.info('Handling non-streaming response...');
+            // Non-streaming response
+            const openaiRes = await response.json();
+            // VERBOSE LOGGING: Log raw OpenAI response
+            logger.info('=== RAW OPENAI RESPONSE ===', {
+                id: openaiRes.id,
+                model: openaiRes.model,
+                choices: openaiRes.choices?.length,
+                finishReason: openaiRes.choices?.[0]?.finish_reason,
+                hasToolCalls: !!(openaiRes.choices?.[0]?.message?.tool_calls),
+                toolCallCount: openaiRes.choices?.[0]?.message?.tool_calls?.length || 0,
+                toolCallNames: openaiRes.choices?.[0]?.message?.tool_calls?.map((tc) => tc.function.name) || [],
+                contentPreview: openaiRes.choices?.[0]?.message?.content?.substring(0, 300),
+                usage: openaiRes.usage
+            });
+            const anthropicRes = this.convertOpenAIToAnthropic(openaiRes);
+            // VERBOSE LOGGING: Log converted Anthropic response
+            logger.info('=== CONVERTED ANTHROPIC RESPONSE ===', {
+                id: anthropicRes.id,
+                model: anthropicRes.model,
+                role: anthropicRes.role,
+                stopReason: anthropicRes.stop_reason,
+                contentBlocks: anthropicRes.content?.length,
+                contentTypes: anthropicRes.content?.map((c) => c.type),
+                toolUseCount: anthropicRes.content?.filter((c) => c.type === 'tool_use').length,
+                textPreview: anthropicRes.content?.find((c) => c.type === 'text')?.text?.substring(0, 200),
+                usage: anthropicRes.usage
+            });
+            return anthropicRes;
+        }
+    }
+    async handleEmulatedRequest(anthropicReq, capabilities) {
+        const emulator = new ToolEmulator(anthropicReq.tools || [], capabilities.emulationStrategy);
+        const lastMessage = anthropicReq.messages[anthropicReq.messages.length - 1];
+        const userMessage = typeof lastMessage.content === 'string'
+            ? lastMessage.content
+            : (lastMessage.content.find(c => c.type === 'text')?.text || '');
+        const result = await executeEmulation(emulator, userMessage, async (prompt) => {
+            // Call model with emulation prompt
+            const openaiReq = {
+                model: anthropicReq.model || this.defaultModel,
+                messages: [{ role: 'user', content: prompt }],
+                temperature: anthropicReq.temperature,
+                max_tokens: anthropicReq.max_tokens
+            };
+            const response = await this.callOpenRouter(openaiReq);
+            return response.choices[0].message.content;
+        }, async (toolCall) => {
+            logger.warn(`Tool execution not yet implemented: ${toolCall.name}`);
+            return { error: 'Tool execution not implemented in Phase 2' };
+        }, { maxIterations: 5, verbose: process.env.VERBOSE === 'true' });
+        return {
+            id: `emulated_${Date.now()}`,
+            type: 'message',
+            role: 'assistant',
+            content: [{ type: 'text', text: result.finalAnswer || 'No response' }],
+            model: anthropicReq.model || this.defaultModel,
+            stop_reason: 'end_turn',
+            usage: { input_tokens: 0, output_tokens: 0 }
+        };
+    }
+    async callOpenRouter(openaiReq) {
+        const response = await fetch(`${this.openrouterBaseUrl}/chat/completions`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this.openrouterApiKey}`,
+                'Content-Type': 'application/json',
+                'HTTP-Referer': 'https://github.com/ruvnet/agentic-flow',
+                'X-Title': 'Agentic Flow'
+            },
+            body: JSON.stringify(openaiReq)
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`OpenRouter API error: ${error}`);
+        }
+        return response.json();
+    }
     convertAnthropicToOpenAI(anthropicReq) {
         logger.info('=== STARTING ANTHROPIC TO OPENAI CONVERSION ===');
         const messages = [];
@@ -507,7 +592,12 @@ export class AnthropicToOpenRouterProxy {
             });
             console.log(`\n✅ Anthropic Proxy running at http://localhost:${port}`);
             console.log(`   OpenRouter Base URL: ${this.openrouterBaseUrl}`);
-            console.log(`   Default Model: ${this.defaultModel}\n`);
+            console.log(`   Default Model: ${this.defaultModel}`);
+            if (this.capabilities?.requiresEmulation) {
+                console.log(`\n   ⚙️  Tool Emulation: ${this.capabilities.emulationStrategy.toUpperCase()} pattern`);
+                console.log(`   📊 Expected reliability: ${this.capabilities.emulationStrategy === 'react' ? '70-85%' : '50-70%'}`);
+            }
+            console.log('');
         });
     }
 }