@elementor/editor-mcp 4.1.0-789 → 4.1.0-791

package/src/mcp-registry.ts

@@ -1,9 +1,10 @@
 import { z, type z3 } from '@elementor/schema';
-import { type AngieMcpSdk } from '@elementor-external/angie-sdk';
 import { McpServer, type ToolCallback } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { type RequestHandlerExtra } from '@modelcontextprotocol/sdk/shared/protocol.js';
+import { UriTemplate } from '@modelcontextprotocol/sdk/shared/uriTemplate.js';
 import { type ServerNotification, type ServerRequest } from '@modelcontextprotocol/sdk/types.js';
 
+import { type IMcpRegistrationAdapter, type McpResourceHandler, type McpResourceUriOrTemplate } from './adapters/types';
 import {
 	ANGIE_MODEL_PREFERENCES,
 	ANGIE_REQUIRED_RESOURCES,
@@ -11,7 +12,6 @@ import {
 	createDefaultModelPreferences,
 } from './angie-annotations';
 import { mockMcpRegistry } from './test-utils/mock-mcp-registry';
-import { getSDK } from './utils/get-sdk';
 
 type ZodRawShape = z3.ZodRawShape;
 
@@ -20,40 +20,56 @@ const mcpDescriptions: { [ namespace: string ]: string } = {};
 // @ts-ignore - QUnit fails this
 const isMcpRegistrationActivated = false || typeof globalThis.jest !== 'undefined';
 
-export const registerMcp = ( mcp: McpServer, name: string ) => {
-	const mcpName = isAlphabet( name );
-	mcpRegistry[ mcpName ] = mcp;
-};
+const registrationAdapters: IMcpRegistrationAdapter[] = [];
+const bufferedTools: Parameters< IMcpRegistrationAdapter[ 'onToolRegistered' ] >[] = [];
+const bufferedResources: Parameters< IMcpRegistrationAdapter[ 'onResourceRegistered' ] >[] = [];
 
-export async function activateMcpRegistration( sdk: AngieMcpSdk, entries = Object.entries( mcpRegistry ), retry = 3 ) {
-	if ( retry === 0 ) {
-		/* eslint-disable-next-line no-console */
-		console.error( 'Failed to register MCP after 3 retries. failed entries: ', entries );
-		return;
-	}
-	if ( entries.length === 0 ) {
-		return;
+let resolveReady!: () => void;
+const readyPromise = new Promise< void >( ( resolve ) => {
+	resolveReady = resolve;
+} );
+
+export const registerMcpAdapter = ( adapter: IMcpRegistrationAdapter ): void => {
+	registrationAdapters.push( adapter );
+	for ( const tool of bufferedTools ) {
+		try {
+			adapter.onToolRegistered( tool[ 0 ], tool[ 1 ] );
+		} catch {
+			// exit quietly
+		}
 	}
-	const failed = [];
-	for await ( const entry of entries ) {
-		const [ key, mcpServer ] = entry;
+	for ( const resource of bufferedResources ) {
 		try {
-			await sdk.registerLocalServer( {
-				title: toMCPTitle( key ),
-				name: `editor-${ key }`,
-				server: mcpServer,
-				version: '1.0.0',
-				description: mcpDescriptions[ key ] || key,
-			} );
+			adapter.onResourceRegistered( ...resource );
 		} catch {
-			failed.push( entry );
+			// exit quietly
 		}
 	}
-	if ( failed.length > 0 ) {
-		return activateMcpRegistration( sdk, failed, retry - 1 );
+};
+
+export const signalMcpReady = (): void => resolveReady();
+
+export const activateAdapters = (): void => callAdapters( ( adapter ) => adapter.activate() );
+
+function callAdapters( fn: ( adapter: IMcpRegistrationAdapter ) => void ): void {
+	for ( const adapter of registrationAdapters ) {
+		try {
+			fn( adapter );
+		} catch {
+			// adapter failed — exit quietly, continue to next
+		}
 	}
 }
 
+export const registerMcp = ( mcp: McpServer, name: string ) => {
+	const mcpName = isAlphabet( name );
+	mcpRegistry[ mcpName ] = mcp;
+};
+
+export const getRegisteredMcpServers = (): Array< [ string, McpServer, string ] > => {
+	return Object.entries( mcpRegistry ).map( ( [ key, server ] ) => [ key, server, mcpDescriptions[ key ] || key ] );
+};
+
 const isAlphabet = ( str: string ): string | never => {
 	const passes = !! str && /^[a-z_]+$/.test( str );
 	if ( ! passes ) {
@@ -89,48 +105,50 @@ export const getMCPByDomain = ( namespace: string, options?: { instructions?: st
 			},
 			{
 				instructions: options?.instructions,
+				capabilities: { resources: { subscribe: true } },
 			}
 		);
+		if ( !! options?.instructions ) {
+			callAdapters( ( adapter ) =>
+				adapter.onResourceRegistered( `${ mcpName }`, { uriTemplate: new UriTemplate( mcpName ) }, () =>
+					Promise.resolve( { contents: [ { text: options.instructions ?? '' } ] } )
+				)
+			);
+		}
 	}
 	const mcpServer = mcpRegistry[ namespace ];
-	const { addTool } = createToolRegistry( mcpServer );
+	const { addTool } = createToolRegistry( mcpServer, mcpName );
 	return {
-		waitForReady: () => getSDK().waitForReady(),
+		waitForReady: () => readyPromise,
 		// @ts-expect-error: TS is unable to infer the type here
 		resource: async ( ...args: Parameters< McpServer[ 'registerResource' ] > ) => {
-			await getSDK().waitForReady();
+			const [ name, uriOrTemplate, ...rest ] = args as [ string, unknown, ...unknown[] ];
+			const handler = rest[ rest.length - 1 ] as McpResourceHandler;
+			const resourceArgs: Parameters< IMcpRegistrationAdapter[ 'onResourceRegistered' ] > = [
+				name,
+				uriOrTemplate as McpResourceUriOrTemplate,
+				handler,
+			];
+			bufferedResources.push( resourceArgs );
+			callAdapters( ( adapter ) => adapter.onResourceRegistered( ...resourceArgs ) );
 			return mcpServer.registerResource( ...args );
 		},
 		sendResourceUpdated: ( ...args: Parameters< McpServer[ 'server' ][ 'sendResourceUpdated' ] > ) => {
-			return getSDK()
-				.waitForReady()
-				.then( () => mcpServer.server.sendResourceUpdated( ...args ) )
-				.catch( ( error: Error ) => {
-					if ( error?.message?.includes( 'Not connected' ) ) {
-						return; // Expected when no MCP client is connected yet
-					}
-					throw error;
-				} );
+			callAdapters( ( adapter ) => adapter.sendResourceUpdated( { uri: args[ 0 ].uri } ) );
+			return Promise.resolve( mcpServer.server.sendResourceUpdated( ...args ) ).catch( ( error: Error ) => {
+				if ( error?.message?.includes( 'Not connected' ) ) {
+					return; // Expected when no MCP client is connected yet
+				}
+				if ( error?.message?.includes( 'does not support notifying about resources' ) ) {
+					return; // Server capability not declared — safe to ignore
+				}
+				throw error;
+			} );
 		},
-		mcpServer,
 		addTool,
 		setMCPDescription: ( description: string ) => {
 			mcpDescriptions[ namespace ] = description;
 		},
-		getActiveChatInfo: () => {
-			const info = localStorage.getItem( 'angie_active_chat_id' );
-			if ( ! info ) {
-				return {
-					expiresAt: 0,
-					sessionId: '',
-				};
-			}
-			const rawData = JSON.parse( info );
-			return {
-				expiresAt: rawData.expiresAt as number,
-				sessionId: rawData.sessionId as string,
-			};
-		},
 	};
 };
 
@@ -139,10 +157,8 @@ export interface MCPRegistryEntry {
 		opts: ToolRegistrationOptions< T, O >
 	) => void;
 	setMCPDescription: ( description: string ) => void;
-	getActiveChatInfo: () => { sessionId: string; expiresAt: number };
 	sendResourceUpdated: McpServer[ 'server' ][ 'sendResourceUpdated' ];
 	resource: McpServer[ 'registerResource' ];
-	mcpServer: McpServer;
 	waitForReady: () => Promise< void >;
 }
 
@@ -178,7 +194,7 @@ type ToolRegistrationOptions<
 	modelPreferences?: AngieModelPreferences;
 };
 
-function createToolRegistry( server: McpServer ) {
+function createToolRegistry( server: McpServer, serverName: string ) {
 	function addTool<
 		T extends undefined | z.ZodRawShape = undefined,
 		O extends undefined | z.ZodRawShape = undefined,
@@ -246,6 +262,25 @@ function createToolRegistry( server: McpServer ) {
 			},
 			toolCallback
 		);
+		const toolDescriptor = {
+			name: opts.name,
+			description: opts.description,
+			inputSchema: inputSchema as object,
+			execute: ( params: Record< string, unknown > ) =>
+				Promise.resolve(
+					toolCallback(
+						params as Parameters< typeof toolCallback >[ 0 ],
+						/* WebMCP: no protocol session — handlers must not rely on `extra` here */
+						{} as RequestHandlerExtra< ServerRequest, ServerNotification >
+					)
+				),
+		};
+		const extraData = {
+			resources: [ `Server resource name: ${ serverName }, Required to fetch!` ],
+			requiredResources: opts.requiredResources?.map( ( resource ) => resource.uri ) ?? [],
+		};
+		bufferedTools.push( [ toolDescriptor, extraData ] );
+		callAdapters( ( adapter ) => adapter.onToolRegistered( toolDescriptor, extraData ) );
 		if ( isMcpRegistrationActivated ) {
 			server.sendToolListChanged();
 		}

package/src/test-utils/mock-mcp-registry.ts

@@ -21,9 +21,6 @@ export const mockMcpRegistry = (): MCPRegistryEntry => {
 		sendResourceUpdated: () => {},
 		addTool: () => {},
 		setMCPDescription: () => {},
-		getActiveChatInfo() {
-			return { sessionId: 'mock-session-id', expiresAt: Date.now() + 3600000 };
-		},
 		mcpServer: mock as McpServer,
 	};
 };

package/src/utils/get-active-chat-info.ts

@@ -0,0 +1,19 @@
+export type ActiveChatInfo = {
+	sessionId: string;
+	expiresAt: number;
+};
+
+export const getActiveChatInfo = (): ActiveChatInfo => {
+	const info = localStorage.getItem( 'angie_active_chat_id' );
+	if ( ! info ) {
+		return {
+			expiresAt: 0,
+			sessionId: '',
+		};
+	}
+	const rawData = JSON.parse( info );
+	return {
+		expiresAt: rawData.expiresAt as number,
+		sessionId: rawData.sessionId as string,
+	};
+};