agentic-flow 3.0.0-alpha.2 → 3.0.0

package/dist/agentic-flow/src/mcp/fastmcp/servers/stdio-full.js

@@ -1,836 +0,0 @@
-#!/usr/bin/env node
-// Full FastMCP server with stdio transport - All 86 claude-flow-sdk tools
-import { FastMCP } from 'fastmcp';
-import { z } from 'zod';
-import { execSync } from 'child_process';
-import { AgentDBService } from '../../../services/agentdb-service.js';
-import { registerSessionTools } from '../tools/session-tools.js';
-import { registerGitHubTools } from '../tools/github-tools.js';
-import { registerNeuralTools } from '../tools/neural-tools.js';
-import { registerRuVectorTools } from '../tools/ruvector-tools.js';
-import { registerSonaRvfTools } from '../tools/sona-rvf-tools.js';
-import { registerInfrastructureTools } from '../tools/infrastructure-tools.js';
-import { registerAutopilotTools } from '../tools/autopilot-tools.js';
-import { registerPerformanceTools } from '../tools/performance-tools.js';
-import { registerWorkflowTools } from '../tools/workflow-tools.js';
-import { registerDAATools } from '../tools/daa-tools.js';
-import { registerAttentionTools } from '../tools/attention-tools.js';
-import { registerHiddenControllerTools } from '../tools/hidden-controllers.js';
-import { registerQUICTools } from '../tools/quic-tools.js';
-import { registerRVFTools } from '../tools/rvf-tools.js';
-import { registerCostOptimizerTools } from '../tools/cost-optimizer-tools.js';
-import { registerStreamingTools } from '../tools/streaming-tools.js';
-import { registerSonaTools } from '../tools/sona-tools.js';
-import { registerMemoryTools } from '../tools/memory-tools.js';
-import { registerQuantizationTools } from '../tools/quantization-tools.js';
-import { registerExplainabilityTools } from '../tools/explainability-tools.js';
-// SECURITY: Import rate limiting middleware
-import { withRateLimit } from '../../middleware/apply-rate-limit.js';
-// Import DirectCallBridge to eliminate CLI spawning
-import { DirectCallBridge } from '../../../services/direct-call-bridge.js';
-import { SwarmService } from '../../../services/swarm-service.js';
-import { HookService } from '../../../services/hook-service.js';
-console.error('Starting FastMCP Full Server (stdio transport)...');
-console.error('Loading 211+ tools: core (12), agentdb (12), session (8), github (8), neural (6), ruvector (6), sona-rvf (11), infrastructure (13), autopilot (10), performance (15), workflow (11), daa (10), attention (6), hidden-controllers (17), quic (4), rvf (5), cost-optimizer (4), streaming (10), sona-rl (8), memory (6), quantization (8), explainability (10)');
-console.error('SECURITY: Rate limiting enabled (100 req/min default, 10 req/min for critical tools)');
-// Create server
-const server = new FastMCP({
-    name: 'fastmcp-stdio-full',
-    version: '1.0.0'
-});
-// Initialize DirectCallBridge (eliminates CLI spawning anti-pattern)
-let directBridge = null;
-(async () => {
-    try {
-        const agentDB = await AgentDBService.getInstance();
-        const hooks = new HookService(agentDB);
-        const swarm = new SwarmService(hooks, agentDB);
-        directBridge = new DirectCallBridge(agentDB, swarm);
-        console.error('[DirectCallBridge] Initialized (100-200x faster than CLI spawning)');
-    }
-    catch (err) {
-        console.error('[DirectCallBridge] Initialization failed, tools will fall back to CLI:', err);
-    }
-})();
-// SECURITY: Wrap addTool to automatically apply rate limiting to ALL tools
-const originalAddTool = server.addTool.bind(server);
-server.addTool = function (tool) {
-    const wrappedTool = {
-        ...tool,
-        execute: withRateLimit(tool.name, tool.execute)
-    };
-    return originalAddTool(wrappedTool);
-};
-// Tool 1: Memory Store
-server.addTool({
-    name: 'memory_store',
-    description: 'Store a value in persistent memory with optional namespace and TTL',
-    parameters: z.object({
-        key: z.string().min(1).describe('Memory key'),
-        value: z.string().describe('Value to store'),
-        namespace: z.string().optional().default('default').describe('Memory namespace'),
-        ttl: z.number().positive().optional().describe('Time-to-live in seconds')
-    }),
-    execute: async ({ key, value, namespace, ttl }) => {
-        try {
-            const cmd = [
-                'npx claude-flow@alpha memory store',
-                `"${key}"`,
-                `"${value}"`,
-                `--namespace "${namespace}"`,
-                ttl ? `--ttl ${ttl}` : ''
-            ].filter(Boolean).join(' ');
-            const result = execSync(cmd, { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
-            return JSON.stringify({
-                success: true,
-                key,
-                namespace,
-                size: value.length,
-                ttl,
-                timestamp: new Date().toISOString(),
-                message: 'Memory stored successfully'
-            }, null, 2);
-        }
-        catch (error) {
-            throw new Error(`Failed to store memory: ${error.message}`);
-        }
-    }
-});
-// Tool 2: Memory Retrieve
-server.addTool({
-    name: 'memory_retrieve',
-    description: 'Retrieve a value from persistent memory',
-    parameters: z.object({
-        key: z.string().min(1).describe('Memory key'),
-        namespace: z.string().optional().default('default').describe('Memory namespace')
-    }),
-    execute: async ({ key, namespace }) => {
-        try {
-            const cmd = `npx claude-flow@alpha memory retrieve "${key}" --namespace "${namespace}"`;
-            const result = execSync(cmd, { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
-            return JSON.stringify({
-                success: true,
-                key,
-                namespace,
-                value: result.trim(),
-                timestamp: new Date().toISOString()
-            }, null, 2);
-        }
-        catch (error) {
-            throw new Error(`Failed to retrieve memory: ${error.message}`);
-        }
-    }
-});
-// Tool 3: Memory Search
-server.addTool({
-    name: 'memory_search',
-    description: 'Search for keys matching a pattern in memory with wildcard support',
-    parameters: z.object({
-        pattern: z.string().min(1).describe('Search pattern (supports wildcards like * and ?)'),
-        namespace: z.string().optional().describe('Memory namespace to search in (searches all if not specified)'),
-        limit: z.number().positive().optional().default(10).describe('Maximum number of results to return (1-100)')
-            .refine((val) => val >= 1 && val <= 100, { message: 'Limit must be between 1 and 100' })
-    }),
-    execute: async ({ pattern, namespace, limit }) => {
-        try {
-            const cmd = [
-                'npx claude-flow@alpha memory search',
-                `"${pattern}"`,
-                namespace ? `--namespace "${namespace}"` : '',
-                `--limit ${limit}`
-            ].filter(Boolean).join(' ');
-            const result = execSync(cmd, { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
-            return JSON.stringify({
-                success: true,
-                pattern,
-                namespace: namespace || 'all',
-                limit,
-                results: result.trim(),
-                timestamp: new Date().toISOString()
-            }, null, 2);
-        }
-        catch (error) {
-            throw new Error(`Failed to search memory: ${error.message}`);
-        }
-    }
-});
-// Tool: Memory Synthesize - Context synthesis from memory search results
-server.addTool({
-    name: 'memory_synthesize',
-    description: 'Search memory and synthesize a coherent context summary with patterns, insights, and recommendations from retrieved episodes',
-    parameters: z.object({
-        query: z.string().min(1).describe('Search query for finding relevant memories'),
-        limit: z.number().min(1).max(50).optional().default(10).describe('Number of memories to synthesize (1-50)'),
-        namespace: z.string().optional().default('default').describe('Memory namespace to search'),
-        includeRecommendations: z.boolean().optional().default(true).describe('Include actionable recommendations'),
-    }),
-    execute: async ({ query, limit, namespace, includeRecommendations }) => {
-        try {
-            // Step 1: Retrieve episodes from AgentDB
-            const agentDB = await AgentDBService.getInstance();
-            const episodes = await agentDB.recallEpisodes(query, limit);
-            if (episodes.length === 0) {
-                return JSON.stringify({
-                    success: true,
-                    data: {
-                        summary: 'No relevant memories found for the given query.',
-                        patterns: [],
-                        successRate: 0,
-                        averageReward: 0,
-                        recommendations: [],
-                        keyInsights: [],
-                        totalMemories: 0,
-                    },
-                    timestamp: new Date().toISOString(),
-                }, null, 2);
-            }
-            // Step 2: Synthesize using ContextSynthesizer
-            let synthesized;
-            try {
-                const { ContextSynthesizer } = await import(
-                /* webpackIgnore: true */ '../../../../packages/agentdb/dist/src/controllers/ContextSynthesizer.js');
-                synthesized = ContextSynthesizer.synthesize(episodes.map((ep) => ({
-                    task: ep.task,
-                    reward: ep.reward,
-                    success: ep.success,
-                    critique: ep.critique,
-                    input: ep.input,
-                    output: ep.output,
-                    similarity: ep.similarity,
-                })), { includeRecommendations, minPatternFrequency: 2 });
-            }
-            catch {
-                // Fallback: basic synthesis without ContextSynthesizer
-                const successCount = episodes.filter((ep) => ep.success).length;
-                const avgReward = episodes.reduce((sum, ep) => sum + (ep.reward || 0), 0) / episodes.length;
-                synthesized = {
-                    summary: `Found ${episodes.length} relevant memories with ${(successCount / episodes.length * 100).toFixed(0)}% success rate.`,
-                    patterns: [],
-                    successRate: successCount / episodes.length,
-                    averageReward: avgReward,
-                    recommendations: [],
-                    keyInsights: [`${episodes.length} episodes found`, `${successCount} successful`],
-                    totalMemories: episodes.length,
-                };
-            }
-            return JSON.stringify({
-                success: true,
-                data: synthesized,
-                timestamp: new Date().toISOString(),
-            }, null, 2);
-        }
-        catch (error) {
-            return JSON.stringify({
-                success: false,
-                error: error.message,
-                timestamp: new Date().toISOString(),
-            }, null, 2);
-        }
-    }
-});
-// Tool 4: Swarm Init
-server.addTool({
-    name: 'swarm_init',
-    description: 'Initialize a multi-agent swarm with specified topology and strategy',
-    parameters: z.object({
-        topology: z.enum(['mesh', 'hierarchical', 'ring', 'star'])
-            .describe('Swarm topology: mesh (peer-to-peer), hierarchical (tree), ring (circular), star (centralized)'),
-        maxAgents: z.number().positive().optional().default(8).describe('Maximum number of agents in the swarm (1-100)')
-            .refine((val) => val >= 1 && val <= 100, { message: 'maxAgents must be between 1 and 100' }),
-        strategy: z.enum(['balanced', 'specialized', 'adaptive']).optional().default('balanced')
-            .describe('Agent distribution strategy: balanced (equal), specialized (role-based), adaptive (dynamic)')
-    }),
-    execute: async ({ topology, maxAgents, strategy }) => {
-        try {
-            const cmd = `npx claude-flow@alpha swarm init --topology ${topology} --max-agents ${maxAgents} --strategy ${strategy}`;
-            const result = execSync(cmd, { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
-            return JSON.stringify({
-                success: true,
-                topology,
-                maxAgents,
-                strategy,
-                message: 'Swarm initialized successfully',
-                details: result.trim(),
-                timestamp: new Date().toISOString()
-            }, null, 2);
-        }
-        catch (error) {
-            throw new Error(`Failed to initialize swarm: ${error.message}`);
-        }
-    }
-});
-// Tool 5: Agent Spawn
-server.addTool({
-    name: 'agent_spawn',
-    description: 'Spawn a new agent in the swarm with specified type and capabilities',
-    parameters: z.object({
-        type: z.enum(['researcher', 'coder', 'analyst', 'optimizer', 'coordinator'])
-            .describe('Agent type: researcher (data gathering), coder (implementation), analyst (analysis), optimizer (performance), coordinator (orchestration)'),
-        capabilities: z.array(z.string()).optional()
-            .describe('Specific capabilities for the agent (e.g., ["python", "testing", "documentation"])'),
-        name: z.string().optional().describe('Custom agent name/identifier')
-    }),
-    execute: async ({ type, capabilities, name }) => {
-        try {
-            const capStr = capabilities ? ` --capabilities "${capabilities.join(',')}"` : '';
-            const nameStr = name ? ` --name "${name}"` : '';
-            const cmd = `npx claude-flow@alpha agent spawn --type ${type}${capStr}${nameStr}`;
-            const result = execSync(cmd, { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024 });
-            return JSON.stringify({
-                success: true,
-                type,
-                capabilities: capabilities || [],
-                name: name || `${type}-${Date.now()}`,
-                message: 'Agent spawned successfully',
-                details: result.trim(),
-                timestamp: new Date().toISOString()
-            }, null, 2);
-        }
-        catch (error) {
-            throw new Error(`Failed to spawn agent: ${error.message}`);
-        }
-    }
-});
-// Tool 6: Task Orchestrate
-server.addTool({
-    name: 'task_orchestrate',
-    description: 'Orchestrate a complex task across the swarm with specified strategy and priority',
-    parameters: z.object({
-        task: z.string().min(1).describe('Task description or instructions for the swarm to execute'),
-        strategy: z.enum(['parallel', 'sequential', 'adaptive']).optional().default('adaptive')
-            .describe('Execution strategy: parallel (simultaneous), sequential (ordered), adaptive (dynamic based on task)'),
-        priority: z.enum(['low', 'medium', 'high', 'critical']).optional().default('medium')
-            .describe('Task priority level: low, medium, high, or critical'),
-        maxAgents: z.number().positive().optional().describe('Maximum number of agents to use for this task (1-10)')
-            .refine((val) => !val || (val >= 1 && val <= 10), { message: 'maxAgents must be between 1 and 10' })
-    }),
-    execute: async ({ task, strategy, priority, maxAgents }) => {
-        try {
-            const maxStr = maxAgents ? ` --max-agents ${maxAgents}` : '';
-            const cmd = `npx claude-flow@alpha task orchestrate "${task}" --strategy ${strategy} --priority ${priority}${maxStr}`;
-            const result = execSync(cmd, { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024, timeout: 300000 });
-            return JSON.stringify({
-                success: true,
-                task,
-                strategy,
-                priority,
-                maxAgents: maxAgents || 'auto',
-                message: 'Task orchestrated successfully',
-                details: result.trim(),
-                timestamp: new Date().toISOString()
-            }, null, 2);
-        }
-        catch (error) {
-            throw new Error(`Failed to orchestrate task: ${error.message}`);
-        }
-    }
-});
-// Tool 7: Agent Execute
-server.addTool({
-    name: 'agent_execute',
-    description: 'Execute a specific agent with a task (equivalent to --agent CLI command)',
-    parameters: z.object({
-        agent: z.string().describe('Agent name to execute'),
-        task: z.string().describe('Task description'),
-        stream: z.boolean().optional().default(false).describe('Enable streaming output')
-    }),
-    execute: async ({ agent, task, stream }) => {
-        try {
-            const streamFlag = stream ? '--stream' : '';
-            const cmd = `npx agentic-flow --agent "${agent}" --task "${task}" ${streamFlag}`.trim();
-            const result = execSync(cmd, { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024, timeout: 300000 });
-            return JSON.stringify({
-                success: true,
-                agent,
-                task: task.substring(0, 100),
-                output: result,
-                timestamp: new Date().toISOString()
-            }, null, 2);
-        }
-        catch (error) {
-            throw new Error(`Failed to execute agent: ${error.message}`);
-        }
-    }
-});
-// Tool 8: Agent Parallel
-server.addTool({
-    name: 'agent_parallel',
-    description: 'Run parallel mode with 3 agents (research, code review, data analysis)',
-    parameters: z.object({
-        topic: z.string().optional().describe('Research topic'),
-        diff: z.string().optional().describe('Code diff for review'),
-        dataset: z.string().optional().describe('Dataset hint'),
-        streaming: z.boolean().optional().default(false).describe('Enable streaming')
-    }),
-    execute: async ({ topic, diff, dataset, streaming }) => {
-        try {
-            const env = {
-                ...process.env,
-                ...(topic && { TOPIC: topic }),
-                ...(diff && { DIFF: diff }),
-                ...(dataset && { DATASET: dataset }),
-                ...(streaming && { ENABLE_STREAMING: 'true' })
-            };
-            const result = execSync('npx agentic-flow', { encoding: 'utf-8', maxBuffer: 10 * 1024 * 1024, timeout: 300000, env });
-            return JSON.stringify({
-                success: true,
-                mode: 'parallel',
-                agents: ['research', 'code_review', 'data'],
-                output: result,
-                timestamp: new Date().toISOString()
-            }, null, 2);
-        }
-        catch (error) {
-            throw new Error(`Failed to run parallel mode: ${error.message}`);
-        }
-    }
-});
-// Tool 9: Agent List
-server.addTool({
-    name: 'agent_list',
-    description: 'List all available agents',
-    parameters: z.object({
-        format: z.enum(['summary', 'detailed', 'json']).optional().default('summary')
-    }),
-    execute: async ({ format }) => {
-        try {
-            const result = execSync('npx agentic-flow --list', { encoding: 'utf-8', maxBuffer: 5 * 1024 * 1024, timeout: 30000 });
-            if (format === 'detailed') {
-                return result;
-            }
-            const agents = [];
-            const lines = result.split('\n');
-            let currentCategory = '';
-            for (const line of lines) {
-                if (line.includes(':') && line.trim().endsWith(':')) {
-                    currentCategory = line.replace(':', '').trim();
-                }
-                else if (line.trim().startsWith('•') || /^\s{2,}\w/.test(line)) {
-                    const match = line.match(/^\s*[•\s]*(\S+)\s+(.+)$/);
-                    if (match) {
-                        agents.push({ name: match[1], description: match[2].trim(), category: currentCategory });
-                    }
-                }
-            }
-            return JSON.stringify({
-                success: true,
-                count: agents.length,
-                agents,
-                timestamp: new Date().toISOString()
-            }, null, 2);
-        }
-        catch (error) {
-            throw new Error(`Failed to list agents: ${error.message}`);
-        }
-    }
-});
-// Tool 10: Add Custom Agent
-server.addTool({
-    name: 'agent_add',
-    description: 'Add a new custom agent defined in markdown',
-    parameters: z.object({
-        name: z.string().describe('Agent name (kebab-case)'),
-        description: z.string().describe('Agent description'),
-        systemPrompt: z.string().describe('System prompt'),
-        category: z.string().optional().default('custom').describe('Category'),
-        capabilities: z.array(z.string()).optional().describe('Capabilities')
-    }),
-    execute: async ({ name, description, systemPrompt, category, capabilities }) => {
-        try {
-            const { writeFileSync, existsSync, mkdirSync } = await import('fs');
-            const { join } = await import('path');
-            const agentsDir = join(process.cwd(), '.claude', 'agents', category || 'custom');
-            if (!existsSync(agentsDir))
-                mkdirSync(agentsDir, { recursive: true });
-            const markdown = `# ${name.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ')}
-
-## Description
-${description}
-
-## System Prompt
-${systemPrompt}
-
-${capabilities && capabilities.length > 0 ? `## Capabilities\n${capabilities.map(c => `- ${c}`).join('\n')}\n` : ''}
-
-## Usage
-\`\`\`bash
-npx agentic-flow --agent ${name} --task "Your task"
-\`\`\`
-
----
-*Generated: ${new Date().toISOString()}*
-`;
-            const filePath = join(agentsDir, `${name}.md`);
-            if (existsSync(filePath))
-                throw new Error(`Agent '${name}' already exists`);
-            writeFileSync(filePath, markdown, 'utf8');
-            return JSON.stringify({
-                success: true,
-                agent: name,
-                category: category || 'custom',
-                filePath,
-                message: `Agent '${name}' created successfully`,
-                timestamp: new Date().toISOString()
-            }, null, 2);
-        }
-        catch (error) {
-            throw new Error(`Failed to add agent: ${error.message}`);
-        }
-    }
-});
-// Tool 11: Add Custom Command
-server.addTool({
-    name: 'command_add',
-    description: 'Add a new custom command defined in markdown',
-    parameters: z.object({
-        name: z.string().describe('Command name (kebab-case)'),
-        description: z.string().describe('Command description'),
-        usage: z.string().describe('Usage example'),
-        parameters: z.array(z.object({
-            name: z.string(),
-            type: z.string(),
-            required: z.boolean(),
-            description: z.string()
-        })).optional().describe('Parameters'),
-        examples: z.array(z.string()).optional().describe('Examples')
-    }),
-    execute: async ({ name, description, usage, parameters, examples }) => {
-        try {
-            const { writeFileSync, existsSync, mkdirSync } = await import('fs');
-            const { join } = await import('path');
-            const commandsDir = join(process.cwd(), '.claude', 'commands');
-            if (!existsSync(commandsDir))
-                mkdirSync(commandsDir, { recursive: true });
-            const markdown = `# ${name.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ')} Command
-
-## Description
-${description}
-
-## Usage
-\`\`\`bash
-${usage}
-\`\`\`
-
-${parameters && parameters.length > 0 ? `## Parameters\n| Name | Type | Required | Description |\n|------|------|----------|-------------|\n${parameters.map(p => `| \`${p.name}\` | ${p.type} | ${p.required ? 'Yes' : 'No'} | ${p.description} |`).join('\n')}\n` : ''}
-
-${examples && examples.length > 0 ? `## Examples\n\n${examples.map((ex, i) => `### Example ${i + 1}\n\`\`\`bash\n${ex}\n\`\`\`\n`).join('\n')}` : ''}
-
----
-*Generated: ${new Date().toISOString()}*
-`;
-            const filePath = join(commandsDir, `${name}.md`);
-            if (existsSync(filePath))
-                throw new Error(`Command '${name}' already exists`);
-            writeFileSync(filePath, markdown, 'utf8');
-            return JSON.stringify({
-                success: true,
-                command: name,
-                filePath,
-                message: `Command '${name}' created successfully`,
-                timestamp: new Date().toISOString()
-            }, null, 2);
-        }
-        catch (error) {
-            throw new Error(`Failed to add command: ${error.message}`);
-        }
-    }
-});
-// ---------------------------------------------------------------------------
-// AgentDB-powered tools (12 new tools using agentdb-service singleton)
-// ---------------------------------------------------------------------------
-// Tool 12: memory_episode_store
-server.addTool({
-    name: 'memory_episode_store',
-    description: 'Store an agent episode via ReflexionMemory for experience replay',
-    parameters: z.object({
-        sessionId: z.string().min(1).describe('Session identifier'),
-        task: z.string().min(1).describe('Task description'),
-        input: z.string().optional().describe('Input provided to the agent'),
-        output: z.string().optional().describe('Agent output/response'),
-        critique: z.string().optional().describe('Self-critique or reflection'),
-        reward: z.number().min(-1).max(1).describe('Reward signal (-1 to 1)'),
-        success: z.boolean().describe('Whether the episode was successful'),
-        tags: z.array(z.string()).optional().describe('Tags for categorization'),
-    }),
-    execute: async (params) => {
-        try {
-            const svc = await AgentDBService.getInstance();
-            const id = await svc.storeEpisode(params);
-            return JSON.stringify({ success: true, data: { id }, timestamp: new Date().toISOString() }, null, 2);
-        }
-        catch (error) {
-            return JSON.stringify({ success: false, error: error.message, timestamp: new Date().toISOString() }, null, 2);
-        }
-    }
-});
-// Tool 13: memory_episode_recall
-server.addTool({
-    name: 'memory_episode_recall',
-    description: 'Recall similar past episodes using semantic search',
-    parameters: z.object({
-        query: z.string().min(1).describe('Search query describing the task'),
-        limit: z.number().positive().optional().default(5).describe('Max results (1-50)'),
-    }),
-    execute: async ({ query, limit }) => {
-        try {
-            const svc = await AgentDBService.getInstance();
-            const episodes = await svc.recallEpisodes(query, limit);
-            return JSON.stringify({ success: true, data: { episodes, count: episodes.length }, timestamp: new Date().toISOString() }, null, 2);
-        }
-        catch (error) {
-            return JSON.stringify({ success: false, error: error.message, timestamp: new Date().toISOString() }, null, 2);
-        }
-    }
-});
-// Tool 14: skill_publish
-server.addTool({
-    name: 'skill_publish',
-    description: 'Publish a reusable agent skill to the SkillLibrary',
-    parameters: z.object({
-        name: z.string().min(1).describe('Skill name'),
-        description: z.string().optional().describe('Skill description'),
-        code: z.string().optional().describe('Skill implementation code'),
-        successRate: z.number().min(0).max(1).describe('Success rate (0 to 1)'),
-        metadata: z.record(z.unknown()).optional().describe('Additional metadata'),
-    }),
-    execute: async (params) => {
-        try {
-            const svc = await AgentDBService.getInstance();
-            const id = await svc.publishSkill(params);
-            return JSON.stringify({ success: true, data: { id, name: params.name }, timestamp: new Date().toISOString() }, null, 2);
-        }
-        catch (error) {
-            return JSON.stringify({ success: false, error: error.message, timestamp: new Date().toISOString() }, null, 2);
-        }
-    }
-});
-// Tool 15: skill_find
-server.addTool({
-    name: 'skill_find',
-    description: 'Find applicable skills by description via semantic search',
-    parameters: z.object({
-        description: z.string().min(1).describe('Task description to match skills against'),
-        limit: z.number().positive().optional().default(5).describe('Max results'),
-    }),
-    execute: async ({ description, limit }) => {
-        try {
-            const svc = await AgentDBService.getInstance();
-            const skills = await svc.findSkills(description, limit);
-            return JSON.stringify({ success: true, data: { skills, count: skills.length }, timestamp: new Date().toISOString() }, null, 2);
-        }
-        catch (error) {
-            return JSON.stringify({ success: false, error: error.message, timestamp: new Date().toISOString() }, null, 2);
-        }
-    }
-});
-// Tool 16: route_semantic
-server.addTool({
-    name: 'route_semantic',
-    description: 'Route a task to the optimal handler tier using semantic analysis (ADR-026)',
-    parameters: z.object({
-        taskDescription: z.string().min(1).describe('Task description to analyze for routing'),
-    }),
-    execute: async ({ taskDescription }) => {
-        try {
-            const svc = await AgentDBService.getInstance();
-            const route = await svc.routeSemantic(taskDescription);
-            return JSON.stringify({ success: true, data: route, timestamp: new Date().toISOString() }, null, 2);
-        }
-        catch (error) {
-            return JSON.stringify({ success: false, error: error.message, timestamp: new Date().toISOString() }, null, 2);
-        }
-    }
-});
-// Tool 17: route_causal
-server.addTool({
-    name: 'route_causal',
-    description: 'Causal routing via CausalMemoryGraph to find optimal agent path',
-    parameters: z.object({
-        taskType: z.string().min(1).describe('Type of task to route'),
-        agentTypes: z.array(z.string()).min(1).describe('Candidate agent types to consider'),
-    }),
-    execute: async ({ taskType, agentTypes }) => {
-        try {
-            const svc = await AgentDBService.getInstance();
-            const patterns = await svc.searchPatterns(taskType, 10);
-            const ranked = agentTypes.map((agent) => {
-                const matching = patterns.filter((p) => p.approach.toLowerCase().includes(agent.toLowerCase()));
-                const avgSuccess = matching.length > 0
-                    ? matching.reduce((sum, p) => sum + p.successRate, 0) / matching.length
-                    : 0.5;
-                return { agent, score: avgSuccess, matchCount: matching.length };
-            }).sort((a, b) => b.score - a.score);
-            return JSON.stringify({ success: true, data: { taskType, ranked }, timestamp: new Date().toISOString() }, null, 2);
-        }
-        catch (error) {
-            return JSON.stringify({ success: false, error: error.message, timestamp: new Date().toISOString() }, null, 2);
-        }
-    }
-});
-// Tool 18: attention_coordinate
-server.addTool({
-    name: 'attention_coordinate',
-    description: 'Coordinate agents using attention-weighted task assignment',
-    parameters: z.object({
-        agents: z.array(z.string()).min(1).describe('Agent names to coordinate'),
-        task: z.string().min(1).describe('Task to assign'),
-        mechanism: z.enum(['softmax', 'uniform', 'priority']).optional().default('softmax')
-            .describe('Attention mechanism: softmax, uniform, or priority'),
-    }),
-    execute: async ({ agents, task, mechanism }) => {
-        try {
-            const svc = await AgentDBService.getInstance();
-            const skills = await svc.findSkills(task, agents.length);
-            const weights = agents.map((agent, i) => {
-                const skill = skills[i];
-                if (mechanism === 'uniform')
-                    return 1 / agents.length;
-                if (mechanism === 'priority')
-                    return 1 / (i + 1);
-                return skill ? skill.successRate : 1 / agents.length;
-            });
-            const sum = weights.reduce((a, b) => a + b, 0) || 1;
-            const assignments = agents.map((agent, i) => ({
-                agent, weight: weights[i] / sum, task,
-            }));
-            return JSON.stringify({ success: true, data: { mechanism, assignments }, timestamp: new Date().toISOString() }, null, 2);
-        }
-        catch (error) {
-            return JSON.stringify({ success: false, error: error.message, timestamp: new Date().toISOString() }, null, 2);
-        }
-    }
-});
-// Tool 19: graph_query
-server.addTool({
-    name: 'graph_query',
-    description: 'Query the agent knowledge graph',
-    parameters: z.object({
-        query: z.string().min(1).describe('Graph query string (natural language or keyword)'),
-        limit: z.number().positive().optional().default(10).describe('Max results'),
-    }),
-    execute: async ({ query, limit }) => {
-        try {
-            const svc = await AgentDBService.getInstance();
-            const results = await svc.queryGraph(query);
-            return JSON.stringify({ success: true, data: { results: results.slice(0, limit), count: results.length }, timestamp: new Date().toISOString() }, null, 2);
-        }
-        catch (error) {
-            return JSON.stringify({ success: false, error: error.message, timestamp: new Date().toISOString() }, null, 2);
-        }
-    }
-});
-// Tool 20: graph_store
-server.addTool({
-    name: 'graph_store',
-    description: 'Store nodes and edges in the agent knowledge graph',
-    parameters: z.object({
-        nodes: z.array(z.object({
-            id: z.string(), type: z.string(), label: z.string().optional(),
-        })).describe('Graph nodes'),
-        edges: z.array(z.object({
-            from: z.string(), to: z.string(),
-            fromType: z.string().optional(), toType: z.string().optional(),
-            similarity: z.number().optional(), confidence: z.number().optional(),
-        })).describe('Graph edges'),
-    }),
-    execute: async ({ nodes, edges }) => {
-        try {
-            const svc = await AgentDBService.getInstance();
-            await svc.storeGraphState(nodes, edges);
-            return JSON.stringify({ success: true, data: { nodesStored: nodes.length, edgesStored: edges.length }, timestamp: new Date().toISOString() }, null, 2);
-        }
-        catch (error) {
-            return JSON.stringify({ success: false, error: error.message, timestamp: new Date().toISOString() }, null, 2);
-        }
-    }
-});
-// Tool 21: learning_trajectory
-server.addTool({
-    name: 'learning_trajectory',
-    description: 'Record a learning trajectory (state-action-reward sequence)',
-    parameters: z.object({
-        steps: z.array(z.object({
-            state: z.string(), action: z.string(), reward: z.number(),
-            nextState: z.string().optional(),
-        })).min(1).describe('Trajectory steps'),
-        reward: z.number().describe('Total trajectory reward'),
-    }),
-    execute: async ({ steps, reward }) => {
-        try {
-            const svc = await AgentDBService.getInstance();
-            await svc.recordTrajectory(steps, reward);
-            return JSON.stringify({ success: true, data: { stepsRecorded: steps.length, totalReward: reward }, timestamp: new Date().toISOString() }, null, 2);
-        }
-        catch (error) {
-            return JSON.stringify({ success: false, error: error.message, timestamp: new Date().toISOString() }, null, 2);
-        }
-    }
-});
-// Tool 22: learning_predict
-server.addTool({
-    name: 'learning_predict',
-    description: 'Predict the optimal action for a given state using learned policy',
-    parameters: z.object({
-        state: z.string().min(1).describe('Current state description'),
-    }),
-    execute: async ({ state }) => {
-        try {
-            const svc = await AgentDBService.getInstance();
-            const prediction = await svc.predictAction(state);
-            return JSON.stringify({ success: true, data: prediction, timestamp: new Date().toISOString() }, null, 2);
-        }
-        catch (error) {
-            return JSON.stringify({ success: false, error: error.message, timestamp: new Date().toISOString() }, null, 2);
-        }
-    }
-});
-// Tool 23: explain_decision
-server.addTool({
-    name: 'explain_decision',
-    description: 'Get an explainable Merkle proof for a recall decision',
-    parameters: z.object({
-        decisionId: z.string().min(1).describe('Decision/query ID to explain'),
-    }),
-    execute: async ({ decisionId }) => {
-        try {
-            const svc = await AgentDBService.getInstance();
-            const explanation = await svc.explainDecision(decisionId);
-            return JSON.stringify({ success: true, data: explanation, timestamp: new Date().toISOString() }, null, 2);
-        }
-        catch (error) {
-            return JSON.stringify({ success: false, error: error.message, timestamp: new Date().toISOString() }, null, 2);
-        }
-    }
-});
-// Register modular tool sets (120+ additional tools)
-// Note: Infrastructure and Workflow tools will use DirectCallBridge when available
-registerSessionTools(server); // 8 tools
-registerGitHubTools(server); // 8 tools
-registerNeuralTools(server); // 6 tools
-registerRuVectorTools(server); // 6 tools
-registerSonaRvfTools(server); // 11 tools
-registerInfrastructureTools(server, () => directBridge); // 13 tools (DirectCallBridge-enabled)
-registerAutopilotTools(server); // 10 tools
-registerPerformanceTools(server); // 15 tools
-registerWorkflowTools(server, () => directBridge); // 11 tools (DirectCallBridge-enabled)
-registerDAATools(server); // 10 tools
-registerAttentionTools(server); // 3 tools
-registerHiddenControllerTools(server); // 17 tools (8 controllers)
-registerQUICTools(server); // 7 tools (QUIC protocol: sync, latency, health, pool, 0rtt, multiplex)
-registerRVFTools(server); // 5 tools (RVF optimizer - ADR-063)
-registerCostOptimizerTools(server); // 4 tools (Cost optimizer - ADR-064)
-registerStreamingTools(server); // 10 tools (Streaming architecture - ADR-065 P1-3)
-registerSonaTools(server); // 8 tools (SONA RL Loop - ADR-065 P1-2)
-registerMemoryTools(server); // 6 tools (Hierarchical Memory - ADR-066 P2-3)
-registerQuantizationTools(server); // 8 tools (Model Quantization - ADR-066 P2-2)
-registerExplainabilityTools(server); // 10 tools (Explainability Dashboard - ADR-066 P2-4)
-console.error('Registered 208+ tools successfully');
-console.error('Starting stdio transport...');
-// Start with stdio transport
-server.start({ transportType: 'stdio' }).then(() => {
-    console.error('FastMCP Full Server running on stdio');
-}).catch((error) => {
-    console.error('Failed to start server:', error);
-    process.exit(1);
-});
-//# sourceMappingURL=stdio-full.js.map