@dexto/core 1.1.10 → 1.1.11

package/dist/prompts/prompt-manager.js

@@ -0,0 +1,352 @@
+import { MCPPromptProvider } from "./providers/mcp-prompt-provider.js";
+import { FilePromptProvider } from "./providers/file-prompt-provider.js";
+import { StarterPromptProvider } from "./providers/starter-prompt-provider.js";
+import {
+  CustomPromptProvider
+} from "./providers/custom-prompt-provider.js";
+import { PromptError } from "./errors.js";
+import { logger } from "../logger/index.js";
+import { normalizePromptArgs, flattenPromptResult } from "./utils.js";
+class PromptManager {
+  constructor(mcpManager, resourceManager, agentConfig, eventBus, database) {
+    this.eventBus = eventBus;
+    this.database = database;
+    this.providers.set("mcp", new MCPPromptProvider(mcpManager));
+    this.providers.set("file", new FilePromptProvider({ resourceManager }));
+    this.providers.set("starter", new StarterPromptProvider(agentConfig));
+    this.providers.set("custom", new CustomPromptProvider(this.database, resourceManager));
+    logger.debug(
+      `PromptManager initialized with providers: ${Array.from(this.providers.keys()).join(", ")}`
+    );
+    const refresh = async (reason) => {
+      logger.debug(`PromptManager refreshing due to: ${reason}`);
+      await this.refresh();
+    };
+    this.eventBus.on("dexto:mcpServerConnected", async (p) => {
+      if (p.success) {
+        await refresh(`mcpServerConnected:${p.name}`);
+      }
+    });
+    this.eventBus.on("dexto:mcpServerRemoved", async (p) => {
+      await refresh(`mcpServerRemoved:${p.serverName}`);
+    });
+    this.eventBus.on("dexto:mcpServerUpdated", async (p) => {
+      await refresh(`mcpServerUpdated:${p.serverName}`);
+    });
+    this.eventBus.on("dexto:mcpPromptsListChanged", async (p) => {
+      await this.updatePromptsForServer(p.serverName, p.prompts);
+      logger.debug(
+        `\u{1F504} Surgically updated prompts for server '${p.serverName}': [${p.prompts.join(", ")}]`
+      );
+    });
+  }
+  providers = /* @__PURE__ */ new Map();
+  promptIndex;
+  aliasMap = /* @__PURE__ */ new Map();
+  buildPromise = null;
+  async initialize() {
+    await this.ensureCache();
+    logger.debug("PromptManager initialization complete");
+  }
+  async list() {
+    await this.ensureCache();
+    const index = this.promptIndex ?? /* @__PURE__ */ new Map();
+    const result = {};
+    for (const [key, entry] of index.entries()) {
+      result[key] = entry.info;
+    }
+    return result;
+  }
+  async has(name) {
+    const entry = await this.findEntry(name);
+    return entry !== void 0;
+  }
+  async getPromptDefinition(name) {
+    const entry = await this.findEntry(name);
+    if (!entry) return null;
+    const { info } = entry;
+    return {
+      name: info.name,
+      ...info.title && { title: info.title },
+      ...info.description && { description: info.description },
+      ...info.arguments && { arguments: info.arguments }
+    };
+  }
+  /**
+   * Retrieve a prompt from the appropriate provider.
+   *
+   * Responsibilities:
+   * - Resolve the correct provider by prompt name (post-cache lookup)
+   * - Map positional arguments (`args._positional: string[]`) to named arguments based
+   *   on the prompt's declared `arguments` schema (order-based mapping)
+   * - Forward `_context` and any named args to the provider
+   *
+   * Mapping rules:
+   * - If `PromptInfo.arguments` is defined (e.g., MCP or file prompts with `argument-hint:`),
+   *   then each position in `_positional` fills the corresponding named arg if not already set.
+   * - Named arguments already present in `args` are not overwritten by positional tokens.
+   */
+  async getPrompt(name, args) {
+    const entry = await this.findEntry(name);
+    if (!entry) {
+      throw PromptError.notFound(name);
+    }
+    const provider = this.providers.get(entry.providerName);
+    if (!provider) {
+      throw PromptError.providerNotFound(entry.providerName);
+    }
+    let finalArgs = args;
+    if (args?._positional && Array.isArray(args._positional) && args._positional.length > 0) {
+      const promptArgs = entry.info.arguments;
+      if (promptArgs && promptArgs.length > 0) {
+        finalArgs = { ...args };
+        const positionalArgs = args._positional;
+        promptArgs.forEach((argDef, index) => {
+          if (index < positionalArgs.length && !finalArgs[argDef.name]) {
+            const value = positionalArgs[index];
+            finalArgs[argDef.name] = typeof value === "string" ? value : String(value);
+          }
+        });
+      }
+    }
+    let providerArgs = finalArgs;
+    if (entry.providerName === "mcp") {
+      const declared = new Set((entry.info.arguments ?? []).map((a) => a.name));
+      const filtered = {};
+      for (const [key, value] of Object.entries(finalArgs ?? {})) {
+        if (key.startsWith("_")) continue;
+        if (declared.size === 0 || declared.has(key)) {
+          filtered[key] = value;
+        }
+      }
+      providerArgs = filtered;
+    }
+    return await provider.getPrompt(entry.providerPromptName, providerArgs);
+  }
+  async resolvePromptKey(nameOrAlias) {
+    await this.ensureCache();
+    if (!this.promptIndex) return null;
+    if (this.promptIndex.has(nameOrAlias)) {
+      return nameOrAlias;
+    }
+    const normalized = nameOrAlias.startsWith("/") ? nameOrAlias.slice(1) : nameOrAlias;
+    const aliasMatch = this.aliasMap.get(nameOrAlias) ?? this.aliasMap.get(normalized);
+    return aliasMatch ?? null;
+  }
+  async createCustomPrompt(input) {
+    const provider = this.providers.get("custom");
+    if (!provider || !(provider instanceof CustomPromptProvider)) {
+      throw PromptError.providerNotFound("custom");
+    }
+    const prompt = await provider.createPrompt(input);
+    await this.refresh();
+    return prompt;
+  }
+  async deleteCustomPrompt(name) {
+    const provider = this.providers.get("custom");
+    if (!provider || !(provider instanceof CustomPromptProvider)) {
+      throw PromptError.providerNotFound("custom");
+    }
+    await provider.deletePrompt(name);
+    await this.refresh();
+  }
+  /**
+   * Resolves a prompt to its text content with all arguments applied.
+   * This is a high-level method that handles:
+   * - Prompt key resolution (resolving aliases)
+   * - Argument normalization (including special `_context` field)
+   * - Passing `_context` through to providers so they can decide whether to append it
+   *   (e.g., file prompts without placeholders will append `Context: ...`)
+   * - Prompt execution and flattening
+   *
+   * @param name The prompt name or alias
+   * @param options Optional configuration for prompt resolution
+   * @returns Promise resolving to the resolved text and resource URIs
+   */
+  async resolvePrompt(name, options = {}) {
+    const args = { ...options.args };
+    if (options.context?.trim()) args._context = options.context.trim();
+    const resolvedName = await this.resolvePromptKey(name) ?? name;
+    const normalized = normalizePromptArgs(args);
+    const providerArgs = normalized.context ? { ...normalized.args, _context: normalized.context } : normalized.args;
+    const promptResult = await this.getPrompt(resolvedName, providerArgs);
+    const flattened = flattenPromptResult(promptResult);
+    if (!flattened.text && flattened.resourceUris.length === 0) {
+      throw PromptError.emptyResolvedContent(resolvedName);
+    }
+    return { text: flattened.text, resources: flattened.resourceUris };
+  }
+  async refresh() {
+    this.promptIndex = void 0;
+    this.aliasMap.clear();
+    for (const provider of this.providers.values()) {
+      provider.invalidateCache();
+    }
+    await this.ensureCache();
+    logger.info("PromptManager refreshed");
+  }
+  /**
+   * Surgically update prompts for a specific MCP server instead of full cache rebuild
+   */
+  async updatePromptsForServer(serverName, _newPrompts) {
+    await this.ensureCache();
+    if (!this.promptIndex) return;
+    this.removePromptsForServer(serverName);
+    const mcpProvider = this.providers.get("mcp");
+    if (mcpProvider) {
+      try {
+        const { prompts } = await mcpProvider.listPrompts();
+        const serverPrompts = prompts.filter(
+          (p) => p.metadata && typeof p.metadata === "object" && "serverName" in p.metadata && p.metadata.serverName === serverName
+        );
+        for (const prompt of serverPrompts) {
+          this.insertPrompt(this.promptIndex, this.aliasMap, "mcp", prompt);
+        }
+      } catch (error) {
+        logger.debug(`Failed to get updated prompts for server '${serverName}': ${error}`);
+      }
+    }
+  }
+  /**
+   * Remove all prompts from a specific server
+   */
+  removePromptsForServer(serverName) {
+    if (!this.promptIndex) return;
+    const keysToRemove = [];
+    for (const [key, entry] of this.promptIndex.entries()) {
+      if (entry.providerName === "mcp" && entry.info.metadata && typeof entry.info.metadata === "object" && "serverName" in entry.info.metadata && entry.info.metadata.serverName === serverName) {
+        keysToRemove.push(key);
+      }
+    }
+    for (const key of keysToRemove) {
+      const entry = this.promptIndex.get(key);
+      if (entry) {
+        this.promptIndex.delete(key);
+        for (const [aliasKey, aliasValue] of Array.from(this.aliasMap.entries())) {
+          if (aliasValue === key) {
+            this.aliasMap.delete(aliasKey);
+          }
+        }
+      }
+    }
+  }
+  sanitizePromptInfo(prompt, providerName) {
+    const metadata = { ...prompt.metadata ?? {} };
+    delete metadata.content;
+    delete metadata.prompt;
+    delete metadata.filePath;
+    delete metadata.messages;
+    if (!metadata.originalName) {
+      metadata.originalName = prompt.name;
+    }
+    metadata.provider = providerName;
+    const sanitized = { ...prompt };
+    if (Object.keys(metadata).length > 0) {
+      sanitized.metadata = metadata;
+    } else {
+      delete sanitized.metadata;
+    }
+    return sanitized;
+  }
+  async ensureCache() {
+    if (this.promptIndex) {
+      return;
+    }
+    if (this.buildPromise) {
+      await this.buildPromise;
+      return;
+    }
+    this.buildPromise = this.buildCache();
+    try {
+      await this.buildPromise;
+    } finally {
+      this.buildPromise = null;
+    }
+  }
+  async buildCache() {
+    const index = /* @__PURE__ */ new Map();
+    const aliases = /* @__PURE__ */ new Map();
+    for (const [providerName, provider] of this.providers) {
+      try {
+        const { prompts } = await provider.listPrompts();
+        for (const prompt of prompts) {
+          this.insertPrompt(index, aliases, providerName, prompt);
+        }
+      } catch (error) {
+        logger.error(
+          `Failed to get prompts from ${providerName} provider: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    this.promptIndex = index;
+    this.aliasMap = aliases;
+    if (index.size > 0) {
+      const sample = Array.from(index.keys()).slice(0, 5);
+      logger.debug(
+        `\u{1F4CB} Prompt discovery: ${index.size} prompts. Sample: ${sample.join(", ")}`
+      );
+    }
+  }
+  insertPrompt(index, aliases, providerName, prompt) {
+    const providerPromptName = prompt.name;
+    const prepared = this.sanitizePromptInfo(prompt, providerName);
+    let key = providerPromptName;
+    const originalName = providerPromptName;
+    if (index.has(key)) {
+      const existing = index.get(key);
+      index.delete(key);
+      const existingKey = `${existing.providerName}:${existing.originalName}`;
+      const updatedExisting = {
+        ...existing,
+        info: existing.info.name === existingKey ? existing.info : { ...existing.info, name: existingKey }
+      };
+      index.set(existingKey, updatedExisting);
+      aliases.set(existing.originalName, existingKey);
+      key = `${providerName}:${originalName}`;
+    }
+    const entryInfo = prepared.name === key ? prepared : { ...prepared, name: key };
+    const entry = {
+      providerName,
+      providerPromptName,
+      originalName,
+      info: entryInfo
+    };
+    index.set(key, entry);
+    aliases.set(originalName, key);
+    const metadata = entryInfo.metadata;
+    if (metadata) {
+      const aliasCandidates = /* @__PURE__ */ new Set();
+      if (typeof metadata.originalName === "string") {
+        aliasCandidates.add(metadata.originalName);
+      }
+      if (typeof metadata.command === "string") {
+        const command = metadata.command;
+        aliasCandidates.add(command);
+        if (command.startsWith("/")) {
+          aliasCandidates.add(command.slice(1));
+        }
+      }
+      for (const candidate of aliasCandidates) {
+        if (candidate && !aliases.has(candidate)) {
+          aliases.set(candidate, key);
+        }
+      }
+    }
+  }
+  async findEntry(name) {
+    await this.ensureCache();
+    if (!this.promptIndex) return void 0;
+    if (this.promptIndex.has(name)) {
+      return this.promptIndex.get(name);
+    }
+    const normalized = name.startsWith("/") ? name.slice(1) : name;
+    const alias = this.aliasMap.get(name) ?? this.aliasMap.get(normalized);
+    if (alias && this.promptIndex.has(alias)) {
+      return this.promptIndex.get(alias);
+    }
+    return void 0;
+  }
+}
+export {
+  PromptManager
+};

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

@@ -0,0 +1,283 @@
+"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 custom_prompt_provider_exports = {};
+__export(custom_prompt_provider_exports, {
+  CustomPromptProvider: () => CustomPromptProvider
+});
+module.exports = __toCommonJS(custom_prompt_provider_exports);
+var import_logger = require("../../logger/index.js");
+var import_utils = require("../utils.js");
+var import_errors = require("../errors.js");
+const CUSTOM_PROMPT_KEY_PREFIX = "prompt:custom:";
+class CustomPromptProvider {
+  constructor(database, resourceManager) {
+    this.database = database;
+    this.resourceManager = resourceManager;
+  }
+  cacheValid = false;
+  promptsCache = [];
+  promptRecords = /* @__PURE__ */ new Map();
+  getSource() {
+    return "custom";
+  }
+  invalidateCache() {
+    this.cacheValid = false;
+    this.promptsCache = [];
+    this.promptRecords.clear();
+  }
+  async listPrompts(_cursor) {
+    if (!this.cacheValid) {
+      await this.buildCache();
+    }
+    return { prompts: this.promptsCache };
+  }
+  async getPrompt(name, args) {
+    if (!this.cacheValid) {
+      await this.buildCache();
+    }
+    const record = this.promptRecords.get(name);
+    if (!record) {
+      throw import_errors.PromptError.notFound(name);
+    }
+    if (record.arguments && record.arguments.length > 0) {
+      const requiredArgs = record.arguments.filter((arg) => arg.required);
+      const missingArgs = requiredArgs.filter((arg) => !args || !(arg.name in args)).map((arg) => arg.name);
+      if (missingArgs.length > 0) {
+        throw import_errors.PromptError.missingRequiredArguments(missingArgs);
+      }
+    }
+    const messages = [];
+    const expanded = (0, import_utils.expandPlaceholders)(record.content, args);
+    const textContent = this.applyArguments(expanded, args, record.arguments);
+    messages.push({
+      role: "user",
+      content: {
+        type: "text",
+        text: textContent
+      }
+    });
+    if (record.resourceUri) {
+      try {
+        const blobService = this.resourceManager.getBlobStore();
+        const blobData = await blobService.retrieve(record.resourceUri, "base64");
+        if (blobData.format === "base64") {
+          messages.push({
+            role: "user",
+            content: {
+              type: "resource",
+              resource: {
+                uri: record.resourceUri,
+                blob: blobData.data,
+                mimeType: record.resourceMetadata?.mimeType || blobData.metadata?.mimeType || "application/octet-stream"
+              }
+            }
+          });
+        }
+      } catch (error) {
+        import_logger.logger.warn(
+          `Failed to load blob resource for custom prompt ${name}: ${String(error)}`
+        );
+      }
+    }
+    return {
+      description: record.description,
+      messages
+    };
+  }
+  async getPromptDefinition(name) {
+    if (!this.cacheValid) {
+      await this.buildCache();
+    }
+    const record = this.promptRecords.get(name);
+    if (!record) return null;
+    return {
+      name: record.name,
+      ...record.title && { title: record.title },
+      ...record.description && { description: record.description },
+      ...record.arguments && { arguments: record.arguments }
+    };
+  }
+  async createPrompt(input) {
+    const id = this.slugify(input.name);
+    if (!id) {
+      throw import_errors.PromptError.nameRequired();
+    }
+    if (!input.content || input.content.trim().length === 0) {
+      throw import_errors.PromptError.missingText();
+    }
+    if (!this.cacheValid) {
+      await this.buildCache();
+    }
+    if (this.promptRecords.has(id)) {
+      throw import_errors.PromptError.alreadyExists(id);
+    }
+    let resourceUri;
+    let resourceMetadata;
+    if (input.resource) {
+      try {
+        const blobService = this.resourceManager.getBlobStore();
+        const { base64, mimeType, filename } = input.resource;
+        const blobRef = await blobService.store(base64, {
+          mimeType,
+          originalName: filename,
+          source: "system"
+        });
+        resourceUri = blobRef.uri;
+        const meta = {};
+        const originalName = blobRef.metadata.originalName ?? filename;
+        if (originalName) {
+          meta.originalName = originalName;
+        }
+        if (blobRef.metadata.mimeType) {
+          meta.mimeType = blobRef.metadata.mimeType;
+        }
+        resourceMetadata = Object.keys(meta).length > 0 ? meta : void 0;
+      } catch (error) {
+        import_logger.logger.warn(`Failed to store custom prompt resource: ${String(error)}`);
+      }
+    }
+    const now = Date.now();
+    const record = {
+      id,
+      name: id,
+      content: input.content,
+      createdAt: now,
+      updatedAt: now,
+      ...input.title ? { title: input.title } : {},
+      ...input.description ? { description: input.description } : {},
+      ...input.arguments ? { arguments: input.arguments } : {},
+      ...resourceUri ? { resourceUri } : {},
+      ...resourceMetadata ? { resourceMetadata } : {}
+    };
+    await this.database.set(this.toKey(id), record);
+    this.invalidateCache();
+    await this.buildCache();
+    const prompt = this.promptsCache.find((p) => p.name === id);
+    if (!prompt) {
+      throw import_errors.PromptError.notFound(id);
+    }
+    return prompt;
+  }
+  async deletePrompt(name) {
+    if (!this.cacheValid) {
+      await this.buildCache();
+    }
+    const record = this.promptRecords.get(name);
+    if (!record) {
+      throw import_errors.PromptError.notFound(name);
+    }
+    await this.database.delete(this.toKey(name));
+    if (record.resourceUri) {
+      try {
+        const blobService = this.resourceManager.getBlobStore();
+        await blobService.delete(record.resourceUri);
+      } catch (error) {
+        import_logger.logger.warn(`Failed to delete blob for custom prompt ${name}: ${String(error)}`);
+      }
+    }
+    this.invalidateCache();
+  }
+  async buildCache() {
+    try {
+      const keys = await this.database.list(CUSTOM_PROMPT_KEY_PREFIX);
+      const prompts = [];
+      this.promptRecords.clear();
+      for (const key of keys) {
+        try {
+          const record = await this.database.get(key);
+          if (!record) continue;
+          this.promptRecords.set(record.name, record);
+          const metadata = {
+            originalName: record.resourceMetadata?.originalName && record.resourceMetadata.originalName.trim().length > 0 ? record.resourceMetadata.originalName : record.name
+          };
+          if (record.resourceUri) {
+            metadata.resourceUri = record.resourceUri;
+          }
+          if (record.resourceMetadata?.mimeType) {
+            metadata.mimeType = record.resourceMetadata.mimeType;
+          }
+          metadata.createdAt = record.createdAt;
+          metadata.updatedAt = record.updatedAt;
+          prompts.push({
+            name: record.name,
+            title: record.title,
+            description: record.description,
+            source: "custom",
+            ...record.arguments && { arguments: record.arguments },
+            metadata
+          });
+        } catch (error) {
+          import_logger.logger.warn(`Failed to load custom prompt from ${key}: ${String(error)}`);
+        }
+      }
+      this.promptsCache = prompts;
+      this.cacheValid = true;
+    } catch (error) {
+      import_logger.logger.error(`Failed to build custom prompts cache: ${String(error)}`);
+      this.promptsCache = [];
+      this.cacheValid = false;
+    }
+  }
+  toKey(id) {
+    return `${CUSTOM_PROMPT_KEY_PREFIX}${id}`;
+  }
+  slugify(name) {
+    const slug = name.toLowerCase().trim().replace(/[^a-z0-9\s\-_]/g, "").replace(/[\s\-_]+/g, "-").replace(/^-+|-+$/g, "");
+    return slug;
+  }
+  applyArguments(content, args, declaredArgs) {
+    if (!args || Object.keys(args).length === 0) {
+      return content;
+    }
+    let result = content;
+    for (const [key, value] of Object.entries(args)) {
+      if (key.startsWith("_")) continue;
+      const placeholder = `{{${key}}}`;
+      result = result.replaceAll(placeholder, String(value));
+    }
+    const usesPositional = /\$[1-9]/.test(content) || content.includes("$ARGUMENTS");
+    let usesNamed = false;
+    if (declaredArgs && declaredArgs.length > 0) {
+      usesNamed = declaredArgs.some((a) => a.name && content.includes(`{{${a.name}}}`));
+    } else {
+      usesNamed = content.includes("{{") && content.includes("}}");
+    }
+    const placeholdersUsed = usesPositional || usesNamed;
+    if (!placeholdersUsed) {
+      if (args._context) {
+        const contextString = String(args._context);
+        return `${result}
+
+Context: ${contextString}`;
+      }
+      const argEntries = Object.entries(args).filter(([k]) => !k.startsWith("_"));
+      if (argEntries.length > 0) {
+        const formattedArgs = argEntries.map(([k, v]) => `${k}: ${v}`).join(", ");
+        return `${result}
+
+Arguments: ${formattedArgs}`;
+      }
+    }
+    return result;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CustomPromptProvider
+});

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

@@ -0,0 +1,36 @@
+import type { PromptProvider, PromptInfo, PromptDefinition, PromptListResult, PromptArgument } from '../types.js';
+import type { GetPromptResult } from '@modelcontextprotocol/sdk/types.js';
+import type { Database } from '../../storage/database/types.js';
+import type { ResourceManager } from '../../resources/manager.js';
+export interface CreateCustomPromptInput {
+    name: string;
+    title?: string;
+    description?: string;
+    content: string;
+    arguments?: PromptArgument[];
+    resource?: {
+        base64: string;
+        mimeType: string;
+        filename?: string;
+    };
+}
+export declare class CustomPromptProvider implements PromptProvider {
+    private database;
+    private resourceManager;
+    private cacheValid;
+    private promptsCache;
+    private promptRecords;
+    constructor(database: Database, resourceManager: ResourceManager);
+    getSource(): string;
+    invalidateCache(): void;
+    listPrompts(_cursor?: string): Promise<PromptListResult>;
+    getPrompt(name: string, args?: Record<string, unknown>): Promise<GetPromptResult>;
+    getPromptDefinition(name: string): Promise<PromptDefinition | null>;
+    createPrompt(input: CreateCustomPromptInput): Promise<PromptInfo>;
+    deletePrompt(name: string): Promise<void>;
+    private buildCache;
+    private toKey;
+    private slugify;
+    private applyArguments;
+}
+//# sourceMappingURL=custom-prompt-provider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"custom-prompt-provider.d.ts","sourceRoot":"","sources":["../../../src/prompts/providers/custom-prompt-provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACR,cAAc,EACd,UAAU,EACV,gBAAgB,EAChB,gBAAgB,EAChB,cAAc,EACjB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AAC1E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iCAAiC,CAAC;AAChE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAuBlE,MAAM,WAAW,uBAAuB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,cAAc,EAAE,CAAC;IAC7B,QAAQ,CAAC,EAAE;QACP,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,EAAE,MAAM,CAAC;QACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC;CACL;AAED,qBAAa,oBAAqB,YAAW,cAAc;IAMnD,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,eAAe;IAN3B,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,YAAY,CAAoB;IACxC,OAAO,CAAC,aAAa,CAA8C;gBAGvD,QAAQ,EAAE,QAAQ,EAClB,eAAe,EAAE,eAAe;IAG5C,SAAS,IAAI,MAAM;IAInB,eAAe,IAAI,IAAI;IAMjB,WAAW,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAQxD,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,eAAe,CAAC;IAiEjF,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC;IAcnE,YAAY,CAAC,KAAK,EAAE,uBAAuB,GAAG,OAAO,CAAC,UAAU,CAAC;IAsEjE,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;YAqBjC,UAAU;IAkDxB,OAAO,CAAC,KAAK;IAIb,OAAO,CAAC,OAAO;IAUf,OAAO,CAAC,cAAc;CA4CzB"}