@mxf-dev/core 2.0.4 → 3.0.0

package/dist/protocols/mcp/tools/KnowledgeGraphTools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"KnowledgeGraphTools.d.ts","sourceRoot":"","sources":["../../../../src/protocols/mcp/tools/KnowledgeGraphTools.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"KnowledgeGraphTools.d.ts","sourceRoot":"","sources":["../../../../src/protocols/mcp/tools/KnowledgeGraphTools.ts"],"names":[],"mappings":"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"}

package/dist/protocols/mcp/tools/KnowledgeGraphTools.js

@@ -31,6 +31,33 @@ import { OrparGraphIntegration } from '../../../services/kg/OrparGraphIntegratio
 import { isKnowledgeGraphEnabled } from '../../../config/knowledge-graph.config.js';
 import { EntityType, RelationshipType } from '../../../types/KnowledgeGraphTypes.js';
 const logger = new Logger('info', 'KnowledgeGraphTools', 'server');
+function requireKnowledgeGraphIdentity(args, context) {
+    if (typeof context.agentId !== 'string' || context.agentId.trim().length === 0 ||
+        typeof context.channelId !== 'string' || context.channelId.trim().length === 0) {
+        throw new Error('Authenticated agentId and channelId are required for Knowledge Graph tools');
+    }
+    const agentId = context.agentId.trim();
+    const channelId = context.channelId.trim();
+    if (args.channelId !== undefined && (typeof args.channelId !== 'string' || args.channelId.trim() !== channelId)) {
+        throw new Error('channelId must match the authenticated tool context');
+    }
+    return { agentId, channelId };
+}
+const errorMessage = (error) => (error instanceof Error ? error.message : String(error));
+const requireStringArgument = (args, name) => {
+    const value = args[name];
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        throw new Error(`${String(name)} must be a non-empty string`);
+    }
+    return value.trim();
+};
+const requireStringArrayArgument = (args, name) => {
+    const value = args[name];
+    if (!Array.isArray(value) || value.length === 0 || value.some(item => (typeof item !== 'string' || item.trim().length === 0))) {
+        throw new Error(`${String(name)} must be a non-empty array of non-empty strings`);
+    }
+    return value.map(item => item.trim());
+};
 /**
  * Helper to get Knowledge Graph service
  */
@@ -67,6 +94,7 @@ export const kg_get_entity = {
     },
     handler: async (args, context) => {
         try {
+            const identity = requireKnowledgeGraphIdentity(args, context);
             if (!isKnowledgeGraphEnabled()) {
                 return {
                     success: false,
@@ -75,12 +103,13 @@ export const kg_get_entity = {
                 };
             }
             const kgService = getKgService();
-            const entity = await kgService.getEntity(args.entityId);
+            const entityId = requireStringArgument(args, 'entityId');
+            const entity = await kgService.getEntity(entityId, identity.channelId);
             if (!entity) {
                 return {
                     success: false,
                     entity: null,
-                    message: `Entity not found: ${args.entityId}`,
+                    message: `Entity not found: ${entityId}`,
                 };
             }
             return {
@@ -90,12 +119,12 @@ export const kg_get_entity = {
             };
         }
         catch (error) {
-            logger.error('Failed to get entity', { error: error.message });
+            logger.error('Failed to get entity', { error: errorMessage(error) });
             return {
                 success: false,
                 entity: null,
                 message: 'Failed to get entity',
-                error: error.message,
+                error: errorMessage(error),
             };
         }
     },
@@ -134,6 +163,7 @@ export const kg_find_entity = {
     },
     handler: async (args, context) => {
         try {
+            const identity = requireKnowledgeGraphIdentity(args, context);
             if (!isKnowledgeGraphEnabled()) {
                 return {
                     success: false,
@@ -141,16 +171,9 @@ export const kg_find_entity = {
                     message: 'Knowledge Graph is disabled',
                 };
             }
-            const channelId = args.channelId || context.channelId;
-            if (!channelId) {
-                return {
-                    success: false,
-                    entities: [],
-                    message: 'channelId is required but not provided',
-                };
-            }
             const kgService = getKgService();
-            const entities = await kgService.findEntityByName(channelId, args.name, args.exact || false);
+            const name = requireStringArgument(args, 'name');
+            const entities = await kgService.findEntityByName(identity.channelId, name, args.exact || false);
             const limitedEntities = entities.slice(0, args.limit || 10);
             return {
                 success: true,
@@ -158,17 +181,17 @@ export const kg_find_entity = {
                 count: limitedEntities.length,
                 totalFound: entities.length,
                 message: entities.length > 0
-                    ? `Found ${entities.length} entities matching "${args.name}"`
-                    : `No entities found matching "${args.name}"`,
+                    ? `Found ${entities.length} entities matching "${name}"`
+                    : `No entities found matching "${name}"`,
             };
         }
         catch (error) {
-            logger.error('Failed to find entity', { error: error.message });
+            logger.error('Failed to find entity', { error: errorMessage(error) });
             return {
                 success: false,
                 entities: [],
                 message: 'Failed to find entity',
-                error: error.message,
+                error: errorMessage(error),
             };
         }
     },
@@ -208,6 +231,7 @@ export const kg_get_neighbors = {
     },
     handler: async (args, context) => {
         try {
+            const identity = requireKnowledgeGraphIdentity(args, context);
             if (!isKnowledgeGraphEnabled()) {
                 return {
                     success: false,
@@ -217,11 +241,21 @@ export const kg_get_neighbors = {
                 };
             }
             const kgService = getKgService();
-            const result = await kgService.getNeighbors(args.entityId, {
+            const entityId = requireStringArgument(args, 'entityId');
+            const entity = await kgService.getEntity(entityId, identity.channelId);
+            if (!entity) {
+                return {
+                    success: false,
+                    entities: [],
+                    relationships: [],
+                    message: `Entity not found: ${entityId}`,
+                };
+            }
+            const result = await kgService.getNeighbors(entityId, {
                 direction: args.direction || 'both',
                 relationshipType: args.relationshipType,
                 limit: args.limit || 20,
-            });
+            }, identity.channelId);
             return {
                 success: true,
                 entities: result.entities,
@@ -232,13 +266,13 @@ export const kg_get_neighbors = {
             };
         }
         catch (error) {
-            logger.error('Failed to get neighbors', { error: error.message });
+            logger.error('Failed to get neighbors', { error: errorMessage(error) });
             return {
                 success: false,
                 entities: [],
                 relationships: [],
                 message: 'Failed to get neighbors',
-                error: error.message,
+                error: errorMessage(error),
             };
         }
     },
@@ -272,6 +306,7 @@ export const kg_find_path = {
     },
     handler: async (args, context) => {
         try {
+            const identity = requireKnowledgeGraphIdentity(args, context);
             if (!isKnowledgeGraphEnabled()) {
                 return {
                     success: false,
@@ -280,7 +315,21 @@ export const kg_find_path = {
                 };
             }
             const kgService = getKgService();
-            const path = await kgService.findPath(args.fromEntityId, args.toEntityId, args.maxHops || 5);
+            const fromEntityId = requireStringArgument(args, 'fromEntityId');
+            const toEntityId = requireStringArgument(args, 'toEntityId');
+            const [fromEntity, toEntity] = await Promise.all([
+                kgService.getEntity(fromEntityId, identity.channelId),
+                kgService.getEntity(toEntityId, identity.channelId)
+            ]);
+            if (!fromEntity || !toEntity) {
+                return {
+                    success: false,
+                    path: null,
+                    found: false,
+                    message: 'Both path endpoints must belong to the authenticated channel',
+                };
+            }
+            const path = await kgService.findPath(fromEntityId, toEntityId, args.maxHops || 5, identity.channelId);
             if (!path) {
                 return {
                     success: true,
@@ -289,6 +338,15 @@ export const kg_find_path = {
                     message: `No path found between entities within ${args.maxHops || 5} hops`,
                 };
             }
+            const pathEntities = await Promise.all(path.entityIds.map(entityId => kgService.getEntity(entityId, identity.channelId)));
+            if (pathEntities.some(entity => !entity)) {
+                return {
+                    success: false,
+                    path: null,
+                    found: false,
+                    message: 'The resolved path is not wholly contained in the authenticated channel',
+                };
+            }
             return {
                 success: true,
                 path,
@@ -298,12 +356,12 @@ export const kg_find_path = {
             };
         }
         catch (error) {
-            logger.error('Failed to find path', { error: error.message });
+            logger.error('Failed to find path', { error: errorMessage(error) });
             return {
                 success: false,
                 path: null,
                 message: 'Failed to find path',
-                error: error.message,
+                error: errorMessage(error),
             };
         }
     },
@@ -335,6 +393,7 @@ export const kg_get_context = {
     },
     handler: async (args, context) => {
         try {
+            const identity = requireKnowledgeGraphIdentity(args, context);
             if (!isKnowledgeGraphEnabled()) {
                 return {
                     success: false,
@@ -342,16 +401,8 @@ export const kg_get_context = {
                     message: 'Knowledge Graph is disabled',
                 };
             }
-            const channelId = args.channelId || context.channelId;
-            if (!channelId) {
-                return {
-                    success: false,
-                    context: null,
-                    message: 'channelId is required but not provided',
-                };
-            }
             const kgService = getKgService();
-            const graphContext = await kgService.getGraphContext(channelId, args.taskId, args.keywords);
+            const graphContext = await kgService.getGraphContext(identity.channelId, args.taskId, args.keywords);
             return {
                 success: true,
                 context: graphContext,
@@ -360,12 +411,12 @@ export const kg_get_context = {
             };
         }
         catch (error) {
-            logger.error('Failed to get context', { error: error.message });
+            logger.error('Failed to get context', { error: errorMessage(error) });
             return {
                 success: false,
                 context: null,
                 message: 'Failed to get context',
-                error: error.message,
+                error: errorMessage(error),
             };
         }
     },
@@ -395,6 +446,7 @@ export const kg_get_high_utility_entities = {
     },
     handler: async (args, context) => {
         try {
+            const identity = requireKnowledgeGraphIdentity(args, context);
             if (!isKnowledgeGraphEnabled()) {
                 return {
                     success: false,
@@ -402,16 +454,8 @@ export const kg_get_high_utility_entities = {
                     message: 'Knowledge Graph is disabled',
                 };
             }
-            const channelId = args.channelId || context.channelId;
-            if (!channelId) {
-                return {
-                    success: false,
-                    entities: [],
-                    message: 'channelId is required but not provided',
-                };
-            }
             const kgService = getKgService();
-            const entities = await kgService.getHighUtilityEntities(channelId, args.limit || 10);
+            const entities = await kgService.getHighUtilityEntities(identity.channelId, args.limit || 10);
             return {
                 success: true,
                 entities,
@@ -420,12 +464,12 @@ export const kg_get_high_utility_entities = {
             };
         }
         catch (error) {
-            logger.error('Failed to get high utility entities', { error: error.message });
+            logger.error('Failed to get high utility entities', { error: errorMessage(error) });
             return {
                 success: false,
                 entities: [],
                 message: 'Failed to get high utility entities',
-                error: error.message,
+                error: errorMessage(error),
             };
         }
     },
@@ -473,6 +517,7 @@ export const kg_create_entity = {
     },
     handler: async (args, context) => {
         try {
+            const identity = requireKnowledgeGraphIdentity(args, context);
             if (!isKnowledgeGraphEnabled()) {
                 return {
                     success: false,
@@ -480,24 +525,18 @@ export const kg_create_entity = {
                     message: 'Knowledge Graph is disabled',
                 };
             }
-            const channelId = args.channelId || context.channelId;
-            if (!channelId) {
-                return {
-                    success: false,
-                    entity: null,
-                    message: 'channelId is required but not provided',
-                };
-            }
             const kgService = getKgService();
+            const name = requireStringArgument(args, 'name');
+            const type = requireStringArgument(args, 'type');
             const entity = await kgService.findOrCreateEntity({
-                channelId,
-                name: args.name,
-                type: args.type,
+                channelId: identity.channelId,
+                name,
+                type,
                 aliases: args.aliases,
                 description: args.description,
                 confidence: args.confidence || 0.8,
                 source: 'manual',
-            }, context.agentId);
+            }, identity.agentId);
             return {
                 success: true,
                 entity,
@@ -505,12 +544,12 @@ export const kg_create_entity = {
             };
         }
         catch (error) {
-            logger.error('Failed to create entity', { error: error.message });
+            logger.error('Failed to create entity', { error: errorMessage(error) });
             return {
                 success: false,
                 entity: null,
                 message: 'Failed to create entity',
-                error: error.message,
+                error: errorMessage(error),
             };
         }
     },
@@ -557,6 +596,7 @@ export const kg_create_relationship = {
     },
     handler: async (args, context) => {
         try {
+            const identity = requireKnowledgeGraphIdentity(args, context);
             if (!isKnowledgeGraphEnabled()) {
                 return {
                     success: false,
@@ -564,37 +604,43 @@ export const kg_create_relationship = {
                     message: 'Knowledge Graph is disabled',
                 };
             }
-            const channelId = args.channelId || context.channelId;
-            if (!channelId) {
+            const kgService = getKgService();
+            const fromEntityId = requireStringArgument(args, 'fromEntityId');
+            const toEntityId = requireStringArgument(args, 'toEntityId');
+            const type = requireStringArgument(args, 'type');
+            const [fromEntity, toEntity] = await Promise.all([
+                kgService.getEntity(fromEntityId, identity.channelId),
+                kgService.getEntity(toEntityId, identity.channelId)
+            ]);
+            if (!fromEntity || !toEntity) {
                 return {
                     success: false,
                     relationship: null,
-                    message: 'channelId is required but not provided',
+                    message: 'Both relationship endpoints must belong to the authenticated channel',
                 };
             }
-            const kgService = getKgService();
             const relationship = await kgService.createRelationship({
-                channelId,
-                fromEntityId: args.fromEntityId,
-                toEntityId: args.toEntityId,
-                type: args.type,
+                channelId: identity.channelId,
+                fromEntityId,
+                toEntityId,
+                type,
                 label: args.label,
                 confidence: args.confidence || 0.8,
                 source: 'manual',
-            }, context.agentId);
+            }, identity.agentId);
             return {
                 success: true,
                 relationship,
-                message: `Created relationship: ${args.type}`,
+                message: `Created relationship: ${type}`,
             };
         }
         catch (error) {
-            logger.error('Failed to create relationship', { error: error.message });
+            logger.error('Failed to create relationship', { error: errorMessage(error) });
             return {
                 success: false,
                 relationship: null,
                 message: 'Failed to create relationship',
-                error: error.message,
+                error: errorMessage(error),
             };
         }
     },
@@ -625,6 +671,7 @@ export const kg_extract_from_text = {
     },
     handler: async (args, context) => {
         try {
+            const identity = requireKnowledgeGraphIdentity(args, context);
             if (!isKnowledgeGraphEnabled()) {
                 return {
                     success: false,
@@ -632,16 +679,9 @@ export const kg_extract_from_text = {
                     message: 'Knowledge Graph is disabled',
                 };
             }
-            const channelId = args.channelId || context.channelId;
-            if (!channelId) {
-                return {
-                    success: false,
-                    result: null,
-                    message: 'channelId is required but not provided',
-                };
-            }
             const extractionService = getExtractionService();
-            const result = await extractionService.extractFromText(channelId, args.text, args.sourceId);
+            const text = requireStringArgument(args, 'text');
+            const result = await extractionService.extractFromText(identity.channelId, text, args.sourceId);
             return {
                 success: true,
                 result,
@@ -652,12 +692,12 @@ export const kg_extract_from_text = {
             };
         }
         catch (error) {
-            logger.error('Failed to extract from text', { error: error.message });
+            logger.error('Failed to extract from text', { error: errorMessage(error) });
             return {
                 success: false,
                 result: null,
                 message: 'Failed to extract from text',
-                error: error.message,
+                error: errorMessage(error),
             };
         }
     },
@@ -688,6 +728,7 @@ export const kg_extract_from_memory = {
     },
     handler: async (args, context) => {
         try {
+            const identity = requireKnowledgeGraphIdentity(args, context);
             if (!isKnowledgeGraphEnabled()) {
                 return {
                     success: false,
@@ -695,16 +736,10 @@ export const kg_extract_from_memory = {
                     message: 'Knowledge Graph is disabled',
                 };
             }
-            const channelId = args.channelId || context.channelId;
-            if (!channelId) {
-                return {
-                    success: false,
-                    result: null,
-                    message: 'channelId is required but not provided',
-                };
-            }
             const extractionService = getExtractionService();
-            const result = await extractionService.processMemory(channelId, args.memoryId, args.memoryContent);
+            const memoryId = requireStringArgument(args, 'memoryId');
+            const memoryContent = requireStringArgument(args, 'memoryContent');
+            const result = await extractionService.processMemory(identity.channelId, memoryId, memoryContent);
             return {
                 success: true,
                 result,
@@ -715,12 +750,12 @@ export const kg_extract_from_memory = {
             };
         }
         catch (error) {
-            logger.error('Failed to extract from memory', { error: error.message });
+            logger.error('Failed to extract from memory', { error: errorMessage(error) });
             return {
                 success: false,
                 result: null,
                 message: 'Failed to extract from memory',
-                error: error.message,
+                error: errorMessage(error),
             };
         }
     },
@@ -757,6 +792,7 @@ export const kg_get_phase_context = {
     },
     handler: async (args, context) => {
         try {
+            const identity = requireKnowledgeGraphIdentity(args, context);
             if (!isKnowledgeGraphEnabled()) {
                 return {
                     success: false,
@@ -764,16 +800,25 @@ export const kg_get_phase_context = {
                     message: 'Knowledge Graph is disabled',
                 };
             }
-            const channelId = args.channelId || context.channelId;
-            if (!channelId) {
-                return {
-                    success: false,
-                    phaseContext: null,
-                    message: 'channelId is required but not provided',
-                };
+            if (args.entityIds !== undefined && (!Array.isArray(args.entityIds) ||
+                args.entityIds.some((entityId) => (typeof entityId !== 'string' || entityId.trim().length === 0)))) {
+                throw new Error('entityIds must contain only non-empty entity identifiers');
+            }
+            const entityIds = (args.entityIds || []);
+            if (entityIds.length > 0) {
+                const kgService = getKgService();
+                const scopedEntities = await Promise.all(entityIds.map(entityId => kgService.getEntity(entityId, identity.channelId)));
+                if (scopedEntities.some(entity => !entity)) {
+                    return {
+                        success: false,
+                        phaseContext: null,
+                        message: 'Every phase-context entity must belong to the authenticated channel',
+                    };
+                }
             }
             const orparIntegration = getOrparIntegration();
-            const phaseContext = await orparIntegration.getPhaseContext(channelId, context.agentId, args.phase, args.taskContent, args.entityIds);
+            const phase = requireStringArgument(args, 'phase');
+            const phaseContext = await orparIntegration.getPhaseContext(identity.channelId, identity.agentId, phase, args.taskContent, entityIds);
             return {
                 success: true,
                 phaseContext,
@@ -785,12 +830,12 @@ export const kg_get_phase_context = {
             };
         }
         catch (error) {
-            logger.error('Failed to get phase context', { error: error.message });
+            logger.error('Failed to get phase context', { error: errorMessage(error) });
             return {
                 success: false,
                 phaseContext: null,
                 message: 'Failed to get phase context',
-                error: error.message,
+                error: errorMessage(error),
             };
         }
     },
@@ -820,6 +865,7 @@ export const kg_find_duplicates = {
     },
     handler: async (args, context) => {
         try {
+            const identity = requireKnowledgeGraphIdentity(args, context);
             if (!isKnowledgeGraphEnabled()) {
                 return {
                     success: false,
@@ -827,16 +873,8 @@ export const kg_find_duplicates = {
                     message: 'Knowledge Graph is disabled',
                 };
             }
-            const channelId = args.channelId || context.channelId;
-            if (!channelId) {
-                return {
-                    success: false,
-                    duplicates: [],
-                    message: 'channelId is required but not provided',
-                };
-            }
             const kgService = getKgService();
-            const duplicates = await kgService.findSimilarEntities(channelId, args.threshold || 0.8);
+            const duplicates = await kgService.findSimilarEntities(identity.channelId, args.threshold || 0.8);
             return {
                 success: true,
                 duplicates,
@@ -847,12 +885,12 @@ export const kg_find_duplicates = {
             };
         }
         catch (error) {
-            logger.error('Failed to find duplicates', { error: error.message });
+            logger.error('Failed to find duplicates', { error: errorMessage(error) });
             return {
                 success: false,
                 duplicates: [],
                 message: 'Failed to find duplicates',
-                error: error.message,
+                error: errorMessage(error),
             };
         }
     },
@@ -880,6 +918,7 @@ export const kg_merge_entities = {
     },
     handler: async (args, context) => {
         try {
+            const identity = requireKnowledgeGraphIdentity(args, context);
             if (!isKnowledgeGraphEnabled()) {
                 return {
                     success: false,
@@ -888,22 +927,33 @@ export const kg_merge_entities = {
                 };
             }
             const kgService = getKgService();
-            const result = await kgService.mergeEntities(args.targetEntityId, args.sourceEntityIds, context.agentId);
+            const targetEntityId = requireStringArgument(args, 'targetEntityId');
+            const sourceEntityIds = requireStringArrayArgument(args, 'sourceEntityIds');
+            const entityIds = [targetEntityId, ...sourceEntityIds];
+            const scopedEntities = await Promise.all(entityIds.map((entityId) => kgService.getEntity(entityId, identity.channelId)));
+            if (scopedEntities.some(entity => !entity)) {
+                return {
+                    success: false,
+                    result: null,
+                    message: 'Every merged entity must belong to the authenticated channel',
+                };
+            }
+            const result = await kgService.mergeEntities(targetEntityId, sourceEntityIds, identity.agentId, identity.channelId);
             return {
                 success: result.success,
                 result,
                 message: result.success
-                    ? `Successfully merged ${args.sourceEntityIds.length} entities into target`
+                    ? `Successfully merged ${sourceEntityIds.length} entities into target`
                     : result.error || 'Merge failed',
             };
         }
         catch (error) {
-            logger.error('Failed to merge entities', { error: error.message });
+            logger.error('Failed to merge entities', { error: errorMessage(error) });
             return {
                 success: false,
                 result: null,
                 message: 'Failed to merge entities',
-                error: error.message,
+                error: errorMessage(error),
             };
         }
     },