@type annotations() :: %{
  optional(:audience) => [role()],
  optional(:priority) => float(),
  optional(:lastModified) => String.t()
}

@type atom_initialize_result() :: %{
  :protocolVersion => String.t(),
  :capabilities => server_capabilities(),
  :serverInfo => server_info(),
  optional(:instructions) => String.t()
}

@type audio_content() :: %{
  :type => :audio,
  :data => String.t(),
  :mimeType => String.t(),
  optional(:annotations) => annotations()
}

@type blob_resource_contents() :: %{
  :uri => String.t(),
  :blob => String.t(),
  optional(:mimeType) => String.t()
}

@type cache_scope() :: :public | :private | String.t()

@type cacheable_result() :: %{
  optional(:resultType) => String.t(),
  optional(:ttlMs) => non_neg_integer(),
  optional(:cacheScope) => cache_scope()
}

@type call_tool_request() :: %{
  :name => String.t(),
  optional(:arguments) => %{required(String.t()) => any()}
}

@type call_tool_result() :: tool_result()

@type cancelled_notification() :: %{
  :requestId => request_id(),
  optional(:reason) => String.t()
}

@type client_capabilities() :: %{
  optional(:experimental) => %{required(String.t()) => map()},
  optional(:roots) => %{optional(:listChanged) => boolean()},
  optional(:sampling) => %{},
  optional(:elicitation) => %{},
  optional(:extensions) => %{required(String.t()) => map()}
}

@type client_info() :: implementation()

@type client_notification() ::
  cancelled_notification()
  | progress_notification()
  | list_changed_notification()

@type client_request() ::
  ping_request()
  | initialize_request()
  | list_resources_request()
  | read_resource_request()
  | list_prompts_request()
  | get_prompt_request()
  | list_tools_request()
  | call_tool_request()
  | complete_request()
  | set_level_request()
  | subscribe_request()
  | unsubscribe_request()

@type client_result() ::
  empty_result()
  | create_message_result()
  | list_roots_result()
  | elicit_result()

@type complete_argument() :: completion_argument()

@type complete_ref() :: completion_reference()

@type complete_request() :: %{
  ref: completion_reference(),
  argument: completion_argument()
}

@type complete_result() :: completion_result()

@type completion_argument() :: %{name: String.t(), value: String.t()}

@type completion_reference() :: resource_reference() | prompt_reference()

@type completion_result() :: %{
  completion: %{
    :values => [String.t()],
    optional(:total) => integer(),
    optional(:hasMore) => boolean()
  }
}

@type content() ::
  text_content() | image_content() | audio_content() | embedded_resource()

@type content_type() :: :text | :image | :audio | :resource

@type create_message_params() :: %{
  :messages => [sampling_message()],
  :maxTokens => integer(),
  optional(:modelPreferences) => model_preferences(),
  optional(:systemPrompt) => String.t(),
  optional(:includeContext) => include_context(),
  optional(:temperature) => float(),
  optional(:stopSequences) => [String.t()],
  optional(:metadata) => map(),
  optional(:tools) => [tool()],
  optional(:toolChoice) => tool_choice()
}

@type create_message_result() :: %{
  :role => role(),
  :content => text_content() | image_content() | audio_content(),
  :model => String.t(),
  optional(:stopReason) => String.t()
}

@type cursor() :: String.t()

@type elicit_request() :: %{
  message: String.t(),
  requestedSchema: %{
    :type => String.t(),
    :properties => %{required(String.t()) => primitive_schema()},
    optional(:required) => [String.t()]
  }
}

@type elicit_result() :: %{
  :action => :accept | :decline | :cancel,
  optional(:content) => %{required(String.t()) => any()}
}

@type embedded_resource() :: %{
  :type => :resource,
  :resource => resource_contents(),
  optional(:annotations) => annotations()
}

@type empty_result() :: %{}

@type error_code() :: integer()

@type error_data() :: any()

@type get_prompt_request() :: %{
  :name => String.t(),
  optional(:arguments) => %{required(String.t()) => String.t()}
}

@type get_prompt_result() :: %{
  optional(:description) => String.t(),
  messages: [prompt_message()]
}

@type icon() :: %{
  :type => String.t(),
  :uri => String.t(),
  optional(:mediaType) => String.t()
}

@type image_content() :: %{
  :type => :image,
  :data => String.t(),
  :mimeType => String.t(),
  optional(:annotations) => annotations()
}

@type implementation() :: %{
  :name => String.t(),
  :version => String.t(),
  optional(:title) => String.t(),
  optional(:description) => String.t()
}

@type include_context() :: :none | :thisServer | :allServers

@type initialize_request() :: %{
  protocolVersion: String.t(),
  capabilities: client_capabilities(),
  clientInfo: client_info()
}

@type initialize_result() :: atom_initialize_result() | wire_initialize_result()

@type json_schema() :: map()

@type jsonrpc_error() :: %{
  :code => error_code(),
  :message => String.t(),
  optional(:data) => error_data()
}

@type jsonrpc_error_response() :: %{
  jsonrpc: String.t(),
  id: request_id(),
  error: jsonrpc_error()
}

@type jsonrpc_message() ::
  jsonrpc_request()
  | jsonrpc_notification()
  | jsonrpc_response()
  | jsonrpc_error_response()

@type jsonrpc_notification() :: %{
  :jsonrpc => String.t(),
  :method => String.t(),
  optional(:params) => map()
}

@type jsonrpc_request() :: %{
  :jsonrpc => String.t(),
  :id => request_id(),
  :method => String.t(),
  optional(:params) => map()
}

@type jsonrpc_response() :: %{jsonrpc: String.t(), id: request_id(), result: any()}

@type list_changed_notification() :: %{}

@type list_prompts_request() :: paginated_request()

@type list_prompts_result() :: %{
  :prompts => [prompt()],
  optional(:nextCursor) => cursor()
}

@type list_resource_templates_request() :: paginated_request()

@type list_resource_templates_result() :: %{
  :resourceTemplates => [resource_template()],
  optional(:nextCursor) => cursor()
}

@type list_resources_request() :: paginated_request()

@type list_resources_result() :: %{
  :resources => [resource()],
  optional(:nextCursor) => cursor()
}

@type list_roots_request() :: %{}

@type list_roots_result() :: %{roots: [root()]}

@type list_tools_request() :: paginated_request()

@type list_tools_result() :: %{:tools => [tool()], optional(:nextCursor) => cursor()}

@type log_level() ::
  :debug | :info | :notice | :warning | :error | :critical | :alert | :emergency

@type log_level_string() :: String.t()

@type log_notification() :: %{
  :level => log_level_string(),
  optional(:logger) => String.t(),
  data: any()
}

@type model_hint() :: %{optional(:name) => String.t()}

@type model_preferences() :: %{
  optional(:hints) => [model_hint()],
  optional(:costPriority) => float(),
  optional(:speedPriority) => float(),
  optional(:intelligencePriority) => float()
}

@type paginated_request() :: %{optional(:cursor) => cursor()}

@type paginated_result() :: %{optional(:nextCursor) => cursor()}

@type ping_request() :: %{}

@type primitive_schema() :: %{
  :type => String.t(),
  optional(:title) => String.t(),
  optional(:description) => String.t(),
  optional(:enum) => [String.t()],
  optional(:enumNames) => [String.t()],
  optional(:default) => any(),
  optional(:minLength) => integer(),
  optional(:maxLength) => integer(),
  optional(:minimum) => number(),
  optional(:maximum) => number(),
  optional(:format) => String.t()
}

@type progress_notification() :: %{
  :progressToken => progress_token(),
  :progress => number(),
  optional(:total) => number(),
  optional(:message) => String.t()
}

@type progress_token() :: String.t() | integer()

@type prompt() :: %{
  :name => String.t(),
  optional(:title) => String.t(),
  optional(:description) => String.t(),
  optional(:arguments) => [prompt_argument() | map()],
  optional(:icons) => [icon()],
  optional(:_meta) => map()
}

@type prompt_argument() :: %{
  :name => String.t(),
  optional(:description) => String.t(),
  optional(:required) => boolean()
}

@type prompt_message() :: %{role: role(), content: content()}

@type prompt_reference() :: %{type: :"ref/prompt", name: String.t()}

@type protocol_mode() :: :legacy_only | :modern_only | :prefer_legacy | :prefer_modern

@type read_resource_request() :: %{uri: String.t()}

@type read_resource_result() :: %{contents: [resource_contents()]}

@type request_id() :: String.t() | integer()

@type resource() :: %{
  :uri => String.t(),
  :name => String.t(),
  optional(:title) => String.t(),
  optional(:description) => String.t(),
  optional(:mimeType) => String.t(),
  optional(:annotations) => annotations(),
  optional(:size) => integer(),
  optional(:icons) => [icon()],
  optional(:_meta) => map()
}

@type resource_contents() :: text_resource_contents() | blob_resource_contents()

@type resource_reference() :: %{type: :"ref/resource", uri: String.t()}

@type resource_template() :: %{
  :uriTemplate => String.t(),
  :name => String.t(),
  optional(:title) => String.t(),
  optional(:description) => String.t(),
  optional(:mimeType) => String.t(),
  optional(:annotations) => annotations(),
  optional(:icons) => [icon()],
  optional(:_meta) => map()
}

@type resource_updated_notification() :: %{uri: String.t()}

@type role() :: :user | :assistant

@type role_string() :: String.t()

@type root() :: %{:uri => String.t(), optional(:name) => String.t()}

@type sampling_message() :: %{
  role: role(),
  content: text_content() | image_content() | audio_content()
}

@type server_capabilities() :: %{
  optional(:experimental) => %{required(String.t()) => map()},
  optional(:logging) => %{},
  optional(:completions) => %{},
  optional(:prompts) => %{optional(:listChanged) => boolean()},
  optional(:resources) => %{
    optional(:subscribe) => boolean(),
    optional(:listChanged) => boolean()
  },
  optional(:tools) => %{optional(:listChanged) => boolean()},
  optional(:extensions) => %{required(String.t()) => map()}
}

@type server_info() :: implementation()

@type server_notification() ::
  cancelled_notification()
  | progress_notification()
  | log_notification()
  | resource_updated_notification()
  | list_changed_notification()

@type server_request() ::
  ping_request()
  | create_message_params()
  | list_roots_request()
  | elicit_request()

@type server_result() ::
  empty_result()
  | initialize_result()
  | complete_result()
  | get_prompt_result()
  | list_prompts_result()
  | list_resource_templates_result()
  | list_resources_result()
  | read_resource_result()
  | call_tool_result()
  | list_tools_result()

@type set_level_request() :: %{level: log_level_string()}

@type subscribe_request() :: %{uri: String.t()}

@type subscribe_result() :: %{}

@type task() :: %{
  :id => String.t(),
  :state => task_state(),
  optional(:toolName) => String.t(),
  optional(:arguments) => map(),
  optional(:createdAt) => String.t(),
  optional(:ttl) => integer(),
  optional(:result) => tool_result(),
  optional(:metadata) => map()
}

@type task_state() :: :working | :input_required | :completed | :failed | :cancelled

@type text_content() :: %{
  :type => :text,
  :text => String.t(),
  optional(:annotations) => annotations()
}

@type text_resource_contents() :: %{
  :uri => String.t(),
  :text => String.t(),
  optional(:mimeType) => String.t()
}

@type tool() :: %{
  :name => String.t(),
  optional(:description) => String.t(),
  optional(:title) => String.t(),
  :inputSchema => json_schema(),
  optional(:outputSchema) => json_schema(),
  optional(:annotations) => tool_annotations(),
  optional(:icons) => [icon()],
  optional(:execution) => map(),
  optional(:_meta) => map()
}

@type tool_annotations() :: %{
  optional(:title) => String.t(),
  optional(:readOnlyHint) => boolean(),
  optional(:destructiveHint) => boolean(),
  optional(:idempotentHint) => boolean(),
  optional(:openWorldHint) => boolean()
}

@type tool_choice() :: %{type: String.t()}

@type tool_result() :: %{
  :content => [content()],
  optional(:isError) => boolean(),
  optional(:structuredContent) => any()
}

@type tool_result_content() :: %{
  :type => String.t(),
  :tool_use_id => String.t(),
  :content => [content()],
  optional(:isError) => boolean()
}

@type tool_use_content() :: %{
  type: String.t(),
  id: String.t(),
  name: String.t(),
  input: map()
}

@type transport() :: :stdio | :http | module()

@type unsubscribe_request() :: %{uri: String.t()}

@type unsubscribe_result() :: %{}

@type wire_initialize_result() :: %{required(String.t()) => any()}