@equilateral_ai/mindmeld 3.3.0 → 3.4.0

package/src/handlers/mcp/mcpHandler.js

@@ -0,0 +1,569 @@
+/**
+ * JARVIS MCP Server - Lambda Handler
+ *
+ * Implements MCP (Model Context Protocol) JSON-RPC directly over HTTP.
+ * No SDK transport layer needed — Lambda's request/response model maps
+ * cleanly to stateless JSON-RPC.
+ *
+ * POST /mcp - JSON-RPC messages (initialize, tools/list, tools/call, etc.)
+ * GET  /mcp - 405 (SSE not supported in stateless Lambda)
+ * DELETE /mcp - 200 (no-op session close)
+ */
+
+const { executeQuery } = require('./dbOperations');
+
+const SERVER_INFO = {
+    name: 'jarvis-mcp',
+    version: '1.0.0'
+};
+
+const PROTOCOL_VERSION = '2025-03-26';
+
+const CORS_HEADERS = {
+    'Access-Control-Allow-Origin': '*',
+    'Access-Control-Allow-Methods': 'POST, GET, DELETE, OPTIONS',
+    'Access-Control-Allow-Headers': 'Content-Type, Accept, Mcp-Session-Id',
+};
+
+// ============================================================
+// Tool Definitions
+// ============================================================
+
+const TOOLS = [
+    {
+        name: 'list_agents',
+        description: 'Discover active agents in the JARVIS mesh and their capabilities, success rates, and circuit breaker status',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                capability: { type: 'string', description: 'Filter by capability (optional)' }
+            }
+        }
+    },
+    {
+        name: 'dispatch_task',
+        description: 'Dispatch a task to the JARVIS orchestration engine for routing to the best agent',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                description: { type: 'string', description: 'Natural language task description' },
+                parameters: { type: 'object', description: 'Task parameters (optional)' },
+                constraints: { type: 'object', description: 'Constraints: minSuccessRate, maxCost, maxDuration (optional)' }
+            },
+            required: ['description']
+        }
+    },
+    {
+        name: 'query_decision_frames',
+        description: 'Query governance decision frames - the audit trail of every agent routing decision with full reasoning context',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                limit: { type: 'number', description: 'Max results (default 20, max 100)' },
+                agentName: { type: 'string', description: 'Filter by agent name (optional)' },
+                timeWindow: { type: 'string', description: 'Time window: 1d, 7d, 30d, 90d (default 7d)' }
+            }
+        }
+    },
+    {
+        name: 'get_standards',
+        description: 'Search the Equilateral standards library for relevant rules, anti-patterns, and examples',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                context: { type: 'string', description: 'Search context (e.g., "Lambda database", "CORS", "cost optimization")' },
+                topK: { type: 'number', description: 'Number of results (default 5, max 20)' }
+            },
+            required: ['context']
+        }
+    },
+    {
+        name: 'get_rapport_context',
+        description: 'Get Rapport invariants, purpose, notes, and active loops for a scope. These are the structural patterns that shape how agents interact.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                scope: { type: 'string', description: 'Scope name (default: jarvis)' }
+            }
+        }
+    },
+    {
+        name: 'get_mesh_status',
+        description: 'Get aggregate health status of the JARVIS agent mesh: active/inactive agents, circuit breaker states, success rates',
+        inputSchema: { type: 'object', properties: {} }
+    },
+    {
+        name: 'get_agent_stats',
+        description: 'Get detailed performance statistics for a specific agent: success rate, duration, cost, recent executions',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentName: { type: 'string', description: 'Name of the agent' },
+                timeWindow: { type: 'string', description: 'Time window: 1d, 7d, 30d, 90d (default 7d)' }
+            },
+            required: ['agentName']
+        }
+    }
+];
+
+// ============================================================
+// Resource Definitions
+// ============================================================
+
+const RESOURCES = [
+    { uri: 'agent://registry', name: 'Agent Registry', description: 'Complete JARVIS agent registry with capabilities and health status', mimeType: 'application/json' },
+    { uri: 'decision://frames/recent', name: 'Decision Frames', description: 'Recent governance decision frames with audit trail', mimeType: 'application/json' },
+    { uri: 'standards://library', name: 'Standards Library', description: 'Equilateral AI standards library - rules and anti-patterns', mimeType: 'application/json' },
+    { uri: 'rapport://invariants/jarvis', name: 'Rapport Invariants', description: 'Rapport structural invariants for the jarvis scope', mimeType: 'application/json' },
+    { uri: 'workflow://active', name: 'Active Workflows', description: 'Currently active agent workflows', mimeType: 'application/json' }
+];
+
+// ============================================================
+// Tool Implementations
+// ============================================================
+
+async function callTool(name, args = {}) {
+    switch (name) {
+        case 'list_agents': {
+            try {
+                let query = `
+                    SELECT agent_name, agent_type, capabilities, tools, status,
+                           circuit_breaker_status, success_rate, total_executions
+                    FROM agent_orchestration.agent_registry
+                    WHERE status = 'active'
+                `;
+                const params = [];
+                if (args.capability) {
+                    query += ` AND $1 = ANY(capabilities)`;
+                    params.push(args.capability);
+                }
+                query += ` ORDER BY success_rate DESC, total_executions DESC`;
+                const result = await executeQuery(query, params);
+                return { content: [{ type: 'text', text: JSON.stringify({ agents: result.rows, count: result.rows.length }, null, 2) }] };
+            } catch (e) {
+                if (e.message.includes('does not exist')) {
+                    return { content: [{ type: 'text', text: 'Agent orchestration schema not available in this database. The agent_orchestration schema is on the JARVIS Mac Mini database. Use get_rapport_context or get_standards for data available in this environment.' }] };
+                }
+                throw e;
+            }
+        }
+
+        case 'dispatch_task': {
+            try {
+                const result = await executeQuery(`
+                    INSERT INTO agent_orchestration.agent_routing_log
+                        (task_description, task_parameters, constraints, status, created_at)
+                    VALUES ($1, $2, $3, 'pending', NOW())
+                    RETURNING routing_id, status, created_at
+                `, [args.description, JSON.stringify(args.parameters || {}), JSON.stringify(args.constraints || {})]);
+                return {
+                    content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            dispatched: true,
+                            routing_id: result.rows[0].routing_id,
+                            status: result.rows[0].status,
+                            message: `Task dispatched: "${args.description}"`
+                        }, null, 2)
+                    }]
+                };
+            } catch (e) {
+                if (e.message.includes('does not exist')) {
+                    return { content: [{ type: 'text', text: 'Agent orchestration schema not available in this database. Task dispatch requires the JARVIS Mac Mini environment.' }] };
+                }
+                throw e;
+            }
+        }
+
+        case 'query_decision_frames': {
+            try {
+                const effectiveLimit = Math.min(parseInt(args.limit) || 20, 100);
+                const validWindows = { '1d': '1 day', '7d': '7 days', '30d': '30 days', '90d': '90 days' };
+                const effectiveWindow = validWindows[args.timeWindow] || '7 days';
+                const params = [effectiveWindow];
+                let query = `
+                    SELECT frame_id, agent_name, decision_type, reasoning,
+                           governance_context, outcome, created_at
+                    FROM agent_orchestration.decision_frames
+                    WHERE created_at > NOW() - $1::interval
+                `;
+                if (args.agentName) {
+                    params.push(args.agentName);
+                    query += ` AND agent_name = $${params.length}`;
+                }
+                params.push(effectiveLimit);
+                query += ` ORDER BY created_at DESC LIMIT $${params.length}`;
+                const result = await executeQuery(query, params);
+                return { content: [{ type: 'text', text: JSON.stringify({ frames: result.rows, count: result.rows.length }, null, 2) }] };
+            } catch (e) {
+                if (e.message.includes('does not exist')) {
+                    return { content: [{ type: 'text', text: 'Decision frames schema not available in this database. Governance audit trails are on the JARVIS Mac Mini environment.' }] };
+                }
+                throw e;
+            }
+        }
+
+        case 'get_standards': {
+            const k = Math.min(args.topK || 5, 20);
+            // Split search into individual words for AND matching
+            const words = args.context.split(/\s+/).filter(w => w.length > 1);
+            const searchFields = `COALESCE(rule,'') || ' ' || COALESCE(category,'') || ' ' || COALESCE(element,'') || ' ' || COALESCE(title,'') || ' ' || COALESCE(keywords::text,'')`;
+            const conditions = words.map((_, i) => `(${searchFields}) ILIKE $${i + 1}`);
+            const params = words.map(w => `%${w}%`);
+            params.push(k);
+            const result = await executeQuery(`
+                SELECT pattern_id, element, title, rule, category,
+                       keywords, anti_patterns, examples, cost_impact,
+                       maturity, correlation
+                FROM rapport.standards_patterns
+                WHERE ${conditions.join(' AND ')}
+                ORDER BY
+                    CASE WHEN maturity = 'enforced' THEN 1
+                         WHEN maturity = 'validated' THEN 2
+                         ELSE 3 END,
+                    correlation DESC
+                LIMIT $${params.length}
+            `, params);
+            return { content: [{ type: 'text', text: JSON.stringify({ standards: result.rows, count: result.rows.length }, null, 2) }] };
+        }
+
+        case 'get_rapport_context': {
+            const scope = args.scope || 'jarvis';
+            const result = await executeQuery(
+                `SELECT rapport.get_user_context($1, $2) as context`,
+                [process.env.MCP_DEFAULT_USER || 'james.ford@happyhippo.ai', scope]
+            );
+            const context = result.rows[0]?.context || {
+                invariants: { agent_level: [], relationship_level: [] },
+                purpose: null, recent_notes: [], active_loops: []
+            };
+            return { content: [{ type: 'text', text: JSON.stringify({ scope, ...context }, null, 2) }] };
+        }
+
+        case 'get_mesh_status': {
+            try {
+                const result = await executeQuery(`
+                    SELECT
+                        COUNT(*) FILTER (WHERE status = 'active') as active_agents,
+                        COUNT(*) FILTER (WHERE status = 'inactive') as inactive_agents,
+                        COUNT(*) FILTER (WHERE circuit_breaker_status = 'open') as circuit_breakers_open,
+                        AVG(success_rate) FILTER (WHERE status = 'active') as avg_success_rate,
+                        SUM(total_executions) as total_executions
+                    FROM agent_orchestration.agent_registry
+                `);
+                const mesh = result.rows[0];
+                return {
+                    content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            mesh: {
+                                active_agents: parseInt(mesh.active_agents) || 0,
+                                inactive_agents: parseInt(mesh.inactive_agents) || 0,
+                                circuit_breakers_open: parseInt(mesh.circuit_breakers_open) || 0,
+                                avg_success_rate: parseFloat(mesh.avg_success_rate) || 0,
+                                total_executions: parseInt(mesh.total_executions) || 0,
+                                status: parseInt(mesh.circuit_breakers_open) > 0 ? 'degraded' : 'healthy',
+                                timestamp: new Date().toISOString()
+                            }
+                        }, null, 2)
+                    }]
+                };
+            } catch (e) {
+                if (e.message.includes('does not exist')) {
+                    return { content: [{ type: 'text', text: 'Agent mesh schema not available in this database. Mesh status is on the JARVIS Mac Mini environment.' }] };
+                }
+                throw e;
+            }
+        }
+
+        case 'get_agent_stats': {
+            try {
+                const validWindows = { '1d': '1 day', '7d': '7 days', '30d': '30 days', '90d': '90 days' };
+                const effectiveWindow = validWindows[args.timeWindow] || '7 days';
+                const agentResult = await executeQuery(`
+                    SELECT agent_name, agent_type, total_executions, total_successes,
+                           total_failures, success_rate, avg_duration_ms, avg_cost_usd,
+                           circuit_breaker_status
+                    FROM agent_orchestration.agent_registry
+                    WHERE agent_name = $1
+                `, [args.agentName]);
+                if (agentResult.rows.length === 0) {
+                    return { content: [{ type: 'text', text: JSON.stringify({ error: `Agent '${args.agentName}' not found` }) }], isError: true };
+                }
+                const executionsResult = await executeQuery(`
+                    SELECT status, duration_ms, cost_usd, execution_timestamp
+                    FROM agent_orchestration.agent_executions
+                    WHERE agent_name = $1
+                      AND execution_timestamp > NOW() - $2::interval
+                    ORDER BY execution_timestamp DESC
+                    LIMIT 50
+                `, [args.agentName, effectiveWindow]);
+            return {
+                content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        agent: agentResult.rows[0],
+                        recent_executions: executionsResult.rows.length,
+                        executions: executionsResult.rows
+                    }, null, 2)
+                }]
+            };
+            } catch (e) {
+                if (e.message.includes('does not exist')) {
+                    return { content: [{ type: 'text', text: 'Agent stats schema not available in this database. Agent performance data is on the JARVIS Mac Mini environment.' }] };
+                }
+                throw e;
+            }
+        }
+
+        default:
+            throw new Error(`Unknown tool: ${name}`);
+    }
+}
+
+// ============================================================
+// Resource Implementations
+// ============================================================
+
+async function readResource(uri) {
+    try {
+        switch (uri) {
+            case 'agent://registry': {
+                const result = await executeQuery(`
+                    SELECT agent_name, agent_type, capabilities, status,
+                           circuit_breaker_status, success_rate
+                    FROM agent_orchestration.agent_registry ORDER BY agent_name
+                `);
+                return { contents: [{ uri, text: JSON.stringify(result.rows, null, 2), mimeType: 'application/json' }] };
+            }
+            case 'decision://frames/recent': {
+                const result = await executeQuery(`
+                    SELECT frame_id, agent_name, decision_type, reasoning, outcome, created_at
+                    FROM agent_orchestration.decision_frames
+                    ORDER BY created_at DESC LIMIT 20
+                `);
+                return { contents: [{ uri, text: JSON.stringify(result.rows, null, 2), mimeType: 'application/json' }] };
+            }
+            case 'standards://library': {
+                const result = await executeQuery(`
+                    SELECT pattern_id, element, title, rule, category, maturity, correlation
+                    FROM rapport.standards_patterns
+                    WHERE maturity IN ('enforced', 'validated', 'recommended')
+                    ORDER BY category, correlation DESC
+                `);
+                return { contents: [{ uri, text: JSON.stringify(result.rows, null, 2), mimeType: 'application/json' }] };
+            }
+            case 'rapport://invariants/jarvis': {
+                const result = await executeQuery(
+                    `SELECT rapport.get_user_context($1, $2) as context`,
+                    [process.env.MCP_DEFAULT_USER || 'james.ford@happyhippo.ai', 'jarvis']
+                );
+                const context = result.rows[0]?.context || { invariants: {} };
+                return { contents: [{ uri, text: JSON.stringify(context, null, 2), mimeType: 'application/json' }] };
+            }
+            case 'workflow://active': {
+                const result = await executeQuery(`
+                    SELECT workflow_name, status, workflow_config, created_at
+                    FROM agent_orchestration.agent_workflows
+                    WHERE status = 'active' ORDER BY created_at DESC
+                `);
+                return { contents: [{ uri, text: JSON.stringify(result.rows, null, 2), mimeType: 'application/json' }] };
+            }
+            default:
+                throw new Error(`Unknown resource: ${uri}`);
+        }
+    } catch (e) {
+        if (e.message.includes('does not exist')) {
+            return { contents: [{ uri, text: JSON.stringify({ error: 'Schema not available in this database environment' }), mimeType: 'application/json' }] };
+        }
+        throw e;
+    }
+}
+
+// ============================================================
+// JSON-RPC Message Router
+// ============================================================
+
+async function handleJsonRpc(message) {
+    const { method, params, id } = message;
+
+    switch (method) {
+        case 'initialize':
+            return {
+                jsonrpc: '2.0',
+                id,
+                result: {
+                    protocolVersion: PROTOCOL_VERSION,
+                    capabilities: {
+                        tools: { listChanged: false },
+                        resources: { subscribe: false, listChanged: false }
+                    },
+                    serverInfo: SERVER_INFO
+                }
+            };
+
+        case 'notifications/initialized':
+            // Client acknowledgment — no response needed for notifications
+            return null;
+
+        case 'ping':
+            return { jsonrpc: '2.0', id, result: {} };
+
+        case 'tools/list':
+            return {
+                jsonrpc: '2.0',
+                id,
+                result: { tools: TOOLS }
+            };
+
+        case 'tools/call': {
+            const { name, arguments: args } = params;
+            try {
+                const result = await callTool(name, args || {});
+                return { jsonrpc: '2.0', id, result };
+            } catch (error) {
+                return {
+                    jsonrpc: '2.0',
+                    id,
+                    result: {
+                        content: [{ type: 'text', text: JSON.stringify({ error: error.message }) }],
+                        isError: true
+                    }
+                };
+            }
+        }
+
+        case 'resources/list':
+            return {
+                jsonrpc: '2.0',
+                id,
+                result: { resources: RESOURCES }
+            };
+
+        case 'resources/read': {
+            const { uri } = params;
+            try {
+                const result = await readResource(uri);
+                return { jsonrpc: '2.0', id, result };
+            } catch (error) {
+                return {
+                    jsonrpc: '2.0',
+                    id,
+                    error: { code: -32602, message: error.message }
+                };
+            }
+        }
+
+        default:
+            return {
+                jsonrpc: '2.0',
+                id,
+                error: { code: -32601, message: `Method not found: ${method}` }
+            };
+    }
+}
+
+// ============================================================
+// Lambda Handler
+// ============================================================
+
+exports.handler = async (event) => {
+    const method = event.httpMethod;
+
+    // CORS preflight
+    if (method === 'OPTIONS') {
+        return {
+            statusCode: 200,
+            headers: { ...CORS_HEADERS, 'Access-Control-Max-Age': '86400' },
+            body: ''
+        };
+    }
+
+    // GET - SSE not supported in stateless Lambda
+    if (method === 'GET') {
+        return {
+            statusCode: 405,
+            headers: { ...CORS_HEADERS, 'Content-Type': 'application/json', Allow: 'POST, DELETE, OPTIONS' },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                error: { code: -32000, message: 'SSE streaming not supported. Use POST for JSON-RPC requests.' },
+                id: null
+            })
+        };
+    }
+
+    // DELETE - Session close (no-op in stateless mode)
+    if (method === 'DELETE') {
+        return {
+            statusCode: 200,
+            headers: { ...CORS_HEADERS, 'Content-Type': 'application/json' },
+            body: ''
+        };
+    }
+
+    // POST - JSON-RPC message processing
+    if (method !== 'POST') {
+        return {
+            statusCode: 405,
+            headers: { ...CORS_HEADERS, 'Content-Type': 'application/json', Allow: 'POST, GET, DELETE, OPTIONS' },
+            body: JSON.stringify({ jsonrpc: '2.0', error: { code: -32000, message: 'Method not allowed' }, id: null })
+        };
+    }
+
+    try {
+        let body;
+        try {
+            body = typeof event.body === 'string' ? JSON.parse(event.body) : event.body;
+        } catch (e) {
+            return {
+                statusCode: 400,
+                headers: { ...CORS_HEADERS, 'Content-Type': 'application/json' },
+                body: JSON.stringify({ jsonrpc: '2.0', error: { code: -32700, message: 'Parse error: invalid JSON' }, id: null })
+            };
+        }
+
+        // Handle batch requests
+        if (Array.isArray(body)) {
+            const responses = [];
+            for (const msg of body) {
+                const response = await handleJsonRpc(msg);
+                if (response) responses.push(response);
+            }
+            return {
+                statusCode: responses.length > 0 ? 200 : 202,
+                headers: { ...CORS_HEADERS, 'Content-Type': 'application/json' },
+                body: responses.length > 0 ? JSON.stringify(responses) : ''
+            };
+        }
+
+        // Handle single request
+        const response = await handleJsonRpc(body);
+
+        // Notifications don't get responses
+        if (!response) {
+            return {
+                statusCode: 202,
+                headers: { ...CORS_HEADERS, 'Content-Type': 'application/json' },
+                body: ''
+            };
+        }
+
+        return {
+            statusCode: 200,
+            headers: { ...CORS_HEADERS, 'Content-Type': 'application/json' },
+            body: JSON.stringify(response)
+        };
+
+    } catch (error) {
+        console.error('MCP handler error:', error);
+        return {
+            statusCode: 500,
+            headers: { ...CORS_HEADERS, 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                error: { code: -32603, message: 'Internal server error' },
+                id: null
+            })
+        };
+    }
+};