0xray 4.0.13 → 4.0.15

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

@@ -0,0 +1,201 @@
+/**
+ * 0xRay Model Health Check MCP Server
+ *
+ * Advanced model compatibility validation and dynamic health assessment
+ */
+import { modelRouter } from "../core/model-router.js";
+import fs from "fs";
+import { frameworkLogger } from "../core/framework-logger.js";
+import { XrayKnowledgeSkillBase } from "./shared/knowledge-skill-base.js";
+class XrayModelHealthCheckServer extends XrayKnowledgeSkillBase {
+    constructor() {
+        super("model-health-check", "3.1.0");
+        this.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",
+                        },
+                    },
+                },
+            },
+        ];
+        this.handlers = {
+            "model-health-check": async (args) => this.handleModelHealthCheck((args || {})),
+        };
+        this.setupToolHandlers();
+        frameworkLogger.log("mcps/model-health-check", "initialize", "info");
+    }
+    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;
+    }
+}
+// Start the server if this file is run directly
+if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {
+    const server = new XrayModelHealthCheckServer();
+    server.run().catch((error) => frameworkLogger.log("mcps/model-health-check", "run", "error", { error: String(error) }));
+}
+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/aside-context.js

@@ -0,0 +1,207 @@
+/**
+ * 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 { frameworkLogger } from "../../core/framework-logger.js";
+let asideCounter = 0;
+const activeAsides = new Map();
+export function getActiveAsideCount() {
+    return activeAsides.size;
+}
+export function getActiveAsideIds() {
+    return Array.from(activeAsides.keys());
+}
+export function getAsideState(asideId) {
+    return activeAsides.get(asideId);
+}
+export function addObservations(asideId, observations) {
+    const aside = activeAsides.get(asideId);
+    if (!aside)
+        return false;
+    aside.observations.push(...observations);
+    return true;
+}
+export function extractGovernanceObservations(result) {
+    const obs = [];
+    obs.push({
+        key: "governanceCycleId",
+        value: result.cycleId,
+        source: "inference/inference-cycle.ts",
+    });
+    obs.push({
+        key: "governanceVoteCount",
+        value: String(result.votes.length),
+        source: "inference/inference-cycle.ts",
+    });
+    const approved = result.votes.filter((v) => v.decision === "approve").length;
+    const rejected = result.votes.filter((v) => v.decision === "reject").length;
+    obs.push({
+        key: "governanceApprovedCount",
+        value: String(approved),
+        source: "inference/inference-cycle.ts",
+    });
+    obs.push({
+        key: "governanceRejectedCount",
+        value: String(rejected),
+        source: "inference/inference-cycle.ts",
+    });
+    if (result.corpusSummary) {
+        obs.push({
+            key: "corpusSessionCount",
+            value: String(result.corpusSummary.sessions),
+            source: "inference/inference-cycle.ts",
+        });
+        obs.push({
+            key: "corpusPatternCount",
+            value: String(result.corpusSummary.recurringPatterns),
+            source: "inference/inference-cycle.ts",
+        });
+    }
+    return obs;
+}
+export function extractOrchestrationObservations(result) {
+    const obs = [];
+    obs.push({
+        key: "orchestrationSuccess",
+        value: String(result.success),
+        source: "mcps/orchestrator/types.ts",
+    });
+    obs.push({
+        key: "tasksCompleted",
+        value: String(result.completedTasks),
+        source: "mcps/orchestrator/types.ts",
+    });
+    obs.push({
+        key: "tasksFailed",
+        value: String(result.failedTasks),
+        source: "mcps/orchestrator/types.ts",
+    });
+    obs.push({
+        key: "orchestrationDuration",
+        value: `${result.duration}ms`,
+        source: "mcps/orchestrator/types.ts",
+    });
+    for (const b of result.bottlenecks) {
+        obs.push({
+            key: "bottleneck",
+            value: b.substring(0, 200),
+            source: "mcps/orchestrator/types.ts",
+        });
+    }
+    for (const r of result.recommendations) {
+        obs.push({
+            key: "recommendation",
+            value: r.substring(0, 200),
+            source: "mcps/orchestrator/types.ts",
+        });
+    }
+    return obs;
+}
+export function extractComplexityObservations(analysis) {
+    const obs = [];
+    obs.push({
+        key: "complexityScore",
+        value: String(analysis.overallComplexity),
+        source: "mcps/orchestrator/execution/execution-planner.ts",
+    });
+    obs.push({
+        key: "recommendedStrategy",
+        value: analysis.recommendedStrategy,
+        source: "mcps/orchestrator/execution/execution-planner.ts",
+    });
+    obs.push({
+        key: "parallelPotential",
+        value: String(analysis.parallelPotential),
+        source: "mcps/orchestrator/execution/execution-planner.ts",
+    });
+    obs.push({
+        key: "estimatedDuration",
+        value: `${analysis.estimatedDuration}ms`,
+        source: "mcps/orchestrator/execution/execution-planner.ts",
+    });
+    for (const tc of analysis.taskComplexity) {
+        obs.push({
+            key: `taskComplexity`,
+            value: `${tc.complexity} (${tc.category})`,
+            source: "mcps/orchestrator/execution/execution-planner.ts",
+        });
+    }
+    return obs;
+}
+export async function spawnAside(options) {
+    const asideId = options.parentAsideId
+        ? `${options.parentAsideId}.aside-${++asideCounter}`
+        : `aside-${++asideCounter}-${Date.now()}`;
+    const startTime = Date.now();
+    const aside = {
+        asideId,
+        description: options.description,
+        startedAt: startTime,
+        observations: [],
+        ...(options.inheritedContext !== undefined ? { inheritedContext: options.inheritedContext } : {}),
+        ...(options.parentAsideId !== undefined ? { parentAsideId: options.parentAsideId } : {}),
+        ...(options.sessionId !== undefined ? { sessionId: options.sessionId } : {}),
+        ...(options.priorVerdictContext !== undefined ? { priorVerdictContext: options.priorVerdictContext } : {}),
+    };
+    activeAsides.set(asideId, aside);
+    frameworkLogger.log("aside-context", "aside-spawn", "info", {
+        asideId,
+        description: options.description,
+        sessionId: options.sessionId,
+        parentAsideId: options.parentAsideId,
+        activeAsideCount: activeAsides.size,
+    });
+    if (options.priorVerdictContext) {
+        const decision = options.priorVerdictContext["decision"];
+        if (decision) {
+            aside.observations.push({
+                key: "governanceDecision",
+                value: String(decision),
+                source: "priorVerdictContext",
+            });
+        }
+    }
+    const duration = Date.now() - startTime;
+    const result = {
+        asideId,
+        description: options.description,
+        success: true,
+        duration,
+        observations: aside.observations,
+        ...(options.priorVerdictContext !== undefined ? { priorVerdictContext: options.priorVerdictContext } : {}),
+    };
+    frameworkLogger.log("aside-context", "aside-complete", "info", {
+        asideId,
+        duration,
+        observationCount: aside.observations.length,
+        activeAsideCount: activeAsides.size,
+    });
+    return result;
+}
+export function closeAside(asideId) {
+    const aside = activeAsides.get(asideId);
+    if (!aside)
+        return false;
+    activeAsides.delete(asideId);
+    frameworkLogger.log("aside-context", "aside-closed", "info", {
+        asideId,
+        duration: Date.now() - aside.startedAt,
+        remainingActive: activeAsides.size,
+    });
+    return true;
+}
+export function closeAllAsides() {
+    const count = activeAsides.size;
+    activeAsides.clear();
+    frameworkLogger.log("aside-context", "aside-close-all", "info", {
+        closedCount: count,
+    });
+    return count;
+}
+export function resetAsideContext() {
+    activeAsides.clear();
+    asideCounter = 0;
+}

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, taskType?: 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/agent-capabilities.js

@@ -0,0 +1,128 @@
+/**
+ * Agent Capabilities Configuration
+ *
+ * Centralized agent capability definitions for orchestration decisions.
+ * Enriched at runtime by the active MemoryRoutingProvider (Repertoire, etc.).
+ */
+import { AGENT_REGISTRY } from "../../../agents/registry.js";
+import { initializeMemoryRouting } from '../../../memory-routing/index.js';
+import { getProvider, toMemoryCapabilityMap, fromMemoryCapabilityMap, } from './memory-routing-bridge.js';
+import { routeSubagent } from '../../../nucleus/autonomy-kernel.js';
+/** routeSubagent names → AGENT_REGISTRY keys */
+const ROUTE_AGENT_ALIASES = {
+    'code-review': 'code-reviewer',
+    'security-audit': 'security-auditor',
+    'bug-triage': 'bug-triage-specialist',
+    'architect-tools': 'architect',
+};
+function resolveRoutedAgent(routed, capabilities) {
+    const candidate = ROUTE_AGENT_ALIASES[routed] ?? routed;
+    if (capabilities.has(candidate))
+        return candidate;
+    if (capabilities.has(routed))
+        return routed;
+    return null;
+}
+const DEFAULT_AGENT_CAPABILITIES = Object.fromEntries(Object.entries(AGENT_REGISTRY).map(([name, entry]) => [
+    name,
+    {
+        capabilities: entry.capabilities,
+        complexityThreshold: entry.maxComplexity,
+        concurrentTasks: entry.concurrentTasks,
+    },
+]));
+initializeMemoryRouting();
+/**
+ * Agent Capabilities Manager
+ * Manages agent capabilities for orchestration decisions
+ */
+export class AgentCapabilitiesManager {
+    capabilities = new Map();
+    enriched = false;
+    constructor() {
+        Object.entries(DEFAULT_AGENT_CAPABILITIES).forEach(([agent, config]) => {
+            this.capabilities.set(agent, config);
+        });
+        this.applyMemoryRoutingEnrichment();
+    }
+    applyMemoryRoutingEnrichment() {
+        const provider = getProvider();
+        if (provider.id === 'null')
+            return;
+        const memoryCaps = toMemoryCapabilityMap(this.capabilities);
+        const enriched = provider.enhanceAgentCapabilities(memoryCaps);
+        this.capabilities = fromMemoryCapabilityMap(enriched);
+        this.enriched = true;
+    }
+    /**
+     * Get capabilities for a specific agent
+     */
+    getCapabilities(agentType) {
+        return this.capabilities.get(agentType);
+    }
+    /**
+     * Get all registered agent capabilities
+     */
+    getAllCapabilities() {
+        if (!this.enriched)
+            this.applyMemoryRoutingEnrichment();
+        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, capabilities, and memory routing.
+     */
+    selectAgentForTask(requiredCapabilities, complexity, operationDescription = '', taskType = '') {
+        if (taskType.trim()) {
+            const routed = routeSubagent(taskType);
+            const resolved = resolveRoutedAgent(routed, this.capabilities);
+            if (resolved)
+                return resolved;
+        }
+        const provider = getProvider();
+        if (provider.id !== 'null' && operationDescription) {
+            const memoryCaps = toMemoryCapabilityMap(this.getAllCapabilities());
+            return provider.selectAgent(memoryCaps, requiredCapabilities, complexity, operationDescription);
+        }
+        let bestAgent = null;
+        let bestScore = -1;
+        for (const [agent, caps] of this.capabilities) {
+            if (complexity > caps.complexityThreshold)
+                continue;
+            const matchCount = requiredCapabilities.filter((cap) => caps.capabilities.includes(cap)).length;
+            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;
+    }
+}
+let capabilitiesManagerInstance = null;
+export function getAgentCapabilitiesManager() {
+    if (!capabilitiesManagerInstance) {
+        capabilitiesManagerInstance = new AgentCapabilitiesManager();
+    }
+    return capabilitiesManagerInstance;
+}
+export function resetAgentCapabilitiesManager() {
+    capabilitiesManagerInstance = null;
+}

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/config/memory-routing-bridge.js

@@ -0,0 +1,71 @@
+/**
+ * Bridge between orchestrator types and the pluggable MemoryRoutingProvider.
+ */
+import { getMemoryRoutingProviderSync, } from '../../../memory-routing/index.js';
+export function toMemoryCapability(caps) {
+    const result = {
+        capabilities: caps.capabilities,
+        complexityThreshold: caps.complexityThreshold,
+        concurrentTasks: caps.concurrentTasks,
+    };
+    if (caps.memorySignals)
+        result.memorySignals = caps.memorySignals;
+    if (caps.memoryTags)
+        result.memoryTags = caps.memoryTags;
+    return result;
+}
+export function fromMemoryCapability(caps) {
+    const result = {
+        capabilities: caps.capabilities,
+        complexityThreshold: caps.complexityThreshold,
+        concurrentTasks: caps.concurrentTasks,
+    };
+    if (caps.memorySignals)
+        result.memorySignals = caps.memorySignals;
+    if (caps.memoryTags)
+        result.memoryTags = caps.memoryTags;
+    return result;
+}
+export function toMemoryTask(task) {
+    const result = {
+        id: task.id,
+        description: task.description,
+        type: task.type,
+    };
+    if (task.priority)
+        result.priority = task.priority;
+    if (Array.isArray(task.dependencies) && task.dependencies.length > 0) {
+        result.dependencies = task.dependencies;
+    }
+    if (task.estimatedComplexity !== undefined)
+        result.estimatedComplexity = task.estimatedComplexity;
+    if (task.metadata)
+        result.metadata = task.metadata;
+    return result;
+}
+export function fromMemoryTask(task) {
+    const result = {
+        id: task.id,
+        description: task.description,
+        type: task.type,
+    };
+    if (task.priority)
+        result.priority = task.priority;
+    if (task.dependencies)
+        result.dependencies = task.dependencies;
+    if (task.estimatedComplexity !== undefined)
+        result.estimatedComplexity = task.estimatedComplexity;
+    const metadata = task.metadata;
+    if (metadata)
+        result.metadata = metadata;
+    return result;
+}
+export function toMemoryCapabilityMap(caps) {
+    return new Map(Array.from(caps.entries()).map(([k, v]) => [k, toMemoryCapability(v)]));
+}
+export function fromMemoryCapabilityMap(caps) {
+    return new Map(Array.from(caps.entries()).map(([k, v]) => [k, fromMemoryCapability(v)]));
+}
+export function getProvider() {
+    return getMemoryRoutingProviderSync();
+}