snow-flow 3.0.8 → 3.0.10

package/dist/queen/integration-test.js

@@ -1,563 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-/**
- * ServiceNow Queen Agent Integration Test Suite
- *
- * COMPREHENSIVE TESTING: Verifies Queen Agent works with real MCP tools
- *
- * TEST SCENARIOS:
- * 1. Basic Queen Initialization ✓
- * 2. MCP Tool Access Verification ✓
- * 3. Simple Objective Parsing ✓
- * 4. Agent Spawning ✓
- * 5. Memory System Persistence ✓
- *
- * INTEGRATION CHECKS:
- * - Queen Agent imports successfully
- * - MCP servers respond without placeholder errors
- * - Agent factory can spawn specialized agents
- * - Memory system can store/retrieve learning patterns
- * - Neural learning can classify tasks
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueenIntegrationTester = void 0;
-const index_js_1 = require("./index.js");
-const agent_factory_js_1 = require("./agent-factory.js");
-const neural_learning_js_1 = require("./neural-learning.js");
-const queen_memory_js_1 = require("./queen-memory.js");
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-// Test configuration
-const TEST_CONFIG = {
-    debugMode: true,
-    memoryPath: './.claude-flow/queen-test/test-memory.db',
-    maxConcurrentAgents: 3,
-    testTimeout: 30000
-};
-class QueenIntegrationTester {
-    constructor() {
-        this.results = [];
-        this.queen = null;
-        this.setupTestEnvironment();
-    }
-    setupTestEnvironment() {
-        // Ensure test directory exists
-        const testDir = path.dirname(TEST_CONFIG.memoryPath);
-        if (!fs.existsSync(testDir)) {
-            fs.mkdirSync(testDir, { recursive: true });
-        }
-        console.log('🧪 QUEEN AGENT INTEGRATION TESTER');
-        console.log('================================');
-        console.log(`Test Directory: ${testDir}`);
-        console.log(`Debug Mode: ${TEST_CONFIG.debugMode}`);
-        console.log(`Max Agents: ${TEST_CONFIG.maxConcurrentAgents}`);
-        console.log('');
-    }
-    /**
-     * TEST 1: Basic Queen Initialization
-     */
-    async testQueenInitialization() {
-        const startTime = Date.now();
-        try {
-            console.log('🔍 TEST 1: Basic Queen Initialization');
-            // Test 1.1: Create Queen instance
-            this.queen = (0, index_js_1.createServiceNowQueen)({
-                debugMode: TEST_CONFIG.debugMode,
-                memoryPath: TEST_CONFIG.memoryPath,
-                maxConcurrentAgents: TEST_CONFIG.maxConcurrentAgents
-            });
-            if (!this.queen) {
-                throw new Error('Failed to create Queen instance');
-            }
-            // Test 1.2: Verify Queen has required components
-            const status = this.queen.getHiveMindStatus();
-            if (!status) {
-                throw new Error('Queen status unavailable');
-            }
-            // Test 1.3: Verify memory system
-            if (typeof status.memoryStats !== 'object') {
-                throw new Error('Memory stats unavailable');
-            }
-            // Test 1.4: Verify agent factory
-            if (typeof status.factoryStats !== 'object') {
-                throw new Error('Factory stats unavailable');
-            }
-            const duration = Date.now() - startTime;
-            const result = {
-                testName: 'Queen Initialization',
-                status: 'PASS',
-                duration,
-                details: `Queen created successfully with ${status.activeTasks} active tasks, ${status.activeAgents} agents`
-            };
-            console.log(`✅ PASS (${duration}ms): Queen initialized with hive-mind components`);
-            return result;
-        }
-        catch (error) {
-            const duration = Date.now() - startTime;
-            const result = {
-                testName: 'Queen Initialization',
-                status: 'FAIL',
-                duration,
-                details: 'Failed to initialize Queen Agent',
-                error: error.message
-            };
-            console.log(`❌ FAIL (${duration}ms): ${error.message}`);
-            return result;
-        }
-    }
-    /**
-     * TEST 2: MCP Tool Access Verification
-     */
-    async testMcpToolAccess() {
-        const startTime = Date.now();
-        try {
-            console.log('🔍 TEST 2: MCP Tool Access Verification');
-            if (!this.queen) {
-                throw new Error('Queen not initialized');
-            }
-            // Test 2.1: Access to deployment tools
-            console.log('  - Testing deployment tool access...');
-            // Test 2.2: Access to flow composer tools
-            console.log('  - Testing flow composer tool access...');
-            // Test 2.3: Access to operations tools
-            console.log('  - Testing operations tool access...');
-            // Test 2.4: Access to intelligent tools
-            console.log('  - Testing intelligent tool access...');
-            // Since we can't directly test MCP tools without live connections,
-            // we'll verify the Queen can create deployment plans that reference the correct tools
-            const mockResult = await this.testMcpToolPlanning();
-            const duration = Date.now() - startTime;
-            const result = {
-                testName: 'MCP Tool Access',
-                status: 'PASS',
-                duration,
-                details: `MCP tool planning successful: ${mockResult.toolsReferenced} tools referenced`
-            };
-            console.log(`✅ PASS (${duration}ms): MCP tools accessible through Queen coordination`);
-            return result;
-        }
-        catch (error) {
-            const duration = Date.now() - startTime;
-            const result = {
-                testName: 'MCP Tool Access',
-                status: 'FAIL',
-                duration,
-                details: 'Failed to access MCP tools',
-                error: error.message
-            };
-            console.log(`❌ FAIL (${duration}ms): ${error.message}`);
-            return result;
-        }
-    }
-    /**
-     * Helper for MCP Tool Planning Test
-     */
-    async testMcpToolPlanning() {
-        if (!this.queen)
-            throw new Error('Queen not initialized');
-        // Test widget deployment plan
-        const widgetObjective = "Create an incident dashboard widget with charts";
-        console.log(`    Testing widget planning: "${widgetObjective}"`);
-        // Test flow deployment plan
-        const flowObjective = "Create an approval flow for iPhone requests";
-        console.log(`    Testing flow planning: "${flowObjective}"`);
-        // Since Queen uses internal planning, we verify it can create execution plans
-        // This tests the MCP tool coordination without requiring live connections
-        return { toolsReferenced: 8 }; // Mock count of MCP tools the Queen would use
-    }
-    /**
-     * TEST 3: Simple Objective Parsing
-     */
-    async testObjectiveParsing() {
-        const startTime = Date.now();
-        try {
-            console.log('🔍 TEST 3: Simple Objective Parsing');
-            if (!this.queen) {
-                throw new Error('Queen not initialized');
-            }
-            // Test 3.1: Widget objective parsing
-            const widgetObjective = "Create a dashboard widget showing incident statistics with charts";
-            console.log(`  - Testing widget parsing: "${widgetObjective}"`);
-            // Test 3.2: Flow objective parsing
-            const flowObjective = "Build an approval workflow for service requests";
-            console.log(`  - Testing flow parsing: "${flowObjective}"`);
-            // Test 3.3: Integration objective parsing
-            const integrationObjective = "Create integration with external API for data sync";
-            console.log(`  - Testing integration parsing: "${integrationObjective}"`);
-            // Test neural learning classification directly
-            const memorySystem = new queen_memory_js_1.QueenMemorySystem(TEST_CONFIG.memoryPath + '-neural');
-            const neuralLearning = new neural_learning_js_1.NeuralLearning(memorySystem);
-            const widgetAnalysis = neuralLearning.analyzeTask(widgetObjective);
-            const flowAnalysis = neuralLearning.analyzeTask(flowObjective);
-            const integrationAnalysis = neuralLearning.analyzeTask(integrationObjective);
-            // Verify classifications
-            if (widgetAnalysis.type !== 'widget') {
-                throw new Error(`Widget classification failed: got ${widgetAnalysis.type}, expected 'widget'`);
-            }
-            if (flowAnalysis.type !== 'flow') {
-                throw new Error(`Flow classification failed: got ${flowAnalysis.type}, expected 'flow'`);
-            }
-            if (integrationAnalysis.type !== 'integration') {
-                throw new Error(`Integration classification failed: got ${integrationAnalysis.type}, expected 'integration'`);
-            }
-            const duration = Date.now() - startTime;
-            const result = {
-                testName: 'Objective Parsing',
-                status: 'PASS',
-                duration,
-                details: `Successfully parsed 3 objectives: widget (${widgetAnalysis.estimatedComplexity.toFixed(2)}), flow (${flowAnalysis.estimatedComplexity.toFixed(2)}), integration (${integrationAnalysis.estimatedComplexity.toFixed(2)})`
-            };
-            console.log(`✅ PASS (${duration}ms): Natural language processing working correctly`);
-            console.log(`    Widget complexity: ${widgetAnalysis.estimatedComplexity.toFixed(2)}`);
-            console.log(`    Flow complexity: ${flowAnalysis.estimatedComplexity.toFixed(2)}`);
-            console.log(`    Integration complexity: ${integrationAnalysis.estimatedComplexity.toFixed(2)}`);
-            // Cleanup
-            memorySystem.close();
-            return result;
-        }
-        catch (error) {
-            const duration = Date.now() - startTime;
-            const result = {
-                testName: 'Objective Parsing',
-                status: 'FAIL',
-                duration,
-                details: 'Failed to parse objectives',
-                error: error.message
-            };
-            console.log(`❌ FAIL (${duration}ms): ${error.message}`);
-            return result;
-        }
-    }
-    /**
-     * TEST 4: Agent Spawning
-     */
-    async testAgentSpawning() {
-        const startTime = Date.now();
-        try {
-            console.log('🔍 TEST 4: Agent Spawning');
-            if (!this.queen) {
-                throw new Error('Queen not initialized');
-            }
-            // Test 4.1: Create agent factory
-            const memorySystem = new queen_memory_js_1.QueenMemorySystem(TEST_CONFIG.memoryPath + '-agents');
-            const agentFactory = new agent_factory_js_1.AgentFactory(memorySystem);
-            // Test 4.2: Spawn individual agents
-            console.log('  - Testing individual agent spawning...');
-            const widgetAgent = agentFactory.spawnAgent('widget-creator', 'test-task-1');
-            const flowAgent = agentFactory.spawnAgent('flow-builder', 'test-task-2');
-            const researcherAgent = agentFactory.spawnAgent('researcher', 'test-task-3');
-            if (!widgetAgent || widgetAgent.type !== 'widget-creator') {
-                throw new Error('Widget agent spawn failed');
-            }
-            if (!flowAgent || flowAgent.type !== 'flow-builder') {
-                throw new Error('Flow agent spawn failed');
-            }
-            if (!researcherAgent || researcherAgent.type !== 'researcher') {
-                throw new Error('Researcher agent spawn failed');
-            }
-            // Test 4.3: Spawn agent swarm
-            console.log('  - Testing agent swarm spawning...');
-            const swarmAgents = agentFactory.spawnAgentSwarm(['researcher', 'widget-creator', 'tester'], 'test-swarm-task');
-            if (swarmAgents.length !== 3) {
-                throw new Error(`Expected 3 agents in swarm, got ${swarmAgents.length}`);
-            }
-            // Test 4.4: Agent capabilities verification
-            console.log('  - Testing agent capabilities...');
-            const widgetCapabilities = widgetAgent.capabilities;
-            if (!widgetCapabilities.includes('HTML template creation')) {
-                throw new Error('Widget agent missing expected capabilities');
-            }
-            const flowCapabilities = flowAgent.capabilities;
-            if (!flowCapabilities.includes('Business process design')) {
-                throw new Error('Flow agent missing expected capabilities');
-            }
-            // Test 4.5: Factory statistics
-            const stats = agentFactory.getStatistics();
-            console.log(`    Active agents: ${stats.totalActiveAgents}`);
-            console.log(`    Agent types: ${Object.keys(stats.agentTypeCounts).join(', ')}`);
-            const duration = Date.now() - startTime;
-            const result = {
-                testName: 'Agent Spawning',
-                status: 'PASS',
-                duration,
-                details: `Successfully spawned ${stats.totalActiveAgents} agents across ${Object.keys(stats.agentTypeCounts).length} types`
-            };
-            console.log(`✅ PASS (${duration}ms): Agent spawning system operational`);
-            // Cleanup
-            agentFactory.cleanupCompletedAgents();
-            memorySystem.close();
-            return result;
-        }
-        catch (error) {
-            const duration = Date.now() - startTime;
-            const result = {
-                testName: 'Agent Spawning',
-                status: 'FAIL',
-                duration,
-                details: 'Failed to spawn agents',
-                error: error.message
-            };
-            console.log(`❌ FAIL (${duration}ms): ${error.message}`);
-            return result;
-        }
-    }
-    /**
-     * TEST 5: Memory System Persistence
-     */
-    async testMemorySystem() {
-        const startTime = Date.now();
-        try {
-            console.log('🔍 TEST 5: Memory System Persistence');
-            if (!this.queen) {
-                throw new Error('Queen not initialized');
-            }
-            // Test 5.1: Memory storage and retrieval
-            console.log('  - Testing memory storage...');
-            const memorySystem = new queen_memory_js_1.QueenMemorySystem(TEST_CONFIG.memoryPath + '-memory');
-            // Store test learning
-            memorySystem.storeLearning('test_pattern_widget', 'Widget creation successful with charts', 0.9);
-            memorySystem.storeLearning('test_pattern_flow', 'Flow creation with approval steps', 0.8);
-            // Test retrieval
-            const widgetLearning = memorySystem.getLearning('test_pattern_widget');
-            const flowLearning = memorySystem.getLearning('test_pattern_flow');
-            if (!widgetLearning || !widgetLearning.includes('Widget creation successful')) {
-                throw new Error('Widget learning not stored/retrieved correctly');
-            }
-            if (!flowLearning || !flowLearning.includes('Flow creation with approval')) {
-                throw new Error('Flow learning not stored/retrieved correctly');
-            }
-            // Test 5.2: Artifact storage
-            console.log('  - Testing artifact storage...');
-            memorySystem.storeArtifact({
-                type: 'widget',
-                name: 'test_dashboard_widget',
-                sys_id: 'test-12345',
-                config: { template: 'dashboard', css: 'responsive' },
-                dependencies: ['Chart.js']
-            });
-            const similarArtifacts = memorySystem.findSimilarArtifacts('widget', 'dashboard');
-            if (similarArtifacts.length === 0) {
-                throw new Error('Artifact not stored/found correctly');
-            }
-            // Test 5.3: Task completion recording
-            console.log('  - Testing task history...');
-            memorySystem.recordTaskCompletion('test-task-' + Date.now() + '-' + Math.random().toString(36).substring(7), // Unique task ID
-            'Create test dashboard widget', 'widget', ['researcher', 'widget-creator', 'tester'], true, 5000);
-            const successRate = memorySystem.getSuccessRate('widget');
-            if (successRate <= 0) {
-                throw new Error('Task completion not recorded correctly');
-            }
-            // Test 5.4: Memory export/import
-            console.log('  - Testing memory export/import...');
-            const exportedMemory = memorySystem.exportMemory();
-            if (!exportedMemory || exportedMemory.length < 10) {
-                throw new Error('Memory export failed');
-            }
-            // Create new memory system and import
-            const memorySystem2 = new queen_memory_js_1.QueenMemorySystem(TEST_CONFIG.memoryPath + '-import');
-            memorySystem2.importMemory(exportedMemory);
-            const importedLearning = memorySystem2.getLearning('test_pattern_widget');
-            if (!importedLearning || !importedLearning.includes('Widget creation successful')) {
-                throw new Error('Memory import failed');
-            }
-            const duration = Date.now() - startTime;
-            const result = {
-                testName: 'Memory System',
-                status: 'PASS',
-                duration,
-                details: `Memory system operational: stored ${similarArtifacts.length} artifacts, success rate: ${(successRate * 100).toFixed(1)}%`
-            };
-            console.log(`✅ PASS (${duration}ms): Memory system persistence working`);
-            console.log(`    Success rate: ${(successRate * 100).toFixed(1)}%`);
-            console.log(`    Artifacts found: ${similarArtifacts.length}`);
-            // Cleanup
-            memorySystem.close();
-            memorySystem2.close();
-            return result;
-        }
-        catch (error) {
-            const duration = Date.now() - startTime;
-            const result = {
-                testName: 'Memory System',
-                status: 'FAIL',
-                duration,
-                details: 'Failed to test memory system',
-                error: error.message
-            };
-            console.log(`❌ FAIL (${duration}ms): ${error.message}`);
-            return result;
-        }
-    }
-    /**
-     * TEST 6: End-to-End Integration Test
-     */
-    async testEndToEndIntegration() {
-        const startTime = Date.now();
-        try {
-            console.log('🔍 TEST 6: End-to-End Integration');
-            if (!this.queen) {
-                throw new Error('Queen not initialized');
-            }
-            // Test 6.1: Simple objective execution (without real deployment)
-            console.log('  - Testing simple objective execution...');
-            const objective = "Create a test widget for incident statistics";
-            // Since we can't do real deployment without ServiceNow, we'll test the coordination logic
-            console.log(`    Objective: "${objective}"`);
-            // Test the Queen's analysis and planning capabilities
-            const status = this.queen.getHiveMindStatus();
-            console.log(`    Current hive-mind status: ${status.activeTasks} tasks, ${status.activeAgents} agents`);
-            // Test learning insights
-            const insights = this.queen.getLearningInsights();
-            console.log(`    Learning patterns: ${insights.memoryStats.totalPatterns}`);
-            console.log(`    Stored artifacts: ${insights.memoryStats.totalArtifacts}`);
-            const duration = Date.now() - startTime;
-            const result = {
-                testName: 'End-to-End Integration',
-                status: 'PASS',
-                duration,
-                details: `Integration test successful: ${insights.memoryStats.totalPatterns} patterns, ${insights.memoryStats.totalArtifacts} artifacts`
-            };
-            console.log(`✅ PASS (${duration}ms): End-to-end integration working`);
-            return result;
-        }
-        catch (error) {
-            const duration = Date.now() - startTime;
-            const result = {
-                testName: 'End-to-End Integration',
-                status: 'FAIL',
-                duration,
-                details: 'Failed end-to-end integration test',
-                error: error.message
-            };
-            console.log(`❌ FAIL (${duration}ms): ${error.message}`);
-            return result;
-        }
-    }
-    /**
-     * Run all integration tests
-     */
-    async runAllTests() {
-        console.log('🚀 STARTING QUEEN AGENT INTEGRATION TESTS\n');
-        const tests = [
-            () => this.testQueenInitialization(),
-            () => this.testMcpToolAccess(),
-            () => this.testObjectiveParsing(),
-            () => this.testAgentSpawning(),
-            () => this.testMemorySystem(),
-            () => this.testEndToEndIntegration()
-        ];
-        for (const test of tests) {
-            const result = await test();
-            this.results.push(result);
-            console.log(''); // Space between tests
-        }
-        await this.generateTestReport();
-    }
-    /**
-     * Generate comprehensive test report
-     */
-    async generateTestReport() {
-        console.log('📊 QUEEN AGENT INTEGRATION TEST RESULTS');
-        console.log('=====================================');
-        const passed = this.results.filter(r => r.status === 'PASS').length;
-        const failed = this.results.filter(r => r.status === 'FAIL').length;
-        const total = this.results.length;
-        console.log(`\n📈 SUMMARY:`);
-        console.log(`   Total Tests: ${total}`);
-        console.log(`   ✅ Passed: ${passed}`);
-        console.log(`   ❌ Failed: ${failed}`);
-        console.log(`   📊 Success Rate: ${((passed / total) * 100).toFixed(1)}%`);
-        console.log(`\n📋 DETAILED RESULTS:`);
-        for (const result of this.results) {
-            const statusIcon = result.status === 'PASS' ? '✅' : '❌';
-            console.log(`   ${statusIcon} ${result.testName}: ${result.details} (${result.duration}ms)`);
-            if (result.error) {
-                console.log(`      Error: ${result.error}`);
-            }
-        }
-        // Integration recommendations
-        console.log(`\n🔧 INTEGRATION RECOMMENDATIONS:`);
-        const allPassed = failed === 0;
-        if (allPassed) {
-            console.log('   ✅ Queen Agent is ready for production integration');
-            console.log('   ✅ All core systems operational');
-            console.log('   ✅ MCP tool coordination working');
-            console.log('   ✅ Memory system persistent');
-            console.log('   ✅ Agent spawning functional');
-        }
-        else {
-            console.log('   ⚠️  Integration issues detected:');
-            for (const failure of this.results.filter(r => r.status === 'FAIL')) {
-                console.log(`      - ${failure.testName}: ${failure.error}`);
-            }
-        }
-        console.log(`\n🎯 NEXT STEPS:`);
-        if (allPassed) {
-            console.log('   1. Integration with snow-flow CLI ready');
-            console.log('   2. Can replace existing swarm coordination');
-            console.log('   3. Deploy in production environment');
-            console.log('   4. Monitor performance metrics');
-        }
-        else {
-            console.log('   1. Fix failing integration tests');
-            console.log('   2. Verify MCP server connectivity');
-            console.log('   3. Re-run integration tests');
-            console.log('   4. Consult troubleshooting guide');
-        }
-        // Cleanup Queen
-        if (this.queen) {
-            await this.queen.shutdown();
-            console.log('\n🛑 Queen Agent shutdown complete');
-        }
-    }
-}
-exports.QueenIntegrationTester = QueenIntegrationTester;
-// Run the integration tests
-async function main() {
-    const tester = new QueenIntegrationTester();
-    try {
-        await tester.runAllTests();
-    }
-    catch (error) {
-        console.error('❌ INTEGRATION TEST SUITE FAILED:', error);
-        process.exit(1);
-    }
-}
-// Execute if run directly
-if (import.meta.url === `file://${process.argv[1]}`) {
-    main().catch(console.error);
-}
-exports.default = QueenIntegrationTester;

package/dist/queen/mock-mcp-client.d.ts

@@ -1,71 +0,0 @@
-/**
- * Mock MCP Client for Queen Agent Testing
- *
- * Simulates MCP tool responses without requiring live ServiceNow connections
- * Tests Queen ↔ MCP communication patterns
- */
-export interface MockMcpResponse {
-    success: boolean;
-    result?: any;
-    error?: string;
-    toolUsed: string;
-    executionTime: number;
-}
-export declare class MockMcpClient {
-    private callHistory;
-    /**
-     * Mock snow_deploy tool
-     */
-    snow_deploy(params: any): Promise<MockMcpResponse>;
-    /**
-     * Mock snow_create_flow tool
-     */
-    snow_create_flow(params: any): Promise<MockMcpResponse>;
-    /**
-     * Mock snow_find_artifact tool
-     */
-    snow_find_artifact(params: any): Promise<MockMcpResponse>;
-    /**
-     * Mock snow_catalog_item_search tool
-     */
-    snow_catalog_item_search(params: any): Promise<MockMcpResponse>;
-    /**
-     * Mock snow_test_flow_with_mock tool
-     */
-    snow_test_flow_with_mock(params: any): Promise<MockMcpResponse>;
-    /**
-     * Mock snow_update_set_create tool
-     */
-    snow_update_set_create(params: any): Promise<MockMcpResponse>;
-    /**
-     * Get call history for analysis
-     */
-    getCallHistory(): Array<{
-        tool: string;
-        params: any;
-        timestamp: Date;
-    }>;
-    /**
-     * Get usage statistics
-     */
-    getUsageStats(): {
-        totalCalls: number;
-        toolUsage: Record<string, number>;
-        avgResponseTime: number;
-    };
-    /**
-     * Clear call history
-     */
-    clearHistory(): void;
-    /**
-     * Simulate realistic API delay
-     */
-    private simulateDelay;
-    /**
-     * COMPATIBILITY FIX: makeRequest method for phantom calls
-     * MockMcpClient simulates HTTP requests
-     */
-    makeRequest(config: any): Promise<any>;
-}
-export default MockMcpClient;
-//# sourceMappingURL=mock-mcp-client.d.ts.map