create_presentation_definition

Instructions

Implementation Reference

• src/tools/createPresentationDefinition.ts:8-92 (handler)

  The main handler function that executes the tool logic: validates input using the schema, constructs the DIF PEX v2.0 presentation definition from input descriptors, validates structure (unique IDs, non-empty), generates human-readable summary and JSON output.

  export async function createPresentationDefinition(args: any): Promise<CallToolResult> {
    // Validate and sanitize input
    const validation = validateAndSanitizeInput(CreatePresentationDefinitionInputSchema, args, 'create_presentation_definition');
    
    if (!validation.success) {
      return createValidationErrorResult(validation.error!);
    }
  
    const data = validation.data!;
    const { id, name, purpose, inputDescriptors } = data;
  
    try {
      // Build the presentation definition according to DIF PEX v2.0 spec
      const presentationDefinition = {
        id,
        name,
        purpose,
        input_descriptors: inputDescriptors.map((descriptor: any) => ({
          id: descriptor.id,
          name: descriptor.name,
          purpose: descriptor.purpose,
          constraints: descriptor.constraints || {},
          schema: descriptor.schema || undefined
        }))
      };
  
      // Validate the structure
      if (!presentationDefinition.input_descriptors.length) {
        throw new Error('At least one input descriptor is required');
      }
  
      // Check for duplicate IDs
      const descriptorIds = presentationDefinition.input_descriptors.map((d: any) => d.id);
      const uniqueIds = new Set(descriptorIds);
      if (descriptorIds.length !== uniqueIds.size) {
        throw new Error('Input descriptor IDs must be unique');
      }
  
      const summary = [
        `• Definition ID: ${id}`,
        `• Name: ${name || 'Not specified'}`,
        `• Purpose: ${purpose || 'Not specified'}`,
        `• Input Descriptors: ${inputDescriptors.length}`,
        ''
      ];
  
      inputDescriptors.forEach((descriptor: any, index: number) => {
        summary.push(`Input Descriptor ${index + 1}:`);
        summary.push(`  • ID: ${descriptor.id}`);
        summary.push(`  • Name: ${descriptor.name || 'Not specified'}`);
        summary.push(`  • Purpose: ${descriptor.purpose || 'Not specified'}`);
        
        if (descriptor.constraints?.fields) {
          summary.push(`  • Field Constraints: ${descriptor.constraints.fields.length}`);
          descriptor.constraints.fields.forEach((field: any, fieldIndex: number) => {
            summary.push(`    - Field ${fieldIndex + 1}: ${field.path?.join(', ') || 'No path specified'}`);
          });
        }
        summary.push('');
      });
  
      return {
        content: [
          {
            type: 'text',
            text: `Created Presentation Definition:\n\n${summary.join('\n')}`
          },
          {
            type: 'text',
            text: `\`\`\`json\n${JSON.stringify(presentationDefinition, null, 2)}\n\`\`\``
          }
        ]
      };
    } catch (error: any) {
      return {
        content: [
          {
            type: 'text',
            text: `Failed to create presentation definition: ${error.message}`
          }
        ],
        isError: true
      };
    }
  }

• src/schemas/toolSchemas.ts:115-120 (schema)

  Zod input schema definition for the create_presentation_definition tool, validating required ID and at least one input descriptor, with optional name and purpose.

  export const CreatePresentationDefinitionInputSchema = z.object({
    id: z.string().min(1, 'Presentation definition ID is required'),
    name: z.string().optional(),
    purpose: z.string().optional(),
    inputDescriptors: z.array(InputDescriptorSchema).min(1, 'At least one input descriptor is required')
  });

• src/utils/schemaConverter.ts:37-39 (registration)

  Tool registration in TOOL_DEFINITIONS array: specifies name, description, and references the input schema for generating MCP Tool objects advertised to clients.

  name: 'create_presentation_definition',
  description: 'Create a DIF Presentation Exchange v2.0 definition for requesting specific credentials. Defines input descriptors and constraints for credential selection.',
  inputSchema: TOOL_SCHEMAS.create_presentation_definition

• src/index.ts:95-96 (registration)

  Handler dispatch in the main switch statement: routes 'create_presentation_definition' tool calls to the createPresentationDefinition function.

  case 'create_presentation_definition':
    return await createPresentationDefinition(args);