mcp-confluent

Instructions

Implementation Reference

• src/confluent/tools/handlers/environments/read-environment-handler.ts:32-122 (handler)

  The handle method of ReadEnvironmentHandler, which parses arguments, calls the Confluent Cloud REST API to retrieve the environment by ID, validates the response, formats details, and returns the result.

    async handle(
      clientManager: ClientManager,
      toolArguments: Record<string, unknown>,
    ): Promise<CallToolResult> {
      const { baseUrl, environmentId } =
        readEnvironmentArguments.parse(toolArguments);
  
      try {
        if (baseUrl !== undefined && baseUrl !== "") {
          clientManager.setConfluentCloudRestEndpoint(baseUrl);
        }
  
        const pathBasedClient = wrapAsPathBasedClient(
          clientManager.getConfluentCloudRestClient(),
        );
  
        const { data: response, error } = await pathBasedClient[
          "/org/v2/environments/{id}"
        ].GET({
          params: {
            path: {
              id: environmentId,
            },
          },
        });
  
        if (error) {
          logger.error({ error }, "API Error");
          return this.createResponse(
            `Failed to fetch environment: ${JSON.stringify(error)}`,
            true,
            { error },
          );
        }
  
        try {
          const validatedEnvironment = environmentSchema.parse(
            response,
          ) as Environment;
          const environmentDetails = {
            api_version: validatedEnvironment.api_version,
            kind: validatedEnvironment.kind,
            id: validatedEnvironment.id,
            name: validatedEnvironment.display_name,
            metadata: {
              created_at: validatedEnvironment.metadata.created_at,
              updated_at: validatedEnvironment.metadata.updated_at,
              deleted_at: validatedEnvironment.metadata.deleted_at,
              resource_name: validatedEnvironment.metadata.resource_name,
              self: validatedEnvironment.metadata.self,
            },
            stream_governance_package:
              validatedEnvironment.stream_governance_config?.package,
          };
  
          const formattedDetails = `
  Environment: ${environmentDetails.name}
    API Version: ${environmentDetails.api_version}
    Kind: ${environmentDetails.kind}
    ID: ${environmentDetails.id}
    Resource Name: ${environmentDetails.metadata.resource_name}
    Self Link: ${environmentDetails.metadata.self}
    Created At: ${environmentDetails.metadata.created_at}
    Updated At: ${environmentDetails.metadata.updated_at}${environmentDetails.metadata.deleted_at ? `\n  Deleted At: ${environmentDetails.metadata.deleted_at}` : ""}${environmentDetails.stream_governance_package ? `\n  Stream Governance Package: ${environmentDetails.stream_governance_package}` : ""}
  `;
  
          return this.createResponse(
            `Successfully retrieved environment:\n${formattedDetails}`,
            false,
            { environment: environmentDetails },
          );
        } catch (validationError) {
          logger.error(
            { error: validationError },
            "Environment validation error",
          );
          return this.createResponse(
            `Invalid environment data: ${validationError instanceof Error ? validationError.message : String(validationError)}`,
            true,
            { error: validationError },
          );
        }
      } catch (error) {
        logger.error({ error }, "Error in ReadEnvironmentHandler");
        return this.createResponse(
          `Failed to fetch environment: ${error instanceof Error ? error.message : String(error)}`,
          true,
          { error: error instanceof Error ? error.message : String(error) },
        );
      }
    }

• src/confluent/tools/handlers/environments/read-environment-handler.ts:18-29 (schema)

  Zod schema defining the input parameters for the read-environment tool: baseUrl (optional) and environmentId (required).

  const readEnvironmentArguments = z.object({
    baseUrl: z
      .string()
      .describe("The base URL of the Confluent Cloud REST API.")
      .url()
      .default(() => env.CONFLUENT_CLOUD_REST_ENDPOINT ?? "")
      .optional(),
    environmentId: z
      .string()
      .describe("The ID of the environment to retrieve")
      .nonempty(),
  });

• src/confluent/tools/tool-factory.ts:65-65 (registration)

  Registration of the read-environment tool in the ToolFactory's static handlers Map, associating ToolName.READ_ENVIRONMENT with a new instance of ReadEnvironmentHandler.

  [ToolName.READ_ENVIRONMENT, new ReadEnvironmentHandler()],

• src/confluent/tools/tool-name.ts:25-25 (helper)

  Definition of the ToolName enum value for 'read-environment' used in registration and tool configuration.

  READ_ENVIRONMENT = "read-environment",

• src/confluent/tools/handlers/environments/read-environment-handler.ts:124-130 (registration)

  Tool configuration method providing the name, description, and input schema for the read-environment tool.

  getToolConfig(): ToolConfig {
    return {
      name: ToolName.READ_ENVIRONMENT,
      description: "Get details of a specific environment by ID",
      inputSchema: readEnvironmentArguments.shape,
    };
  }