commit 4d7982df4f1d1c336f4a8868f22af78e74c44e3d · anil.recoil.org/ocaml-mcp

+18 -18

lib/mcp.ml

···

       559
       559
        
       

     

       560
       560
        
       module JSONRPCMessage = struct

     

       561
       561
        
         type notification = {

     

       562
       562
       -
           method_: Method.t;

     

       562
       562
       +
           meth: Method.t;

     

       563
       563
        
           params: Json.t option;

     

       564
       564
        
         }

     

       565
       565
        
       

     

       566
       566
        
         type request = {

     

       567
       567
        
           id: RequestId.t;

     

       568
       568
       -
           method_: Method.t;

     

       568
       568
       +
           meth: Method.t;

     

       569
       569
        
           params: Json.t option;

     

       570
       570
        
           progress_token: ProgressToken.t option;

     

       571
       571
        
         }

     
···

       591
       591
        
         let yojson_of_notification (n: notification) =

     

       592
       592
        
           let assoc = [

     

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

     

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

     

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

     

       595
       595
        
           ] in

     

       596
       596
        
           let assoc = match n.params with

     

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

     
···

       603
       603
        
           let assoc = [

     

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

     

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

     

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

     

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

     

       607
       607
        
           ] in

     

       608
       608
        
           let assoc = match r.params with

     

       609
       609
        
             | Some params ->

     
···

       653
       653
        
       

     

       654
       654
        
         let notification_of_yojson = function

     

       655
       655
        
           | `Assoc fields ->

     

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

     

       656
       656
       +
             let meth = match List.assoc_opt "method" fields with

     

       657
       657
        
               | Some (`String s) -> 

     

       658
       658
        
                   (try Method.of_string s

     

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

     

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

     

       661
       661
        
             in

     

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

     

       663
       663
       -
             { method_; params }

     

       663
       663
       +
             { meth; params }

     

       664
       664
        
           | j -> raise (Json.Of_json ("Expected object for notification", j))

     

       665
       665
        
       

     

       666
       666
        
         let request_of_yojson = function

     
···

       669
       669
        
               | Some id_json -> Id.t_of_yojson id_json

     

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

     

       671
       671
        
             in

     

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

     

       672
       672
       +
             let meth = match List.assoc_opt "method" fields with

     

       673
       673
        
               | Some (`String s) -> 

     

       674
       674
        
                   (try Method.of_string s

     

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

     
···

       687
       687
        
                  | _ -> None)

     

       688
       688
        
               | _ -> None

     

       689
       689
        
             in

     

       690
       690
       -
             { id; method_; params; progress_token }

     

       690
       690
       +
             { id; meth; params; progress_token }

     

       691
       691
        
           | j -> raise (Json.Of_json ("Expected object for request", j))

     

       692
       692
        
       

     

       693
       693
        
         let response_of_yojson = function

     
···

       745
       745
        
               raise (Json.Of_json ("Invalid JSONRPC message format", json))

     

       746
       746
        
           | j -> raise (Json.Of_json ("Expected object for JSONRPC message", j))

     

       747
       747
        
       

     

       748
       748
       -
         let create_notification ?(params=None) ~method_ () =

     

       749
       749
       -
           Notification { method_; params }

     

       748
       748
       +
         let create_notification ?(params=None) ~meth () =

     

       749
       749
       +
           Notification { meth; params }

     

       750
       750
        
       

     

       751
       751
       -
         let create_request ?(params=None) ?(progress_token=None) ~id ~method_ () =

     

       752
       752
       -
           Request { id; method_; params; progress_token }

     

       751
       751
       +
         let create_request ?(params=None) ?(progress_token=None) ~id ~meth () =

     

       752
       752
       +
           Request { id; meth; params; progress_token }

     

       753
       753
        
       

     

       754
       754
        
         let create_response ~id ~result =

     

       755
       755
        
           Response { id; result }

     
···

       797
       797
        
       

     

       798
       798
        
           let to_jsonrpc ~id t =

     

       799
       799
        
             let params = yojson_of_t t in

     

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

     

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

     

       801
       801
        
         end

     

       802
       802
        
       

     

       803
       803
        
         module Result = struct

     
···

       882
       882
        
               | `Assoc [] -> None

     

       883
       883
        
               | json -> Some json

     

       884
       884
        
             in

     

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

     

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

     

       886
       886
        
         end

     

       887
       887
        
       end

     

       888
       888
        
       

     
···

       892
       892
        
       let parse_message json =

     

       893
       893
        
         JSONRPCMessage.t_of_yojson json

     

       894
       894
        
       

     

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

     

       896
       896
       -
         JSONRPCMessage.create_notification ~params ~method_ ()

     

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

     

       896
       896
       +
         JSONRPCMessage.create_notification ~params ~meth ()

     

       897
       897
        
       

     

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

     

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

     

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

     

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

     

       900
       900
        
       

     

       901
       901
        
       let create_response = JSONRPCMessage.create_response

     

       902
       902
        
       let create_error = JSONRPCMessage.create_error

+11 -11

lib/mcp.mli

···

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

     

       80
       80
        
         

     

       81
       81
        
         (** Convert method type to string representation

     

       82
       82
       -
             @param method_ The method to convert

     

       82
       82
       +
             @param meth The method to convert

     

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

     

       84
       84
        
         *)

     

       85
       85
        
         val to_string : t -> string

     
···

       515
       515
        
             v}

     

       516
       516
        
         *)

     

       517
       517
        
         type notification = {

     

       518
       518
       -
           method_: Method.t;

     

       518
       518
       +
           meth: Method.t;

     

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

     

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

     

       521
       521
        
           params: Json.t option;

     
···

       548
       548
        
           id: RequestId.t;

     

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

     

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

     

       551
       551
       -
           method_: Method.t;

     

       551
       551
       +
           meth: Method.t;

     

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

     

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

     

       554
       554
        
           params: Json.t option;

     
···

       714
       714
        
       

     

       715
       715
        
         (** Create a new notification message

     

       716
       716
        
             @param params Optional parameters for the notification

     

       717
       717
       -
             @param method_ Method name for the notification

     

       717
       717
       +
             @param meth Method name for the notification

     

       718
       718
        
             @return A new JSON-RPC notification message

     

       719
       719
        
         *)

     

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

     

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

     

       721
       721
        
         

     

       722
       722
        
         (** Create a new request message

     

       723
       723
        
             @param params Optional parameters for the request

     

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

     

       725
       725
        
             @param id Unique identifier for the request

     

       726
       726
       -
             @param method_ Method name for the request

     

       726
       726
       +
             @param meth Method name for the request

     

       727
       727
        
             @return A new JSON-RPC request message

     

       728
       728
        
         *)

     

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

     

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

     

       730
       730
        
         

     

       731
       731
        
         (** Create a new response message

     

       732
       732
        
             @param id ID matching the original request

     
···

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

     

       915
       915
        
           

     

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

     

       917
       917
       -
           @param method_ Method type for the notification

     

       917
       917
       +
           @param meth Method type for the notification

     

       918
       918
        
           @return A new JSON-RPC notification message

     

       919
       919
        
       *)

     

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

     

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

     

       921
       921
        
       

     

       922
       922
        
       (** Create a new request message

     

       923
       923
        
           

     
···

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

     

       938
       938
        
                  that can report progress updates

     

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

     

       940
       940
       -
           @param method_ Method type for the request

     

       940
       940
       +
           @param meth Method type for the request

     

       941
       941
        
           @return A new JSON-RPC request message

     

       942
       942
        
       *)

     

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

     

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

     

       944
       944
        
       

     

       945
       945
        
       (** Create a new response message

     

       946
       946

+11 -11

lib/mcp_message.ml

···

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

     

       116
       116
        
           in

     

       117
       117
        
           let params = Request.yojson_of_t { cursor } in

     

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

     

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

     

       119
       119
        
         

     

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

     

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

     
···

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

     

       196
       196
        
           in

     

       197
       197
        
           let params = Request.yojson_of_t { uri } in

     

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

     

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

     

       199
       199
        
         

     

       200
       200
        
         let create_response ~id ~contents () =

     

       201
       201
        
           let result = Response.yojson_of_t { contents } in

     
···

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

     

       304
       304
        
           in

     

       305
       305
        
           let params = Request.yojson_of_t { cursor } in

     

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

     

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

     

       307
       307
        
         

     

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

     

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

     
···

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

     

       400
       400
        
           in

     

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

     

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

     

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

     

       403
       403
        
         

     

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

     

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

     
···

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

     

       547
       547
        
           in

     

       548
       548
        
           let params = Request.yojson_of_t { cursor } in

     

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

     

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

     

       550
       550
        
         

     

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

     

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

     
···

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

     

       627
       627
        
           in

     

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

     

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

     

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

     

       630
       630
        
         

     

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

     

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

     
···

       638
       638
        
         (* No parameters for these notifications *)

     

       639
       639
        
         

     

       640
       640
        
         let create_resources_notification () =

     

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

     

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

     

       642
       642
        
         

     

       643
       643
        
         let create_tools_notification () =

     

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

     

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

     

       645
       645
        
         

     

       646
       646
        
         let create_prompts_notification () =

     

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

     

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

     

       648
       648
        
       end

     

       649
       649
        
       

     

       650
       650
        
       (* Resource Updated Notification *)

     
···

       672
       672
        
         

     

       673
       673
        
         let create_notification ~uri () =

     

       674
       674
        
           let params = Notification.yojson_of_t { uri } in

     

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

     

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

     

       676
       676
        
       end

     

       677
       677
        
       

     

       678
       678
        
       (* Progress Notification *)

     
···

       712
       712
        
         

     

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

     

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

     

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

     

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

     

       716
       716
        
       end

     

       717
       717
        
       

     

       718
       718
        
       (* Type aliases for backward compatibility *)

+1 -1

lib/mcp_sdk.ml

···

       46
       46
        
               ("total", `Float total);

     

       47
       47
        
               ("progressToken", ProgressToken.yojson_of_t token)

     

       48
       48
        
             ] in

     

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

     

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

     

       50
       50
        
           | _ -> None

     

       51
       51
        
       end

     

       52
       52

+7 -7

lib/mcp_server.ml

···

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

     

       163
       163
        
           match JSONRPCMessage.t_of_yojson message with

     

       164
       164
        
           | JSONRPCMessage.Request req ->

     

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

     

       166
       166
       -
             (match req.method_ with

     

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

     

       166
       166
       +
             (match req.meth with

     

       167
       167
        
              | Method.Initialize -> handle_initialize server req

     

       168
       168
        
              | Method.ToolsList -> handle_tools_list server req

     

       169
       169
        
              | Method.ToolsCall -> handle_tools_call server req

     

       170
       170
        
              | Method.PromptsList -> handle_prompts_list server req

     

       171
       171
        
              | Method.ResourcesList -> handle_resources_list server req

     

       172
       172
        
              | _ -> 

     

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

     

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

     

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

     

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

     

       175
       175
        
           | JSONRPCMessage.Notification notif ->

     

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

     

       177
       177
       -
             (match notif.method_ with

     

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

     

       177
       177
       +
             (match notif.meth with

     

       178
       178
        
              | Method.Initialized -> handle_initialized notif

     

       179
       179
        
              | _ ->

     

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

     

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

     

       181
       181
        
                 None)

     

       182
       182
        
           | JSONRPCMessage.Response _ ->

     

       183
       183
        
             Log.error "Unexpected response message received";