0xray 2.0.0

package/dist/mcps/model-health-check.server.js

@@ -0,0 +1,228 @@
+/**
+ * 0xRay Model Health Check MCP Server
+ *
+ * Advanced model compatibility validation and dynamic health assessment
+ */
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { modelRouter } from "../core/model-router.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { frameworkLogger } from "../core/framework-logger.js";
+class StringRayModelHealthCheckServer {
+    server;
+    constructor() {
+        this.server = new Server({
+            name: "model-health-check", version: "1.22.67",
+        }, {
+            capabilities: {
+                tools: {},
+            },
+        });
+        this.setupToolHandlers();
+        frameworkLogger.log("mcps/model-health-check", "initialize", "info");
+    }
+    setupToolHandlers() {
+        // List available tools
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+            return {
+                tools: [
+                    {
+                        name: "model-health-check",
+                        description: "Advanced model compatibility validation and dynamic health assessment",
+                        inputSchema: {
+                            type: "object",
+                            properties: {
+                                models: {
+                                    type: "array",
+                                    items: { type: "string" },
+                                    description: "Specific models to check (optional - checks all configured if empty)",
+                                },
+                                compatibility: {
+                                    type: "boolean",
+                                    default: true,
+                                    description: "Include compatibility matrix in results",
+                                },
+                                performance: {
+                                    type: "boolean",
+                                    default: true,
+                                    description: "Include performance metrics in results",
+                                },
+                            },
+                        },
+                    },
+                ],
+            };
+        });
+        // Handle tool calls
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            switch (name) {
+                case "model-health-check":
+                    return await this.handleModelHealthCheck((args || {}));
+                default:
+                    throw new Error(`Unknown tool: ${name}`);
+            }
+        });
+    }
+    async handleModelHealthCheck(args) {
+        const models = args.models || [modelRouter.getValidatedModel()];
+        const includeCompatibility = args.compatibility !== false;
+        const includePerformance = args.performance !== false;
+        const results = {
+            models: [],
+            compatibilityMatrix: {},
+            performanceMetrics: {},
+            summary: {
+                total: models.length,
+                healthy: 0,
+                issues: 0,
+            },
+        };
+        // Check each model
+        for (const model of models) {
+            try {
+                const modelHealth = await this.checkModelHealth(model);
+                results.models.push(modelHealth);
+                if (modelHealth.healthy) {
+                    results.summary.healthy++;
+                }
+                else {
+                    results.summary.issues++;
+                }
+                if (includePerformance &&
+                    modelHealth.latency !== undefined &&
+                    modelHealth.latency !== null) {
+                    results.performanceMetrics[model] = {
+                        latency: modelHealth.latency,
+                        throughput: "N/A",
+                    };
+                }
+            }
+            catch (error) {
+                results.models.push({
+                    model,
+                    healthy: false,
+                    issues: [
+                        `Health check failed: ${error instanceof Error ? error.message : String(error)}`,
+                    ],
+                    latency: undefined,
+                });
+                results.summary.issues++;
+            }
+        }
+        // Generate compatibility matrix if requested
+        if (includeCompatibility && models.length > 1) {
+            results.compatibilityMatrix = this.generateCompatibilityMatrix(models);
+        }
+        // Generate report
+        const report = this.generateHealthReport(results);
+        return {
+            content: [{ type: "text", text: report }],
+        };
+    }
+    async checkModelHealth(model) {
+        // Simulate model health check - in real implementation, this would test actual model connectivity
+        const issues = [];
+        let latency = Math.random() * 1000 + 500; // Simulate 500-1500ms latency
+        // Basic health checks
+        if (!model || !model.includes("/")) {
+            issues.push("Invalid model format");
+        }
+        // Check model format validity
+        const validPrefixes = ["claude-", "gpt-", "gemini-", "llama-", "mistral-"];
+        if (!validPrefixes.some(p => model.includes(p))) {
+            // Unknown model - may have issues
+            if (Math.random() < 0.1) {
+                issues.push("Model may not be available");
+                latency = undefined;
+            }
+        }
+        return {
+            model,
+            healthy: issues.length === 0,
+            issues,
+            latency,
+            timestamp: new Date().toISOString(),
+        };
+    }
+    generateCompatibilityMatrix(models) {
+        const matrix = {};
+        // Generate mock compatibility data
+        for (const model1 of models) {
+            matrix[model1] = {};
+            for (const model2 of models) {
+                // Models are generally compatible with themselves and similar models
+                matrix[model1][model2] =
+                    model1 === model2 || model1.split("/")[0] === model2.split("/")[0];
+            }
+        }
+        return matrix;
+    }
+    generateHealthReport(results) {
+        let report = "# Model Health Check Report\n\n";
+        // Summary
+        report += "## Summary\n";
+        report += `- Total Models: ${results.summary.total}\n`;
+        report += `- Healthy: ${results.summary.healthy}\n`;
+        report += `- Issues: ${results.summary.issues}\n\n`;
+        // Model Status Details
+        report += "## Model Status Details\n";
+        for (const modelResult of results.models) {
+            report += `**${modelResult.model}:**\n`;
+            report += `- Healthy: ${modelResult.healthy ? "Yes" : "No"}\n`;
+            report += `- Issues: ${modelResult.issues?.join(", ") || "None"}\n`;
+            report += `- Latency: ${modelResult.latency || "N/A"}ms\n\n`;
+        }
+        // Compatibility Matrix
+        if (Object.keys(results.compatibilityMatrix).length > 0) {
+            report += "## Compatibility Matrix\n";
+            const firstModel = Object.keys(results.compatibilityMatrix)[0];
+            if (firstModel && results.compatibilityMatrix[firstModel]) {
+                report +=
+                    "| Model \\\\ Model | " +
+                        Object.keys(results.compatibilityMatrix[firstModel]).join(" | ") +
+                        " |\n";
+                report +=
+                    "|---------------|" +
+                        Object.keys(results.compatibilityMatrix[firstModel])
+                            .map(() => "---|")
+                            .join("") +
+                        "\n";
+                for (const model1 of Object.keys(results.compatibilityMatrix)) {
+                    const row = results.compatibilityMatrix[model1];
+                    if (!row)
+                        continue;
+                    report += `| ${model1} |`;
+                    for (const model2 of Object.keys(row)) {
+                        const compatible = row[model2];
+                        report += ` ${compatible ? "✅" : "❌"} |`;
+                    }
+                    report += "\n";
+                }
+            }
+            report += "\n";
+        }
+        // Performance Metrics
+        if (Object.keys(results.performanceMetrics).length > 0) {
+            report += "## Performance Metrics\n";
+            for (const [model, metrics] of Object.entries(results.performanceMetrics)) {
+                const perfMetrics = metrics;
+                report += `**${model}:**\n`;
+                report += `- Average Latency: ${perfMetrics.latency}ms\n`;
+                report += `- Throughput: ${perfMetrics.throughput}\n\n`;
+            }
+        }
+        return report;
+    }
+    async start() {
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        frameworkLogger.log("mcps/model-health-check", "start", "info");
+    }
+}
+// Start the server if this file is run directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const server = new StringRayModelHealthCheckServer();
+    server.start().catch((error) => frameworkLogger.log("mcps/model-health-check", "run", "error", { error: String(error) }));
+}
+export default StringRayModelHealthCheckServer;

package/dist/mcps/orchestrator/config/agent-capabilities.js

@@ -0,0 +1,87 @@
+/**
+ * Agent Capabilities Configuration
+ *
+ * Centralized agent capability definitions for orchestration decisions
+ */
+import { AGENT_REGISTRY } from "../../../agents/registry.js";
+const DEFAULT_AGENT_CAPABILITIES = Object.fromEntries(Object.entries(AGENT_REGISTRY).map(([name, entry]) => [
+    name,
+    {
+        capabilities: entry.capabilities,
+        complexityThreshold: entry.maxComplexity,
+        concurrentTasks: entry.concurrentTasks,
+    },
+]));
+/**
+ * Agent Capabilities Manager
+ * Manages agent capabilities for orchestration decisions
+ */
+export class AgentCapabilitiesManager {
+    capabilities = new Map();
+    constructor() {
+        // Initialize with default capabilities
+        Object.entries(DEFAULT_AGENT_CAPABILITIES).forEach(([agent, config]) => {
+            this.capabilities.set(agent, config);
+        });
+    }
+    /**
+     * Get capabilities for a specific agent
+     */
+    getCapabilities(agentType) {
+        return this.capabilities.get(agentType);
+    }
+    /**
+     * Get all registered agent capabilities
+     */
+    getAllCapabilities() {
+        return new Map(this.capabilities);
+    }
+    /**
+     * Register or update agent capabilities
+     */
+    setCapabilities(agentType, capability) {
+        this.capabilities.set(agentType, capability);
+    }
+    /**
+     * Select the best agent for a task based on complexity and capabilities
+     */
+    selectAgentForTask(requiredCapabilities, complexity) {
+        let bestAgent = null;
+        let bestScore = -1;
+        for (const [agent, caps] of this.capabilities) {
+            // Check if agent can handle the complexity
+            if (complexity > caps.complexityThreshold) {
+                continue;
+            }
+            // Calculate capability match score
+            const matchCount = requiredCapabilities.filter(cap => caps.capabilities.includes(cap)).length;
+            // Prefer agents with more concurrent tasks available
+            const score = matchCount * 10 + caps.concurrentTasks;
+            if (score > bestScore) {
+                bestScore = score;
+                bestAgent = agent;
+            }
+        }
+        return bestAgent;
+    }
+    /**
+     * Get all available agents for a given complexity level
+     */
+    getAvailableAgents(complexity) {
+        const available = [];
+        for (const [agent, caps] of this.capabilities) {
+            if (complexity <= caps.complexityThreshold) {
+                available.push(agent);
+            }
+        }
+        return available;
+    }
+}
+// Singleton instance
+let capabilitiesManagerInstance = null;
+export function getAgentCapabilitiesManager() {
+    if (!capabilitiesManagerInstance) {
+        capabilitiesManagerInstance = new AgentCapabilitiesManager();
+    }
+    return capabilitiesManagerInstance;
+}

package/dist/mcps/orchestrator/execution/execution-planner.js

@@ -0,0 +1,279 @@
+/**
+ * Execution Planner
+ *
+ * Creates optimized execution plans for orchestration tasks
+ */
+import { getAgentCapabilitiesManager } from '../config/agent-capabilities.js';
+/**
+ * Execution Planner
+ * Plans and optimizes task execution strategies
+ */
+export class ExecutionPlanner {
+    capabilitiesManager = getAgentCapabilitiesManager();
+    /**
+     * Validate a list of tasks
+     */
+    validateTasks(tasks) {
+        const errors = [];
+        if (!tasks || tasks.length === 0) {
+            errors.push('No tasks provided');
+            return { valid: false, errors };
+        }
+        for (let i = 0; i < tasks.length; i++) {
+            const task = tasks[i];
+            if (!task)
+                continue;
+            if (!task.id) {
+                errors.push(`Task ${i}: Missing required field 'id'`);
+            }
+            if (!task.description) {
+                errors.push(`Task ${i}: Missing required field 'description'`);
+            }
+            if (!task.type) {
+                errors.push(`Task ${i}: Missing required field 'type'`);
+            }
+            // Check dependencies exist
+            if (task.dependencies && task.id) {
+                const taskIds = new Set(tasks.map(t => t.id).filter((id) => !!id));
+                for (const depId of task.dependencies) {
+                    if (!taskIds.has(depId)) {
+                        errors.push(`Task ${i}: Dependency '${depId}' does not exist`);
+                    }
+                }
+            }
+        }
+        return { valid: errors.length === 0, errors };
+    }
+    /**
+     * Create an execution plan based on tasks and mode
+     */
+    async createExecutionPlan(tasks, executionMode) {
+        const agentAssignments = new Map();
+        switch (executionMode) {
+            case 'parallel':
+                this.createParallelPlan(tasks, agentAssignments);
+                break;
+            case 'sequential':
+                this.createSequentialPlan(tasks, agentAssignments);
+                break;
+            case 'optimized':
+            default:
+                await this.createOptimizedPlan(tasks, agentAssignments);
+                break;
+        }
+        const estimatedDuration = this.estimateExecutionDuration(agentAssignments);
+        return {
+            tasks,
+            strategy: executionMode,
+            agentAssignments,
+            estimatedDuration,
+        };
+    }
+    /**
+     * Create a parallel execution plan
+     */
+    createParallelPlan(tasks, agentAssignments) {
+        // Assign each task to an available agent
+        const agents = this.capabilitiesManager.getAllCapabilities();
+        let agentIndex = 0;
+        const agentList = Array.from(agents.keys()).filter((a) => !!a);
+        if (agentList.length === 0)
+            return;
+        for (const task of tasks) {
+            const agent = agentList[agentIndex % agentList.length];
+            if (!agent)
+                continue;
+            if (!agentAssignments.has(agent)) {
+                agentAssignments.set(agent, []);
+            }
+            agentAssignments.get(agent).push(task);
+            agentIndex++;
+        }
+    }
+    /**
+     * Create a sequential execution plan
+     */
+    createSequentialPlan(tasks, agentAssignments) {
+        // Use orchestrator agent for sequential execution
+        agentAssignments.set('orchestrator', [...tasks]);
+    }
+    /**
+     * Create an optimized execution plan considering dependencies and complexity
+     */
+    async createOptimizedPlan(tasks, agentAssignments) {
+        // Sort tasks by dependencies first
+        const sortedTasks = this.sortByDependencies(tasks);
+        // Group independent tasks for parallel execution
+        const independentTasks = [];
+        const dependentTasks = [];
+        for (const task of sortedTasks) {
+            if (!task.dependencies || task.dependencies.length === 0) {
+                independentTasks.push(task);
+            }
+            else {
+                dependentTasks.push(task);
+            }
+        }
+        // Assign independent tasks in parallel
+        this.assignTasksToAgents(independentTasks, agentAssignments);
+        // Assign dependent tasks (these will run after dependencies complete)
+        this.assignTasksToAgents(dependentTasks, agentAssignments);
+    }
+    /**
+     * Sort tasks by their dependencies
+     */
+    sortByDependencies(tasks) {
+        const taskMap = new Map(tasks.map(t => [t.id, t]));
+        const sorted = [];
+        const visited = new Set();
+        const visit = (task) => {
+            if (visited.has(task.id))
+                return;
+            visited.add(task.id);
+            if (task.dependencies) {
+                for (const depId of task.dependencies) {
+                    const depTask = taskMap.get(depId);
+                    if (depTask)
+                        visit(depTask);
+                }
+            }
+            sorted.push(task);
+        };
+        for (const task of tasks) {
+            visit(task);
+        }
+        return sorted;
+    }
+    /**
+     * Assign tasks to agents based on capability
+     */
+    assignTasksToAgents(tasks, agentAssignments) {
+        for (const task of tasks) {
+            const complexity = task.estimatedComplexity || 30;
+            const agent = this.capabilitiesManager.selectAgentForTask([task.type], complexity) || 'orchestrator';
+            if (!agentAssignments.has(agent)) {
+                agentAssignments.set(agent, []);
+            }
+            agentAssignments.get(agent).push(task);
+        }
+    }
+    /**
+     * Estimate execution duration based on agent assignments
+     */
+    estimateExecutionDuration(agentAssignments) {
+        let maxDuration = 0;
+        for (const [agent, tasks] of agentAssignments) {
+            const caps = this.capabilitiesManager.getCapabilities(agent);
+            if (!caps)
+                continue;
+            // Estimate time based on concurrent capacity
+            const batches = Math.ceil(tasks.length / caps.concurrentTasks);
+            const taskDuration = tasks.reduce((sum, t) => sum + (t.estimatedComplexity || 30) * 10, 0);
+            const agentDuration = batches * (taskDuration / tasks.length);
+            maxDuration = Math.max(maxDuration, agentDuration);
+        }
+        return Math.round(maxDuration);
+    }
+    /**
+     * Analyze task complexity
+     */
+    async analyzeTaskComplexity(tasks) {
+        const taskComplexity = [];
+        const agentAssignments = [];
+        const assignments = new Map();
+        for (const task of tasks) {
+            const complexity = this.calculateTaskComplexity(task);
+            taskComplexity.push({
+                complexity,
+                category: task.type,
+            });
+            // Assign to agent
+            const agent = this.capabilitiesManager.selectAgentForTask([task.type], complexity) || 'orchestrator';
+            if (!assignments.has(agent)) {
+                assignments.set(agent, []);
+            }
+            assignments.get(agent).push(task);
+        }
+        // Calculate agent utilization
+        for (const [agent, assignedTasks] of assignments) {
+            const caps = this.capabilitiesManager.getCapabilities(agent);
+            const utilization = caps
+                ? Math.round((assignedTasks.length / caps.concurrentTasks) * 100)
+                : 100;
+            agentAssignments.push({
+                agent,
+                taskCount: assignedTasks.length,
+                utilization: Math.min(utilization, 100),
+            });
+        }
+        const overallComplexity = taskComplexity.length > 0
+            ? Math.round(taskComplexity.reduce((sum, t) => sum + t.complexity, 0) / taskComplexity.length)
+            : 0;
+        const recommendedStrategy = this.recommendStrategy(overallComplexity, tasks.length);
+        const estimatedDuration = this.estimateExecutionDuration(assignments);
+        const parallelPotential = this.calculateParallelPotential(tasks);
+        return {
+            overallComplexity,
+            recommendedStrategy,
+            taskComplexity,
+            agentAssignments,
+            estimatedDuration,
+            parallelPotential,
+        };
+    }
+    /**
+     * Calculate complexity for a single task
+     */
+    calculateTaskComplexity(task) {
+        let complexity = 30; // Base complexity
+        // Adjust based on priority
+        switch (task.priority) {
+            case 'critical':
+                complexity += 20;
+                break;
+            case 'high':
+                complexity += 10;
+                break;
+            case 'low':
+                complexity -= 5;
+                break;
+        }
+        // Adjust based on estimated complexity
+        if (task.estimatedComplexity) {
+            complexity = (complexity + task.estimatedComplexity) / 2;
+        }
+        // Adjust based on dependencies
+        if (task.dependencies) {
+            complexity += task.dependencies.length * 5;
+        }
+        return Math.min(Math.max(Math.round(complexity), 1), 100);
+    }
+    /**
+     * Recommend execution strategy based on complexity and task count
+     */
+    recommendStrategy(overallComplexity, taskCount) {
+        if (taskCount <= 1)
+            return 'sequential';
+        if (overallComplexity > 70)
+            return 'sequential';
+        if (overallComplexity < 30 && taskCount > 3)
+            return 'parallel';
+        return 'optimized';
+    }
+    /**
+     * Calculate parallel execution potential
+     */
+    calculateParallelPotential(tasks) {
+        // Tasks without dependencies can run in parallel
+        const independent = tasks.filter(t => !t.dependencies || t.dependencies.length === 0);
+        return independent.length / tasks.length;
+    }
+}
+// Singleton
+let executionPlannerInstance = null;
+export function getExecutionPlanner() {
+    if (!executionPlannerInstance) {
+        executionPlannerInstance = new ExecutionPlanner();
+    }
+    return executionPlannerInstance;
+}

package/dist/mcps/orchestrator/handlers/complexity-handler.js

@@ -0,0 +1,94 @@
+/**
+ * Complexity Handler
+ *
+ * Handles complexity analysis requests
+ */
+import { frameworkLogger } from '../../../core/framework-logger.js';
+import { getExecutionPlanner } from '../execution/execution-planner.js';
+/**
+ * Complexity Handler
+ * Processes analyze-complexity requests
+ */
+export class ComplexityHandler {
+    planner = getExecutionPlanner();
+    /**
+     * Handle analyze-complexity request
+     */
+    async handleAnalyzeComplexity(args) {
+        const { tasks = [] } = args;
+        await frameworkLogger.log('orchestrator.server', 'analyze-complexity-start', 'info', { taskCount: tasks.length });
+        try {
+            const analysis = await this.planner.analyzeTaskComplexity(tasks);
+            const recommendations = this.generateRecommendations(analysis);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: this.formatComplexityResponse(analysis, recommendations, tasks.length),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ Complexity analysis failed: ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+            };
+        }
+    }
+    /**
+     * Generate recommendations based on complexity analysis
+     */
+    generateRecommendations(analysis) {
+        const recommendations = [];
+        if (analysis.overallComplexity > 70) {
+            recommendations.push('Consider breaking down complex tasks into smaller subtasks');
+            recommendations.push('Use sequential execution mode for high-complexity workflows');
+        }
+        if (analysis.parallelPotential > 0.7) {
+            recommendations.push('High parallel potential - consider parallel execution mode');
+        }
+        if (analysis.parallelPotential < 0.3) {
+            recommendations.push('Many dependencies - sequential or optimized mode recommended');
+        }
+        for (const assignment of analysis.agentAssignments) {
+            if (assignment.utilization > 80) {
+                recommendations.push(`${assignment.agent} is at ${assignment.utilization}% utilization - consider adding more agents`);
+            }
+        }
+        if (recommendations.length === 0) {
+            recommendations.push('Task distribution looks optimal');
+        }
+        return recommendations;
+    }
+    /**
+     * Format complexity response
+     */
+    formatComplexityResponse(analysis, recommendations, taskCount) {
+        return `🔍 Complexity Analysis Results
+
+**Tasks Analyzed:** ${taskCount}
+**Overall Complexity:** ${analysis.overallComplexity}/100
+**Recommended Strategy:** ${analysis.recommendedStrategy}
+
+**Complexity Breakdown:**
+${analysis.taskComplexity
+            .map((task, index) => `• Task ${index + 1}: ${task.complexity}/100 (${task.category})`)
+            .join('\n')}
+
+**Agent Assignments:**
+${analysis.agentAssignments
+            .map((assignment) => `• ${assignment.agent}: ${assignment.taskCount} tasks (${assignment.utilization}%)`)
+            .join('\n')}
+
+**Recommendations:**
+${recommendations.map((r) => `• 💡 ${r}`).join('\n')}
+
+**Execution Estimate:** ${analysis.estimatedDuration}ms
+**Parallel Potential:** ${Math.round(analysis.parallelPotential * 100)}%`;
+    }
+}