@utaba/ucm-mcp-server 6.5.1 → 6.7.0

package/dist/tools/base/BaseToolController.js

@@ -1,4 +1,5 @@
 import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+import { ZodError } from 'zod';
 export class BaseToolController {
     ucmClient;
     logger;
@@ -8,29 +9,45 @@ export class BaseToolController {
         this.logger = logger;
         this.publishingAuthorId = publishingAuthorId;
     }
+    /** Override to provide a zod schema for runtime validation */
+    get schema() { return undefined; }
     async execute(params) {
         try {
-            this.validateParams(params);
-            return await this.handleExecute(params);
+            let validated;
+            if (this.schema) {
+                validated = this.schema.parse(params);
+            }
+            else {
+                this.validateParams(params);
+                validated = params;
+            }
+            return await this.handleExecute(validated);
         }
         catch (error) {
+            if (error instanceof ZodError) {
+                throw new McpError(McpErrorCode.InvalidParams, `Invalid parameters: ${error.errors.map(e => `${e.path.join('.')}: ${e.message}`).join(', ')}`);
+            }
             // Sanitize error for logging to avoid circular reference issues with axios errors
+            const err = error;
+            const response = err?.response;
+            const config = err?.config;
             const sanitizedError = {
-                message: error?.message,
-                name: error?.name,
-                status: error?.response?.status,
-                statusText: error?.response?.statusText,
-                data: error?.response?.data,
-                url: error?.config?.url
+                message: err?.message,
+                name: err?.name,
+                status: response?.status,
+                statusText: response?.statusText,
+                data: response?.data,
+                url: config?.url
             };
             this.logger.error('BaseToolController', `Tool ${this.name} execution failed`, '', sanitizedError);
             throw error;
         }
     }
     validateParams(params) {
-        // Basic validation - can be overridden by specific tools
-        if (this.inputSchema.required) {
-            for (const field of this.inputSchema.required) {
+        // Legacy validation for tools that haven't adopted zod schemas yet
+        const schema = this.inputSchema;
+        if (schema.required) {
+            for (const field of schema.required) {
                 if (params[field] === undefined || params[field] === null) {
                     throw new McpError(McpErrorCode.InvalidParams, `Required parameter '${field}' is missing`);
                 }

package/dist/tools/connections/AccessConnectionTool.js

@@ -11,7 +11,7 @@ export class AccessConnectionTool extends BaseToolController {
         super(ucmClient, logger, publishingAuthorId);
     }
     get name() {
-        return 'ucm_access_connection';
+        return 'ucm_connection_access';
     }
     get description() {
         return 'Access a specific external connection, check auth status, and return available tool schemas. Call without toolNames to get a summary index of all available tools. Pass toolNames to retrieve full parameter schemas.';
@@ -22,7 +22,7 @@ export class AccessConnectionTool extends BaseToolController {
             properties: {
                 connectionId: {
                     type: 'string',
-                    description: 'Connection ID (SharePoint connection or Remote MCP Server) from ucm_list_connections',
+                    description: 'Connection ID (SharePoint connection or Remote MCP Server) from ucm_connection_list',
                     minLength: 36,
                     maxLength: 36
                 },

package/dist/tools/connections/CallRemoteToolTool.js

@@ -11,7 +11,7 @@ export class CallRemoteToolTool extends BaseToolController {
         super(ucmClient, logger, publishingAuthorId);
     }
     get name() {
-        return 'ucm_call_remote_tool';
+        return 'ucm_connection_call_tool';
     }
     get description() {
         return 'Call a tool on an external connection.';
@@ -22,13 +22,13 @@ export class CallRemoteToolTool extends BaseToolController {
             properties: {
                 connectionId: {
                     type: 'string',
-                    description: 'Connection ID (SharePoint connection or Remote MCP Server) from ucm_list_connections',
+                    description: 'Connection ID (SharePoint connection or Remote MCP Server) from ucm_connection_list',
                     minLength: 36,
                     maxLength: 36
                 },
                 toolName: {
                     type: 'string',
-                    description: 'Name of the tool to call (see ucm_access_connection for available tools)',
+                    description: 'Name of the tool to call (see ucm_connection_access for available tools)',
                     minLength: 1
                 },
                 args: {

package/dist/tools/core/DeleteArtifactTool.js

@@ -4,7 +4,7 @@ export class DeleteArtifactTool extends BaseToolController {
         super(ucmClient, logger, publishingAuthorId);
     }
     get name() {
-        return 'ucm_delete_artifact';
+        return 'ucm_artifact_delete';
     }
     get description() {
         return 'Delete a UCM artifact by path and version. This action cannot be undone. Only the latest or specified version is deleted.';
@@ -13,7 +13,7 @@ export class DeleteArtifactTool extends BaseToolController {
         return {
             type: 'object',
             properties: {
-                author: {
+                workspace: {
                     type: 'string',
                     description: `Author name (e.g., ${this.publishingAuthorId || '01234567890'})`,
                     minLength: 1,
@@ -44,11 +44,12 @@ export class DeleteArtifactTool extends BaseToolController {
                     maxLength: 150
                 }
             },
-            required: ['author', 'repository', 'category', 'subcategory', 'filename']
+            required: ['workspace', 'repository', 'category', 'subcategory', 'filename']
         };
     }
     async handleExecute(params) {
-        const { author, repository, category, subcategory, filename } = params;
+        const { workspace, repository, category, subcategory, filename } = params;
+        const author = workspace;
         this.logger.debug('DeleteArtifactTool', `Deleting artifact: ${author}/${repository}/${category}/${subcategory}/${filename}`);
         try {
             // Parse filename to extract version if present

package/dist/tools/core/EditArtifactMetadataTool.js

@@ -6,7 +6,7 @@ export class EditArtifactMetadataTool extends BaseToolController {
         super(ucmClient, logger, publishingAuthorId);
     }
     get name() {
-        return 'ucm_edit_artifact_metadata';
+        return 'ucm_artifact_edit_metadata';
     }
     get description() {
         return 'Edit artifact metadata and move artifacts. Supports updating description, namespace, filename, MIME type, technology, and tags. Move operations affect all versions while metadata-only updates apply to latest version only.';

package/dist/tools/core/GetArtifactTool.js

@@ -8,7 +8,7 @@ export class GetArtifactTool extends BaseToolController {
         this.trustedAuthors = trustedAuthors;
     }
     get name() {
-        return 'ucm_get_artifact';
+        return 'ucm_artifact_get';
     }
     get description() {
         return 'Retrieve UCM artifact content with metadata. Large files are automatically chunked.';

package/dist/tools/core/GetArtifactVersionsTool.js

@@ -5,7 +5,7 @@ export class GetArtifactVersionsTool extends BaseToolController {
         super(ucmClient, logger, publishingAuthorId);
     }
     get name() {
-        return 'ucm_get_artifact_versions';
+        return 'ucm_artifact_get_versions';
     }
     get description() {
         return 'Get all available versions of a specific UCM artifact';

package/dist/tools/core/GetChunkTool.js

@@ -6,7 +6,7 @@ export class GetChunkTool extends BaseToolController {
         super(ucmClient, logger, publishingAuthorId);
     }
     get name() {
-        return 'ucm_get_chunk';
+        return 'ucm_artifact_get_chunk';
     }
     get description() {
         return 'Retrieve the next chunk of a large UCM artifact response';

package/dist/tools/core/ListArtifactsTool.js

@@ -5,7 +5,7 @@ export class ListArtifactsTool extends BaseToolController {
         super(ucmClient, logger, publishingAuthorId);
     }
     get name() {
-        return 'ucm_list_artifacts';
+        return 'ucm_artifact_list';
     }
     get description() {
         return `List artifacts with exploratory browsing support. Can list authors, repositories, categories, subcategories, or artifacts depending on path depth. ${this.publishingAuthorId ? "Your author value is '" + this.publishingAuthorId + "'" : ''}`;

package/dist/tools/core/MoveArtifactTool.d.ts

@@ -6,7 +6,7 @@ export declare class MoveArtifactTool extends BaseToolController {
     get name(): string;
     get description(): string;
     get inputSchema(): Record<string, unknown>;
-    protected handleExecute(params: Record<string, unknown>): Promise<Record<string, unknown>>;
+    protected handleExecute(params: Record<string, unknown>): Promise<string>;
     protected validateParams(params: Record<string, unknown>): void;
 }
 //# sourceMappingURL=MoveArtifactTool.d.ts.map

package/dist/tools/core/MoveArtifactTool.js

@@ -6,7 +6,7 @@ export class MoveArtifactTool extends BaseToolController {
         super(ucmClient, logger, publishingAuthorId);
     }
     get name() {
-        return 'ucm_move_artifact';
+        return 'ucm_artifact_move';
     }
     get description() {
         return 'Move an artifact from one namespace location to another. All versions are moved. Requires read access on source and write access on destination.';
@@ -57,7 +57,7 @@ export class MoveArtifactTool extends BaseToolController {
                 _links: responseData._links || {}
             };
             this.logger.info('MoveArtifactTool', `Artifact moved successfully: ${sourcePath} → ${destinationPath}`);
-            return response;
+            return JSON.stringify(response);
         }
         catch (error) {
             this.logger.error('MoveArtifactTool', `Failed to move artifact: ${sourcePath} → ${destinationPath}`, '', error);

package/dist/tools/core/PublishArtifactFromFileTool.js

@@ -8,7 +8,7 @@ export class PublishArtifactFromFileTool extends BaseToolController {
         super(ucmClient, logger, publishingAuthorId);
     }
     get name() {
-        return 'ucm_publish_artifact_fromfile';
+        return 'ucm_artifact_publish_from_file';
     }
     get description() {
         return 'Create or update UCM artifacts from a file URI. Supports versioning. PREFERRED METHOD: Use this tool for file-based content as it is much faster and more efficient. Pass the local file path as a file:// URI (e.g., "file:///path/to/file.txt").';

package/dist/tools/core/PublishArtifactTool.js

@@ -6,10 +6,10 @@ export class PublishArtifactTool extends BaseToolController {
         super(ucmClient, logger, publishingAuthorId);
     }
     get name() {
-        return 'ucm_publish_artifact';
+        return 'ucm_artifact_publish';
     }
     get description() {
-        return 'Create or update UCM artifacts with content and metadata. Supports versioning and automatic conflict detection. The API automatically detects whether to create or update based on existing artifacts. NOTE: Only use this tool for small data - use ucm_publish_artifact_fromfile for files as it is much faster and more efficient.';
+        return 'Create or update UCM artifacts with content and metadata. Supports versioning and automatic conflict detection. The API automatically detects whether to create or update based on existing artifacts. NOTE: Only use this tool for small data - use ucm_artifact_publish_from_file for files as it is much faster and more efficient.';
     }
     get inputSchema() {
         return {

package/dist/tools/core/SearchArtifactsTool.js

@@ -4,10 +4,10 @@ export class SearchArtifactsTool extends BaseToolController {
         super(ucmClient, logger, publishingAuthorId);
     }
     get name() {
-        return 'ucm_search_artifacts';
+        return 'ucm_artifact_search';
     }
     get description() {
-        return `Search artifacts by text across multiple metadata fields with privacy filtering. Searches namespace, filename, description, and tags fields. ${this.publishingAuthorId ? "Your author value is '" + this.publishingAuthorId + "'" : ''}`;
+        return `Search your workspaces by text across multiple metadata fields. Searches namespace, filename, description, and tags fields. ${this.publishingAuthorId ? "Your workspace value is '" + this.publishingAuthorId + "'" : ''}`;
     }
     get inputSchema() {
         return {
@@ -21,12 +21,12 @@ export class SearchArtifactsTool extends BaseToolController {
                 },
                 namespace: {
                     type: 'string',
-                    description: 'Optional namespace filter (e.g., "utaba/main/commands/user")',
+                    description: 'Optional namespace filter (e.g., "main/commands/user")',
                     maxLength: 200
                 },
-                author: {
+                workspace: {
                     type: 'string',
-                    description: `Optional.  Leave empty to search your own author and public authors.  '(e.g., "' + this.publishingAuthorId + '")' : ''}`,
+                    description: `Optional workspace filter. Leave empty to search your workspaces. ${this.publishingAuthorId ? '(e.g., "' + this.publishingAuthorId + '")' : ''}`,
                     maxLength: 50
                 },
                 repository: {
@@ -70,7 +70,8 @@ export class SearchArtifactsTool extends BaseToolController {
         };
     }
     async handleExecute(params) {
-        const { searchText, namespace, author, repository, category, subcategory, filename, tags, offset, limit } = params;
+        const { searchText, namespace, workspace, repository, category, subcategory, filename, tags, offset, limit } = params;
+        const author = workspace;
         this.logger.debug('SearchArtifactsTool', `Searching with filters`, '', {
             searchText,
             namespace,

package/dist/tools/memory-graph/GraphCreateEntitiesTool.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 GraphCreateEntitiesParams } from '../../../schemas/memory-graph-tool-schemas.js';
+import { ZodSchema } from 'zod';
+export declare class GraphCreateEntitiesTool 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: GraphCreateEntitiesParams): Promise<string>;
+}
+//# sourceMappingURL=GraphCreateEntitiesTool.d.ts.map

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

@@ -0,0 +1,58 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+import { GraphCreateEntitiesSchema } from '../../../schemas/memory-graph-tool-schemas.js';
+export class GraphCreateEntitiesTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() { return 'ucm_graph_create_entities'; }
+    get description() {
+        return 'Create one or more entities in a Memory Graph. Each entity requires a type (from vocabulary) and label. Properties are validated against the vocabulary schema. Pass a single item in the array for single operations.';
+    }
+    get schema() { return GraphCreateEntitiesSchema; }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                memoryGraphId: {
+                    type: 'string',
+                    description: 'The Memory Graph ID'
+                },
+                entities: {
+                    type: 'array',
+                    description: 'Array of entities to create',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            entityType: { type: 'string', description: 'Entity type (must exist in vocabulary)' },
+                            label: { type: 'string', description: 'Human-readable label for the entity' },
+                            summary: { type: 'string', description: 'Brief summary/description' },
+                            properties: { type: 'object', description: 'Entity properties (validated against vocabulary schema)' },
+                            data: { type: ['string', 'object'], description: 'Optional freeform data attached to the entity' }
+                        },
+                        required: ['entityType', 'label']
+                    }
+                }
+            },
+            required: ['memoryGraphId', 'entities']
+        };
+    }
+    async handleExecute(params) {
+        const { memoryGraphId, entities } = params;
+        this.logger.info('GraphCreateEntitiesTool', `Creating ${entities.length} entities in graph: ${memoryGraphId}`);
+        try {
+            const result = await this.ucmClient.graphCreateEntities(memoryGraphId, entities);
+            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 create entities: ${error.message}`);
+        }
+    }
+}
+//# sourceMappingURL=GraphCreateEntitiesTool.js.map

package/dist/tools/memory-graph/GraphCreateRelationshipsTool.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 GraphCreateRelationshipsParams } from '../../../schemas/memory-graph-tool-schemas.js';
+import { ZodSchema } from 'zod';
+export declare class GraphCreateRelationshipsTool 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: GraphCreateRelationshipsParams): Promise<string>;
+}
+//# sourceMappingURL=GraphCreateRelationshipsTool.d.ts.map

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

@@ -0,0 +1,57 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+import { GraphCreateRelationshipsSchema } from '../../../schemas/memory-graph-tool-schemas.js';
+export class GraphCreateRelationshipsTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() { return 'ucm_graph_create_relationships'; }
+    get description() {
+        return 'Create one or more relationships between entities in a Memory Graph. Each relationship requires a type (from vocabulary), source entity ID, and target entity ID. Pass a single item in the array for single operations.';
+    }
+    get schema() { return GraphCreateRelationshipsSchema; }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                memoryGraphId: {
+                    type: 'string',
+                    description: 'The Memory Graph ID'
+                },
+                relationships: {
+                    type: 'array',
+                    description: 'Array of relationships to create',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            relationshipType: { type: 'string', description: 'Relationship type (must exist in vocabulary)' },
+                            sourceEntityId: { type: 'string', description: 'Source entity ID' },
+                            targetEntityId: { type: 'string', description: 'Target entity ID' },
+                            properties: { type: 'object', description: 'Optional relationship properties' }
+                        },
+                        required: ['relationshipType', 'sourceEntityId', 'targetEntityId']
+                    }
+                }
+            },
+            required: ['memoryGraphId', 'relationships']
+        };
+    }
+    async handleExecute(params) {
+        const { memoryGraphId, relationships } = params;
+        this.logger.info('GraphCreateRelationshipsTool', `Creating ${relationships.length} relationships in graph: ${memoryGraphId}`);
+        try {
+            const result = await this.ucmClient.graphCreateRelationships(memoryGraphId, relationships);
+            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 create relationships: ${error.message}`);
+        }
+    }
+}
+//# sourceMappingURL=GraphCreateRelationshipsTool.js.map

package/dist/tools/memory-graph/GraphCreateTool.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 GraphCreateParams } from '../../../schemas/memory-graph-tool-schemas.js';
+import { ZodSchema } from 'zod';
+export declare class GraphCreateTool 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: GraphCreateParams): Promise<string>;
+}
+//# sourceMappingURL=GraphCreateTool.d.ts.map

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

@@ -0,0 +1,64 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+import { GraphCreateSchema } from '../../../schemas/memory-graph-tool-schemas.js';
+export class GraphCreateTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() { return 'ucm_graph_create'; }
+    get description() {
+        return 'Create a new Memory Graph with a vocabulary template. Defaults to a personal graph. Set scope to \'organization\' to create an org-wide graph (requires Owner role). Call ucm_graph_list_templates first to see available templates.';
+    }
+    get schema() { return GraphCreateSchema; }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                label: {
+                    type: 'string',
+                    description: 'Display name for the new Memory Graph'
+                },
+                templateId: {
+                    type: 'string',
+                    description: 'Vocabulary template ID to use for the graph. Use ucm_graph_list_templates to see available templates.'
+                },
+                description: {
+                    type: 'string',
+                    description: 'Optional description of the Memory Graph purpose'
+                },
+                scope: {
+                    type: 'string',
+                    enum: ['personal', 'organization'],
+                    description: 'Graph ownership scope. "personal" (default) creates a graph owned by you. "organization" creates an org-wide graph (requires Owner role).'
+                }
+            },
+            required: ['label', 'templateId']
+        };
+    }
+    async handleExecute(params) {
+        const { label, templateId, description, scope } = params;
+        const resolvedScope = scope || 'personal';
+        this.logger.info('GraphCreateTool', `Creating ${resolvedScope} memory graph: ${label}`);
+        try {
+            const result = await this.ucmClient.createMemoryGraph({ label, templateId, description, scope: resolvedScope });
+            return JSON.stringify(result);
+        }
+        catch (error) {
+            if (error.response?.status === 400) {
+                const detail = error.response?.data?.message || 'Invalid parameters for graph creation';
+                throw new McpError(McpErrorCode.InvalidParams, detail);
+            }
+            if (error.response?.status === 403) {
+                throw new McpError(McpErrorCode.InvalidParams, 'Creating an organisation graph requires Owner role on the organisation.');
+            }
+            if (error.response?.status === 404) {
+                throw new McpError(McpErrorCode.InvalidParams, `Template not found: ${templateId}`);
+            }
+            if (error.response?.status === 503) {
+                throw new McpError(McpErrorCode.InternalError, `Deep Memory service is not configured`);
+            }
+            throw new McpError(McpErrorCode.InternalError, `Failed to create memory graph: ${error.message}`);
+        }
+    }
+}
+//# sourceMappingURL=GraphCreateTool.js.map

package/dist/tools/memory-graph/GraphDeleteEntitiesTool.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 GraphDeleteEntitiesParams } from '../../../schemas/memory-graph-tool-schemas.js';
+import { ZodSchema } from 'zod';
+export declare class GraphDeleteEntitiesTool 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: GraphDeleteEntitiesParams): Promise<string>;
+}
+//# sourceMappingURL=GraphDeleteEntitiesTool.d.ts.map

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

@@ -0,0 +1,45 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+import { GraphDeleteEntitiesSchema } from '../../../schemas/memory-graph-tool-schemas.js';
+export class GraphDeleteEntitiesTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() { return 'ucm_graph_delete_entities'; }
+    get description() {
+        return 'Delete one or more entities from a Memory Graph. Each deleted entity also has its relationships removed. Pass entity IDs as an array.';
+    }
+    get schema() { return GraphDeleteEntitiesSchema; }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                memoryGraphId: {
+                    type: 'string',
+                    description: 'The Memory Graph ID'
+                },
+                entityIds: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Array of entity IDs to delete'
+                }
+            },
+            required: ['memoryGraphId', 'entityIds']
+        };
+    }
+    async handleExecute(params) {
+        const { memoryGraphId, entityIds } = params;
+        this.logger.info('GraphDeleteEntitiesTool', `Deleting ${entityIds.length} entities from graph: ${memoryGraphId}`);
+        try {
+            const result = await this.ucmClient.graphDeleteEntities(memoryGraphId, entityIds);
+            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 delete entities: ${error.message}`);
+        }
+    }
+}
+//# sourceMappingURL=GraphDeleteEntitiesTool.js.map

package/dist/tools/memory-graph/GraphDeleteRelationshipsTool.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 GraphDeleteRelationshipsParams } from '../../../schemas/memory-graph-tool-schemas.js';
+import { ZodSchema } from 'zod';
+export declare class GraphDeleteRelationshipsTool 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: GraphDeleteRelationshipsParams): Promise<string>;
+}
+//# sourceMappingURL=GraphDeleteRelationshipsTool.d.ts.map

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

@@ -0,0 +1,45 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+import { GraphDeleteRelationshipsSchema } from '../../../schemas/memory-graph-tool-schemas.js';
+export class GraphDeleteRelationshipsTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() { return 'ucm_graph_delete_relationships'; }
+    get description() {
+        return 'Delete one or more relationships from a Memory Graph by their IDs. Pass relationship IDs as an array.';
+    }
+    get schema() { return GraphDeleteRelationshipsSchema; }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                memoryGraphId: {
+                    type: 'string',
+                    description: 'The Memory Graph ID'
+                },
+                relationshipIds: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Array of relationship IDs to delete'
+                }
+            },
+            required: ['memoryGraphId', 'relationshipIds']
+        };
+    }
+    async handleExecute(params) {
+        const { memoryGraphId, relationshipIds } = params;
+        this.logger.info('GraphDeleteRelationshipsTool', `Deleting ${relationshipIds.length} relationships from graph: ${memoryGraphId}`);
+        try {
+            const result = await this.ucmClient.graphDeleteRelationships(memoryGraphId, relationshipIds);
+            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 delete relationships: ${error.message}`);
+        }
+    }
+}
+//# sourceMappingURL=GraphDeleteRelationshipsTool.js.map