@utaba/ucm-mcp-server 6.5.1 → 6.7.0

package/dist/clients/UcmLocalApiClient.d.ts

@@ -3,9 +3,8 @@ export declare class UcmLocalApiClient {
     private baseUrl;
     private authToken?;
     private authorId?;
-    private organizationId?;
     private client;
-    constructor(baseUrl: string, authToken?: string | undefined, timeout?: number, authorId?: string | undefined, organizationId?: string | undefined);
+    constructor(baseUrl: string, authToken?: string | undefined, timeout?: number, authorId?: string | undefined);
     private setupInterceptors;
     private ensureClient;
     getAuthors(): Promise<AuthorData[]>;
@@ -223,5 +222,225 @@ export declare class UcmLocalApiClient {
      * @param connectionType - Optional filter: 'sharepoint' | 'remote-mcp' | 'all' (default: 'all')
      */
     listAuthorizations(connectionType?: string): Promise<any>;
+    /**
+     * List memory graphs, optionally filtered by scope
+     * @param scope - 'organization' | 'personal' | 'all' (default: 'all')
+     */
+    listMemoryGraphs(scope?: string): Promise<any>;
+    /**
+     * Create a new Memory Graph for the authenticated user
+     */
+    createMemoryGraph(data: {
+        label: string;
+        templateId: string;
+        description?: string;
+        scope?: string;
+    }): Promise<any>;
+    /**
+     * Update an existing Memory Graph's metadata
+     */
+    updateMemoryGraph(memoryGraphId: string, data: {
+        label?: string;
+        description?: string | null;
+        usageInstructions?: string | null;
+    }): Promise<any>;
+    /**
+     * List available vocabulary templates for Memory Graph creation
+     */
+    listMemoryGraphTemplates(): Promise<any>;
+    /**
+     * Semantic vector search across multiple Memory Graphs
+     */
+    graphSearchMultiple(query: string, options?: {
+        graphIds?: string[];
+        entityTypes?: string[];
+        limit?: number;
+        similarityThreshold?: number;
+    }): Promise<any>;
+    /**
+     * List knowledge sets for an organization
+     */
+    listKnowledgeSets(): Promise<any>;
+    /**
+     * List knowledge set summary (markdown) for an organization
+     */
+    listKnowledgeSetSummary(): Promise<string>;
+    /**
+     * Open a knowledge set — returns markdown summary with contents and tool guidance
+     */
+    openKnowledgeSet(knowledgeSetId: string): Promise<string>;
+    /**
+     * Open a memory graph — returns vocabulary, stats, instructions, policies, and metadata
+     */
+    graphOpen(graphId: string): Promise<any>;
+    /**
+     * Find entities with filters and pagination
+     */
+    graphFindEntities(graphId: string, query: {
+        entityTypes?: string[];
+        searchTerm?: string;
+        detailLevel?: string;
+        offset?: number;
+        limit?: number;
+    }): Promise<any>;
+    /**
+     * Get a single entity by ID
+     */
+    graphGetEntity(graphId: string, entityId: string, detailLevel?: string): Promise<any>;
+    /**
+     * Get relationships for an entity
+     */
+    graphGetRelationships(graphId: string, entityId: string, options?: {
+        direction?: string;
+        relationshipTypes?: string[];
+        limit?: number;
+    }): Promise<any>;
+    /**
+     * Explore neighbourhood around an entity (BFS, 1-3 hops)
+     */
+    graphExplore(graphId: string, options: {
+        entityId: string;
+        maxDepth?: number;
+        relationshipTypes?: string[];
+        entityTypes?: string[];
+        limit?: number;
+    }): Promise<any>;
+    /**
+     * Find paths between two entities
+     */
+    graphFindPaths(graphId: string, options: {
+        sourceEntityId: string;
+        targetEntityId: string;
+        maxDepth?: number;
+        relationshipTypes?: string[];
+    }): Promise<any>;
+    /**
+     * Structured graph traversal with a JSON spec
+     */
+    graphTraverse(graphId: string, spec: {
+        start: Record<string, any>;
+        steps: Array<Record<string, any>>;
+        returnMode?: string;
+        limit?: number;
+        detailLevel?: string;
+    }): Promise<any>;
+    /**
+     * Semantic vector search on entity embeddings
+     */
+    graphSearch(graphId: string, query: string, options?: {
+        entityTypes?: string[];
+        limit?: number;
+        similarityThreshold?: number;
+    }): Promise<any>;
+    /**
+     * Create one or more entities
+     */
+    graphCreateEntities(graphId: string, entities: Array<{
+        entityType: string;
+        label: string;
+        summary?: string;
+        properties?: Record<string, unknown>;
+        data?: unknown;
+    }>): Promise<any>;
+    /**
+     * Update one or more entities
+     */
+    graphUpdateEntities(graphId: string, updates: Array<{
+        entityId: string;
+        label?: string;
+        summary?: string;
+        properties?: Record<string, unknown>;
+        data?: unknown;
+    }>): Promise<any>;
+    /**
+     * Delete one or more entities
+     */
+    graphDeleteEntities(graphId: string, entityIds: string[]): Promise<any>;
+    /**
+     * Create one or more relationships
+     */
+    graphCreateRelationships(graphId: string, relationships: Array<{
+        sourceEntityId: string;
+        targetEntityId: string;
+        relationshipType: string;
+        properties?: Record<string, unknown>;
+    }>): Promise<any>;
+    /**
+     * Delete one or more relationships
+     */
+    graphDeleteRelationships(graphId: string, relationshipIds: string[]): Promise<any>;
+    /**
+     * Delete an entire memory graph (SQL record + CosmosDB repository)
+     */
+    graphDelete(graphId: string): Promise<any>;
+    /**
+     * Propose vocabulary extensions (entity types / relationship types)
+     */
+    graphProposeVocabulary(graphId: string, proposals: {
+        entityTypes?: Array<{
+            type: string;
+            description: string;
+            justification: string;
+            properties?: Array<{
+                name: string;
+                type: string;
+                required: boolean;
+                description?: string;
+            }>;
+        }>;
+        relationshipTypes?: Array<{
+            type: string;
+            description: string;
+            justification: string;
+            allowedSourceTypes: string[];
+            allowedTargetTypes: string[];
+            bidirectional?: boolean;
+            properties?: Array<{
+                name: string;
+                type: string;
+                required: boolean;
+                description?: string;
+            }>;
+        }>;
+        editEntityTypes?: Array<{
+            type: string;
+            description?: string;
+            justification: string;
+            addProperties?: Array<{
+                name: string;
+                type: string;
+                required: boolean;
+                description?: string;
+            }>;
+            removeProperties?: string[];
+            updateProperties?: Array<{
+                name: string;
+                type: string;
+                required: boolean;
+                description?: string;
+            }>;
+        }>;
+        editRelationshipTypes?: Array<{
+            type: string;
+            description?: string;
+            justification: string;
+            allowedSourceTypes?: string[];
+            allowedTargetTypes?: string[];
+            bidirectional?: boolean;
+            addProperties?: Array<{
+                name: string;
+                type: string;
+                required: boolean;
+                description?: string;
+            }>;
+            removeProperties?: string[];
+            updateProperties?: Array<{
+                name: string;
+                type: string;
+                required: boolean;
+                description?: string;
+            }>;
+        }>;
+    }): Promise<unknown>;
 }
 //# sourceMappingURL=UcmLocalApiClient.d.ts.map

package/dist/clients/UcmLocalApiClient.js

@@ -3,13 +3,11 @@ export class UcmLocalApiClient {
     baseUrl;
     authToken;
     authorId;
-    organizationId;
     client;
-    constructor(baseUrl, authToken, timeout = 600000, authorId, organizationId) {
+    constructor(baseUrl, authToken, timeout = 600000, authorId) {
         this.baseUrl = baseUrl;
         this.authToken = authToken;
         this.authorId = authorId;
-        this.organizationId = organizationId;
         this.client = axios.create({
             baseURL: this.baseUrl,
             timeout,
@@ -515,5 +513,215 @@ export class UcmLocalApiClient {
         const response = await client.get('/api/v1/oauth/authorizations', { params });
         return response.data;
     }
+    // ─── Memory Graph API Methods ───────────────────────────────────────
+    /**
+     * List memory graphs, optionally filtered by scope
+     * @param scope - 'organization' | 'personal' | 'all' (default: 'all')
+     */
+    async listMemoryGraphs(scope) {
+        const client = this.ensureClient();
+        const params = {};
+        if (scope && scope !== 'all') {
+            params.scope = scope;
+        }
+        const response = await client.get(`/api/v1/memory-graphs`, { params });
+        return response.data;
+    }
+    /**
+     * Create a new Memory Graph for the authenticated user
+     */
+    async createMemoryGraph(data) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/memory-graphs`, data);
+        return response.data;
+    }
+    /**
+     * Update an existing Memory Graph's metadata
+     */
+    async updateMemoryGraph(memoryGraphId, data) {
+        const client = this.ensureClient();
+        const response = await client.put(`/api/v1/memory-graphs/${memoryGraphId}`, data);
+        return response.data;
+    }
+    /**
+     * List available vocabulary templates for Memory Graph creation
+     */
+    async listMemoryGraphTemplates() {
+        const client = this.ensureClient();
+        const response = await client.get(`/api/v1/memory-graphs/templates`);
+        return response.data;
+    }
+    /**
+     * Semantic vector search across multiple Memory Graphs
+     */
+    async graphSearchMultiple(query, options) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/memory-graphs/search`, {
+            query,
+            ...options
+        });
+        return response.data;
+    }
+    /**
+     * List knowledge sets for an organization
+     */
+    async listKnowledgeSets() {
+        const client = this.ensureClient();
+        const response = await client.get(`/api/v1/knowledge-sets`);
+        return response.data;
+    }
+    /**
+     * List knowledge set summary (markdown) for an organization
+     */
+    async listKnowledgeSetSummary() {
+        const client = this.ensureClient();
+        const response = await client.get(`/api/v1/knowledge-sets/summary`);
+        return response.data.markdown;
+    }
+    /**
+     * Open a knowledge set — returns markdown summary with contents and tool guidance
+     */
+    async openKnowledgeSet(knowledgeSetId) {
+        const client = this.ensureClient();
+        const response = await client.get(`/api/v1/knowledge-sets/${knowledgeSetId}/summary`);
+        return response.data.markdown;
+    }
+    /**
+     * Open a memory graph — returns vocabulary, stats, instructions, policies, and metadata
+     */
+    async graphOpen(graphId) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/memory-graphs/${graphId}/open`);
+        return response.data;
+    }
+    /**
+     * Find entities with filters and pagination
+     */
+    async graphFindEntities(graphId, query) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/memory-graphs/${graphId}/entities/find`, query);
+        return response.data;
+    }
+    /**
+     * Get a single entity by ID
+     */
+    async graphGetEntity(graphId, entityId, detailLevel) {
+        const client = this.ensureClient();
+        const params = {};
+        if (detailLevel)
+            params.detailLevel = detailLevel;
+        const response = await client.get(`/api/v1/memory-graphs/${graphId}/entities/${entityId}`, { params });
+        return response.data;
+    }
+    /**
+     * Get relationships for an entity
+     */
+    async graphGetRelationships(graphId, entityId, options) {
+        const client = this.ensureClient();
+        const params = {};
+        if (options?.direction)
+            params.direction = options.direction;
+        if (options?.relationshipTypes)
+            params.relationshipTypes = options.relationshipTypes.join(',');
+        if (options?.limit)
+            params.limit = String(options.limit);
+        const response = await client.get(`/api/v1/memory-graphs/${graphId}/entities/${entityId}/relationships`, { params });
+        return response.data;
+    }
+    /**
+     * Explore neighbourhood around an entity (BFS, 1-3 hops)
+     */
+    async graphExplore(graphId, options) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/memory-graphs/${graphId}/explore`, options);
+        return response.data;
+    }
+    /**
+     * Find paths between two entities
+     */
+    async graphFindPaths(graphId, options) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/memory-graphs/${graphId}/find-paths`, options);
+        return response.data;
+    }
+    /**
+     * Structured graph traversal with a JSON spec
+     */
+    async graphTraverse(graphId, spec) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/memory-graphs/${graphId}/traverse`, spec);
+        return response.data;
+    }
+    /**
+     * Semantic vector search on entity embeddings
+     */
+    async graphSearch(graphId, query, options) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/memory-graphs/${graphId}/search`, {
+            query,
+            ...options
+        });
+        return response.data;
+    }
+    /**
+     * Create one or more entities
+     */
+    async graphCreateEntities(graphId, entities) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/memory-graphs/${graphId}/entities`, { entities });
+        return response.data;
+    }
+    /**
+     * Update one or more entities
+     */
+    async graphUpdateEntities(graphId, updates) {
+        const client = this.ensureClient();
+        const response = await client.put(`/api/v1/memory-graphs/${graphId}/entities`, { updates });
+        return response.data;
+    }
+    /**
+     * Delete one or more entities
+     */
+    async graphDeleteEntities(graphId, entityIds) {
+        const client = this.ensureClient();
+        const response = await client.delete(`/api/v1/memory-graphs/${graphId}/entities`, {
+            data: { entityIds }
+        });
+        return response.data;
+    }
+    /**
+     * Create one or more relationships
+     */
+    async graphCreateRelationships(graphId, relationships) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/memory-graphs/${graphId}/relationships`, { relationships });
+        return response.data;
+    }
+    /**
+     * Delete one or more relationships
+     */
+    async graphDeleteRelationships(graphId, relationshipIds) {
+        const client = this.ensureClient();
+        const response = await client.delete(`/api/v1/memory-graphs/${graphId}/relationships`, {
+            data: { relationshipIds }
+        });
+        return response.data;
+    }
+    /**
+     * Delete an entire memory graph (SQL record + CosmosDB repository)
+     */
+    async graphDelete(graphId) {
+        const client = this.ensureClient();
+        const response = await client.delete(`/api/v1/memory-graphs/${graphId}`);
+        return response.data;
+    }
+    /**
+     * Propose vocabulary extensions (entity types / relationship types)
+     */
+    async graphProposeVocabulary(graphId, proposals) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/memory-graphs/${graphId}/vocabulary/propose`, proposals);
+        return response.data;
+    }
 }
 //# sourceMappingURL=UcmLocalApiClient.js.map

package/dist/index.js

@@ -12,7 +12,7 @@ async function main() {
     program
         .name('ucm-mcp-server')
         .description('Universal Context Manager - Read the ucm_connect tool first to avoid mistakes')
-        .version('6.5.1')
+        .version('6.7.0')
         .option('-u, --ucm-url <url>', 'UCM API base URL (defaults to https://ucm.utaba.ai)')
         .option('-p, --port <port>', 'Server port', '3001')
         .option('--log-level <level>', 'Log level', 'ERROR')

package/dist/interfaces/IMcpTool.d.ts

@@ -1,7 +1,7 @@
 export interface IMcpTool {
     readonly name: string;
     readonly description: string;
-    readonly inputSchema: any;
-    execute(params: any): Promise<any>;
+    readonly inputSchema: Record<string, unknown>;
+    execute(params: Record<string, unknown>): Promise<string>;
 }
 //# sourceMappingURL=IMcpTool.d.ts.map

package/dist/server/ToolRegistry.js

@@ -1,11 +1,9 @@
 import { McpError, McpErrorCode } from '../utils/McpErrorHandler.js';
 // Import utility tools
-// import { HealthCheckController } from '../tools/utility/HealthCheckController.js'; // commented out — use ucm_connect instead
 import { QuickstartTool } from '../tools/utility/QuickstartTool.js';
 import { AuthorIndexTool } from '../tools/utility/AuthorIndexTool.js';
 import { AuthorRecentsTool } from '../tools/utility/AuthorRecentsTool.js';
 import { ListRepositoriesTool } from '../tools/utility/ListRepositoriesTool.js';
-// import { SubmitFeedbackTool } from '../tools/utility/SubmitFeedbackTool.js'; // removed — tool disabled
 // Import core tools
 import { GetArtifactTool } from '../tools/core/GetArtifactTool.js';
 import { GetChunkTool } from '../tools/core/GetChunkTool.js';
@@ -21,10 +19,9 @@ import { MoveArtifactTool } from '../tools/core/MoveArtifactTool.js';
 import { CreateRepositoryTool } from '../tools/repository/CreateRepositoryTool.js';
 import { GetRepositoryTool } from '../tools/repository/GetRepositoryTool.js';
 import { UpdateRepositoryTool } from '../tools/repository/UpdateRepositoryTool.js';
-import { DeleteRepositoryGuidanceTool } from '../tools/repository/DeleteRepositoryGuidanceTool.js';
 // Import connection/SharePoint tools
 import { ListConnectionsTool } from '../tools/sharepoint/SharePointListConnectionsTool.js';
-// DEPRECATED: Legacy SharePoint tools - use ucm_call_remote_tool via unified gateway instead
+// DEPRECATED: Legacy SharePoint tools - use ucm_connection_call_tool via unified gateway instead
 // Commented out 2026-02-13 - pending confirmation that unified gateway works correctly
 // import { SharePointSearchTool } from '../tools/sharepoint/SharePointSearchTool.js';
 // import { SharePointListFoldersTool } from '../tools/sharepoint/SharePointListFoldersTool.js';
@@ -36,6 +33,27 @@ import { ListAuthorizationsTool } from '../tools/authorization/ListAuthorization
 // Import connection tools
 import { AccessConnectionTool } from '../tools/connections/AccessConnectionTool.js';
 import { CallRemoteToolTool } from '../tools/connections/CallRemoteToolTool.js';
+// Import memory graph tools
+import { GraphListTool } from '../tools/memory-graph/GraphListTool.js';
+import { GraphCreateTool } from '../tools/memory-graph/GraphCreateTool.js';
+import { GraphUpdateTool } from '../tools/memory-graph/GraphUpdateTool.js';
+import { GraphListTemplatesTool } from '../tools/memory-graph/GraphListTemplatesTool.js';
+import { KnowledgeSetListTool } from '../tools/memory-graph/KnowledgeSetListTool.js';
+import { KnowledgeSetOpenTool } from '../tools/memory-graph/KnowledgeSetOpenTool.js';
+import { GraphOpenTool } from '../tools/memory-graph/GraphOpenTool.js';
+import { GraphFindEntitiesTool } from '../tools/memory-graph/GraphFindEntitiesTool.js';
+import { GraphGetEntityTool } from '../tools/memory-graph/GraphGetEntityTool.js';
+import { GraphGetRelationshipsTool } from '../tools/memory-graph/GraphGetRelationshipsTool.js';
+import { GraphExploreTool } from '../tools/memory-graph/GraphExploreTool.js';
+import { GraphFindPathsTool } from '../tools/memory-graph/GraphFindPathsTool.js';
+import { GraphTraverseTool } from '../tools/memory-graph/GraphTraverseTool.js';
+import { GraphSearchTool } from '../tools/memory-graph/GraphSearchTool.js';
+import { GraphCreateEntitiesTool } from '../tools/memory-graph/GraphCreateEntitiesTool.js';
+import { GraphUpdateEntitiesTool } from '../tools/memory-graph/GraphUpdateEntitiesTool.js';
+import { GraphDeleteEntitiesTool } from '../tools/memory-graph/GraphDeleteEntitiesTool.js';
+import { GraphCreateRelationshipsTool } from '../tools/memory-graph/GraphCreateRelationshipsTool.js';
+import { GraphDeleteRelationshipsTool } from '../tools/memory-graph/GraphDeleteRelationshipsTool.js';
+import { GraphProposeVocabularyTool } from '../tools/memory-graph/GraphProposeVocabularyTool.js';
 export class ToolRegistry {
     ucmClient;
     logger;
@@ -54,11 +72,9 @@ export class ToolRegistry {
     registerTools() {
         // Register utility tools
         this.registerTool(new QuickstartTool(this.ucmClient, this.logger, this.authorId));
-        // this.registerTool(new HealthCheckController(this.ucmClient, this.logger, this.authorId)); // commented out — use ucm_connect instead
         this.registerTool(new AuthorIndexTool(this.ucmClient, this.logger, this.authorId));
         this.registerTool(new AuthorRecentsTool(this.ucmClient, this.logger, this.authorId));
         this.registerTool(new ListRepositoriesTool(this.ucmClient, this.logger, this.authorId));
-        // this.registerTool(new SubmitFeedbackTool(this.ucmClient, this.logger, this.authorId)); // removed — tool disabled
         // Register core tools
         this.registerTool(new GetArtifactTool(this.ucmClient, this.logger, this.authorId, this.trustedAuthors));
         this.registerTool(new GetChunkTool(this.ucmClient, this.logger, this.authorId));
@@ -74,10 +90,9 @@ export class ToolRegistry {
         this.registerTool(new CreateRepositoryTool(this.ucmClient, this.logger, this.authorId));
         this.registerTool(new GetRepositoryTool(this.ucmClient, this.logger, this.authorId));
         this.registerTool(new UpdateRepositoryTool(this.ucmClient, this.logger, this.authorId));
-        this.registerTool(new DeleteRepositoryGuidanceTool(this.ucmClient, this.logger, this.authorId, this.baseUrl));
         // Register connection tools (ListConnectionsTool is unified - lists all connection types)
         this.registerTool(new ListConnectionsTool(this.ucmClient, this.logger, this.authorId));
-        // DEPRECATED: Legacy SharePoint tools - use ucm_call_remote_tool via unified gateway instead
+        // DEPRECATED: Legacy SharePoint tools - use ucm_connection_call_tool via unified gateway instead
         // Commented out 2026-02-13 - pending confirmation that unified gateway works correctly
         // this.registerTool(new SharePointSearchTool(this.ucmClient, this.logger, this.authorId));
         // this.registerTool(new SharePointListFoldersTool(this.ucmClient, this.logger, this.authorId));
@@ -89,6 +104,27 @@ export class ToolRegistry {
         // Register unified authorization tools
         this.registerTool(new SignOutTool(this.ucmClient, this.logger, this.authorId));
         this.registerTool(new ListAuthorizationsTool(this.ucmClient, this.logger, this.authorId));
+        // Register memory graph tools
+        this.registerTool(new GraphListTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphCreateTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphUpdateTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphListTemplatesTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new KnowledgeSetListTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new KnowledgeSetOpenTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphOpenTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphFindEntitiesTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphGetEntityTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphGetRelationshipsTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphExploreTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphFindPathsTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphTraverseTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphSearchTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphCreateEntitiesTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphUpdateEntitiesTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphDeleteEntitiesTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphCreateRelationshipsTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphDeleteRelationshipsTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GraphProposeVocabularyTool(this.ucmClient, this.logger, this.authorId));
         this.logger.info('ToolRegistry', `Registered ${this.tools.size} MCP tools`);
     }
     registerTool(tool) {

package/dist/tools/authorization/ListAuthorizationsTool.js

@@ -8,7 +8,7 @@ export class ListAuthorizationsTool extends BaseToolController {
         super(ucmClient, logger, publishingAuthorId);
     }
     get name() {
-        return 'ucm_list_authorizations';
+        return 'ucm_connection_list_auth';
     }
     get description() {
         return 'List all your active OAuth authorizations across connection types. Shows which services you are currently authorized to access, with expiry info and connection details.';
@@ -138,7 +138,7 @@ export class ListAuthorizationsTool extends BaseToolController {
                 }
             }
             lines.push('\n## Actions\n');
-            lines.push('To revoke an authorization, use: `ucm_signout` with connectionType and connectionId');
+            lines.push('To revoke an authorization, use: `ucm_connection_signout` with connectionType and connectionId');
         }
         return lines.join('\n');
     }

package/dist/tools/authorization/SignOutTool.js

@@ -9,7 +9,7 @@ export class SignOutTool extends BaseToolController {
         super(ucmClient, logger, publishingAuthorId);
     }
     get name() {
-        return 'ucm_signout';
+        return 'ucm_connection_signout';
     }
     get description() {
         return 'Sign out from an OAuth-authorized connection. Revokes user-delegated permissions by deleting access tokens. Works for SharePoint OnBehalfOf connections and Remote MCP Servers with user-delegated OAuth.';
@@ -25,7 +25,7 @@ export class SignOutTool extends BaseToolController {
                 },
                 connectionId: {
                     type: 'string',
-                    description: 'Connection ID to revoke authorization for (get from ucm_list_authorizations or ucm_list_connections)',
+                    description: 'Connection ID to revoke authorization for (get from ucm_connection_list_auth or ucm_connection_list)',
                     minLength: 36,
                     maxLength: 36
                 }

package/dist/tools/base/BaseToolController.d.ts

@@ -1,6 +1,7 @@
 import { IMcpTool } from '../../interfaces/IMcpTool.js';
 import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
 import { ILogger } from '../../interfaces/ILogger.js';
+import { ZodSchema } from 'zod';
 export declare abstract class BaseToolController implements IMcpTool {
     protected ucmClient: UcmLocalApiClient;
     protected logger: ILogger;
@@ -8,9 +9,11 @@ export declare abstract class BaseToolController implements IMcpTool {
     constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string | undefined);
     abstract get name(): string;
     abstract get description(): string;
-    abstract get inputSchema(): any;
-    execute(params: any): Promise<any>;
-    protected abstract handleExecute(params: any): Promise<any>;
-    protected validateParams(params: any): void;
+    abstract get inputSchema(): Record<string, unknown>;
+    /** Override to provide a zod schema for runtime validation */
+    get schema(): ZodSchema | undefined;
+    execute(params: Record<string, unknown>): Promise<string>;
+    protected abstract handleExecute(params: Record<string, unknown>): Promise<string>;
+    protected validateParams(params: Record<string, unknown>): void;
 }
 //# sourceMappingURL=BaseToolController.d.ts.map