agentic-flow 1.2.0 → 1.2.2

package/README.md

@@ -12,7 +12,15 @@
 
 ## 📖 Introduction
 
-Agentic Flow is a framework for running AI agents at scale with intelligent cost optimization. It runs any Claude Code agent through the [Claude Agent SDK](https://docs.claude.com/en/api/agent-sdk), automatically routing tasks to the cheapest model that meets quality requirements.
+I built Agentic Flow to easily switch between alternative low-cost AI models in Claude Code/Agent SDK. For those comfortable using Claude agents and commands, it lets you take what you've created and deploy fully hosted agents for real business purposes. Use Claude Code to get the agent working, then deploy it in your favorite cloud.
+
+Agentic Flow runs Claude Code agents at near zero cost without rewriting a thing. The built-in model optimizer automatically routes every task to the cheapest option that meets your quality requirements—free local models for privacy, OpenRouter for 99% cost savings, Gemini for speed, or Anthropic when quality matters most. It analyzes each task and selects the optimal model from 27+ options with a single flag, reducing API costs dramatically compared to using Claude exclusively.
+
+The system spawns specialized agents on demand through Claude Code's Task tool and MCP coordination. It orchestrates swarms of 66+ pre-built agents (researchers, coders, reviewers, testers, architects) that work in parallel, coordinate through shared memory, and auto-scale based on workload. Transparent OpenRouter and Gemini proxies translate Anthropic API calls automatically—no code changes needed. Local models run direct without proxies for maximum privacy. Switch providers with environment variables, not refactoring.
+
+Extending agent capabilities is effortless. Add custom tools and integrations through the CLI—weather data, databases, search engines, or any external service—without touching config files. Your agents instantly gain new abilities across all projects. Every tool you add becomes available to the entire agent ecosystem automatically, and all operations are logged with full traceability for auditing, debugging, and compliance. This means your agents can connect to proprietary systems, third-party APIs, or internal tools in seconds, not hours.
+
+Define routing rules through flexible policy modes: Strict mode keeps sensitive data offline, Economy mode prefers free models (99% savings), Premium mode uses Anthropic for highest quality, or create custom cost/quality thresholds. The policy defines the rules; the swarm enforces them automatically. Runs local for development, Docker for CI/CD, or Flow Nexus cloud for production scale. Agentic Flow is the framework for autonomous efficiency—one unified runner for every Claude Code agent, self-tuning, self-routing, and built for real-world deployment.
 
 **Key Capabilities:**
 - ✅ **66 Specialized Agents** - Pre-built experts for coding, research, review, testing, DevOps
@@ -370,9 +378,9 @@ node dist/mcp/fastmcp/servers/http-sse.js
 - **stdio**: Claude Desktop, Cursor IDE, command-line tools
 - **HTTP/SSE**: Web apps, browser extensions, REST APIs, mobile apps
 
-### Add Custom MCP Servers (No Code Required)
+### Add Custom MCP Servers (No Code Required) ✨ NEW in v1.2.1
 
-Add your own MCP servers via CLI without editing code:
+Add your own MCP servers via CLI without editing code—extends agent capabilities in seconds:
 
 ```bash
 # Add MCP server (Claude Desktop style JSON config)
@@ -393,6 +401,13 @@ npx agentic-flow mcp disable weather
 
 # Remove server
 npx agentic-flow mcp remove weather
+
+# Test server configuration
+npx agentic-flow mcp test weather
+
+# Export/import configurations
+npx agentic-flow mcp export ./mcp-backup.json
+npx agentic-flow mcp import ./mcp-backup.json
 ```
 
 **Configuration stored in:** `~/.agentic-flow/mcp-config.json`
@@ -411,6 +426,13 @@ npx agentic-flow --agent researcher --task "Get weather forecast for Tokyo"
 - `weather-mcp` - Weather data
 - `database-mcp` - Database operations
 
+**v1.2.1 Improvements:**
+- ✅ CLI routing fixed - `mcp add/list/remove` commands now work correctly
+- ✅ Model optimizer filters models without tool support automatically
+- ✅ Full compatibility with Claude Desktop config format
+- ✅ Test command for validating server configurations
+- ✅ Export/import for backing up and sharing configurations
+
 **Documentation:** See [docs/guides/ADDING-MCP-SERVERS-CLI.md](docs/guides/ADDING-MCP-SERVERS-CLI.md) for complete guide.
 
 ### Using MCP Tools in Agents

package/dist/agents/claudeAgent.js

@@ -85,11 +85,13 @@ export async function claudeAgent(agent, input, onStream, modelOverride) {
             });
         }
         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 ONNX: Use ANTHROPIC_BASE_URL if already set by CLI (proxy mode)
+            envOverrides.ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY || 'sk-ant-onnx-local-key';
+            envOverrides.ANTHROPIC_BASE_URL = process.env.ANTHROPIC_BASE_URL || process.env.ONNX_PROXY_URL || 'http://localhost:3001';
+            logger.info('Using ONNX local proxy', {
+                proxyUrl: envOverrides.ANTHROPIC_BASE_URL,
+                model: finalModel
+            });
         }
         // For Anthropic provider, use existing ANTHROPIC_API_KEY (no proxy needed)
         logger.info('Multi-provider configuration', {

package/dist/cli-proxy.js

@@ -65,6 +65,26 @@ class AgenticFlowCLI {
             await handleAgentCommand(agentArgs);
             process.exit(0);
         }
+        if (options.mode === 'mcp-manager') {
+            // Handle MCP manager commands (add, list, remove, etc.)
+            const { spawn } = await import('child_process');
+            const { resolve, dirname } = await import('path');
+            const { fileURLToPath } = await import('url');
+            const __filename = fileURLToPath(import.meta.url);
+            const __dirname = dirname(__filename);
+            const mcpManagerPath = resolve(__dirname, './cli/mcp-manager.js');
+            // Pass all args after 'mcp' to mcp-manager
+            const mcpArgs = process.argv.slice(3); // Skip 'node', 'cli-proxy.js', 'mcp'
+            const proc = spawn('node', [mcpManagerPath, ...mcpArgs], {
+                stdio: 'inherit'
+            });
+            proc.on('exit', (code) => {
+                process.exit(code || 0);
+            });
+            process.on('SIGINT', () => proc.kill('SIGINT'));
+            process.on('SIGTERM', () => proc.kill('SIGTERM'));
+            return;
+        }
         if (options.mode === 'proxy') {
             // Run standalone proxy server for Claude Code/Cursor
             await this.runStandaloneProxy();
@@ -110,7 +130,8 @@ class AgenticFlowCLI {
                 agent: options.agent,
                 task: options.task,
                 priority: options.optimizePriority || 'balanced',
-                maxCostPerTask: options.maxCost
+                maxCostPerTask: options.maxCost,
+                requiresTools: true // Agents have MCP tools available, so require tool support
             });
             // Display recommendation
             ModelOptimizer.displayRecommendation(recommendation);
@@ -124,6 +145,7 @@ class AgenticFlowCLI {
             console.log(`✅ Using optimized model: ${recommendation.modelName}\n`);
         }
         // Determine which provider to use
+        const useONNX = this.shouldUseONNX(options);
         const useOpenRouter = this.shouldUseOpenRouter(options);
         const useGemini = this.shouldUseGemini(options);
         // Debug output for provider selection
@@ -131,6 +153,7 @@ class AgenticFlowCLI {
             console.log('\n🔍 Provider Selection Debug:');
             console.log(`  Provider flag: ${options.provider || 'not set'}`);
             console.log(`  Model: ${options.model || 'default'}`);
+            console.log(`  Use ONNX: ${useONNX}`);
             console.log(`  Use OpenRouter: ${useOpenRouter}`);
             console.log(`  Use Gemini: ${useGemini}`);
             console.log(`  OPENROUTER_API_KEY: ${process.env.OPENROUTER_API_KEY ? '✓ set' : '✗ not set'}`);
@@ -138,8 +161,12 @@ class AgenticFlowCLI {
             console.log(`  ANTHROPIC_API_KEY: ${process.env.ANTHROPIC_API_KEY ? '✓ set' : '✗ not set'}\n`);
         }
         try {
-            // Start proxy if needed (OpenRouter or Gemini)
-            if (useOpenRouter) {
+            // Start proxy if needed (ONNX, OpenRouter, or Gemini)
+            if (useONNX) {
+                console.log('🚀 Initializing ONNX local inference proxy...');
+                await this.startONNXProxy(options.model);
+            }
+            else if (useOpenRouter) {
                 console.log('🚀 Initializing OpenRouter proxy...');
                 await this.startOpenRouterProxy(options.model);
             }
@@ -151,7 +178,7 @@ class AgenticFlowCLI {
                 console.log('🚀 Using direct Anthropic API...\n');
             }
             // Run agent
-            await this.runAgent(options, useOpenRouter, useGemini);
+            await this.runAgent(options, useOpenRouter, useGemini, useONNX);
             logger.info('Execution completed successfully');
             process.exit(0);
         }
@@ -161,6 +188,19 @@ class AgenticFlowCLI {
             process.exit(1);
         }
     }
+    shouldUseONNX(options) {
+        // Use ONNX if:
+        // 1. Provider is explicitly set to onnx
+        // 2. PROVIDER env var is set to onnx
+        // 3. USE_ONNX env var is set
+        if (options.provider === 'onnx' || process.env.PROVIDER === 'onnx') {
+            return true;
+        }
+        if (process.env.USE_ONNX === 'true') {
+            return true;
+        }
+        return false;
+    }
     shouldUseGemini(options) {
         // Use Gemini if:
         // 1. Provider is explicitly set to gemini
@@ -272,6 +312,35 @@ class AgenticFlowCLI {
         // Wait for proxy to be ready
         await new Promise(resolve => setTimeout(resolve, 1500));
     }
+    async startONNXProxy(modelOverride) {
+        logger.info('Starting integrated ONNX local inference proxy');
+        console.log('🔧 Provider: ONNX Local (Phi-4-mini)');
+        console.log('💾 Free local inference - no API costs\n');
+        // Import ONNX proxy
+        const { AnthropicToONNXProxy } = await import('./proxy/anthropic-to-onnx.js');
+        // Use a different port for ONNX to avoid conflicts
+        const onnxProxyPort = parseInt(process.env.ONNX_PROXY_PORT || '3001');
+        const proxy = new AnthropicToONNXProxy({
+            port: onnxProxyPort,
+            modelPath: process.env.ONNX_MODEL_PATH,
+            executionProviders: process.env.ONNX_EXECUTION_PROVIDERS?.split(',') || ['cpu']
+        });
+        // Start proxy in background
+        await proxy.start();
+        this.proxyServer = proxy;
+        // Set ANTHROPIC_BASE_URL to ONNX proxy
+        process.env.ANTHROPIC_BASE_URL = `http://localhost:${onnxProxyPort}`;
+        // Set dummy ANTHROPIC_API_KEY for proxy (local inference doesn't need key)
+        if (!process.env.ANTHROPIC_API_KEY) {
+            process.env.ANTHROPIC_API_KEY = 'sk-ant-onnx-local-key';
+        }
+        console.log(`🔗 Proxy Mode: ONNX Local Inference`);
+        console.log(`🔧 Proxy URL: http://localhost:${onnxProxyPort}`);
+        console.log(`🤖 Model: Phi-4-mini-instruct (ONNX)\n`);
+        // Wait for proxy to be ready and model to load
+        console.log('⏳ Loading ONNX model... (this may take a moment)\n');
+        await new Promise(resolve => setTimeout(resolve, 2000));
+    }
     async runStandaloneProxy() {
         const args = process.argv.slice(3); // Skip 'node', 'cli-proxy.js', 'proxy'
         // Parse proxy arguments
@@ -411,7 +480,7 @@ EXAMPLES:
   claude
 `);
     }
-    async runAgent(options, useOpenRouter, useGemini) {
+    async runAgent(options, useOpenRouter, useGemini, useONNX = false) {
         const agentName = options.agent || process.env.AGENT || '';
         const task = options.task || process.env.TASK || '';
         if (!agentName) {

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

@@ -0,0 +1,213 @@
+// Anthropic to ONNX Local Proxy Server
+// Converts Anthropic API format to ONNX Runtime local inference
+import express from 'express';
+import { logger } from '../utils/logger.js';
+import { ONNXLocalProvider } from '../router/providers/onnx-local.js';
+export class AnthropicToONNXProxy {
+    app;
+    onnxProvider;
+    port;
+    server;
+    constructor(config = {}) {
+        this.app = express();
+        this.port = config.port || 3001;
+        // Initialize ONNX provider with configuration
+        this.onnxProvider = new ONNXLocalProvider({
+            modelPath: config.modelPath,
+            executionProviders: config.executionProviders || ['cpu'],
+            maxTokens: 512,
+            temperature: 0.7
+        });
+        this.setupMiddleware();
+        this.setupRoutes();
+    }
+    setupMiddleware() {
+        // Parse JSON bodies
+        this.app.use(express.json({ limit: '50mb' }));
+        // Logging middleware
+        this.app.use((req, res, next) => {
+            logger.debug('ONNX proxy request', {
+                method: req.method,
+                path: req.path,
+                headers: Object.keys(req.headers)
+            });
+            next();
+        });
+    }
+    setupRoutes() {
+        // Health check
+        this.app.get('/health', (req, res) => {
+            const modelInfo = this.onnxProvider.getModelInfo();
+            res.json({
+                status: 'ok',
+                service: 'anthropic-to-onnx-proxy',
+                onnx: {
+                    initialized: modelInfo.initialized,
+                    tokenizerLoaded: modelInfo.tokenizerLoaded,
+                    executionProviders: modelInfo.executionProviders
+                }
+            });
+        });
+        // Anthropic Messages API → ONNX Local Inference
+        this.app.post('/v1/messages', async (req, res) => {
+            try {
+                const anthropicReq = req.body;
+                // Extract system prompt
+                let systemPrompt = '';
+                if (typeof anthropicReq.system === 'string') {
+                    systemPrompt = anthropicReq.system;
+                }
+                else if (Array.isArray(anthropicReq.system)) {
+                    systemPrompt = anthropicReq.system
+                        .filter((block) => block.type === 'text')
+                        .map((block) => block.text)
+                        .join('\n');
+                }
+                logger.info('Converting Anthropic request to ONNX', {
+                    anthropicModel: anthropicReq.model,
+                    onnxModel: 'Phi-4-mini-instruct',
+                    messageCount: anthropicReq.messages.length,
+                    systemPromptLength: systemPrompt.length,
+                    maxTokens: anthropicReq.max_tokens,
+                    temperature: anthropicReq.temperature
+                });
+                // Convert Anthropic messages to internal format
+                const messages = [];
+                // Add system message if present
+                if (systemPrompt) {
+                    messages.push({
+                        role: 'system',
+                        content: systemPrompt
+                    });
+                }
+                // Add user/assistant messages
+                for (const msg of anthropicReq.messages) {
+                    let content;
+                    if (typeof msg.content === 'string') {
+                        content = msg.content;
+                    }
+                    else {
+                        content = msg.content
+                            .filter((block) => block.type === 'text')
+                            .map((block) => block.text || '')
+                            .join('\n');
+                    }
+                    messages.push({
+                        role: msg.role,
+                        content
+                    });
+                }
+                // Streaming not supported by ONNX provider yet
+                if (anthropicReq.stream) {
+                    logger.warn('Streaming requested but not supported by ONNX provider, falling back to non-streaming');
+                }
+                // Run ONNX inference
+                const result = await this.onnxProvider.chat({
+                    model: 'phi-4-mini-instruct',
+                    messages,
+                    maxTokens: anthropicReq.max_tokens || 512,
+                    temperature: anthropicReq.temperature || 0.7
+                });
+                // Convert ONNX response to Anthropic format
+                const anthropicResponse = {
+                    id: result.id,
+                    type: 'message',
+                    role: 'assistant',
+                    content: result.content.map(block => ({
+                        type: 'text',
+                        text: block.text || ''
+                    })),
+                    model: 'onnx-local/phi-4-mini-instruct',
+                    stop_reason: result.stopReason || 'end_turn',
+                    usage: {
+                        input_tokens: result.usage?.inputTokens || 0,
+                        output_tokens: result.usage?.outputTokens || 0
+                    }
+                };
+                logger.info('ONNX inference completed', {
+                    inputTokens: result.usage?.inputTokens || 0,
+                    outputTokens: result.usage?.outputTokens || 0,
+                    latency: result.metadata?.latency,
+                    tokensPerSecond: result.metadata?.tokensPerSecond
+                });
+                res.json(anthropicResponse);
+            }
+            catch (error) {
+                logger.error('ONNX proxy error', {
+                    error: error.message,
+                    provider: error.provider,
+                    retryable: error.retryable
+                });
+                res.status(500).json({
+                    error: {
+                        type: 'api_error',
+                        message: `ONNX inference failed: ${error.message}`
+                    }
+                });
+            }
+        });
+        // 404 handler
+        this.app.use((req, res) => {
+            res.status(404).json({
+                error: {
+                    type: 'not_found',
+                    message: `Route not found: ${req.method} ${req.path}`
+                }
+            });
+        });
+    }
+    start() {
+        return new Promise((resolve) => {
+            this.server = this.app.listen(this.port, () => {
+                logger.info('ONNX proxy server started', {
+                    port: this.port,
+                    endpoint: `http://localhost:${this.port}`,
+                    healthCheck: `http://localhost:${this.port}/health`,
+                    messagesEndpoint: `http://localhost:${this.port}/v1/messages`
+                });
+                console.log(`\n🚀 ONNX Proxy Server running on http://localhost:${this.port}`);
+                console.log(`   📋 Messages API: POST http://localhost:${this.port}/v1/messages`);
+                console.log(`   ❤️  Health check: GET http://localhost:${this.port}/health\n`);
+                resolve();
+            });
+        });
+    }
+    stop() {
+        return new Promise((resolve) => {
+            if (this.server) {
+                this.server.close(() => {
+                    logger.info('ONNX proxy server stopped');
+                    resolve();
+                });
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    async dispose() {
+        await this.stop();
+        await this.onnxProvider.dispose();
+    }
+}
+// CLI entry point
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const proxy = new AnthropicToONNXProxy({
+        port: parseInt(process.env.ONNX_PROXY_PORT || '3001')
+    });
+    proxy.start().catch(error => {
+        console.error('Failed to start ONNX proxy:', error);
+        process.exit(1);
+    });
+    // Graceful shutdown
+    process.on('SIGINT', async () => {
+        console.log('\n🛑 Shutting down ONNX proxy...');
+        await proxy.dispose();
+        process.exit(0);
+    });
+    process.on('SIGTERM', async () => {
+        console.log('\n🛑 Shutting down ONNX proxy...');
+        await proxy.dispose();
+        process.exit(0);
+    });
+}

package/dist/utils/.claude-flow/metrics/agent-metrics.json

@@ -0,0 +1 @@
+{}

package/dist/utils/.claude-flow/metrics/performance.json

@@ -0,0 +1,9 @@
+{
+  "startTime": 1759762633186,
+  "totalTasks": 1,
+  "successfulTasks": 1,
+  "failedTasks": 0,
+  "totalAgents": 0,
+  "activeAgents": 0,
+  "neuralEvents": 0
+}

package/dist/utils/.claude-flow/metrics/task-metrics.json

@@ -0,0 +1,10 @@
+[
+  {
+    "id": "cmd-hooks-1759762633317",
+    "type": "hooks",
+    "success": true,
+    "duration": 6.094114000000047,
+    "timestamp": 1759762633323,
+    "metadata": {}
+  }
+]

package/dist/utils/cli.js

@@ -16,8 +16,16 @@ export function parseArgs() {
     }
     // Check for MCP command
     if (args[0] === 'mcp') {
+        const mcpSubcommand = args[1];
+        // MCP Manager commands (CLI configuration)
+        const managerCommands = ['add', 'list', 'remove', 'enable', 'disable', 'update', 'test', 'info', 'export', 'import'];
+        if (managerCommands.includes(mcpSubcommand)) {
+            options.mode = 'mcp-manager';
+            return options;
+        }
+        // MCP Server commands (start/stop server)
         options.mode = 'mcp';
-        options.mcpCommand = args[1] || 'start'; // default to start
+        options.mcpCommand = mcpSubcommand || 'start'; // default to start
         options.mcpServer = args[2] || 'all'; // default to all servers
         return options;
     }

package/dist/utils/modelOptimizer.js

@@ -16,6 +16,7 @@ const MODEL_DATABASE = {
         speed_score: 85,
         cost_score: 20,
         tier: 'flagship',
+        supports_tools: true,
         strengths: ['reasoning', 'coding', 'analysis', 'production'],
         weaknesses: ['cost'],
         bestFor: ['coder', 'reviewer', 'architecture', 'planner', 'production-validator']
@@ -30,6 +31,7 @@ const MODEL_DATABASE = {
         speed_score: 90,
         cost_score: 30,
         tier: 'flagship',
+        supports_tools: true,
         strengths: ['multimodal', 'speed', 'general-purpose', 'vision'],
         weaknesses: ['cost'],
         bestFor: ['researcher', 'analyst', 'multimodal-tasks']
@@ -44,6 +46,7 @@ const MODEL_DATABASE = {
         speed_score: 75,
         cost_score: 50,
         tier: 'flagship',
+        supports_tools: true,
         strengths: ['reasoning', 'large-context', 'math', 'analysis'],
         weaknesses: ['speed'],
         bestFor: ['planner', 'architecture', 'researcher', 'code-analyzer']
@@ -59,8 +62,9 @@ const MODEL_DATABASE = {
         speed_score: 80,
         cost_score: 100,
         tier: 'cost-effective',
+        supports_tools: false, // DeepSeek R1 does NOT support tool/function calling
         strengths: ['reasoning', 'coding', 'math', 'value', 'free'],
-        weaknesses: ['newer-model'],
+        weaknesses: ['newer-model', 'no-tool-use'],
         bestFor: ['coder', 'pseudocode', 'specification', 'refinement', 'tester']
     },
     'deepseek-chat-v3': {
@@ -73,6 +77,7 @@ const MODEL_DATABASE = {
         speed_score: 90,
         cost_score: 100,
         tier: 'cost-effective',
+        supports_tools: true,
         strengths: ['cost', 'speed', 'coding', 'development', 'free'],
         weaknesses: ['complex-reasoning'],
         bestFor: ['coder', 'reviewer', 'tester', 'backend-dev', 'cicd-engineer']
@@ -88,6 +93,7 @@ const MODEL_DATABASE = {
         speed_score: 98,
         cost_score: 98,
         tier: 'balanced',
+        supports_tools: true,
         strengths: ['speed', 'cost', 'interactive'],
         weaknesses: ['quality'],
         bestFor: ['researcher', 'planner', 'smart-agent']
@@ -102,6 +108,7 @@ const MODEL_DATABASE = {
         speed_score: 95,
         cost_score: 100,
         tier: 'balanced',
+        supports_tools: true,
         strengths: ['open-source', 'versatile', 'coding', 'free', 'fast'],
         weaknesses: ['smaller-model'],
         bestFor: ['coder', 'reviewer', 'base-template-generator', 'tester']
@@ -116,6 +123,7 @@ const MODEL_DATABASE = {
         speed_score: 85,
         cost_score: 90,
         tier: 'balanced',
+        supports_tools: true,
         strengths: ['multilingual', 'coding', 'reasoning'],
         weaknesses: ['english-optimized'],
         bestFor: ['researcher', 'coder', 'multilingual-tasks']
@@ -131,6 +139,7 @@ const MODEL_DATABASE = {
         speed_score: 95,
         cost_score: 99,
         tier: 'budget',
+        supports_tools: true,
         strengths: ['ultra-low-cost', 'speed'],
         weaknesses: ['quality', 'complex-tasks'],
         bestFor: ['simple-tasks', 'testing']
@@ -146,6 +155,7 @@ const MODEL_DATABASE = {
         speed_score: 30,
         cost_score: 100,
         tier: 'local',
+        supports_tools: false,
         strengths: ['privacy', 'offline', 'zero-cost'],
         weaknesses: ['quality', 'speed'],
         bestFor: ['privacy-tasks', 'offline-tasks']
@@ -197,8 +207,14 @@ export class ModelOptimizer {
         const taskComplexity = criteria.taskComplexity || this.inferComplexity(criteria.task);
         // Set default priority to balanced if not specified
         const priority = criteria.priority || 'balanced';
+        // Filter models that support tools if required
+        let availableModels = Object.entries(MODEL_DATABASE);
+        if (criteria.requiresTools) {
+            availableModels = availableModels.filter(([key, model]) => model.supports_tools !== false);
+            logger.info(`Filtered to ${availableModels.length} models with tool support`);
+        }
         // Score all models
-        const scoredModels = Object.entries(MODEL_DATABASE).map(([key, model]) => {
+        const scoredModels = availableModels.map(([key, model]) => {
             // Calculate overall score based on priority
             let overall_score;
             switch (priority) {

package/docs/.claude-flow/metrics/performance.json

@@ -1,5 +1,5 @@
 {
-  "startTime": 1759680310468,
+  "startTime": 1759768557067,
   "totalTasks": 1,
   "successfulTasks": 1,
   "failedTasks": 0,

package/docs/.claude-flow/metrics/task-metrics.json

@@ -1,10 +1,10 @@
 [
   {
-    "id": "cmd-hooks-1759680310618",
+    "id": "cmd-hooks-1759768557202",
     "type": "hooks",
     "success": true,
-    "duration": 8.211029999999994,
-    "timestamp": 1759680310627,
+    "duration": 9.268956000000003,
+    "timestamp": 1759768557212,
     "metadata": {}
   }
 ]