tachibot-mcp 2.0.2

package/dist/src/config/timeout-config.js

@@ -0,0 +1,130 @@
+/**
+ * Centralized Timeout Configuration
+ *
+ * Provides configurable timeouts for all MCP operations to prevent premature
+ * termination of long-running AI operations.
+ *
+ * See docs/ADR-002-timeout-configuration.md for rationale.
+ */
+/**
+ * Get timeout configuration from environment variables with fallbacks
+ */
+export function getTimeoutConfig() {
+    return {
+        // Global default (90 seconds)
+        default: parseInt(process.env.TACHI_DEFAULT_TIMEOUT || '90000'),
+        // Per-tool timeouts
+        verifier: parseInt(process.env.TACHI_VERIFIER_TIMEOUT || '120000'), // 2 minutes
+        challenger: parseInt(process.env.TACHI_CHALLENGER_TIMEOUT || '180000'), // 3 minutes
+        scout: parseInt(process.env.TACHI_SCOUT_TIMEOUT || '180000'), // 3 minutes
+        focus: parseInt(process.env.TACHI_FOCUS_TIMEOUT || '300000'), // 5 minutes
+        workflow: parseInt(process.env.TACHI_WORKFLOW_TIMEOUT || '300000'), // 5 minutes
+        pingpong: parseInt(process.env.TACHI_PINGPONG_TIMEOUT || '600000'), // 10 minutes
+        // Individual API call timeout (60 seconds)
+        api: parseInt(process.env.TACHI_API_TIMEOUT || '60000'),
+        // Progress threshold (30 seconds)
+        progressThreshold: parseInt(process.env.TACHI_PROGRESS_THRESHOLD || '30000'),
+    };
+}
+/**
+ * Get timeout for specific tool with fallback to default
+ */
+export function getToolTimeout(toolName) {
+    const config = getTimeoutConfig();
+    const toolKey = toolName.toLowerCase();
+    return config[toolKey] || config.default;
+}
+/**
+ * Format timeout duration for display
+ */
+export function formatTimeout(ms) {
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60) {
+        return `${seconds}s`;
+    }
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+    if (remainingSeconds === 0) {
+        return `${minutes}m`;
+    }
+    return `${minutes}m ${remainingSeconds}s`;
+}
+/**
+ * Create timeout promise for use with Promise.race()
+ */
+export function createTimeoutPromise(ms, message) {
+    return new Promise((_, reject) => {
+        setTimeout(() => {
+            reject(new Error(message || `Operation timed out after ${formatTimeout(ms)}`));
+        }, ms);
+    });
+}
+/**
+ * Wrap promise with timeout
+ */
+export async function withTimeout(promise, timeoutMs, toolName) {
+    const timeoutMessage = toolName
+        ? `${toolName} operation timed out after ${formatTimeout(timeoutMs)}`
+        : `Operation timed out after ${formatTimeout(timeoutMs)}`;
+    return Promise.race([
+        promise,
+        createTimeoutPromise(timeoutMs, timeoutMessage)
+    ]);
+}
+/**
+ * Check if we should show progress (operation exceeds threshold)
+ */
+export function shouldShowProgress(elapsedMs) {
+    const config = getTimeoutConfig();
+    return elapsedMs >= config.progressThreshold;
+}
+export const SMART_TIMEOUT_DEFAULTS = {
+    interactive: {
+        base: 15000, // 15 seconds
+        max: 45000, // 45 seconds
+        retries: 3
+    },
+    batch: {
+        base: 30000, // 30 seconds
+        max: 120000, // 2 minutes
+        retries: 5
+    },
+    providers: {
+        perplexity: {
+            base: 30000, // 30 seconds - Perplexity can be slow
+            max: 90000 // 90 seconds
+        },
+        grok: {
+            base: 30000, // 30 seconds
+            max: 90000 // 90 seconds
+        },
+        openai: {
+            base: 20000, // 20 seconds
+            max: 60000 // 60 seconds
+        },
+        anthropic: {
+            base: 20000, // 20 seconds
+            max: 60000 // 60 seconds
+        },
+        google: {
+            base: 15000, // 15 seconds
+            max: 45000 // 45 seconds
+        }
+    }
+};
+/**
+ * Get smart timeout for specific provider and priority
+ */
+export function getSmartTimeout(provider, priority) {
+    const providerConfig = SMART_TIMEOUT_DEFAULTS.providers[provider];
+    const priorityConfig = SMART_TIMEOUT_DEFAULTS[priority];
+    return {
+        base: providerConfig?.base || priorityConfig.base,
+        max: providerConfig?.max || priorityConfig.max,
+        retries: priorityConfig.retries
+    };
+}
+// Export singleton instance
+export const timeouts = getTimeoutConfig();
+// Re-export for convenience
+export { getTimeoutConfig as default };

package/dist/src/config.js

@@ -0,0 +1,173 @@
+import { config } from 'dotenv';
+import { TechnicalDomain } from './reasoning-chain.js';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+// Get the directory of the current module
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Load environment variables from the correct path (project root)
+// When built: dist/src/config.js -> need to go up 2 levels to reach .env
+config({ path: path.resolve(__dirname, '../../.env') });
+/**
+ * Detect if running in Claude Code environment
+ */
+function detectClaudeCode() {
+    return !!(process.env.CLAUDE_CODE_SESSION ||
+        process.env.ANTHROPIC_SESSION_ID ||
+        process.env.CLAUDE_CODE_ACTIVE ||
+        process.env.CLAUDE_PROJECT_ROOT ||
+        process.env.CLAUDE_WORKSPACE ||
+        // Check if we're in Claude Code by looking for specific patterns
+        (process.env.USER?.includes('claude') && process.env.HOME?.includes('claude')));
+}
+/**
+ * Detect active Claude model
+ */
+function detectClaudeModel() {
+    const model = process.env.CLAUDE_MODEL ||
+        process.env.ANTHROPIC_MODEL ||
+        process.env.CLAUDE_CODE_MODEL;
+    if (model) {
+        if (model.includes('opus'))
+            return 'opus-4.1';
+        if (model.includes('sonnet'))
+            return 'sonnet-4';
+    }
+    return undefined;
+}
+/**
+ * Parse technical domain from string
+ */
+function parseDomain(domain) {
+    if (!domain)
+        return undefined;
+    const domainMap = {
+        'architecture': TechnicalDomain.ARCHITECTURE,
+        'algorithms': TechnicalDomain.ALGORITHMS,
+        'debugging': TechnicalDomain.DEBUGGING,
+        'security': TechnicalDomain.SECURITY,
+        'performance': TechnicalDomain.PERFORMANCE,
+        'api_design': TechnicalDomain.API_DESIGN,
+        'database': TechnicalDomain.DATABASE,
+        'frontend': TechnicalDomain.FRONTEND,
+        'backend': TechnicalDomain.BACKEND,
+        'devops': TechnicalDomain.DEVOPS,
+        'testing': TechnicalDomain.TESTING
+    };
+    return domainMap[domain.toLowerCase()];
+}
+/**
+ * Load configuration from environment
+ */
+export function loadConfig() {
+    const isClaudeCode = detectClaudeCode();
+    const claudeModel = detectClaudeModel();
+    return {
+        isClaudeCode,
+        claudeModel,
+        apiKeys: {
+            anthropic: process.env.ANTHROPIC_API_KEY,
+            openai: process.env.OPENAI_API_KEY,
+            openrouter: process.env.OPENROUTER_API_KEY,
+            gemini: process.env.GOOGLE_API_KEY,
+            deepseek: process.env.DEEPSEEK_API_KEY,
+            perplexity: process.env.PERPLEXITY_API_KEY,
+            grok: process.env.GROK_API_KEY,
+            qwen: process.env.QWEN_API_KEY,
+        },
+        preferences: {
+            defaultDomain: parseDomain(process.env.DEFAULT_DOMAIN),
+            enableVisuals: process.env.ENABLE_VISUALS !== 'false',
+            costOptimization: process.env.COST_OPTIMIZATION !== 'false',
+            maxReasoningRounds: parseInt(process.env.MAX_REASONING_ROUNDS || '5', 10),
+            maxPingPongRounds: parseInt(process.env.MAX_PINGPONG_ROUNDS || '24', 10), // Default 24 (divisible by 6 models), users can increase if needed
+            debug: process.env.DEBUG === 'true'
+        },
+        session: {
+            enableLogging: process.env.ENABLE_SESSION_LOGGING !== 'false',
+            autoSave: process.env.SESSION_AUTO_SAVE === 'true',
+            defaultVerbose: process.env.SESSION_DEFAULT_VERBOSE === 'true',
+            sessionDir: process.env.SESSION_OUTPUT_DIR || './workflow-output/sessions',
+            outputFormat: process.env.SESSION_DEFAULT_FORMAT || 'markdown',
+            includeMetadata: process.env.SESSION_INCLUDE_METADATA !== 'false',
+            maxHistory: parseInt(process.env.SESSION_MAX_HISTORY || '100', 10)
+        },
+        workflow: {
+            outputDir: process.env.WORKFLOW_OUTPUT_DIR || './workflow-output'
+        }
+    };
+}
+/**
+ * Get available models based on configuration
+ */
+export function getAvailableModels(config) {
+    const models = [];
+    // Claude Code mode - always available
+    if (config.isClaudeCode && config.claudeModel) {
+        models.push(`claude-code-${config.claudeModel}`);
+    }
+    // API-based models
+    if (config.apiKeys.anthropic) {
+        models.push('claude-sonnet-4-api', 'claude-opus-4.1-api');
+    }
+    if (config.apiKeys.openai) {
+        // GPT-5 models (require ENABLE_GPT5=true flag)
+        if (process.env.ENABLE_GPT5 === 'true') {
+            models.push('gpt-5', 'gpt-5-mini', 'gpt-5-nano');
+        }
+    }
+    if (config.apiKeys.gemini) {
+        // Use Gemini 2.5 (latest and best)
+        models.push('gemini-2.5-flash', 'gemini-2.5-pro', 'gemini-2.5-flash-lite');
+    }
+    if (config.apiKeys.deepseek) {
+        models.push('deepseek-r1');
+    }
+    if (config.apiKeys.perplexity) {
+        models.push('sonar-pro', 'sonar-reasoning-pro', 'sonar-deep-research');
+    }
+    if (config.apiKeys.grok) {
+        models.push('grok-3', 'grok-3-fast', 'grok-4-0709');
+    }
+    if (config.apiKeys.openrouter) {
+        models.push('qwen3-coder', 'qwq-32b', 'qwen3-32b');
+    }
+    if (config.apiKeys.qwen) {
+        models.push('qwen-max');
+    }
+    return models;
+}
+/**
+ * Get configuration status for debugging
+ */
+export function getConfigStatus(config) {
+    const models = getAvailableModels(config);
+    let status = `🔧 Focus MCP Configuration\n\n`;
+    status += `**Mode**: ${config.isClaudeCode ? 'Claude Code' : 'Standalone'}\n`;
+    if (config.isClaudeCode) {
+        status += `**Active Model**: ${config.claudeModel || 'Not detected'}\n`;
+    }
+    status += `\n**Available Models** (${models.length}):\n`;
+    models.forEach(model => {
+        status += `  • ${model}\n`;
+    });
+    status += `\n**Preferences**:\n`;
+    status += `  • Default Domain: ${config.preferences.defaultDomain || 'None set'}\n`;
+    status += `  • Visuals: ${config.preferences.enableVisuals ? 'Enabled' : 'Disabled'}\n`;
+    status += `  • Cost Optimization: ${config.preferences.costOptimization ? 'Enabled' : 'Disabled'}\n`;
+    status += `  • Max Reasoning Rounds: ${config.preferences.maxReasoningRounds}\n`;
+    status += `  • Max Ping-Pong Rounds: ${config.preferences.maxPingPongRounds} (configurable via MAX_PINGPONG_ROUNDS)\n`;
+    status += `  • Debug Mode: ${config.preferences.debug ? 'On' : 'Off'}\n`;
+    status += `\n**Session Configuration**:\n`;
+    status += `  • Logging: ${config.session.enableLogging ? 'Enabled' : 'Disabled'}\n`;
+    status += `  • Auto-save: ${config.session.autoSave ? 'On' : 'Off'}\n`;
+    status += `  • Verbose by default: ${config.session.defaultVerbose ? 'Yes' : 'No'}\n`;
+    status += `  • Session Directory: ${config.session.sessionDir}\n`;
+    status += `  • Output Format: ${config.session.outputFormat}\n`;
+    status += `  • Include Metadata: ${config.session.includeMetadata ? 'Yes' : 'No'}\n`;
+    status += `  • Max History: ${config.session.maxHistory} sessions\n`;
+    if (!config.isClaudeCode && models.length === 0) {
+        status += `\n⚠️ **Warning**: No API keys configured. Add keys to .env file for full functionality.\n`;
+    }
+    return status;
+}

package/dist/src/domain/interfaces/IFocusMode.js

@@ -0,0 +1,5 @@
+/**
+ * IFocusMode Interface - Strategy pattern for Focus tool modes
+ * Follows Open/Closed Principle (SOLID) - extend via new implementations
+ */
+export {};

package/dist/src/domain/interfaces/IProvider.js

@@ -0,0 +1,6 @@
+/**
+ * IProvider Interface - Abstraction for AI providers
+ * Follows Dependency Inversion Principle (SOLID)
+ * Allows swapping providers without changing dependent code
+ */
+export {};

package/dist/src/domain/interfaces/ITool.js

@@ -0,0 +1,5 @@
+/**
+ * ITool Interface - Base abstraction for all MCP tools
+ * Follows Interface Segregation Principle (SOLID)
+ */
+export {};

package/dist/src/focus-deep.js

@@ -0,0 +1,245 @@
+/**
+ * Focus-Deep - Ultimate reasoning combining Sequential Thinking + Multi-Model Orchestration
+ * The most powerful reasoning mode in tachibot-mcp
+ */
+import { sequentialThinking } from "./sequential-thinking.js";
+import { isGeminiAvailable } from "./tools/gemini-tools.js";
+import { isPerplexityAvailable } from "./tools/perplexity-tools.js";
+import { loadConfig } from "./config.js";
+/**
+ * Create a Focus-Deep plan based on available models
+ */
+export function createFocusDeepPlan(objective, domain) {
+    const config = loadConfig();
+    const availableModels = [];
+    const steps = [];
+    // Check what's available
+    if (config.isClaudeCode) {
+        availableModels.push(`claude-${config.claudeModel}`);
+    }
+    if (isGeminiAvailable()) {
+        availableModels.push("gemini");
+    }
+    if (isPerplexityAvailable()) {
+        availableModels.push("perplexity");
+    }
+    // Always have think tool
+    availableModels.push("think");
+    // Create optimal plan based on available models
+    if (availableModels.length >= 4) {
+        // Full multi-model Focus-Deep
+        steps.push({
+            model: availableModels.includes("gemini") ? "gemini" : availableModels[0],
+            action: "brainstorm",
+            prompt: "Generate innovative approaches and identify key challenges",
+            reasoning: "Starting with creative exploration to map the solution space"
+        });
+        steps.push({
+            model: availableModels.includes("claude") ? availableModels[0] : "think",
+            action: "analyze",
+            prompt: "Critically analyze the proposed approaches, identify gaps",
+            reasoning: "Claude excels at systematic analysis and finding edge cases"
+        });
+        steps.push({
+            model: availableModels.includes("perplexity") ? "perplexity" : "think",
+            action: "research",
+            prompt: "Research evidence, best practices, and similar implementations",
+            reasoning: "Grounding our solution in real-world evidence"
+        });
+        steps.push({
+            model: availableModels[0],
+            action: "refine",
+            prompt: "Refine the approach based on research findings",
+            reasoning: "Incorporating evidence to improve the solution"
+        });
+        steps.push({
+            model: "think",
+            action: "synthesize",
+            prompt: "Synthesize all insights into a final, actionable solution",
+            reasoning: "Using think tool for cost-effective synthesis"
+        });
+    }
+    else if (availableModels.length >= 2) {
+        // Limited model Focus-Deep
+        steps.push({
+            model: availableModels[0],
+            action: "explore",
+            prompt: "Explore the problem space and generate initial solutions",
+            reasoning: "Initial exploration with primary model"
+        });
+        steps.push({
+            model: availableModels[1] !== "think" ? availableModels[1] : availableModels[0],
+            action: "critique",
+            prompt: "Critique and improve the initial solutions",
+            reasoning: "Getting a second perspective or self-critique"
+        });
+        steps.push({
+            model: availableModels[0],
+            action: "refine",
+            prompt: "Refine based on critique and develop final approach",
+            reasoning: "Iterative improvement"
+        });
+        steps.push({
+            model: "think",
+            action: "synthesize",
+            prompt: "Synthesize the final solution",
+            reasoning: "Final synthesis"
+        });
+    }
+    else {
+        // Single model Focus-Deep (Claude Code only)
+        steps.push({
+            model: availableModels[0],
+            action: "decompose",
+            prompt: "Break down the problem into components",
+            reasoning: "Problem decomposition"
+        });
+        steps.push({
+            model: availableModels[0],
+            action: "explore",
+            prompt: "Explore solutions for each component",
+            reasoning: "Solution exploration"
+        });
+        steps.push({
+            model: availableModels[0],
+            action: "integrate",
+            prompt: "Integrate component solutions",
+            reasoning: "Solution integration"
+        });
+        steps.push({
+            model: "think",
+            action: "finalize",
+            prompt: "Finalize and validate the solution",
+            reasoning: "Final validation"
+        });
+    }
+    // Start sequential thinking session
+    const sessionId = sequentialThinking.startSession(objective, steps.length);
+    return {
+        sessionId,
+        objective,
+        steps,
+        estimatedThoughts: steps.length,
+        availableModels
+    };
+}
+/**
+ * Generate Focus-Deep visualization
+ */
+export function generateFocusDeepVisualization(plan) {
+    let viz = `# 🧠⚡ FOCUS-DEEP SESSION\n\n`;
+    viz += `**Objective**: ${plan.objective}\n`;
+    viz += `**Available Models**: ${plan.availableModels.join(", ")}\n`;
+    viz += `**Thoughts Planned**: ${plan.estimatedThoughts}\n\n`;
+    // ASCII art for Focus-Deep
+    viz += "```\n";
+    viz += "@@@@@@@@@@@@@@@@@@@@@\n";
+    viz += "@   ◉       ◉   @ 🧠⚡ ULTRATHINKING...\n";
+    viz += "@       ≈       @    Maximum reasoning power\n";
+    viz += "@   =========   @    Sequential + Multi-Model\n";
+    viz += "@@@@@@@@@@@@@@@@@@@@@\n";
+    viz += "```\n\n";
+    // Model flow diagram
+    viz += "## Reasoning Flow\n\n";
+    viz += "```\n";
+    plan.steps.forEach((step, idx) => {
+        const arrow = idx < plan.steps.length - 1 ? " ──► " : "";
+        viz += `[${step.model}:${step.action}]${arrow}`;
+        if ((idx + 1) % 3 === 0 && idx < plan.steps.length - 1) {
+            viz += "\n         ⬇\n";
+        }
+    });
+    viz += "\n```\n\n";
+    // Detailed steps
+    viz += "## Execution Plan\n\n";
+    plan.steps.forEach((step, idx) => {
+        viz += `### Thought ${idx + 1}: ${step.action.toUpperCase()}\n`;
+        viz += `**Model**: ${step.model}\n`;
+        viz += `**Task**: ${step.prompt}\n`;
+        if (step.reasoning) {
+            viz += `**Reasoning**: ${step.reasoning}\n`;
+        }
+        viz += "\n";
+    });
+    // Instructions
+    viz += "## How Focus-Deep Works\n\n";
+    viz += "1. **Sequential Thinking**: Each thought builds on previous insights\n";
+    viz += "2. **Multi-Model Orchestration**: Different models handle different aspects\n";
+    viz += "3. **Dynamic Adaptation**: Can revise or branch based on discoveries\n";
+    viz += "4. **Synthesis**: Final thought combines all insights\n\n";
+    viz += "### Unique Features:\n";
+    viz += "- 🔄 **Revision**: Can go back and revise earlier thoughts\n";
+    viz += "- 🌿 **Branching**: Explore alternative reasoning paths\n";
+    viz += "- 🎯 **Focused**: Each model used for its strengths\n";
+    viz += "- 💰 **Efficient**: Think tool for synthesis (no API cost)\n\n";
+    viz += "**Note**: This is the most powerful reasoning mode in tachibot-mcp, ";
+    viz += "combining the best of sequential thinking and multi-model collaboration.\n";
+    return viz;
+}
+/**
+ * Execute a single Focus-Deep step
+ */
+export async function executeFocusDeepStep(sessionId, stepIndex, plan, previousResponse) {
+    const step = plan.steps[stepIndex];
+    if (!step) {
+        throw new Error(`Invalid step index: ${stepIndex}`);
+    }
+    // Build context from previous responses
+    let context = `Objective: ${plan.objective}\n`;
+    if (previousResponse) {
+        context += `Previous insight: ${previousResponse.substring(0, 500)}...\n`;
+    }
+    context += `Current task: ${step.prompt}`;
+    // Map to actual tool based on model and action
+    let tool = "think"; // Default
+    let parameters = { thought: context };
+    if (step.model === "gemini" && step.action === "brainstorm") {
+        tool = "gemini_brainstorm";
+        parameters = {
+            prompt: plan.objective,
+            claudeThoughts: previousResponse
+        };
+    }
+    else if (step.model === "perplexity" && step.action === "research") {
+        tool = "perplexity_research";
+        parameters = {
+            topic: plan.objective,
+            depth: "standard"
+        };
+    }
+    else if (step.model.includes("claude")) {
+        // Use current Claude session
+        tool = "think";
+        parameters = { thought: `${step.action}: ${context}` };
+    }
+    return {
+        instruction: `Step ${stepIndex + 1}/${plan.steps.length}: ${step.action}`,
+        tool,
+        parameters
+    };
+}
+/**
+ * Check if Focus-Deep can run optimally
+ */
+export function canRunFocusDeep() {
+    const config = loadConfig();
+    const models = [];
+    if (config.isClaudeCode) {
+        models.push("claude");
+    }
+    if (isGeminiAvailable()) {
+        models.push("gemini");
+    }
+    if (isPerplexityAvailable()) {
+        models.push("perplexity");
+    }
+    models.push("think"); // Always available
+    const quality = models.length >= 4 ? "optimal" :
+        models.length >= 3 ? "good" :
+            "basic";
+    return {
+        available: true, // Always available, just varies in quality
+        models,
+        quality
+    };
+}

package/dist/src/infrastructure/ascii/art/robots.ascii.js

@@ -0,0 +1,16 @@
+/**
+ * Robot ASCII Art - Presentation Layer
+ * Extracted from server.ts (Phase 1 of SOLID refactoring)
+ */
+export const ROBOT_ASCII = {
+    tachiBot: {
+        exploring: `@@@@@@@@@
+@  ○ ○  @ 🤖🔍 TachiBot: Starting the hunt...
+@  \\_/  @
+@@@@@@@@@`,
+        discovery: `@@@@@@@@@
+@  ★ ★  @ 🤖🧠 TachiBot: EUREKA MOMENT!
+@ \\\\o// @
+@@@@@@@@@`
+    }
+};

package/dist/src/mcp-client.js

@@ -0,0 +1,90 @@
+// Note: MCP servers cannot directly call other MCP servers.
+// This class generates instructions for the client (Claude) to execute tools.
+export class MCPClient {
+    constructor() {
+        this.availableTools = new Set();
+    }
+    async connect() {
+        // In a real implementation, this would discover available tools
+        // For now, we'll assume these tools are available
+        this.availableTools = new Set([
+            'mcp__gemini__gemini-brainstorm',
+            'mcp__perplexity-ask__perplexity_research',
+            'mcp__openai-mcp__openai_gpt5_reason',
+            'mcp__openai-mcp__openai_brainstorm',
+            'mcp__think-mcp-server__think',
+            'mcp__devlog-search__search_devlogs',
+            'mcp__devlog-core__devlog_session_log'
+        ]);
+    }
+    hasTools(tools) {
+        return tools.every(tool => this.availableTools.has(tool));
+    }
+    // Instead of executing directly, return structured instructions
+    async executeTool(toolName, parameters) {
+        if (!this.availableTools.has(toolName)) {
+            throw new Error(`Tool ${toolName} not available`);
+        }
+        // Return a placeholder that indicates the tool should be called
+        // In real usage, this would be replaced by actual tool execution by Claude
+        return `[EXECUTE_TOOL: ${toolName}]`;
+    }
+    // Generate instructions for Claude to execute tools
+    generateToolInstructions(toolName, parameters) {
+        // Map internal parameters to tool-specific parameters
+        const toolParams = this.mapParameters(toolName, parameters);
+        return {
+            tool: toolName,
+            parameters: toolParams,
+            description: this.getToolDescription(toolName)
+        };
+    }
+    mapParameters(toolName, params) {
+        // Map generic parameters to tool-specific ones
+        switch (toolName) {
+            case 'mcp__gemini__gemini-brainstorm':
+                return {
+                    prompt: params.prompt || params.query,
+                    claudeThoughts: params.context || 'Orchestrating brainstorm session'
+                };
+            case 'mcp__perplexity-ask__perplexity_research':
+            case 'mcp__perplexity-ask__perplexity_reason':
+                return {
+                    messages: [{
+                            role: 'user',
+                            content: params.prompt || params.query
+                        }]
+                };
+            case 'mcp__openai-mcp__openai_gpt5_reason':
+                return {
+                    query: params.prompt || params.query,
+                    context: params.context
+                };
+            case 'mcp__openai-mcp__openai_brainstorm':
+                return {
+                    problem: params.prompt || params.query,
+                    constraints: params.context
+                };
+            case 'mcp__think-mcp-server__think':
+                return {
+                    thought: params.thought || params.prompt || params.query
+                };
+            default:
+                return params;
+        }
+    }
+    getToolDescription(toolName) {
+        const descriptions = {
+            'mcp__gemini__gemini-brainstorm': 'Creative brainstorming with Gemini',
+            'mcp__perplexity-ask__perplexity_research': 'Deep research with citations',
+            'mcp__openai-mcp__openai_gpt5_reason': 'Mathematical/logical reasoning (GPT-5-mini)',
+            'mcp__openai-mcp__openai_brainstorm': 'Alternative perspective generation',
+            'mcp__think-mcp-server__think': 'Reflective thinking scratchpad'
+        };
+        return descriptions[toolName] || 'Execute tool';
+    }
+    // Generate a batch of tool instructions for a workflow
+    generateWorkflowInstructions(tools) {
+        return tools.map(({ name, prompt, context }) => this.generateToolInstructions(name, { prompt, context }));
+    }
+}