@gotza02/smartagent 1.2.0

package/dist/index.js

@@ -0,0 +1,1101 @@
+#!/usr/bin/env node
+/**
+ * Swarm MCP Enterprise Server
+ * Enterprise-Grade Multi-Agent Swarm System with Sequential Thinking & Auto-Routing
+ *
+ * @module swarm-mcp-enterprise
+ * @version 1.0.0
+ * @author Enterprise AI Team
+ * @license MIT
+ */
+import { randomUUID } from "crypto";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+// Core modules
+import { database } from "./core/database.js";
+import { agentManager } from "./core/agent-manager.js";
+import { contextManager } from "./core/context-manager.js";
+import { eventEmitter } from "./core/event-emitter.js";
+import { taskScheduler } from "./core/task-scheduler.js";
+import { middlewareManager } from "./core/middleware.js";
+import { metricsManager } from "./core/metrics.js";
+import { pluginManager } from "./core/plugin-system.js";
+import { configManager } from "./config/index.js";
+// Engines
+import { SequentialThinkingEngine } from "./engines/sequential-thinking.js";
+import { AutoRouter } from "./engines/auto-router.js";
+import { parallelEngine } from "./engines/parallel-execution.js";
+// Tools
+import { FileSystemTool } from "./tools/filesystem.js";
+import { TerminalTool } from "./tools/terminal.js";
+// Utils
+import { logger, logRequest, logError } from "./utils/logger.js";
+// ============================================
+// Server Configuration
+// ============================================
+const SERVER_NAME = "swarm-mcp-enterprise";
+const SERVER_VERSION = "1.0.0";
+// Initialize configuration
+configManager.initialize();
+// Get configuration
+const config = configManager.getConfig();
+const DEBUG = process.env.SWARM_DEBUG === "true" || config.logLevel === "debug";
+const LOG_LEVEL = process.env.SWARM_LOG_LEVEL || config.logLevel;
+// ============================================
+// Engine Instances
+// ============================================
+const thinkingEngine = new SequentialThinkingEngine(config.sequentialThinking);
+const autoRouter = new AutoRouter(config.autoRouting);
+// Tool instances (available for future use)
+new FileSystemTool();
+new TerminalTool();
+// Initialize metrics
+metricsManager.registerDefaultMetrics();
+// ============================================
+// MCP Tools Definition
+// ============================================
+const TOOLS = [
+    // Agent Management
+    {
+        name: "spawn_agent",
+        description: "Spawn a new agent in the swarm system",
+        inputSchema: {
+            type: "object",
+            properties: {
+                type: {
+                    type: "string",
+                    enum: ["product_manager", "architect", "engineer", "qa", "reviewer"],
+                    description: "Type of agent to spawn",
+                },
+                name: {
+                    type: "string",
+                    description: "Optional name for the agent",
+                },
+                mode: {
+                    type: "string",
+                    enum: ["plan", "edit", "ralph"],
+                    description: "Operating mode for the agent",
+                },
+                capabilities: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Additional capabilities for the agent",
+                },
+                metadata: {
+                    type: "object",
+                    description: "Additional metadata",
+                },
+            },
+            required: ["type"],
+        },
+    },
+    {
+        name: "spawn_agents_batch",
+        description: "Spawn multiple agents simultaneously (max 10)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                type: {
+                    type: "string",
+                    enum: ["product_manager", "architect", "engineer", "qa", "reviewer"],
+                    description: "Type of agents to spawn",
+                },
+                count: {
+                    type: "number",
+                    minimum: 1,
+                    maximum: 10,
+                    description: "Number of agents to spawn",
+                },
+                baseName: {
+                    type: "string",
+                    description: "Base name for agents (will be suffixed with _1, _2, etc.)",
+                },
+                mode: {
+                    type: "string",
+                    enum: ["plan", "edit", "ralph"],
+                    description: "Operating mode for all agents",
+                },
+                metadata: {
+                    type: "object",
+                    description: "Metadata to apply to all agents",
+                },
+            },
+            required: ["type", "count"],
+        },
+    },
+    {
+        name: "get_agent",
+        description: "Get agent details by ID",
+        inputSchema: {
+            type: "object",
+            properties: {
+                agentId: {
+                    type: "string",
+                    description: "ID of the agent",
+                },
+            },
+            required: ["agentId"],
+        },
+    },
+    {
+        name: "list_agents",
+        description: "List all agents with optional filtering",
+        inputSchema: {
+            type: "object",
+            properties: {
+                type: {
+                    type: "string",
+                    enum: ["product_manager", "architect", "engineer", "qa", "reviewer"],
+                    description: "Filter by agent type",
+                },
+                status: {
+                    type: "string",
+                    enum: ["idle", "busy", "completed", "error", "terminated"],
+                    description: "Filter by agent status",
+                },
+            },
+        },
+    },
+    {
+        name: "terminate_agent",
+        description: "Terminate an agent",
+        inputSchema: {
+            type: "object",
+            properties: {
+                agentId: {
+                    type: "string",
+                    description: "ID of the agent to terminate",
+                },
+            },
+            required: ["agentId"],
+        },
+    },
+    {
+        name: "send_agent_message",
+        description: "Send a message from one agent to another",
+        inputSchema: {
+            type: "object",
+            properties: {
+                fromAgentId: {
+                    type: "string",
+                    description: "ID of the sender agent",
+                },
+                toAgentId: {
+                    type: "string",
+                    description: "ID of the recipient agent",
+                },
+                messageType: {
+                    type: "string",
+                    description: "Type of message",
+                },
+                content: {
+                    type: "object",
+                    description: "Message content",
+                },
+            },
+            required: ["fromAgentId", "toAgentId", "messageType", "content"],
+        },
+    },
+    {
+        name: "get_agent_messages",
+        description: "Get messages for an agent",
+        inputSchema: {
+            type: "object",
+            properties: {
+                agentId: {
+                    type: "string",
+                    description: "ID of the agent",
+                },
+                limit: {
+                    type: "number",
+                    description: "Maximum number of messages to return",
+                },
+            },
+            required: ["agentId"],
+        },
+    },
+    // Task Management
+    {
+        name: "assign_task",
+        description: "Assign a task to an agent",
+        inputSchema: {
+            type: "object",
+            properties: {
+                agentId: {
+                    type: "string",
+                    description: "ID of the agent",
+                },
+                type: {
+                    type: "string",
+                    description: "Type of task",
+                },
+                description: {
+                    type: "string",
+                    description: "Task description",
+                },
+                context: {
+                    type: "object",
+                    description: "Task context data",
+                },
+                priority: {
+                    type: "number",
+                    minimum: 1,
+                    maximum: 10,
+                    description: "Task priority (1-10)",
+                },
+                timeout: {
+                    type: "number",
+                    description: "Task timeout in seconds",
+                },
+                dependencies: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "IDs of tasks that must complete before this task",
+                },
+            },
+            required: ["agentId", "type", "description"],
+        },
+    },
+    {
+        name: "get_task",
+        description: "Get task details by ID",
+        inputSchema: {
+            type: "object",
+            properties: {
+                taskId: {
+                    type: "string",
+                    description: "ID of the task",
+                },
+            },
+            required: ["taskId"],
+        },
+    },
+    {
+        name: "complete_task",
+        description: "Mark a task as completed",
+        inputSchema: {
+            type: "object",
+            properties: {
+                taskId: {
+                    type: "string",
+                    description: "ID of the task",
+                },
+                result: {
+                    type: "object",
+                    description: "Task result data",
+                },
+            },
+            required: ["taskId"],
+        },
+    },
+    {
+        name: "fail_task",
+        description: "Mark a task as failed",
+        inputSchema: {
+            type: "object",
+            properties: {
+                taskId: {
+                    type: "string",
+                    description: "ID of the task",
+                },
+                error: {
+                    type: "string",
+                    description: "Error message",
+                },
+            },
+            required: ["taskId", "error"],
+        },
+    },
+    {
+        name: "cancel_task",
+        description: "Cancel a task",
+        inputSchema: {
+            type: "object",
+            properties: {
+                taskId: {
+                    type: "string",
+                    description: "ID of the task",
+                },
+            },
+            required: ["taskId"],
+        },
+    },
+    {
+        name: "list_tasks",
+        description: "List all tasks with optional filtering",
+        inputSchema: {
+            type: "object",
+            properties: {
+                agentId: {
+                    type: "string",
+                    description: "Filter by agent ID",
+                },
+                status: {
+                    type: "string",
+                    enum: ["pending", "in_progress", "completed", "failed", "cancelled"],
+                    description: "Filter by task status",
+                },
+            },
+        },
+    },
+    // Sequential Thinking
+    {
+        name: "thinking_create_chain",
+        description: "Create a new thought chain for sequential thinking",
+        inputSchema: {
+            type: "object",
+            properties: {
+                agentId: {
+                    type: "string",
+                    description: "ID of the agent",
+                },
+                taskId: {
+                    type: "string",
+                    description: "ID of the associated task",
+                },
+                title: {
+                    type: "string",
+                    description: "Title for the thought chain",
+                },
+            },
+            required: ["agentId", "taskId", "title"],
+        },
+    },
+    {
+        name: "thinking_add_thought",
+        description: "Add a thought to a chain",
+        inputSchema: {
+            type: "object",
+            properties: {
+                chainId: {
+                    type: "string",
+                    description: "ID of the thought chain",
+                },
+                content: {
+                    type: "string",
+                    description: "Thought content",
+                },
+                reasoning: {
+                    type: "string",
+                    description: "Reasoning behind this thought",
+                },
+                confidence: {
+                    type: "number",
+                    minimum: 0,
+                    maximum: 1,
+                    description: "Confidence score (0-1)",
+                },
+                branchFrom: {
+                    type: "string",
+                    description: "Parent thought ID for branching",
+                },
+                revisionOf: {
+                    type: "string",
+                    description: "Thought ID being revised",
+                },
+            },
+            required: ["chainId", "content", "reasoning", "confidence"],
+        },
+    },
+    {
+        name: "thinking_get_chain",
+        description: "Get a thought chain by ID",
+        inputSchema: {
+            type: "object",
+            properties: {
+                chainId: {
+                    type: "string",
+                    description: "ID of the thought chain",
+                },
+            },
+            required: ["chainId"],
+        },
+    },
+    {
+        name: "thinking_export",
+        description: "Export thought chain as JSON or Markdown",
+        inputSchema: {
+            type: "object",
+            properties: {
+                chainId: {
+                    type: "string",
+                    description: "ID of the thought chain",
+                },
+                format: {
+                    type: "string",
+                    enum: ["json", "markdown"],
+                    description: "Export format",
+                },
+            },
+            required: ["chainId", "format"],
+        },
+    },
+    // Auto-Routing
+    {
+        name: "routing_classify_intent",
+        description: "Classify intent from input text",
+        inputSchema: {
+            type: "object",
+            properties: {
+                input: {
+                    type: "string",
+                    description: "Input text to classify",
+                },
+            },
+            required: ["input"],
+        },
+    },
+    {
+        name: "routing_route",
+        description: "Route a request to the appropriate agent",
+        inputSchema: {
+            type: "object",
+            properties: {
+                input: {
+                    type: "string",
+                    description: "Input to route",
+                },
+                preferredAgent: {
+                    type: "string",
+                    enum: ["product_manager", "architect", "engineer", "qa", "reviewer"],
+                    description: "Preferred agent type",
+                },
+            },
+            required: ["input"],
+        },
+    },
+    // Parallel Execution
+    {
+        name: "parallel_execute",
+        description: "Execute multiple tasks in parallel",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tasks: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            agentType: {
+                                type: "string",
+                                enum: ["product_manager", "architect", "engineer", "qa", "reviewer"],
+                            },
+                            type: { type: "string" },
+                            description: { type: "string" },
+                            context: { type: "object" },
+                            priority: { type: "number" },
+                        },
+                        required: ["agentType", "type", "description"],
+                    },
+                    description: "Tasks to execute in parallel",
+                },
+                maxConcurrency: {
+                    type: "number",
+                    minimum: 1,
+                    maximum: 5,
+                    description: "Maximum concurrent tasks",
+                },
+                aggregationStrategy: {
+                    type: "string",
+                    enum: ["all", "first", "majority", "custom"],
+                    description: "Result aggregation strategy",
+                },
+            },
+            required: ["tasks"],
+        },
+    },
+    {
+        name: "parallel_get_execution",
+        description: "Get parallel execution details",
+        inputSchema: {
+            type: "object",
+            properties: {
+                executionId: {
+                    type: "string",
+                    description: "ID of the execution",
+                },
+            },
+            required: ["executionId"],
+        },
+    },
+    // Context & Handoff
+    {
+        name: "context_create",
+        description: "Create a new context for an agent",
+        inputSchema: {
+            type: "object",
+            properties: {
+                agentId: {
+                    type: "string",
+                    description: "ID of the agent",
+                },
+                maxTokens: {
+                    type: "number",
+                    description: "Maximum tokens for context",
+                },
+            },
+            required: ["agentId"],
+        },
+    },
+    {
+        name: "context_handoff",
+        description: "Perform handoff between agents",
+        inputSchema: {
+            type: "object",
+            properties: {
+                fromAgentId: {
+                    type: "string",
+                    description: "Source agent ID",
+                },
+                toAgentId: {
+                    type: "string",
+                    description: "Target agent ID",
+                },
+                taskId: {
+                    type: "string",
+                    description: "Associated task ID",
+                },
+                notes: {
+                    type: "string",
+                    description: "Handoff notes",
+                },
+            },
+            required: ["fromAgentId", "toAgentId", "taskId"],
+        },
+    },
+    {
+        name: "context_get_handoff_history",
+        description: "Get handoff history for an agent",
+        inputSchema: {
+            type: "object",
+            properties: {
+                agentId: {
+                    type: "string",
+                    description: "ID of the agent",
+                },
+            },
+            required: ["agentId"],
+        },
+    },
+    // System
+    {
+        name: "system_stats",
+        description: "Get system statistics",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    {
+        name: "system_health",
+        description: "Perform system health check",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    {
+        name: "system_config",
+        description: "Get or update system configuration",
+        inputSchema: {
+            type: "object",
+            properties: {
+                action: {
+                    type: "string",
+                    enum: ["get", "update", "reset"],
+                    description: "Action to perform",
+                },
+                config: {
+                    type: "object",
+                    description: "Configuration updates (for update action)",
+                },
+            },
+            required: ["action"],
+        },
+    },
+    {
+        name: "system_metrics",
+        description: "Get system metrics",
+        inputSchema: {
+            type: "object",
+            properties: {
+                format: {
+                    type: "string",
+                    enum: ["json", "prometheus"],
+                    description: "Output format",
+                },
+            },
+        },
+    },
+    // Plugin Management
+    {
+        name: "plugin_list",
+        description: "List all registered plugins",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    {
+        name: "plugin_register",
+        description: "Register a new plugin",
+        inputSchema: {
+            type: "object",
+            properties: {
+                pluginPath: {
+                    type: "string",
+                    description: "Path to plugin file",
+                },
+            },
+            required: ["pluginPath"],
+        },
+    },
+    {
+        name: "plugin_unregister",
+        description: "Unregister a plugin",
+        inputSchema: {
+            type: "object",
+            properties: {
+                pluginId: {
+                    type: "string",
+                    description: "ID of the plugin to unregister",
+                },
+            },
+            required: ["pluginId"],
+        },
+    },
+];
+// ============================================
+// Tool Handlers
+// ============================================
+async function handleToolCall(name, args) {
+    const requestId = randomUUID();
+    const startTime = Date.now();
+    // Increment request counter
+    metricsManager.increment("swarm_requests_total", 1, { tool: name });
+    try {
+        let result;
+        switch (name) {
+            // Agent Management
+            case "spawn_agent": {
+                const config = args;
+                result = await agentManager.spawnAgent(config);
+                metricsManager.increment("swarm_agents_total");
+                break;
+            }
+            case "spawn_agents_batch": {
+                const { type, count, baseName, mode, metadata } = args;
+                result = await agentManager.spawnMultiple(type, count, {
+                    baseName,
+                    mode,
+                    metadata,
+                });
+                metricsManager.increment("swarm_agents_total", count);
+                break;
+            }
+            case "get_agent": {
+                const { agentId } = args;
+                result = await agentManager.getAgent(agentId);
+                break;
+            }
+            case "list_agents": {
+                const { type, status } = args;
+                if (type) {
+                    result = await agentManager.getAgentsByType(type);
+                }
+                else if (status) {
+                    result = await agentManager.getAgentsByStatus(status);
+                }
+                else {
+                    result = await agentManager.getAllAgents();
+                }
+                break;
+            }
+            case "terminate_agent": {
+                const { agentId } = args;
+                result = { success: await agentManager.terminateAgent(agentId) };
+                break;
+            }
+            case "send_agent_message": {
+                const { fromAgentId, toAgentId, messageType, content } = args;
+                result = {
+                    success: eventEmitter.sendMessage({
+                        fromAgentId,
+                        toAgentId,
+                        type: messageType,
+                        content,
+                    }),
+                };
+                break;
+            }
+            case "get_agent_messages": {
+                const { agentId, limit } = args;
+                result = eventEmitter.getMessages(agentId, { limit });
+                break;
+            }
+            // Task Management
+            case "assign_task": {
+                const { agentId, type, description, context: taskContext, priority, timeout, dependencies } = args;
+                // Use task scheduler if dependencies are specified
+                if (dependencies && dependencies.length > 0) {
+                    result = taskScheduler.scheduleTask(agentId, type, description, {
+                        priority,
+                        dependencies,
+                    });
+                }
+                else {
+                    result = await agentManager.assignTask(agentId, {
+                        type,
+                        description,
+                        context: taskContext,
+                        priority,
+                        timeout,
+                    });
+                }
+                metricsManager.increment("swarm_tasks_created_total");
+                break;
+            }
+            case "get_task": {
+                const { taskId } = args;
+                // Try task scheduler first, then database
+                result = taskScheduler.getTask(taskId) || await database.getTask(taskId);
+                break;
+            }
+            case "complete_task": {
+                const { taskId, result: taskResult } = args;
+                // Try task scheduler first
+                const scheduledTask = taskScheduler.getTask(taskId);
+                if (scheduledTask) {
+                    result = taskScheduler.completeTask(taskId, taskResult);
+                }
+                else {
+                    result = await agentManager.completeTask(taskId, taskResult);
+                }
+                metricsManager.increment("swarm_tasks_completed_total");
+                break;
+            }
+            case "fail_task": {
+                const { taskId, error } = args;
+                // Try task scheduler first
+                const scheduledTask = taskScheduler.getTask(taskId);
+                if (scheduledTask) {
+                    result = taskScheduler.failTask(taskId, error);
+                }
+                else {
+                    result = await agentManager.failTask(taskId, error);
+                }
+                metricsManager.increment("swarm_tasks_failed_total");
+                break;
+            }
+            case "cancel_task": {
+                const { taskId } = args;
+                result = { success: taskScheduler.cancelTask(taskId) };
+                break;
+            }
+            case "list_tasks": {
+                const { agentId, status } = args;
+                if (agentId) {
+                    result = taskScheduler.getTasksByAgent(agentId);
+                }
+                else if (status) {
+                    result = taskScheduler.getTasksByStatus(status);
+                }
+                else {
+                    result = taskScheduler.getAllTasks();
+                }
+                break;
+            }
+            // Sequential Thinking
+            case "thinking_create_chain": {
+                const { agentId, taskId, title } = args;
+                result = await thinkingEngine.createChain(agentId, taskId, title);
+                break;
+            }
+            case "thinking_add_thought": {
+                const { chainId, content, reasoning, confidence, branchFrom, revisionOf } = args;
+                result = await thinkingEngine.addThought(chainId, content, reasoning, confidence, { branchFrom, revisionOf });
+                break;
+            }
+            case "thinking_get_chain": {
+                const { chainId } = args;
+                result = await thinkingEngine.getChain(chainId);
+                break;
+            }
+            case "thinking_export": {
+                const { chainId, format } = args;
+                if (format === "json") {
+                    result = thinkingEngine.exportToJSON(chainId);
+                }
+                else {
+                    result = thinkingEngine.exportToMarkdown(chainId);
+                }
+                break;
+            }
+            // Auto-Routing
+            case "routing_classify_intent": {
+                const { input } = args;
+                result = autoRouter.classifyIntent(input);
+                break;
+            }
+            case "routing_route": {
+                const { input, preferredAgent } = args;
+                result = autoRouter.route(input, { preferredAgent });
+                break;
+            }
+            // Parallel Execution
+            case "parallel_execute": {
+                const { tasks, maxConcurrency, aggregationStrategy } = args;
+                result = await parallelEngine.executeParallel(tasks, {
+                    maxConcurrency,
+                    aggregationStrategy,
+                });
+                break;
+            }
+            case "parallel_get_execution": {
+                const { executionId } = args;
+                result = parallelEngine.getExecution(executionId);
+                break;
+            }
+            // Context & Handoff
+            case "context_create": {
+                const { agentId, maxTokens } = args;
+                result = await contextManager.createContext(agentId, { maxTokens });
+                break;
+            }
+            case "context_handoff": {
+                const { fromAgentId, toAgentId, taskId, notes } = args;
+                result = await contextManager.handoff(fromAgentId, toAgentId, taskId, {
+                    notes,
+                });
+                break;
+            }
+            case "context_get_handoff_history": {
+                const { agentId } = args;
+                result = await contextManager.getHandoffHistory(agentId);
+                break;
+            }
+            // System
+            case "system_stats": {
+                const [agentStats, dbStats, parallelStats] = await Promise.all([
+                    agentManager.getAgentStats(),
+                    database.getSystemStats(),
+                    Promise.resolve(parallelEngine.getStats()),
+                ]);
+                const taskStats = taskScheduler.getStats();
+                result = {
+                    agents: agentStats,
+                    tasks: taskStats,
+                    database: dbStats,
+                    parallel: parallelStats,
+                    plugins: {
+                        count: pluginManager.getPluginCount(),
+                        hooks: pluginManager.getAvailableHooks(),
+                    },
+                    timestamp: new Date().toISOString(),
+                };
+                break;
+            }
+            case "system_health": {
+                const healthCheck = await agentManager.performHealthCheck();
+                const config = configManager.getConfig();
+                result = {
+                    status: "healthy",
+                    healthCheck,
+                    config: {
+                        maxAgents: config.maxAgents,
+                        logLevel: config.logLevel,
+                        healthCheckInterval: config.healthCheckInterval,
+                    },
+                    timestamp: new Date().toISOString(),
+                };
+                break;
+            }
+            case "system_config": {
+                const { action, config: updateConfig } = args;
+                switch (action) {
+                    case "get":
+                        result = configManager.getConfig();
+                        break;
+                    case "update":
+                        if (updateConfig) {
+                            configManager.updateConfig(updateConfig);
+                        }
+                        result = { success: true, config: configManager.getConfig() };
+                        break;
+                    case "reset":
+                        configManager.reset();
+                        result = { success: true, config: configManager.getConfig() };
+                        break;
+                }
+                break;
+            }
+            case "system_metrics": {
+                const { format } = args;
+                if (format === "prometheus") {
+                    result = metricsManager.exportPrometheus();
+                }
+                else {
+                    result = metricsManager.exportJSON();
+                }
+                break;
+            }
+            // Plugin Management
+            case "plugin_list": {
+                result = {
+                    plugins: pluginManager.getAllPlugins().map((p) => ({
+                        id: p.manifest.id,
+                        name: p.manifest.name,
+                        version: p.manifest.version,
+                        description: p.manifest.description,
+                    })),
+                    hooks: pluginManager.getAvailableHooks(),
+                };
+                break;
+            }
+            case "plugin_register": {
+                const { pluginPath } = args;
+                const success = await pluginManager.loadPluginFromFile(pluginPath);
+                result = { success };
+                break;
+            }
+            case "plugin_unregister": {
+                const { pluginId } = args;
+                const success = await pluginManager.unregisterPlugin(pluginId);
+                result = { success };
+                break;
+            }
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+        const duration = Date.now() - startTime;
+        // Record metrics
+        metricsManager.observe("swarm_request_duration_seconds", duration / 1000, { tool: name });
+        logRequest(requestId, name, args, duration, true);
+        return {
+            success: true,
+            data: result,
+            meta: {
+                timestamp: new Date().toISOString(),
+                requestId,
+                duration,
+            },
+        };
+    }
+    catch (error) {
+        const duration = Date.now() - startTime;
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        // Record failed request
+        metricsManager.increment("swarm_requests_failed_total", 1, { tool: name });
+        metricsManager.observe("swarm_request_duration_seconds", duration / 1000, { tool: name });
+        logError(error instanceof Error ? error : new Error(errorMessage), {
+            category: "tool",
+            operation: name,
+        });
+        logRequest(requestId, name, args, duration, false);
+        return {
+            success: false,
+            error: {
+                code: "TOOL_EXECUTION_ERROR",
+                message: errorMessage,
+                details: { tool: name, args },
+            },
+            meta: {
+                timestamp: new Date().toISOString(),
+                requestId,
+                duration,
+            },
+        };
+    }
+}
+// ============================================
+// Main Server
+// ============================================
+async function main() {
+    logger.info(`Starting ${SERVER_NAME} v${SERVER_VERSION}`);
+    logger.info(`Node version: ${process.version}`);
+    logger.info(`Debug mode: ${DEBUG}`);
+    logger.info(`Log level: ${LOG_LEVEL}`);
+    // Initialize database
+    await database.initialize();
+    // Register built-in plugins
+    const loggingPlugin = pluginManager.createBuiltinPlugin("logging", "Logging Plugin", {
+        "request:before": (data) => {
+            logger.debug("Request started", data);
+        },
+        "request:after": (data) => {
+            logger.debug("Request completed", data);
+        },
+    });
+    await pluginManager.registerPlugin(loggingPlugin);
+    // Create MCP Server
+    const server = new Server({
+        name: SERVER_NAME,
+        version: SERVER_VERSION,
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    // Handle list tools
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return { tools: TOOLS };
+    });
+    // Handle tool calls with middleware
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        // Execute through middleware
+        const response = await middlewareManager.execute(name, args, async () => handleToolCall(name, args), { tool: name });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(response, null, 2),
+                },
+            ],
+            isError: !response.success,
+        };
+    });
+    // Start server
+    const transport = new StdioServerTransport();
+    logger.info("Server initialized and ready");
+    logger.info("Waiting for connections...");
+    await server.connect(transport);
+}
+// Run main
+main().catch((error) => {
+    logger.error("Fatal error", {
+        error: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : undefined,
+    });
+    process.exit(1);
+});
+// Graceful shutdown
+process.on("SIGINT", async () => {
+    logger.info("Received SIGINT, shutting down gracefully...");
+    agentManager.stopHealthChecks();
+    await database.close();
+    await pluginManager.reset();
+    process.exit(0);
+});
+process.on("SIGTERM", async () => {
+    logger.info("Received SIGTERM, shutting down gracefully...");
+    agentManager.stopHealthChecks();
+    await database.close();
+    await pluginManager.reset();
+    process.exit(0);
+});
+// Handle uncaught errors
+process.on("uncaughtException", (error) => {
+    logger.error("Uncaught exception", {
+        error: error.message,
+        stack: error.stack,
+    });
+    process.exit(1);
+});
+process.on("unhandledRejection", (reason) => {
+    logger.error("Unhandled rejection", {
+        reason: reason instanceof Error ? reason.message : String(reason),
+    });
+});
+//# sourceMappingURL=index.js.map