Skip to main content
Glama

request_action_confirmation

Request user confirmation before implementing research-based architectural changes to ensure alignment with project goals and risk assessment.

Instructions

Request confirmation before applying research-based changes

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
actionYesDescription of the action to be performed
detailsYesDetailed information about the action
impactNoImpact level of the actionmedium

Implementation Reference

  • Primary handler for 'request_action_confirmation' MCP tool. Generates formatted confirmation request with impact assessment, decision guidelines, and response format for user approval of critical actions.
    export async function requestActionConfirmation(args: {
      action: string;
      details: string;
      impact?: 'low' | 'medium' | 'high' | 'critical';
    }): Promise<any> {
      const { action, details, impact = 'medium' } = args;
    
      try {
        const { promptForActionConfirmation } = await import('../utils/research-integration.js');
    
        const result = promptForActionConfirmation(action, details, impact);
    
        return {
          content: [
            {
              type: 'text',
              text: `# Action Confirmation Request
    
    ${result.instructions}
    
    ## Confirmation Prompt
    
    ${result.confirmationPrompt}
    
    ## Response Required
    
    Please provide your decision on this action:
    
    ### Response Format
    \`\`\`
    DECISION: [APPROVED|REJECTED|MODIFIED|DEFERRED]
    
    REASONING: [Your reasoning for the decision]
    
    MODIFICATIONS: [If MODIFIED, specify required changes]
    
    TIMELINE: [If DEFERRED, specify when to reconsider]
    
    ADDITIONAL_REQUIREMENTS: [Any additional requirements or conditions]
    \`\`\`
    
    ### Decision Guidelines
    
    - **APPROVED**: Action can proceed as proposed
    - **REJECTED**: Action should not be implemented (provide reasoning)
    - **MODIFIED**: Action needs changes before approval (specify modifications)
    - **DEFERRED**: Action should be postponed (specify timeline)
    
    ## Impact Assessment
    
    **Impact Level**: ${impact.toUpperCase()}
    
    ${
      impact === 'critical'
        ? '⚠️ **CRITICAL IMPACT**: This action requires careful review and may affect multiple systems or stakeholders.'
        : impact === 'high'
          ? '🔶 **HIGH IMPACT**: This action should be reviewed by senior stakeholders and may require coordination.'
          : impact === 'medium'
            ? '🔷 **MEDIUM IMPACT**: This action requires standard review and approval processes.'
            : '🔹 **LOW IMPACT**: This action has minimal risk but still requires confirmation.'
    }
    
    ## Next Steps
    
    After receiving confirmation:
    1. **Document the decision** and reasoning
    2. **Proceed with approved actions** following implementation guidelines
    3. **Apply any required modifications** before implementation
    4. **Schedule deferred actions** for future consideration
    5. **Communicate decisions** to relevant stakeholders
    `,
            },
          ],
        };
      } catch (error) {
        throw new McpAdrError(
          `Failed to request action confirmation: ${error instanceof Error ? error.message : String(error)}`,
          'CONFIRMATION_ERROR'
        );
      }
    }
  • Helper function used by the handler to generate the confirmation prompt template and accompanying instructions based on the action details and impact level.
    export function promptForActionConfirmation(
      action: string,
      details: string,
      impact: 'low' | 'medium' | 'high' | 'critical'
    ): { confirmationPrompt: string; instructions: string } {
      const confirmationPrompt = `
    # Action Confirmation Required
    
    **Action**: ${action}
    **Impact Level**: ${impact.toUpperCase()}
    
    ## Details
    ${details}
    
    ## Confirmation Required
    Before proceeding with this action, please confirm:
    
    1. **Understanding**: Do you understand the proposed action and its implications?
    2. **Authorization**: Are you authorized to approve this type of change?
    3. **Impact Assessment**: Have you reviewed the potential impact on existing systems?
    4. **Timing**: Is this an appropriate time to implement this change?
    5. **Resources**: Are the necessary resources available for implementation?
    
    ## Risk Assessment
    ${
      impact === 'critical'
        ? '🔴 **CRITICAL**: This action may have significant system-wide impact'
        : impact === 'high'
          ? '🟠 **HIGH**: This action may affect multiple components or stakeholders'
          : impact === 'medium'
            ? '🟡 **MEDIUM**: This action has moderate impact and should be reviewed'
            : '🟢 **LOW**: This action has minimal impact but still requires confirmation'
    }
    
    Please respond with:
    - **APPROVED**: To proceed with the action
    - **REJECTED**: To cancel the action
    - **MODIFIED**: To request modifications to the proposed action
    - **DEFERRED**: To postpone the action to a later time
    
    Include any additional comments or requirements for the action.
    `;
    
      const instructions = `
    # Action Confirmation Instructions
    
    This confirmation step ensures that significant changes are properly reviewed before implementation.
    
    ## Confirmation Process
    1. **Review the proposed action** and its details carefully
    2. **Assess the impact level** and potential consequences
    3. **Consider timing and resources** required for implementation
    4. **Provide clear approval or rejection** with reasoning
    5. **Specify any modifications** needed if not approving as-is
    
    ## Response Options
    - **APPROVED**: Action can proceed as proposed
    - **REJECTED**: Action should not be implemented
    - **MODIFIED**: Action needs changes before approval
    - **DEFERRED**: Action should be postponed
    
    ## Best Practices
    - Always review high and critical impact actions carefully
    - Consider stakeholder impact and communication needs
    - Ensure proper backup and rollback plans are in place
    - Document the approval decision and reasoning
    `;
    
      return {
        confirmationPrompt,
        instructions,
      };
    }
  • Input schema defined by TypeScript function parameters for the tool: required action and details strings, optional impact level.
    export async function requestActionConfirmation(args: {
      action: string;
      details: string;
      impact?: 'low' | 'medium' | 'high' | 'critical';
    }): Promise<any> {
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'request confirmation,' implying an interactive or approval-seeking behavior, but fails to detail how confirmation is handled (e.g., user prompt, automated check), what happens upon confirmation or denial, or any side effects like rate limits or permissions. This leaves significant gaps in understanding the tool's operational behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence: 'Request confirmation before applying research-based changes.' It is front-loaded with the core purpose, has zero wasted words, and is appropriately sized for the tool's complexity, making it easy to parse quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's moderate complexity (3 parameters, no output schema, no annotations), the description is minimally adequate. It states the purpose but lacks details on behavioral traits, return values, or error handling. Without annotations or output schema, more context on what happens after confirmation (e.g., success/failure responses) would improve completeness, leaving room for enhancement.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage, with clear documentation for 'action,' 'details,' and 'impact' (including enum values and default). The description does not add any additional semantic context beyond what the schema provides, such as examples or usage tips. With high schema coverage, the baseline score of 3 is appropriate, as the schema adequately covers parameter meanings without extra description input.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Request confirmation before applying research-based changes.' It specifies the verb ('request confirmation') and the context ('before applying research-based changes'), making it distinct from sibling tools that focus on analysis, generation, or validation. However, it doesn't explicitly differentiate from potential confirmation-related siblings, which prevents a perfect score.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage context ('before applying research-based changes'), suggesting it should be used prior to making changes based on research. However, it lacks explicit guidance on when to use this tool versus alternatives (e.g., direct application tools or other confirmation methods) and does not specify exclusions or prerequisites, leaving some ambiguity.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/tosin2013/mcp-adr-analysis-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server