@mastra/mcp 0.10.2 → 0.10.3

package/dist/_tsup-dts-rollup.d.ts

@@ -1,8 +1,10 @@
 import { Agent } from '@mastra/core/agent';
 import type { ClientCapabilities } from '@modelcontextprotocol/sdk/types.js';
 import type { ConvertedTool } from '@mastra/core/mcp';
+import type { GetPromptResult } from '@modelcontextprotocol/sdk/types.js';
 import type * as http from 'node:http';
 import type { IMastraLogger } from '@mastra/core/logger';
+import type { ListPromptsResult } from '@modelcontextprotocol/sdk/types.js';
 import { LoggingLevel } from '@modelcontextprotocol/sdk/types.js';
 import { MastraBase } from '@mastra/core/base';
 import { MCPServerBase } from '@mastra/core/mcp';
@@ -13,6 +15,8 @@ import type { MCPToolType } from '@mastra/core/mcp';
 import { objectInputType } from 'zod';
 import { objectOutputType } from 'zod';
 import { objectUtil } from 'zod';
+import type { Prompt } from '@modelcontextprotocol/sdk/types.js';
+import type { PromptMessage } from '@modelcontextprotocol/sdk/types.js';
 import type { Resource } from '@modelcontextprotocol/sdk/types.js';
 import type { ResourceTemplate } from '@modelcontextprotocol/sdk/types.js';
 import { ResourceUpdatedNotificationSchema } from '@modelcontextprotocol/sdk/types.js';
@@ -70,6 +74,7 @@ export declare class InternalMastraMCPClient extends MastraBase {
     private transport?;
     private currentOperationContext;
     readonly resources: ResourceClientActions;
+    readonly prompts: PromptClientActions;
     constructor({ name, version, server, capabilities, timeout, }: InternalMastraMCPClientOptions);
     /**
      * Log a message at the specified level
@@ -170,6 +175,26 @@ export declare class InternalMastraMCPClient extends MastraBase {
             mimeType: z.ZodOptional<z.ZodString>;
         }, z.ZodTypeAny, "passthrough">>, "many">;
     }, z.ZodTypeAny, "passthrough">>;
+    /**
+     * Fetch the list of available prompts from the MCP server.
+     */
+    listPrompts(): Promise<ListPromptsResult>;
+    /**
+     * Get a prompt and its dynamic messages from the server.
+     * @param name The prompt name
+     * @param args Arguments for the prompt
+     * @param version (optional) The prompt version to retrieve
+     */
+    getPrompt({ name, args, version }: {
+        name: string;
+        args?: Record<string, any>;
+        version?: string;
+    }): Promise<GetPromptResult>;
+    /**
+     * Register a handler to be called when the prompt list changes on the server.
+     * Use this to refresh cached prompt lists in the client/UI if needed.
+     */
+    setPromptListChangedNotificationHandler(handler: () => void): void;
     setResourceUpdatedNotificationHandler(handler: (params: z.infer<typeof ResourceUpdatedNotificationSchema>['params']) => void): void;
     setResourceListChangedNotificationHandler(handler: () => void): void;
     private convertInputSchema;
@@ -186,10 +211,12 @@ export declare type InternalMastraMCPClientOptions = {
 
 export { LoggingLevel }
 export { LoggingLevel as LoggingLevel_alias_1 }
+export { LoggingLevel as LoggingLevel_alias_2 }
 
 declare type LogHandler = (logMessage: LogMessage) => void;
 export { LogHandler }
 export { LogHandler as LogHandler_alias_1 }
+export { LogHandler as LogHandler_alias_2 }
 
 declare interface LogMessage {
     level: LoggingLevel;
@@ -201,6 +228,7 @@ declare interface LogMessage {
 }
 export { LogMessage }
 export { LogMessage as LogMessage_alias_1 }
+export { LogMessage as LogMessage_alias_2 }
 
 /**
  * @deprecated MastraMCPClient is deprecated and will be removed in a future release. Please use MCPClient instead.
@@ -210,10 +238,12 @@ declare class MastraMCPClient extends InternalMastraMCPClient {
 }
 export { MastraMCPClient }
 export { MastraMCPClient as MastraMCPClient_alias_1 }
+export { MastraMCPClient as MastraMCPClient_alias_2 }
 
 declare type MastraMCPServerDefinition = StdioServerDefinition | HttpServerDefinition;
 export { MastraMCPServerDefinition }
 export { MastraMCPServerDefinition as MastraMCPServerDefinition_alias_1 }
+export { MastraMCPServerDefinition as MastraMCPServerDefinition_alias_2 }
 
 declare class MCPClient extends MastraBase {
     private serverConfigs;
@@ -267,6 +297,55 @@ declare class MCPClient extends MastraBase {
         }) => void) => Promise<void>;
         onListChanged: (serverName: string, handler: () => void) => Promise<void>;
     };
+    get prompts(): {
+        list: () => Promise<Record<string, Prompt[]>>;
+        get: ({ serverName, name, args, version }: {
+            serverName: string;
+            name: string;
+            args?: Record<string, any>;
+            version?: string;
+        }) => Promise<{
+            [x: string]: unknown;
+            messages: {
+                [x: string]: unknown;
+                role: "user" | "assistant";
+                content: {
+                    [x: string]: unknown;
+                    type: "text";
+                    text: string;
+                } | {
+                    [x: string]: unknown;
+                    type: "image";
+                    data: string;
+                    mimeType: string;
+                } | {
+                    [x: string]: unknown;
+                    type: "audio";
+                    data: string;
+                    mimeType: string;
+                } | {
+                    [x: string]: unknown;
+                    type: "resource";
+                    resource: {
+                        [x: string]: unknown;
+                        text: string;
+                        uri: string;
+                        mimeType?: string | undefined;
+                    } | {
+                        [x: string]: unknown;
+                        uri: string;
+                        blob: string;
+                        mimeType?: string | undefined;
+                    };
+                };
+            }[];
+            description?: string | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+        }>;
+        onListChanged: (serverName: string, handler: () => void) => Promise<void>;
+    };
     private addToInstanceCache;
     private makeId;
     disconnect(): Promise<void>;
@@ -277,8 +356,8 @@ declare class MCPClient extends MastraBase {
      */
     getResources(): Promise<Record<string, {
         [x: string]: unknown;
-        uri: string;
         name: string;
+        uri: string;
         description?: string | undefined;
         mimeType?: string | undefined;
     }[]>>;
@@ -293,6 +372,7 @@ declare class MCPClient extends MastraBase {
 }
 export { MCPClient }
 export { MCPClient as MCPClient_alias_1 }
+export { MCPClient as MCPClient_alias_2 }
 
 declare interface MCPClientOptions {
     id?: string;
@@ -301,6 +381,7 @@ declare interface MCPClientOptions {
 }
 export { MCPClientOptions }
 export { MCPClientOptions as MCPClientOptions_alias_1 }
+export { MCPClientOptions as MCPClientOptions_alias_2 }
 
 /**
  * @deprecated MCPConfiguration is deprecated and will be removed in a future release. Use MCPClient instead.
@@ -310,6 +391,7 @@ declare class MCPConfiguration extends MCPClient {
 }
 export { MCPConfiguration }
 export { MCPConfiguration as MCPConfiguration_alias_1 }
+export { MCPConfiguration as MCPConfiguration_alias_2 }
 
 /**
  * @deprecated MCPConfigurationOptions is deprecated and will be removed in a future release. Use MCPClientOptions instead.
@@ -321,6 +403,7 @@ declare interface MCPConfigurationOptions {
 }
 export { MCPConfigurationOptions }
 export { MCPConfigurationOptions as MCPConfigurationOptions_alias_1 }
+export { MCPConfigurationOptions as MCPConfigurationOptions_alias_2 }
 
 declare class MCPServer extends MCPServerBase {
     private server;
@@ -335,11 +418,16 @@ declare class MCPServer extends MCPServerBase {
     private listResourceTemplatesHandlerIsRegistered;
     private subscribeResourceHandlerIsRegistered;
     private unsubscribeResourceHandlerIsRegistered;
+    private listPromptsHandlerIsRegistered;
+    private getPromptHandlerIsRegistered;
     private definedResources?;
     private definedResourceTemplates?;
     private resourceOptions?;
+    private definedPrompts?;
+    private promptOptions?;
     private subscriptions;
     readonly resources: ServerResourceActions;
+    readonly prompts: ServerPromptActions;
     /**
      * Get the current stdio transport.
      */
@@ -366,6 +454,7 @@ declare class MCPServer extends MCPServerBase {
      */
     constructor(opts: MCPServerConfig & {
         resources?: MCPServerResources;
+        prompts?: MCPServerPrompts;
     });
     private convertAgentsToTools;
     private convertWorkflowsToTools;
@@ -406,6 +495,14 @@ declare class MCPServer extends MCPServerBase {
      * Register the UnsubscribeResource handler.
      */
     private registerUnsubscribeResourceHandler;
+    /**
+     * Register the ListPrompts handler.
+     */
+    private registerListPromptsHandler;
+    /**
+     * Register the GetPrompt handler.
+     */
+    private registerGetPromptHandler;
     /**
      * Start the MCP server using stdio transport (for Windsurf integration).
      */
@@ -509,9 +606,27 @@ declare class MCPServer extends MCPServerBase {
 }
 export { MCPServer }
 export { MCPServer as MCPServer_alias_1 }
+export { MCPServer as MCPServer_alias_2 }
 
 export declare const mcpServerName = "firecrawl-mcp-fixture";
 
+declare type MCPServerPromptMessagesCallback = ({ name, version, args, }: {
+    name: string;
+    version?: string;
+    args?: any;
+}) => Promise<PromptMessage[]>;
+export { MCPServerPromptMessagesCallback }
+export { MCPServerPromptMessagesCallback as MCPServerPromptMessagesCallback_alias_1 }
+export { MCPServerPromptMessagesCallback as MCPServerPromptMessagesCallback_alias_2 }
+
+declare type MCPServerPrompts = {
+    listPrompts: () => Promise<Prompt[]>;
+    getPromptMessages?: MCPServerPromptMessagesCallback;
+};
+export { MCPServerPrompts }
+export { MCPServerPrompts as MCPServerPrompts_alias_1 }
+export { MCPServerPrompts as MCPServerPrompts_alias_2 }
+
 declare type MCPServerResourceContent = {
     text?: string;
 } | {
@@ -519,12 +634,14 @@ declare type MCPServerResourceContent = {
 };
 export { MCPServerResourceContent }
 export { MCPServerResourceContent as MCPServerResourceContent_alias_1 }
+export { MCPServerResourceContent as MCPServerResourceContent_alias_2 }
 
 declare type MCPServerResourceContentCallback = ({ uri, }: {
     uri: string;
 }) => Promise<MCPServerResourceContent | MCPServerResourceContent[]>;
 export { MCPServerResourceContentCallback }
 export { MCPServerResourceContentCallback as MCPServerResourceContentCallback_alias_1 }
+export { MCPServerResourceContentCallback as MCPServerResourceContentCallback_alias_2 }
 
 declare type MCPServerResources = {
     listResources: () => Promise<Resource[]>;
@@ -533,9 +650,47 @@ declare type MCPServerResources = {
 };
 export { MCPServerResources }
 export { MCPServerResources as MCPServerResources_alias_1 }
+export { MCPServerResources as MCPServerResources_alias_2 }
+
+/**
+ * Client-side prompt actions for listing, getting, and subscribing to prompt changes.
+ */
+export declare class PromptClientActions {
+    private readonly client;
+    private readonly logger;
+    constructor({ client, logger }: PromptClientActionsConfig);
+    /**
+     * Get all prompts from the connected MCP server.
+     * @returns A list of prompts with their versions.
+     */
+    list(): Promise<Prompt[]>;
+    /**
+     * Get a specific prompt.
+     * @param name The name of the prompt to get.
+     * @param args Optional arguments for the prompt.
+     * @param version Optional version of the prompt to get.
+     * @returns The prompt content.
+     */
+    get({ name, args, version }: {
+        name: string;
+        args?: Record<string, any>;
+        version?: string;
+    }): Promise<GetPromptResult>;
+    /**
+     * Set a notification handler for when the list of available prompts changes.
+     * @param handler The callback function to handle the notification.
+     */
+    onListChanged(handler: () => void): Promise<void>;
+}
+
+declare interface PromptClientActionsConfig {
+    client: InternalMastraMCPClient;
+    logger: IMastraLogger;
+}
 
 export { Resource }
 export { Resource as Resource_alias_1 }
+export { Resource as Resource_alias_2 }
 
 export declare class ResourceClientActions {
     private readonly client;
@@ -622,6 +777,7 @@ declare interface ResourceClientActionsConfig {
 
 export { ResourceTemplate }
 export { ResourceTemplate as ResourceTemplate_alias_1 }
+export { ResourceTemplate as ResourceTemplate_alias_2 }
 
 export declare const server: Server<{
     method: string;
@@ -649,6 +805,24 @@ export declare const server: Server<{
 
 export declare const server_alias_1: MCPServer;
 
+export declare class ServerPromptActions {
+    private readonly getLogger;
+    private readonly getSdkServer;
+    private readonly clearDefinedPrompts;
+    constructor(dependencies: ServerPromptActionsDependencies);
+    /**
+     * Notifies the server that the overall list of available prompts has changed.
+     * This will clear the internal cache of defined prompts and send a list_changed notification to clients.
+     */
+    notifyListChanged(): Promise<void>;
+}
+
+declare interface ServerPromptActionsDependencies {
+    getLogger: () => IMastraLogger;
+    getSdkServer: () => Server;
+    clearDefinedPrompts: () => void;
+}
+
 export declare class ServerResourceActions {
     private readonly getSubscriptions;
     private readonly getLogger;

package/dist/index.cjs

@@ -30,6 +30,58 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 var equal__default = /*#__PURE__*/_interopDefault(equal);
 
 // src/client/client.ts
+var PromptClientActions = class {
+  client;
+  logger;
+  constructor({ client, logger }) {
+    this.client = client;
+    this.logger = logger;
+  }
+  /**
+   * Get all prompts from the connected MCP server.
+   * @returns A list of prompts with their versions.
+   */
+  async list() {
+    try {
+      const response = await this.client.listPrompts();
+      if (response && response.prompts && Array.isArray(response.prompts)) {
+        return response.prompts.map((prompt) => ({ ...prompt, version: prompt.version || "" }));
+      } else {
+        this.logger.warn(`Prompts response from server ${this.client.name} did not have expected structure.`, {
+          response
+        });
+        return [];
+      }
+    } catch (e) {
+      if (e.code === types_js.ErrorCode.MethodNotFound) {
+        return [];
+      }
+      this.logger.error(`Error getting prompts from server ${this.client.name}`, {
+        error: e instanceof Error ? e.message : String(e)
+      });
+      throw new Error(
+        `Failed to fetch prompts from server ${this.client.name}: ${e instanceof Error ? e.stack || e.message : String(e)}`
+      );
+    }
+  }
+  /**
+   * Get a specific prompt.
+   * @param name The name of the prompt to get.
+   * @param args Optional arguments for the prompt.
+   * @param version Optional version of the prompt to get.
+   * @returns The prompt content.
+   */
+  async get({ name, args, version }) {
+    return this.client.getPrompt({ name, args, version });
+  }
+  /**
+   * Set a notification handler for when the list of available prompts changes.
+   * @param handler The callback function to handle the notification.
+   */
+  async onListChanged(handler) {
+    this.client.setPromptListChangedNotificationHandler(handler);
+  }
+};
 var ResourceClientActions = class {
   client;
   logger;
@@ -59,7 +111,6 @@ var ResourceClientActions = class {
       this.logger.error(`Error getting resources from server ${this.client.name}`, {
         error: e instanceof Error ? e.message : String(e)
       });
-      console.log("errorheere", e);
       throw new Error(
         `Failed to fetch resources from server ${this.client.name}: ${e instanceof Error ? e.stack || e.message : String(e)}`
       );
@@ -82,7 +133,6 @@ var ResourceClientActions = class {
         return [];
       }
     } catch (e) {
-      console.log({ errorcooode: e.code });
       if (e.code === types_js.ErrorCode.MethodNotFound) {
         return [];
       }
@@ -161,6 +211,7 @@ var InternalMastraMCPClient = class extends base.MastraBase {
   transport;
   currentOperationContext = null;
   resources;
+  prompts;
   constructor({
     name,
     version = "1.0.0",
@@ -185,6 +236,7 @@ var InternalMastraMCPClient = class extends base.MastraBase {
     );
     this.setupLogging();
     this.resources = new ResourceClientActions({ client: this, logger: this.logger });
+    this.prompts = new PromptClientActions({ client: this, logger: this.logger });
   }
   /**
    * Log a message at the specified level
@@ -368,6 +420,39 @@ var InternalMastraMCPClient = class extends base.MastraBase {
       timeout: this.timeout
     });
   }
+  /**
+   * Fetch the list of available prompts from the MCP server.
+   */
+  async listPrompts() {
+    this.log("debug", `Requesting prompts from MCP server`);
+    return await this.client.request({ method: "prompts/list" }, types_js.ListPromptsResultSchema, {
+      timeout: this.timeout
+    });
+  }
+  /**
+   * Get a prompt and its dynamic messages from the server.
+   * @param name The prompt name
+   * @param args Arguments for the prompt
+   * @param version (optional) The prompt version to retrieve
+   */
+  async getPrompt({ name, args, version }) {
+    this.log("debug", `Requesting prompt from MCP server: ${name}`);
+    return await this.client.request(
+      { method: "prompts/get", params: { name, arguments: args, version } },
+      types_js.GetPromptResultSchema,
+      { timeout: this.timeout }
+    );
+  }
+  /**
+   * Register a handler to be called when the prompt list changes on the server.
+   * Use this to refresh cached prompt lists in the client/UI if needed.
+   */
+  setPromptListChangedNotificationHandler(handler) {
+    this.log("debug", "Setting prompt list changed notification handler");
+    this.client.setNotificationHandler(types_js.PromptListChangedNotificationSchema, () => {
+      handler();
+    });
+  }
   setResourceUpdatedNotificationHandler(handler) {
     this.log("debug", "Setting resource updated notification handler");
     this.client.setNotificationHandler(types_js.ResourceUpdatedNotificationSchema, (notification) => {
@@ -557,6 +642,31 @@ To fix this you have three different options:
       }
     };
   }
+  get prompts() {
+    this.addToInstanceCache();
+    return {
+      list: async () => {
+        const allPrompts = {};
+        for (const serverName of Object.keys(this.serverConfigs)) {
+          try {
+            const internalClient = await this.getConnectedClientForServer(serverName);
+            allPrompts[serverName] = await internalClient.prompts.list();
+          } catch (error) {
+            this.logger.error(`Failed to list prompts from server ${serverName}`, { error });
+          }
+        }
+        return allPrompts;
+      },
+      get: async ({ serverName, name, args, version }) => {
+        const internalClient = await this.getConnectedClientForServer(serverName);
+        return internalClient.prompts.get({ name, args, version });
+      },
+      onListChanged: async (serverName, handler) => {
+        const internalClient = await this.getConnectedClientForServer(serverName);
+        return internalClient.prompts.onListChanged(handler);
+      }
+    };
+  }
   addToInstanceCache() {
     if (!mcpClientInstances.has(this.id)) {
       mcpClientInstances.set(this.id, this);
@@ -765,6 +875,34 @@ var SSETransport = class {
   }
 };
 
+// src/server/promptActions.ts
+var ServerPromptActions = class {
+  getLogger;
+  getSdkServer;
+  clearDefinedPrompts;
+  constructor(dependencies) {
+    this.getLogger = dependencies.getLogger;
+    this.getSdkServer = dependencies.getSdkServer;
+    this.clearDefinedPrompts = dependencies.clearDefinedPrompts;
+  }
+  /**
+   * Notifies the server that the overall list of available prompts has changed.
+   * This will clear the internal cache of defined prompts and send a list_changed notification to clients.
+   */
+  async notifyListChanged() {
+    this.getLogger().info("Prompt list change externally notified. Clearing definedPrompts and sending notification.");
+    this.clearDefinedPrompts();
+    try {
+      await this.getSdkServer().sendPromptListChanged();
+    } catch (error) {
+      this.getLogger().error("Failed to send prompt list changed notification:", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+};
+
 // src/server/resourceActions.ts
 var ServerResourceActions = class {
   getSubscriptions;
@@ -829,11 +967,16 @@ var MCPServer = class extends mcp.MCPServerBase {
   listResourceTemplatesHandlerIsRegistered = false;
   subscribeResourceHandlerIsRegistered = false;
   unsubscribeResourceHandlerIsRegistered = false;
+  listPromptsHandlerIsRegistered = false;
+  getPromptHandlerIsRegistered = false;
   definedResources;
   definedResourceTemplates;
   resourceOptions;
+  definedPrompts;
+  promptOptions;
   subscriptions = /* @__PURE__ */ new Set();
   resources;
+  prompts;
   /**
    * Get the current stdio transport.
    */
@@ -871,6 +1014,7 @@ var MCPServer = class extends mcp.MCPServerBase {
   constructor(opts) {
     super(opts);
     this.resourceOptions = opts.resources;
+    this.promptOptions = opts.prompts;
     const capabilities = {
       tools: {},
       logging: { enabled: true }
@@ -878,6 +1022,9 @@ var MCPServer = class extends mcp.MCPServerBase {
     if (opts.resources) {
       capabilities.resources = { subscribe: true, listChanged: true };
     }
+    if (opts.prompts) {
+      capabilities.prompts = { listChanged: true };
+    }
     this.server = new index_js.Server({ name: this.name, version: this.version }, { capabilities });
     this.logger.info(
       `Initialized MCPServer '${this.name}' v${this.version} (ID: ${this.id}) with tools: ${Object.keys(this.convertedTools).join(", ")} and resources. Capabilities: ${JSON.stringify(capabilities)}`
@@ -894,6 +1041,12 @@ var MCPServer = class extends mcp.MCPServerBase {
         this.registerListResourceTemplatesHandler();
       }
     }
+    if (opts.prompts) {
+      this.registerListPromptsHandler();
+      this.registerGetPromptHandler({
+        getPromptMessagesCallback: opts.prompts.getPromptMessages
+      });
+    }
     this.resources = new ServerResourceActions({
       getSubscriptions: () => this.subscriptions,
       getLogger: () => this.logger,
@@ -905,6 +1058,13 @@ var MCPServer = class extends mcp.MCPServerBase {
         this.definedResourceTemplates = void 0;
       }
     });
+    this.prompts = new ServerPromptActions({
+      getLogger: () => this.logger,
+      getSdkServer: () => this.server,
+      clearDefinedPrompts: () => {
+        this.definedPrompts = void 0;
+      }
+    });
   }
   convertAgentsToTools(agentsConfig, definedConvertedTools) {
     const agentTools = {};
@@ -1331,6 +1491,95 @@ var MCPServer = class extends mcp.MCPServerBase {
       return {};
     });
   }
+  /**
+   * Register the ListPrompts handler.
+   */
+  registerListPromptsHandler() {
+    if (this.listPromptsHandlerIsRegistered) {
+      return;
+    }
+    this.listPromptsHandlerIsRegistered = true;
+    const capturedPromptOptions = this.promptOptions;
+    if (!capturedPromptOptions?.listPrompts) {
+      this.logger.warn("ListPrompts capability not supported by server configuration.");
+      return;
+    }
+    this.server.setRequestHandler(types_js.ListPromptsRequestSchema, async () => {
+      this.logger.debug("Handling ListPrompts request");
+      if (this.definedPrompts) {
+        return {
+          prompts: this.definedPrompts?.map((p) => ({ ...p, version: p.version ?? void 0 }))
+        };
+      } else {
+        try {
+          const prompts = await capturedPromptOptions.listPrompts();
+          for (const prompt of prompts) {
+            types_js.PromptSchema.parse(prompt);
+          }
+          this.definedPrompts = prompts;
+          this.logger.debug(`Fetched and cached ${this.definedPrompts.length} prompts.`);
+          return {
+            prompts: this.definedPrompts?.map((p) => ({ ...p, version: p.version ?? void 0 }))
+          };
+        } catch (error) {
+          this.logger.error("Error fetching prompts via listPrompts():", {
+            error: error instanceof Error ? error.message : String(error)
+          });
+          throw error;
+        }
+      }
+    });
+  }
+  /**
+   * Register the GetPrompt handler.
+   */
+  registerGetPromptHandler({
+    getPromptMessagesCallback
+  }) {
+    if (this.getPromptHandlerIsRegistered) return;
+    this.getPromptHandlerIsRegistered = true;
+    this.server.setRequestHandler(
+      types_js.GetPromptRequestSchema,
+      async (request) => {
+        const startTime = Date.now();
+        const { name, version, arguments: args } = request.params;
+        if (!this.definedPrompts) {
+          const prompts = await this.promptOptions?.listPrompts?.();
+          if (!prompts) throw new Error("Failed to load prompts");
+          this.definedPrompts = prompts;
+        }
+        let prompt;
+        if (version) {
+          prompt = this.definedPrompts?.find((p) => p.name === name && p.version === version);
+        } else {
+          prompt = this.definedPrompts?.find((p) => p.name === name);
+        }
+        if (!prompt) throw new Error(`Prompt "${name}"${version ? ` (version ${version})` : ""} not found`);
+        if (prompt.arguments) {
+          for (const arg of prompt.arguments) {
+            if (arg.required && (args?.[arg.name] === void 0 || args?.[arg.name] === null)) {
+              throw new Error(`Missing required argument: ${arg.name}`);
+            }
+          }
+        }
+        try {
+          let messages = [];
+          if (getPromptMessagesCallback) {
+            messages = await getPromptMessagesCallback({ name, version, args });
+          }
+          const duration = Date.now() - startTime;
+          this.logger.info(
+            `Prompt '${name}'${version ? ` (version ${version})` : ""} retrieved successfully in ${duration}ms.`
+          );
+          return { prompt, messages };
+        } catch (error) {
+          const duration = Date.now() - startTime;
+          this.logger.error(`Failed to get content for prompt '${name}' in ${duration}ms`, { error });
+          throw error;
+        }
+      }
+    );
+  }
   /**
    * Start the MCP server using stdio transport (for Windsurf integration).
    */