listProcedures

Implementation Reference

• src/mcp-capabilities/tools/handlers/list-procedures.ts:12-61 (handler)

  The createListProceduresHandler function defining the tool's name, description, input schema, and asynchronous handler logic. It fetches procedures via api.getProceduresList(), formats them using formatters.procedureList, and returns formatted text content or error message.

  export function createListProceduresHandler(api: ERegulationsApi): ToolHandler {
    return {
      name: ToolName.LIST_PROCEDURES,
      description: `List all available procedures in the eRegulations system.`,
      inputSchema: zodToJsonSchema(ListProceduresSchema),
      inputSchemaDefinition: ListProceduresSchema,
      handler: async (args: any) => {
        try {
          // Use the inferred type for args
          // const { max_items, max_length } = args as ListProceduresArgs; // Removed
  
          logger.log(`Handling LIST_PROCEDURES request`);
          // Removed logging for max_items, max_length
  
          const procedures = await api.getProceduresList();
  
          // Use the dedicated formatter, always requesting text only
          const formattedResult = formatters.procedureList.format(
            procedures,
            false
            // Removed max_items, max_length
          );
  
          logger.log(`LIST_PROCEDURES returning ${procedures.length} procedures`);
  
          // Always return only text content
          return {
            content: [
              {
                type: "text",
                text: formattedResult.text,
              },
            ],
          };
        } catch (error) {
          logger.error(`Error in LIST_PROCEDURES handler:`, error);
          return {
            content: [
              {
                type: "text",
                text: `Error retrieving procedures: ${
                  error instanceof Error ? error.message : String(error)
                }`,
              },
            ],
          };
        }
      },
    };
  }

• src/mcp-capabilities/tools/schemas.ts:10-12 (schema)

  Zod schema definition for the listProcedures tool input (empty object, no parameters).

  export const ListProceduresSchema = z.object({
    // Remove max_items and max_length
  });

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

  Tool handlers factory function that registers (creates) the listProcedures handler along with others, to be used in MCP server.

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

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

  Top-level MCP server registration loop that calls server.tool() for each handler, including listProcedures, using its name, schema shape, and handler function.

  const handlers = createHandlers(api);
  
  // Add the example 'add' tool for testing - REMOVED
  /*
  server.tool(
    "add",
    { a: z.number(), b: z.number() },
    async ({ a, b }) => {
      logger.info(`Handling tool call: add(${a}, ${b})`);
      return {
        // Ensure response matches MCP ToolResult structure
        content: [{ type: "text", text: String(a + b) }],
      };
    }
  );
  */
  
  // Register eRegulations tools
  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.`
      );
    }
  });