0xray 3.4.1 → 3.4.3

package/dist/mcps/mcp-client.d.ts

@@ -0,0 +1,157 @@
+/**
+ * MCP Client Layer
+ *
+ * Enables framework components to call MCP servers programmatically.
+ * Refactored as a lean facade using extracted modules (Phases 1-5).
+ *
+ * Architecture:
+ * - ToolRegistry: Manages tool registration and lookup
+ * - ToolDiscovery: Discovers tools from MCP servers
+ * - ToolExecutor: Executes tools via JSON-RPC
+ * - ToolCache: Caches discovered tools
+ * - SimulationEngine: Provides fallback simulations
+ */
+import { EventEmitter } from 'events';
+import { MCPClientConfig, MCPTool, MCPToolResult } from './types/index.js';
+interface RetryConfig {
+    maxRetries: number;
+    initialDelayMs: number;
+    maxDelayMs: number;
+    backoffMultiplier: number;
+}
+/**
+ * Tool event types for hooks
+ */
+export interface ToolBeforeEvent {
+    toolName: string;
+    serverName: string;
+    args: unknown;
+    timestamp: number;
+}
+export interface ToolAfterEvent extends ToolBeforeEvent {
+    result?: MCPToolResult;
+    error?: string;
+    duration: number;
+    success: boolean;
+}
+/**
+ * MCP Client
+ *
+ * Facade that orchestrates tool discovery, caching, execution, and simulation.
+ */
+export declare class MCPClient extends EventEmitter {
+    private config;
+    private toolRegistry;
+    private toolDiscovery;
+    private toolExecutor;
+    private toolCache;
+    private simulationEngine;
+    private retryConfig;
+    constructor(config: MCPClientConfig, retryConfig?: Partial<RetryConfig>);
+    /**
+     * Execute with exponential backoff retry
+     */
+    private executeWithRetry;
+    /**
+     * Execute a tool using the real MCP transport (ConnectionPool + ToolExecutor).
+     * This is the primary production path.
+     */
+    private executeRealTool;
+    /**
+     * Pure MCP mode — simulation and generic fallbacks are disabled.
+     */
+    private get isPureMcpMode();
+    /**
+     * Register default simulation implementations
+     */
+    private registerDefaultSimulations;
+    /**
+     * Initialize MCP client by discovering and caching tools
+     */
+    initialize(): Promise<void>;
+    /**
+     * Discover available tools for this server
+     */
+    private discoverTools;
+    /**
+     * Get static tool definitions for a server
+     */
+    private getStaticTools;
+    /**
+     * Call a specific MCP server tool
+     */
+    callTool(toolName: string, args?: unknown): Promise<MCPToolResult>;
+    /**
+     * Get list of available tools
+     */
+    getAvailableTools(): MCPTool[];
+    /**
+     * Check if a tool is available
+     */
+    hasTool(toolName: string): boolean;
+    /**
+     * Get tool by name
+     */
+    getTool(toolName: string): MCPTool | undefined;
+    /**
+     * Subscribe to tool.before events
+     */
+    onToolBefore(callback: (event: ToolBeforeEvent) => void): void;
+    /**
+     * Subscribe to tool.after events
+     */
+    onToolAfter(callback: (event: ToolAfterEvent) => void): void;
+    /**
+     * Unsubscribe from tool.before events
+     */
+    offToolBefore(callback: (event: ToolBeforeEvent) => void): void;
+    /**
+     * Unsubscribe from tool.after events
+     */
+    offToolAfter(callback: (event: ToolAfterEvent) => void): void;
+}
+/**
+ * MCP Client Manager
+ *
+ * Manages MCP client instances and provides unified interface
+ * for framework components to access MCP server capabilities.
+ */
+export declare class MCPClientManager {
+    private static instance;
+    private clients;
+    private constructor();
+    static getInstance(): MCPClientManager;
+    /**
+     * Get or create MCP client for a server
+     */
+    getClient(serverName: string): Promise<MCPClient>;
+    /**
+     * Get the event emitter for a specific client
+     * Use this to subscribe to tool.before/tool.after events
+     */
+    getClientEventEmitter(serverName: string): MCPClient | null;
+    /**
+     * Subscribe to tool events across all clients
+     * Note: This creates a subscription for each client - manage subscriptions carefully
+     * @returns Unsubscribe function to call to remove all event listeners
+     */
+    onToolEvent(eventType: 'tool.before' | 'tool.after', callback: (event: ToolBeforeEvent | ToolAfterEvent) => void): Promise<() => void>;
+    /**
+     * Create client configuration for a server
+     */
+    createClientConfig(serverName: string): MCPClientConfig;
+    /**
+     * Call MCP server tool
+     */
+    callServerTool(serverName: string, toolName: string, args?: unknown): Promise<MCPToolResult>;
+    /**
+     * Get all available MCP server tools
+     */
+    getAllAvailableTools(): Promise<Record<string, MCPTool[]>>;
+    /**
+     * Clear all cached clients
+     */
+    clearClients(): void;
+}
+export declare const mcpClientManager: MCPClientManager;
+export {};

package/dist/mcps/model-health-check.server.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 0xRay Model Health Check MCP Server
+ *
+ * Advanced model compatibility validation and dynamic health assessment
+ */
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+declare class XrayModelHealthCheckServer extends XrayKnowledgeSkillBase {
+    constructor();
+    private handleModelHealthCheck;
+    private checkModelHealth;
+    private generateCompatibilityMatrix;
+    private generateHealthReport;
+}
+export default XrayModelHealthCheckServer;

package/dist/mcps/orchestrator/aside-context.d.ts

@@ -0,0 +1,21 @@
+/**
+ * AsideContext — bounded subcontext for depth, continuity, and layered exploration
+ *
+ * Enables the orchestrator to spawn sub-investigations that inherit session context,
+ * accumulate structured observations from v3 subsystems (governance, orchestration,
+ * complexity analysis), and feed results back into the governance loop.
+ */
+import type { AsideContextOptions, AsideObservation, AsideResult, ActiveAside } from "./types.js";
+import type { InferenceCycleResult } from "../../inference/inference-cycle.js";
+import type { OrchestrationResult, ComplexityAnalysis } from "./types.js";
+export declare function getActiveAsideCount(): number;
+export declare function getActiveAsideIds(): string[];
+export declare function getAsideState(asideId: string): ActiveAside | undefined;
+export declare function addObservations(asideId: string, observations: AsideObservation[]): boolean;
+export declare function extractGovernanceObservations(result: InferenceCycleResult): AsideObservation[];
+export declare function extractOrchestrationObservations(result: OrchestrationResult): AsideObservation[];
+export declare function extractComplexityObservations(analysis: ComplexityAnalysis): AsideObservation[];
+export declare function spawnAside(options: AsideContextOptions): Promise<AsideResult>;
+export declare function closeAside(asideId: string): boolean;
+export declare function closeAllAsides(): number;
+export declare function resetAsideContext(): void;

package/dist/mcps/orchestrator/config/agent-capabilities.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Agent Capabilities Configuration
+ *
+ * Centralized agent capability definitions for orchestration decisions.
+ * Enriched at runtime by the active MemoryRoutingProvider (Repertoire, etc.).
+ */
+import type { AgentCapability } from '../types.js';
+/**
+ * Agent Capabilities Manager
+ * Manages agent capabilities for orchestration decisions
+ */
+export declare class AgentCapabilitiesManager {
+    private capabilities;
+    private enriched;
+    constructor();
+    private applyMemoryRoutingEnrichment;
+    /**
+     * Get capabilities for a specific agent
+     */
+    getCapabilities(agentType: string): AgentCapability | undefined;
+    /**
+     * Get all registered agent capabilities
+     */
+    getAllCapabilities(): Map<string, AgentCapability>;
+    /**
+     * Register or update agent capabilities
+     */
+    setCapabilities(agentType: string, capability: AgentCapability): void;
+    /**
+     * Select the best agent for a task based on complexity, capabilities, and memory routing.
+     */
+    selectAgentForTask(requiredCapabilities: string[], complexity: number, operationDescription?: string): string | null;
+    /**
+     * Get all available agents for a given complexity level
+     */
+    getAvailableAgents(complexity: number): string[];
+}
+export declare function getAgentCapabilitiesManager(): AgentCapabilitiesManager;
+export declare function resetAgentCapabilitiesManager(): void;

package/dist/mcps/orchestrator/config/memory-routing-bridge.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Bridge between orchestrator types and the pluggable MemoryRoutingProvider.
+ */
+import { type MemoryAgentCapability, type MemoryOrchestrationTask, type MemoryRoutingProvider } from '../../../memory-routing/index.js';
+import type { AgentCapability, OrchestrationTask } from '../types.js';
+export declare function toMemoryCapability(caps: AgentCapability): MemoryAgentCapability;
+export declare function fromMemoryCapability(caps: MemoryAgentCapability): AgentCapability;
+export declare function toMemoryTask(task: OrchestrationTask): MemoryOrchestrationTask;
+export declare function fromMemoryTask(task: MemoryOrchestrationTask): OrchestrationTask;
+export declare function toMemoryCapabilityMap(caps: Map<string, AgentCapability>): Map<string, MemoryAgentCapability>;
+export declare function fromMemoryCapabilityMap(caps: Map<string, MemoryAgentCapability>): Map<string, AgentCapability>;
+export declare function getProvider(): MemoryRoutingProvider;

package/dist/mcps/orchestrator/execution/execution-planner.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Execution Planner
+ *
+ * Creates optimized execution plans for orchestration tasks
+ */
+import type { OrchestrationTask, ExecutionPlan, ComplexityAnalysis, TaskValidation } from '../types.js';
+/**
+ * Execution Planner
+ * Plans and optimizes task execution strategies
+ */
+export declare class ExecutionPlanner {
+    private capabilitiesManager;
+    /**
+     * Validate a list of tasks
+     */
+    validateTasks(tasks: OrchestrationTask[]): TaskValidation;
+    /**
+     * Create an execution plan based on tasks and mode
+     */
+    createExecutionPlan(tasks: OrchestrationTask[], executionMode: string): Promise<ExecutionPlan>;
+    /**
+     * Create a parallel execution plan
+     */
+    private createParallelPlan;
+    /**
+     * Create a sequential execution plan
+     */
+    private createSequentialPlan;
+    /**
+     * Create an optimized execution plan considering dependencies and complexity
+     */
+    private createOptimizedPlan;
+    /**
+     * Sort tasks by their dependencies
+     */
+    private sortByDependencies;
+    /**
+     * Assign tasks to agents based on capability
+     */
+    private assignTasksToAgents;
+    /**
+     * Estimate execution duration based on agent assignments
+     */
+    estimateExecutionDuration(agentAssignments: Map<string, OrchestrationTask[]>): number;
+    /**
+     * Analyze task complexity
+     */
+    analyzeTaskComplexity(tasks: OrchestrationTask[]): Promise<ComplexityAnalysis>;
+    /**
+     * Calculate complexity for a single task
+     */
+    calculateTaskComplexity(task: OrchestrationTask): number;
+    /**
+     * Recommend execution strategy based on complexity and task count
+     */
+    private recommendStrategy;
+    /**
+     * Calculate parallel execution potential
+     */
+    private calculateParallelPotential;
+}
+export declare function getExecutionPlanner(): ExecutionPlanner;

package/dist/mcps/orchestrator/handlers/complexity-handler.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Complexity Handler
+ *
+ * Handles complexity analysis requests
+ */
+import type { OrchestrationTask } from '../types.js';
+/**
+ * Complexity Handler
+ * Processes analyze-complexity requests
+ */
+export declare class ComplexityHandler {
+    private planner;
+    /**
+     * Handle analyze-complexity request
+     */
+    handleAnalyzeComplexity(args: {
+        tasks: OrchestrationTask[];
+    }, asideId?: string): Promise<{
+        content: Array<{
+            type: string;
+            text: string;
+        }>;
+    }>;
+    /**
+     * Generate recommendations based on complexity analysis
+     */
+    private generateRecommendations;
+    /**
+     * Format complexity response
+     */
+    private formatComplexityResponse;
+}

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

@@ -4,6 +4,7 @@
  * Handles complexity analysis requests
  */
 import { frameworkLogger } from '../../../core/framework-logger.js';
+import { buildLeadDevPlan, isLeadDevModeActive, persistLeadDevPlan, } from '../../../nucleus/autonomy-kernel.js';
 import { getExecutionPlanner } from '../execution/execution-planner.js';
 import { addObservations, extractComplexityObservations } from '../aside-context.js';
 /**
@@ -24,11 +25,24 @@ export class ComplexityHandler {
             if (asideId) {
                 addObservations(asideId, extractComplexityObservations(analysis));
             }
+            const primaryDescription = tasks.map((t) => t.description).filter(Boolean).join(' ');
+            const taskTypes = tasks.map((t) => t.type).filter(Boolean);
+            const leadDevPlan = isLeadDevModeActive() && primaryDescription
+                ? buildLeadDevPlan(primaryDescription, taskTypes.length ? taskTypes : ['implement'])
+                : null;
+            if (leadDevPlan) {
+                try {
+                    persistLeadDevPlan(leadDevPlan);
+                }
+                catch (err) {
+                    await frameworkLogger.log('orchestrator.server', 'lead-dev-plan-persist-failed', 'warning', { error: err instanceof Error ? err.message : String(err) });
+                }
+            }
             return {
                 content: [
                     {
                         type: 'text',
-                        text: this.formatComplexityResponse(analysis, recommendations, tasks.length),
+                        text: this.formatComplexityResponse(analysis, recommendations, tasks.length, leadDevPlan),
                     },
                 ],
             };
@@ -72,7 +86,23 @@ export class ComplexityHandler {
     /**
      * Format complexity response
      */
-    formatComplexityResponse(analysis, recommendations, taskCount) {
+    formatComplexityResponse(analysis, recommendations, taskCount, leadDevPlan = null) {
+        const leadDevSection = leadDevPlan
+            ? `
+
+**Lead-dev plan (codex ${leadDevPlan.codexTerms.join(', ')}):**
+${leadDevPlan.phases
+                .map((p) => `### ${p.id} — ${p.name}\n${p.todos
+                .map((t) => `- [ ] ${t.id} (${t.subagent}): ${t.task}`)
+                .join('\n')}`)
+                .join('\n\n')}
+
+**Test protocol:** ${leadDevPlan.testProtocol.hint}
+
+\`\`\`json
+${JSON.stringify(leadDevPlan, null, 2)}
+\`\`\``
+            : '';
         return `🔍 Complexity Analysis Results
 
 **Tasks Analyzed:** ${taskCount}
@@ -93,6 +123,6 @@ ${analysis.agentAssignments
 ${recommendations.map((r) => `• 💡 ${r}`).join('\n')}
 
 **Execution Estimate:** ${analysis.estimatedDuration}ms
-**Parallel Potential:** ${Math.round(analysis.parallelPotential * 100)}%`;
+**Parallel Potential:** ${Math.round(analysis.parallelPotential * 100)}%${leadDevSection}`;
     }
 }

package/dist/mcps/orchestrator/handlers/status-handler.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Status Handler
+ *
+ * Handles orchestration status requests
+ */
+import type { OrchestrationResult } from '../types.js';
+interface HistoryItem {
+    sessionId: string;
+    description: string;
+    tasks: number;
+    result: OrchestrationResult;
+    timestamp: string;
+}
+interface StatusHandlerDeps {
+    activeTasks: Map<string, unknown>;
+    taskHistory: HistoryItem[];
+    asideCount?: number;
+    asideIds?: string[];
+}
+/**
+ * Status Handler
+ * Processes get-orchestration-status requests
+ */
+export declare class StatusHandler {
+    /**
+     * Handle get-orchestration-status request
+     */
+    handleGetOrchestrationStatus(args: {
+        sessionId?: string;
+        detailed?: boolean;
+    }, deps: StatusHandlerDeps): Promise<{
+        content: Array<{
+            type: string;
+            text: string;
+        }>;
+    }>;
+    /**
+     * Handle cancel-orchestration request
+     */
+    handleCancelOrchestration(args: {
+        sessionId?: string;
+        taskId?: string;
+        force?: boolean;
+    }, deps: StatusHandlerDeps): Promise<{
+        content: Array<{
+            type: string;
+            text: string;
+        }>;
+    }>;
+    /**
+     * Handle optimize-orchestration request
+     */
+    handleOptimizeOrchestration(args: {
+        history?: boolean;
+        recommendations?: boolean;
+    }): Promise<{
+        content: Array<{
+            type: string;
+            text: string;
+        }>;
+    }>;
+    /**
+     * Get overall orchestration status
+     */
+    private getOverallStatus;
+    /**
+     * Format status response
+     */
+    private formatStatusResponse;
+}
+export {};

package/dist/mcps/orchestrator/handlers/task-handler.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Task Handler
+ *
+ * Handles task orchestration requests
+ */
+import type { OrchestrationResult, OrchestrationTask } from '../types.js';
+export interface TaskHandlerDeps {
+    taskHistory: OrchestrationHistoryItem[];
+    activeTasks: Map<string, unknown>;
+    asideId?: string;
+}
+interface OrchestrationHistoryItem {
+    sessionId: string;
+    description: string;
+    tasks: number;
+    result: OrchestrationResult;
+    timestamp: string;
+}
+/**
+ * Task Handler
+ * Processes orchestrate-task requests
+ */
+export declare class TaskHandler {
+    private planner;
+    /**
+     * Handle orchestrate-task request
+     */
+    handleOrchestrateTask(args: {
+        description: string;
+        tasks?: OrchestrationTask[];
+        sessionId?: string;
+        executionMode?: string;
+        timeout?: number;
+    }, deps: TaskHandlerDeps): Promise<{
+        content: Array<{
+            type: string;
+            text: string;
+        }>;
+    }>;
+    /**
+     * Execute the orchestration plan.
+     * For known MCP skill servers (code-review, security-audit, researcher, etc.),
+     * we actually call the target tool. For other agents we record the assignment.
+     */
+    private executePlan;
+    private mapAgentToTool;
+    private extractTextFromMcpResult;
+    /**
+     * Format orchestration response
+     */
+    private formatOrchestrationResponse;
+}
+export {};

package/dist/mcps/orchestrator/index.d.ts

@@ -0,0 +1,6 @@
+export { OrchestratorServer, createOrchestratorServer } from './server.js';
+export { TaskHandler } from './handlers/task-handler.js';
+export { ComplexityHandler } from './handlers/complexity-handler.js';
+export { StatusHandler } from './handlers/status-handler.js';
+export { spawnAside, closeAside, closeAllAsides, addObservations, getActiveAsideCount, getActiveAsideIds, getAsideState, resetAsideContext, extractGovernanceObservations, extractOrchestrationObservations, extractComplexityObservations, } from './aside-context.js';
+export type { AsideContextOptions, AsideObservation, AsideResult, ActiveAside, OrchestrationTask, OrchestrationResult, OrchestrationStatus, ComplexityAnalysis, TaskExecutionResult, ExecutionPlan, } from './types.js';

package/dist/mcps/orchestrator/server.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Orchestrator MCP Server - Facade
+ *
+ * Main entry point for the orchestrator MCP server
+ * Provides a clean API while hiding internal complexity
+ */
+/**
+ * Orchestrator MCP Server
+ * Enterprise-grade orchestration with advanced task management and agent coordination
+ */
+export declare class OrchestratorServer {
+    private server;
+    private activeTasks;
+    private taskHistory;
+    private taskHandler;
+    private complexityHandler;
+    private statusHandler;
+    private coordinator;
+    constructor();
+    /**
+     * Initialize tool definitions
+     */
+    private initializeTools;
+    /**
+     * Set up tool request handlers
+     */
+    private setupToolHandlers;
+    private handleGovernAndApply;
+    /**
+     * Start the server
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the server
+     */
+    stop(): Promise<void>;
+}
+export declare function createOrchestratorServer(): OrchestratorServer;

package/dist/mcps/orchestrator/server.js

@@ -105,7 +105,7 @@ export class OrchestratorServer {
                     },
                     {
                         name: 'analyze-complexity',
-                        description: 'Analyze task complexity and recommend optimal orchestration strategy',
+                        description: 'Analyze task complexity and recommend orchestration strategy. When lead_dev_mode is on (features.json), includes phased plan + todos + subagent routes.',
                         inputSchema: {
                             type: 'object',
                             properties: {