Open MCP Server

Instructions

Implementation Reference

• src/core/prompt-manager.ts:255-287 (handler)

  Core implementation of prompt parameter validation: checks template existence, required parameters using helper, and type validation for each parameter.

  validate(
    templateId: string,
    params: Record<string, unknown>
  ): { valid: boolean; errors: string[] } {
    const template = this.get(templateId);
    if (!template) {
      return { valid: false, errors: [`Template not found: ${templateId}`] };
    }
  
    const paramValidation = validateParameters(template, params);
    if (!paramValidation.valid) {
      return {
        valid: false,
        errors: [`Missing required parameters: ${paramValidation.missing.join(", ")}`],
      };
    }
  
    // Type validation
    const errors: string[] = [];
    for (const param of template.parameters) {
      const value = params[param.name];
      if (value !== undefined && !this.validateType(value, param.type)) {
        errors.push(
          `Parameter '${param.name}' should be type '${param.type}', got '${typeof value}'`
        );
      }
    }
  
    return {
      valid: errors.length === 0,
      errors,
    };
  }

• src/prompts/prompts.ts:293-312 (registration)

  MCP tool registration for 'validate_prompt', defining input schema with Zod and thin handler delegating to PromptManager.validate.

  server.tool(
    "validate_prompt",
    "Validate parameters against a prompt template without rendering",
    {
      templateId: z.string().describe("The ID of the template"),
      parameters: z.record(z.any()).describe("Parameters to validate"),
    },
    async (args) => {
      const validation = registry.prompts.validate(args.templateId, args.parameters);
  
      return {
        content: [
          {
            type: "text",
            text: JSON.stringify(validation, null, 2),
          },
        ],
      };
    }
  );

• src/core/prompt-manager.ts:24-34 (helper)

  Helper function to check for missing required parameters in prompt templates.

  function validateParameters(
    template: PromptTemplate,
    params: Record<string, unknown>
  ): { valid: boolean; missing: string[] } {
    const required = template.parameters.filter((p) => p.required);
    const missing = required.filter((p) => !(p.name in params));
    return {
      valid: missing.length === 0,
      missing: missing.map((p) => p.name),
    };
  }

• src/core/prompt-manager.ts:292-307 (helper)

  Private helper to validate parameter types (string, number, boolean, array, object).

  private validateType(value: unknown, expectedType: string): boolean {
    switch (expectedType) {
      case "string":
        return typeof value === "string";
      case "number":
        return typeof value === "number";
      case "boolean":
        return typeof value === "boolean";
      case "array":
        return Array.isArray(value);
      case "object":
        return typeof value === "object" && value !== null && !Array.isArray(value);
      default:
        return true;
    }
  }

• src/prompts/prompts.ts:296-299 (schema)

  Zod input schema for the validate_prompt tool: templateId (string), parameters (record).

  {
    templateId: z.string().describe("The ID of the template"),
    parameters: z.record(z.any()).describe("Parameters to validate"),
  },