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

+80 -33

lib/mcp.ml

···

       35
       35
        
           | CustomError _ -> "Error"

     

       36
       36
        
       end

     

       37
       37
        
       

     

       38
       38
       -
       (* Protocol method strings *)

     

       38
       38
       +
       (* Protocol method types *)

     

       39
       39
        
       module Method = struct

     

       40
       40
       -
         (* Initialization and lifecycle methods *)

     

       41
       41
       -
         let initialize = "initialize"

     

       42
       42
       -
         let initialized = "notifications/initialized"

     

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

     

       41
       41
       +
         type t =

     

       42
       42
       +
           (* Initialization and lifecycle methods *)

     

       43
       43
       +
           | Initialize

     

       44
       44
       +
           | Initialized

     

       45
       45
       +
           

     

       46
       46
       +
           (* Resource methods *)

     

       47
       47
       +
           | ResourcesList

     

       48
       48
       +
           | ResourcesRead

     

       49
       49
       +
           | ResourcesTemplatesList

     

       50
       50
       +
           | ResourcesSubscribe

     

       51
       51
       +
           | ResourcesListChanged

     

       52
       52
       +
           | ResourcesUpdated

     

       53
       53
       +
           

     

       54
       54
       +
           (* Tool methods *)

     

       55
       55
       +
           | ToolsList

     

       56
       56
       +
           | ToolsCall

     

       57
       57
       +
           | ToolsListChanged

     

       58
       58
       +
           

     

       59
       59
       +
           (* Prompt methods *)

     

       60
       60
       +
           | PromptsList

     

       61
       61
       +
           | PromptsGet

     

       62
       62
       +
           | PromptsListChanged

     

       63
       63
       +
           

     

       64
       64
       +
           (* Progress notifications *)

     

       65
       65
       +
           | Progress

     

       43
       66
        
         

     

       44
       44
       -
         (* Resource methods *)

     

       45
       45
       -
         let resources_list = "resources/list"

     

       46
       46
       -
         let resources_read = "resources/read"

     

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

     

       48
       48
       -
         let resources_subscribe = "resources/subscribe"

     

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

     

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

     

       51
       51
       -
         

     

       52
       52
       -
         (* Tool methods *)

     

       53
       53
       -
         let tools_list = "tools/list"

     

       54
       54
       -
         let tools_call = "tools/call"

     

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

     

       56
       56
       -
         

     

       57
       57
       -
         (* Prompt methods *)

     

       58
       58
       -
         let prompts_list = "prompts/list"

     

       59
       59
       -
         let prompts_get = "prompts/get"

     

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

     

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

     

       68
       68
       +
         let to_string = function

     

       69
       69
       +
           | Initialize -> "initialize"

     

       70
       70
       +
           | Initialized -> "notifications/initialized"

     

       71
       71
       +
           | ResourcesList -> "resources/list"

     

       72
       72
       +
           | ResourcesRead -> "resources/read"

     

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

     

       74
       74
       +
           | ResourcesSubscribe -> "resources/subscribe"

     

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

     

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

     

       77
       77
       +
           | ToolsList -> "tools/list"

     

       78
       78
       +
           | ToolsCall -> "tools/call"

     

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

     

       80
       80
       +
           | PromptsList -> "prompts/list"

     

       81
       81
       +
           | PromptsGet -> "prompts/get"

     

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

     

       83
       83
       +
           | Progress -> "notifications/progress"

     

       61
       84
        
         

     

       62
       62
       -
         (* Progress notifications *)

     

       63
       63
       -
         let progress = "notifications/progress"

     

       85
       85
       +
         (* Convert string to method type *)

     

       86
       86
       +
         let of_string = function

     

       87
       87
       +
           | "initialize" -> Initialize

     

       88
       88
       +
           | "notifications/initialized" -> Initialized

     

       89
       89
       +
           | "resources/list" -> ResourcesList

     

       90
       90
       +
           | "resources/read" -> ResourcesRead

     

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

     

       92
       92
       +
           | "resources/subscribe" -> ResourcesSubscribe

     

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

     

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

     

       95
       95
       +
           | "tools/list" -> ToolsList

     

       96
       96
       +
           | "tools/call" -> ToolsCall

     

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

     

       98
       98
       +
           | "prompts/list" -> PromptsList

     

       99
       99
       +
           | "prompts/get" -> PromptsGet

     

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

     

       101
       101
       +
           | "notifications/progress" -> Progress

     

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

     

       64
       103
        
       end

     

       65
       104
        
       

     

       66
       105
        
       (* Common types *)

     
···

       520
       559
        
       

     

       521
       560
        
       module JSONRPCMessage = struct

     

       522
       561
        
         type notification = {

     

       523
       523
       -
           method_: string;

     

       562
       562
       +
           method_: Method.t;

     

       524
       563
        
           params: Json.t option;

     

       525
       564
        
         }

     

       526
       565
        
       

     

       527
       566
        
         type request = {

     

       528
       567
        
           id: RequestId.t;

     

       529
       529
       -
           method_: string;

     

       568
       568
       +
           method_: Method.t;

     

       530
       569
        
           params: Json.t option;

     

       531
       570
        
           progress_token: ProgressToken.t option;

     

       532
       571
        
         }

     
···

       552
       591
        
         let yojson_of_notification (n: notification) =

     

       553
       592
        
           let assoc = [

     

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

     

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

     

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

     

       556
       595
        
           ] in

     

       557
       596
        
           let assoc = match n.params with

     

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

     
···

       564
       603
        
           let assoc = [

     

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

     

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

     

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

     

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

     

       568
       607
        
           ] in

     

       569
       608
        
           let assoc = match r.params with

     

       570
       609
        
             | Some params ->

     
···

       615
       654
        
         let notification_of_yojson = function

     

       616
       655
        
           | `Assoc fields ->

     

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

     

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

     

       657
       657
       +
               | Some (`String s) -> 

     

       658
       658
       +
                   (try Method.of_string s

     

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

     

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

     

       620
       661
        
             in

     

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

     
···

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

     

       630
       671
        
             in

     

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

     

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

     

       673
       673
       +
               | Some (`String s) -> 

     

       674
       674
       +
                   (try Method.of_string s

     

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

     

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

     

       634
       677
        
             in

     

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

     
···

       754
       797
        
       

     

       755
       798
        
           let to_jsonrpc ~id t =

     

       756
       799
        
             let params = yojson_of_t t in

     

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

     

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

     

       758
       801
        
         end

     

       759
       802
        
       

     

       760
       803
        
         module Result = struct

     
···

       839
       882
        
               | `Assoc [] -> None

     

       840
       883
        
               | json -> Some json

     

       841
       884
        
             in

     

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

     

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

     

       843
       886
        
         end

     

       844
       887
        
       end

     

       845
       888
        
       

     
···

       849
       892
        
       let parse_message json =

     

       850
       893
        
         JSONRPCMessage.t_of_yojson json

     

       851
       894
        
       

     

       852
       852
       -
       let create_notification = JSONRPCMessage.create_notification

     

       853
       853
       -
       let create_request = JSONRPCMessage.create_request

     

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

     

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

     

       897
       897
       +
       

     

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

     

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

     

       900
       900
       +
       

     

       854
       901
        
       let create_response = JSONRPCMessage.create_response

     

       855
       902
        
       let create_error = JSONRPCMessage.create_error

     

       856
       903

+50 -50

lib/mcp.mli

···

       49
       49
        
         val to_message : t -> string

     

       50
       50
        
       end

     

       51
       51
        
       

     

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

     

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

     

       53
       53
        
       module Method : sig

     

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

     

       55
       55
       -
         

     

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

     

       57
       57
       -
         

     

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

     

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

     

       55
       55
       +
         type t =

     

       56
       56
       +
           (* Initialization and lifecycle methods *)

     

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

     

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

     

       59
       59
       +
           

     

       60
       60
       +
           (* Resource methods *)

     

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

     

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

     

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

     

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

     

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

     

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

     

       67
       67
       +
           

     

       68
       68
       +
           (* Tool methods *)

     

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

     

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

     

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

     

       72
       72
       +
           

     

       73
       73
       +
           (* Prompt methods *)

     

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

     

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

     

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

     

       77
       77
       +
           

     

       78
       78
       +
           (* Progress notifications *)

     

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

     

       59
       80
        
         

     

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

     

       61
       61
       -
       

     

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

     

       63
       63
       -
       

     

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

     

       65
       65
       -
       

     

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

     

       67
       67
       -
       

     

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

     

       69
       69
       -
       

     

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

     

       71
       71
       -
       

     

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

     

       73
       73
       -
       

     

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

     

       75
       75
       -
       

     

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

     

       77
       77
       -
       

     

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

     

       79
       79
       -
       

     

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

     

       81
       81
       -
       

     

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

     

       81
       81
       +
         (** Convert method type to string representation

     

       82
       82
       +
             @param method_ 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

     

       83
       86
        
         

     

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

     

       87
       87
       +
         (** Convert string to method type

     

       88
       88
       +
             @param s The string representation of the method

     

       89
       89
       +
             @return The corresponding method type

     

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

     

       91
       91
       +
         *)

     

       92
       92
       +
         val of_string : string -> t

     

       85
       93
        
       end

     

       86
       94
        
       

     

       87
       95
        
       

     
···

       507
       515
        
             v}

     

       508
       516
        
         *)

     

       509
       517
        
         type notification = {

     

       510
       510
       -
           method_: string;

     

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

     

       512
       512
       -
               Common method patterns include:

     

       513
       513
       -
               - "notifications/X" for standard notifications

     

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

     

       515
       515
       -
               

     

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

     

       518
       518
       +
           method_: Method.t;

     

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

     

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

     

       517
       521
        
           params: Json.t option;

     

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

     

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

     
···

       544
       548
        
           id: RequestId.t;

     

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

     

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

     

       547
       547
       -
           method_: string;

     

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

     

       549
       549
       -
               Common method patterns include:

     

       550
       550
       -
               - "X/Y" for standard operations

     

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

     

       552
       552
       -
               

     

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

     

       551
       551
       +
           method_: 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;

     

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

     

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

     
···

       717
       717
        
             @param method_ 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_:string -> unit -> t

     

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

     

       721
       721
        
         

     

       722
       722
        
         (** Create a new request message

     

       723
       723
        
             @param params Optional parameters for the request

     
···

       726
       726
        
             @param method_ 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_:string -> unit -> t

     

       729
       729
       +
         val create_request : ?params:Json.t option -> ?progress_token:ProgressToken.t option -> id:RequestId.t -> method_: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 name for the notification, typically following MCP naming conventions

     

       917
       917
       +
           @param method_ 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_:string -> unit -> JSONRPCMessage.t

     

       920
       920
       +
       val create_notification : ?params:Json.t option -> method_: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 name for the request, following MCP naming conventions

     

       940
       940
       +
           @param method_ 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_:string -> unit -> JSONRPCMessage.t

     

       943
       943
       +
       val create_request : ?params:Json.t option -> ?progress_token:ProgressToken.t option -> id:RequestId.t -> method_: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.resources_list ~params:(Some params) ()

     

       118
       118
       +
           JSONRPCMessage.create_request ~id ~method_: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.resources_read ~params:(Some params) ()

     

       198
       198
       +
           JSONRPCMessage.create_request ~id ~method_: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.tools_list ~params:(Some params) ()

     

       306
       306
       +
           JSONRPCMessage.create_request ~id ~method_: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.tools_call ~params:(Some params) ()

     

       402
       402
       +
           JSONRPCMessage.create_request ~id ~method_: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.prompts_list ~params:(Some params) ()

     

       549
       549
       +
           JSONRPCMessage.create_request ~id ~method_: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.prompts_get ~params:(Some params) ()

     

       629
       629
       +
           JSONRPCMessage.create_request ~id ~method_: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.resources_list_changed ()

     

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

     

       642
       642
        
         

     

       643
       643
        
         let create_tools_notification () =

     

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

     

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

     

       645
       645
        
         

     

       646
       646
        
         let create_prompts_notification () =

     

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

     

       647
       647
       +
           JSONRPCMessage.create_notification ~method_: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.resources_updated ~params:(Some params) ()

     

       675
       675
       +
           JSONRPCMessage.create_notification ~method_: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 ~method_: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_:"notifications/progress" ~params:(Some params) ())

     

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

     

       50
       50
        
           | _ -> None

     

       51
       51
        
       end

     

       52
       52

+11 -12

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" req.method_);

     

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

     

       166
       166
        
             (match req.method_ with

     

       167
       167
       -
              | "initialize" -> handle_initialize server req

     

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

     

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

     

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

     

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

     

       172
       172
       -
              | "ping" -> handle_ping req

     

       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

     

       173
       172
        
              | _ -> 

     

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

     

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

     

       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_)) ()))

     

       176
       175
        
           | JSONRPCMessage.Notification notif ->

     

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

     

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

     

       178
       177
        
             (match notif.method_ with

     

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

     

       178
       178
       +
              | Method.Initialized -> handle_initialized notif

     

       180
       179
        
              | _ ->

     

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

     

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

     

       182
       181
        
                 None)

     

       183
       182
        
           | JSONRPCMessage.Response _ ->

     

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