@utaba/ucm-mcp-server 6.5.1 → 6.7.0

package/dist/tools/memory-graph/GraphProposeVocabularyTool.js

@@ -0,0 +1,149 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+import { GraphProposeVocabularySchema } from '../../../schemas/memory-graph-tool-schemas.js';
+export class GraphProposeVocabularyTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() { return 'ucm_graph_propose_vocabulary'; }
+    get description() {
+        return 'Propose new entity or relationship types, or edit existing types (add/remove/update properties) for a Memory Graph vocabulary. Behaviour depends on the governance mode: auto-approved in "open" mode, queued for review in "managed" mode, rejected in "locked" mode.';
+    }
+    get schema() { return GraphProposeVocabularySchema; }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                memoryGraphId: {
+                    type: 'string',
+                    description: 'The Memory Graph ID'
+                },
+                entityTypes: {
+                    type: 'array',
+                    description: 'New entity types to propose',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            type: { type: 'string', description: 'Entity type name (PascalCase)' },
+                            description: { type: 'string', description: 'Description of the entity type' },
+                            justification: { type: 'string', description: 'Why this entity type is needed' },
+                            properties: {
+                                type: 'array',
+                                items: {
+                                    type: 'object',
+                                    properties: {
+                                        name: { type: 'string', description: 'Property name' },
+                                        type: { type: 'string', description: 'Property type: string, number, boolean, date, enum' },
+                                        required: { type: 'boolean', description: 'Whether the property is required' },
+                                        description: { type: 'string', description: 'Property description' }
+                                    },
+                                    required: ['name', 'type', 'required']
+                                },
+                                description: 'Property schemas for the entity type'
+                            }
+                        },
+                        required: ['type', 'description', 'justification']
+                    }
+                },
+                relationshipTypes: {
+                    type: 'array',
+                    description: 'New relationship types to propose',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            type: { type: 'string', description: 'Relationship type name (SCREAMING_SNAKE_CASE)' },
+                            description: { type: 'string', description: 'Description of the relationship type' },
+                            justification: { type: 'string', description: 'Why this relationship type is needed' },
+                            allowedSourceTypes: { type: 'array', items: { type: 'string' }, description: 'Allowed source entity types' },
+                            allowedTargetTypes: { type: 'array', items: { type: 'string' }, description: 'Allowed target entity types' },
+                            bidirectional: { type: 'boolean', description: 'Whether the relationship is symmetric (default: false)' },
+                            properties: {
+                                type: 'array',
+                                items: {
+                                    type: 'object',
+                                    properties: {
+                                        name: { type: 'string', description: 'Property name' },
+                                        type: { type: 'string', description: 'Property type: string, number, boolean, date, enum' },
+                                        required: { type: 'boolean', description: 'Whether the property is required' },
+                                        description: { type: 'string', description: 'Property description' }
+                                    },
+                                    required: ['name', 'type', 'required']
+                                },
+                                description: 'Property schemas for the relationship type'
+                            }
+                        },
+                        required: ['type', 'description', 'justification', 'allowedSourceTypes', 'allowedTargetTypes']
+                    }
+                },
+                editEntityTypes: {
+                    type: 'array',
+                    description: 'Edits to existing entity types — add, remove, or update properties',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            type: { type: 'string', description: 'Existing entity type name to modify' },
+                            description: { type: 'string', description: 'New description (omit to keep current)' },
+                            justification: { type: 'string', description: 'Why this change is needed' },
+                            addProperties: { type: 'array', items: { type: 'object', properties: { name: { type: 'string' }, type: { type: 'string', description: 'string, number, boolean, date' }, required: { type: 'boolean' }, description: { type: 'string' } }, required: ['name', 'type', 'required'] }, description: 'New properties to add' },
+                            removeProperties: { type: 'array', items: { type: 'string' }, description: 'Property names to remove' },
+                            updateProperties: { type: 'array', items: { type: 'object', properties: { name: { type: 'string' }, type: { type: 'string', description: 'string, number, boolean, date' }, required: { type: 'boolean' }, description: { type: 'string' } }, required: ['name', 'type', 'required'] }, description: 'Existing properties to update (matched by name)' }
+                        },
+                        required: ['type', 'justification']
+                    }
+                },
+                editRelationshipTypes: {
+                    type: 'array',
+                    description: 'Edits to existing relationship types',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            type: { type: 'string', description: 'Existing relationship type name to modify' },
+                            description: { type: 'string', description: 'New description (omit to keep current)' },
+                            justification: { type: 'string', description: 'Why this change is needed' },
+                            allowedSourceTypes: { type: 'array', items: { type: 'string' }, description: 'Replace allowed source entity types' },
+                            allowedTargetTypes: { type: 'array', items: { type: 'string' }, description: 'Replace allowed target entity types' },
+                            bidirectional: { type: 'boolean', description: 'Change bidirectional flag' },
+                            addProperties: { type: 'array', items: { type: 'object', properties: { name: { type: 'string' }, type: { type: 'string' }, required: { type: 'boolean' }, description: { type: 'string' } }, required: ['name', 'type', 'required'] }, description: 'New properties to add' },
+                            removeProperties: { type: 'array', items: { type: 'string' }, description: 'Property names to remove' },
+                            updateProperties: { type: 'array', items: { type: 'object', properties: { name: { type: 'string' }, type: { type: 'string' }, required: { type: 'boolean' }, description: { type: 'string' } }, required: ['name', 'type', 'required'] }, description: 'Existing properties to update (matched by name)' }
+                        },
+                        required: ['type', 'justification']
+                    }
+                }
+            },
+            required: ['memoryGraphId']
+        };
+    }
+    async handleExecute(params) {
+        const { memoryGraphId, entityTypes, relationshipTypes, editEntityTypes, editRelationshipTypes } = params;
+        const hasAny = (entityTypes && entityTypes.length > 0) ||
+            (relationshipTypes && relationshipTypes.length > 0) ||
+            (editEntityTypes && editEntityTypes.length > 0) ||
+            (editRelationshipTypes && editRelationshipTypes.length > 0);
+        if (!hasAny) {
+            throw new McpError(McpErrorCode.InvalidParams, 'At least one of entityTypes, relationshipTypes, editEntityTypes, or editRelationshipTypes must be provided');
+        }
+        this.logger.info('GraphProposeVocabularyTool', `Proposing vocabulary for graph: ${memoryGraphId}`);
+        try {
+            const result = await this.ucmClient.graphProposeVocabulary(memoryGraphId, {
+                // TYPE-EXCEPTION: Zod infers `required?: boolean` but API client expects `required: boolean`;
+                // runtime values are always valid — cast to satisfy the client signature.
+                entityTypes: entityTypes,
+                relationshipTypes: relationshipTypes,
+                editEntityTypes: editEntityTypes,
+                editRelationshipTypes: editRelationshipTypes,
+            });
+            return JSON.stringify(result);
+        }
+        catch (error) {
+            if (error.response?.status === 400) {
+                throw new McpError(McpErrorCode.InvalidParams, error.response.data?.message || 'Validation error');
+            }
+            if (error.response?.status === 404) {
+                throw new McpError(McpErrorCode.InvalidParams, `Memory Graph not found`);
+            }
+            throw new McpError(McpErrorCode.InternalError, `Failed to propose vocabulary: ${error.message}`);
+        }
+    }
+}
+//# sourceMappingURL=GraphProposeVocabularyTool.js.map

package/dist/tools/memory-graph/GraphSearchTool.d.ts

@@ -0,0 +1,14 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
+import { ILogger } from '../../interfaces/ILogger.js';
+import { type GraphSearchParams } from '../../../schemas/memory-graph-tool-schemas.js';
+import { ZodSchema } from 'zod';
+export declare class GraphSearchTool extends BaseToolController {
+    constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
+    get name(): string;
+    get description(): string;
+    get schema(): ZodSchema;
+    get inputSchema(): Record<string, unknown>;
+    protected handleExecute(params: GraphSearchParams): Promise<string>;
+}
+//# sourceMappingURL=GraphSearchTool.d.ts.map

package/dist/tools/memory-graph/GraphSearchTool.js

@@ -0,0 +1,94 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+import { GraphSearchSchema } from '../../../schemas/memory-graph-tool-schemas.js';
+export class GraphSearchTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() { return 'ucm_graph_search'; }
+    get description() {
+        return 'Semantic search across one or more Memory Graphs using vector similarity. Uses embeddings if available. Returns entities ranked by relevance to the query concept. Provide memoryGraphId for single-graph search, graphIds (array) for multi-graph search, or omit both to search all accessible graphs.';
+    }
+    get schema() { return GraphSearchSchema; }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                memoryGraphId: {
+                    type: 'string',
+                    description: 'Single Memory Graph ID to search (use this for single-graph search)'
+                },
+                graphIds: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Multiple Memory Graph IDs to search across (use this for multi-graph search)'
+                },
+                query: {
+                    type: 'string',
+                    description: 'Natural language query to search for (will be embedded and compared against entity embeddings)'
+                },
+                entityTypes: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Filter results by entity types'
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum results (default: 10, max: 50)'
+                },
+                similarityThreshold: {
+                    type: 'number',
+                    description: 'Minimum similarity score threshold (0-1, default: 0.7)'
+                }
+            },
+            required: ['query']
+        };
+    }
+    async handleExecute(params) {
+        const { memoryGraphId, graphIds, query, entityTypes, limit, similarityThreshold } = params;
+        // Use single-graph search only when memoryGraphId is provided and graphIds is not
+        if (memoryGraphId && !graphIds) {
+            this.logger.info('GraphSearchTool', `Searching single graph: ${memoryGraphId}`);
+            try {
+                const result = await this.ucmClient.graphSearch(memoryGraphId, query, {
+                    entityTypes,
+                    limit,
+                    similarityThreshold
+                });
+                return JSON.stringify(result);
+            }
+            catch (error) {
+                if (error.response?.status === 422) {
+                    const detail = error.response?.data?.message || 'Embeddings are not configured for this Memory Graph';
+                    throw new McpError(McpErrorCode.InvalidRequest, detail);
+                }
+                if (error.response?.status === 404) {
+                    throw new McpError(McpErrorCode.InvalidParams, `Memory Graph not found`);
+                }
+                throw new McpError(McpErrorCode.InternalError, `Failed to search graph: ${error.message}`);
+            }
+        }
+        // Multi-graph search: graphIds provided, or neither memoryGraphId nor graphIds provided
+        this.logger.info('GraphSearchTool', `Searching multiple graphs`);
+        try {
+            const result = await this.ucmClient.graphSearchMultiple(query, {
+                graphIds,
+                entityTypes,
+                limit,
+                similarityThreshold
+            });
+            return JSON.stringify(result);
+        }
+        catch (error) {
+            if (error.response?.status === 422) {
+                const detail = error.response?.data?.message || 'Embeddings are not configured for one or more Memory Graphs';
+                throw new McpError(McpErrorCode.InvalidRequest, detail);
+            }
+            if (error.response?.status === 404) {
+                throw new McpError(McpErrorCode.InvalidParams, `One or more Memory Graphs not found`);
+            }
+            throw new McpError(McpErrorCode.InternalError, `Failed to search graphs: ${error.message}`);
+        }
+    }
+}
+//# sourceMappingURL=GraphSearchTool.js.map

package/dist/tools/memory-graph/GraphTraverseTool.d.ts

@@ -0,0 +1,14 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
+import { ILogger } from '../../interfaces/ILogger.js';
+import { type GraphTraverseParams } from '../../../schemas/memory-graph-tool-schemas.js';
+import { ZodSchema } from 'zod';
+export declare class GraphTraverseTool extends BaseToolController {
+    constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
+    get name(): string;
+    get description(): string;
+    get schema(): ZodSchema;
+    get inputSchema(): Record<string, unknown>;
+    protected handleExecute(params: GraphTraverseParams): Promise<string>;
+}
+//# sourceMappingURL=GraphTraverseTool.d.ts.map

package/dist/tools/memory-graph/GraphTraverseTool.js

@@ -0,0 +1,114 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+import { GraphTraverseSchema } from '../../../schemas/memory-graph-tool-schemas.js';
+export class GraphTraverseTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() { return 'ucm_graph_traverse'; }
+    get description() {
+        return 'Execute a structured graph traversal using a JSON spec. Supports start point selection, ordered hop steps with relationship/entity type filters, property filters, repeat loops, and multiple return modes (terminal, all, paths). The most powerful query tool for complex graph navigation.';
+    }
+    get schema() { return GraphTraverseSchema; }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                memoryGraphId: {
+                    type: 'string',
+                    description: 'The Memory Graph ID'
+                },
+                start: {
+                    type: 'object',
+                    description: 'Start point specification',
+                    properties: {
+                        entityId: { type: 'string', description: 'Start from a specific entity ID or slug' },
+                        entityType: { type: 'string', description: 'Start from all entities of this type' },
+                        filter: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    key: { type: 'string' },
+                                    operator: { type: 'string', description: 'eq, neq, gt, gte, lt, lte, contains, isNull, isNotNull' },
+                                    value: {}
+                                },
+                                required: ['key', 'operator']
+                            },
+                            description: 'Property filters on start entities'
+                        }
+                    }
+                },
+                steps: {
+                    type: 'array',
+                    description: 'Ordered traversal steps (hops)',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            direction: { type: 'string', enum: ['out', 'in', 'both'], description: 'Hop direction' },
+                            relationshipTypes: { type: 'array', items: { type: 'string' }, description: 'Filter by relationship types' },
+                            entityTypes: { type: 'array', items: { type: 'string' }, description: 'Filter by entity types at this step' },
+                            entityFilter: {
+                                type: 'array',
+                                items: {
+                                    type: 'object',
+                                    properties: {
+                                        key: { type: 'string' },
+                                        operator: { type: 'string' },
+                                        value: {}
+                                    },
+                                    required: ['key', 'operator']
+                                },
+                                description: 'Property filters on entities at this step'
+                            },
+                            repeat: {
+                                type: 'object',
+                                properties: {
+                                    maxDepth: { type: 'number', description: 'Maximum repeat depth' },
+                                    emitIntermediates: { type: 'boolean', description: 'Include intermediate results' }
+                                },
+                                description: 'Repeat this step up to maxDepth times'
+                            }
+                        }
+                    }
+                },
+                returnMode: {
+                    type: 'string',
+                    enum: ['terminal', 'all', 'path'],
+                    description: 'What to return: terminal (only final step entities), all (every visited entity), path (full traversal paths with relationships). Default: terminal'
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum results (default: 50, max: 200)'
+                },
+                detailLevel: {
+                    type: 'string',
+                    enum: ['brief', 'summary', 'full'],
+                    description: 'Detail level for returned entities (default: summary)'
+                }
+            },
+            required: ['memoryGraphId', 'start', 'steps']
+        };
+    }
+    async handleExecute(params) {
+        const { memoryGraphId, start, steps, returnMode, limit, detailLevel } = params;
+        this.logger.info('GraphTraverseTool', `Traversing graph: ${memoryGraphId}`);
+        try {
+            const result = await this.ucmClient.graphTraverse(memoryGraphId, {
+                start,
+                steps,
+                returnMode,
+                limit,
+                detailLevel
+            });
+            return JSON.stringify(result);
+        }
+        catch (error) {
+            if (error.response?.status === 404) {
+                throw new McpError(McpErrorCode.InvalidParams, `Memory Graph not found`);
+            }
+            throw new McpError(McpErrorCode.InternalError, `Failed to traverse graph: ${error.message}`);
+        }
+    }
+}
+//# sourceMappingURL=GraphTraverseTool.js.map

package/dist/tools/memory-graph/GraphUpdateEntitiesTool.d.ts

@@ -0,0 +1,14 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
+import { ILogger } from '../../interfaces/ILogger.js';
+import { type GraphUpdateEntitiesParams } from '../../../schemas/memory-graph-tool-schemas.js';
+import { ZodSchema } from 'zod';
+export declare class GraphUpdateEntitiesTool extends BaseToolController {
+    constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
+    get name(): string;
+    get description(): string;
+    get schema(): ZodSchema;
+    get inputSchema(): Record<string, unknown>;
+    protected handleExecute(params: GraphUpdateEntitiesParams): Promise<string>;
+}
+//# sourceMappingURL=GraphUpdateEntitiesTool.d.ts.map

package/dist/tools/memory-graph/GraphUpdateEntitiesTool.js

@@ -0,0 +1,58 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+import { GraphUpdateEntitiesSchema } from '../../../schemas/memory-graph-tool-schemas.js';
+export class GraphUpdateEntitiesTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() { return 'ucm_graph_update_entities'; }
+    get description() {
+        return 'Update one or more entities in a Memory Graph. Each update specifies an entityId and the fields to change (label, summary, properties, data). Pass a single item in the array for single operations.';
+    }
+    get schema() { return GraphUpdateEntitiesSchema; }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                memoryGraphId: {
+                    type: 'string',
+                    description: 'The Memory Graph ID'
+                },
+                updates: {
+                    type: 'array',
+                    description: 'Array of entity updates',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            entityId: { type: 'string', description: 'The entity ID to update' },
+                            label: { type: 'string', description: 'New label' },
+                            summary: { type: 'string', description: 'New summary' },
+                            properties: { type: 'object', description: 'Properties to update (merged with existing)' },
+                            data: { type: 'object', description: 'Data to update (merged with existing)' }
+                        },
+                        required: ['entityId']
+                    }
+                }
+            },
+            required: ['memoryGraphId', 'updates']
+        };
+    }
+    async handleExecute(params) {
+        const { memoryGraphId, updates } = params;
+        this.logger.info('GraphUpdateEntitiesTool', `Updating ${updates.length} entities in graph: ${memoryGraphId}`);
+        try {
+            const result = await this.ucmClient.graphUpdateEntities(memoryGraphId, updates);
+            return JSON.stringify(result);
+        }
+        catch (error) {
+            if (error.response?.status === 400) {
+                throw new McpError(McpErrorCode.InvalidParams, error.response.data?.message || 'Validation error');
+            }
+            if (error.response?.status === 404) {
+                throw new McpError(McpErrorCode.InvalidParams, `Entity or Memory Graph not found`);
+            }
+            throw new McpError(McpErrorCode.InternalError, `Failed to update entities: ${error.message}`);
+        }
+    }
+}
+//# sourceMappingURL=GraphUpdateEntitiesTool.js.map

package/dist/tools/memory-graph/GraphUpdateTool.d.ts

@@ -0,0 +1,14 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
+import { ILogger } from '../../interfaces/ILogger.js';
+import { type GraphUpdateParams } from '../../../schemas/memory-graph-tool-schemas.js';
+import { ZodSchema } from 'zod';
+export declare class GraphUpdateTool extends BaseToolController {
+    constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
+    get name(): string;
+    get description(): string;
+    get schema(): ZodSchema;
+    get inputSchema(): Record<string, unknown>;
+    protected handleExecute(params: GraphUpdateParams): Promise<string>;
+}
+//# sourceMappingURL=GraphUpdateTool.d.ts.map

package/dist/tools/memory-graph/GraphUpdateTool.js

@@ -0,0 +1,59 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+import { GraphUpdateSchema } from '../../../schemas/memory-graph-tool-schemas.js';
+export class GraphUpdateTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() { return 'ucm_graph_update'; }
+    get description() {
+        return 'Update a Memory Graph\'s metadata — label, description, or usage instructions. Use this to update usage instructions with per-graph behavioural rules. Whole-document replacement for usageInstructions.';
+    }
+    get schema() { return GraphUpdateSchema; }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                memoryGraphId: {
+                    type: 'string',
+                    description: 'The ID of the Memory Graph to update'
+                },
+                label: {
+                    type: 'string',
+                    description: 'New display name for the Memory Graph'
+                },
+                description: {
+                    type: ['string', 'null'],
+                    description: 'New description of the Memory Graph purpose'
+                },
+                usageInstructions: {
+                    type: ['string', 'null'],
+                    description: 'Per-graph behavioural rules and usage instructions. Whole-document replacement.'
+                }
+            },
+            required: ['memoryGraphId']
+        };
+    }
+    async handleExecute(params) {
+        const { memoryGraphId, label, description, usageInstructions } = params;
+        this.logger.info('GraphUpdateTool', `Updating memory graph: ${memoryGraphId}`);
+        try {
+            const result = await this.ucmClient.updateMemoryGraph(memoryGraphId, { label, description, usageInstructions });
+            return JSON.stringify(result);
+        }
+        catch (error) {
+            if (error.response?.status === 400) {
+                const detail = error.response?.data?.message || 'Invalid parameters for graph update';
+                throw new McpError(McpErrorCode.InvalidParams, detail);
+            }
+            if (error.response?.status === 403) {
+                throw new McpError(McpErrorCode.InvalidParams, 'Access denied: you do not have permission to update this Memory Graph.');
+            }
+            if (error.response?.status === 404) {
+                throw new McpError(McpErrorCode.InvalidParams, `Memory Graph not found: ${memoryGraphId}`);
+            }
+            throw new McpError(McpErrorCode.InternalError, `Failed to update memory graph: ${error.message}`);
+        }
+    }
+}
+//# sourceMappingURL=GraphUpdateTool.js.map

package/dist/tools/memory-graph/KnowledgeSetListTool.d.ts

@@ -0,0 +1,14 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
+import { ILogger } from '../../interfaces/ILogger.js';
+import { type KnowledgeSetListParams } from '../../../schemas/memory-graph-tool-schemas.js';
+import { ZodSchema } from 'zod';
+export declare class KnowledgeSetListTool extends BaseToolController {
+    constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
+    get name(): string;
+    get description(): string;
+    get schema(): ZodSchema;
+    get inputSchema(): Record<string, unknown>;
+    protected handleExecute(_params: KnowledgeSetListParams): Promise<string>;
+}
+//# sourceMappingURL=KnowledgeSetListTool.d.ts.map

package/dist/tools/memory-graph/KnowledgeSetListTool.js

@@ -0,0 +1,25 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { KnowledgeSetListSchema } from '../../../schemas/memory-graph-tool-schemas.js';
+export class KnowledgeSetListTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() { return 'ucm_knowledge_set_list'; }
+    get description() {
+        return 'List Knowledge Sets you have access to. Use `ucm_knowledge_set_open` with a Knowledge Set ID to explore its contents.';
+    }
+    get schema() { return KnowledgeSetListSchema; }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {},
+            required: []
+        };
+    }
+    async handleExecute(_params) {
+        this.logger.info('KnowledgeSetListTool', 'Listing knowledge sets');
+        const result = await this.ucmClient.listKnowledgeSetSummary();
+        return result;
+    }
+}
+//# sourceMappingURL=KnowledgeSetListTool.js.map

package/dist/tools/memory-graph/KnowledgeSetOpenTool.d.ts

@@ -0,0 +1,14 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
+import { ILogger } from '../../interfaces/ILogger.js';
+import { type KnowledgeSetOpenParams } from '../../../schemas/memory-graph-tool-schemas.js';
+import { ZodSchema } from 'zod';
+export declare class KnowledgeSetOpenTool extends BaseToolController {
+    constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
+    get name(): string;
+    get description(): string;
+    get schema(): ZodSchema;
+    get inputSchema(): Record<string, unknown>;
+    protected handleExecute(_params: KnowledgeSetOpenParams): Promise<string>;
+}
+//# sourceMappingURL=KnowledgeSetOpenTool.d.ts.map

package/dist/tools/memory-graph/KnowledgeSetOpenTool.js

@@ -0,0 +1,31 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { KnowledgeSetOpenSchema } from '../../../schemas/memory-graph-tool-schemas.js';
+export class KnowledgeSetOpenTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() { return 'ucm_knowledge_set_open'; }
+    get description() {
+        return 'Open a Knowledge Set to see its contents — Memory Graphs, artifact repositories, and artifact namespaces — with guidance on which tools to use for each.';
+    }
+    get schema() { return KnowledgeSetOpenSchema; }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                knowledgeSetId: {
+                    type: 'string',
+                    description: 'The Knowledge Set ID to open'
+                }
+            },
+            required: ['knowledgeSetId']
+        };
+    }
+    async handleExecute(_params) {
+        const { knowledgeSetId } = _params;
+        this.logger.info('KnowledgeSetOpenTool', `Opening knowledge set ${knowledgeSetId}`);
+        const result = await this.ucmClient.openKnowledgeSet(knowledgeSetId);
+        return result;
+    }
+}
+//# sourceMappingURL=KnowledgeSetOpenTool.js.map