@sowonai/crewx-cli 0.4.0-dev.1

package/dist/crewx.tool.js

@@ -0,0 +1,1461 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var CrewXTool_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrewXTool = void 0;
+const common_1 = require("@nestjs/common");
+const nestjs_mcp_adapter_1 = require("@sowonai/nestjs-mcp-adapter");
+const zod_1 = require("zod");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const ai_service_1 = require("./ai.service");
+const ai_provider_service_1 = require("./ai-provider.service");
+const project_service_1 = require("./project.service");
+const crewx_sdk_1 = require("@sowonai/crewx-sdk");
+const parallel_processing_service_1 = require("./services/parallel-processing.service");
+const task_management_service_1 = require("./services/task-management.service");
+const result_formatter_service_1 = require("./services/result-formatter.service");
+const template_service_1 = require("./services/template.service");
+const document_loader_service_1 = require("./services/document-loader.service");
+const tool_call_service_1 = require("./services/tool-call.service");
+const agent_loader_service_1 = require("./services/agent-loader.service");
+const remote_agent_service_1 = require("./services/remote-agent.service");
+let CrewXTool = CrewXTool_1 = class CrewXTool {
+    generateSecurityKey() {
+        return crypto.randomBytes(8).toString('hex');
+    }
+    buildToolsContext() {
+        const tools = this.toolCallService.list();
+        if (!tools || tools.length === 0) {
+            return undefined;
+        }
+        return {
+            list: tools.map(t => ({
+                name: t.name,
+                description: t.description,
+                input_schema: t.input_schema,
+                output_schema: t.output_schema,
+            })),
+            json: JSON.stringify(tools, null, 2),
+            count: tools.length,
+        };
+    }
+    async buildStructuredPayload(params) {
+        const { agentId, provider, mode, prompt, context, messages, platform, model } = params;
+        const safeMessages = Array.isArray(messages) ? messages : [];
+        let formattedHistory = '';
+        try {
+            if (safeMessages.length > 0) {
+                const template = '{{{formatConversation messages platform}}}';
+                const { processDocumentTemplate } = await Promise.resolve().then(() => __importStar(require('./utils/template-processor')));
+                formattedHistory = await processDocumentTemplate(template, this.documentLoaderService, {
+                    messages: safeMessages,
+                    platform: platform ?? 'cli',
+                });
+                formattedHistory = formattedHistory?.trim() ?? '';
+            }
+        }
+        catch (error) {
+            this.logger.warn(`Failed to format conversation history for structured payload: ${error?.message || error}`);
+        }
+        const normalizedContext = context?.trim() ?? '';
+        const payload = {
+            version: '1.0',
+            agent: {
+                id: agentId,
+                provider,
+                mode,
+                model: model || null,
+            },
+            prompt,
+            context: normalizedContext,
+            messages: safeMessages,
+            metadata: {
+                platform: platform ?? 'cli',
+                formattedHistory,
+                messageCount: safeMessages.length,
+                generatedAt: new Date().toISOString(),
+                originalContext: normalizedContext,
+            },
+        };
+        return JSON.stringify(payload);
+    }
+    constructor(aiService, aiProviderService, projectService, parallelProcessingService, taskManagementService, resultFormatterService, templateService, documentLoaderService, toolCallService, agentLoaderService, remoteAgentService) {
+        this.aiService = aiService;
+        this.aiProviderService = aiProviderService;
+        this.projectService = projectService;
+        this.parallelProcessingService = parallelProcessingService;
+        this.taskManagementService = taskManagementService;
+        this.resultFormatterService = resultFormatterService;
+        this.templateService = templateService;
+        this.documentLoaderService = documentLoaderService;
+        this.toolCallService = toolCallService;
+        this.agentLoaderService = agentLoaderService;
+        this.remoteAgentService = remoteAgentService;
+        this.logger = new common_1.Logger(CrewXTool_1.name);
+        this.timeoutConfig = (0, crewx_sdk_1.getTimeoutConfig)();
+    }
+    onModuleInit() {
+        this.toolCallService.setCrewXTool(this);
+        this.logger.log('CrewXTool registered to ToolCallService');
+    }
+    async getTaskLogs(input) {
+        this.logger.log('=== getTaskLogs called ===');
+        this.logger.log(`Input taskId: ${input.taskId}`);
+        try {
+            const logsContent = this.taskManagementService.getTaskLogsFromFile(input.taskId);
+            return {
+                content: [{ type: 'text', text: logsContent }],
+                isError: false
+            };
+        }
+        catch (error) {
+            this.logger.error('Error reading logs:', error);
+            return {
+                content: [{ type: 'text', text: `Error reading logs: ${error.message}` }],
+                isError: true
+            };
+        }
+    }
+    async checkAIProviders() {
+        this.logger.log('Checking AI provider availability');
+        try {
+            const availableProviders = await this.aiService.checkAvailableProviders();
+            const installation = await this.aiService.validateCLIInstallation();
+            const recommendations = this.getInstallationRecommendations(installation);
+            const responseText = `🤖 **AI Providers Status**
+
+**Available Providers:**
+${availableProviders.length > 0 ? availableProviders.map(p => `✅ ${p}`).join('\n') : '❌ No providers available'}
+
+**Installation Status:**
+• Claude CLI: ${installation.claude ? '✅ Installed' : '❌ Not Installed'}
+• Gemini CLI: ${installation.gemini ? '✅ Installed' : '❌ Not Installed'}  
+• Copilot CLI: ${installation.copilot ? '✅ Installed' : '❌ Not Installed'}
+
+**Recommendations:**
+${recommendations.map(r => `• ${r}`).join('\n')}`;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: responseText
+                    }
+                ],
+                success: true,
+                availableProviders,
+                installation: {
+                    claude: installation.claude,
+                    gemini: installation.gemini,
+                    copilot: installation.copilot,
+                },
+                recommendations,
+            };
+        }
+        catch (error) {
+            const errorMessage = (0, crewx_sdk_1.getErrorMessage)(error);
+            this.logger.error(`Provider check failed: ${errorMessage}`, (0, crewx_sdk_1.getErrorStack)(error));
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ **AI Providers Check Failed**
+
+**Error:** ${errorMessage}
+
+No AI providers could be verified.`
+                    }
+                ],
+                success: false,
+                error: errorMessage,
+                availableProviders: [],
+                installation: {
+                    claude: { installed: false },
+                    gemini: { installed: false },
+                    copilot: { installed: false }
+                }
+            };
+        }
+    }
+    getInstallationRecommendations(installation) {
+        const recommendations = [];
+        if (!installation.claude) {
+            recommendations.push('Claude CLI installation: npm install -g @anthropic-ai/claude-code');
+        }
+        if (!installation.gemini) {
+            recommendations.push('Gemini CLI installation: npm install -g @google/gemini-cli');
+        }
+        if (!installation.copilot) {
+            recommendations.push('GitHub Copilot CLI installation: npm install -g @github/copilot-cli or gh extension install github/gh-copilot');
+        }
+        if (installation.claude && installation.gemini && installation.copilot) {
+            recommendations.push('All AI providers are available!');
+        }
+        return recommendations;
+    }
+    async listAgents() {
+        try {
+            const agents = await this.agentLoaderService.getAllAgents();
+            this.logger.log(`Retrieved ${agents.length} available agents`);
+            const agentsConfigPath = process.env.CREWX_CONFIG;
+            let yamlContent = '';
+            if (agentsConfigPath) {
+                try {
+                    const { readFile } = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+                    yamlContent = await readFile(agentsConfigPath, 'utf-8');
+                }
+                catch (error) {
+                    this.logger.warn('Could not read YAML file for display:', (0, crewx_sdk_1.getErrorMessage)(error));
+                }
+            }
+            const responseText = `🤖 **Available AI Agents (${agents.length} total)**
+
+**Configuration Source:** ${process.env.CREWX_CONFIG ? 'External YAML file' : 'Built-in defaults'}
+${process.env.CREWX_CONFIG ? `**Config Path:** \`${process.env.CREWX_CONFIG}\`` : ''}
+
+**Parsed Agent Summary:**
+${agents.map((agent, index) => `${index + 1}. **${agent.id}**
+   - Provider: ${agent.provider}
+   - Working Dir: ${agent.workingDirectory}
+   ${agent.name ? `- Name: ${agent.name}` : ''}
+   ${agent.role ? `- Role: ${agent.role}` : ''}
+   ${agent.team ? `- Team: ${agent.team}` : ''}
+`).join('')}
+
+${yamlContent ? `**Full YAML Configuration:**
+\`\`\`yaml
+${yamlContent}
+\`\`\`
+
+**💡 Customization Guide:**
+You can customize agents by modifying the YAML file. Required fields:
+- \`id\`: Unique identifier
+- \`working_directory\`: Path for agent operations  
+- \`inline.provider\`: AI provider (claude/gemini/copilot)
+- \`inline.system_prompt\`: Agent's specialized instructions
+
+Optional fields (like \`name\`, \`role\`, \`team\`, etc.) can be added for better organization.` : `**Default Configuration:**
+No external YAML file configured. Using built-in agents.
+Set \`CREWX_CONFIG\` environment variable to use custom agents.
+
+**Example YAML Structure:**
+\`\`\`yaml
+agents:
+  - id: "your_agent_id"
+    name: "Your Agent Name"
+    role: "specialist"
+    working_directory: "/path/to/project"
+    inline:
+      type: "agent"
+      provider: "claude"
+      system_prompt: |
+        You are a specialized AI agent for...
+\`\`\``}
+
+**Recommendations:**
+
+**🚀 Performance Tip:** For optimal results, formulate queries in English. Testing shows English queries typically produce more detailed responses, faster processing times (20% improvement), and higher success rates compared to other languages.
+
+**Configuration Source:** ${process.env.CREWX_CONFIG ? 'External YAML file' : 'Default hardcoded values'}`;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: responseText
+                    }
+                ],
+                success: true,
+                availableAgents: agents,
+                totalCount: agents.length,
+                configurationSource: process.env.CREWX_CONFIG ? 'External YAML file' : 'Default hardcoded values'
+            };
+        }
+        catch (error) {
+            const errorMessage = (0, crewx_sdk_1.getErrorMessage)(error);
+            this.logger.error('Agent listing failed:', errorMessage);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ **Error loading agents:** ${errorMessage}
+
+**Fallback:** No agents available due to configuration error.`
+                    }
+                ],
+                success: false,
+                error: errorMessage,
+                availableAgents: [],
+                totalCount: 0
+            };
+        }
+    }
+    async queryAgent(args) {
+        const taskId = this.taskManagementService.createTask({
+            type: 'query',
+            provider: 'claude',
+            prompt: args.query,
+            agentId: args.agentId
+        });
+        const agentDescriptor = args.model ? `${args.agentId} (model: ${args.model})` : args.agentId;
+        this.taskManagementService.addTaskLog(taskId, { level: 'info', message: `Started query agent ${agentDescriptor}` });
+        try {
+            const { agentId, query, context, model, messages, platform } = args;
+            this.logger.log(`[${taskId}] Querying agent ${agentId}: ${query.substring(0, 50)}...`);
+            this.taskManagementService.addTaskLog(taskId, { level: 'info', message: `Query: ${query.substring(0, 100)}...` });
+            if (model) {
+                this.taskManagementService.addTaskLog(taskId, { level: 'info', message: `Model: ${model}` });
+            }
+            const agents = await this.agentLoaderService.getAllAgents();
+            const agent = agents.find(a => a.id === agentId);
+            if (!agent) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `❌ **Agent Not Found**
+
+**Error:** Agent '${agentId}' not found.
+
+**Available Agents:** ${agents.map(a => a.id).join(', ')}
+
+Please check the agent ID and try again.`
+                        }
+                    ],
+                    success: false,
+                    agent: agentId,
+                    error: `Agent '${agentId}' not found`,
+                    availableAgents: agents.map(a => a.id),
+                    readOnlyMode: true
+                };
+            }
+            if (agent.remote?.type === 'mcp-http') {
+                try {
+                    const remoteResult = await this.remoteAgentService.queryRemoteAgent(agent, {
+                        query,
+                        context,
+                        model,
+                        platform,
+                        messages,
+                    });
+                    const normalized = this.normalizeRemoteResult(agent, taskId, remoteResult, true);
+                    const logLevel = normalized.success ? 'info' : 'error';
+                    this.taskManagementService.addTaskLog(taskId, {
+                        level: logLevel,
+                        message: normalized.success
+                            ? 'Remote agent query completed successfully'
+                            : `Remote agent query failed: ${normalized.error || 'Unknown error'}`,
+                    });
+                    this.taskManagementService.completeTask(taskId, normalized, normalized.success !== false);
+                    return normalized;
+                }
+                catch (error) {
+                    const errorMessage = (0, crewx_sdk_1.getErrorMessage)(error);
+                    this.taskManagementService.addTaskLog(taskId, {
+                        level: 'error',
+                        message: `Remote agent query failed: ${errorMessage}`,
+                    });
+                    this.taskManagementService.completeTask(taskId, { success: false, error: errorMessage }, false);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `❌ **Remote agent error**\n\n\
+${errorMessage}`,
+                            },
+                        ],
+                        success: false,
+                        agent: agentId,
+                        provider: 'remote',
+                        error: errorMessage,
+                        taskId,
+                        readOnlyMode: true,
+                        readOnly: true,
+                    };
+                }
+            }
+            const workingDir = agent.workingDirectory || process.cwd();
+            let systemPrompt = agent.systemPrompt || agent.description || `You are an expert ${agentId}.`;
+            const securityKey = this.generateSecurityKey();
+            if (systemPrompt) {
+                const { processDocumentTemplate } = await Promise.resolve().then(() => __importStar(require('./utils/template-processor')));
+                const contextMessages = messages && messages.length > 0 ? messages.slice(0, -1) : [];
+                const templateContext = {
+                    env: process.env,
+                    agent: {
+                        id: agent.id,
+                        name: agent.name || agent.id,
+                        provider: (Array.isArray(agent.provider) ? agent.provider[0] : agent.provider) || 'claude',
+                        model: model || agent.inline?.model,
+                        workingDirectory: workingDir,
+                    },
+                    mode: 'query',
+                    messages: contextMessages,
+                    platform: platform,
+                    tools: this.buildToolsContext(),
+                    vars: {
+                        security_key: securityKey,
+                    },
+                };
+                systemPrompt = await processDocumentTemplate(systemPrompt, this.documentLoaderService, templateContext);
+            }
+            systemPrompt += `
+
+Specialties: ${agent.specialties?.join(', ') || 'General'}
+Capabilities: ${agent.capabilities?.join(', ') || 'Analysis'}
+Working Directory: ${workingDir}`;
+            const wrappedQuery = `
+<user_query key="${securityKey}">
+${query}
+</user_query>`;
+            let fullPrompt = systemPrompt;
+            if (context) {
+                fullPrompt += `\n\n${context}`;
+            }
+            fullPrompt += `\n\n${wrappedQuery}`;
+            let response;
+            let provider;
+            if (Array.isArray(agent.provider)) {
+                if (agent.inline?.model || model) {
+                    provider = agent.provider[0] || 'claude';
+                }
+                else {
+                    provider = await this.getAvailableProvider(agent.provider);
+                    this.taskManagementService.addTaskLog(taskId, { level: 'info', message: `Using fallback provider: ${provider}` });
+                }
+            }
+            else {
+                provider = agent.provider || 'claude';
+            }
+            const agentOptions = this.getOptionsForAgent(agent, 'query', provider);
+            const modelToUse = model || agent.inline?.model;
+            const structuredPayload = await this.buildStructuredPayload({
+                agentId,
+                provider,
+                mode: 'query',
+                prompt: fullPrompt,
+                context,
+                messages,
+                platform: platform || 'cli',
+                model: modelToUse,
+            });
+            response = await this.aiService.queryAI(fullPrompt, provider, {
+                workingDirectory: workingDir,
+                timeout: this.timeoutConfig.parallel,
+                additionalArgs: agentOptions,
+                taskId,
+                model: modelToUse,
+                agentId,
+                securityKey,
+                messages,
+                pipedContext: structuredPayload,
+            });
+            this.taskManagementService.addTaskLog(taskId, { level: 'info', message: `Query completed. Success: ${response.success}` });
+            this.taskManagementService.completeTask(taskId, response, response.success);
+            const responseText = response.success
+                ? response.content
+                : `❌ **Error**\n\`\`\`${response.error}\`\`\`\n\nAgent: ${agentId} (${response.provider}) · Task ID: \`${taskId}\``;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: responseText
+                    }
+                ],
+                taskId: taskId,
+                success: response.success,
+                agent: agentId,
+                provider: response.provider,
+                query: query,
+                response: response.content,
+                readOnlyMode: true,
+                error: response.error,
+                workingDirectory: workingDir
+            };
+        }
+        catch (error) {
+            const errorMessage = (0, crewx_sdk_1.getErrorMessage)(error);
+            this.taskManagementService.addTaskLog(taskId, { level: 'error', message: `Query failed: ${errorMessage}` });
+            this.taskManagementService.completeTask(taskId, { error: errorMessage }, false);
+            this.logger.error(`[${taskId}] Agent query failed for ${args.agentId}:`, errorMessage);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ **Agent Query Failed**
+
+**Task ID:** ${taskId}
+**Agent:** ${args.agentId}
+**Error:** ${errorMessage}
+**Query:** ${args.query}
+
+Read-Only Mode: No files were modified.`
+                    }
+                ],
+                success: false,
+                agent: args.agentId,
+                error: errorMessage,
+                readOnlyMode: true
+            };
+        }
+    }
+    async executeAgent(args) {
+        const taskId = this.taskManagementService.createTask({
+            type: 'execute',
+            provider: 'claude',
+            prompt: args.task,
+            agentId: args.agentId
+        });
+        const agentDescriptor = args.model ? `${args.agentId} (model: ${args.model})` : args.agentId;
+        this.taskManagementService.addTaskLog(taskId, { level: 'info', message: `Started execute agent ${agentDescriptor}` });
+        try {
+            const { agentId, task, projectPath, context, model, messages, platform } = args;
+            this.logger.log(`[${taskId}] Executing agent ${agentId}: ${task.substring(0, 50)}...`);
+            this.taskManagementService.addTaskLog(taskId, { level: 'info', message: `Task: ${task.substring(0, 100)}...` });
+            if (model) {
+                this.taskManagementService.addTaskLog(taskId, { level: 'info', message: `Model: ${model}` });
+            }
+            const agents = await this.agentLoaderService.getAllAgents();
+            const agent = agents.find(a => a.id === agentId);
+            if (!agent) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `❌ **Agent Not Found**
+
+**Error:** Agent '${agentId}' not found.
+
+**Available Agents:** ${agents.map(a => a.id).join(', ')}
+
+Please check the agent ID and try again.`
+                        }
+                    ],
+                    success: false,
+                    agent: agentId,
+                    error: `Agent '${agentId}' not found`,
+                    availableAgents: agents.map(a => a.id),
+                    executionMode: true
+                };
+            }
+            if (agent.remote?.type === 'mcp-http') {
+                try {
+                    const remoteResult = await this.remoteAgentService.executeRemoteAgent(agent, {
+                        task,
+                        context,
+                        model,
+                        platform,
+                        messages,
+                    });
+                    const normalized = this.normalizeRemoteResult(agent, taskId, remoteResult, false);
+                    const logLevel = normalized.success ? 'info' : 'error';
+                    this.taskManagementService.addTaskLog(taskId, {
+                        level: logLevel,
+                        message: normalized.success
+                            ? 'Remote agent execute completed successfully'
+                            : `Remote agent execute failed: ${normalized.error || 'Unknown error'}`,
+                    });
+                    this.taskManagementService.completeTask(taskId, normalized, normalized.success !== false);
+                    return normalized;
+                }
+                catch (error) {
+                    const errorMessage = (0, crewx_sdk_1.getErrorMessage)(error);
+                    this.taskManagementService.addTaskLog(taskId, {
+                        level: 'error',
+                        message: `Remote agent execute failed: ${errorMessage}`,
+                    });
+                    this.taskManagementService.completeTask(taskId, { success: false, error: errorMessage }, false);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `❌ **Remote agent error**\n\n${errorMessage}`,
+                            },
+                        ],
+                        success: false,
+                        agent: agentId,
+                        provider: 'remote',
+                        error: errorMessage,
+                        taskId,
+                        executionMode: true,
+                        readOnly: false,
+                    };
+                }
+            }
+            const workingDir = projectPath || agent.workingDirectory || './';
+            let systemPrompt = agent.systemPrompt || agent.description || `You are an expert ${agentId}.`;
+            const securityKey = this.generateSecurityKey();
+            if (systemPrompt) {
+                const { processDocumentTemplate } = await Promise.resolve().then(() => __importStar(require('./utils/template-processor')));
+                const contextMessages = messages && messages.length > 0 ? messages.slice(0, -1) : [];
+                const templateContext = {
+                    env: process.env,
+                    agent: {
+                        id: agent.id,
+                        name: agent.name || agent.id,
+                        provider: (Array.isArray(agent.provider) ? agent.provider[0] : agent.provider) || 'claude',
+                        model: model || agent.inline?.model,
+                        workingDirectory: workingDir,
+                    },
+                    mode: 'execute',
+                    messages: contextMessages,
+                    platform: platform,
+                    tools: this.buildToolsContext(),
+                    vars: {
+                        security_key: securityKey,
+                    },
+                };
+                systemPrompt = await processDocumentTemplate(systemPrompt, this.documentLoaderService, templateContext);
+            }
+            systemPrompt += `
+Specialties: ${agent.specialties?.join(', ') || 'General'}
+Capabilities: ${agent.capabilities?.join(', ') || 'Implementation'}
+Working Directory: ${workingDir}`;
+            const fullPrompt = context
+                ? `${systemPrompt}
+${context}
+
+Task: ${task}
+`
+                : `${systemPrompt}
+
+Task: ${task}
+`;
+            let response;
+            let provider;
+            if (Array.isArray(agent.provider)) {
+                if (agent.inline?.model || model) {
+                    provider = agent.provider[0] || 'claude';
+                }
+                else {
+                    provider = await this.getAvailableProvider(agent.provider);
+                    this.taskManagementService.addTaskLog(taskId, { level: 'info', message: `Using fallback provider: ${provider}` });
+                }
+            }
+            else {
+                provider = agent.provider || 'claude';
+            }
+            this.taskManagementService.addTaskLog(taskId, { level: 'info', message: `Using provider: ${provider}` });
+            const agentOptions = this.getOptionsForAgent(agent, 'execute', provider);
+            const modelToUse = model || agent.inline?.model;
+            const structuredPayload = await this.buildStructuredPayload({
+                agentId,
+                provider,
+                mode: 'execute',
+                prompt: fullPrompt,
+                context,
+                messages,
+                platform: platform || 'cli',
+                model: modelToUse,
+            });
+            response = await this.aiService.executeAI(fullPrompt, provider, {
+                workingDirectory: workingDir,
+                timeout: 1200000,
+                taskId: taskId,
+                additionalArgs: agentOptions,
+                model: modelToUse,
+                agentId,
+                messages,
+                pipedContext: structuredPayload,
+            });
+            this.taskManagementService.addTaskLog(taskId, { level: 'info', message: `Execution completed. Success: ${response.success}` });
+            this.taskManagementService.completeTask(taskId, response, response.success);
+            const responseText = response.success ? response.content : `❌ Execution Failed: ${response.error}`;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: responseText
+                    }
+                ],
+                success: response.success,
+                taskId: taskId,
+                agent: agentId,
+                provider: response.provider,
+                implementation: response.content,
+                error: response.error,
+                recommendations: []
+            };
+        }
+        catch (error) {
+            const errorMessage = (0, crewx_sdk_1.getErrorMessage)(error);
+            this.taskManagementService.addTaskLog(taskId, { level: 'error', message: `Execution failed: ${errorMessage}` });
+            this.taskManagementService.completeTask(taskId, { error: errorMessage }, false);
+            this.logger.error(`[${taskId}] Agent execution failed for ${args.agentId}:`, errorMessage);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ Execution Failed: ${errorMessage}`
+                    }
+                ],
+                success: false,
+                taskId: taskId,
+                agent: args.agentId,
+                provider: 'unknown',
+                implementation: null,
+                error: errorMessage,
+                recommendations: []
+            };
+        }
+    }
+    normalizeRemoteResult(agent, taskId, remoteResult, readOnly) {
+        const normalizedAgentId = remoteResult?.agent ?? agent.remote?.agentId ?? agent.id;
+        const provider = remoteResult?.provider ?? 'remote';
+        let content = remoteResult?.content;
+        if (!Array.isArray(content) || content.length === 0) {
+            const fallback = remoteResult?.response ??
+                remoteResult?.implementation ??
+                remoteResult?.message ??
+                remoteResult?.output;
+            const text = typeof fallback === 'string'
+                ? fallback
+                : JSON.stringify(fallback ?? remoteResult, null, 2);
+            content = [
+                {
+                    type: 'text',
+                    text,
+                },
+            ];
+        }
+        return {
+            ...remoteResult,
+            content,
+            agent: normalizedAgentId,
+            provider,
+            taskId: remoteResult?.taskId ?? taskId,
+            success: remoteResult?.success !== false,
+            readOnlyMode: readOnly,
+            readOnly,
+        };
+    }
+    getOptionsForAgent(agent, mode, provider) {
+        try {
+            if (agent.options && typeof agent.options === 'object' && !Array.isArray(agent.options)) {
+                const modeOptions = agent.options[mode];
+                if (modeOptions && typeof modeOptions === 'object' && !Array.isArray(modeOptions)) {
+                    if (provider) {
+                        const simpleProviderName = provider.includes('/') ? provider.split('/').pop() : provider;
+                        if (simpleProviderName && modeOptions[simpleProviderName]) {
+                            return modeOptions[simpleProviderName];
+                        }
+                        if (modeOptions[provider]) {
+                            return modeOptions[provider];
+                        }
+                    }
+                    if (modeOptions['default']) {
+                        return modeOptions['default'];
+                    }
+                    return [];
+                }
+                return modeOptions || [];
+            }
+            if (agent.options && Array.isArray(agent.options)) {
+                return agent.options;
+            }
+            return [];
+        }
+        catch (error) {
+            this.logger.warn(`Failed to get options for agent ${agent.id}: ${error}`);
+            return [];
+        }
+    }
+    async queryAgentParallel(args) {
+        try {
+            const { queries } = args;
+            this.logger.log(`Starting parallel agent queries (${queries.length} queries)`);
+            if (!queries || queries.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `❌ **No Queries Provided**
+
+Please provide at least one query in the queries array.
+
+**Example:**
+\`\`\`json
+{
+  "queries": [
+    {
+      "agentId": "gmail_mcp_developer",
+      "query": "Analyze the README"
+    },
+    {
+      "agentId": "frontend_developer", 
+      "query": "Explain the component structure"
+    }
+  ]
+}
+\`\`\``
+                        }
+                    ],
+                    success: false,
+                    error: 'No queries provided',
+                    results: []
+                };
+            }
+            queries.forEach((q, index) => {
+                this.logger.log(`Query ${index + 1}: ${q.agentId} -> "${q.query.substring(0, 50)}..."`);
+            });
+            const startTime = Date.now();
+            const queryPromises = queries.map(async (q, index) => {
+                const queryStart = Date.now();
+                try {
+                    const result = await this.queryAgent({
+                        agentId: q.agentId,
+                        query: q.query,
+                        context: q.context,
+                        model: q.model,
+                        messages: q.messages,
+                        platform: q.platform
+                    });
+                    const duration = Date.now() - queryStart;
+                    return {
+                        index: index + 1,
+                        agentId: q.agentId,
+                        query: q.query,
+                        success: result.success !== false,
+                        response: result.response || result.content?.[0]?.text,
+                        provider: result.provider,
+                        duration,
+                        taskId: result.taskId
+                    };
+                }
+                catch (error) {
+                    const duration = Date.now() - queryStart;
+                    return {
+                        index: index + 1,
+                        agentId: q.agentId,
+                        query: q.query,
+                        success: false,
+                        error: error.message,
+                        duration
+                    };
+                }
+            });
+            const results = await Promise.all(queryPromises);
+            const totalDuration = Date.now() - startTime;
+            const successCount = results.filter(r => r.success).length;
+            const failureCount = results.length - successCount;
+            const summary = {
+                total: results.length,
+                successful: successCount,
+                failed: failureCount,
+                totalDuration,
+                averageDuration: results.reduce((sum, r) => sum + r.duration, 0) / results.length
+            };
+            this.logger.log(`Parallel queries completed: ${successCount} success, ${failureCount} failed, ${totalDuration}ms total`);
+            const enhancedResults = results;
+            const formattedResult = this.resultFormatterService.formatParallelResult(enhancedResults, {
+                total: summary.total,
+                success: summary.successful,
+                failed: summary.failed,
+                totalDuration: summary.totalDuration,
+                averageDuration: summary.averageDuration,
+                fastest: Math.min(...results.map(r => r.duration)),
+                slowest: Math.max(...results.map(r => r.duration)),
+                timeSaved: Math.max(0, results.reduce((sum, r) => sum + r.duration, 0) - summary.totalDuration)
+            }, true);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: formattedResult.mcp
+                    }
+                ],
+                success: true,
+                summary: {
+                    totalQueries: summary.total,
+                    successful: summary.successful,
+                    failed: summary.failed,
+                    totalDuration: summary.totalDuration,
+                    averageDuration: summary.averageDuration
+                },
+                results: enhancedResults,
+                performance: {
+                    fastestQuery: Math.min(...results.map(r => r.duration)),
+                    slowestQuery: Math.max(...results.map(r => r.duration)),
+                    timeSaved: Math.max(0, results.reduce((sum, r) => sum + r.duration, 0) - summary.totalDuration)
+                },
+                readOnlyMode: true
+            };
+        }
+        catch (error) {
+            const errorMessage = (0, crewx_sdk_1.getErrorMessage)(error);
+            this.logger.error('Parallel agent queries failed:', errorMessage);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ **Parallel Agent Queries Failed**
+
+**Error:** ${errorMessage}
+
+**Total Queries:** ${args.queries?.length || 0}
+
+Read-Only Mode: No files were modified.`
+                    }
+                ],
+                success: false,
+                error: errorMessage,
+                results: [],
+                readOnlyMode: true
+            };
+        }
+    }
+    async executeAgentParallel(args) {
+        try {
+            const { tasks } = args;
+            this.logger.log(`Starting parallel agent execution (${tasks.length} tasks)`);
+            if (!tasks || tasks.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `❌ **No Tasks Provided**
+
+Please provide at least one task in the tasks array.
+
+**Example:**
+\`\`\`json
+{
+  "tasks": [
+    {
+      "task": "Create a utility function for handling timeouts"
+    },
+    {
+      "agentId": "crewx_developer_claude",
+      "task": "Write unit tests for the new utility function"
+    },
+    {
+      "agentId": "crewx_developer_gemini",
+      "task": "Review the implementation for edge cases"
+    }
+  ]
+}
+\`\`\``
+                        }
+                    ],
+                    success: false,
+                    error: 'No tasks provided',
+                    results: []
+                };
+            }
+            tasks.forEach((t, index) => {
+                this.logger.log(`Task ${index + 1}: ${t.agentId} -> "${t.task.substring(0, 50)}..."`);
+            });
+            const startTime = Date.now();
+            const results = await Promise.all(tasks.map(async (taskItem, index) => {
+                const taskStartTime = Date.now();
+                try {
+                    const result = await this.executeAgent({
+                        agentId: taskItem.agentId,
+                        task: taskItem.task,
+                        projectPath: taskItem.projectPath,
+                        context: taskItem.context,
+                    });
+                    const taskDuration = Date.now() - taskStartTime;
+                    return {
+                        index: index + 1,
+                        agentId: taskItem.agentId,
+                        task: taskItem.task,
+                        success: result.success,
+                        implementation: result.implementation || result.error,
+                        provider: result.provider,
+                        duration: taskDuration,
+                        error: result.error,
+                        context: taskItem.context,
+                        workingDirectory: taskItem.projectPath || `Default for ${taskItem.agentId}`,
+                        recommendations: result.recommendations || [],
+                        taskId: result.taskId
+                    };
+                }
+                catch (error) {
+                    const taskDuration = Date.now() - taskStartTime;
+                    return {
+                        index: index + 1,
+                        agentId: taskItem.agentId,
+                        task: taskItem.task,
+                        success: false,
+                        implementation: null,
+                        provider: 'unknown',
+                        duration: taskDuration,
+                        error: error.message || 'Unknown error occurred',
+                        context: taskItem.context,
+                        workingDirectory: taskItem.projectPath || `Default for ${taskItem.agentId}`,
+                        recommendations: [],
+                        taskId: null
+                    };
+                }
+            }));
+            const totalDuration = Date.now() - startTime;
+            const successCount = results.filter(r => r.success).length;
+            const failureCount = results.length - successCount;
+            this.logger.log(`Parallel execution completed: ${successCount} success, ${failureCount} failed, ${totalDuration}ms total`);
+            const responseText = `⚡ **Parallel Agent Execution Results**
+
+**Summary:**
+- Total Tasks: ${results.length}
+- Successful: ${successCount}
+- Failed: ${failureCount}
+- Total Duration: ${totalDuration}ms
+- Average Duration: ${Math.round(totalDuration / results.length)}ms per task
+
+**Individual Results:**
+
+${results.map(result => `---
+**${result.index}. Agent: ${result.agentId}** (${result.provider}) - ${result.duration}ms
+**Task:** ${result.task}
+**Status:** ${result.success ? '✅ Success' : '❌ Failed'}
+**Working Directory:** ${result.workingDirectory}
+${result.context ? `**Context:** ${result.context}\n` : ''}
+**Implementation:**
+${result.success ? result.implementation : `Error: ${result.error}`}
+
+${result.recommendations.length > 0 ? `**Recommendations:**
+${result.recommendations.map((recommendation) => `• ${recommendation}`).join('\n')}` : ''}
+`).join('\n')}
+
+**Performance Insights:**
+- Fastest Task: ${Math.min(...results.map(r => r.duration))}ms
+- Slowest Task: ${Math.max(...results.map(r => r.duration))}ms
+- Parallel processing saved approximately ${Math.max(0, results.reduce((sum, r) => sum + r.duration, 0) - totalDuration)}ms compared to sequential execution
+
+**⚠️ Important Notes:**
+- All tasks were executed in IMPLEMENTATION MODE with potential file modifications
+- Review all provided implementations before applying changes
+- Test in development environment first
+- Consider backing up files before making modifications`;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: responseText
+                    }
+                ],
+                success: true,
+                summary: {
+                    totalTasks: results.length,
+                    successful: successCount,
+                    failed: failureCount,
+                    totalDuration,
+                    averageDuration: Math.round(totalDuration / results.length)
+                },
+                results: results,
+                performance: {
+                    fastestTask: Math.min(...results.map(r => r.duration)),
+                    slowestTask: Math.max(...results.map(r => r.duration)),
+                    timeSaved: Math.max(0, results.reduce((sum, r) => sum + r.duration, 0) - totalDuration)
+                },
+                executionMode: true
+            };
+        }
+        catch (error) {
+            const errorMessage = (0, crewx_sdk_1.getErrorMessage)(error);
+            this.logger.error('Parallel agent execution failed:', errorMessage);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ **Parallel Agent Execution Failed**
+
+**Error:** ${errorMessage}
+
+**Total Tasks:** ${args.tasks?.length || 0}
+
+Execution Mode: Implementation guidance could not be provided.`
+                    }
+                ],
+                success: false,
+                error: errorMessage,
+                results: [],
+                executionMode: true
+            };
+        }
+    }
+    async clearAllLogs() {
+        try {
+            const logsDir = path.join(process.cwd(), '.crewx', 'logs');
+            if (!fs.existsSync(logsDir)) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `📁 **Log Directory Status**
+
+❌ **No logs directory found**
+
+The logs directory \`.crewx/logs\` does not exist. Nothing to clean.
+
+**Path checked:** \`${logsDir}\`
+`
+                        }
+                    ],
+                    success: true,
+                    message: 'No logs directory found',
+                    path: logsDir
+                };
+            }
+            const files = fs.readdirSync(logsDir);
+            const logFiles = files.filter(file => file.endsWith('.log'));
+            if (logFiles.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `📁 **Log Directory Status**
+
+✅ **Already clean**
+
+The logs directory exists but contains no log files to clean.
+
+**Directory:** \`${logsDir}\`
+**Total files:** ${files.length}
+**Log files:** 0
+`
+                        }
+                    ],
+                    success: true,
+                    message: 'No log files to clean',
+                    path: logsDir,
+                    totalFiles: files.length,
+                    logFiles: 0
+                };
+            }
+            let totalSize = 0;
+            let deletedCount = 0;
+            const deletedFiles = [];
+            for (const file of logFiles) {
+                const filePath = path.join(logsDir, file);
+                try {
+                    const stats = fs.statSync(filePath);
+                    totalSize += stats.size;
+                    fs.unlinkSync(filePath);
+                    deletedCount++;
+                    deletedFiles.push(file);
+                }
+                catch (error) {
+                    this.logger.warn(`Failed to delete log file ${file}:`, error);
+                }
+            }
+            const formatSize = (bytes) => {
+                if (bytes === 0)
+                    return '0 B';
+                const k = 1024;
+                const sizes = ['B', 'KB', 'MB', 'GB'];
+                const i = Math.floor(Math.log(bytes) / Math.log(k));
+                return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+            };
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `🗑️ **Log Cleanup Complete**
+
+✅ **Successfully cleared all log files**
+
+**Directory:** \`${logsDir}\`
+**Files deleted:** ${deletedCount}
+**Total space freed:** ${formatSize(totalSize)}
+
+${deletedCount > 10 ?
+                            `**Sample deleted files:**
+${deletedFiles.slice(0, 10).map(f => `  • ${f}`).join('\n')}
+  • ... and ${deletedCount - 10} more files` :
+                            `**Deleted files:**
+${deletedFiles.map(f => `  • ${f}`).join('\n')}`}
+
+The logs directory is now clean and ready for new task logs. 🧹✨
+`
+                    }
+                ],
+                success: true,
+                message: 'All log files cleared successfully',
+                path: logsDir,
+                deletedCount,
+                totalSize,
+                deletedFiles: deletedFiles.slice(0, 20)
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to clear logs:', error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ **Log Cleanup Failed**
+
+**Error:** ${error.message}
+
+Please check permissions and try again, or manually delete files from \`.crewx/logs/\` directory.
+`
+                    }
+                ],
+                success: false,
+                error: error.message
+            };
+        }
+    }
+    async getAvailableProvider(providerConfig) {
+        const defaultFallbackOrder = ['claude', 'gemini', 'copilot'];
+        let fallbackOrder;
+        if (!providerConfig) {
+            fallbackOrder = defaultFallbackOrder;
+        }
+        else if (Array.isArray(providerConfig)) {
+            fallbackOrder = providerConfig;
+        }
+        else {
+            fallbackOrder = [providerConfig, ...defaultFallbackOrder.filter(p => p !== providerConfig)];
+        }
+        for (const providerName of fallbackOrder) {
+            const provider = this.aiProviderService.getProvider(providerName);
+            if (provider) {
+                const isAvailable = await provider.isAvailable();
+                if (isAvailable) {
+                    if (fallbackOrder.indexOf(providerName) > 0) {
+                        this.logger.log(`Using fallback provider: ${providerName} (tried: ${fallbackOrder.slice(0, fallbackOrder.indexOf(providerName)).join(', ')})`);
+                    }
+                    return providerName;
+                }
+            }
+        }
+        this.logger.warn('No providers available, defaulting to claude');
+        return 'claude';
+    }
+};
+exports.CrewXTool = CrewXTool;
+__decorate([
+    (0, nestjs_mcp_adapter_1.McpTool)({
+        server: crewx_sdk_1.SERVER_NAME,
+        name: `${crewx_sdk_1.PREFIX_TOOL_NAME}getTaskLogs`,
+        description: 'Get task logs by task ID to monitor progress and detailed execution logs.',
+        input: {
+            taskId: zod_1.z.string().optional().describe('Task ID to get logs for. If not provided, returns all recent tasks.')
+        },
+        annotations: {
+            title: 'Get Task Logs',
+            readOnlyHint: true,
+            desctructiveHint: false
+        }
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], CrewXTool.prototype, "getTaskLogs", null);
+__decorate([
+    (0, nestjs_mcp_adapter_1.McpTool)({
+        server: crewx_sdk_1.SERVER_NAME,
+        name: `${crewx_sdk_1.PREFIX_TOOL_NAME}checkAIProviders`,
+        description: 'Check the status of available AI CLI tools (Claude, Gemini, GitHub Copilot).',
+        input: {},
+        annotations: {
+            title: 'Check AI Providers Status',
+            readOnlyHint: true,
+            desctructiveHint: false
+        }
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], CrewXTool.prototype, "checkAIProviders", null);
+__decorate([
+    (0, nestjs_mcp_adapter_1.McpTool)({
+        server: crewx_sdk_1.SERVER_NAME,
+        name: `${crewx_sdk_1.PREFIX_TOOL_NAME}listAgents`,
+        description: 'List available specialist AI agents that can be utilized. Each agent is specialized in a specific domain.',
+        input: {},
+        annotations: {
+            title: 'List Available AI Agents',
+            readOnlyHint: true,
+            desctructiveHint: false
+        }
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], CrewXTool.prototype, "listAgents", null);
+__decorate([
+    (0, nestjs_mcp_adapter_1.McpTool)({
+        server: crewx_sdk_1.SERVER_NAME,
+        name: `${crewx_sdk_1.PREFIX_TOOL_NAME}queryAgent`,
+        description: 'Query a specific specialist agent (read-only mode). You can request code analysis, explanations, reviews, etc. No file modifications will be performed.',
+        input: {
+            agentId: zod_1.z.string().describe('Agent ID to query (e.g., frontend_developer, backend_developer, devops_engineer, security_analyst, or custom agents)'),
+            query: zod_1.z.string().describe('Question or request to ask the agent'),
+            projectPath: zod_1.z.string().describe('Absolute path of the project to analyze').optional(),
+            context: zod_1.z.string().describe('Additional context or background information').optional(),
+            model: zod_1.z.string().describe('Model to use for this query (e.g., sonnet, gemini-2.5-pro, gpt-5)').optional(),
+            messages: zod_1.z.array(zod_1.z.object({
+                text: zod_1.z.string(),
+                isAssistant: zod_1.z.boolean(),
+                metadata: zod_1.z.record(zod_1.z.any()).optional(),
+            })).describe('Conversation history to provide as context (oldest → newest)').optional(),
+        },
+        annotations: {
+            title: 'Query Specialist Agent (Read-Only)',
+            readOnlyHint: true,
+            desctructiveHint: false
+        }
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], CrewXTool.prototype, "queryAgent", null);
+__decorate([
+    (0, nestjs_mcp_adapter_1.McpTool)({
+        server: crewx_sdk_1.SERVER_NAME,
+        name: `${crewx_sdk_1.PREFIX_TOOL_NAME}executeAgent`,
+        description: 'Execute tasks through a specialist agent. Can provide implementation guidance, code examples, and actionable solutions.',
+        input: {
+            agentId: zod_1.z.string().describe('Agent ID to execute (e.g., frontend_developer, backend_developer, devops_engineer, security_analyst, or custom agents)'),
+            task: zod_1.z.string().describe('Task or implementation request for the agent to perform'),
+            projectPath: zod_1.z.string().describe('Absolute path of the project to work on').optional(),
+            context: zod_1.z.string().describe('Additional context or background information').optional(),
+            model: zod_1.z.string().describe('Model to use for this execution (e.g., sonnet, gemini-2.5-pro, gpt-5)').optional(),
+            messages: zod_1.z.array(zod_1.z.object({
+                text: zod_1.z.string(),
+                isAssistant: zod_1.z.boolean(),
+                metadata: zod_1.z.record(zod_1.z.any()).optional(),
+            })).describe('Conversation history to provide as context (oldest → newest)').optional(),
+        },
+        annotations: {
+            title: 'Execute Agent Task (Can Modify Files)',
+            readOnlyHint: false,
+            desctructiveHint: true
+        }
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], CrewXTool.prototype, "executeAgent", null);
+__decorate([
+    (0, nestjs_mcp_adapter_1.McpTool)({
+        server: crewx_sdk_1.SERVER_NAME,
+        name: `${crewx_sdk_1.PREFIX_TOOL_NAME}queryAgentParallel`,
+        description: 'Query multiple specialist agents simultaneously in parallel (read-only mode). Efficiently send multiple tasks to the same agent or different questions to various agents.',
+        input: {
+            queries: zod_1.z.array(zod_1.z.object({
+                agentId: zod_1.z.string().describe('Agent ID to query (e.g., frontend_developer, backend_developer, gmail_mcp_developer, etc.)'),
+                query: zod_1.z.string().describe('Question or request to ask the agent'),
+                projectPath: zod_1.z.string().describe('Absolute path of the project to analyze').optional(),
+                context: zod_1.z.string().describe('Additional context or background information').optional(),
+                model: zod_1.z.string().describe('Model to use for this query').optional(),
+                messages: zod_1.z.array(zod_1.z.object({
+                    text: zod_1.z.string(),
+                    isAssistant: zod_1.z.boolean(),
+                    metadata: zod_1.z.record(zod_1.z.any()).optional(),
+                })).describe('Conversation history to provide as context (oldest → newest)').optional(),
+            })).describe('Array of queries to process in parallel'),
+        },
+        annotations: {
+            title: 'Query Multiple Agents in Parallel (Read-Only)',
+            readOnlyHint: true,
+            desctructiveHint: false
+        }
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], CrewXTool.prototype, "queryAgentParallel", null);
+__decorate([
+    (0, nestjs_mcp_adapter_1.McpTool)({
+        server: crewx_sdk_1.SERVER_NAME,
+        name: `${crewx_sdk_1.PREFIX_TOOL_NAME}executeAgentParallel`,
+        description: 'Execute multiple tasks through specialist agents simultaneously in parallel (execution mode). Efficiently distribute implementation work across multiple agents.',
+        input: {
+            tasks: zod_1.z.array(zod_1.z.object({
+                agentId: zod_1.z.string().describe('Agent ID to execute (e.g., frontend_developer, backend_developer, crewx_developer_claude, etc.)'),
+                task: zod_1.z.string().describe('Task or implementation request for the agent to perform'),
+                projectPath: zod_1.z.string().describe('Absolute path of the project to work on').optional(),
+                context: zod_1.z.string().describe('Additional context or background information').optional(),
+                model: zod_1.z.string().describe('Model to use for this execution').optional(),
+                messages: zod_1.z.array(zod_1.z.object({
+                    text: zod_1.z.string(),
+                    isAssistant: zod_1.z.boolean(),
+                    metadata: zod_1.z.record(zod_1.z.any()).optional(),
+                })).describe('Conversation history to provide as context (oldest → newest)').optional(),
+            })).describe('Array of tasks to execute in parallel'),
+        },
+        annotations: {
+            title: 'Execute Multiple Agent Tasks in Parallel (Can Modify Files)',
+            readOnlyHint: false,
+            desctructiveHint: true
+        }
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], CrewXTool.prototype, "executeAgentParallel", null);
+__decorate([
+    (0, nestjs_mcp_adapter_1.McpTool)({
+        server: crewx_sdk_1.SERVER_NAME,
+        name: `${crewx_sdk_1.PREFIX_TOOL_NAME}clearAllLogs`,
+        description: 'Clear all log files from the .crewx/logs directory to clean up accumulated task logs',
+        input: {},
+        annotations: {
+            title: 'Clear All Logs',
+            readOnlyHint: false,
+        }
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], CrewXTool.prototype, "clearAllLogs", null);
+exports.CrewXTool = CrewXTool = CrewXTool_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [ai_service_1.AIService,
+        ai_provider_service_1.AIProviderService,
+        project_service_1.ProjectService,
+        parallel_processing_service_1.ParallelProcessingService,
+        task_management_service_1.TaskManagementService,
+        result_formatter_service_1.ResultFormatterService,
+        template_service_1.TemplateService,
+        document_loader_service_1.DocumentLoaderService,
+        tool_call_service_1.ToolCallService,
+        agent_loader_service_1.AgentLoaderService,
+        remote_agent_service_1.RemoteAgentService])
+], CrewXTool);
+//# sourceMappingURL=crewx.tool.js.map