@dexto/core 1.1.10 → 1.2.0

package/dist/prompts/providers/file-prompt-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-prompt-provider.d.ts","sourceRoot":"","sources":["../../../src/prompts/providers/file-prompt-provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAc,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAGlG,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AAQ1E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAElE,UAAU,yBAAyB;IAC/B,eAAe,EAAE,eAAe,CAAC;CACpC;AASD,qBAAa,kBAAmB,YAAW,cAAc;IAErD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAW;IACvC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAkB;IAClD,OAAO,CAAC,YAAY,CAAoB;IACxC,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,eAAe,CAAkC;IACzD,OAAO,CAAC,aAAa,CAAkC;gBAE3C,OAAO,EAAE,yBAAyB;IAQ9C,SAAS,IAAI,MAAM;IAInB,eAAe,IAAI,IAAI;IAQjB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,eAAe,CAAC;IAmDjF,WAAW,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAUxD,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC;YAiB3D,iBAAiB;YAyGjB,eAAe;IA+G7B;;;OAGG;IACH,OAAO,CAAC,iBAAiB;YA2BX,kBAAkB;IAqBhC;;;;;;;;;;;;;;OAcG;IACH,OAAO,CAAC,cAAc;IAqCtB,OAAO,CAAC,yBAAyB;CA4BpC"}

package/dist/prompts/providers/file-prompt-provider.js

@@ -0,0 +1,376 @@
+import "../../chunk-C6A6W6XS.js";
+import { expandPlaceholders } from "../utils.js";
+import { assertValidPromptName } from "../name-validation.js";
+import { logger } from "../../logger/index.js";
+import { PromptError } from "../errors.js";
+import { readFile, readdir, realpath } from "fs/promises";
+import { join, extname, resolve, relative, sep } from "path";
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { findDextoProjectRoot, findDextoSourceRoot } from "../../utils/execution-context.js";
+class FilePromptProvider {
+  // Multiple command directories (local project/repo and global user dir)
+  commandDirs;
+  resourceManager;
+  promptsCache = [];
+  cacheValid = false;
+  promptResources = /* @__PURE__ */ new Map();
+  inlineContent = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.commandDirs = this.resolveDefaultCommandDirs();
+    this.resourceManager = options.resourceManager;
+  }
+  getSource() {
+    return "file";
+  }
+  invalidateCache() {
+    this.cacheValid = false;
+    this.promptsCache = [];
+    this.promptResources.clear();
+    this.inlineContent.clear();
+    logger.debug("FilePromptProvider cache invalidated");
+  }
+  async getPrompt(name, args) {
+    if (!this.cacheValid) {
+      await this.buildPromptsCache();
+    }
+    const prompt = this.promptsCache.find((p) => p.name === name);
+    if (!prompt) {
+      throw PromptError.notFound(name);
+    }
+    const resourceUri = this.promptResources.get(name);
+    let text = this.inlineContent.get(name) ?? "";
+    if (resourceUri) {
+      try {
+        const result = await this.resourceManager.read(resourceUri);
+        const first = result.contents[0];
+        if (first?.text && typeof first.text === "string") {
+          text = first.text;
+        } else if (first?.blob && typeof first.blob === "string") {
+          text = Buffer.from(first.blob, "base64").toString("utf-8");
+        } else {
+          logger.warn(`Prompt ${name} resource ${resourceUri} did not contain text`);
+        }
+      } catch (error) {
+        logger.warn(
+          `Failed to load prompt resource ${resourceUri}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    if (!text) {
+      throw PromptError.missingText();
+    }
+    const resolved = this.applyArguments(text, args);
+    return {
+      description: prompt.description,
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: resolved
+          }
+        }
+      ]
+    };
+  }
+  async listPrompts(_cursor) {
+    if (!this.cacheValid) {
+      await this.buildPromptsCache();
+    }
+    return {
+      prompts: this.promptsCache
+    };
+  }
+  async getPromptDefinition(name) {
+    if (!this.cacheValid) {
+      await this.buildPromptsCache();
+    }
+    const promptInfo = this.promptsCache.find((p) => p.name === name);
+    if (!promptInfo) {
+      return null;
+    }
+    return {
+      name: promptInfo.name,
+      ...promptInfo.title && { title: promptInfo.title },
+      ...promptInfo.description && { description: promptInfo.description },
+      ...promptInfo.arguments && { arguments: promptInfo.arguments }
+    };
+  }
+  async buildPromptsCache() {
+    const cache = [];
+    const resourceMap = /* @__PURE__ */ new Map();
+    const inlineMap = /* @__PURE__ */ new Map();
+    const seenNames = /* @__PURE__ */ new Set();
+    const scannedDirs = [];
+    for (const dir of this.commandDirs) {
+      if (!existsSync(dir)) {
+        continue;
+      }
+      try {
+        scannedDirs.push(dir);
+        const files = await readdir(dir);
+        const markdownFiles = files.filter((file) => extname(file).toLowerCase() === ".md");
+        for (const file of markdownFiles) {
+          try {
+            try {
+              const candidate = join(dir, file);
+              const resolvedDir = await realpath(dir);
+              const resolvedFile = await realpath(candidate);
+              const rel = relative(resolvedDir, resolvedFile);
+              if (rel.startsWith(".." + sep) || rel === "..") {
+                logger.warn(
+                  `Skipping file '${file}' in '${dir}': path traversal attempt detected (resolved outside directory)`
+                );
+                continue;
+              }
+            } catch (realpathError) {
+              logger.warn(
+                `Skipping file '${file}' in '${dir}': unable to resolve path (${realpathError instanceof Error ? realpathError.message : String(realpathError)})`
+              );
+              continue;
+            }
+            const parsed = await this.parsePromptFile(file, dir);
+            if (seenNames.has(parsed.info.name)) {
+              logger.debug(
+                `Skipping duplicate prompt name '${parsed.info.name}' from ${join(
+                  dir,
+                  file
+                )}`
+              );
+              continue;
+            }
+            const storage = await this.storePromptContent(parsed.content, file);
+            if (storage.resourceUri) {
+              resourceMap.set(parsed.info.name, storage.resourceUri);
+            }
+            if (storage.inlineContent) {
+              inlineMap.set(parsed.info.name, storage.inlineContent);
+            }
+            if (storage.resourceUri || storage.inlineContent) {
+              const metadata = {
+                ...parsed.info.metadata ?? {},
+                ...storage.resourceUri && { resourceUri: storage.resourceUri }
+                // Security: Don't expose absolute sourceDir path
+                // The relative filePath in parsed.info.metadata is sufficient
+              };
+              if (Object.keys(metadata).length > 0) {
+                parsed.info = { ...parsed.info, metadata };
+              } else {
+                parsed.info = { ...parsed.info };
+                delete parsed.info.metadata;
+              }
+            }
+            cache.push(parsed.info);
+            seenNames.add(parsed.info.name);
+          } catch (error) {
+            logger.warn(
+              `Failed to process prompt file '${file}' in '${dir}': ${error instanceof Error ? error.message : String(error)}`
+            );
+          }
+        }
+      } catch (error) {
+        logger.debug(
+          `Commands directory '${dir}' not accessible: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    logger.debug(
+      `\u{1F4DD} Cached ${cache.length} file prompts from directories: ${scannedDirs.join(", ")}`
+    );
+    this.promptsCache = cache;
+    this.promptResources = resourceMap;
+    this.inlineContent = inlineMap;
+    this.cacheValid = true;
+  }
+  async parsePromptFile(fileName, baseDir) {
+    const promptName = fileName.replace(/\.md$/, "");
+    const filePath = join(baseDir, fileName);
+    const content = await readFile(filePath, "utf-8");
+    const lines = content.trim().split("\n");
+    let description = `File prompt: ${promptName}`;
+    let title = promptName;
+    let category;
+    let id;
+    let nameOverride;
+    let argumentHint;
+    let contentBody;
+    if (lines[0]?.trim() === "---") {
+      let inFrontmatter = false;
+      let frontmatterEnd = 0;
+      for (let i = 0; i < lines.length; i++) {
+        if (lines[i]?.trim() === "---") {
+          if (!inFrontmatter) {
+            inFrontmatter = true;
+          } else {
+            frontmatterEnd = i;
+            break;
+          }
+        }
+      }
+      if (frontmatterEnd > 0) {
+        const frontmatterLines = lines.slice(1, frontmatterEnd);
+        contentBody = lines.slice(frontmatterEnd + 1).join("\n");
+        for (const line of frontmatterLines) {
+          if (line.includes("description:")) {
+            const descMatch = line.match(/description:\s*(?:['"](.+)['"]|(.+))/);
+            if (descMatch) {
+              description = (descMatch[1] || descMatch[2] || "").trim();
+            }
+          } else if (line.includes("id:")) {
+            const idMatch = line.match(/id:\s*(?:['"](.+)['"]|(.+))/);
+            if (idMatch) {
+              id = (idMatch[1] || idMatch[2] || "").trim();
+            }
+          } else if (line.includes("name:")) {
+            const nameMatch = line.match(/name:\s*(?:['"](.+)['"]|(.+))/);
+            if (nameMatch) {
+              nameOverride = (nameMatch[1] || nameMatch[2] || "").trim();
+            }
+          } else if (line.includes("category:")) {
+            const categoryMatch = line.match(/category:\s*(?:['"](.+)['"]|(.+))/);
+            if (categoryMatch) {
+              category = (categoryMatch[1] || categoryMatch[2] || "").trim();
+            }
+          } else if (line.includes("argument-hint:")) {
+            const hintMatch = line.match(/argument-hint:\s*(?:['"](.+)['"]|(.+))/);
+            if (hintMatch) {
+              argumentHint = (hintMatch[1] || hintMatch[2] || "").trim();
+            }
+          }
+        }
+      }
+    }
+    if (!contentBody) {
+      contentBody = content;
+    }
+    const bodyLines = contentBody.trim().split("\n");
+    for (const line of bodyLines) {
+      if (line.trim().startsWith("#")) {
+        title = line.trim().replace(/^#+\s*/, "");
+        break;
+      }
+    }
+    const finalName = (nameOverride ?? promptName).trim();
+    assertValidPromptName(finalName, {
+      hint: "Use kebab-case in the 'name:' field or file name."
+    });
+    const parsedArguments = argumentHint ? this.parseArgumentHint(argumentHint) : void 0;
+    const relativePath = relative(baseDir, filePath);
+    const promptInfo = {
+      name: finalName,
+      title,
+      description,
+      source: "file",
+      ...parsedArguments && { arguments: parsedArguments },
+      metadata: {
+        originalName: promptName,
+        fileName,
+        // Only include relative path within the commands directory (e.g., "my-command.md")
+        // not the full path which could expose ~/.dexto or project structure
+        ...relativePath && { filePath: relativePath },
+        ...id && { id },
+        ...category && { category }
+      }
+    };
+    return { info: promptInfo, content: contentBody };
+  }
+  /**
+   * Parse argument-hint string into structured argument definitions
+   * Format: "[style] [length?]" → [{name: "style", required: true}, {name: "length", required: false}]
+   */
+  parseArgumentHint(hint) {
+    const args = [];
+    const argPattern = /\[([^\]]+)\]/g;
+    let match;
+    while ((match = argPattern.exec(hint)) !== null) {
+      const argText = match[1];
+      if (!argText) continue;
+      const isOptional = argText.endsWith("?");
+      const name = isOptional ? argText.slice(0, -1).trim() : argText.trim();
+      if (name) {
+        args.push({
+          name,
+          required: !isOptional
+        });
+      }
+    }
+    return args;
+  }
+  async storePromptContent(content, fileName) {
+    const blobService = this.resourceManager.getBlobStore();
+    if (!blobService) {
+      logger.warn("BlobService not available; storing prompt content in memory");
+      return { inlineContent: content };
+    }
+    const blobInput = Buffer.from(content, "utf-8");
+    const blob = await blobService.store(blobInput, {
+      mimeType: "text/markdown",
+      originalName: fileName,
+      source: "system"
+    });
+    return { resourceUri: blob.uri };
+  }
+  /**
+   * Apply arguments to a file prompt's content.
+   *
+   * Behavior mirrors Claude Code-style file prompts:
+   * - Positional placeholders ($1..$9 and $ARGUMENTS) are expanded first.
+   * - If and only if the template contains explicit placeholders ($1..$9 or $ARGUMENTS),
+   *   then we consider arguments "deconstructed in-template" and DO NOT append them again.
+   * - If the template contains no such placeholders, we append either:
+   *   - `Context: <_context>` above the content when `_context` is provided, or
+   *   - `Arguments: key: value, ...` below the content for plain named args.
+   *
+   * Notes:
+   * - The `$$` sequence is an escape for a literal dollar sign. It MUST NOT be
+   *   treated as a placeholder indicator and should not suppress argument appending.
+   */
+  applyArguments(content, args) {
+    const detectionTarget = content.replaceAll("$$", "");
+    const usesPositionalPlaceholders = /\$[1-9](?!\d)/.test(detectionTarget) || detectionTarget.includes("$ARGUMENTS");
+    const expanded = expandPlaceholders(content, args).trim();
+    if (!args || typeof args !== "object" || Object.keys(args).length === 0) {
+      return expanded;
+    }
+    if (!usesPositionalPlaceholders) {
+      if (args._context) {
+        const contextString = String(args._context);
+        return `${expanded}
+
+Context: ${contextString}`;
+      }
+      const argEntries = Object.entries(args).filter(([key]) => !key.startsWith("_"));
+      if (argEntries.length > 0) {
+        const formattedArgs = argEntries.map(([key, value]) => `${key}: ${value}`).join(", ");
+        return `${expanded}
+
+Arguments: ${formattedArgs}`;
+      }
+    }
+    return expanded;
+  }
+  // Determine default command/prompt directories based on execution context
+  resolveDefaultCommandDirs() {
+    const dirs = [];
+    const sourceRoot = findDextoSourceRoot();
+    const projectRoot = findDextoProjectRoot();
+    const localRoot = sourceRoot ?? projectRoot ?? null;
+    if (localRoot) {
+      const commandsDir = resolve(localRoot, "commands");
+      if (existsSync(commandsDir)) dirs.push(commandsDir);
+    }
+    const globalCommands = resolve(homedir(), ".dexto", "commands");
+    if (existsSync(globalCommands)) dirs.push(globalCommands);
+    if (dirs.length === 0) {
+      if (localRoot) {
+        dirs.push(resolve(localRoot, "commands"));
+      }
+      dirs.push(globalCommands);
+    }
+    return dirs;
+  }
+}
+export {
+  FilePromptProvider
+};

package/dist/prompts/providers/mcp-prompt-provider.cjs

@@ -0,0 +1,102 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mcp_prompt_provider_exports = {};
+__export(mcp_prompt_provider_exports, {
+  MCPPromptProvider: () => MCPPromptProvider
+});
+module.exports = __toCommonJS(mcp_prompt_provider_exports);
+var import_logger = require("../../logger/index.js");
+class MCPPromptProvider {
+  mcpManager;
+  constructor(mcpManager) {
+    this.mcpManager = mcpManager;
+  }
+  /**
+   * Get the source identifier for this provider
+   */
+  getSource() {
+    return "mcp";
+  }
+  /**
+   * Invalidate the prompts cache (no-op as MCPManager handles caching)
+   */
+  invalidateCache() {
+    import_logger.logger.debug("MCPPromptProvider cache invalidation (handled by MCPManager)");
+  }
+  /**
+   * List all available prompts from MCP servers using MCPManager's cache
+   */
+  async listPrompts(_cursor) {
+    const cachedPrompts = this.mcpManager.getAllPromptMetadata();
+    const prompts = cachedPrompts.map(
+      ({ promptName, serverName, definition }) => {
+        const promptInfo = {
+          name: promptName,
+          title: definition.title || definition.description || `MCP prompt: ${promptName}`,
+          description: definition.description || `MCP prompt: ${promptName}`,
+          ...definition.arguments && { arguments: definition.arguments },
+          source: "mcp",
+          metadata: {
+            serverName,
+            originalName: promptName,
+            ...definition
+          }
+        };
+        return promptInfo;
+      }
+    );
+    import_logger.logger.debug(`\u{1F4DD} Listed ${prompts.length} MCP prompts from cache`);
+    return {
+      prompts
+    };
+  }
+  /**
+   * Get a specific prompt by name
+   */
+  async getPrompt(name, args) {
+    import_logger.logger.debug(`\u{1F4DD} Reading MCP prompt: ${name}`);
+    return await this.mcpManager.getPrompt(name, args);
+  }
+  /**
+   * Get prompt definition (metadata only) from MCPManager's cache
+   */
+  async getPromptDefinition(name) {
+    try {
+      const definition = this.mcpManager.getPromptMetadata(name);
+      if (!definition) {
+        return null;
+      }
+      return {
+        name: definition.name,
+        ...definition.title && { title: definition.title },
+        ...definition.description && { description: definition.description },
+        ...definition.arguments && { arguments: definition.arguments }
+      };
+    } catch (error) {
+      import_logger.logger.debug(
+        `Failed to get prompt definition for '${name}': ${error instanceof Error ? error.message : String(error)}`
+      );
+      return null;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MCPPromptProvider
+});

package/dist/prompts/providers/mcp-prompt-provider.d.ts

@@ -0,0 +1,35 @@
+import type { MCPManager } from '../../mcp/manager.js';
+import type { PromptProvider, PromptDefinition, PromptListResult } from '../types.js';
+import type { GetPromptResult } from '@modelcontextprotocol/sdk/types.js';
+/**
+ * MCP Prompt Provider - Provides prompts from connected MCP servers
+ *
+ * This provider acts as a bridge between the PromptManager and MCPManager,
+ * exposing prompts from all connected MCP servers through a unified interface.
+ * It leverages MCPManager's built-in prompt metadata cache for efficient access.
+ */
+export declare class MCPPromptProvider implements PromptProvider {
+    private mcpManager;
+    constructor(mcpManager: MCPManager);
+    /**
+     * Get the source identifier for this provider
+     */
+    getSource(): string;
+    /**
+     * Invalidate the prompts cache (no-op as MCPManager handles caching)
+     */
+    invalidateCache(): void;
+    /**
+     * List all available prompts from MCP servers using MCPManager's cache
+     */
+    listPrompts(_cursor?: string): Promise<PromptListResult>;
+    /**
+     * Get a specific prompt by name
+     */
+    getPrompt(name: string, args?: Record<string, unknown>): Promise<GetPromptResult>;
+    /**
+     * Get prompt definition (metadata only) from MCPManager's cache
+     */
+    getPromptDefinition(name: string): Promise<PromptDefinition | null>;
+}
+//# sourceMappingURL=mcp-prompt-provider.d.ts.map

package/dist/prompts/providers/mcp-prompt-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-prompt-provider.d.ts","sourceRoot":"","sources":["../../../src/prompts/providers/mcp-prompt-provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,KAAK,EAAE,cAAc,EAAc,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAClG,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AAG1E;;;;;;GAMG;AACH,qBAAa,iBAAkB,YAAW,cAAc;IACpD,OAAO,CAAC,UAAU,CAAa;gBAEnB,UAAU,EAAE,UAAU;IAIlC;;OAEG;IACH,SAAS,IAAI,MAAM;IAInB;;OAEG;IACH,eAAe,IAAI,IAAI;IAKvB;;OAEG;IACG,WAAW,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IA6B9D;;OAEG;IACG,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,eAAe,CAAC;IAKvF;;OAEG;IACG,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC;CAoB5E"}

package/dist/prompts/providers/mcp-prompt-provider.js

@@ -0,0 +1,79 @@
+import "../../chunk-C6A6W6XS.js";
+import { logger } from "../../logger/index.js";
+class MCPPromptProvider {
+  mcpManager;
+  constructor(mcpManager) {
+    this.mcpManager = mcpManager;
+  }
+  /**
+   * Get the source identifier for this provider
+   */
+  getSource() {
+    return "mcp";
+  }
+  /**
+   * Invalidate the prompts cache (no-op as MCPManager handles caching)
+   */
+  invalidateCache() {
+    logger.debug("MCPPromptProvider cache invalidation (handled by MCPManager)");
+  }
+  /**
+   * List all available prompts from MCP servers using MCPManager's cache
+   */
+  async listPrompts(_cursor) {
+    const cachedPrompts = this.mcpManager.getAllPromptMetadata();
+    const prompts = cachedPrompts.map(
+      ({ promptName, serverName, definition }) => {
+        const promptInfo = {
+          name: promptName,
+          title: definition.title || definition.description || `MCP prompt: ${promptName}`,
+          description: definition.description || `MCP prompt: ${promptName}`,
+          ...definition.arguments && { arguments: definition.arguments },
+          source: "mcp",
+          metadata: {
+            serverName,
+            originalName: promptName,
+            ...definition
+          }
+        };
+        return promptInfo;
+      }
+    );
+    logger.debug(`\u{1F4DD} Listed ${prompts.length} MCP prompts from cache`);
+    return {
+      prompts
+    };
+  }
+  /**
+   * Get a specific prompt by name
+   */
+  async getPrompt(name, args) {
+    logger.debug(`\u{1F4DD} Reading MCP prompt: ${name}`);
+    return await this.mcpManager.getPrompt(name, args);
+  }
+  /**
+   * Get prompt definition (metadata only) from MCPManager's cache
+   */
+  async getPromptDefinition(name) {
+    try {
+      const definition = this.mcpManager.getPromptMetadata(name);
+      if (!definition) {
+        return null;
+      }
+      return {
+        name: definition.name,
+        ...definition.title && { title: definition.title },
+        ...definition.description && { description: definition.description },
+        ...definition.arguments && { arguments: definition.arguments }
+      };
+    } catch (error) {
+      logger.debug(
+        `Failed to get prompt definition for '${name}': ${error instanceof Error ? error.message : String(error)}`
+      );
+      return null;
+    }
+  }
+}
+export {
+  MCPPromptProvider
+};