Method setPromptRequestHandlers

src/server/mcp.ts:566–626

()

    private _promptHandlersInitialized = false;

    private setPromptRequestHandlers() {
        if (this._promptHandlersInitialized) {
            return;
        }

        this.server.assertCanSetRequestHandler(getMethodValue(ListPromptsRequestSchema));
        this.server.assertCanSetRequestHandler(getMethodValue(GetPromptRequestSchema));

        this.server.registerCapabilities({
            prompts: {
                listChanged: true
            }
        });

        this.server.setRequestHandler(
            ListPromptsRequestSchema,
            (): ListPromptsResult => ({
                prompts: Object.entries(this._registeredPrompts)
                    .filter(([, prompt]) => prompt.enabled)
                    .map(([name, prompt]): Prompt => {
                        return {
                            name,
                            title: prompt.title,
                            description: prompt.description,
                            arguments: prompt.argsSchema ? promptArgumentsFromSchema(prompt.argsSchema) : undefined
                        };
                    })
            })
        );

        this.server.setRequestHandler(GetPromptRequestSchema, async (request, extra): Promise<GetPromptResult> => {
            const prompt = this._registeredPrompts[request.params.name];
            if (!prompt) {
                throw new McpError(ErrorCode.InvalidParams, `Prompt ${request.params.name} not found`);
            }

            if (!prompt.enabled) {
                throw new McpError(ErrorCode.InvalidParams, `Prompt ${request.params.name} disabled`);
            }

            if (prompt.argsSchema) {
                const argsObj = normalizeObjectSchema(prompt.argsSchema) as AnyObjectSchema;
                const parseResult = await safeParseAsync(argsObj, request.params.arguments);
                if (!parseResult.success) {
                    const error = 'error' in parseResult ? parseResult.error : 'Unknown error';
                    const errorMessage = getParseErrorMessage(error);
                    throw new McpError(ErrorCode.InvalidParams, `Invalid arguments for prompt ${request.params.name}: ${errorMessage}`);
                }

                const args = parseResult.data;
                const cb = prompt.callback as PromptCallback<PromptArgsRawShape>;
                return await Promise.resolve(cb(args, extra));
            } else {
                const cb = prompt.callback as PromptCallback<undefined>;
                // eslint-disable-next-line @typescript-eslint/no-explicit-any
                return await Promise.resolve((cb as any)(extra));
            }
        });