@utaba/ucm-mcp-server 6.5.1 → 6.7.0

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

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

@@ -0,0 +1,73 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+import { GraphExploreSchema } from '../../../schemas/memory-graph-tool-schemas.js';
+export class GraphExploreTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() { return 'ucm_graph_explore'; }
+    get description() {
+        return 'Explore the neighbourhood around an entity using BFS traversal (1-3 hops). Returns connected entities grouped by distance, with optional relationship/entity type filters.';
+    }
+    get schema() { return GraphExploreSchema; }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                memoryGraphId: {
+                    type: 'string',
+                    description: 'The Memory Graph ID'
+                },
+                entityId: {
+                    type: 'string',
+                    description: 'Starting entity ID for exploration'
+                },
+                depth: {
+                    type: 'number',
+                    description: 'Exploration depth: 1, 2, or 3 hops (default: 1)'
+                },
+                relationshipTypes: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Filter by relationship types'
+                },
+                entityTypes: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Filter by entity types'
+                },
+                direction: {
+                    type: 'string',
+                    enum: ['outbound', 'inbound', 'both'],
+                    description: 'Traversal direction (default: both)'
+                },
+                limitPerType: {
+                    type: 'number',
+                    description: 'Maximum results per relationship type (default: 10)'
+                }
+            },
+            required: ['memoryGraphId', 'entityId']
+        };
+    }
+    async handleExecute(params) {
+        const { memoryGraphId, entityId, depth, relationshipTypes, entityTypes, direction, limitPerType } = params;
+        this.logger.info('GraphExploreTool', `Exploring from entity ${entityId} in graph: ${memoryGraphId}`);
+        try {
+            const result = await this.ucmClient.graphExplore(memoryGraphId, {
+                entityId,
+                maxDepth: depth,
+                relationshipTypes,
+                entityTypes,
+                limit: limitPerType
+            });
+            return JSON.stringify(result);
+        }
+        catch (error) {
+            if (error.response?.status === 404) {
+                throw new McpError(McpErrorCode.InvalidParams, `Entity or Memory Graph not found`);
+            }
+            throw new McpError(McpErrorCode.InternalError, `Failed to explore neighbourhood: ${error.message}`);
+        }
+    }
+}
+//# sourceMappingURL=GraphExploreTool.js.map

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

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

@@ -0,0 +1,68 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+import { GraphFindEntitiesSchema } from '../../../schemas/memory-graph-tool-schemas.js';
+export class GraphFindEntitiesTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() { return 'ucm_graph_find_entities'; }
+    get description() {
+        return 'Find entities in a Memory Graph by label, type, or property filters. Supports pagination and detail levels (brief/summary/full).';
+    }
+    get schema() { return GraphFindEntitiesSchema; }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                memoryGraphId: {
+                    type: 'string',
+                    description: 'The Memory Graph ID'
+                },
+                searchTerm: {
+                    type: 'string',
+                    description: 'Search term to match against entity labels (partial match)'
+                },
+                entityTypes: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Filter by entity types (from vocabulary)'
+                },
+                detailLevel: {
+                    type: 'string',
+                    enum: ['brief', 'summary', 'full'],
+                    description: 'Detail level for returned entities (default: summary)'
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum results to return (default: 20, max: 100)'
+                },
+                offset: {
+                    type: 'number',
+                    description: 'Pagination offset (default: 0)'
+                }
+            },
+            required: ['memoryGraphId']
+        };
+    }
+    async handleExecute(params) {
+        const { memoryGraphId, searchTerm, entityTypes, detailLevel, limit, offset } = params;
+        this.logger.info('GraphFindEntitiesTool', `Finding entities in graph: ${memoryGraphId}`);
+        try {
+            const result = await this.ucmClient.graphFindEntities(memoryGraphId, {
+                entityTypes,
+                searchTerm,
+                detailLevel,
+                offset,
+                limit
+            });
+            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 find entities: ${error.message}`);
+        }
+    }
+}
+//# sourceMappingURL=GraphFindEntitiesTool.js.map

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

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

@@ -0,0 +1,62 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+import { GraphFindPathsSchema } from '../../../schemas/memory-graph-tool-schemas.js';
+export class GraphFindPathsTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() { return 'ucm_graph_find_paths'; }
+    get description() {
+        return 'Find paths between two entities in a Memory Graph. Returns all paths up to the specified max depth with optional relationship/entity type filtering.';
+    }
+    get schema() { return GraphFindPathsSchema; }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                memoryGraphId: {
+                    type: 'string',
+                    description: 'The Memory Graph ID'
+                },
+                sourceEntityId: {
+                    type: 'string',
+                    description: 'Starting entity ID'
+                },
+                targetEntityId: {
+                    type: 'string',
+                    description: 'Target entity ID'
+                },
+                maxDepth: {
+                    type: 'number',
+                    description: 'Maximum path depth (3-5, default: 3)'
+                },
+                relationshipTypes: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Filter by relationship types'
+                }
+            },
+            required: ['memoryGraphId', 'sourceEntityId', 'targetEntityId']
+        };
+    }
+    async handleExecute(params) {
+        const { memoryGraphId, sourceEntityId, targetEntityId, maxDepth, relationshipTypes } = params;
+        this.logger.info('GraphFindPathsTool', `Finding paths in graph: ${memoryGraphId}`);
+        try {
+            const result = await this.ucmClient.graphFindPaths(memoryGraphId, {
+                sourceEntityId,
+                targetEntityId,
+                maxDepth,
+                relationshipTypes
+            });
+            return JSON.stringify(result);
+        }
+        catch (error) {
+            if (error.response?.status === 404) {
+                throw new McpError(McpErrorCode.InvalidParams, `Entity or Memory Graph not found`);
+            }
+            throw new McpError(McpErrorCode.InternalError, `Failed to find paths: ${error.message}`);
+        }
+    }
+}
+//# sourceMappingURL=GraphFindPathsTool.js.map

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

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

@@ -0,0 +1,49 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+import { GraphGetEntitySchema } from '../../../schemas/memory-graph-tool-schemas.js';
+export class GraphGetEntityTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() { return 'ucm_graph_get_entity'; }
+    get description() {
+        return 'Get full details of an entity including all properties, data, and provenance. Use the entityId from find_entities or explore results.';
+    }
+    get schema() { return GraphGetEntitySchema; }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                memoryGraphId: {
+                    type: 'string',
+                    description: 'The Memory Graph ID'
+                },
+                entityId: {
+                    type: 'string',
+                    description: 'The entity ID or slug to retrieve'
+                },
+                detailLevel: {
+                    type: 'string',
+                    enum: ['brief', 'summary', 'full'],
+                    description: 'Detail level (default: full)'
+                }
+            },
+            required: ['memoryGraphId', 'entityId']
+        };
+    }
+    async handleExecute(params) {
+        const { memoryGraphId, entityId, detailLevel } = params;
+        this.logger.info('GraphGetEntityTool', `Getting entity ${entityId} from graph: ${memoryGraphId}`);
+        try {
+            const result = await this.ucmClient.graphGetEntity(memoryGraphId, entityId, detailLevel);
+            return JSON.stringify(result);
+        }
+        catch (error) {
+            if (error.response?.status === 404) {
+                throw new McpError(McpErrorCode.InvalidParams, `Entity or Memory Graph not found`);
+            }
+            throw new McpError(McpErrorCode.InternalError, `Failed to get entity: ${error.message}`);
+        }
+    }
+}
+//# sourceMappingURL=GraphGetEntityTool.js.map

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

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

@@ -0,0 +1,62 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+import { GraphGetRelationshipsSchema } from '../../../schemas/memory-graph-tool-schemas.js';
+export class GraphGetRelationshipsTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() { return 'ucm_graph_get_relationships'; }
+    get description() {
+        return 'Get relationships for an entity with optional type filtering and direction control (outbound, inbound, or both).';
+    }
+    get schema() { return GraphGetRelationshipsSchema; }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                memoryGraphId: {
+                    type: 'string',
+                    description: 'The Memory Graph ID'
+                },
+                entityId: {
+                    type: 'string',
+                    description: 'The entity ID to get relationships for'
+                },
+                relationshipTypes: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Filter by relationship types (from vocabulary)'
+                },
+                direction: {
+                    type: 'string',
+                    enum: ['outbound', 'inbound', 'both'],
+                    description: 'Relationship direction (default: both)'
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum results (default: 50)'
+                }
+            },
+            required: ['memoryGraphId', 'entityId']
+        };
+    }
+    async handleExecute(params) {
+        const { memoryGraphId, entityId, relationshipTypes, direction, limit } = params;
+        this.logger.info('GraphGetRelationshipsTool', `Getting relationships for entity ${entityId}`);
+        try {
+            const result = await this.ucmClient.graphGetRelationships(memoryGraphId, entityId, {
+                direction,
+                relationshipTypes,
+                limit
+            });
+            return JSON.stringify(result);
+        }
+        catch (error) {
+            if (error.response?.status === 404) {
+                throw new McpError(McpErrorCode.InvalidParams, `Entity or Memory Graph not found`);
+            }
+            throw new McpError(McpErrorCode.InternalError, `Failed to get relationships: ${error.message}`);
+        }
+    }
+}
+//# sourceMappingURL=GraphGetRelationshipsTool.js.map

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

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

@@ -0,0 +1,34 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+import { GraphListTemplatesSchema } from '../../../schemas/memory-graph-tool-schemas.js';
+export class GraphListTemplatesTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() { return 'ucm_graph_list_templates'; }
+    get description() {
+        return 'List available vocabulary templates for creating Memory Graphs. Each template defines entity types, relationship types, and property definitions for a specific domain. Use the templateId when calling ucm_graph_create.';
+    }
+    get schema() { return GraphListTemplatesSchema; }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {},
+            required: []
+        };
+    }
+    async handleExecute(_params) {
+        this.logger.info('GraphListTemplatesTool', 'Listing vocabulary templates');
+        try {
+            const result = await this.ucmClient.listMemoryGraphTemplates();
+            return JSON.stringify(result);
+        }
+        catch (error) {
+            if (error.response?.status === 503) {
+                throw new McpError(McpErrorCode.InternalError, `Deep Memory service is not configured`);
+            }
+            throw new McpError(McpErrorCode.InternalError, `Failed to list templates: ${error.message}`);
+        }
+    }
+}
+//# sourceMappingURL=GraphListTemplatesTool.js.map

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

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

@@ -0,0 +1,45 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { GraphListSchema } from '../../../schemas/memory-graph-tool-schemas.js';
+export class GraphListTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() { return 'ucm_graph_list'; }
+    get description() {
+        return 'List all Memory Graphs you have access to (including those not in a Knowledge Set). Returns graph metadata, embedding status, descriptions, and ownership scope (personal or organization).';
+    }
+    get schema() { return GraphListSchema; }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                scope: {
+                    type: 'string',
+                    enum: ['organization', 'personal', 'all'],
+                    description: 'Filter graphs by ownership scope. "organization" returns only org graphs, "personal" returns only your personal graphs, "all" (default) returns both.'
+                }
+            },
+            required: []
+        };
+    }
+    async handleExecute(params) {
+        const { scope } = params;
+        this.logger.info('GraphListTool', `Listing memory graphs (scope: ${scope ?? 'all'})`);
+        const result = await this.ucmClient.listMemoryGraphs(scope ?? 'all');
+        // Annotate each graph with a scope field based on which owner field is set
+        if (result && Array.isArray(result.data)) {
+            result.data = result.data.map((graph) => ({
+                ...graph,
+                scope: graph.userId ? 'personal' : 'organization'
+            }));
+        }
+        else if (Array.isArray(result)) {
+            return JSON.stringify(result.map((graph) => ({
+                ...graph,
+                scope: graph.userId ? 'personal' : 'organization'
+            })));
+        }
+        return JSON.stringify(result);
+    }
+}
+//# sourceMappingURL=GraphListTool.js.map

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

@@ -0,0 +1,15 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
+import { ILogger } from '../../interfaces/ILogger.js';
+import { type GraphOpenParams } from '../../../schemas/memory-graph-tool-schemas.js';
+import { ZodSchema } from 'zod';
+export declare class GraphOpenTool 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: GraphOpenParams): Promise<string>;
+    private handleApiError;
+}
+//# sourceMappingURL=GraphOpenTool.d.ts.map

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

@@ -0,0 +1,50 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+import { GraphOpenSchema } from '../../../schemas/memory-graph-tool-schemas.js';
+export class GraphOpenTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() { return 'ucm_graph_open'; }
+    get description() {
+        return 'Open a Memory Graph and get its vocabulary, statistics, query instructions, usage instructions, and policies. Call this FIRST before querying a graph — it returns the schema (entity types, relationship types, property definitions) needed to construct queries.';
+    }
+    get schema() { return GraphOpenSchema; }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                memoryGraphId: {
+                    type: 'string',
+                    description: 'The Memory Graph ID to open'
+                }
+            },
+            required: ['memoryGraphId']
+        };
+    }
+    async handleExecute(params) {
+        const { memoryGraphId } = params;
+        this.logger.info('GraphOpenTool', `Opening graph: ${memoryGraphId}`);
+        try {
+            const result = await this.ucmClient.graphOpen(memoryGraphId);
+            // scope is now returned directly by the OpenGraphCommand — no annotation needed
+            return JSON.stringify(result);
+        }
+        catch (error) {
+            this.handleApiError(error, 'open memory graph');
+        }
+    }
+    handleApiError(error, action) {
+        if (error.response?.status === 403) {
+            throw new McpError(McpErrorCode.InvalidParams, `Access denied: you do not have permission to open this Memory Graph`);
+        }
+        if (error.response?.status === 404) {
+            throw new McpError(McpErrorCode.InvalidParams, `Memory Graph not found`);
+        }
+        if (error.response?.status === 503) {
+            throw new McpError(McpErrorCode.InternalError, `Deep Memory service is not configured`);
+        }
+        throw new McpError(McpErrorCode.InternalError, `Failed to ${action}: ${error.message}`);
+    }
+}
+//# sourceMappingURL=GraphOpenTool.js.map

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