eRegulations MCP Server

Implementation Reference

• src/mcp-capabilities/tools/handlers/get-procedure-details.ts:12-65 (handler)

  The main handler implementation for the getProcedureDetails tool. It creates a ToolHandler object with the tool's metadata and the async execution logic that retrieves procedure details via the ERegulationsApi and formats the response.

  export function createGetProcedureDetailsHandler(
    api: ERegulationsApi
  ): ToolHandler {
    return {
      name: ToolName.GET_PROCEDURE_DETAILS,
      description: `Get detailed information about a specific procedure by ID.`,
      inputSchema: zodToJsonSchema(GetProcedureDetailsSchema),
      inputSchemaDefinition: GetProcedureDetailsSchema,
      handler: async (args: any) => {
        try {
          // Use the inferred type for args
          const { procedureId } = args as GetProcedureDetailsArgs;
  
          logger.log(
            `Handling GET_PROCEDURE_DETAILS request for ID ${procedureId}`
          );
  
          const procedure = await api.getProcedureById(procedureId);
  
          // Use the formatter - Get result (data part will be ignored)
          const formattedResult = formatters.procedure.format(procedure);
  
          logger.log(
            `GET_PROCEDURE_DETAILS returning details for ${procedure.name}`
          );
  
          // Always return only text content
          return {
            content: [
              {
                type: "text",
                text: formattedResult.text, // Data part of formattedResult is ignored
              },
            ],
          };
        } catch (error: any) {
          const errorMessage = error.message || String(error);
          logger.error(
            `Error in GET_PROCEDURE_DETAILS handler for ID ${args?.procedureId}:`,
            errorMessage
          );
  
          return {
            content: [
              {
                type: "text",
                text: `Error retrieving procedure details: ${errorMessage}\n\nValid procedure IDs can be found by using the listProcedures tool first.`,
              },
            ],
          };
        }
      },
    };
  }

• src/mcp-capabilities/tools/schemas.ts:14-20 (schema)

  Zod schema definition for the input parameters of the getProcedureDetails tool, requiring a positive integer procedureId.

  export const GetProcedureDetailsSchema = z.object({
    procedureId: z
      .number()
      .int()
      .positive()
      .describe("ID of the procedure to retrieve"),
  });

• src/mcp-server.ts:65-79 (registration)

  Registration of all tools, including getProcedureDetails, with the MCP server using server.tool() in a loop over the handlers array.

  handlers.forEach((handler) => {
    const schemaDef = handler.inputSchemaDefinition;
    // Check if it's an instance of ZodObject
    if (schemaDef instanceof z.ZodObject) {
      // Now TypeScript knows schemaDef is a ZodObject and has .shape
      // Cast handler to 'any' to bypass strict type checking
      server.tool(handler.name, schemaDef.shape, handler.handler as any);
      logger.info(`Registered tool '${handler.name}' with McpServer`);
    } else {
      // Handle non-object schemas or log warning
      logger.warn(
        `Could not register tool '${handler.name}': Schema is not a ZodObject.`
      );
    }
  });

• src/mcp-capabilities/tools/handlers/index.ts:13-20 (registration)

  The createHandlers function that includes the getProcedureDetails handler in the array of all tool handlers, called from mcp-server.ts.

  export function createHandlers(api: ERegulationsApi): ToolHandler[] {
    return [
      createListProceduresHandler(api),
      createGetProcedureDetailsHandler(api),
      createGetProcedureStepHandler(api),
      createSearchProceduresHandler(api),
    ];
  }

• src/mcp-capabilities/tools/schemas.ts:3-8 (schema)

  Enum defining the tool names, including GET_PROCEDURE_DETAILS used as the tool name string.

  export enum ToolName {
    LIST_PROCEDURES = "listProcedures",
    GET_PROCEDURE_DETAILS = "getProcedureDetails",
    GET_PROCEDURE_STEP = "getProcedureStep",
    SEARCH_PROCEDURES = "searchProcedures",
  }