@dexto/core 1.2.5 → 1.2.6

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

@@ -0,0 +1,308 @@
+import "../../chunk-C6A6W6XS.js";
+import { DextoLogComponent } from "../../logger/v2/types.js";
+import { PromptError } from "../errors.js";
+import { expandPlaceholders } from "../utils.js";
+import { assertValidPromptName } from "../name-validation.js";
+import { readFile, realpath } from "fs/promises";
+import { existsSync } from "fs";
+import { dirname, relative, sep } from "path";
+class ConfigPromptProvider {
+  prompts = [];
+  promptsCache = [];
+  promptContent = /* @__PURE__ */ new Map();
+  cacheValid = false;
+  logger;
+  constructor(agentConfig, logger) {
+    this.logger = logger.createChild(DextoLogComponent.PROMPT);
+    this.prompts = agentConfig.prompts;
+    this.buildPromptsCache();
+  }
+  getSource() {
+    return "config";
+  }
+  invalidateCache() {
+    this.cacheValid = false;
+    this.promptsCache = [];
+    this.promptContent.clear();
+    this.logger.debug("ConfigPromptProvider cache invalidated");
+  }
+  updateConfig(agentConfig) {
+    this.prompts = agentConfig.prompts;
+    this.invalidateCache();
+    this.buildPromptsCache();
+  }
+  async listPrompts(_cursor) {
+    if (!this.cacheValid) {
+      await this.buildPromptsCache();
+    }
+    return {
+      prompts: this.promptsCache
+    };
+  }
+  async getPrompt(name, args) {
+    if (!this.cacheValid) {
+      await this.buildPromptsCache();
+    }
+    const promptInfo = this.promptsCache.find((p) => p.name === name);
+    if (!promptInfo) {
+      throw PromptError.notFound(name);
+    }
+    let content = this.promptContent.get(name);
+    if (!content) {
+      throw PromptError.missingText();
+    }
+    content = this.applyArguments(content, args);
+    return {
+      description: promptInfo.description,
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: content
+          }
+        }
+      ]
+    };
+  }
+  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 contentMap = /* @__PURE__ */ new Map();
+    for (const prompt of this.prompts) {
+      try {
+        if (prompt.type === "inline") {
+          const { info, content } = this.processInlinePrompt(prompt);
+          cache.push(info);
+          contentMap.set(info.name, content);
+        } else if (prompt.type === "file") {
+          const result = await this.processFilePrompt(prompt);
+          if (result) {
+            cache.push(result.info);
+            contentMap.set(result.info.name, result.content);
+          }
+        }
+      } catch (error) {
+        this.logger.warn(
+          `Failed to process prompt: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    cache.sort((a, b) => {
+      const priorityA = a.metadata?.priority ?? 0;
+      const priorityB = b.metadata?.priority ?? 0;
+      return priorityB - priorityA;
+    });
+    this.promptsCache = cache;
+    this.promptContent = contentMap;
+    this.cacheValid = true;
+    this.logger.debug(`Cached ${cache.length} config prompts`);
+  }
+  processInlinePrompt(prompt) {
+    const promptName = `config:${prompt.id}`;
+    const promptInfo = {
+      name: promptName,
+      title: prompt.title,
+      description: prompt.description,
+      source: "config",
+      metadata: {
+        type: "inline",
+        category: prompt.category,
+        priority: prompt.priority,
+        showInStarters: prompt.showInStarters,
+        originalId: prompt.id
+      }
+    };
+    return { info: promptInfo, content: prompt.prompt };
+  }
+  async processFilePrompt(prompt) {
+    const filePath = prompt.file;
+    if (!existsSync(filePath)) {
+      this.logger.warn(`Prompt file not found: ${filePath}`);
+      return null;
+    }
+    try {
+      const resolvedDir = await realpath(dirname(filePath));
+      const resolvedFile = await realpath(filePath);
+      const rel = relative(resolvedDir, resolvedFile);
+      if (rel.startsWith(".." + sep) || rel === "..") {
+        this.logger.warn(
+          `Skipping prompt file '${filePath}': path traversal attempt detected (resolved outside directory)`
+        );
+        return null;
+      }
+    } catch (realpathError) {
+      this.logger.warn(
+        `Skipping prompt file '${filePath}': unable to resolve path (${realpathError instanceof Error ? realpathError.message : String(realpathError)})`
+      );
+      return null;
+    }
+    try {
+      const rawContent = await readFile(filePath, "utf-8");
+      const parsed = this.parseMarkdownPrompt(rawContent, filePath);
+      try {
+        assertValidPromptName(parsed.id, {
+          context: `file prompt '${filePath}'`,
+          hint: "Use kebab-case in the 'id:' frontmatter field or file name."
+        });
+      } catch (validationError) {
+        this.logger.warn(
+          `Invalid prompt name in '${filePath}': ${validationError instanceof Error ? validationError.message : String(validationError)}`
+        );
+        return null;
+      }
+      const promptInfo = {
+        name: `config:${parsed.id}`,
+        title: parsed.title,
+        description: parsed.description,
+        source: "config",
+        ...parsed.arguments && { arguments: parsed.arguments },
+        metadata: {
+          type: "file",
+          filePath,
+          category: parsed.category,
+          priority: parsed.priority,
+          showInStarters: prompt.showInStarters,
+          originalId: parsed.id
+        }
+      };
+      return { info: promptInfo, content: parsed.content };
+    } catch (error) {
+      this.logger.warn(
+        `Failed to read prompt file ${filePath}: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return null;
+    }
+  }
+  parseMarkdownPrompt(rawContent, filePath) {
+    const lines = rawContent.trim().split("\n");
+    const fileName = filePath.split("/").pop()?.replace(/\.md$/, "") ?? "unknown";
+    let id = fileName;
+    let title = fileName;
+    let description = `File prompt: ${fileName}`;
+    let category;
+    let priority;
+    let argumentHint;
+    let contentBody;
+    if (lines[0]?.trim() === "---") {
+      let frontmatterEnd = 0;
+      for (let i = 1; i < lines.length; i++) {
+        if (lines[i]?.trim() === "---") {
+          frontmatterEnd = i;
+          break;
+        }
+      }
+      if (frontmatterEnd > 0) {
+        const frontmatterLines = lines.slice(1, frontmatterEnd);
+        contentBody = lines.slice(frontmatterEnd + 1).join("\n");
+        for (const line of frontmatterLines) {
+          const match = (key) => {
+            const regex = new RegExp(`${key}:\\s*(?:['"](.+)['"]|(.+))`);
+            const m = line.match(regex);
+            return m ? (m[1] || m[2] || "").trim() : null;
+          };
+          if (line.includes("id:")) {
+            const val = match("id");
+            if (val) id = val;
+          } else if (line.includes("title:")) {
+            const val = match("title");
+            if (val) title = val;
+          } else if (line.includes("description:")) {
+            const val = match("description");
+            if (val) description = val;
+          } else if (line.includes("category:")) {
+            const val = match("category");
+            if (val) category = val;
+          } else if (line.includes("priority:")) {
+            const val = match("priority");
+            if (val) priority = parseInt(val, 10);
+          } else if (line.includes("argument-hint:")) {
+            const val = match("argument-hint");
+            if (val) argumentHint = val;
+          }
+        }
+      } else {
+        contentBody = rawContent;
+      }
+    } else {
+      contentBody = rawContent;
+    }
+    if (title === fileName) {
+      for (const line of contentBody.trim().split("\n")) {
+        if (line.trim().startsWith("#")) {
+          title = line.trim().replace(/^#+\s*/, "");
+          break;
+        }
+      }
+    }
+    const parsedArguments = argumentHint ? this.parseArgumentHint(argumentHint) : void 0;
+    return {
+      id,
+      title,
+      description,
+      content: contentBody.trim(),
+      ...category !== void 0 && { category },
+      ...priority !== void 0 && { priority },
+      ...parsedArguments !== void 0 && { arguments: parsedArguments }
+    };
+  }
+  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;
+  }
+  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;
+  }
+}
+export {
+  ConfigPromptProvider
+};

package/dist/prompts/schemas.cjs

@@ -18,37 +18,56 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var schemas_exports = {};
 __export(schemas_exports, {
-  StarterPromptsSchema: () => StarterPromptsSchema
+  FilePromptSchema: () => FilePromptSchema,
+  InlinePromptSchema: () => InlinePromptSchema,
+  PromptsSchema: () => PromptsSchema
 });
 module.exports = __toCommonJS(schemas_exports);
 var import_zod = require("zod");
 var import_name_validation = require("./name-validation.js");
-const StarterPromptsSchema = import_zod.z.array(
-  import_zod.z.object({
-    id: import_zod.z.string().min(1).max(64).regex(import_name_validation.PROMPT_NAME_REGEX, `Starter prompt id must be ${import_name_validation.PROMPT_NAME_GUIDANCE}`).describe("Kebab-case slug id for the starter prompt (e.g., quick-start)"),
-    title: import_zod.z.string().optional().describe("Display title for the starter prompt"),
-    description: import_zod.z.string().optional().default("").describe("Description shown on hover or in the UI"),
-    prompt: import_zod.z.string().describe("The actual prompt text that gets resolved and sent"),
-    category: import_zod.z.string().optional().default("general").describe(
-      "Category for organizing starter prompts (e.g., general, coding, analysis, tools, learning)"
-    ),
-    priority: import_zod.z.number().optional().default(0).describe("Higher numbers appear first")
-  }).strict()
-).superRefine((arr, ctx) => {
+const InlinePromptSchema = import_zod.z.object({
+  type: import_zod.z.literal("inline").describe("Inline prompt type"),
+  id: import_zod.z.string().min(1).max(64).regex(import_name_validation.PROMPT_NAME_REGEX, `Prompt id must be ${import_name_validation.PROMPT_NAME_GUIDANCE}`).describe("Kebab-case slug id for the prompt (e.g., quick-start)"),
+  title: import_zod.z.string().optional().describe("Display title for the prompt"),
+  description: import_zod.z.string().optional().default("").describe("Description shown on hover or in the UI"),
+  prompt: import_zod.z.string().describe("The actual prompt text"),
+  category: import_zod.z.string().optional().default("general").describe("Category for organizing prompts (e.g., general, coding, analysis, tools)"),
+  priority: import_zod.z.number().optional().default(0).describe("Higher numbers appear first in the list"),
+  showInStarters: import_zod.z.boolean().optional().default(false).describe("Show as a clickable button in WebUI starter prompts")
+}).strict().describe("Inline prompt with text defined directly in config");
+const FilePromptSchema = import_zod.z.object({
+  type: import_zod.z.literal("file").describe("File-based prompt type"),
+  file: import_zod.z.string().describe(
+    "Path to markdown file containing prompt (supports ${{dexto.agent_dir}} template)"
+  ),
+  showInStarters: import_zod.z.boolean().optional().default(false).describe("Show as a clickable button in WebUI starter prompts")
+}).strict().describe("File-based prompt loaded from a markdown file");
+const PromptsSchema = import_zod.z.array(import_zod.z.discriminatedUnion("type", [InlinePromptSchema, FilePromptSchema])).superRefine((arr, ctx) => {
   const seen = /* @__PURE__ */ new Map();
   arr.forEach((p, idx) => {
-    if (seen.has(p.id)) {
-      ctx.addIssue({
-        code: import_zod.z.ZodIssueCode.custom,
-        message: `Duplicate starterPrompt id: ${p.id}`,
-        path: ["starterPrompts", idx, "id"]
-      });
-    } else {
-      seen.set(p.id, idx);
+    if (p.type === "inline") {
+      if (seen.has(p.id)) {
+        ctx.addIssue({
+          code: import_zod.z.ZodIssueCode.custom,
+          message: `Duplicate prompt id: ${p.id}`,
+          path: [idx, "id"]
+        });
+      } else {
+        seen.set(p.id, idx);
+      }
     }
   });
-}).transform((arr) => arr.map((p) => ({ ...p, title: p.title ?? p.id.replace(/-/g, " ") }))).default([]).describe("Starter prompts that appear as clickable buttons in the WebUI");
+}).transform(
+  (arr) => arr.map((p) => {
+    if (p.type === "inline") {
+      return { ...p, title: p.title ?? p.id.replace(/-/g, " ") };
+    }
+    return p;
+  })
+).default([]).describe("Agent prompts - inline text or file-based");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  StarterPromptsSchema
+  FilePromptSchema,
+  InlinePromptSchema,
+  PromptsSchema
 });

package/dist/prompts/schemas.d.ts

@@ -1,65 +1,174 @@
 /**
  * Zod schemas for prompt-related configurations
+ *
+ * Unified prompt system with discriminated union:
+ * - type: 'inline' - Prompt text defined directly in config
+ * - type: 'file' - Prompt loaded from a markdown file
+ *
+ * Both support showInStarters flag to control WebUI button display.
  */
 import { z } from 'zod';
 /**
- * Schema for starter prompts configuration
- *
- * Starter prompts appear as clickable buttons in the WebUI, providing users
- * with quick-start templates for common tasks and interactions.
+ * Schema for inline prompts - text defined directly in config
  */
-export declare const StarterPromptsSchema: z.ZodDefault<z.ZodEffects<z.ZodEffects<z.ZodArray<z.ZodObject<{
+export declare const InlinePromptSchema: z.ZodObject<{
+    type: z.ZodLiteral<"inline">;
     id: z.ZodString;
     title: z.ZodOptional<z.ZodString>;
     description: z.ZodDefault<z.ZodOptional<z.ZodString>>;
     prompt: z.ZodString;
     category: z.ZodDefault<z.ZodOptional<z.ZodString>>;
     priority: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    showInStarters: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
 }, "strict", z.ZodTypeAny, {
     prompt: string;
     description: string;
+    type: "inline";
     id: string;
     priority: number;
     category: string;
+    showInStarters: boolean;
     title?: string | undefined;
 }, {
     prompt: string;
+    type: "inline";
     id: string;
     description?: string | undefined;
     title?: string | undefined;
     priority?: number | undefined;
     category?: string | undefined;
-}>, "many">, {
+    showInStarters?: boolean | undefined;
+}>;
+/**
+ * Schema for file-based prompts - loaded from markdown files
+ */
+export declare const FilePromptSchema: z.ZodObject<{
+    type: z.ZodLiteral<"file">;
+    file: z.ZodString;
+    showInStarters: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strict", z.ZodTypeAny, {
+    file: string;
+    type: "file";
+    showInStarters: boolean;
+}, {
+    file: string;
+    type: "file";
+    showInStarters?: boolean | undefined;
+}>;
+/**
+ * Unified prompts schema - array of inline or file-based prompts
+ * Replaces the old StarterPromptsSchema
+ */
+export declare const PromptsSchema: z.ZodDefault<z.ZodEffects<z.ZodEffects<z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"inline">;
+    id: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    prompt: z.ZodString;
+    category: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    priority: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    showInStarters: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strict", z.ZodTypeAny, {
     prompt: string;
     description: string;
+    type: "inline";
     id: string;
     priority: number;
     category: string;
+    showInStarters: boolean;
     title?: string | undefined;
-}[], {
+}, {
     prompt: string;
+    type: "inline";
     id: string;
     description?: string | undefined;
     title?: string | undefined;
     priority?: number | undefined;
     category?: string | undefined;
-}[]>, {
+    showInStarters?: boolean | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"file">;
+    file: z.ZodString;
+    showInStarters: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strict", z.ZodTypeAny, {
+    file: string;
+    type: "file";
+    showInStarters: boolean;
+}, {
+    file: string;
+    type: "file";
+    showInStarters?: boolean | undefined;
+}>]>, "many">, ({
+    prompt: string;
+    description: string;
+    type: "inline";
+    id: string;
+    priority: number;
+    category: string;
+    showInStarters: boolean;
+    title?: string | undefined;
+} | {
+    file: string;
+    type: "file";
+    showInStarters: boolean;
+})[], ({
+    prompt: string;
+    type: "inline";
+    id: string;
+    description?: string | undefined;
+    title?: string | undefined;
+    priority?: number | undefined;
+    category?: string | undefined;
+    showInStarters?: boolean | undefined;
+} | {
+    file: string;
+    type: "file";
+    showInStarters?: boolean | undefined;
+})[]>, ({
+    file: string;
+    type: "file";
+    showInStarters: boolean;
+} | {
     title: string;
     prompt: string;
     description: string;
+    type: "inline";
     id: string;
     priority: number;
     category: string;
-}[], {
+    showInStarters: boolean;
+})[], ({
     prompt: string;
+    type: "inline";
     id: string;
     description?: string | undefined;
     title?: string | undefined;
     priority?: number | undefined;
     category?: string | undefined;
-}[]>>;
+    showInStarters?: boolean | undefined;
+} | {
+    file: string;
+    type: "file";
+    showInStarters?: boolean | undefined;
+})[]>>;
+/**
+ * Type for a single inline prompt (validated)
+ */
+export type ValidatedInlinePrompt = z.output<typeof InlinePromptSchema>;
+/**
+ * Type for a single file-based prompt (validated)
+ */
+export type ValidatedFilePrompt = z.output<typeof FilePromptSchema>;
+/**
+ * Type for a single prompt (either inline or file)
+ */
+export type ValidatedPrompt = ValidatedInlinePrompt | ValidatedFilePrompt;
+/**
+ * Validated prompts configuration type
+ */
+export type ValidatedPromptsConfig = z.output<typeof PromptsSchema>;
 /**
- * Validated starter prompts configuration type
+ * Input type for prompts configuration (before validation)
  */
-export type ValidatedStarterPromptsConfig = z.output<typeof StarterPromptsSchema>;
+export type PromptsConfig = z.input<typeof PromptsSchema>;
 //# sourceMappingURL=schemas.d.ts.map

package/dist/prompts/schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/prompts/schemas.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA4C6C,CAAC;AAE/E;;GAEG;AACH,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/prompts/schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiCoC,CAAC;AAEpE;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;EAeiC,CAAC;AAE/D;;;GAGG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA6BgC,CAAC;AAE3D;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAExE;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEpE;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG,qBAAqB,GAAG,mBAAmB,CAAC;AAE1E;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,aAAa,CAAC,CAAC;AAEpE;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/dist/prompts/schemas.js

@@ -1,31 +1,48 @@
 import "../chunk-C6A6W6XS.js";
 import { z } from "zod";
 import { PROMPT_NAME_REGEX, PROMPT_NAME_GUIDANCE } from "./name-validation.js";
-const StarterPromptsSchema = z.array(
-  z.object({
-    id: z.string().min(1).max(64).regex(PROMPT_NAME_REGEX, `Starter prompt id must be ${PROMPT_NAME_GUIDANCE}`).describe("Kebab-case slug id for the starter prompt (e.g., quick-start)"),
-    title: z.string().optional().describe("Display title for the starter prompt"),
-    description: z.string().optional().default("").describe("Description shown on hover or in the UI"),
-    prompt: z.string().describe("The actual prompt text that gets resolved and sent"),
-    category: z.string().optional().default("general").describe(
-      "Category for organizing starter prompts (e.g., general, coding, analysis, tools, learning)"
-    ),
-    priority: z.number().optional().default(0).describe("Higher numbers appear first")
-  }).strict()
-).superRefine((arr, ctx) => {
+const InlinePromptSchema = z.object({
+  type: z.literal("inline").describe("Inline prompt type"),
+  id: z.string().min(1).max(64).regex(PROMPT_NAME_REGEX, `Prompt id must be ${PROMPT_NAME_GUIDANCE}`).describe("Kebab-case slug id for the prompt (e.g., quick-start)"),
+  title: z.string().optional().describe("Display title for the prompt"),
+  description: z.string().optional().default("").describe("Description shown on hover or in the UI"),
+  prompt: z.string().describe("The actual prompt text"),
+  category: z.string().optional().default("general").describe("Category for organizing prompts (e.g., general, coding, analysis, tools)"),
+  priority: z.number().optional().default(0).describe("Higher numbers appear first in the list"),
+  showInStarters: z.boolean().optional().default(false).describe("Show as a clickable button in WebUI starter prompts")
+}).strict().describe("Inline prompt with text defined directly in config");
+const FilePromptSchema = z.object({
+  type: z.literal("file").describe("File-based prompt type"),
+  file: z.string().describe(
+    "Path to markdown file containing prompt (supports ${{dexto.agent_dir}} template)"
+  ),
+  showInStarters: z.boolean().optional().default(false).describe("Show as a clickable button in WebUI starter prompts")
+}).strict().describe("File-based prompt loaded from a markdown file");
+const PromptsSchema = z.array(z.discriminatedUnion("type", [InlinePromptSchema, FilePromptSchema])).superRefine((arr, ctx) => {
   const seen = /* @__PURE__ */ new Map();
   arr.forEach((p, idx) => {
-    if (seen.has(p.id)) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: `Duplicate starterPrompt id: ${p.id}`,
-        path: ["starterPrompts", idx, "id"]
-      });
-    } else {
-      seen.set(p.id, idx);
+    if (p.type === "inline") {
+      if (seen.has(p.id)) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `Duplicate prompt id: ${p.id}`,
+          path: [idx, "id"]
+        });
+      } else {
+        seen.set(p.id, idx);
+      }
     }
   });
-}).transform((arr) => arr.map((p) => ({ ...p, title: p.title ?? p.id.replace(/-/g, " ") }))).default([]).describe("Starter prompts that appear as clickable buttons in the WebUI");
+}).transform(
+  (arr) => arr.map((p) => {
+    if (p.type === "inline") {
+      return { ...p, title: p.title ?? p.id.replace(/-/g, " ") };
+    }
+    return p;
+  })
+).default([]).describe("Agent prompts - inline text or file-based");
 export {
-  StarterPromptsSchema
+  FilePromptSchema,
+  InlinePromptSchema,
+  PromptsSchema
 };

package/dist/prompts/types.d.ts

@@ -22,7 +22,7 @@ export interface PromptDefinition {
  * Enhanced prompt info with MCP-compliant structure
  */
 export interface PromptInfo extends PromptDefinition {
-    source: 'mcp' | 'file' | 'starter' | 'custom';
+    source: 'mcp' | 'config' | 'custom';
     metadata?: Record<string, unknown>;
 }
 /**

package/dist/prompts/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/prompts/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AAE1E;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAClC;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,SAAS,CAAC,EAAE,cAAc,EAAE,GAAG,SAAS,CAAC;CAC5C;AAED;;GAEG;AACH,MAAM,WAAW,UAAW,SAAQ,gBAAgB;IAChD,MAAM,EAAE,KAAK,GAAG,MAAM,GAAG,SAAS,GAAG,QAAQ,CAAC;IAC9C,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC;AAED;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;AAEnD;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC7B,OAAO,EAAE,UAAU,EAAE,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC3B;;OAEG;IACH,SAAS,IAAI,MAAM,CAAC;IAEpB;;OAEG;IACH,eAAe,IAAI,IAAI,CAAC;IAExB;;OAEG;IACH,WAAW,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAExD;;OAEG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;IAElF;;OAEG;IACH,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAAC;CACvE"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/prompts/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAC;AAE1E;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAClC;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,SAAS,CAAC,EAAE,cAAc,EAAE,GAAG,SAAS,CAAC;CAC5C;AAED;;GAEG;AACH,MAAM,WAAW,UAAW,SAAQ,gBAAgB;IAChD,MAAM,EAAE,KAAK,GAAG,QAAQ,GAAG,QAAQ,CAAC;IACpC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC;AAED;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;AAEnD;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC7B,OAAO,EAAE,UAAU,EAAE,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC3B;;OAEG;IACH,SAAS,IAAI,MAAM,CAAC;IAEpB;;OAEG;IACH,eAAe,IAAI,IAAI,CAAC;IAExB;;OAEG;IACH,WAAW,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAExD;;OAEG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;IAElF;;OAEG;IACH,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAAC;CACvE"}