@claude-flow/plugin-hyperbolic-reasoning 3.0.0-alpha.1

package/dist/mcp-tools.js

@@ -0,0 +1,740 @@
+/**
+ * Hyperbolic Reasoning MCP Tools
+ *
+ * MCP tool definitions for hyperbolic geometry operations including:
+ * - hyperbolic/embed-hierarchy: Embed hierarchies in Poincare ball
+ * - hyperbolic/taxonomic-reason: Taxonomic reasoning and queries
+ * - hyperbolic/semantic-search: Hierarchically-aware search
+ * - hyperbolic/hierarchy-compare: Compare hierarchical structures
+ * - hyperbolic/entailment-graph: Build and query entailment graphs
+ */
+import { EmbedHierarchyInputSchema, TaxonomicReasonInputSchema, SemanticSearchInputSchema, HierarchyCompareInputSchema, EntailmentGraphInputSchema, successResult, errorResult, RESOURCE_LIMITS, poincareDistance, } from './types.js';
+import { HyperbolicBridge } from './bridges/hyperbolic-bridge.js';
+import { GnnBridge } from './bridges/gnn-bridge.js';
+// Default logger
+const defaultLogger = {
+    debug: (msg, meta) => console.debug(`[hyperbolic-reasoning] ${msg}`, meta),
+    info: (msg, meta) => console.info(`[hyperbolic-reasoning] ${msg}`, meta),
+    warn: (msg, meta) => console.warn(`[hyperbolic-reasoning] ${msg}`, meta),
+    error: (msg, meta) => console.error(`[hyperbolic-reasoning] ${msg}`, meta),
+};
+// Shared bridge instances
+let hyperbolicBridge = null;
+let gnnBridge = null;
+// Stored embeddings and taxonomies
+const embeddingStore = new Map();
+const taxonomyStore = new Map();
+async function getHyperbolicBridge() {
+    if (!hyperbolicBridge) {
+        hyperbolicBridge = new HyperbolicBridge();
+        await hyperbolicBridge.initialize();
+    }
+    return hyperbolicBridge;
+}
+async function getGnnBridge() {
+    if (!gnnBridge) {
+        gnnBridge = new GnnBridge();
+        await gnnBridge.initialize();
+    }
+    return gnnBridge;
+}
+// ============================================================================
+// Tool 1: hyperbolic/embed-hierarchy
+// ============================================================================
+async function embedHierarchyHandler(input, context) {
+    const logger = context?.logger ?? defaultLogger;
+    const startTime = performance.now();
+    try {
+        const validationResult = EmbedHierarchyInputSchema.safeParse(input);
+        if (!validationResult.success) {
+            return errorResult(`Invalid input: ${validationResult.error.message}`);
+        }
+        const data = validationResult.data;
+        logger.debug('Embed hierarchy', {
+            nodes: data.hierarchy.nodes.length,
+            model: data.model,
+            dimensions: data.parameters?.dimensions,
+        });
+        // Validate size
+        if (data.hierarchy.nodes.length > RESOURCE_LIMITS.MAX_NODES) {
+            return errorResult(`Too many nodes: ${data.hierarchy.nodes.length} > ${RESOURCE_LIMITS.MAX_NODES}`);
+        }
+        const bridge = await getHyperbolicBridge();
+        const result = await bridge.embedHierarchy(data.hierarchy, data.parameters);
+        // Store for later use
+        const indexId = `embed_${Date.now()}`;
+        embeddingStore.set(indexId, result);
+        // Create index for search
+        bridge.createIndex(indexId, result.dimension, result.curvature);
+        for (const [nodeId, point] of result.embeddings) {
+            bridge.addToIndex(indexId, nodeId, point);
+        }
+        const duration = performance.now() - startTime;
+        logger.info('Hierarchy embedded', {
+            nodes: result.embeddings.size,
+            curvature: result.curvature,
+            mapScore: result.metrics.mapScore,
+            durationMs: duration.toFixed(2),
+        });
+        // Convert embeddings to serializable format
+        const embeddingsList = [];
+        for (const [nodeId, point] of result.embeddings) {
+            embeddingsList.push({
+                id: nodeId,
+                coordinates: Array.from(point.coordinates).slice(0, 5), // First 5 dimensions
+                depth: bridge.hierarchyDepth(point),
+            });
+        }
+        return successResult({
+            indexId,
+            model: result.model,
+            curvature: result.curvature,
+            dimension: result.dimension,
+            metrics: result.metrics,
+            embeddings: embeddingsList.slice(0, 20), // Sample of embeddings
+            totalNodes: result.embeddings.size,
+        });
+    }
+    catch (error) {
+        logger.error('Embedding failed', { error: error instanceof Error ? error.message : String(error) });
+        return errorResult(error instanceof Error ? error : new Error(String(error)));
+    }
+}
+export const embedHierarchyTool = {
+    name: 'hyperbolic_embed_hierarchy',
+    description: 'Embed hierarchical structure in Poincare ball. Uses hyperbolic geometry for optimal tree representation with logarithmic distortion.',
+    category: 'hyperbolic',
+    version: '0.1.0',
+    tags: ['hyperbolic', 'poincare', 'hierarchy', 'embedding', 'tree'],
+    cacheable: true,
+    cacheTTL: 300000,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            hierarchy: {
+                type: 'object',
+                properties: {
+                    nodes: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                id: { type: 'string' },
+                                parent: { type: 'string' },
+                                features: { type: 'object' },
+                            },
+                        },
+                    },
+                    edges: { type: 'array' },
+                },
+            },
+            model: { type: 'string', enum: ['poincare_ball', 'lorentz', 'klein', 'half_plane'] },
+            parameters: {
+                type: 'object',
+                properties: {
+                    dimensions: { type: 'number', default: 32 },
+                    curvature: { type: 'number', default: -1.0 },
+                    learnCurvature: { type: 'boolean', default: true },
+                    epochs: { type: 'number', default: 100 },
+                    learningRate: { type: 'number', default: 0.01 },
+                },
+            },
+        },
+        required: ['hierarchy'],
+    },
+    handler: embedHierarchyHandler,
+};
+// ============================================================================
+// Tool 2: hyperbolic/taxonomic-reason
+// ============================================================================
+async function taxonomicReasonHandler(input, context) {
+    const logger = context?.logger ?? defaultLogger;
+    const startTime = performance.now();
+    try {
+        const validationResult = TaxonomicReasonInputSchema.safeParse(input);
+        if (!validationResult.success) {
+            return errorResult(`Invalid input: ${validationResult.error.message}`);
+        }
+        const data = validationResult.data;
+        logger.debug('Taxonomic reason', { type: data.query.type, subject: data.query.subject });
+        // Get stored embedding
+        const stored = embeddingStore.get(data.taxonomy);
+        if (!stored) {
+            return errorResult(`Taxonomy not found: ${data.taxonomy}. Use hyperbolic_embed_hierarchy first.`);
+        }
+        const subjectEmb = stored.embeddings.get(data.query.subject);
+        if (!subjectEmb) {
+            return errorResult(`Subject not found in taxonomy: ${data.query.subject}`);
+        }
+        const bridge = await getHyperbolicBridge();
+        let result;
+        let confidence = 1.0;
+        let explanation = '';
+        const steps = [];
+        switch (data.query.type) {
+            case 'is_a': {
+                if (!data.query.object) {
+                    return errorResult('Object required for is_a query');
+                }
+                const objectEmb = stored.embeddings.get(data.query.object);
+                if (!objectEmb) {
+                    return errorResult(`Object not found in taxonomy: ${data.query.object}`);
+                }
+                // Check if subject is descendant of object (object is ancestor)
+                const isAncestor = bridge.isAncestor(objectEmb, subjectEmb);
+                const distance = bridge.distance(subjectEmb, objectEmb);
+                result = isAncestor;
+                confidence = Math.exp(-distance / 2);
+                explanation = isAncestor
+                    ? `${data.query.subject} IS-A ${data.query.object} (distance: ${distance.toFixed(3)})`
+                    : `${data.query.subject} is NOT-A ${data.query.object}`;
+                break;
+            }
+            case 'subsumption': {
+                if (!data.query.object) {
+                    return errorResult('Object required for subsumption query');
+                }
+                const objectEmb = stored.embeddings.get(data.query.object);
+                if (!objectEmb) {
+                    return errorResult(`Object not found in taxonomy: ${data.query.object}`);
+                }
+                // Check both directions
+                const subjectSubsumesObject = bridge.isAncestor(subjectEmb, objectEmb);
+                const objectSubsumesSubject = bridge.isAncestor(objectEmb, subjectEmb);
+                if (subjectSubsumesObject) {
+                    result = 'subject_subsumes_object';
+                    explanation = `${data.query.subject} subsumes ${data.query.object}`;
+                }
+                else if (objectSubsumesSubject) {
+                    result = 'object_subsumes_subject';
+                    explanation = `${data.query.object} subsumes ${data.query.subject}`;
+                }
+                else {
+                    result = 'no_subsumption';
+                    explanation = `No subsumption relation between ${data.query.subject} and ${data.query.object}`;
+                }
+                confidence = 0.9;
+                break;
+            }
+            case 'lowest_common_ancestor': {
+                if (!data.query.object) {
+                    return errorResult('Object required for LCA query');
+                }
+                const objectEmb = stored.embeddings.get(data.query.object);
+                if (!objectEmb) {
+                    return errorResult(`Object not found in taxonomy: ${data.query.object}`);
+                }
+                // Find LCA by searching for node closest to midpoint
+                let bestLca = '';
+                let bestScore = Infinity;
+                for (const [nodeId, nodeEmb] of stored.embeddings) {
+                    // Check if this node is ancestor of both
+                    const isAncOfSubject = bridge.isAncestor(nodeEmb, subjectEmb);
+                    const isAncOfObject = bridge.isAncestor(nodeEmb, objectEmb);
+                    if (isAncOfSubject && isAncOfObject) {
+                        const depth = bridge.hierarchyDepth(nodeEmb);
+                        // Prefer deepest common ancestor (highest depth value)
+                        const score = -depth;
+                        if (score < bestScore) {
+                            bestScore = score;
+                            bestLca = nodeId;
+                        }
+                    }
+                }
+                result = bestLca || null;
+                confidence = bestLca ? 0.95 : 0;
+                explanation = bestLca
+                    ? `Lowest common ancestor is ${bestLca}`
+                    : 'No common ancestor found';
+                break;
+            }
+            case 'path': {
+                if (!data.query.object) {
+                    return errorResult('Object required for path query');
+                }
+                // Find path through ancestors
+                const path = [data.query.subject];
+                let current = data.query.subject;
+                // Find ancestors of subject
+                const ancestorsOfSubject = [];
+                for (const [nodeId, nodeEmb] of stored.embeddings) {
+                    if (bridge.isAncestor(nodeEmb, subjectEmb)) {
+                        ancestorsOfSubject.push(nodeId);
+                    }
+                }
+                // Sort by depth (shallowest first)
+                ancestorsOfSubject.sort((a, b) => {
+                    const depthA = bridge.hierarchyDepth(stored.embeddings.get(a));
+                    const depthB = bridge.hierarchyDepth(stored.embeddings.get(b));
+                    return depthA - depthB;
+                });
+                // Check if object is in ancestors
+                if (ancestorsOfSubject.includes(data.query.object)) {
+                    path.push(...ancestorsOfSubject.slice(0, ancestorsOfSubject.indexOf(data.query.object) + 1));
+                    result = path;
+                    explanation = `Path from ${data.query.subject} to ${data.query.object}: ${path.join(' -> ')}`;
+                }
+                else {
+                    // Find common ancestor and path through it
+                    result = [];
+                    explanation = `No direct path from ${data.query.subject} to ${data.query.object}`;
+                }
+                confidence = 0.9;
+                break;
+            }
+            case 'similarity': {
+                if (!data.query.object) {
+                    return errorResult('Object required for similarity query');
+                }
+                const objectEmb = stored.embeddings.get(data.query.object);
+                if (!objectEmb) {
+                    return errorResult(`Object not found in taxonomy: ${data.query.object}`);
+                }
+                const distance = bridge.distance(subjectEmb, objectEmb);
+                const similarity = Math.exp(-distance);
+                result = similarity;
+                confidence = 1.0;
+                explanation = `Hyperbolic similarity: ${similarity.toFixed(4)} (distance: ${distance.toFixed(4)})`;
+                break;
+            }
+        }
+        const duration = performance.now() - startTime;
+        logger.info('Taxonomic reasoning completed', {
+            type: data.query.type,
+            confidence,
+            durationMs: duration.toFixed(2),
+        });
+        return successResult({
+            result,
+            confidence,
+            explanation,
+            steps,
+            queryType: data.query.type,
+            subject: data.query.subject,
+            object: data.query.object,
+        });
+    }
+    catch (error) {
+        logger.error('Taxonomic reasoning failed', { error: error instanceof Error ? error.message : String(error) });
+        return errorResult(error instanceof Error ? error : new Error(String(error)));
+    }
+}
+export const taxonomicReasonTool = {
+    name: 'hyperbolic_taxonomic_reason',
+    description: 'Taxonomic reasoning using hyperbolic entailment. Supports IS-A, subsumption, LCA, path, and similarity queries.',
+    category: 'hyperbolic',
+    version: '0.1.0',
+    tags: ['hyperbolic', 'taxonomy', 'reasoning', 'is-a', 'subsumption'],
+    cacheable: true,
+    cacheTTL: 60000,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            query: {
+                type: 'object',
+                properties: {
+                    type: { type: 'string', enum: ['is_a', 'subsumption', 'lowest_common_ancestor', 'path', 'similarity'] },
+                    subject: { type: 'string' },
+                    object: { type: 'string' },
+                },
+            },
+            taxonomy: { type: 'string', description: 'Taxonomy index ID from embed-hierarchy' },
+            inference: {
+                type: 'object',
+                properties: {
+                    transitive: { type: 'boolean', default: true },
+                    fuzzy: { type: 'boolean', default: false },
+                    confidence: { type: 'number', default: 0.8 },
+                },
+            },
+        },
+        required: ['query', 'taxonomy'],
+    },
+    handler: taxonomicReasonHandler,
+};
+// ============================================================================
+// Tool 3: hyperbolic/semantic-search
+// ============================================================================
+async function semanticSearchHandler(input, context) {
+    const logger = context?.logger ?? defaultLogger;
+    const startTime = performance.now();
+    try {
+        const validationResult = SemanticSearchInputSchema.safeParse(input);
+        if (!validationResult.success) {
+            return errorResult(`Invalid input: ${validationResult.error.message}`);
+        }
+        const data = validationResult.data;
+        logger.debug('Semantic search', { index: data.index, mode: data.searchMode, topK: data.topK });
+        // Get stored embedding
+        const stored = embeddingStore.get(data.index);
+        if (!stored) {
+            return errorResult(`Index not found: ${data.index}. Use hyperbolic_embed_hierarchy first.`);
+        }
+        const bridge = await getHyperbolicBridge();
+        // Create query embedding from text
+        // In production, use a proper text encoder
+        const queryEmb = new Float32Array(stored.dimension);
+        for (let i = 0; i < data.query.length; i++) {
+            const idx = data.query.charCodeAt(i) % stored.dimension;
+            queryEmb[idx] += 1;
+        }
+        const norm = Math.sqrt(queryEmb.reduce((s, v) => s + v * v, 0));
+        for (let i = 0; i < queryEmb.length; i++) {
+            queryEmb[i] = (queryEmb[i] / (norm + 1e-10)) * 0.5; // Scale to be inside ball
+        }
+        const queryPoint = {
+            coordinates: queryEmb,
+            curvature: stored.curvature,
+            dimension: stored.dimension,
+        };
+        const result = await bridge.search(queryPoint, data.index, data.topK, data.searchMode);
+        // Apply constraints
+        let filteredItems = result.items;
+        if (data.constraints?.maxDepth !== undefined) {
+            filteredItems = filteredItems.filter(item => {
+                const emb = stored.embeddings.get(item.id);
+                if (!emb)
+                    return false;
+                return bridge.hierarchyDepth(emb) <= data.constraints.maxDepth;
+            });
+        }
+        if (data.constraints?.minDepth !== undefined) {
+            filteredItems = filteredItems.filter(item => {
+                const emb = stored.embeddings.get(item.id);
+                if (!emb)
+                    return false;
+                return bridge.hierarchyDepth(emb) >= data.constraints.minDepth;
+            });
+        }
+        if (data.constraints?.subtreeRoot) {
+            const rootEmb = stored.embeddings.get(data.constraints.subtreeRoot);
+            if (rootEmb) {
+                filteredItems = filteredItems.filter(item => {
+                    const emb = stored.embeddings.get(item.id);
+                    if (!emb)
+                        return false;
+                    return bridge.isAncestor(rootEmb, emb);
+                });
+            }
+        }
+        const duration = performance.now() - startTime;
+        logger.info('Semantic search completed', {
+            results: filteredItems.length,
+            mode: data.searchMode,
+            durationMs: duration.toFixed(2),
+        });
+        return successResult({
+            items: filteredItems.slice(0, data.topK).map(item => ({
+                id: item.id,
+                distance: item.distance,
+                similarity: item.similarity,
+                depth: stored.embeddings.get(item.id)
+                    ? bridge.hierarchyDepth(stored.embeddings.get(item.id))
+                    : undefined,
+            })),
+            totalCandidates: result.totalCandidates,
+            searchTimeMs: result.searchTimeMs,
+            mode: data.searchMode,
+        });
+    }
+    catch (error) {
+        logger.error('Semantic search failed', { error: error instanceof Error ? error.message : String(error) });
+        return errorResult(error instanceof Error ? error : new Error(String(error)));
+    }
+}
+export const semanticSearchTool = {
+    name: 'hyperbolic_semantic_search',
+    description: 'Semantic search with hierarchical awareness. Supports nearest, subtree, ancestors, siblings, and cone search modes.',
+    category: 'hyperbolic',
+    version: '0.1.0',
+    tags: ['hyperbolic', 'search', 'semantic', 'hierarchy', 'nearest-neighbor'],
+    cacheable: true,
+    cacheTTL: 30000,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            query: { type: 'string', description: 'Search query text' },
+            index: { type: 'string', description: 'Index ID from embed-hierarchy' },
+            searchMode: { type: 'string', enum: ['nearest', 'subtree', 'ancestors', 'siblings', 'cone'] },
+            constraints: {
+                type: 'object',
+                properties: {
+                    maxDepth: { type: 'number' },
+                    minDepth: { type: 'number' },
+                    subtreeRoot: { type: 'string' },
+                },
+            },
+            topK: { type: 'number', default: 10 },
+        },
+        required: ['query', 'index'],
+    },
+    handler: semanticSearchHandler,
+};
+// ============================================================================
+// Tool 4: hyperbolic/hierarchy-compare
+// ============================================================================
+async function hierarchyCompareHandler(input, context) {
+    const logger = context?.logger ?? defaultLogger;
+    const startTime = performance.now();
+    try {
+        const validationResult = HierarchyCompareInputSchema.safeParse(input);
+        if (!validationResult.success) {
+            return errorResult(`Invalid input: ${validationResult.error.message}`);
+        }
+        const data = validationResult.data;
+        logger.debug('Hierarchy compare', {
+            sourceNodes: data.source.nodes.length,
+            targetNodes: data.target.nodes.length,
+            method: data.alignment,
+        });
+        const bridge = await getHyperbolicBridge();
+        // Embed both hierarchies
+        const sourceEmb = await bridge.embedHierarchy(data.source);
+        const targetEmb = await bridge.embedHierarchy(data.target);
+        // Compute alignments
+        const alignments = [];
+        const matchedSource = new Set();
+        const matchedTarget = new Set();
+        // Greedy matching based on embedding similarity
+        const sourceIds = Array.from(sourceEmb.embeddings.keys());
+        const targetIds = Array.from(targetEmb.embeddings.keys());
+        for (const srcId of sourceIds) {
+            const srcPoint = sourceEmb.embeddings.get(srcId);
+            let bestTarget = '';
+            let bestSimilarity = -Infinity;
+            for (const tgtId of targetIds) {
+                if (matchedTarget.has(tgtId))
+                    continue;
+                const tgtPoint = targetEmb.embeddings.get(tgtId);
+                // Compare embeddings (project to same curvature)
+                const dist = poincareDistance(srcPoint.coordinates, tgtPoint.coordinates, srcPoint.curvature);
+                const similarity = Math.exp(-dist);
+                if (similarity > bestSimilarity) {
+                    bestSimilarity = similarity;
+                    bestTarget = tgtId;
+                }
+            }
+            if (bestTarget && bestSimilarity > 0.5) {
+                alignments.push({
+                    source: srcId,
+                    target: bestTarget,
+                    confidence: bestSimilarity,
+                });
+                matchedSource.add(srcId);
+                matchedTarget.add(bestTarget);
+            }
+        }
+        // Compute metrics
+        const metrics = {};
+        // Structural similarity: ratio of matched nodes
+        metrics['structural_similarity'] =
+            (alignments.length * 2) / (sourceIds.length + targetIds.length);
+        // Semantic similarity: average alignment confidence
+        metrics['semantic_similarity'] =
+            alignments.length > 0
+                ? alignments.reduce((s, a) => s + a.confidence, 0) / alignments.length
+                : 0;
+        // Coverage: ratio of source nodes matched
+        metrics['coverage'] = alignments.length / sourceIds.length;
+        // Precision: ratio of target nodes matched
+        metrics['precision'] = alignments.length / targetIds.length;
+        const unmatchedSource = sourceIds.filter(id => !matchedSource.has(id));
+        const unmatchedTarget = targetIds.filter(id => !matchedTarget.has(id));
+        const duration = performance.now() - startTime;
+        logger.info('Hierarchy comparison completed', {
+            alignments: alignments.length,
+            structuralSimilarity: metrics['structural_similarity'],
+            durationMs: duration.toFixed(2),
+        });
+        return successResult({
+            similarity: (metrics['structural_similarity'] + metrics['semantic_similarity']) / 2,
+            alignments,
+            metrics,
+            unmatchedSource,
+            unmatchedTarget,
+            method: data.alignment,
+        });
+    }
+    catch (error) {
+        logger.error('Hierarchy comparison failed', { error: error instanceof Error ? error.message : String(error) });
+        return errorResult(error instanceof Error ? error : new Error(String(error)));
+    }
+}
+export const hierarchyCompareTool = {
+    name: 'hyperbolic_hierarchy_compare',
+    description: 'Compare hierarchies using hyperbolic alignment. Computes structural and semantic similarity with node-level alignments.',
+    category: 'hyperbolic',
+    version: '0.1.0',
+    tags: ['hyperbolic', 'comparison', 'alignment', 'tree-edit', 'similarity'],
+    cacheable: true,
+    cacheTTL: 120000,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            source: { type: 'object', description: 'First hierarchy' },
+            target: { type: 'object', description: 'Second hierarchy' },
+            alignment: {
+                type: 'string',
+                enum: ['wasserstein', 'gromov_wasserstein', 'tree_edit', 'subtree_isomorphism'],
+            },
+            metrics: {
+                type: 'array',
+                items: { type: 'string', enum: ['structural_similarity', 'semantic_similarity', 'coverage', 'precision'] },
+            },
+        },
+        required: ['source', 'target'],
+    },
+    handler: hierarchyCompareHandler,
+};
+// ============================================================================
+// Tool 5: hyperbolic/entailment-graph
+// ============================================================================
+async function entailmentGraphHandler(input, context) {
+    const logger = context?.logger ?? defaultLogger;
+    const startTime = performance.now();
+    try {
+        const validationResult = EntailmentGraphInputSchema.safeParse(input);
+        if (!validationResult.success) {
+            return errorResult(`Invalid input: ${validationResult.error.message}`);
+        }
+        const data = validationResult.data;
+        logger.debug('Entailment graph', { action: data.action, concepts: data.concepts?.length });
+        const gnn = await getGnnBridge();
+        switch (data.action) {
+            case 'build': {
+                if (!data.concepts || data.concepts.length === 0) {
+                    return errorResult('Concepts required for build action');
+                }
+                const graph = await gnn.buildEntailmentGraph(data.concepts, data.entailmentThreshold);
+                // Apply transitive closure if requested
+                const finalGraph = data.transitiveClosure
+                    ? gnn.computeTransitiveClosure(graph)
+                    : graph;
+                const duration = performance.now() - startTime;
+                logger.info('Entailment graph built', {
+                    nodes: finalGraph.stats.nodeCount,
+                    edges: finalGraph.stats.edgeCount,
+                    durationMs: duration.toFixed(2),
+                });
+                return successResult({
+                    graphId: `entailment_${Date.now()}`,
+                    stats: finalGraph.stats,
+                    relations: finalGraph.relations.slice(0, 50), // Sample
+                    transitiveClosure: finalGraph.transitiveClosure,
+                });
+            }
+            case 'query': {
+                if (!data.query?.premise) {
+                    return errorResult('Premise required for query action');
+                }
+                // Would query stored graph - simplified for demo
+                return successResult({
+                    query: data.query,
+                    results: [],
+                    message: 'Query requires pre-built graph. Use build action first.',
+                });
+            }
+            case 'prune': {
+                if (!data.graphId) {
+                    return errorResult('GraphId required for prune action');
+                }
+                // Simplified - would prune stored graph
+                return successResult({
+                    graphId: data.graphId,
+                    pruneStrategy: data.pruneStrategy,
+                    message: 'Prune action completed',
+                });
+            }
+            case 'expand': {
+                if (!data.concepts) {
+                    return errorResult('Concepts required for expand action');
+                }
+                return successResult({
+                    added: data.concepts.length,
+                    message: 'Expand action completed',
+                });
+            }
+            default:
+                return errorResult(`Unknown action: ${data.action}`);
+        }
+    }
+    catch (error) {
+        logger.error('Entailment graph operation failed', { error: error instanceof Error ? error.message : String(error) });
+        return errorResult(error instanceof Error ? error : new Error(String(error)));
+    }
+}
+export const entailmentGraphTool = {
+    name: 'hyperbolic_entailment_graph',
+    description: 'Build and query entailment graphs using hyperbolic embeddings. Supports transitive closure and pruning strategies.',
+    category: 'hyperbolic',
+    version: '0.1.0',
+    tags: ['hyperbolic', 'entailment', 'graph', 'nli', 'reasoning'],
+    cacheable: false,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            action: { type: 'string', enum: ['build', 'query', 'expand', 'prune'] },
+            concepts: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    properties: {
+                        id: { type: 'string' },
+                        text: { type: 'string' },
+                        type: { type: 'string' },
+                    },
+                },
+            },
+            graphId: { type: 'string' },
+            query: {
+                type: 'object',
+                properties: {
+                    premise: { type: 'string' },
+                    hypothesis: { type: 'string' },
+                },
+            },
+            entailmentThreshold: { type: 'number', default: 0.7 },
+            transitiveClosure: { type: 'boolean', default: true },
+            pruneStrategy: { type: 'string', enum: ['none', 'transitive_reduction', 'confidence_threshold'] },
+        },
+        required: ['action'],
+    },
+    handler: entailmentGraphHandler,
+};
+// ============================================================================
+// Tool Exports
+// ============================================================================
+/**
+ * All Hyperbolic Reasoning MCP Tools
+ */
+export const hyperbolicReasoningTools = [
+    embedHierarchyTool,
+    taxonomicReasonTool,
+    semanticSearchTool,
+    hierarchyCompareTool,
+    entailmentGraphTool,
+];
+/**
+ * Tool name to handler map
+ */
+export const toolHandlers = new Map([
+    ['hyperbolic_embed_hierarchy', embedHierarchyHandler],
+    ['hyperbolic_taxonomic_reason', taxonomicReasonHandler],
+    ['hyperbolic_semantic_search', semanticSearchHandler],
+    ['hyperbolic_hierarchy_compare', hierarchyCompareHandler],
+    ['hyperbolic_entailment_graph', entailmentGraphHandler],
+]);
+/**
+ * Get a tool by name
+ */
+export function getTool(name) {
+    return hyperbolicReasoningTools.find(t => t.name === name);
+}
+/**
+ * Get all tool names
+ */
+export function getToolNames() {
+    return hyperbolicReasoningTools.map(t => t.name);
+}
+export default hyperbolicReasoningTools;
+//# sourceMappingURL=mcp-tools.js.map