@spec check_required_capabilities(map(), list()) :: :ok | {:error, String.t()}

Checks that required capabilities are available in the server capabilities.

Parameters

• server_capabilities - The server's capabilities
• required_capabilities - List of required capabilities

Returns

• :ok - All required capabilities are available
• {:error, reason} - Some required capabilities are missing

Examples

Simple capability list:

iex> server_capabilities = %{resources: %{}, tools: %{}}
iex> Lifecycle.check_required_capabilities(server_capabilities, [:resources])
:ok

With sub-capability requirements:

iex> server_capabilities = %{resources: %{subscribe: true}}
iex> Lifecycle.check_required_capabilities(server_capabilities, [resources: [:subscribe]])
:ok

@spec create_initialize_request(map(), map(), String.t()) ::
  MCPEx.Protocol.Types.InitializeRequest.t()

Creates an initialization request according to the MCP specification.

Parameters

• client_info - Information about the client (name, version)
• capabilities - The client's capabilities
• protocol_version - The protocol version to use (defaults to latest)

Returns

• InitializeRequest.t() - The initialization request struct

Examples

iex> Lifecycle.create_initialize_request(
...>   %{name: "TestClient", version: "1.0.0"},
...>   %{sampling: %{}}
...> )

@spec create_initialized_notification() ::
  MCPEx.Protocol.Types.InitializedNotification.t()

Creates an initialized notification according to the MCP specification.

Returns

• InitializedNotification.t() - The initialized notification struct

Examples

iex> Lifecycle.create_initialized_notification()
%InitializedNotification{}

@spec process_initialize_response(map()) ::
  {:ok, MCPEx.Protocol.Types.InitializeResult.t()} | {:error, String.t()}

Processes an initialization response from the server.

Parameters

• response - The server's response to the initialization request

Returns

• {:ok, InitializeResult.t()} - Successful initialization
• {:error, reason} - Error during initialization

Examples

iex> response = %{
...>   jsonrpc: "2.0", id: 1, 
...>   result: %{
...>     serverInfo: %{name: "Server", version: "1.0"},
...>     protocolVersion: "2025-03-26",
...>     capabilities: %{}
...>   }
...> }
iex> {:ok, result} = Lifecycle.process_initialize_response(response)

@spec process_server_capabilities(map() | nil) :: {:ok, map()} | {:error, String.t()}

Processes server capabilities from the initialize response.

Parameters

• capabilities - The raw server capabilities map

Returns

• {:ok, map()} - Processed capabilities
• {:error, reason} - Error processing capabilities

@spec validate_protocol_version(String.t()) :: :ok | {:error, String.t()}

Validates that a protocol version is supported by the client.

Parameters

• version - The protocol version to check

Returns

• :ok - The version is supported
• {:error, reason} - The version is not supported

@spec validate_server_initialization(map()) :: :ok | {:error, String.t()}

Validates a server initialization response.

Parameters

• response - The server's response to the initialization request

Returns

• :ok - The initialization is valid
• {:error, reason} - There are issues with the initialization