(** MCP SDK - Model Context Protocol SDK for OCaml *)

open Mcp
open Jsonrpc

(** SDK version *)
val version : string

(** Logging utilities *)
module Log : sig
  type level = Debug | Info | Warning | Error

  val string_of_level : level -> string

  (** Format-string based logging functions *)
  val logf : level -> ('a, out_channel, unit) format -> 'a
  val debugf : ('a, out_channel, unit) format -> 'a
  val infof : ('a, out_channel, unit) format -> 'a
  val warningf : ('a, out_channel, unit) format -> 'a
  val errorf : ('a, out_channel, unit) format -> 'a

  (** Simple string logging functions (for backward compatibility) *)
  val log : level -> string -> unit
  val debug : string -> unit
  val info : string -> unit
  val warning : string -> unit
  val error : string -> unit
end

(** Context for tools and resources *)
module Context : sig
  type t

  val create : ?request_id:RequestId.t -> ?progress_token:ProgressToken.t -> ?lifespan_context:(string * Json.t) list -> unit -> t
  val get_context_value : t -> string -> Json.t option
  val report_progress : t -> float -> float -> JSONRPCMessage.t option
end

(** Tools for the MCP server *)
module Tool : sig
  type handler = Context.t -> Json.t -> (Json.t, string) result

  type t = {
    name: string;
    description: string option;
    input_schema: Json.t;
    handler: handler;
  }

  val create : name:string -> ?description:string -> input_schema:Json.t -> handler:handler -> unit -> t
  val to_json : t -> Json.t
  
  (** Convert to Mcp_rpc.ToolsList.Tool.t *)
  val to_rpc_tool_list_tool : t -> Mcp_rpc.ToolsList.Tool.t
  
  (** Convert a list of Tool.t to the format needed for tools/list response *)
  val to_rpc_tools_list : t list -> Mcp_rpc.ToolsList.Tool.t list
  
  (** Convert Mcp_rpc.ToolsCall response content to Mcp.content list *)
  val rpc_content_to_mcp_content : Mcp_rpc.ToolsCall.ToolContent.t list -> Mcp.content list
  
  (** Convert Mcp.content list to Mcp_rpc.ToolsCall.ToolContent.t list *)
  val mcp_content_to_rpc_content : Mcp.content list -> Mcp_rpc.ToolsCall.ToolContent.t list
  
  (** Create a tool result with content *)
  val create_tool_result : Mcp.content list -> is_error:bool -> Json.t
  
  (** Create a tool error result with structured content *)
  val create_error_result : string -> Json.t
  
  (** Handle tool execution errors *)
  val handle_execution_error : string -> Json.t
  
  (** Handle unknown tool error *)
  val handle_unknown_tool_error : string -> Json.t
  
  (** Handle general tool execution exception *)
  val handle_execution_exception : exn -> Json.t
end

(** Resources for the MCP server *)
module Resource : sig
  type handler = Context.t -> string list -> (string, string) result

  type t = {
    uri: string;
    name: string;
    description: string option;
    mime_type: string option;
    handler: handler;
  }

  val create : uri:string -> name:string -> ?description:string -> ?mime_type:string -> handler:handler -> unit -> t
  val to_json : t -> Json.t
  
  (** Convert to Mcp_rpc.ResourcesList.Resource.t *)
  val to_rpc_resource_list_resource : t -> Mcp_rpc.ResourcesList.Resource.t
  
  (** Convert a list of Resource.t to the format needed for resources/list response *)
  val to_rpc_resources_list : t list -> Mcp_rpc.ResourcesList.Resource.t list
end

(** Resource Templates for the MCP server *)
module ResourceTemplate : sig
  type handler = Context.t -> string list -> (string, string) result

  type t = {
    uri_template: string;
    name: string;
    description: string option;
    mime_type: string option;
    handler: handler;
  }

  val create : uri_template:string -> name:string -> ?description:string -> ?mime_type:string -> handler:handler -> unit -> t
  val to_json : t -> Json.t
  
  (** Convert to Mcp_rpc.ResourceTemplatesList.ResourceTemplate.t *)
  val to_rpc_resource_template : t -> Mcp_rpc.ListResourceTemplatesResult.ResourceTemplate.t
  
  (** Convert a list of ResourceTemplate.t to the format needed for resources/templates/list response *)
  val to_rpc_resource_templates_list : t list -> Mcp_rpc.ListResourceTemplatesResult.ResourceTemplate.t list
end

(** Prompts for the MCP server *)
module Prompt : sig
  type argument = {
    name: string;
    description: string option;
    required: bool;
  }

  type message = {
    role: Role.t;
    content: content;
  }

  type handler = Context.t -> (string * string) list -> (message list, string) result

  type t = {
    name: string;
    description: string option;
    arguments: argument list;
    handler: handler;
  }

  val create : name:string -> ?description:string -> ?arguments:argument list -> handler:handler -> unit -> t
  val create_argument : name:string -> ?description:string -> ?required:bool -> unit -> argument
  val to_json : t -> Json.t
  
  (** Convert argument to Mcp_rpc.PromptsList.PromptArgument.t *)
  val argument_to_rpc_prompt_argument : argument -> Mcp_rpc.PromptsList.PromptArgument.t
  
  (** Convert to Mcp_rpc.PromptsList.Prompt.t *)
  val to_rpc_prompt_list_prompt : t -> Mcp_rpc.PromptsList.Prompt.t
  
  (** Convert a list of Prompt.t to the format needed for prompts/list response *)
  val to_rpc_prompts_list : t list -> Mcp_rpc.PromptsList.Prompt.t list
  
  (** Convert message to Mcp_rpc.PromptMessage.t *)
  val message_to_rpc_prompt_message : message -> PromptMessage.t
  
  (** Convert a list of messages to the format needed for prompts/get response *)
  val messages_to_rpc_prompt_messages : message list -> PromptMessage.t list
end

(** Main server type *)
type server

val name : server -> string
val version : server -> string
val protocol_version : server -> string
val capabilities : server -> Json.t
val tools : server -> Tool.t list
val resources : server -> Resource.t list
val resource_templates : server -> ResourceTemplate.t list
val prompts : server -> Prompt.t list

(** Create a new server *)
val create_server : name:string -> ?version:string -> ?protocol_version:string -> unit -> server

(** Default capabilities for the server *)
val default_capabilities : ?with_tools:bool -> ?with_resources:bool -> ?with_resource_templates:bool -> ?with_prompts:bool -> unit -> Json.t

(** Create and register a tool in one step *)
val add_tool : server -> name:string -> ?description:string -> ?schema_properties:(string * string * string) list -> ?schema_required:string list -> (Json.t -> Json.t) -> Tool.t

(** Create and register a resource in one step *)
val add_resource : server -> uri:string -> name:string -> ?description:string -> ?mime_type:string -> (string list -> string) -> Resource.t

(** Create and register a resource template in one step *)
val add_resource_template : server -> uri_template:string -> name:string -> ?description:string -> ?mime_type:string -> (string list -> string) -> ResourceTemplate.t

(** Create and register a prompt in one step *)
val add_prompt : server -> name:string -> ?description:string -> ?arguments:(string * string option * bool) list -> ((string * string) list -> Prompt.message list) -> Prompt.t

(** Configure server with default capabilities based on registered components *)
val configure_server : server -> ?with_tools:bool -> ?with_resources:bool -> ?with_resource_templates:bool -> ?with_prompts:bool -> unit -> server

val make_tool_schema : (string * string * string) list -> string list -> Json.t