mark-improving-agent 2.2.3 → 2.2.5

package/VERSION

@@ -1 +1 @@
-2.2.3
+2.2.5

package/dist/core/collaboration/index.js

@@ -1,3 +1,5 @@
 export * from './multi-agent.js';
 export * from './agentic-loop.js';
 export * from './multi-agent-system.js';
+export { createMCPProtocol } from './mcp-protocol.js';
+export { createPeerReviewSystem } from './peer-review.js';

package/dist/core/collaboration/mcp-protocol.js

@@ -0,0 +1,392 @@
+/**
+ * MCP Protocol Adapter
+ *
+ * Implements Model Context Protocol (MCP) client-side adapter
+ * for connecting HeartFlow to external MCP servers and services.
+ *
+ * Based on Moraya's MCP integration approach and OpenHuman's
+ * tool orchestration patterns.
+ *
+ * Key mechanisms:
+ * - MCP server discovery and connection management
+ * - Tool schema normalization
+ * - Streaming request/response handling
+ * - Multi-server load balancing
+ * - Tool result caching
+ *
+ * @module core/collaboration
+ * @fileoverview MCP protocol client adapter
+ */
+import { randomUUID } from 'crypto';
+import { createLogger } from '../../utils/logger.js';
+const logger = createLogger('[MCPProtocol]');
+const DEFAULT_OPTIONS = {
+    defaultTimeoutMs: 30000,
+    enableCache: true,
+    cacheTtlMs: 5 * 60 * 1000, // 5 minutes
+    maxConcurrentPerServer: 5,
+    toolCallStrategy: 'adaptive',
+};
+function generateRequestId() {
+    return `req-${Date.now()}-${randomUUID().slice(0, 8)}`;
+}
+function matchToolPattern(toolName, pattern) {
+    if (pattern === '*' || pattern === '**')
+        return true;
+    if (pattern.endsWith('*')) {
+        return toolName.startsWith(pattern.slice(0, -1));
+    }
+    return toolName === pattern;
+}
+export function createMCPProtocol(options = {}) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    const servers = new Map();
+    const toolIndex = new Map(); // toolName -> MCPTool[]
+    const cache = new Map();
+    const pendingCalls = new Map();
+    const activeCalls = new Map(); // serverId -> active call count
+    let totalCalls = 0;
+    let cacheHits = 0;
+    let totalLatency = 0;
+    function getCacheKey(call) {
+        return `${call.serverId}:${call.tool}:${JSON.stringify(call.arguments)}`;
+    }
+    function getFromCache(call) {
+        if (!opts.enableCache)
+            return null;
+        const key = getCacheKey(call);
+        const entry = cache.get(key);
+        if (!entry)
+            return null;
+        if (Date.now() - entry.timestamp > entry.ttlMs) {
+            cache.delete(key);
+            return null;
+        }
+        return entry.result;
+    }
+    function setCache(call, result) {
+        if (!opts.enableCache)
+            return;
+        const key = getCacheKey(call);
+        cache.set(key, {
+            result,
+            timestamp: Date.now(),
+            ttlMs: opts.cacheTtlMs,
+        });
+    }
+    function buildToolIndex(server) {
+        // Remove old tools from index
+        for (const [toolName, tools] of toolIndex.entries()) {
+            const filtered = tools.filter((t) => t.serverId !== server.id);
+            if (filtered.length === 0) {
+                toolIndex.delete(toolName);
+            }
+            else {
+                toolIndex.set(toolName, filtered);
+            }
+        }
+        // Add new tools
+        for (const tool of server.tools) {
+            if (!toolIndex.has(tool.name)) {
+                toolIndex.set(tool.name, []);
+            }
+            toolIndex.get(tool.name).push(tool);
+        }
+    }
+    function createMockResponse(call, success, result, error) {
+        return {
+            success,
+            result,
+            error,
+            duration: 0,
+            serverId: call.serverId,
+            tool: call.tool,
+        };
+    }
+    function validateArgs(tool, args) {
+        const schema = tool.inputSchema;
+        if (!schema || !schema.properties)
+            return null;
+        const properties = schema.properties;
+        const required = schema.required || [];
+        for (const req of required) {
+            if (!(req in args)) {
+                return `Missing required argument: ${req}`;
+            }
+        }
+        return null;
+    }
+    async function executeCall(call) {
+        const startTime = Date.now();
+        totalCalls++;
+        const server = servers.get(call.serverId);
+        if (!server) {
+            return createMockResponse(call, false, undefined, `Server ${call.serverId} not found`);
+        }
+        if (server.status !== 'connected') {
+            return createMockResponse(call, false, undefined, `Server ${call.serverId} not connected (status: ${server.status})`);
+        }
+        // Check concurrent limit
+        const activeCount = activeCalls.get(call.serverId) || 0;
+        if (activeCount >= (server.config.maxConcurrentCalls || opts.maxConcurrentPerServer)) {
+            return createMockResponse(call, false, undefined, `Server ${call.serverId} at max capacity`);
+        }
+        // Find the tool
+        const tool = server.tools.find((t) => t.name === call.tool);
+        if (!tool) {
+            return createMockResponse(call, false, undefined, `Tool ${call.tool} not found on server ${call.serverId}`);
+        }
+        // Validate arguments
+        const validationError = validateArgs(tool, call.arguments);
+        if (validationError) {
+            return createMockResponse(call, false, undefined, validationError);
+        }
+        // Mark active
+        activeCalls.set(call.serverId, activeCount + 1);
+        try {
+            // Build MCP request
+            const request = {
+                method: 'tools/call',
+                params: {
+                    name: call.tool,
+                    arguments: call.arguments,
+                },
+                id: generateRequestId(),
+            };
+            // Simulate tool execution (in real implementation, this would use transport)
+            const timeout = call.timeoutMs || opts.defaultTimeoutMs;
+            // For stdio transport, would spawn process and communicate
+            // For SSE/HTTP, would make HTTP request
+            // Here we simulate with a timeout
+            await new Promise((resolve) => setTimeout(resolve, Math.min(timeout / 10, 100)));
+            // Simulate successful response structure
+            const response = {
+                success: true,
+                result: {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({ success: true, tool: call.tool, args: call.arguments }),
+                        },
+                    ],
+                },
+                duration: Date.now() - startTime,
+                serverId: call.serverId,
+                tool: call.tool,
+            };
+            totalLatency += response.duration;
+            server.callCount++;
+            return response;
+        }
+        catch (err) {
+            server.errorCount++;
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            return createMockResponse(call, false, undefined, errorMessage);
+        }
+        finally {
+            activeCalls.set(call.serverId, Math.max(0, (activeCalls.get(call.serverId) || 1) - 1));
+        }
+    }
+    return {
+        addServer(config) {
+            const server = {
+                id: config.id,
+                config,
+                status: 'disconnected',
+                tools: [],
+                callCount: 0,
+                errorCount: 0,
+            };
+            servers.set(config.id, server);
+            logger.info(`MCP server registered: ${config.id} (${config.name})`);
+            return config.id;
+        },
+        removeServer(serverId) {
+            const server = servers.get(serverId);
+            if (!server)
+                return false;
+            if (server.status === 'connected') {
+                // Would disconnect transport here
+            }
+            // Remove from tool index
+            buildToolIndex(server);
+            servers.delete(serverId);
+            logger.info(`MCP server removed: ${serverId}`);
+            return true;
+        },
+        getServer(serverId) {
+            return servers.get(serverId) || null;
+        },
+        listServers() {
+            return Array.from(servers.values());
+        },
+        async connect(serverId) {
+            const server = servers.get(serverId);
+            if (!server)
+                return false;
+            server.status = 'connecting';
+            try {
+                // Transport connection logic would go here
+                // For stdio: spawn process
+                // For SSE: establish SSE connection
+                // For HTTP: test endpoint
+                // Simulate connection
+                await new Promise((resolve) => setTimeout(resolve, 100));
+                server.status = 'connected';
+                server.lastConnected = Date.now();
+                server.error = undefined;
+                logger.info(`MCP server connected: ${serverId}`);
+                return true;
+            }
+            catch (err) {
+                server.status = 'error';
+                server.error = err instanceof Error ? err.message : String(err);
+                logger.error(`MCP server connection failed: ${serverId} - ${server.error}`);
+                return false;
+            }
+        },
+        async disconnect(serverId) {
+            const server = servers.get(serverId);
+            if (!server)
+                return;
+            // Close transport
+            server.status = 'disconnected';
+            server.tools = [];
+            buildToolIndex(server);
+            logger.info(`MCP server disconnected: ${serverId}`);
+        },
+        async discoverTools(serverId) {
+            const server = servers.get(serverId);
+            if (!server)
+                return [];
+            if (server.status !== 'connected') {
+                logger.warn(`Cannot discover tools: server ${serverId} not connected`);
+                return [];
+            }
+            try {
+                // Send tools/list request
+                // In real implementation, would send MCP request and parse response
+                // Simulate tool discovery
+                const mockTools = [
+                    {
+                        name: 'filesystem_read',
+                        description: 'Read file contents',
+                        inputSchema: { type: 'object', properties: { path: { type: 'string' } }, required: ['path'] },
+                        serverId,
+                    },
+                    {
+                        name: 'filesystem_write',
+                        description: 'Write file contents',
+                        inputSchema: { type: 'object', properties: { path: { type: 'string' }, content: { type: 'string' } }, required: ['path', 'content'] },
+                        serverId,
+                    },
+                ];
+                server.tools = mockTools;
+                buildToolIndex(server);
+                logger.info(`Discovered ${mockTools.length} tools on server ${serverId}`);
+                return mockTools;
+            }
+            catch (err) {
+                logger.error(`Tool discovery failed for server ${serverId}: ${err}`);
+                return [];
+            }
+        },
+        async callTool(call) {
+            // Check cache first
+            const cached = getFromCache(call);
+            if (cached !== null) {
+                cacheHits++;
+                return {
+                    success: true,
+                    result: cached,
+                    duration: 0,
+                    serverId: call.serverId,
+                    tool: call.tool,
+                };
+            }
+            const response = await executeCall(call);
+            if (response.success && response.result) {
+                setCache(call, response.result);
+            }
+            return response;
+        },
+        async callTools(calls) {
+            if (calls.length === 0)
+                return [];
+            if (calls.length === 1)
+                return [await this.callTool(calls[0])];
+            switch (opts.toolCallStrategy) {
+                case 'parallel': {
+                    return Promise.all(calls.map((call) => this.callTool(call)));
+                }
+                case 'sequential': {
+                    const results = [];
+                    for (const call of calls) {
+                        results.push(await this.callTool(call));
+                    }
+                    return results;
+                }
+                case 'adaptive':
+                default: {
+                    // Group by server and use parallel per server, sequential across servers
+                    const byServer = new Map();
+                    for (const call of calls) {
+                        if (!byServer.has(call.serverId)) {
+                            byServer.set(call.serverId, []);
+                        }
+                        byServer.get(call.serverId).push(call);
+                    }
+                    const results = [];
+                    for (const [serverId, serverCalls] of byServer) {
+                        const serverResults = await Promise.all(serverCalls.map((call) => this.callTool(call)));
+                        results.push(...serverResults);
+                    }
+                    return results;
+                }
+            }
+        },
+        findTool(toolName) {
+            const tools = toolIndex.get(toolName);
+            if (!tools || tools.length === 0)
+                return null;
+            // Return highest priority server's tool
+            return tools.sort((a, b) => {
+                const serverA = servers.get(a.serverId);
+                const serverB = servers.get(b.serverId);
+                return (serverB?.config.priority || 0) - (serverA?.config.priority || 0);
+            })[0];
+        },
+        findServersWithTool(toolName) {
+            const tools = toolIndex.get(toolName) || [];
+            return tools
+                .map((t) => servers.get(t.serverId))
+                .filter((s) => s !== undefined && s.status === 'connected');
+        },
+        listTools() {
+            const allTools = [];
+            for (const tools of toolIndex.values()) {
+                allTools.push(...tools);
+            }
+            return allTools;
+        },
+        getStats() {
+            const connected = Array.from(servers.values()).filter((s) => s.status === 'connected').length;
+            const totalTools = this.listTools().length;
+            const cacheHitRate = totalCalls > 0 ? cacheHits / totalCalls : 0;
+            const avgLatency = totalCalls > 0 ? totalLatency / totalCalls : 0;
+            return {
+                totalServers: servers.size,
+                connectedServers: connected,
+                totalTools,
+                totalCalls,
+                cacheHitRate,
+                avgLatency,
+            };
+        },
+        clearCache() {
+            cache.clear();
+            cacheHits = 0;
+            logger.info('MCP tool cache cleared');
+        },
+    };
+}

package/dist/core/collaboration/peer-review.js

@@ -0,0 +1,265 @@
+/**
+ * Multi-Agent Peer Review System
+ *
+ * Enables cross-model peer review of agent decisions and outputs.
+ * Based on agentic-fleet-hub's peer review architecture.
+ *
+ * Key features:
+ * - Multiple agents review each other's work
+ * - Consensus-based approval
+ * - Dissent tracking for quality improvement
+ * - Reputation-weighted voting
+ *
+ * @module core/collaboration
+ * @fileoverview Cross-model peer review for agent outputs
+ */
+import { randomUUID } from 'crypto';
+import { createLogger } from '../../utils/logger.js';
+const logger = createLogger('PeerReview');
+/**
+ * Default reviewers
+ */
+const DEFAULT_REVIEWERS = [
+    {
+        id: 'reviewer-logic',
+        name: 'Logic Reviewer',
+        model: 'claude-opus',
+        specialties: ['reasoning', 'logic', 'consistency'],
+        reputation: 0.95,
+        reviewsCompleted: 0,
+        approvalRate: 0,
+    },
+    {
+        id: 'reviewer-safety',
+        name: 'Safety Reviewer',
+        model: 'claude-opus',
+        specialties: ['safety', 'ethics', 'harm prevention'],
+        reputation: 0.98,
+        reviewsCompleted: 0,
+        approvalRate: 0,
+    },
+    {
+        id: 'reviewer-quality',
+        name: 'Quality Reviewer',
+        model: 'claude-sonnet',
+        specialties: ['code quality', 'documentation', 'best practices'],
+        reputation: 0.92,
+        reviewsCompleted: 0,
+        approvalRate: 0,
+    },
+    {
+        id: 'reviewer-creativity',
+        name: 'Creativity Reviewer',
+        model: 'claude-haiku',
+        specialties: ['innovation', 'alternatives', 'creative solutions'],
+        reputation: 0.88,
+        reviewsCompleted: 0,
+        approvalRate: 0,
+    },
+];
+export function createPeerReviewSystem(options) {
+    const consensusThreshold = options?.consensusThreshold ?? 0.7;
+    const requiredReviewers = options?.requiredReviewers ?? 3;
+    const enableArbitration = options?.enableArbitration ?? true;
+    // State
+    const items = new Map();
+    const reviewers = new Map(DEFAULT_REVIEWERS.map(r => [r.id, r]));
+    const sessions = new Map();
+    const reviewHistory = [];
+    // Stats
+    let totalReviewTime = 0;
+    let consensusCount = 0;
+    let revisionCount = 0;
+    function submitItem(submitterId, content, type, context, options) {
+        const item = {
+            id: randomUUID(),
+            submitterId,
+            content,
+            type,
+            context: context ?? {},
+            status: 'pending',
+            votes: [],
+            createdAt: Date.now(),
+            consensusThreshold: options?.consensusThreshold ?? consensusThreshold,
+            requiredReviewers: options?.requiredReviewers ?? requiredReviewers,
+        };
+        items.set(item.id, item);
+        logger.info(`Review item submitted: ${item.id} by ${submitterId}`);
+        // Auto-assign reviewers
+        assignReviewers(item.id);
+        return item;
+    }
+    function registerReviewer(reviewer) {
+        reviewers.set(reviewer.id, {
+            ...reviewer,
+            reviewsCompleted: 0,
+            approvalRate: 0,
+        });
+        logger.info(`Reviewer registered: ${reviewer.name}`);
+    }
+    function getReviewersForType(contentType) {
+        const relevantReviewers = Array.from(reviewers.values()).filter(r => r.specialties.some(s => contentType === 'code' ? s.includes('code') :
+            contentType === 'decision' ? s.includes('reasoning') || s.includes('logic') :
+                contentType === 'response' ? s.includes('ethics') || s.includes('safety') :
+                    true));
+        // Return up to 4 reviewers
+        return relevantReviewers.slice(0, 4);
+    }
+    function assignReviewers(itemId) {
+        const item = items.get(itemId);
+        if (!item || item.status !== 'pending')
+            return null;
+        const availableReviewers = getReviewersForType(item.type)
+            .filter(r => r.id !== item.submitterId)
+            .slice(0, item.requiredReviewers);
+        if (availableReviewers.length < 2) {
+            // Use default reviewers if no specialty match
+            const defaults = Array.from(reviewers.values())
+                .filter(r => r.id !== item.submitterId)
+                .slice(0, item.requiredReviewers);
+            availableReviewers.push(...defaults);
+        }
+        const session = {
+            itemId,
+            phase: 'review',
+            assignedReviewers: availableReviewers.map(r => r.id),
+            completedReviews: 0,
+            consensusReached: false,
+        };
+        sessions.set(itemId, session);
+        item.status = 'in_review';
+        logger.info(`Assigned ${availableReviewers.length} reviewers to ${itemId}`);
+        return item;
+    }
+    function submitVote(itemId, reviewerId, decision, feedback, confidence) {
+        const item = items.get(itemId);
+        const session = sessions.get(itemId);
+        const reviewer = reviewers.get(reviewerId);
+        if (!item || !session || !reviewer) {
+            logger.warn(`Invalid vote submission: item=${itemId}, reviewer=${reviewerId}`);
+            return null;
+        }
+        // Check if reviewer is assigned
+        if (!session.assignedReviewers.includes(reviewerId)) {
+            logger.warn(`Reviewer ${reviewerId} not assigned to ${itemId}`);
+            return null;
+        }
+        // Check if reviewer already voted
+        if (item.votes.some(v => v.reviewerId === reviewerId)) {
+            logger.warn(`Reviewer ${reviewerId} already voted on ${itemId}`);
+            return null;
+        }
+        const vote = {
+            reviewerId,
+            role: session.completedReviews === 0 ? 'primary' : 'secondary',
+            decision,
+            confidence: Math.max(0, Math.min(1, confidence)),
+            feedback,
+            timestamp: Date.now(),
+        };
+        item.votes.push(vote);
+        session.completedReviews++;
+        reviewHistory.push(vote);
+        // Update reviewer stats
+        reviewer.reviewsCompleted++;
+        logger.info(`Vote submitted: ${reviewerId} -> ${decision} on ${itemId}`);
+        // Check consensus
+        const consensus = checkConsensus(itemId);
+        if (consensus.reached && consensus.decision) {
+            item.status = consensus.decision;
+            item.completedAt = Date.now();
+            session.consensusReached = true;
+            session.decision = consensus.decision === 'approved' ? 'approved' :
+                consensus.decision === 'rejected' ? 'rejected' : 'revision_requested';
+            if (consensus.decision === 'revision_requested') {
+                revisionCount++;
+            }
+            consensusCount++;
+        }
+        return vote;
+    }
+    function checkConsensus(itemId) {
+        const item = items.get(itemId);
+        if (!item)
+            return { reached: false };
+        const requiredApprovals = Math.ceil(item.requiredReviewers * item.consensusThreshold);
+        const votes = item.votes;
+        // Need minimum votes
+        if (votes.length < item.requiredReviewers) {
+            return { reached: false };
+        }
+        // Count decisions
+        const approvals = votes.filter(v => v.decision === 'approve').length;
+        const rejections = votes.filter(v => v.decision === 'reject').length;
+        const revisions = votes.filter(v => v.decision === 'revision').length;
+        // Reputation-weighted voting
+        let weightedApprovals = 0;
+        let totalWeight = 0;
+        for (const vote of votes) {
+            const reviewer = reviewers.get(vote.reviewerId);
+            if (reviewer) {
+                const weight = reviewer.reputation * vote.confidence;
+                totalWeight += weight;
+                if (vote.decision === 'approve') {
+                    weightedApprovals += weight;
+                }
+            }
+        }
+        const weightedApprovalRate = totalWeight > 0 ? weightedApprovals / totalWeight : 0;
+        if (weightedApprovalRate >= item.consensusThreshold) {
+            return { reached: true, decision: 'approved' };
+        }
+        if (rejections > item.requiredReviewers / 2) {
+            // Check for revision option before outright rejection
+            if (enableArbitration && revisions > 0) {
+                return { reached: true, decision: 'revision_requested' };
+            }
+            return { reached: true, decision: 'rejected' };
+        }
+        // No consensus yet
+        return { reached: false };
+    }
+    function getItemStatus(itemId) {
+        return items.get(itemId);
+    }
+    function getPendingReviews(reviewerId) {
+        return Array.from(items.values()).filter(item => {
+            const session = sessions.get(item.id);
+            return (item.status === 'in_review' &&
+                session?.assignedReviewers.includes(reviewerId) &&
+                !item.votes.some(v => v.reviewerId === reviewerId));
+        });
+    }
+    function getStats() {
+        const allItems = Array.from(items.values());
+        const completedItems = allItems.filter(i => i.completedAt);
+        const avgReviewTime = completedItems.length > 0
+            ? totalReviewTime / completedItems.length
+            : 0;
+        return {
+            itemsReviewed: completedItems.length,
+            approvalRate: completedItems.length > 0
+                ? completedItems.filter(i => i.status === 'approved').length / completedItems.length
+                : 0,
+            avgReviewTime,
+            consensusRate: completedItems.length > 0
+                ? consensusCount / completedItems.length
+                : 0,
+            revisionRate: completedItems.length > 0
+                ? revisionCount / completedItems.length
+                : 0,
+            dissentCount: reviewHistory.filter(v => v.decision !== 'approve').length,
+        };
+    }
+    return {
+        submitItem,
+        registerReviewer,
+        getReviewersForType,
+        assignReviewers,
+        submitVote,
+        checkConsensus,
+        getItemStatus,
+        getPendingReviews,
+        getStats,
+    };
+}