commit f5aab64409224dd2a7fe85e0f4c2906c3bac6422 · anil.recoil.org/ocaml-mcp

+80 -33

lib/mcp.ml

···

       35
        
           | CustomError _ -> "Error"

     

       36
        
       end

     

       37
        
       

     

       38
       -
       (* Protocol method strings *)

     

       39
        
       module Method = struct

     

       40
       -
         (* Initialization and lifecycle methods *)

     

       41
       -
         let initialize = "initialize"

     

       42
       -
         let initialized = "notifications/initialized"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       43
        
         

     

       44
       -
         (* Resource methods *)

     

       45
       -
         let resources_list = "resources/list"

     

       46
       -
         let resources_read = "resources/read"

     

       47
       -
         let resources_templates_list = "resources/templates/list"

     

       48
       -
         let resources_subscribe = "resources/subscribe"

     

       49
       -
         let resources_list_changed = "notifications/resources/list_changed"

     

       50
       -
         let resources_updated = "notifications/resources/updated"

     

       51
       -
         

     

       52
       -
         (* Tool methods *)

     

       53
       -
         let tools_list = "tools/list"

     

       54
       -
         let tools_call = "tools/call"

     

       55
       -
         let tools_list_changed = "notifications/tools/list_changed"

     

       56
       -
         

     

       57
       -
         (* Prompt methods *)

     

       58
       -
         let prompts_list = "prompts/list"

     

       59
       -
         let prompts_get = "prompts/get"

     

       60
       -
         let prompts_list_changed = "notifications/prompts/list_changed"

     

       61
        
         

     

       62
       -
         (* Progress notifications *)

     

       63
       -
         let progress = "notifications/progress"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       64
        
       end

     

       65
        
       

     

       66
        
       (* Common types *)

     
···

       520
        
       

     

       521
        
       module JSONRPCMessage = struct

     

       522
        
         type notification = {

     

       523
       -
           method_: string;

     

       524
        
           params: Json.t option;

     

       525
        
         }

     

       526
        
       

     

       527
        
         type request = {

     

       528
        
           id: RequestId.t;

     

       529
       -
           method_: string;

     

       530
        
           params: Json.t option;

     

       531
        
           progress_token: ProgressToken.t option;

     

       532
        
         }

     
···

       552
        
         let yojson_of_notification (n: notification) =

     

       553
        
           let assoc = [

     

       554
        
             ("jsonrpc", `String "2.0");

     

       555
       -
             ("method", `String n.method_);

     

       556
        
           ] in

     

       557
        
           let assoc = match n.params with

     

       558
        
             | Some params -> ("params", params) :: assoc

     
···

       564
        
           let assoc = [

     

       565
        
             ("jsonrpc", `String "2.0");

     

       566
        
             ("id", Id.yojson_of_t r.id);

     

       567
       -
             ("method", `String r.method_);

     

       568
        
           ] in

     

       569
        
           let assoc = match r.params with

     

       570
        
             | Some params ->

     
···

       615
        
         let notification_of_yojson = function

     

       616
        
           | `Assoc fields ->

     

       617
        
             let method_ = match List.assoc_opt "method" fields with

     

       618
       -
               | Some (`String s) -> s

     

       0
        
       
     

       0
        
       
     

       619
        
               | _ -> raise (Json.Of_json ("Missing or invalid 'method' field", `Assoc fields))

     

       620
        
             in

     

       621
        
             let params = List.assoc_opt "params" fields in

     
···

       629
        
               | _ -> raise (Json.Of_json ("Missing or invalid 'id' field", `Assoc fields))

     

       630
        
             in

     

       631
        
             let method_ = match List.assoc_opt "method" fields with

     

       632
       -
               | Some (`String s) -> s

     

       0
        
       
     

       0
        
       
     

       633
        
               | _ -> raise (Json.Of_json ("Missing or invalid 'method' field", `Assoc fields))

     

       634
        
             in

     

       635
        
             let params = List.assoc_opt "params" fields in

     
···

       754
        
       

     

       755
        
           let to_jsonrpc ~id t =

     

       756
        
             let params = yojson_of_t t in

     

       757
       -
             JSONRPCMessage.create_request ~id ~method_:"initialize" ~params:(Some params) ()

     

       758
        
         end

     

       759
        
       

     

       760
        
         module Result = struct

     
···

       839
        
               | `Assoc [] -> None

     

       840
        
               | json -> Some json

     

       841
        
             in

     

       842
       -
             JSONRPCMessage.create_notification ~method_:"notifications/initialized" ~params ()

     

       843
        
         end

     

       844
        
       end

     

       845
        
       

     
···

       849
        
       let parse_message json =

     

       850
        
         JSONRPCMessage.t_of_yojson json

     

       851
        
       

     

       852
       -
       let create_notification = JSONRPCMessage.create_notification

     

       853
       -
       let create_request = JSONRPCMessage.create_request

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       854
        
       let create_response = JSONRPCMessage.create_response

     

       855
        
       let create_error = JSONRPCMessage.create_error

     

       856

···

       35
        
           | CustomError _ -> "Error"

     

       36
        
       end

     

       37
        
       

     

       38
       +
       (* Protocol method types *)

     

       39
        
       module Method = struct

     

       40
       +
         (* Method type representing all MCP protocol methods *)

     

       41
       +
         type t =

     

       42
       +
           (* Initialization and lifecycle methods *)

     

       43
       +
           | Initialize

     

       44
       +
           | Initialized

     

       45
       +
           

     

       46
       +
           (* Resource methods *)

     

       47
       +
           | ResourcesList

     

       48
       +
           | ResourcesRead

     

       49
       +
           | ResourcesTemplatesList

     

       50
       +
           | ResourcesSubscribe

     

       51
       +
           | ResourcesListChanged

     

       52
       +
           | ResourcesUpdated

     

       53
       +
           

     

       54
       +
           (* Tool methods *)

     

       55
       +
           | ToolsList

     

       56
       +
           | ToolsCall

     

       57
       +
           | ToolsListChanged

     

       58
       +
           

     

       59
       +
           (* Prompt methods *)

     

       60
       +
           | PromptsList

     

       61
       +
           | PromptsGet

     

       62
       +
           | PromptsListChanged

     

       63
       +
           

     

       64
       +
           (* Progress notifications *)

     

       65
       +
           | Progress

     

       66
        
         

     

       67
       +
         (* Convert method type to string representation *)

     

       68
       +
         let to_string = function

     

       69
       +
           | Initialize -> "initialize"

     

       70
       +
           | Initialized -> "notifications/initialized"

     

       71
       +
           | ResourcesList -> "resources/list"

     

       72
       +
           | ResourcesRead -> "resources/read"

     

       73
       +
           | ResourcesTemplatesList -> "resources/templates/list"

     

       74
       +
           | ResourcesSubscribe -> "resources/subscribe"

     

       75
       +
           | ResourcesListChanged -> "notifications/resources/list_changed"

     

       76
       +
           | ResourcesUpdated -> "notifications/resources/updated"

     

       77
       +
           | ToolsList -> "tools/list"

     

       78
       +
           | ToolsCall -> "tools/call"

     

       79
       +
           | ToolsListChanged -> "notifications/tools/list_changed"

     

       80
       +
           | PromptsList -> "prompts/list"

     

       81
       +
           | PromptsGet -> "prompts/get"

     

       82
       +
           | PromptsListChanged -> "notifications/prompts/list_changed"

     

       83
       +
           | Progress -> "notifications/progress"

     

       84
        
         

     

       85
       +
         (* Convert string to method type *)

     

       86
       +
         let of_string = function

     

       87
       +
           | "initialize" -> Initialize

     

       88
       +
           | "notifications/initialized" -> Initialized

     

       89
       +
           | "resources/list" -> ResourcesList

     

       90
       +
           | "resources/read" -> ResourcesRead

     

       91
       +
           | "resources/templates/list" -> ResourcesTemplatesList

     

       92
       +
           | "resources/subscribe" -> ResourcesSubscribe

     

       93
       +
           | "notifications/resources/list_changed" -> ResourcesListChanged

     

       94
       +
           | "notifications/resources/updated" -> ResourcesUpdated

     

       95
       +
           | "tools/list" -> ToolsList

     

       96
       +
           | "tools/call" -> ToolsCall

     

       97
       +
           | "notifications/tools/list_changed" -> ToolsListChanged

     

       98
       +
           | "prompts/list" -> PromptsList

     

       99
       +
           | "prompts/get" -> PromptsGet

     

       100
       +
           | "notifications/prompts/list_changed" -> PromptsListChanged

     

       101
       +
           | "notifications/progress" -> Progress

     

       102
       +
           | s -> failwith ("Unknown MCP method: " ^ s)

     

       103
        
       end

     

       104
        
       

     

       105
        
       (* Common types *)

     
···

       559
        
       

     

       560
        
       module JSONRPCMessage = struct

     

       561
        
         type notification = {

     

       562
       +
           method_: Method.t;

     

       563
        
           params: Json.t option;

     

       564
        
         }

     

       565
        
       

     

       566
        
         type request = {

     

       567
        
           id: RequestId.t;

     

       568
       +
           method_: Method.t;

     

       569
        
           params: Json.t option;

     

       570
        
           progress_token: ProgressToken.t option;

     

       571
        
         }

     
···

       591
        
         let yojson_of_notification (n: notification) =

     

       592
        
           let assoc = [

     

       593
        
             ("jsonrpc", `String "2.0");

     

       594
       +
             ("method", `String (Method.to_string n.method_));

     

       595
        
           ] in

     

       596
        
           let assoc = match n.params with

     

       597
        
             | Some params -> ("params", params) :: assoc

     
···

       603
        
           let assoc = [

     

       604
        
             ("jsonrpc", `String "2.0");

     

       605
        
             ("id", Id.yojson_of_t r.id);

     

       606
       +
             ("method", `String (Method.to_string r.method_));

     

       607
        
           ] in

     

       608
        
           let assoc = match r.params with

     

       609
        
             | Some params ->

     
···

       654
        
         let notification_of_yojson = function

     

       655
        
           | `Assoc fields ->

     

       656
        
             let method_ = match List.assoc_opt "method" fields with

     

       657
       +
               | Some (`String s) -> 

     

       658
       +
                   (try Method.of_string s

     

       659
       +
                    with Failure msg -> raise (Json.Of_json (msg, `String s)))

     

       660
        
               | _ -> raise (Json.Of_json ("Missing or invalid 'method' field", `Assoc fields))

     

       661
        
             in

     

       662
        
             let params = List.assoc_opt "params" fields in

     
···

       670
        
               | _ -> raise (Json.Of_json ("Missing or invalid 'id' field", `Assoc fields))

     

       671
        
             in

     

       672
        
             let method_ = match List.assoc_opt "method" fields with

     

       673
       +
               | Some (`String s) -> 

     

       674
       +
                   (try Method.of_string s

     

       675
       +
                    with Failure msg -> raise (Json.Of_json (msg, `String s)))

     

       676
        
               | _ -> raise (Json.Of_json ("Missing or invalid 'method' field", `Assoc fields))

     

       677
        
             in

     

       678
        
             let params = List.assoc_opt "params" fields in

     
···

       797
        
       

     

       798
        
           let to_jsonrpc ~id t =

     

       799
        
             let params = yojson_of_t t in

     

       800
       +
             JSONRPCMessage.create_request ~id ~method_:Method.Initialize ~params:(Some params) ()

     

       801
        
         end

     

       802
        
       

     

       803
        
         module Result = struct

     
···

       882
        
               | `Assoc [] -> None

     

       883
        
               | json -> Some json

     

       884
        
             in

     

       885
       +
             JSONRPCMessage.create_notification ~method_:Method.Initialized ~params ()

     

       886
        
         end

     

       887
        
       end

     

       888
        
       

     
···

       892
        
       let parse_message json =

     

       893
        
         JSONRPCMessage.t_of_yojson json

     

       894
        
       

     

       895
       +
       let create_notification ?(params=None) ~method_ () =

     

       896
       +
         JSONRPCMessage.create_notification ~params ~method_ ()

     

       897
       +
       

     

       898
       +
       let create_request ?(params=None) ?(progress_token=None) ~id ~method_ () =

     

       899
       +
         JSONRPCMessage.create_request ~params ~progress_token ~id ~method_ ()

     

       900
       +
       

     

       901
        
       let create_response = JSONRPCMessage.create_response

     

       902
        
       let create_error = JSONRPCMessage.create_error

     

       903

+50 -50

lib/mcp.mli

···

       49
        
         val to_message : t -> string

     

       50
        
       end

     

       51
        
       

     

       52
       -
       (** MCP Protocol Methods - Standard method names used in JSON-RPC messages *)

     

       53
        
       module Method : sig

     

       54
       -
         (** Standard protocol methods used in MCP JSON-RPC messages *)

     

       55
       -
         

     

       56
       -
         val initialize : string  (** "initialize" - Start the MCP lifecycle *)

     

       57
       -
         

     

       58
       -
         val initialized : string (** "notifications/initialized" - Signal readiness after initialization *)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       59
        
         

     

       60
       -
         val resources_list : string (** "resources/list" - Discover available resources *)

     

       61
       -
       

     

       62
       -
         val resources_read : string (** "resources/read" - Retrieve resource contents *)

     

       63
       -
       

     

       64
       -
         val resources_templates_list : string (** "resources/templates/list" - List available resource templates *)

     

       65
       -
       

     

       66
       -
         val resources_subscribe : string (** "resources/subscribe" - Subscribe to resource changes *)

     

       67
       -
       

     

       68
       -
         val resources_list_changed : string (** "notifications/resources/list_changed" - Resource list has changed *)

     

       69
       -
       

     

       70
       -
         val resources_updated : string (** "notifications/resources/updated" - Resource has been updated *)

     

       71
       -
       

     

       72
       -
         val tools_list : string (** "tools/list" - Discover available tools *)

     

       73
       -
       

     

       74
       -
         val tools_call : string (** "tools/call" - Invoke a tool *)

     

       75
       -
       

     

       76
       -
         val tools_list_changed : string (** "notifications/tools/list_changed" - Tool list has changed *)

     

       77
       -
       

     

       78
       -
         val prompts_list : string (** "prompts/list" - Discover available prompts *)

     

       79
       -
       

     

       80
       -
         val prompts_get : string (** "prompts/get" - Retrieve a prompt template with arguments *)

     

       81
       -
       

     

       82
       -
         val prompts_list_changed : string (** "notifications/prompts/list_changed" - Prompt list has changed *)

     

       83
        
         

     

       84
       -
         val progress : string (** "notifications/progress" - Progress update for long-running operations *)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       85
        
       end

     

       86
        
       

     

       87
        
       

     
···

       507
        
             v}

     

       508
        
         *)

     

       509
        
         type notification = {

     

       510
       -
           method_: string;

     

       511
       -
           (** Method name for the notification, following the MCP naming conventions.

     

       512
       -
               Common method patterns include:

     

       513
       -
               - "notifications/X" for standard notifications

     

       514
       -
               - "notifications/X/Y" for more specific notifications

     

       515
       -
               

     

       516
       -
               Examples: "notifications/initialized", "notifications/resources/updated" *)

     

       517
        
           params: Json.t option;

     

       518
        
           (** Optional parameters for the notification as arbitrary JSON.

     

       519
        
               The structure depends on the specific notification method. *)

     
···

       544
        
           id: RequestId.t;

     

       545
        
           (** Unique identifier for the request, which will be echoed in the response.

     

       546
        
               This can be a string or integer and should be unique within the session. *)

     

       547
       -
           method_: string;

     

       548
       -
           (** Method name for the request, following the MCP naming conventions.

     

       549
       -
               Common method patterns include:

     

       550
       -
               - "X/Y" for standard operations

     

       551
       -
               - "X/Y/Z" for more specific operations

     

       552
       -
               

     

       553
       -
               Examples: "initialize", "resources/read", "tools/call", "prompts/get" *)

     

       554
        
           params: Json.t option;

     

       555
        
           (** Optional parameters for the request as arbitrary JSON.

     

       556
        
               The structure depends on the specific request method. *)

     
···

       717
        
             @param method_ Method name for the notification

     

       718
        
             @return A new JSON-RPC notification message

     

       719
        
         *)

     

       720
       -
         val create_notification : ?params:Json.t option -> method_:string -> unit -> t

     

       721
        
         

     

       722
        
         (** Create a new request message

     

       723
        
             @param params Optional parameters for the request

     
···

       726
        
             @param method_ Method name for the request

     

       727
        
             @return A new JSON-RPC request message

     

       728
        
         *)

     

       729
       -
         val create_request : ?params:Json.t option -> ?progress_token:ProgressToken.t option -> id:RequestId.t -> method_:string -> unit -> t

     

       730
        
         

     

       731
        
         (** Create a new response message

     

       732
        
             @param id ID matching the original request

     
···

       914
        
           - "notifications/tools/list_changed" - Available tools changed

     

       915
        
           

     

       916
        
           @param params Optional parameters for the notification as a JSON value

     

       917
       -
           @param method_ Method name for the notification, typically following MCP naming conventions

     

       918
        
           @return A new JSON-RPC notification message

     

       919
        
       *)

     

       920
       -
       val create_notification : ?params:Json.t option -> method_:string -> unit -> JSONRPCMessage.t

     

       921
        
       

     

       922
        
       (** Create a new request message

     

       923
        
           

     
···

       937
        
           @param progress_token Optional progress token for long-running operations

     

       938
        
                  that can report progress updates

     

       939
        
           @param id Unique identifier for the request, used to correlate with the response

     

       940
       -
           @param method_ Method name for the request, following MCP naming conventions

     

       941
        
           @return A new JSON-RPC request message

     

       942
        
       *)

     

       943
       -
       val create_request : ?params:Json.t option -> ?progress_token:ProgressToken.t option -> id:RequestId.t -> method_:string -> unit -> JSONRPCMessage.t

     

       944
        
       

     

       945
        
       (** Create a new response message

     

       946

···

       49
        
         val to_message : t -> string

     

       50
        
       end

     

       51
        
       

     

       52
       +
       (** MCP Protocol Methods - Algebraic data type representing all MCP methods *)

     

       53
        
       module Method : sig

     

       54
       +
         (** Method type representing all MCP protocol methods *)

     

       55
       +
         type t =

     

       56
       +
           (* Initialization and lifecycle methods *)

     

       57
       +
           | Initialize      (** Start the MCP lifecycle *)

     

       58
       +
           | Initialized     (** Signal readiness after initialization *)

     

       59
       +
           

     

       60
       +
           (* Resource methods *)

     

       61
       +
           | ResourcesList           (** Discover available resources *)

     

       62
       +
           | ResourcesRead           (** Retrieve resource contents *)

     

       63
       +
           | ResourcesTemplatesList  (** List available resource templates *)

     

       64
       +
           | ResourcesSubscribe      (** Subscribe to resource changes *)

     

       65
       +
           | ResourcesListChanged    (** Resource list has changed *)

     

       66
       +
           | ResourcesUpdated        (** Resource has been updated *)

     

       67
       +
           

     

       68
       +
           (* Tool methods *)

     

       69
       +
           | ToolsList        (** Discover available tools *)

     

       70
       +
           | ToolsCall        (** Invoke a tool *)

     

       71
       +
           | ToolsListChanged (** Tool list has changed *)

     

       72
       +
           

     

       73
       +
           (* Prompt methods *)

     

       74
       +
           | PromptsList        (** Discover available prompts *)

     

       75
       +
           | PromptsGet         (** Retrieve a prompt template with arguments *)

     

       76
       +
           | PromptsListChanged (** Prompt list has changed *)

     

       77
       +
           

     

       78
       +
           (* Progress notifications *)

     

       79
       +
           | Progress         (** Progress update for long-running operations *)

     

       80
        
         

     

       81
       +
         (** Convert method type to string representation

     

       82
       +
             @param method_ The method to convert

     

       83
       +
             @return The string representation of the method (e.g., "initialize", "resources/list")

     

       84
       +
         *)

     

       85
       +
         val to_string : t -> string

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       86
        
         

     

       87
       +
         (** Convert string to method type

     

       88
       +
             @param s The string representation of the method

     

       89
       +
             @return The corresponding method type

     

       90
       +
             @raise Failure if the string is not a valid MCP method

     

       91
       +
         *)

     

       92
       +
         val of_string : string -> t

     

       93
        
       end

     

       94
        
       

     

       95
        
       

     
···

       515
        
             v}

     

       516
        
         *)

     

       517
        
         type notification = {

     

       518
       +
           method_: Method.t;

     

       519
       +
           (** Method for the notification, using the Method.t type to ensure type safety.

     

       520
       +
               Examples: Method.Initialized, Method.ResourcesUpdated *)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       521
        
           params: Json.t option;

     

       522
        
           (** Optional parameters for the notification as arbitrary JSON.

     

       523
        
               The structure depends on the specific notification method. *)

     
···

       548
        
           id: RequestId.t;

     

       549
        
           (** Unique identifier for the request, which will be echoed in the response.

     

       550
        
               This can be a string or integer and should be unique within the session. *)

     

       551
       +
           method_: Method.t;

     

       552
       +
           (** Method for the request, using the Method.t type to ensure type safety.

     

       553
       +
               Examples: Method.Initialize, Method.ResourcesRead, Method.ToolsCall *)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       554
        
           params: Json.t option;

     

       555
        
           (** Optional parameters for the request as arbitrary JSON.

     

       556
        
               The structure depends on the specific request method. *)

     
···

       717
        
             @param method_ Method name for the notification

     

       718
        
             @return A new JSON-RPC notification message

     

       719
        
         *)

     

       720
       +
         val create_notification : ?params:Json.t option -> method_:Method.t -> unit -> t

     

       721
        
         

     

       722
        
         (** Create a new request message

     

       723
        
             @param params Optional parameters for the request

     
···

       726
        
             @param method_ Method name for the request

     

       727
        
             @return A new JSON-RPC request message

     

       728
        
         *)

     

       729
       +
         val create_request : ?params:Json.t option -> ?progress_token:ProgressToken.t option -> id:RequestId.t -> method_:Method.t -> unit -> t

     

       730
        
         

     

       731
        
         (** Create a new response message

     

       732
        
             @param id ID matching the original request

     
···

       914
        
           - "notifications/tools/list_changed" - Available tools changed

     

       915
        
           

     

       916
        
           @param params Optional parameters for the notification as a JSON value

     

       917
       +
           @param method_ Method type for the notification

     

       918
        
           @return A new JSON-RPC notification message

     

       919
        
       *)

     

       920
       +
       val create_notification : ?params:Json.t option -> method_:Method.t -> unit -> JSONRPCMessage.t

     

       921
        
       

     

       922
        
       (** Create a new request message

     

       923
        
           

     
···

       937
        
           @param progress_token Optional progress token for long-running operations

     

       938
        
                  that can report progress updates

     

       939
        
           @param id Unique identifier for the request, used to correlate with the response

     

       940
       +
           @param method_ Method type for the request

     

       941
        
           @return A new JSON-RPC request message

     

       942
        
       *)

     

       943
       +
       val create_request : ?params:Json.t option -> ?progress_token:ProgressToken.t option -> id:RequestId.t -> method_:Method.t -> unit -> JSONRPCMessage.t

     

       944
        
       

     

       945
        
       (** Create a new response message

     

       946

+11 -11

lib/mcp_message.ml

···

       115
        
             | None -> `Int (Random.int 10000)

     

       116
        
           in

     

       117
        
           let params = Request.yojson_of_t { cursor } in

     

       118
       -
           JSONRPCMessage.create_request ~id ~method_:Method.resources_list ~params:(Some params) ()

     

       119
        
         

     

       120
        
         let create_response ~id ~resources ?next_cursor () =

     

       121
        
           let result = Response.yojson_of_t { resources; next_cursor } in

     
···

       195
        
             | None -> `Int (Random.int 10000)

     

       196
        
           in

     

       197
        
           let params = Request.yojson_of_t { uri } in

     

       198
       -
           JSONRPCMessage.create_request ~id ~method_:Method.resources_read ~params:(Some params) ()

     

       199
        
         

     

       200
        
         let create_response ~id ~contents () =

     

       201
        
           let result = Response.yojson_of_t { contents } in

     
···

       303
        
             | None -> `Int (Random.int 10000)

     

       304
        
           in

     

       305
        
           let params = Request.yojson_of_t { cursor } in

     

       306
       -
           JSONRPCMessage.create_request ~id ~method_:Method.tools_list ~params:(Some params) ()

     

       307
        
         

     

       308
        
         let create_response ~id ~tools ?next_cursor () =

     

       309
        
           let result = Response.yojson_of_t { tools; next_cursor } in

     
···

       399
        
             | None -> `Int (Random.int 10000)

     

       400
        
           in

     

       401
        
           let params = Request.yojson_of_t { name; arguments } in

     

       402
       -
           JSONRPCMessage.create_request ~id ~method_:Method.tools_call ~params:(Some params) ()

     

       403
        
         

     

       404
        
         let create_response ~id ~content ~is_error () =

     

       405
        
           let result = Response.yojson_of_t { content; is_error } in

     
···

       546
        
             | None -> `Int (Random.int 10000)

     

       547
        
           in

     

       548
        
           let params = Request.yojson_of_t { cursor } in

     

       549
       -
           JSONRPCMessage.create_request ~id ~method_:Method.prompts_list ~params:(Some params) ()

     

       550
        
         

     

       551
        
         let create_response ~id ~prompts ?next_cursor () =

     

       552
        
           let result = Response.yojson_of_t { prompts; next_cursor } in

     
···

       626
        
             | None -> `Int (Random.int 10000)

     

       627
        
           in

     

       628
        
           let params = Request.yojson_of_t { name; arguments } in

     

       629
       -
           JSONRPCMessage.create_request ~id ~method_:Method.prompts_get ~params:(Some params) ()

     

       630
        
         

     

       631
        
         let create_response ~id ?description ~messages () =

     

       632
        
           let result = Response.yojson_of_t { description; messages } in

     
···

       638
        
         (* No parameters for these notifications *)

     

       639
        
         

     

       640
        
         let create_resources_notification () =

     

       641
       -
           JSONRPCMessage.create_notification ~method_:Method.resources_list_changed ()

     

       642
        
         

     

       643
        
         let create_tools_notification () =

     

       644
       -
           JSONRPCMessage.create_notification ~method_:Method.tools_list_changed ()

     

       645
        
         

     

       646
        
         let create_prompts_notification () =

     

       647
       -
           JSONRPCMessage.create_notification ~method_:Method.prompts_list_changed ()

     

       648
        
       end

     

       649
        
       

     

       650
        
       (* Resource Updated Notification *)

     
···

       672
        
         

     

       673
        
         let create_notification ~uri () =

     

       674
        
           let params = Notification.yojson_of_t { uri } in

     

       675
       -
           JSONRPCMessage.create_notification ~method_:Method.resources_updated ~params:(Some params) ()

     

       676
        
       end

     

       677
        
       

     

       678
        
       (* Progress Notification *)

     
···

       712
        
         

     

       713
        
         let create_notification ~progress ~total ~progress_token () =

     

       714
        
           let params = Notification.yojson_of_t { progress; total; progress_token } in

     

       715
       -
           JSONRPCMessage.create_notification ~method_:Method.progress ~params:(Some params) ()

     

       716
        
       end

     

       717
        
       

     

       718
        
       (* Type aliases for backward compatibility *)

···

       115
        
             | None -> `Int (Random.int 10000)

     

       116
        
           in

     

       117
        
           let params = Request.yojson_of_t { cursor } in

     

       118
       +
           JSONRPCMessage.create_request ~id ~method_:Method.ResourcesList ~params:(Some params) ()

     

       119
        
         

     

       120
        
         let create_response ~id ~resources ?next_cursor () =

     

       121
        
           let result = Response.yojson_of_t { resources; next_cursor } in

     
···

       195
        
             | None -> `Int (Random.int 10000)

     

       196
        
           in

     

       197
        
           let params = Request.yojson_of_t { uri } in

     

       198
       +
           JSONRPCMessage.create_request ~id ~method_:Method.ResourcesRead ~params:(Some params) ()

     

       199
        
         

     

       200
        
         let create_response ~id ~contents () =

     

       201
        
           let result = Response.yojson_of_t { contents } in

     
···

       303
        
             | None -> `Int (Random.int 10000)

     

       304
        
           in

     

       305
        
           let params = Request.yojson_of_t { cursor } in

     

       306
       +
           JSONRPCMessage.create_request ~id ~method_:Method.ToolsList ~params:(Some params) ()

     

       307
        
         

     

       308
        
         let create_response ~id ~tools ?next_cursor () =

     

       309
        
           let result = Response.yojson_of_t { tools; next_cursor } in

     
···

       399
        
             | None -> `Int (Random.int 10000)

     

       400
        
           in

     

       401
        
           let params = Request.yojson_of_t { name; arguments } in

     

       402
       +
           JSONRPCMessage.create_request ~id ~method_:Method.ToolsCall ~params:(Some params) ()

     

       403
        
         

     

       404
        
         let create_response ~id ~content ~is_error () =

     

       405
        
           let result = Response.yojson_of_t { content; is_error } in

     
···

       546
        
             | None -> `Int (Random.int 10000)

     

       547
        
           in

     

       548
        
           let params = Request.yojson_of_t { cursor } in

     

       549
       +
           JSONRPCMessage.create_request ~id ~method_:Method.PromptsList ~params:(Some params) ()

     

       550
        
         

     

       551
        
         let create_response ~id ~prompts ?next_cursor () =

     

       552
        
           let result = Response.yojson_of_t { prompts; next_cursor } in

     
···

       626
        
             | None -> `Int (Random.int 10000)

     

       627
        
           in

     

       628
        
           let params = Request.yojson_of_t { name; arguments } in

     

       629
       +
           JSONRPCMessage.create_request ~id ~method_:Method.PromptsGet ~params:(Some params) ()

     

       630
        
         

     

       631
        
         let create_response ~id ?description ~messages () =

     

       632
        
           let result = Response.yojson_of_t { description; messages } in

     
···

       638
        
         (* No parameters for these notifications *)

     

       639
        
         

     

       640
        
         let create_resources_notification () =

     

       641
       +
           JSONRPCMessage.create_notification ~method_:Method.ResourcesListChanged ()

     

       642
        
         

     

       643
        
         let create_tools_notification () =

     

       644
       +
           JSONRPCMessage.create_notification ~method_:Method.ToolsListChanged ()

     

       645
        
         

     

       646
        
         let create_prompts_notification () =

     

       647
       +
           JSONRPCMessage.create_notification ~method_:Method.PromptsListChanged ()

     

       648
        
       end

     

       649
        
       

     

       650
        
       (* Resource Updated Notification *)

     
···

       672
        
         

     

       673
        
         let create_notification ~uri () =

     

       674
        
           let params = Notification.yojson_of_t { uri } in

     

       675
       +
           JSONRPCMessage.create_notification ~method_:Method.ResourcesUpdated ~params:(Some params) ()

     

       676
        
       end

     

       677
        
       

     

       678
        
       (* Progress Notification *)

     
···

       712
        
         

     

       713
        
         let create_notification ~progress ~total ~progress_token () =

     

       714
        
           let params = Notification.yojson_of_t { progress; total; progress_token } in

     

       715
       +
           JSONRPCMessage.create_notification ~method_:Method.Progress ~params:(Some params) ()

     

       716
        
       end

     

       717
        
       

     

       718
        
       (* Type aliases for backward compatibility *)

+1 -1

lib/mcp_sdk.ml

···

       46
        
               ("total", `Float total);

     

       47
        
               ("progressToken", ProgressToken.yojson_of_t token)

     

       48
        
             ] in

     

       49
       -
             Some (create_notification ~method_:"notifications/progress" ~params:(Some params) ())

     

       50
        
           | _ -> None

     

       51
        
       end

     

       52

···

       46
        
               ("total", `Float total);

     

       47
        
               ("progressToken", ProgressToken.yojson_of_t token)

     

       48
        
             ] in

     

       49
       +
             Some (create_notification ~method_:Method.Progress ~params:(Some params) ())

     

       50
        
           | _ -> None

     

       51
        
       end

     

       52

+11 -12

lib/mcp_server.ml

···

       162
        
           Log.debug (Printf.sprintf "Processing message: %s" (Yojson.Safe.to_string message));

     

       163
        
           match JSONRPCMessage.t_of_yojson message with

     

       164
        
           | JSONRPCMessage.Request req ->

     

       165
       -
             Log.debug (Printf.sprintf "Received request with method: %s" req.method_);

     

       166
        
             (match req.method_ with

     

       167
       -
              | "initialize" -> handle_initialize server req

     

       168
       -
              | "tools/list" -> handle_tools_list server req

     

       169
       -
              | "tools/call" -> handle_tools_call server req

     

       170
       -
              | "prompts/list" -> handle_prompts_list server req

     

       171
       -
              | "resources/list" -> handle_resources_list server req

     

       172
       -
              | "ping" -> handle_ping req

     

       173
        
              | _ -> 

     

       174
       -
                 Log.error (Printf.sprintf "Unknown method received: %s" req.method_);

     

       175
       -
                 Some (create_jsonrpc_error req.id MethodNotFound ("Method not found: " ^ req.method_) ()))

     

       176
        
           | JSONRPCMessage.Notification notif ->

     

       177
       -
             Log.debug (Printf.sprintf "Received notification with method: %s" notif.method_);

     

       178
        
             (match notif.method_ with

     

       179
       -
              | "notifications/initialized" -> handle_initialized notif

     

       180
        
              | _ ->

     

       181
       -
                 Log.debug (Printf.sprintf "Ignoring notification: %s" notif.method_);

     

       182
        
                 None)

     

       183
        
           | JSONRPCMessage.Response _ ->

     

       184
        
             Log.error "Unexpected response message received";

···

       162
        
           Log.debug (Printf.sprintf "Processing message: %s" (Yojson.Safe.to_string message));

     

       163
        
           match JSONRPCMessage.t_of_yojson message with

     

       164
        
           | JSONRPCMessage.Request req ->

     

       165
       +
             Log.debug (Printf.sprintf "Received request with method: %s" (Method.to_string req.method_));

     

       166
        
             (match req.method_ with

     

       167
       +
              | Method.Initialize -> handle_initialize server req

     

       168
       +
              | Method.ToolsList -> handle_tools_list server req

     

       169
       +
              | Method.ToolsCall -> handle_tools_call server req

     

       170
       +
              | Method.PromptsList -> handle_prompts_list server req

     

       171
       +
              | Method.ResourcesList -> handle_resources_list server req

     

       0
        
       
     

       172
        
              | _ -> 

     

       173
       +
                 Log.error (Printf.sprintf "Unknown method received: %s" (Method.to_string req.method_));

     

       174
       +
                 Some (create_jsonrpc_error req.id MethodNotFound ("Method not found: " ^ (Method.to_string req.method_)) ()))

     

       175
        
           | JSONRPCMessage.Notification notif ->

     

       176
       +
             Log.debug (Printf.sprintf "Received notification with method: %s" (Method.to_string notif.method_));

     

       177
        
             (match notif.method_ with

     

       178
       +
              | Method.Initialized -> handle_initialized notif

     

       179
        
              | _ ->

     

       180
       +
                 Log.debug (Printf.sprintf "Ignoring notification: %s" (Method.to_string notif.method_));

     

       181
        
                 None)

     

       182
        
           | JSONRPCMessage.Response _ ->

     

       183
        
             Log.error "Unexpected response message received";