create_presentation_definition

Define credential requirements for verifiable presentations by specifying input descriptors and constraints using DIF Presentation Exchange v2.0 standards.

Instructions

Create a DIF Presentation Exchange v2.0 definition for requesting specific credentials. Defines input descriptors and constraints for credential selection.

Input Schema

TableJSON Schema

Name	Required	Description	Default
`id`	Yes
`name`	No
`purpose`	No
`inputDescriptors`	Yes

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);
```

HiveAuth MCP Server