commit 328ae50dcbb50999aebed7a00d71a9432b02576f · anil.recoil.org/slop

+288

claudeio/lib_mcp/SERVER_SESSION_README.md

···

       1
       1
       +
       # MCP Server Session API

     

       2
       2
       +
       

     

       3
       3
       +
       The `Server_session` module provides a high-level, easy-to-use API for creating MCP (Model Context Protocol) servers in OCaml using Eio.

     

       4
       4
       +
       

     

       5
       5
       +
       ## Overview

     

       6
       6
       +
       

     

       7
       7
       +
       This module handles:

     

       8
       8
       +
       - **Initialization handshake**: Automatically handles the MCP initialization protocol

     

       9
       9
       +
       - **Request routing**: Routes incoming requests to your handler functions

     

       10
       10
       +
       - **Response encoding**: Automatically encodes responses using the correct MCP message types

     

       11
       11
       +
       - **Notification sending**: Provides convenient functions for sending notifications to clients

     

       12
       12
       +
       - **Error handling**: Returns proper JSON-RPC error responses for missing handlers

     

       13
       13
       +
       

     

       14
       14
       +
       ## Quick Start

     

       15
       15
       +
       

     

       16
       16
       +
       ```ocaml

     

       17
       17
       +
       open Mcp

     

       18
       18
       +
       

     

       19
       19
       +
       (* Define your handlers *)

     

       20
       20
       +
       let list_tools ~cursor:_ =

     

       21
       21
       +
         let tool = Messages.Tools.make_tool

     

       22
       22
       +
           ~name:"my_tool"

     

       23
       23
       +
           ~description:"An example tool"

     

       24
       24
       +
           ~input_schema:(Jsont.Object ([], Jsont.Meta.none))

     

       25
       25
       +
           ()

     

       26
       26
       +
         in

     

       27
       27
       +
         Messages.Tools.make_list_result ~tools:[tool] ()

     

       28
       28
       +
       

     

       29
       29
       +
       let call_tool ~name ~arguments =

     

       30
       30
       +
         match name with

     

       31
       31
       +
         | "my_tool" ->

     

       32
       32
       +
             Messages.Tools.make_call_result

     

       33
       33
       +
               ~content:[Content.text "Tool result"]

     

       34
       34
       +
               ()

     

       35
       35
       +
         | _ ->

     

       36
       36
       +
             Messages.Tools.make_call_result

     

       37
       37
       +
               ~content:[Content.text "Unknown tool"]

     

       38
       38
       +
               ~is_error:true

     

       39
       39
       +
               ()

     

       40
       40
       +
       

     

       41
       41
       +
       (* Configure your server *)

     

       42
       42
       +
       let config = {

     

       43
       43
       +
         Server_session.server_info = Capabilities.Implementation.make

     

       44
       44
       +
           ~name:"my-server"

     

       45
       45
       +
           ~version:"1.0.0";

     

       46
       46
       +
         server_capabilities = Capabilities.Server.make

     

       47
       47
       +
           ~tools:(Capabilities.Tools.make ())

     

       48
       48
       +
           ();

     

       49
       49
       +
         instructions = Some "My MCP server";

     

       50
       50
       +
       }

     

       51
       51
       +
       

     

       52
       52
       +
       let handlers = {

     

       53
       53
       +
         Server_session.list_tools = Some list_tools;

     

       54
       54
       +
         call_tool = Some call_tool;

     

       55
       55
       +
         list_resources = None;

     

       56
       56
       +
         list_resource_templates = None;

     

       57
       57
       +
         read_resource = None;

     

       58
       58
       +
         subscribe_resource = None;

     

       59
       59
       +
         unsubscribe_resource = None;

     

       60
       60
       +
         list_prompts = None;

     

       61
       61
       +
         get_prompt = None;

     

       62
       62
       +
         complete = None;

     

       63
       63
       +
         ping = None;

     

       64
       64
       +
       }

     

       65
       65
       +
       

     

       66
       66
       +
       (* Start the server *)

     

       67
       67
       +
       let () =

     

       68
       68
       +
         Eio_main.run @@ fun env ->

     

       69
       69
       +
           Eio.Switch.run @@ fun sw ->

     

       70
       70
       +
             let transport = (* create your transport *) in

     

       71
       71
       +
             let server = Server_session.create

     

       72
       72
       +
               ~sw

     

       73
       73
       +
               ~transport

     

       74
       74
       +
               config

     

       75
       75
       +
               handlers

     

       76
       76
       +
             in

     

       77
       77
       +
             (* Server is now running *)

     

       78
       78
       +
       ```

     

       79
       79
       +
       

     

       80
       80
       +
       ## Architecture

     

       81
       81
       +
       

     

       82
       82
       +
       ### Initialization Flow

     

       83
       83
       +
       

     

       84
       84
       +
       1. **Client sends Initialize request** → Server stores client capabilities and info

     

       85
       85
       +
       2. **Server responds with capabilities** → Returns server capabilities and info

     

       86
       86
       +
       3. **Client sends Initialized notification** → Server marks initialization complete

     

       87
       87
       +
       4. **Server is ready** → Now accepts requests and can send notifications

     

       88
       88
       +
       

     

       89
       89
       +
       ### Request Handling

     

       90
       90
       +
       

     

       91
       91
       +
       When a request arrives:

     

       92
       92
       +
       

     

       93
       93
       +
       1. The method name is matched against handler types

     

       94
       94
       +
       2. If a handler exists, it's called with the decoded parameters

     

       95
       95
       +
       3. The result is encoded and sent back

     

       96
       96
       +
       4. If no handler exists, a METHOD_NOT_FOUND error is returned

     

       97
       97
       +
       

     

       98
       98
       +
       ### Error Handling

     

       99
       99
       +
       

     

       100
       100
       +
       The module automatically handles:

     

       101
       101
       +
       - Missing handlers → METHOD_NOT_FOUND error

     

       102
       102
       +
       - Invalid params → INVALID_PARAMS error

     

       103
       103
       +
       - Handler exceptions → INTERNAL_ERROR with exception message

     

       104
       104
       +
       - Pre-initialization requests → Rejected with error

     

       105
       105
       +
       

     

       106
       106
       +
       ## Supported Capabilities

     

       107
       107
       +
       

     

       108
       108
       +
       The server can implement any combination of these capabilities:

     

       109
       109
       +
       

     

       110
       110
       +
       ### Resources

     

       111
       111
       +
       - `list_resources`: List available resources with optional pagination

     

       112
       112
       +
       - `list_resource_templates`: List resource templates

     

       113
       113
       +
       - `read_resource`: Read resource contents by URI

     

       114
       114
       +
       - `subscribe_resource`: Subscribe to resource updates

     

       115
       115
       +
       - `unsubscribe_resource`: Unsubscribe from updates

     

       116
       116
       +
       

     

       117
       117
       +
       Notifications you can send:

     

       118
       118
       +
       - `send_resource_updated`: Notify about a specific resource update

     

       119
       119
       +
       - `send_resource_list_changed`: Notify that the resource list changed

     

       120
       120
       +
       

     

       121
       121
       +
       ### Tools

     

       122
       122
       +
       - `list_tools`: List available tools with optional pagination

     

       123
       123
       +
       - `call_tool`: Execute a tool by name with arguments

     

       124
       124
       +
       

     

       125
       125
       +
       Notifications you can send:

     

       126
       126
       +
       - `send_tool_list_changed`: Notify that the tool list changed

     

       127
       127
       +
       

     

       128
       128
       +
       ### Prompts

     

       129
       129
       +
       - `list_prompts`: List available prompts with optional pagination

     

       130
       130
       +
       - `get_prompt`: Get a prompt by name with arguments

     

       131
       131
       +
       

     

       132
       132
       +
       Notifications you can send:

     

       133
       133
       +
       - `send_prompt_list_changed`: Notify that the prompt list changed

     

       134
       134
       +
       

     

       135
       135
       +
       ### Other

     

       136
       136
       +
       - `complete`: Auto-completion suggestions

     

       137
       137
       +
       - `ping`: Keepalive handler

     

       138
       138
       +
       

     

       139
       139
       +
       ### Logging

     

       140
       140
       +
       - `send_log_message`: Send log messages to the client

     

       141
       141
       +
       

     

       142
       142
       +
       ### Progress

     

       143
       143
       +
       - `send_progress`: Send progress updates for long-running operations

     

       144
       144
       +
       

     

       145
       145
       +
       ## Handler Signatures

     

       146
       146
       +
       

     

       147
       147
       +
       All handlers return strongly-typed message results:

     

       148
       148
       +
       

     

       149
       149
       +
       ```ocaml

     

       150
       150
       +
       type handlers = {

     

       151
       151
       +
         list_resources : (cursor:string option -> Messages.Resources.list_result) option;

     

       152
       152
       +
         read_resource : (uri:string -> Messages.Resources.read_result) option;

     

       153
       153
       +
         list_tools : (cursor:string option -> Messages.Tools.list_result) option;

     

       154
       154
       +
         call_tool : (name:string -> arguments:Jsont.json option -> Messages.Tools.call_result) option;

     

       155
       155
       +
         list_prompts : (cursor:string option -> Messages.Prompts.list_result) option;

     

       156
       156
       +
         get_prompt : (name:string -> arguments:(string * string) list option -> Messages.Prompts.get_result) option;

     

       157
       157
       +
         complete : (ref_:Messages.Completions.completion_ref -> argument:string -> Messages.Completions.result) option;

     

       158
       158
       +
         ping : (unit -> unit) option;

     

       159
       159
       +
         (* ... *)

     

       160
       160
       +
       }

     

       161
       161
       +
       ```

     

       162
       162
       +
       

     

       163
       163
       +
       Set a handler to `None` if you don't support that operation.

     

       164
       164
       +
       

     

       165
       165
       +
       ## Accessing Client Information

     

       166
       166
       +
       

     

       167
       167
       +
       After initialization, you can query client capabilities:

     

       168
       168
       +
       

     

       169
       169
       +
       ```ocaml

     

       170
       170
       +
       let server = Server_session.create ~sw ~transport config handlers in

     

       171
       171
       +
       

     

       172
       172
       +
       (* Get client capabilities *)

     

       173
       173
       +
       let client_caps = Server_session.client_capabilities server in

     

       174
       174
       +
       match client_caps.roots with

     

       175
       175
       +
       | Some _ -> (* Client supports roots *)

     

       176
       176
       +
       | None -> (* Client doesn't support roots *)

     

       177
       177
       +
       

     

       178
       178
       +
       (* Get client info *)

     

       179
       179
       +
       let client_info = Server_session.client_info server in

     

       180
       180
       +
       Printf.printf "Connected to: %s v%s\n"

     

       181
       181
       +
         client_info.name

     

       182
       182
       +
         client_info.version;

     

       183
       183
       +
       

     

       184
       184
       +
       (* Get protocol version *)

     

       185
       185
       +
       let version = Server_session.protocol_version server in

     

       186
       186
       +
       ```

     

       187
       187
       +
       

     

       188
       188
       +
       ## Sending Notifications

     

       189
       189
       +
       

     

       190
       190
       +
       Send notifications to inform clients of changes:

     

       191
       191
       +
       

     

       192
       192
       +
       ```ocaml

     

       193
       193
       +
       (* Resource was updated *)

     

       194
       194
       +
       Server_session.send_resource_updated server ~uri:"file:///example.txt";

     

       195
       195
       +
       

     

       196
       196
       +
       (* Resource list changed *)

     

       197
       197
       +
       Server_session.send_resource_list_changed server;

     

       198
       198
       +
       

     

       199
       199
       +
       (* Tool list changed *)

     

       200
       200
       +
       Server_session.send_tool_list_changed server;

     

       201
       201
       +
       

     

       202
       202
       +
       (* Log a message *)

     

       203
       203
       +
       let log_data = Jsont.String ("Something happened", Jsont.Meta.none) in

     

       204
       204
       +
       Server_session.send_log_message server

     

       205
       205
       +
         ~level:Messages.Logging.Info

     

       206
       206
       +
         ~data:log_data

     

       207
       207
       +
         ();

     

       208
       208
       +
       

     

       209
       209
       +
       (* Report progress *)

     

       210
       210
       +
       Server_session.send_progress server

     

       211
       211
       +
         ~progress_token:"operation-123"

     

       212
       212
       +
         ~progress:0.5

     

       213
       213
       +
         ~total:100.0

     

       214
       214
       +
         ();

     

       215
       215
       +
       ```

     

       216
       216
       +
       

     

       217
       217
       +
       ## Requesting from Client

     

       218
       218
       +
       

     

       219
       219
       +
       Some servers may need to request information from clients:

     

       220
       220
       +
       

     

       221
       221
       +
       ```ocaml

     

       222
       222
       +
       (* Request the list of roots (if client supports it) *)

     

       223
       223
       +
       match Server_session.request_roots_list server with

     

       224
       224
       +
       | Some result ->

     

       225
       225
       +
           List.iter (fun root ->

     

       226
       226
       +
             Printf.printf "Root: %s\n" root.Messages.Roots.uri

     

       227
       227
       +
           ) result.roots

     

       228
       228
       +
       | None ->

     

       229
       229
       +
           (* Client doesn't support roots capability *)

     

       230
       230
       +
           ()

     

       231
       231
       +
       ```

     

       232
       232
       +
       

     

       233
       233
       +
       ## Example: Simple Tool Server

     

       234
       234
       +
       

     

       235
       235
       +
       See `examples/mcp_server_example.ml` for a complete example that demonstrates:

     

       236
       236
       +
       - Tool implementation (add, echo)

     

       237
       237
       +
       - Resource serving (example://greeting)

     

       238
       238
       +
       - Proper capability declaration

     

       239
       239
       +
       - Handler implementation

     

       240
       240
       +
       

     

       241
       241
       +
       ## Implementation Notes

     

       242
       242
       +
       

     

       243
       243
       +
       ### Thread Safety

     

       244
       244
       +
       The module uses Eio structured concurrency. All operations are safe within the same Eio domain. The Session module handles concurrent requests using Eio fibers.

     

       245
       245
       +
       

     

       246
       246
       +
       ### Timeout Support

     

       247
       247
       +
       You can configure request timeouts:

     

       248
       248
       +
       

     

       249
       249
       +
       ```ocaml

     

       250
       250
       +
       let server = Server_session.create

     

       251
       251
       +
         ~sw

     

       252
       252
       +
         ~transport

     

       253
       253
       +
         ~timeout:30.0  (* 30 second timeout *)

     

       254
       254
       +
         ~clock:(Session.C (Eio.Stdenv.clock env))

     

       255
       255
       +
         config

     

       256
       256
       +
         handlers

     

       257
       257
       +
       ```

     

       258
       258
       +
       

     

       259
       259
       +
       ### Error Propagation

     

       260
       260
       +
       - Handler exceptions are caught and converted to INTERNAL_ERROR responses

     

       261
       261
       +
       - The server continues running after handler errors

     

       262
       262
       +
       - Use proper error handling in your handlers for better error messages

     

       263
       263
       +
       

     

       264
       264
       +
       ### Shutdown

     

       265
       265
       +
       The server runs as long as the Eio switch is active:

     

       266
       266
       +
       

     

       267
       267
       +
       ```ocaml

     

       268
       268
       +
       (* Explicit close *)

     

       269
       269
       +
       Server_session.close server;

     

       270
       270
       +
       

     

       271
       271
       +
       (* Or let the switch handle cleanup *)

     

       272
       272
       +
       Eio.Switch.run @@ fun sw ->

     

       273
       273
       +
         let server = Server_session.create ~sw ~transport config handlers in

     

       274
       274
       +
         (* server auto-closes when switch exits *)

     

       275
       275
       +
       ```

     

       276
       276
       +
       

     

       277
       277
       +
       ## Related Modules

     

       278
       278
       +
       

     

       279
       279
       +
       - `Session`: Low-level bidirectional JSON-RPC session

     

       280
       280
       +
       - `Messages`: MCP protocol message types

     

       281
       281
       +
       - `Capabilities`: Capability negotiation types

     

       282
       282
       +
       - `Transport`: Transport layer abstraction

     

       283
       283
       +
       - `Content`: Content block types (text, image, etc.)

     

       284
       284
       +
       

     

       285
       285
       +
       ## References

     

       286
       286
       +
       

     

       287
       287
       +
       - [MCP Specification](https://spec.modelcontextprotocol.io/)

     

       288
       288
       +
       - [JSON-RPC 2.0 Specification](https://www.jsonrpc.org/)

+284

claudeio/lib_mcp/capabilities.ml

···

       1
       1
       +
       (** MCP Capability negotiation types *)

     

       2
       2
       +
       

     

       3
       3
       +
       (* Implementation Info *)

     

       4
       4
       +
       

     

       5
       5
       +
       module Implementation = struct

     

       6
       6
       +
         type t = {

     

       7
       7
       +
           name : string;

     

       8
       8
       +
           version : string;

     

       9
       9
       +
           unknown : Jsont.json;

     

       10
       10
       +
         }

     

       11
       11
       +
       

     

       12
       12
       +
         let make ~name ~version =

     

       13
       13
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       14
       14
       +
           { name; version; unknown }

     

       15
       15
       +
       

     

       16
       16
       +
         let jsont : t Jsont.t =

     

       17
       17
       +
           let make name version unknown = { name; version; unknown } in

     

       18
       18
       +
           Jsont.Object.map ~kind:"Implementation" make

     

       19
       19
       +
           |> Jsont.Object.mem "name" Jsont.string ~enc:(fun i -> i.name)

     

       20
       20
       +
           |> Jsont.Object.mem "version" Jsont.string ~enc:(fun i -> i.version)

     

       21
       21
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun i -> i.unknown)

     

       22
       22
       +
           |> Jsont.Object.finish

     

       23
       23
       +
       

     

       24
       24
       +
         let pp fmt i =

     

       25
       25
       +
           Format.fprintf fmt "%s/%s" i.name i.version

     

       26
       26
       +
       end

     

       27
       27
       +
       

     

       28
       28
       +
       (* Client Capabilities *)

     

       29
       29
       +
       

     

       30
       30
       +
       module Sampling = struct

     

       31
       31
       +
         type t = {

     

       32
       32
       +
           context : bool option;

     

       33
       33
       +
           tools : bool option;

     

       34
       34
       +
           unknown : Jsont.json;

     

       35
       35
       +
         }

     

       36
       36
       +
       

     

       37
       37
       +
         let empty =

     

       38
       38
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       39
       39
       +
           { context = None; tools = None; unknown }

     

       40
       40
       +
       

     

       41
       41
       +
         let make ?context ?tools () =

     

       42
       42
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       43
       43
       +
           { context; tools; unknown }

     

       44
       44
       +
       

     

       45
       45
       +
         let jsont : t Jsont.t =

     

       46
       46
       +
           let make context tools unknown = { context; tools; unknown } in

     

       47
       47
       +
           Jsont.Object.map ~kind:"Sampling" make

     

       48
       48
       +
           |> Jsont.Object.opt_mem "context" Jsont.bool ~enc:(fun s -> s.context)

     

       49
       49
       +
           |> Jsont.Object.opt_mem "tools" Jsont.bool ~enc:(fun s -> s.tools)

     

       50
       50
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun s -> s.unknown)

     

       51
       51
       +
           |> Jsont.Object.finish

     

       52
       52
       +
       end

     

       53
       53
       +
       

     

       54
       54
       +
       module Elicitation = struct

     

       55
       55
       +
         type t = {

     

       56
       56
       +
           unknown : Jsont.json;

     

       57
       57
       +
         }

     

       58
       58
       +
       

     

       59
       59
       +
         let empty =

     

       60
       60
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       61
       61
       +
           { unknown }

     

       62
       62
       +
       

     

       63
       63
       +
         let jsont : t Jsont.t =

     

       64
       64
       +
           let make unknown = { unknown } in

     

       65
       65
       +
           Jsont.Object.map ~kind:"Elicitation" make

     

       66
       66
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun e -> e.unknown)

     

       67
       67
       +
           |> Jsont.Object.finish

     

       68
       68
       +
       end

     

       69
       69
       +
       

     

       70
       70
       +
       module Roots = struct

     

       71
       71
       +
         type t = {

     

       72
       72
       +
           list_changed : bool option;

     

       73
       73
       +
           unknown : Jsont.json;

     

       74
       74
       +
         }

     

       75
       75
       +
       

     

       76
       76
       +
         let empty =

     

       77
       77
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       78
       78
       +
           { list_changed = None; unknown }

     

       79
       79
       +
       

     

       80
       80
       +
         let make ?list_changed () =

     

       81
       81
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       82
       82
       +
           { list_changed; unknown }

     

       83
       83
       +
       

     

       84
       84
       +
         let jsont : t Jsont.t =

     

       85
       85
       +
           let make list_changed unknown = { list_changed; unknown } in

     

       86
       86
       +
           Jsont.Object.map ~kind:"Roots" make

     

       87
       87
       +
           |> Jsont.Object.opt_mem "listChanged" Jsont.bool ~enc:(fun r -> r.list_changed)

     

       88
       88
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)

     

       89
       89
       +
           |> Jsont.Object.finish

     

       90
       90
       +
       end

     

       91
       91
       +
       

     

       92
       92
       +
       module Client = struct

     

       93
       93
       +
         type t = {

     

       94
       94
       +
           sampling : Sampling.t option;

     

       95
       95
       +
           elicitation : Elicitation.t option;

     

       96
       96
       +
           roots : Roots.t option;

     

       97
       97
       +
           experimental : Jsont.json option;

     

       98
       98
       +
           unknown : Jsont.json;

     

       99
       99
       +
         }

     

       100
       100
       +
       

     

       101
       101
       +
         let empty =

     

       102
       102
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       103
       103
       +
           { sampling = None; elicitation = None; roots = None; experimental = None; unknown }

     

       104
       104
       +
       

     

       105
       105
       +
         let make ?sampling ?elicitation ?roots ?experimental () =

     

       106
       106
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       107
       107
       +
           { sampling; elicitation; roots; experimental; unknown }

     

       108
       108
       +
       

     

       109
       109
       +
         let jsont : t Jsont.t =

     

       110
       110
       +
           let make sampling elicitation roots experimental unknown =

     

       111
       111
       +
             { sampling; elicitation; roots; experimental; unknown }

     

       112
       112
       +
           in

     

       113
       113
       +
           Jsont.Object.map ~kind:"ClientCapabilities" make

     

       114
       114
       +
           |> Jsont.Object.opt_mem "sampling" Sampling.jsont ~enc:(fun c -> c.sampling)

     

       115
       115
       +
           |> Jsont.Object.opt_mem "elicitation" Elicitation.jsont ~enc:(fun c -> c.elicitation)

     

       116
       116
       +
           |> Jsont.Object.opt_mem "roots" Roots.jsont ~enc:(fun c -> c.roots)

     

       117
       117
       +
           |> Jsont.Object.opt_mem "experimental" Jsont.json ~enc:(fun c -> c.experimental)

     

       118
       118
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun c -> c.unknown)

     

       119
       119
       +
           |> Jsont.Object.finish

     

       120
       120
       +
       

     

       121
       121
       +
         let pp fmt c =

     

       122
       122
       +
           let caps = [

     

       123
       123
       +
             (match c.sampling with Some _ -> Some "sampling" | None -> None);

     

       124
       124
       +
             (match c.elicitation with Some _ -> Some "elicitation" | None -> None);

     

       125
       125
       +
             (match c.roots with Some _ -> Some "roots" | None -> None);

     

       126
       126
       +
           ] |> List.filter_map Fun.id in

     

       127
       127
       +
           Format.fprintf fmt "[%s]" (String.concat ", " caps)

     

       128
       128
       +
       end

     

       129
       129
       +
       

     

       130
       130
       +
       (* Server Capabilities *)

     

       131
       131
       +
       

     

       132
       132
       +
       module Logging = struct

     

       133
       133
       +
         type t = {

     

       134
       134
       +
           unknown : Jsont.json;

     

       135
       135
       +
         }

     

       136
       136
       +
       

     

       137
       137
       +
         let empty =

     

       138
       138
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       139
       139
       +
           { unknown }

     

       140
       140
       +
       

     

       141
       141
       +
         let jsont : t Jsont.t =

     

       142
       142
       +
           let make unknown = { unknown } in

     

       143
       143
       +
           Jsont.Object.map ~kind:"Logging" make

     

       144
       144
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun l -> l.unknown)

     

       145
       145
       +
           |> Jsont.Object.finish

     

       146
       146
       +
       end

     

       147
       147
       +
       

     

       148
       148
       +
       module Prompts = struct

     

       149
       149
       +
         type t = {

     

       150
       150
       +
           list_changed : bool option;

     

       151
       151
       +
           unknown : Jsont.json;

     

       152
       152
       +
         }

     

       153
       153
       +
       

     

       154
       154
       +
         let empty =

     

       155
       155
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       156
       156
       +
           { list_changed = None; unknown }

     

       157
       157
       +
       

     

       158
       158
       +
         let make ?list_changed () =

     

       159
       159
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       160
       160
       +
           { list_changed; unknown }

     

       161
       161
       +
       

     

       162
       162
       +
         let jsont : t Jsont.t =

     

       163
       163
       +
           let make list_changed unknown = { list_changed; unknown } in

     

       164
       164
       +
           Jsont.Object.map ~kind:"Prompts" make

     

       165
       165
       +
           |> Jsont.Object.opt_mem "listChanged" Jsont.bool ~enc:(fun p -> p.list_changed)

     

       166
       166
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun p -> p.unknown)

     

       167
       167
       +
           |> Jsont.Object.finish

     

       168
       168
       +
       end

     

       169
       169
       +
       

     

       170
       170
       +
       module Resources = struct

     

       171
       171
       +
         type t = {

     

       172
       172
       +
           subscribe : bool option;

     

       173
       173
       +
           list_changed : bool option;

     

       174
       174
       +
           unknown : Jsont.json;

     

       175
       175
       +
         }

     

       176
       176
       +
       

     

       177
       177
       +
         let empty =

     

       178
       178
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       179
       179
       +
           { subscribe = None; list_changed = None; unknown }

     

       180
       180
       +
       

     

       181
       181
       +
         let make ?subscribe ?list_changed () =

     

       182
       182
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       183
       183
       +
           { subscribe; list_changed; unknown }

     

       184
       184
       +
       

     

       185
       185
       +
         let jsont : t Jsont.t =

     

       186
       186
       +
           let make subscribe list_changed unknown =

     

       187
       187
       +
             { subscribe; list_changed; unknown }

     

       188
       188
       +
           in

     

       189
       189
       +
           Jsont.Object.map ~kind:"Resources" make

     

       190
       190
       +
           |> Jsont.Object.opt_mem "subscribe" Jsont.bool ~enc:(fun r -> r.subscribe)

     

       191
       191
       +
           |> Jsont.Object.opt_mem "listChanged" Jsont.bool ~enc:(fun r -> r.list_changed)

     

       192
       192
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)

     

       193
       193
       +
           |> Jsont.Object.finish

     

       194
       194
       +
       end

     

       195
       195
       +
       

     

       196
       196
       +
       module Tools = struct

     

       197
       197
       +
         type t = {

     

       198
       198
       +
           list_changed : bool option;

     

       199
       199
       +
           unknown : Jsont.json;

     

       200
       200
       +
         }

     

       201
       201
       +
       

     

       202
       202
       +
         let empty =

     

       203
       203
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       204
       204
       +
           { list_changed = None; unknown }

     

       205
       205
       +
       

     

       206
       206
       +
         let make ?list_changed () =

     

       207
       207
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       208
       208
       +
           { list_changed; unknown }

     

       209
       209
       +
       

     

       210
       210
       +
         let jsont : t Jsont.t =

     

       211
       211
       +
           let make list_changed unknown = { list_changed; unknown } in

     

       212
       212
       +
           Jsont.Object.map ~kind:"Tools" make

     

       213
       213
       +
           |> Jsont.Object.opt_mem "listChanged" Jsont.bool ~enc:(fun t -> t.list_changed)

     

       214
       214
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun t -> t.unknown)

     

       215
       215
       +
           |> Jsont.Object.finish

     

       216
       216
       +
       end

     

       217
       217
       +
       

     

       218
       218
       +
       module Completions = struct

     

       219
       219
       +
         type t = {

     

       220
       220
       +
           unknown : Jsont.json;

     

       221
       221
       +
         }

     

       222
       222
       +
       

     

       223
       223
       +
         let empty =

     

       224
       224
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       225
       225
       +
           { unknown }

     

       226
       226
       +
       

     

       227
       227
       +
         let jsont : t Jsont.t =

     

       228
       228
       +
           let make unknown = { unknown } in

     

       229
       229
       +
           Jsont.Object.map ~kind:"Completions" make

     

       230
       230
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun c -> c.unknown)

     

       231
       231
       +
           |> Jsont.Object.finish

     

       232
       232
       +
       end

     

       233
       233
       +
       

     

       234
       234
       +
       module Server = struct

     

       235
       235
       +
         type t = {

     

       236
       236
       +
           logging : Logging.t option;

     

       237
       237
       +
           prompts : Prompts.t option;

     

       238
       238
       +
           resources : Resources.t option;

     

       239
       239
       +
           tools : Tools.t option;

     

       240
       240
       +
           completions : Completions.t option;

     

       241
       241
       +
           experimental : Jsont.json option;

     

       242
       242
       +
           unknown : Jsont.json;

     

       243
       243
       +
         }

     

       244
       244
       +
       

     

       245
       245
       +
         let empty =

     

       246
       246
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       247
       247
       +
           {

     

       248
       248
       +
             logging = None;

     

       249
       249
       +
             prompts = None;

     

       250
       250
       +
             resources = None;

     

       251
       251
       +
             tools = None;

     

       252
       252
       +
             completions = None;

     

       253
       253
       +
             experimental = None;

     

       254
       254
       +
             unknown;

     

       255
       255
       +
           }

     

       256
       256
       +
       

     

       257
       257
       +
         let make ?logging ?prompts ?resources ?tools ?completions ?experimental () =

     

       258
       258
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       259
       259
       +
           { logging; prompts; resources; tools; completions; experimental; unknown }

     

       260
       260
       +
       

     

       261
       261
       +
         let jsont : t Jsont.t =

     

       262
       262
       +
           let make logging prompts resources tools completions experimental unknown =

     

       263
       263
       +
             { logging; prompts; resources; tools; completions; experimental; unknown }

     

       264
       264
       +
           in

     

       265
       265
       +
           Jsont.Object.map ~kind:"ServerCapabilities" make

     

       266
       266
       +
           |> Jsont.Object.opt_mem "logging" Logging.jsont ~enc:(fun s -> s.logging)

     

       267
       267
       +
           |> Jsont.Object.opt_mem "prompts" Prompts.jsont ~enc:(fun s -> s.prompts)

     

       268
       268
       +
           |> Jsont.Object.opt_mem "resources" Resources.jsont ~enc:(fun s -> s.resources)

     

       269
       269
       +
           |> Jsont.Object.opt_mem "tools" Tools.jsont ~enc:(fun s -> s.tools)

     

       270
       270
       +
           |> Jsont.Object.opt_mem "completions" Completions.jsont ~enc:(fun s -> s.completions)

     

       271
       271
       +
           |> Jsont.Object.opt_mem "experimental" Jsont.json ~enc:(fun s -> s.experimental)

     

       272
       272
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun s -> s.unknown)

     

       273
       273
       +
           |> Jsont.Object.finish

     

       274
       274
       +
       

     

       275
       275
       +
         let pp fmt s =

     

       276
       276
       +
           let caps = [

     

       277
       277
       +
             (match s.logging with Some _ -> Some "logging" | None -> None);

     

       278
       278
       +
             (match s.prompts with Some _ -> Some "prompts" | None -> None);

     

       279
       279
       +
             (match s.resources with Some _ -> Some "resources" | None -> None);

     

       280
       280
       +
             (match s.tools with Some _ -> Some "tools" | None -> None);

     

       281
       281
       +
             (match s.completions with Some _ -> Some "completions" | None -> None);

     

       282
       282
       +
           ] |> List.filter_map Fun.id in

     

       283
       283
       +
           Format.fprintf fmt "[%s]" (String.concat ", " caps)

     

       284
       284
       +
       end

+161

claudeio/lib_mcp/capabilities.mli

···

       1
       1
       +
       (** MCP Capability negotiation types.

     

       2
       2
       +
       

     

       3
       3
       +
           Capabilities are exchanged during initialization to determine what features

     

       4
       4
       +
           the client and server support. *)

     

       5
       5
       +
       

     

       6
       6
       +
       (** {1 Implementation Info} *)

     

       7
       7
       +
       

     

       8
       8
       +
       module Implementation : sig

     

       9
       9
       +
         type t = {

     

       10
       10
       +
           name : string;

     

       11
       11
       +
           version : string;

     

       12
       12
       +
           unknown : Jsont.json;

     

       13
       13
       +
         }

     

       14
       14
       +
         (** Information about client or server implementation *)

     

       15
       15
       +
       

     

       16
       16
       +
         val make : name:string -> version:string -> t

     

       17
       17
       +
         val jsont : t Jsont.t

     

       18
       18
       +
         val pp : Format.formatter -> t -> unit

     

       19
       19
       +
       end

     

       20
       20
       +
       

     

       21
       21
       +
       (** {1 Client Capabilities} *)

     

       22
       22
       +
       

     

       23
       23
       +
       module Sampling : sig

     

       24
       24
       +
         type t = {

     

       25
       25
       +
           context : bool option;

     

       26
       26
       +
           tools : bool option;

     

       27
       27
       +
           unknown : Jsont.json;

     

       28
       28
       +
         }

     

       29
       29
       +
         (** Sampling capability (for servers to request LLM sampling from clients) *)

     

       30
       30
       +
       

     

       31
       31
       +
         val empty : t

     

       32
       32
       +
         val make : ?context:bool -> ?tools:bool -> unit -> t

     

       33
       33
       +
         val jsont : t Jsont.t

     

       34
       34
       +
       end

     

       35
       35
       +
       

     

       36
       36
       +
       module Elicitation : sig

     

       37
       37
       +
         type t = {

     

       38
       38
       +
           unknown : Jsont.json;

     

       39
       39
       +
         }

     

       40
       40
       +
         (** Elicitation capability (for servers to request user input) *)

     

       41
       41
       +
       

     

       42
       42
       +
         val empty : t

     

       43
       43
       +
         val jsont : t Jsont.t

     

       44
       44
       +
       end

     

       45
       45
       +
       

     

       46
       46
       +
       module Roots : sig

     

       47
       47
       +
         type t = {

     

       48
       48
       +
           list_changed : bool option;

     

       49
       49
       +
           unknown : Jsont.json;

     

       50
       50
       +
         }

     

       51
       51
       +
         (** Roots capability (for servers to query filesystem roots) *)

     

       52
       52
       +
       

     

       53
       53
       +
         val empty : t

     

       54
       54
       +
         val make : ?list_changed:bool -> unit -> t

     

       55
       55
       +
         val jsont : t Jsont.t

     

       56
       56
       +
       end

     

       57
       57
       +
       

     

       58
       58
       +
       module Client : sig

     

       59
       59
       +
         type t = {

     

       60
       60
       +
           sampling : Sampling.t option;

     

       61
       61
       +
           elicitation : Elicitation.t option;

     

       62
       62
       +
           roots : Roots.t option;

     

       63
       63
       +
           experimental : Jsont.json option;

     

       64
       64
       +
           unknown : Jsont.json;

     

       65
       65
       +
         }

     

       66
       66
       +
         (** Client capabilities advertised during initialization *)

     

       67
       67
       +
       

     

       68
       68
       +
         val empty : t

     

       69
       69
       +
         val make :

     

       70
       70
       +
           ?sampling:Sampling.t ->

     

       71
       71
       +
           ?elicitation:Elicitation.t ->

     

       72
       72
       +
           ?roots:Roots.t ->

     

       73
       73
       +
           ?experimental:Jsont.json ->

     

       74
       74
       +
           unit -> t

     

       75
       75
       +
         val jsont : t Jsont.t

     

       76
       76
       +
         val pp : Format.formatter -> t -> unit

     

       77
       77
       +
       end

     

       78
       78
       +
       

     

       79
       79
       +
       (** {1 Server Capabilities} *)

     

       80
       80
       +
       

     

       81
       81
       +
       module Logging : sig

     

       82
       82
       +
         type t = {

     

       83
       83
       +
           unknown : Jsont.json;

     

       84
       84
       +
         }

     

       85
       85
       +
         (** Logging capability *)

     

       86
       86
       +
       

     

       87
       87
       +
         val empty : t

     

       88
       88
       +
         val jsont : t Jsont.t

     

       89
       89
       +
       end

     

       90
       90
       +
       

     

       91
       91
       +
       module Prompts : sig

     

       92
       92
       +
         type t = {

     

       93
       93
       +
           list_changed : bool option;

     

       94
       94
       +
           unknown : Jsont.json;

     

       95
       95
       +
         }

     

       96
       96
       +
         (** Prompts capability *)

     

       97
       97
       +
       

     

       98
       98
       +
         val empty : t

     

       99
       99
       +
         val make : ?list_changed:bool -> unit -> t

     

       100
       100
       +
         val jsont : t Jsont.t

     

       101
       101
       +
       end

     

       102
       102
       +
       

     

       103
       103
       +
       module Resources : sig

     

       104
       104
       +
         type t = {

     

       105
       105
       +
           subscribe : bool option;

     

       106
       106
       +
           list_changed : bool option;

     

       107
       107
       +
           unknown : Jsont.json;

     

       108
       108
       +
         }

     

       109
       109
       +
         (** Resources capability *)

     

       110
       110
       +
       

     

       111
       111
       +
         val empty : t

     

       112
       112
       +
         val make : ?subscribe:bool -> ?list_changed:bool -> unit -> t

     

       113
       113
       +
         val jsont : t Jsont.t

     

       114
       114
       +
       end

     

       115
       115
       +
       

     

       116
       116
       +
       module Tools : sig

     

       117
       117
       +
         type t = {

     

       118
       118
       +
           list_changed : bool option;

     

       119
       119
       +
           unknown : Jsont.json;

     

       120
       120
       +
         }

     

       121
       121
       +
         (** Tools capability *)

     

       122
       122
       +
       

     

       123
       123
       +
         val empty : t

     

       124
       124
       +
         val make : ?list_changed:bool -> unit -> t

     

       125
       125
       +
         val jsont : t Jsont.t

     

       126
       126
       +
       end

     

       127
       127
       +
       

     

       128
       128
       +
       module Completions : sig

     

       129
       129
       +
         type t = {

     

       130
       130
       +
           unknown : Jsont.json;

     

       131
       131
       +
         }

     

       132
       132
       +
         (** Completions capability (for auto-complete) *)

     

       133
       133
       +
       

     

       134
       134
       +
         val empty : t

     

       135
       135
       +
         val jsont : t Jsont.t

     

       136
       136
       +
       end

     

       137
       137
       +
       

     

       138
       138
       +
       module Server : sig

     

       139
       139
       +
         type t = {

     

       140
       140
       +
           logging : Logging.t option;

     

       141
       141
       +
           prompts : Prompts.t option;

     

       142
       142
       +
           resources : Resources.t option;

     

       143
       143
       +
           tools : Tools.t option;

     

       144
       144
       +
           completions : Completions.t option;

     

       145
       145
       +
           experimental : Jsont.json option;

     

       146
       146
       +
           unknown : Jsont.json;

     

       147
       147
       +
         }

     

       148
       148
       +
         (** Server capabilities advertised during initialization *)

     

       149
       149
       +
       

     

       150
       150
       +
         val empty : t

     

       151
       151
       +
         val make :

     

       152
       152
       +
           ?logging:Logging.t ->

     

       153
       153
       +
           ?prompts:Prompts.t ->

     

       154
       154
       +
           ?resources:Resources.t ->

     

       155
       155
       +
           ?tools:Tools.t ->

     

       156
       156
       +
           ?completions:Completions.t ->

     

       157
       157
       +
           ?experimental:Jsont.json ->

     

       158
       158
       +
           unit -> t

     

       159
       159
       +
         val jsont : t Jsont.t

     

       160
       160
       +
         val pp : Format.formatter -> t -> unit

     

       161
       161
       +
       end

+356

claudeio/lib_mcp/client_session.ml

···

       1
       1
       +
       (** High-level MCP client session implementation *)

     

       2
       2
       +
       

     

       3
       3
       +
       (** {1 Configuration} *)

     

       4
       4
       +
       

     

       5
       5
       +
       type config = {

     

       6
       6
       +
         client_info : Capabilities.Implementation.t;

     

       7
       7
       +
         client_capabilities : Capabilities.Client.t;

     

       8
       8
       +
       }

     

       9
       9
       +
       

     

       10
       10
       +
       (** {1 Internal State} *)

     

       11
       11
       +
       

     

       12
       12
       +
       exception Initialization_error of string

     

       13
       13
       +
       

     

       14
       14
       +
       type notification_handlers = {

     

       15
       15
       +
         mutable on_resource_updated : (uri:string -> unit) option;

     

       16
       16
       +
         mutable on_resource_list_changed : (unit -> unit) option;

     

       17
       17
       +
         mutable on_tool_list_changed : (unit -> unit) option;

     

       18
       18
       +
         mutable on_prompt_list_changed : (unit -> unit) option;

     

       19
       19
       +
         mutable on_log_message : (level:Messages.Logging.level -> logger:string option -> data:Jsont.json -> unit) option;

     

       20
       20
       +
       }

     

       21
       21
       +
       

     

       22
       22
       +
       type t = {

     

       23
       23
       +
         session : Session.t;

     

       24
       24
       +
         server_capabilities : Capabilities.Server.t;

     

       25
       25
       +
         server_info : Capabilities.Implementation.t;

     

       26
       26
       +
         server_instructions : string option;

     

       27
       27
       +
         handlers : notification_handlers;

     

       28
       28
       +
       }

     

       29
       29
       +
       

     

       30
       30
       +
       (** {1 Helper Functions} *)

     

       31
       31
       +
       

     

       32
       32
       +
       (* Encode a value to JSON using jsont codec *)

     

       33
       33
       +
       let encode codec value =

     

       34
       34
       +
         match Jsont.Json.encode codec value with

     

       35
       35
       +
         | Ok json -> json

     

       36
       36
       +
         | Error msg -> failwith ("Failed to encode: " ^ msg)

     

       37
       37
       +
       

     

       38
       38
       +
       (* Decode a JSON value using jsont codec *)

     

       39
       39
       +
       let decode codec json =

     

       40
       40
       +
         match Jsont.Json.decode codec json with

     

       41
       41
       +
         | Ok value -> value

     

       42
       42
       +
         | Error msg -> failwith ("Failed to decode: " ^ msg)

     

       43
       43
       +
       

     

       44
       44
       +
       (* Parse notification parameters - returns None if params is None or null *)

     

       45
       45
       +
       let parse_notification_params codec params_opt =

     

       46
       46
       +
         match params_opt with

     

       47
       47
       +
         | None -> None

     

       48
       48
       +
         | Some (Jsont.Null _) -> None

     

       49
       49
       +
         | Some json -> Some (decode codec json)

     

       50
       50
       +
       

     

       51
       51
       +
       (** {1 Notification Routing} *)

     

       52
       52
       +
       

     

       53
       53
       +
       let create_notification_handler handlers : Session.notification_handler =

     

       54
       54
       +
         fun ~method_ ~params ->

     

       55
       55
       +
           match method_ with

     

       56
       56
       +
           | "notifications/resources/updated" ->

     

       57
       57
       +
               (match handlers.on_resource_updated with

     

       58
       58
       +
               | None -> ()

     

       59
       59
       +
               | Some handler ->

     

       60
       60
       +
                   let notif = parse_notification_params

     

       61
       61
       +
                     Messages.Resources.updated_notification_jsont params in

     

       62
       62
       +
                   (match notif with

     

       63
       63
       +
                   | None -> ()

     

       64
       64
       +
                   | Some n -> handler ~uri:n.Messages.Resources.uri))

     

       65
       65
       +
       

     

       66
       66
       +
           | "notifications/resources/list_changed" ->

     

       67
       67
       +
               (match handlers.on_resource_list_changed with

     

       68
       68
       +
               | None -> ()

     

       69
       69
       +
               | Some handler -> handler ())

     

       70
       70
       +
       

     

       71
       71
       +
           | "notifications/tools/list_changed" ->

     

       72
       72
       +
               (match handlers.on_tool_list_changed with

     

       73
       73
       +
               | None -> ()

     

       74
       74
       +
               | Some handler -> handler ())

     

       75
       75
       +
       

     

       76
       76
       +
           | "notifications/prompts/list_changed" ->

     

       77
       77
       +
               (match handlers.on_prompt_list_changed with

     

       78
       78
       +
               | None -> ()

     

       79
       79
       +
               | Some handler -> handler ())

     

       80
       80
       +
       

     

       81
       81
       +
           | "notifications/message" ->

     

       82
       82
       +
               (match handlers.on_log_message with

     

       83
       83
       +
               | None -> ()

     

       84
       84
       +
               | Some handler ->

     

       85
       85
       +
                   let notif = parse_notification_params

     

       86
       86
       +
                     Messages.Logging.notification_jsont params in

     

       87
       87
       +
                   (match notif with

     

       88
       88
       +
                   | None -> ()

     

       89
       89
       +
                   | Some n ->

     

       90
       90
       +
                       let data = match n.Messages.Logging.data with

     

       91
       91
       +
                         | None -> Jsont.Null ((), Jsont.Meta.none)

     

       92
       92
       +
                         | Some d -> d

     

       93
       93
       +
                       in

     

       94
       94
       +
                       handler

     

       95
       95
       +
                         ~level:n.Messages.Logging.level

     

       96
       96
       +
                         ~logger:n.Messages.Logging.logger

     

       97
       97
       +
                         ~data))

     

       98
       98
       +
       

     

       99
       99
       +
           | _ ->

     

       100
       100
       +
               (* Unknown notification - ignore *)

     

       101
       101
       +
               ()

     

       102
       102
       +
       

     

       103
       103
       +
       (** {1 Request Handler} *)

     

       104
       104
       +
       

     

       105
       105
       +
       (* Client doesn't expect to receive requests from server in most cases *)

     

       106
       106
       +
       let create_request_handler () : Session.request_handler =

     

       107
       107
       +
         fun ~method_ ~params:_ ->

     

       108
       108
       +
           (* Default: return method not found error *)

     

       109
       109
       +
           let error = Jsonrpc.Error_data.make

     

       110
       110
       +
             ~code:Method_not_found

     

       111
       111
       +
             ~message:(Printf.sprintf "Client does not handle method: %s" method_)

     

       112
       112
       +
             ()

     

       113
       113
       +
           in

     

       114
       114
       +
           raise (Session.Remote_error error)

     

       115
       115
       +
       

     

       116
       116
       +
       (** {1 Initialization} *)

     

       117
       117
       +
       

     

       118
       118
       +
       let perform_initialization session config =

     

       119
       119
       +
         (* Send Initialize request *)

     

       120
       120
       +
         let init_params = Messages.Initialize.make_request_params

     

       121
       121
       +
           ~protocol_version:"2024-11-05"

     

       122
       122
       +
           ~capabilities:config.client_capabilities

     

       123
       123
       +
           ~client_info:config.client_info

     

       124
       124
       +
           ()

     

       125
       125
       +
         in

     

       126
       126
       +
         let params_json = encode Messages.Initialize.request_params_jsont init_params in

     

       127
       127
       +
       

     

       128
       128
       +
         let response_json = Session.send_request session

     

       129
       129
       +
           ~method_:Messages.Initialize.method_

     

       130
       130
       +
           ~params:params_json

     

       131
       131
       +
           ()

     

       132
       132
       +
         in

     

       133
       133
       +
       

     

       134
       134
       +
         (* Decode Initialize result *)

     

       135
       135
       +
         let init_result = decode Messages.Initialize.result_jsont response_json in

     

       136
       136
       +
       

     

       137
       137
       +
         (* Send Initialized notification *)

     

       138
       138
       +
         let initialized_notif = Messages.Initialized.make_notification () in

     

       139
       139
       +
         let notif_json = encode Messages.Initialized.notification_jsont initialized_notif in

     

       140
       140
       +
         Session.send_notification session

     

       141
       141
       +
           ~method_:Messages.Initialized.method_

     

       142
       142
       +
           ~params:notif_json

     

       143
       143
       +
           ();

     

       144
       144
       +
       

     

       145
       145
       +
         (* Return server info *)

     

       146
       146
       +
         (init_result.Messages.Initialize.capabilities,

     

       147
       147
       +
          init_result.Messages.Initialize.server_info,

     

       148
       148
       +
          init_result.Messages.Initialize.instructions)

     

       149
       149
       +
       

     

       150
       150
       +
       (** {1 Public API} *)

     

       151
       151
       +
       

     

       152
       152
       +
       let create ~sw ~transport ?timeout ?clock config =

     

       153
       153
       +
         (* Create notification handlers *)

     

       154
       154
       +
         let handlers = {

     

       155
       155
       +
           on_resource_updated = None;

     

       156
       156
       +
           on_resource_list_changed = None;

     

       157
       157
       +
           on_tool_list_changed = None;

     

       158
       158
       +
           on_prompt_list_changed = None;

     

       159
       159
       +
           on_log_message = None;

     

       160
       160
       +
         } in

     

       161
       161
       +
       

     

       162
       162
       +
         (* Create session config *)

     

       163
       163
       +
         let session_config : Session.config = {

     

       164
       164
       +
           transport;

     

       165
       165
       +
           request_handler = create_request_handler ();

     

       166
       166
       +
           notification_handler = create_notification_handler handlers;

     

       167
       167
       +
           timeout;

     

       168
       168
       +
           clock;

     

       169
       169
       +
         } in

     

       170
       170
       +
       

     

       171
       171
       +
         (* Create underlying session *)

     

       172
       172
       +
         let session = Session.create ~sw session_config in

     

       173
       173
       +
       

     

       174
       174
       +
         try

     

       175
       175
       +
           (* Perform initialization handshake *)

     

       176
       176
       +
           let (server_capabilities, server_info, server_instructions) =

     

       177
       177
       +
             perform_initialization session config

     

       178
       178
       +
           in

     

       179
       179
       +
       

     

       180
       180
       +
           (* Return client session *)

     

       181
       181
       +
           {

     

       182
       182
       +
             session;

     

       183
       183
       +
             server_capabilities;

     

       184
       184
       +
             server_info;

     

       185
       185
       +
             server_instructions;

     

       186
       186
       +
             handlers;

     

       187
       187
       +
           }

     

       188
       188
       +
         with

     

       189
       189
       +
         | Session.Remote_error err ->

     

       190
       190
       +
             Session.close session;

     

       191
       191
       +
             raise (Initialization_error

     

       192
       192
       +
               (Printf.sprintf "Server returned error: %s" err.Jsonrpc.Error_data.message))

     

       193
       193
       +
         | Session.Timeout msg ->

     

       194
       194
       +
             Session.close session;

     

       195
       195
       +
             raise (Initialization_error ("Initialization timeout: " ^ msg))

     

       196
       196
       +
         | exn ->

     

       197
       197
       +
             Session.close session;

     

       198
       198
       +
             raise (Initialization_error

     

       199
       199
       +
               (Printf.sprintf "Initialization failed: %s" (Printexc.to_string exn)))

     

       200
       200
       +
       

     

       201
       201
       +
       (** {1 Server Information} *)

     

       202
       202
       +
       

     

       203
       203
       +
       let server_capabilities t = t.server_capabilities

     

       204
       204
       +
       let server_info t = t.server_info

     

       205
       205
       +
       let server_instructions t = t.server_instructions

     

       206
       206
       +
       

     

       207
       207
       +
       (** {1 Basic Operations} *)

     

       208
       208
       +
       

     

       209
       209
       +
       let ping t =

     

       210
       210
       +
         let params = Messages.Ping.make_params () in

     

       211
       211
       +
         let params_json = encode Messages.Ping.params_jsont params in

     

       212
       212
       +
         let response_json = Session.send_request t.session

     

       213
       213
       +
           ~method_:Messages.Ping.method_

     

       214
       214
       +
           ~params:params_json

     

       215
       215
       +
           ()

     

       216
       216
       +
         in

     

       217
       217
       +
         let _result = decode Messages.Ping.result_jsont response_json in

     

       218
       218
       +
         ()

     

       219
       219
       +
       

     

       220
       220
       +
       (** {1 Resources} *)

     

       221
       221
       +
       

     

       222
       222
       +
       let list_resources t ?cursor () =

     

       223
       223
       +
         let request = Messages.Resources.make_list_request ?cursor () in

     

       224
       224
       +
         let params_json = encode Messages.Resources.list_request_jsont request in

     

       225
       225
       +
         let response_json = Session.send_request t.session

     

       226
       226
       +
           ~method_:Messages.Resources.list_method

     

       227
       227
       +
           ~params:params_json

     

       228
       228
       +
           ()

     

       229
       229
       +
         in

     

       230
       230
       +
         decode Messages.Resources.list_result_jsont response_json

     

       231
       231
       +
       

     

       232
       232
       +
       let read_resource t ~uri =

     

       233
       233
       +
         let request = Messages.Resources.make_read_request ~uri in

     

       234
       234
       +
         let params_json = encode Messages.Resources.read_request_jsont request in

     

       235
       235
       +
         let response_json = Session.send_request t.session

     

       236
       236
       +
           ~method_:Messages.Resources.read_method

     

       237
       237
       +
           ~params:params_json

     

       238
       238
       +
           ()

     

       239
       239
       +
         in

     

       240
       240
       +
         decode Messages.Resources.read_result_jsont response_json

     

       241
       241
       +
       

     

       242
       242
       +
       let subscribe_resource t ~uri =

     

       243
       243
       +
         let request = Messages.Resources.make_subscribe_request ~uri in

     

       244
       244
       +
         let params_json = encode Messages.Resources.subscribe_request_jsont request in

     

       245
       245
       +
         let _response_json = Session.send_request t.session

     

       246
       246
       +
           ~method_:Messages.Resources.subscribe_method

     

       247
       247
       +
           ~params:params_json

     

       248
       248
       +
           ()

     

       249
       249
       +
         in

     

       250
       250
       +
         ()

     

       251
       251
       +
       

     

       252
       252
       +
       let unsubscribe_resource t ~uri =

     

       253
       253
       +
         let request = Messages.Resources.make_unsubscribe_request ~uri in

     

       254
       254
       +
         let params_json = encode Messages.Resources.unsubscribe_request_jsont request in

     

       255
       255
       +
         let _response_json = Session.send_request t.session

     

       256
       256
       +
           ~method_:Messages.Resources.unsubscribe_method

     

       257
       257
       +
           ~params:params_json

     

       258
       258
       +
           ()

     

       259
       259
       +
         in

     

       260
       260
       +
         ()

     

       261
       261
       +
       

     

       262
       262
       +
       (** {1 Tools} *)

     

       263
       263
       +
       

     

       264
       264
       +
       let list_tools t ?cursor () =

     

       265
       265
       +
         let request = Messages.Tools.make_list_request ?cursor () in

     

       266
       266
       +
         let params_json = encode Messages.Tools.list_request_jsont request in

     

       267
       267
       +
         let response_json = Session.send_request t.session

     

       268
       268
       +
           ~method_:Messages.Tools.list_method

     

       269
       269
       +
           ~params:params_json

     

       270
       270
       +
           ()

     

       271
       271
       +
         in

     

       272
       272
       +
         decode Messages.Tools.list_result_jsont response_json

     

       273
       273
       +
       

     

       274
       274
       +
       let call_tool t ~name ?arguments () =

     

       275
       275
       +
         let request = Messages.Tools.make_call_request ~name ?arguments () in

     

       276
       276
       +
         let params_json = encode Messages.Tools.call_request_jsont request in

     

       277
       277
       +
         let response_json = Session.send_request t.session

     

       278
       278
       +
           ~method_:Messages.Tools.call_method

     

       279
       279
       +
           ~params:params_json

     

       280
       280
       +
           ()

     

       281
       281
       +
         in

     

       282
       282
       +
         decode Messages.Tools.call_result_jsont response_json

     

       283
       283
       +
       

     

       284
       284
       +
       (** {1 Prompts} *)

     

       285
       285
       +
       

     

       286
       286
       +
       let list_prompts t ?cursor () =

     

       287
       287
       +
         let request = Messages.Prompts.make_list_request ?cursor () in

     

       288
       288
       +
         let params_json = encode Messages.Prompts.list_request_jsont request in

     

       289
       289
       +
         let response_json = Session.send_request t.session

     

       290
       290
       +
           ~method_:Messages.Prompts.list_method

     

       291
       291
       +
           ~params:params_json

     

       292
       292
       +
           ()

     

       293
       293
       +
         in

     

       294
       294
       +
         decode Messages.Prompts.list_result_jsont response_json

     

       295
       295
       +
       

     

       296
       296
       +
       let get_prompt t ~name ?arguments () =

     

       297
       297
       +
         let request = Messages.Prompts.make_get_request ~name ?arguments () in

     

       298
       298
       +
         let params_json = encode Messages.Prompts.get_request_jsont request in

     

       299
       299
       +
         let response_json = Session.send_request t.session

     

       300
       300
       +
           ~method_:Messages.Prompts.get_method

     

       301
       301
       +
           ~params:params_json

     

       302
       302
       +
           ()

     

       303
       303
       +
         in

     

       304
       304
       +
         decode Messages.Prompts.get_result_jsont response_json

     

       305
       305
       +
       

     

       306
       306
       +
       (** {1 Completions} *)

     

       307
       307
       +
       

     

       308
       308
       +
       let complete t ~ref ~argument =

     

       309
       309
       +
         let request = Messages.Completions.make_request ~ref_:ref ~argument () in

     

       310
       310
       +
         let params_json = encode Messages.Completions.request_jsont request in

     

       311
       311
       +
         let response_json = Session.send_request t.session

     

       312
       312
       +
           ~method_:Messages.Completions.method_

     

       313
       313
       +
           ~params:params_json

     

       314
       314
       +
           ()

     

       315
       315
       +
         in

     

       316
       316
       +
         decode Messages.Completions.result_jsont response_json

     

       317
       317
       +
       

     

       318
       318
       +
       (** {1 Logging} *)

     

       319
       319
       +
       

     

       320
       320
       +
       let set_log_level t level =

     

       321
       321
       +
         (* Create a simple request with level parameter *)

     

       322
       322
       +
         let level_json = encode Messages.Logging.level_jsont level in

     

       323
       323
       +
         let params = Jsont.Object ([

     

       324
       324
       +
           (("level", Jsont.Meta.none), level_json)

     

       325
       325
       +
         ], Jsont.Meta.none) in

     

       326
       326
       +
         let _response_json = Session.send_request t.session

     

       327
       327
       +
           ~method_:"logging/setLevel"

     

       328
       328
       +
           ~params

     

       329
       329
       +
           ()

     

       330
       330
       +
         in

     

       331
       331
       +
         ()

     

       332
       332
       +
       

     

       333
       333
       +
       (** {1 Notification Handlers} *)

     

       334
       334
       +
       

     

       335
       335
       +
       let on_resource_updated t handler =

     

       336
       336
       +
         t.handlers.on_resource_updated <- Some handler

     

       337
       337
       +
       

     

       338
       338
       +
       let on_resource_list_changed t handler =

     

       339
       339
       +
         t.handlers.on_resource_list_changed <- Some handler

     

       340
       340
       +
       

     

       341
       341
       +
       let on_tool_list_changed t handler =

     

       342
       342
       +
         t.handlers.on_tool_list_changed <- Some handler

     

       343
       343
       +
       

     

       344
       344
       +
       let on_prompt_list_changed t handler =

     

       345
       345
       +
         t.handlers.on_prompt_list_changed <- Some handler

     

       346
       346
       +
       

     

       347
       347
       +
       let on_log_message t handler =

     

       348
       348
       +
         t.handlers.on_log_message <- Some handler

     

       349
       349
       +
       

     

       350
       350
       +
       (** {1 Session Control} *)

     

       351
       351
       +
       

     

       352
       352
       +
       let close t =

     

       353
       353
       +
         Session.close t.session

     

       354
       354
       +
       

     

       355
       355
       +
       let is_closed t =

     

       356
       356
       +
         Session.is_closed t.session

+217

claudeio/lib_mcp/client_session.mli

···

       1
       1
       +
       (** High-level MCP client session API.

     

       2
       2
       +
       

     

       3
       3
       +
           This module provides a high-level client API for connecting to MCP servers.

     

       4
       4
       +
           It handles the initialization handshake, capability negotiation, and provides

     

       5
       5
       +
           typed methods for all MCP protocol operations.

     

       6
       6
       +
       

     

       7
       7
       +
           {1 Example Usage}

     

       8
       8
       +
       

     

       9
       9
       +
           {[

     

       10
       10
       +
             Eio_main.run @@ fun env ->

     

       11
       11
       +
             Eio.Switch.run @@ fun sw ->

     

       12
       12
       +
               let transport = Transport_stdio.create ~sw (module Eio.Stdenv : Eio.Stdenv.S with type t = _) env in

     

       13
       13
       +
       

     

       14
       14
       +
               let config = {

     

       15
       15
       +
                 client_info = Capabilities.Implementation.make

     

       16
       16
       +
                   ~name:"my-client"

     

       17
       17
       +
                   ~version:"1.0.0";

     

       18
       18
       +
                 client_capabilities = Capabilities.Client.make

     

       19
       19
       +
                   ~roots:(Capabilities.Roots.make ~list_changed:true ())

     

       20
       20
       +
                   ();

     

       21
       21
       +
               } in

     

       22
       22
       +
       

     

       23
       23
       +
               let client = Client_session.create ~sw ~transport config in

     

       24
       24
       +
       

     

       25
       25
       +
               (* List available tools *)

     

       26
       26
       +
               let tools_result = Client_session.list_tools client () in

     

       27
       27
       +
               List.iter (fun tool ->

     

       28
       28
       +
                 Printf.printf "Tool: %s\n" tool.Messages.Tools.name

     

       29
       29
       +
               ) tools_result.Messages.Tools.tools;

     

       30
       30
       +
       

     

       31
       31
       +
               (* Call a tool *)

     

       32
       32
       +
               let args = `Object [("query", `String "hello")] in

     

       33
       33
       +
               let result = Client_session.call_tool client

     

       34
       34
       +
                 ~name:"search"

     

       35
       35
       +
                 ~arguments:args

     

       36
       36
       +
                 ()

     

       37
       37
       +
               in

     

       38
       38
       +
       

     

       39
       39
       +
               Client_session.close client

     

       40
       40
       +
           ]} *)

     

       41
       41
       +
       

     

       42
       42
       +
       (** {1 Configuration} *)

     

       43
       43
       +
       

     

       44
       44
       +
       type config = {

     

       45
       45
       +
         client_info : Capabilities.Implementation.t;

     

       46
       46
       +
         (** Client implementation information (name and version) *)

     

       47
       47
       +
         client_capabilities : Capabilities.Client.t;

     

       48
       48
       +
         (** Client capabilities to advertise to server *)

     

       49
       49
       +
       }

     

       50
       50
       +
       (** Client session configuration *)

     

       51
       51
       +
       

     

       52
       52
       +
       (** {1 Session Management} *)

     

       53
       53
       +
       

     

       54
       54
       +
       type t

     

       55
       55
       +
       (** Client session handle *)

     

       56
       56
       +
       

     

       57
       57
       +
       exception Initialization_error of string

     

       58
       58
       +
       (** Raised when initialization handshake fails *)

     

       59
       59
       +
       

     

       60
       60
       +
       val create :

     

       61
       61
       +
         sw:Eio.Switch.t ->

     

       62
       62
       +
         transport:Transport.t ->

     

       63
       63
       +
         ?timeout:float ->

     

       64
       64
       +
         ?clock:Session.clock ->

     

       65
       65
       +
         config ->

     

       66
       66
       +
         t

     

       67
       67
       +
       (** Create a client session and perform the initialization handshake.

     

       68
       68
       +
       

     

       69
       69
       +
           This sends an Initialize request to the server, stores the server's

     

       70
       70
       +
           capabilities and info, then sends an Initialized notification.

     

       71
       71
       +
       

     

       72
       72
       +
           @param sw Switch for background fibers

     

       73
       73
       +
           @param transport Transport layer for communication

     

       74
       74
       +
           @param timeout Optional request timeout in seconds

     

       75
       75
       +
           @param clock Clock for timeout handling (required if timeout is set)

     

       76
       76
       +
           @param config Client configuration

     

       77
       77
       +
           @raise Initialization_error if the handshake fails

     

       78
       78
       +
           @raise Session.Remote_error if the server returns an error

     

       79
       79
       +
           @raise Session.Timeout if the initialize request times out *)

     

       80
       80
       +
       

     

       81
       81
       +
       (** {1 Server Information} *)

     

       82
       82
       +
       

     

       83
       83
       +
       val server_capabilities : t -> Capabilities.Server.t

     

       84
       84
       +
       (** Get the server's advertised capabilities from initialization *)

     

       85
       85
       +
       

     

       86
       86
       +
       val server_info : t -> Capabilities.Implementation.t

     

       87
       87
       +
       (** Get the server's implementation info (name and version) *)

     

       88
       88
       +
       

     

       89
       89
       +
       val server_instructions : t -> string option

     

       90
       90
       +
       (** Get optional server instructions from initialization *)

     

       91
       91
       +
       

     

       92
       92
       +
       (** {1 Basic Operations} *)

     

       93
       93
       +
       

     

       94
       94
       +
       val ping : t -> unit

     

       95
       95
       +
       (** Send a ping request to the server (keepalive).

     

       96
       96
       +
           @raise Session.Remote_error if the server returns an error

     

       97
       97
       +
           @raise Session.Timeout if the request times out

     

       98
       98
       +
           @raise Session.Session_closed if the session is closed *)

     

       99
       99
       +
       

     

       100
       100
       +
       (** {1 Resources} *)

     

       101
       101
       +
       

     

       102
       102
       +
       val list_resources : t -> ?cursor:string -> unit -> Messages.Resources.list_result

     

       103
       103
       +
       (** List available resources.

     

       104
       104
       +
           @param cursor Optional pagination cursor

     

       105
       105
       +
           @raise Session.Remote_error if the server returns an error

     

       106
       106
       +
           @raise Session.Timeout if the request times out

     

       107
       107
       +
           @raise Session.Session_closed if the session is closed *)

     

       108
       108
       +
       

     

       109
       109
       +
       val read_resource : t -> uri:string -> Messages.Resources.read_result

     

       110
       110
       +
       (** Read resource contents by URI.

     

       111
       111
       +
           @param uri Resource URI to read

     

       112
       112
       +
           @raise Session.Remote_error if the server returns an error

     

       113
       113
       +
           @raise Session.Timeout if the request times out

     

       114
       114
       +
           @raise Session.Session_closed if the session is closed *)

     

       115
       115
       +
       

     

       116
       116
       +
       val subscribe_resource : t -> uri:string -> unit

     

       117
       117
       +
       (** Subscribe to resource update notifications.

     

       118
       118
       +
           @param uri Resource URI to subscribe to

     

       119
       119
       +
           @raise Session.Remote_error if the server returns an error

     

       120
       120
       +
           @raise Session.Timeout if the request times out

     

       121
       121
       +
           @raise Session.Session_closed if the session is closed *)

     

       122
       122
       +
       

     

       123
       123
       +
       val unsubscribe_resource : t -> uri:string -> unit

     

       124
       124
       +
       (** Unsubscribe from resource update notifications.

     

       125
       125
       +
           @param uri Resource URI to unsubscribe from

     

       126
       126
       +
           @raise Session.Remote_error if the server returns an error

     

       127
       127
       +
           @raise Session.Timeout if the request times out

     

       128
       128
       +
           @raise Session.Session_closed if the session is closed *)

     

       129
       129
       +
       

     

       130
       130
       +
       (** {1 Tools} *)

     

       131
       131
       +
       

     

       132
       132
       +
       val list_tools : t -> ?cursor:string -> unit -> Messages.Tools.list_result

     

       133
       133
       +
       (** List available tools.

     

       134
       134
       +
           @param cursor Optional pagination cursor

     

       135
       135
       +
           @raise Session.Remote_error if the server returns an error

     

       136
       136
       +
           @raise Session.Timeout if the request times out

     

       137
       137
       +
           @raise Session.Session_closed if the session is closed *)

     

       138
       138
       +
       

     

       139
       139
       +
       val call_tool : t -> name:string -> ?arguments:Jsont.json -> unit -> Messages.Tools.call_result

     

       140
       140
       +
       (** Call a tool by name.

     

       141
       141
       +
           @param name Tool name

     

       142
       142
       +
           @param arguments Optional tool arguments (JSON object)

     

       143
       143
       +
           @raise Session.Remote_error if the server returns an error

     

       144
       144
       +
           @raise Session.Timeout if the request times out

     

       145
       145
       +
           @raise Session.Session_closed if the session is closed *)

     

       146
       146
       +
       

     

       147
       147
       +
       (** {1 Prompts} *)

     

       148
       148
       +
       

     

       149
       149
       +
       val list_prompts : t -> ?cursor:string -> unit -> Messages.Prompts.list_result

     

       150
       150
       +
       (** List available prompts.

     

       151
       151
       +
           @param cursor Optional pagination cursor

     

       152
       152
       +
           @raise Session.Remote_error if the server returns an error

     

       153
       153
       +
           @raise Session.Timeout if the request times out

     

       154
       154
       +
           @raise Session.Session_closed if the session is closed *)

     

       155
       155
       +
       

     

       156
       156
       +
       val get_prompt : t -> name:string -> ?arguments:(string * string) list -> unit -> Messages.Prompts.get_result

     

       157
       157
       +
       (** Get a prompt by name with optional arguments.

     

       158
       158
       +
           @param name Prompt name

     

       159
       159
       +
           @param arguments Optional key-value pairs for prompt arguments

     

       160
       160
       +
           @raise Session.Remote_error if the server returns an error

     

       161
       161
       +
           @raise Session.Timeout if the request times out

     

       162
       162
       +
           @raise Session.Session_closed if the session is closed *)

     

       163
       163
       +
       

     

       164
       164
       +
       (** {1 Completions} *)

     

       165
       165
       +
       

     

       166
       166
       +
       val complete : t -> ref:Messages.Completions.completion_ref -> argument:string -> Messages.Completions.result

     

       167
       167
       +
       (** Request auto-completion suggestions.

     

       168
       168
       +
           @param ref Completion reference (prompt or resource)

     

       169
       169
       +
           @param argument Argument value to complete

     

       170
       170
       +
           @raise Session.Remote_error if the server returns an error

     

       171
       171
       +
           @raise Session.Timeout if the request times out

     

       172
       172
       +
           @raise Session.Session_closed if the session is closed *)

     

       173
       173
       +
       

     

       174
       174
       +
       (** {1 Logging} *)

     

       175
       175
       +
       

     

       176
       176
       +
       val set_log_level : t -> Messages.Logging.level -> unit

     

       177
       177
       +
       (** Set the server's logging level.

     

       178
       178
       +
           Note: This sends a "logging/setLevel" request.

     

       179
       179
       +
           @param level Desired log level

     

       180
       180
       +
           @raise Session.Remote_error if the server returns an error

     

       181
       181
       +
           @raise Session.Timeout if the request times out

     

       182
       182
       +
           @raise Session.Session_closed if the session is closed *)

     

       183
       183
       +
       

     

       184
       184
       +
       (** {1 Notification Handlers} *)

     

       185
       185
       +
       

     

       186
       186
       +
       val on_resource_updated : t -> (uri:string -> unit) -> unit

     

       187
       187
       +
       (** Register a handler for resource update notifications.

     

       188
       188
       +
           The handler is called when a subscribed resource is updated.

     

       189
       189
       +
           Only one handler can be registered at a time (replaces previous handler). *)

     

       190
       190
       +
       

     

       191
       191
       +
       val on_resource_list_changed : t -> (unit -> unit) -> unit

     

       192
       192
       +
       (** Register a handler for resource list change notifications.

     

       193
       193
       +
           The handler is called when the list of available resources changes.

     

       194
       194
       +
           Only one handler can be registered at a time (replaces previous handler). *)

     

       195
       195
       +
       

     

       196
       196
       +
       val on_tool_list_changed : t -> (unit -> unit) -> unit

     

       197
       197
       +
       (** Register a handler for tool list change notifications.

     

       198
       198
       +
           The handler is called when the list of available tools changes.

     

       199
       199
       +
           Only one handler can be registered at a time (replaces previous handler). *)

     

       200
       200
       +
       

     

       201
       201
       +
       val on_prompt_list_changed : t -> (unit -> unit) -> unit

     

       202
       202
       +
       (** Register a handler for prompt list change notifications.

     

       203
       203
       +
           The handler is called when the list of available prompts changes.

     

       204
       204
       +
           Only one handler can be registered at a time (replaces previous handler). *)

     

       205
       205
       +
       

     

       206
       206
       +
       val on_log_message : t -> (level:Messages.Logging.level -> logger:string option -> data:Jsont.json -> unit) -> unit

     

       207
       207
       +
       (** Register a handler for log message notifications from the server.

     

       208
       208
       +
           Only one handler can be registered at a time (replaces previous handler). *)

     

       209
       209
       +
       

     

       210
       210
       +
       (** {1 Session Control} *)

     

       211
       211
       +
       

     

       212
       212
       +
       val close : t -> unit

     

       213
       213
       +
       (** Close the client session and underlying transport.

     

       214
       214
       +
           This is idempotent - safe to call multiple times. *)

     

       215
       215
       +
       

     

       216
       216
       +
       val is_closed : t -> bool

     

       217
       217
       +
       (** Check if the session is closed. *)

+246

claudeio/lib_mcp/content.ml

···

       1
       1
       +
       (** MCP Content Block types *)

     

       2
       2
       +
       

     

       3
       3
       +
       (* Annotations *)

     

       4
       4
       +
       

     

       5
       5
       +
       module Audience = struct

     

       6
       6
       +
         type t = User | Assistant

     

       7
       7
       +
       

     

       8
       8
       +
         let jsont : t Jsont.t =

     

       9
       9
       +
           Jsont.enum [

     

       10
       10
       +
             "user", User;

     

       11
       11
       +
             "assistant", Assistant;

     

       12
       12
       +
           ]

     

       13
       13
       +
       

     

       14
       14
       +
         let pp fmt = function

     

       15
       15
       +
           | User -> Format.fprintf fmt "user"

     

       16
       16
       +
           | Assistant -> Format.fprintf fmt "assistant"

     

       17
       17
       +
       end

     

       18
       18
       +
       

     

       19
       19
       +
       module Annotations = struct

     

       20
       20
       +
         type t = {

     

       21
       21
       +
           audience : Audience.t list option;

     

       22
       22
       +
           priority : float option;

     

       23
       23
       +
           unknown : Jsont.json;

     

       24
       24
       +
         }

     

       25
       25
       +
       

     

       26
       26
       +
         let empty =

     

       27
       27
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       28
       28
       +
           { audience = None; priority = None; unknown }

     

       29
       29
       +
       

     

       30
       30
       +
         let jsont : t Jsont.t =

     

       31
       31
       +
           let make audience priority unknown = { audience; priority; unknown } in

     

       32
       32
       +
           Jsont.Object.map ~kind:"Annotations" make

     

       33
       33
       +
           |> Jsont.Object.opt_mem "audience" (Jsont.list Audience.jsont)

     

       34
       34
       +
               ~enc:(fun a -> a.audience)

     

       35
       35
       +
           |> Jsont.Object.opt_mem "priority" Jsont.number

     

       36
       36
       +
               ~enc:(fun a -> a.priority)

     

       37
       37
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun a -> a.unknown)

     

       38
       38
       +
           |> Jsont.Object.finish

     

       39
       39
       +
       

     

       40
       40
       +
         let pp fmt _ann =

     

       41
       41
       +
           Format.fprintf fmt "{annotations}"

     

       42
       42
       +
       end

     

       43
       43
       +
       

     

       44
       44
       +
       (* Text Content *)

     

       45
       45
       +
       

     

       46
       46
       +
       module Text = struct

     

       47
       47
       +
         type t = {

     

       48
       48
       +
           text : string;

     

       49
       49
       +
           annotations : Annotations.t option;

     

       50
       50
       +
           unknown : Jsont.json;

     

       51
       51
       +
         }

     

       52
       52
       +
       

     

       53
       53
       +
         let make text =

     

       54
       54
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       55
       55
       +
           { text; annotations = None; unknown }

     

       56
       56
       +
       

     

       57
       57
       +
         let jsont : t Jsont.t =

     

       58
       58
       +
           let make text annotations unknown = { text; annotations; unknown } in

     

       59
       59
       +
           Jsont.Object.map ~kind:"TextContent" make

     

       60
       60
       +
           |> Jsont.Object.mem "text" Jsont.string ~enc:(fun t -> t.text)

     

       61
       61
       +
           |> Jsont.Object.opt_mem "annotations" Annotations.jsont

     

       62
       62
       +
               ~enc:(fun t -> t.annotations)

     

       63
       63
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun t -> t.unknown)

     

       64
       64
       +
           |> Jsont.Object.finish

     

       65
       65
       +
       

     

       66
       66
       +
         let pp fmt t =

     

       67
       67
       +
           Format.fprintf fmt "%S" t.text

     

       68
       68
       +
       end

     

       69
       69
       +
       

     

       70
       70
       +
       (* Image Content *)

     

       71
       71
       +
       

     

       72
       72
       +
       module Image = struct

     

       73
       73
       +
         type t = {

     

       74
       74
       +
           data : string;

     

       75
       75
       +
           mime_type : string;

     

       76
       76
       +
           annotations : Annotations.t option;

     

       77
       77
       +
           unknown : Jsont.json;

     

       78
       78
       +
         }

     

       79
       79
       +
       

     

       80
       80
       +
         let make ~data ~mime_type =

     

       81
       81
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       82
       82
       +
           { data; mime_type; annotations = None; unknown }

     

       83
       83
       +
       

     

       84
       84
       +
         let jsont : t Jsont.t =

     

       85
       85
       +
           let make data mime_type annotations unknown =

     

       86
       86
       +
             { data; mime_type; annotations; unknown }

     

       87
       87
       +
           in

     

       88
       88
       +
           Jsont.Object.map ~kind:"ImageContent" make

     

       89
       89
       +
           |> Jsont.Object.mem "data" Jsont.string ~enc:(fun i -> i.data)

     

       90
       90
       +
           |> Jsont.Object.mem "mimeType" Jsont.string ~enc:(fun i -> i.mime_type)

     

       91
       91
       +
           |> Jsont.Object.opt_mem "annotations" Annotations.jsont

     

       92
       92
       +
               ~enc:(fun i -> i.annotations)

     

       93
       93
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun i -> i.unknown)

     

       94
       94
       +
           |> Jsont.Object.finish

     

       95
       95
       +
       

     

       96
       96
       +
         let pp fmt i =

     

       97
       97
       +
           Format.fprintf fmt "Image(%s, %d bytes)" i.mime_type (String.length i.data)

     

       98
       98
       +
       end

     

       99
       99
       +
       

     

       100
       100
       +
       (* Audio Content *)

     

       101
       101
       +
       

     

       102
       102
       +
       module Audio = struct

     

       103
       103
       +
         type t = {

     

       104
       104
       +
           data : string;

     

       105
       105
       +
           mime_type : string;

     

       106
       106
       +
           annotations : Annotations.t option;

     

       107
       107
       +
           unknown : Jsont.json;

     

       108
       108
       +
         }

     

       109
       109
       +
       

     

       110
       110
       +
         let make ~data ~mime_type =

     

       111
       111
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       112
       112
       +
           { data; mime_type; annotations = None; unknown }

     

       113
       113
       +
       

     

       114
       114
       +
         let jsont : t Jsont.t =

     

       115
       115
       +
           let make data mime_type annotations unknown =

     

       116
       116
       +
             { data; mime_type; annotations; unknown }

     

       117
       117
       +
           in

     

       118
       118
       +
           Jsont.Object.map ~kind:"AudioContent" make

     

       119
       119
       +
           |> Jsont.Object.mem "data" Jsont.string ~enc:(fun a -> a.data)

     

       120
       120
       +
           |> Jsont.Object.mem "mimeType" Jsont.string ~enc:(fun a -> a.mime_type)

     

       121
       121
       +
           |> Jsont.Object.opt_mem "annotations" Annotations.jsont

     

       122
       122
       +
               ~enc:(fun a -> a.annotations)

     

       123
       123
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun a -> a.unknown)

     

       124
       124
       +
           |> Jsont.Object.finish

     

       125
       125
       +
       

     

       126
       126
       +
         let pp fmt a =

     

       127
       127
       +
           Format.fprintf fmt "Audio(%s, %d bytes)" a.mime_type (String.length a.data)

     

       128
       128
       +
       end

     

       129
       129
       +
       

     

       130
       130
       +
       (* Embedded Resource *)

     

       131
       131
       +
       

     

       132
       132
       +
       module Embedded_resource = struct

     

       133
       133
       +
         type resource = {

     

       134
       134
       +
           uri : string;

     

       135
       135
       +
           mime_type : string option;

     

       136
       136
       +
           text : string option;

     

       137
       137
       +
           blob : string option;

     

       138
       138
       +
           unknown : Jsont.json;

     

       139
       139
       +
         }

     

       140
       140
       +
       

     

       141
       141
       +
         let resource_jsont : resource Jsont.t =

     

       142
       142
       +
           let make uri mime_type text blob unknown =

     

       143
       143
       +
             { uri; mime_type; text; blob; unknown }

     

       144
       144
       +
           in

     

       145
       145
       +
           Jsont.Object.map ~kind:"Resource" make

     

       146
       146
       +
           |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)

     

       147
       147
       +
           |> Jsont.Object.opt_mem "mimeType" Jsont.string ~enc:(fun r -> r.mime_type)

     

       148
       148
       +
           |> Jsont.Object.opt_mem "text" Jsont.string ~enc:(fun r -> r.text)

     

       149
       149
       +
           |> Jsont.Object.opt_mem "blob" Jsont.string ~enc:(fun r -> r.blob)

     

       150
       150
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)

     

       151
       151
       +
           |> Jsont.Object.finish

     

       152
       152
       +
       

     

       153
       153
       +
         type t = {

     

       154
       154
       +
           resource : resource;

     

       155
       155
       +
           annotations : Annotations.t option;

     

       156
       156
       +
           unknown : Jsont.json;

     

       157
       157
       +
         }

     

       158
       158
       +
       

     

       159
       159
       +
         let make_text ~uri ~text ?mime_type () =

     

       160
       160
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       161
       161
       +
           let resource = {

     

       162
       162
       +
             uri;

     

       163
       163
       +
             mime_type;

     

       164
       164
       +
             text = Some text;

     

       165
       165
       +
             blob = None;

     

       166
       166
       +
             unknown;

     

       167
       167
       +
           } in

     

       168
       168
       +
           { resource; annotations = None; unknown }

     

       169
       169
       +
       

     

       170
       170
       +
         let make_blob ~uri ~blob ~mime_type =

     

       171
       171
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       172
       172
       +
           let resource = {

     

       173
       173
       +
             uri;

     

       174
       174
       +
             mime_type = Some mime_type;

     

       175
       175
       +
             text = None;

     

       176
       176
       +
             blob = Some blob;

     

       177
       177
       +
             unknown;

     

       178
       178
       +
           } in

     

       179
       179
       +
           { resource; annotations = None; unknown }

     

       180
       180
       +
       

     

       181
       181
       +
         let jsont : t Jsont.t =

     

       182
       182
       +
           let make resource annotations unknown =

     

       183
       183
       +
             { resource; annotations; unknown }

     

       184
       184
       +
           in

     

       185
       185
       +
           Jsont.Object.map ~kind:"EmbeddedResource" make

     

       186
       186
       +
           |> Jsont.Object.mem "resource" resource_jsont ~enc:(fun e -> e.resource)

     

       187
       187
       +
           |> Jsont.Object.opt_mem "annotations" Annotations.jsont

     

       188
       188
       +
               ~enc:(fun e -> e.annotations)

     

       189
       189
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun e -> e.unknown)

     

       190
       190
       +
           |> Jsont.Object.finish

     

       191
       191
       +
       

     

       192
       192
       +
         let pp fmt e =

     

       193
       193
       +
           Format.fprintf fmt "Resource(%s)" e.resource.uri

     

       194
       194
       +
       end

     

       195
       195
       +
       

     

       196
       196
       +
       (* Content Block *)

     

       197
       197
       +
       

     

       198
       198
       +
       type block =

     

       199
       199
       +
         | Text of Text.t

     

       200
       200
       +
         | Image of Image.t

     

       201
       201
       +
         | Audio of Audio.t

     

       202
       202
       +
         | Embedded_resource of Embedded_resource.t

     

       203
       203
       +
       

     

       204
       204
       +
       let block_jsont : block Jsont.t =

     

       205
       205
       +
         (* Content blocks use "type" discriminator *)

     

       206
       206
       +
         let case_map kind obj dec = Jsont.Object.Case.map kind obj ~dec in

     

       207
       207
       +
       

     

       208
       208
       +
         let case_text = case_map "text" Text.jsont (fun v -> Text v) in

     

       209
       209
       +
         let case_image = case_map "image" Image.jsont (fun v -> Image v) in

     

       210
       210
       +
         let case_audio = case_map "audio" Audio.jsont (fun v -> Audio v) in

     

       211
       211
       +
         let case_resource = case_map "resource" Embedded_resource.jsont

     

       212
       212
       +
           (fun v -> Embedded_resource v)

     

       213
       213
       +
         in

     

       214
       214
       +
       

     

       215
       215
       +
         let enc_case = function

     

       216
       216
       +
           | Text v -> Jsont.Object.Case.value case_text v

     

       217
       217
       +
           | Image v -> Jsont.Object.Case.value case_image v

     

       218
       218
       +
           | Audio v -> Jsont.Object.Case.value case_audio v

     

       219
       219
       +
           | Embedded_resource v -> Jsont.Object.Case.value case_resource v

     

       220
       220
       +
         in

     

       221
       221
       +
       

     

       222
       222
       +
         let cases = Jsont.Object.Case.[

     

       223
       223
       +
           make case_text;

     

       224
       224
       +
           make case_image;

     

       225
       225
       +
           make case_audio;

     

       226
       226
       +
           make case_resource;

     

       227
       227
       +
         ] in

     

       228
       228
       +
       

     

       229
       229
       +
         Jsont.Object.map ~kind:"ContentBlock" Fun.id

     

       230
       230
       +
         |> Jsont.Object.case_mem "type" Jsont.string ~enc:Fun.id ~enc_case cases

     

       231
       231
       +
             ~tag_to_string:Fun.id ~tag_compare:String.compare

     

       232
       232
       +
         |> Jsont.Object.finish

     

       233
       233
       +
       

     

       234
       234
       +
       let pp_block fmt = function

     

       235
       235
       +
         | Text t -> Text.pp fmt t

     

       236
       236
       +
         | Image i -> Image.pp fmt i

     

       237
       237
       +
         | Audio a -> Audio.pp fmt a

     

       238
       238
       +
         | Embedded_resource e -> Embedded_resource.pp fmt e

     

       239
       239
       +
       

     

       240
       240
       +
       (* Convenience constructors *)

     

       241
       241
       +
       

     

       242
       242
       +
       let text s = Text (Text.make s)

     

       243
       243
       +
       

     

       244
       244
       +
       let image ~data ~mime_type = Image (Image.make ~data ~mime_type)

     

       245
       245
       +
       

     

       246
       246
       +
       let audio ~data ~mime_type = Audio (Audio.make ~data ~mime_type)

+125

claudeio/lib_mcp/content.mli

···

       1
       1
       +
       (** MCP Content Block types.

     

       2
       2
       +
       

     

       3
       3
       +
           Content blocks are the building blocks for tool results, prompts, and resource contents.

     

       4
       4
       +
           They support text, images, audio, embedded resources, and tool use/results. *)

     

       5
       5
       +
       

     

       6
       6
       +
       (** {1 Annotations} *)

     

       7
       7
       +
       

     

       8
       8
       +
       module Audience : sig

     

       9
       9
       +
         type t = User | Assistant

     

       10
       10
       +
         (** Who should see this content *)

     

       11
       11
       +
       

     

       12
       12
       +
         val jsont : t Jsont.t

     

       13
       13
       +
         val pp : Format.formatter -> t -> unit

     

       14
       14
       +
       end

     

       15
       15
       +
       

     

       16
       16
       +
       module Annotations : sig

     

       17
       17
       +
         type t = {

     

       18
       18
       +
           audience : Audience.t list option;

     

       19
       19
       +
           priority : float option;

     

       20
       20
       +
           unknown : Jsont.json;

     

       21
       21
       +
         }

     

       22
       22
       +
         (** Hints about content visibility and importance *)

     

       23
       23
       +
       

     

       24
       24
       +
         val empty : t

     

       25
       25
       +
         val jsont : t Jsont.t

     

       26
       26
       +
         val pp : Format.formatter -> t -> unit

     

       27
       27
       +
       end

     

       28
       28
       +
       

     

       29
       29
       +
       (** {1 Text Content} *)

     

       30
       30
       +
       

     

       31
       31
       +
       module Text : sig

     

       32
       32
       +
         type t = {

     

       33
       33
       +
           text : string;

     

       34
       34
       +
           annotations : Annotations.t option;

     

       35
       35
       +
           unknown : Jsont.json;

     

       36
       36
       +
         }

     

       37
       37
       +
         (** Plain text content *)

     

       38
       38
       +
       

     

       39
       39
       +
         val make : string -> t

     

       40
       40
       +
         val jsont : t Jsont.t

     

       41
       41
       +
         val pp : Format.formatter -> t -> unit

     

       42
       42
       +
       end

     

       43
       43
       +
       

     

       44
       44
       +
       (** {1 Image Content} *)

     

       45
       45
       +
       

     

       46
       46
       +
       module Image : sig

     

       47
       47
       +
         type t = {

     

       48
       48
       +
           data : string;         (** Base64-encoded image data *)

     

       49
       49
       +
           mime_type : string;    (** e.g. "image/png" *)

     

       50
       50
       +
           annotations : Annotations.t option;

     

       51
       51
       +
           unknown : Jsont.json;

     

       52
       52
       +
         }

     

       53
       53
       +
         (** Image content (base64-encoded) *)

     

       54
       54
       +
       

     

       55
       55
       +
         val make : data:string -> mime_type:string -> t

     

       56
       56
       +
         val jsont : t Jsont.t

     

       57
       57
       +
         val pp : Format.formatter -> t -> unit

     

       58
       58
       +
       end

     

       59
       59
       +
       

     

       60
       60
       +
       (** {1 Audio Content} *)

     

       61
       61
       +
       

     

       62
       62
       +
       module Audio : sig

     

       63
       63
       +
         type t = {

     

       64
       64
       +
           data : string;         (** Base64-encoded audio data *)

     

       65
       65
       +
           mime_type : string;    (** e.g. "audio/mp3" *)

     

       66
       66
       +
           annotations : Annotations.t option;

     

       67
       67
       +
           unknown : Jsont.json;

     

       68
       68
       +
         }

     

       69
       69
       +
         (** Audio content (base64-encoded) *)

     

       70
       70
       +
       

     

       71
       71
       +
         val make : data:string -> mime_type:string -> t

     

       72
       72
       +
         val jsont : t Jsont.t

     

       73
       73
       +
         val pp : Format.formatter -> t -> unit

     

       74
       74
       +
       end

     

       75
       75
       +
       

     

       76
       76
       +
       (** {1 Embedded Resource} *)

     

       77
       77
       +
       

     

       78
       78
       +
       module Embedded_resource : sig

     

       79
       79
       +
         type resource = {

     

       80
       80
       +
           uri : string;

     

       81
       81
       +
           mime_type : string option;

     

       82
       82
       +
           text : string option;

     

       83
       83
       +
           blob : string option;  (** Base64-encoded binary data *)

     

       84
       84
       +
           unknown : Jsont.json;

     

       85
       85
       +
         }

     

       86
       86
       +
         (** Resource contents *)

     

       87
       87
       +
       

     

       88
       88
       +
         type t = {

     

       89
       89
       +
           resource : resource;

     

       90
       90
       +
           annotations : Annotations.t option;

     

       91
       91
       +
           unknown : Jsont.json;

     

       92
       92
       +
         }

     

       93
       93
       +
         (** Embedded resource content *)

     

       94
       94
       +
       

     

       95
       95
       +
         val make_text : uri:string -> text:string -> ?mime_type:string -> unit -> t

     

       96
       96
       +
         val make_blob : uri:string -> blob:string -> mime_type:string -> t

     

       97
       97
       +
         val jsont : t Jsont.t

     

       98
       98
       +
         val pp : Format.formatter -> t -> unit

     

       99
       99
       +
       end

     

       100
       100
       +
       

     

       101
       101
       +
       (** {1 Content Block} *)

     

       102
       102
       +
       

     

       103
       103
       +
       type block =

     

       104
       104
       +
         | Text of Text.t

     

       105
       105
       +
         | Image of Image.t

     

       106
       106
       +
         | Audio of Audio.t

     

       107
       107
       +
         | Embedded_resource of Embedded_resource.t

     

       108
       108
       +
       (** Content block variants *)

     

       109
       109
       +
       

     

       110
       110
       +
       val block_jsont : block Jsont.t

     

       111
       111
       +
       (** Codec for content blocks (discriminated by "type" field) *)

     

       112
       112
       +
       

     

       113
       113
       +
       val pp_block : Format.formatter -> block -> unit

     

       114
       114
       +
       (** Pretty-print a content block *)

     

       115
       115
       +
       

     

       116
       116
       +
       (** {1 Convenience Constructors} *)

     

       117
       117
       +
       

     

       118
       118
       +
       val text : string -> block

     

       119
       119
       +
       (** Create a text content block *)

     

       120
       120
       +
       

     

       121
       121
       +
       val image : data:string -> mime_type:string -> block

     

       122
       122
       +
       (** Create an image content block *)

     

       123
       123
       +
       

     

       124
       124
       +
       val audio : data:string -> mime_type:string -> block

     

       125
       125
       +
       (** Create an audio content block *)

claudeio/lib_mcp/dune

···

       1
       1
       +
       (library

     

       2
       2
       +
        (name mcp)

     

       3
       3
       +
        (public_name mcp)

     

       4
       4
       +
        (libraries eio eio.unix fmt logs jsont jsont.bytesrw unix))

+279

claudeio/lib_mcp/jsonrpc.ml

···

       1
       1
       +
       (** JSON-RPC 2.0 protocol implementation *)

     

       2
       2
       +
       

     

       3
       3
       +
       (* Protocol Version *)

     

       4
       4
       +
       

     

       5
       5
       +
       type jsonrpc = [ `V2 ]

     

       6
       6
       +
       

     

       7
       7
       +
       let jsonrpc_jsont = Jsont.enum ["2.0", `V2]

     

       8
       8
       +
       

     

       9
       9
       +
       (* Request/Response Identifiers *)

     

       10
       10
       +
       

     

       11
       11
       +
       module Id = struct

     

       12
       12
       +
         type t = [ `String of string | `Number of float | `Null ]

     

       13
       13
       +
       

     

       14
       14
       +
         let jsont : t Jsont.t =

     

       15
       15
       +
           let null = Jsont.null `Null in

     

       16
       16
       +
           let string =

     

       17
       17
       +
             let dec s = `String s in

     

       18
       18
       +
             let enc = function `String s -> s | _ -> assert false in

     

       19
       19
       +
             Jsont.map ~dec ~enc Jsont.string

     

       20
       20
       +
           in

     

       21
       21
       +
           let number =

     

       22
       22
       +
             let dec n = `Number n in

     

       23
       23
       +
             let enc = function `Number n -> n | _ -> assert false in

     

       24
       24
       +
             Jsont.map ~dec ~enc Jsont.number

     

       25
       25
       +
           in

     

       26
       26
       +
           let enc = function

     

       27
       27
       +
           | `Null -> null | `String _ -> string | `Number _ -> number

     

       28
       28
       +
           in

     

       29
       29
       +
           Jsont.any ~dec_null:null ~dec_string:string ~dec_number:number ~enc ()

     

       30
       30
       +
       

     

       31
       31
       +
         let to_string = function

     

       32
       32
       +
           | `String s -> s

     

       33
       33
       +
           | `Number n -> string_of_float n

     

       34
       34
       +
           | `Null -> "null"

     

       35
       35
       +
       

     

       36
       36
       +
         let compare a b = match a, b with

     

       37
       37
       +
           | `Null, `Null -> 0

     

       38
       38
       +
           | `Null, _ -> -1

     

       39
       39
       +
           | _, `Null -> 1

     

       40
       40
       +
           | `String s1, `String s2 -> String.compare s1 s2

     

       41
       41
       +
           | `String _, _ -> -1

     

       42
       42
       +
           | _, `String _ -> 1

     

       43
       43
       +
           | `Number n1, `Number n2 -> Float.compare n1 n2

     

       44
       44
       +
       

     

       45
       45
       +
         let pp fmt = function

     

       46
       46
       +
           | `String s -> Format.fprintf fmt "%S" s

     

       47
       47
       +
           | `Number n -> Format.fprintf fmt "%g" n

     

       48
       48
       +
           | `Null -> Format.fprintf fmt "null"

     

       49
       49
       +
       end

     

       50
       50
       +
       

     

       51
       51
       +
       (* Error Codes *)

     

       52
       52
       +
       

     

       53
       53
       +
       module Error_code = struct

     

       54
       54
       +
         type t =

     

       55
       55
       +
           | Parse_error

     

       56
       56
       +
           | Invalid_request

     

       57
       57
       +
           | Method_not_found

     

       58
       58
       +
           | Invalid_params

     

       59
       59
       +
           | Internal_error

     

       60
       60
       +
           | Connection_closed

     

       61
       61
       +
           | Server_error of int

     

       62
       62
       +
           | Other of int

     

       63
       63
       +
       

     

       64
       64
       +
         let to_int = function

     

       65
       65
       +
           | Parse_error -> -32700

     

       66
       66
       +
           | Invalid_request -> -32600

     

       67
       67
       +
           | Method_not_found -> -32601

     

       68
       68
       +
           | Invalid_params -> -32602

     

       69
       69
       +
           | Internal_error -> -32603

     

       70
       70
       +
           | Connection_closed -> -32000

     

       71
       71
       +
           | Server_error n -> n

     

       72
       72
       +
           | Other n -> n

     

       73
       73
       +
       

     

       74
       74
       +
         let of_int = function

     

       75
       75
       +
           | -32700 -> Parse_error

     

       76
       76
       +
           | -32600 -> Invalid_request

     

       77
       77
       +
           | -32601 -> Method_not_found

     

       78
       78
       +
           | -32602 -> Invalid_params

     

       79
       79
       +
           | -32603 -> Internal_error

     

       80
       80
       +
           | -32000 -> Connection_closed

     

       81
       81
       +
           | n when n >= -32099 && n <= -32001 -> Server_error n

     

       82
       82
       +
           | n -> Other n

     

       83
       83
       +
       

     

       84
       84
       +
         let jsont : t Jsont.t =

     

       85
       85
       +
           let dec n = of_int n in

     

       86
       86
       +
           let enc code = to_int code in

     

       87
       87
       +
           Jsont.map ~dec ~enc Jsont.int

     

       88
       88
       +
       

     

       89
       89
       +
         let pp fmt code =

     

       90
       90
       +
           Format.fprintf fmt "%d" (to_int code)

     

       91
       91
       +
       end

     

       92
       92
       +
       

     

       93
       93
       +
       (* Error Data *)

     

       94
       94
       +
       

     

       95
       95
       +
       module Error_data = struct

     

       96
       96
       +
         type t = {

     

       97
       97
       +
           code : Error_code.t;

     

       98
       98
       +
           message : string;

     

       99
       99
       +
           data : Jsont.json option;

     

       100
       100
       +
           unknown : Jsont.json;

     

       101
       101
       +
         }

     

       102
       102
       +
       

     

       103
       103
       +
         let make ~code ~message ?data () =

     

       104
       104
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       105
       105
       +
           { code; message; data; unknown }

     

       106
       106
       +
       

     

       107
       107
       +
         let jsont : t Jsont.t =

     

       108
       108
       +
           let make code message data unknown = { code; message; data; unknown } in

     

       109
       109
       +
           Jsont.Object.map ~kind:"ErrorData" make

     

       110
       110
       +
           |> Jsont.Object.mem "code" Error_code.jsont ~enc:(fun e -> e.code)

     

       111
       111
       +
           |> Jsont.Object.mem "message" Jsont.string ~enc:(fun e -> e.message)

     

       112
       112
       +
           |> Jsont.Object.opt_mem "data" Jsont.json ~enc:(fun e -> e.data)

     

       113
       113
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun e -> e.unknown)

     

       114
       114
       +
           |> Jsont.Object.finish

     

       115
       115
       +
       

     

       116
       116
       +
         let pp fmt err =

     

       117
       117
       +
           Format.fprintf fmt "{code=%a, message=%S}" Error_code.pp err.code err.message

     

       118
       118
       +
       end

     

       119
       119
       +
       

     

       120
       120
       +
       (* Params *)

     

       121
       121
       +
       

     

       122
       122
       +
       type params = Jsont.json

     

       123
       123
       +
       

     

       124
       124
       +
       let params_jsont =

     

       125
       125
       +
         let enc = function

     

       126
       126
       +
         | Jsont.Object _ | Jsont.Array _ -> Jsont.json

     

       127
       127
       +
         | j ->

     

       128
       128
       +
             let meta = Jsont.Meta.none in

     

       129
       129
       +
             let fnd = Jsont.Sort.to_string (Jsont.Json.sort j) in

     

       130
       130
       +
             Jsont.Error.expected meta "object or array" ~fnd

     

       131
       131
       +
         in

     

       132
       132
       +
         let kind = "JSON-RPC params" in

     

       133
       133
       +
         Jsont.any ~kind ~dec_array:Jsont.json ~dec_object:Jsont.json ~enc ()

     

       134
       134
       +
       

     

       135
       135
       +
       (* Request Message *)

     

       136
       136
       +
       

     

       137
       137
       +
       module Request = struct

     

       138
       138
       +
         type t = {

     

       139
       139
       +
           jsonrpc : jsonrpc;

     

       140
       140
       +
           method_ : string;

     

       141
       141
       +
           params : params option;

     

       142
       142
       +
           id : Id.t option;

     

       143
       143
       +
           unknown : Jsont.json;

     

       144
       144
       +
         }

     

       145
       145
       +
       

     

       146
       146
       +
         let make ~method_ ?params ?id () =

     

       147
       147
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       148
       148
       +
           { jsonrpc = `V2; method_; params; id; unknown }

     

       149
       149
       +
       

     

       150
       150
       +
         let jsont : t Jsont.t =

     

       151
       151
       +
           let make jsonrpc method_ params id unknown =

     

       152
       152
       +
             { jsonrpc; method_; params; id; unknown }

     

       153
       153
       +
           in

     

       154
       154
       +
           Jsont.Object.map ~kind:"JSONRPCRequest" make

     

       155
       155
       +
           |> Jsont.Object.mem "jsonrpc" jsonrpc_jsont ~enc:(fun r -> r.jsonrpc)

     

       156
       156
       +
           |> Jsont.Object.mem "method" Jsont.string ~enc:(fun r -> r.method_)

     

       157
       157
       +
           |> Jsont.Object.opt_mem "params" params_jsont ~enc:(fun r -> r.params)

     

       158
       158
       +
           |> Jsont.Object.opt_mem "id" Id.jsont ~enc:(fun r -> r.id)

     

       159
       159
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)

     

       160
       160
       +
           |> Jsont.Object.finish

     

       161
       161
       +
       

     

       162
       162
       +
         let pp fmt req =

     

       163
       163
       +
           let id_str = match req.id with

     

       164
       164
       +
             | Some id -> Id.to_string id

     

       165
       165
       +
             | None -> "none"

     

       166
       166
       +
           in

     

       167
       167
       +
           Format.fprintf fmt "{method=%S, id=%s}" req.method_ id_str

     

       168
       168
       +
       end

     

       169
       169
       +
       

     

       170
       170
       +
       (* Response Message *)

     

       171
       171
       +
       

     

       172
       172
       +
       module Response = struct

     

       173
       173
       +
         type t = {

     

       174
       174
       +
           jsonrpc : jsonrpc;

     

       175
       175
       +
           value : (Jsont.json, Error_data.t) result;

     

       176
       176
       +
           id : Id.t;

     

       177
       177
       +
           unknown : Jsont.json;

     

       178
       178
       +
         }

     

       179
       179
       +
       

     

       180
       180
       +
         let make_result ~id ~result =

     

       181
       181
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       182
       182
       +
           { jsonrpc = `V2; value = Ok result; id; unknown }

     

       183
       183
       +
       

     

       184
       184
       +
         let make_error ~id ~error =

     

       185
       185
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       186
       186
       +
           { jsonrpc = `V2; value = Error error; id; unknown }

     

       187
       187
       +
       

     

       188
       188
       +
         let response_result r = match r.value with Ok v -> Some v | Error _ -> None

     

       189
       189
       +
         let response_error r = match r.value with Ok _ -> None | Error e -> Some e

     

       190
       190
       +
       

     

       191
       191
       +
         let response jsonrpc result error id : t =

     

       192
       192
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       193
       193
       +
           let err_both () =

     

       194
       194
       +
             Jsont.Error.msgf Jsont.Meta.none "Both %a and %a members are defined"

     

       195
       195
       +
               Jsont.Repr.pp_code "result" Jsont.Repr.pp_code "error"

     

       196
       196
       +
           in

     

       197
       197
       +
           let err_none () =

     

       198
       198
       +
             Jsont.Error.msgf Jsont.Meta.none "Missing either %a or %a member"

     

       199
       199
       +
               Jsont.Repr.pp_code "result" Jsont.Repr.pp_code "error"

     

       200
       200
       +
           in

     

       201
       201
       +
           match result, error with

     

       202
       202
       +
           | Some result, None -> { jsonrpc; value = Ok result; id; unknown }

     

       203
       203
       +
           | None, Some error -> { jsonrpc; value = Error error; id; unknown }

     

       204
       204
       +
           | Some _ , Some _ -> err_both ()

     

       205
       205
       +
           | None, None -> err_none ()

     

       206
       206
       +
       

     

       207
       207
       +
         let jsont : t Jsont.t =

     

       208
       208
       +
           let make jsonrpc result error id unknown =

     

       209
       209
       +
             let resp = response jsonrpc result error id in

     

       210
       210
       +
             { resp with unknown }

     

       211
       211
       +
           in

     

       212
       212
       +
           Jsont.Object.map ~kind:"JSONRPCResponse" make

     

       213
       213
       +
           |> Jsont.Object.mem "jsonrpc" jsonrpc_jsont ~enc:(fun r -> r.jsonrpc)

     

       214
       214
       +
           |> Jsont.Object.opt_mem "result" Jsont.json ~enc:response_result

     

       215
       215
       +
           |> Jsont.Object.opt_mem "error" Error_data.jsont ~enc:response_error

     

       216
       216
       +
           |> Jsont.Object.mem "id" Id.jsont ~enc:(fun r -> r.id)

     

       217
       217
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)

     

       218
       218
       +
           |> Jsont.Object.finish

     

       219
       219
       +
       

     

       220
       220
       +
         let pp fmt resp =

     

       221
       221
       +
           let result_str = match resp.value with

     

       222
       222
       +
             | Ok _ -> "Ok(...)"

     

       223
       223
       +
             | Error err -> Format.asprintf "Error(%a)" Error_data.pp err

     

       224
       224
       +
           in

     

       225
       225
       +
           Format.fprintf fmt "{id=%a, %s}" Id.pp resp.id result_str

     

       226
       226
       +
       end

     

       227
       227
       +
       

     

       228
       228
       +
       (* Message Union *)

     

       229
       229
       +
       

     

       230
       230
       +
       module Message = struct

     

       231
       231
       +
         type t =

     

       232
       232
       +
           | Request of Request.t

     

       233
       233
       +
           | Response of Response.t

     

       234
       234
       +
       

     

       235
       235
       +
         let classify json =

     

       236
       236
       +
           (* Detect message type by presence of fields:

     

       237
       237
       +
              - "method" -> Request

     

       238
       238
       +
              - "result" or "error" -> Response *)

     

       239
       239
       +
           match json with

     

       240
       240
       +
           | Jsont.Object (members, _) ->

     

       241
       241
       +
               let has_method = List.exists (fun ((name, _), _) -> name = "method") members in

     

       242
       242
       +
               let has_result_or_error =

     

       243
       243
       +
                 List.exists (fun ((name, _), _) ->

     

       244
       244
       +
                   name = "result" || name = "error"

     

       245
       245
       +
                 ) members

     

       246
       246
       +
               in

     

       247
       247
       +
               if has_method then

     

       248
       248
       +
                 match Jsont.Json.decode Request.jsont json with

     

       249
       249
       +
                 | Ok req -> Request req

     

       250
       250
       +
                 | Error msg -> failwith ("Failed to decode request: " ^ msg)

     

       251
       251
       +
               else if has_result_or_error then

     

       252
       252
       +
                 match Jsont.Json.decode Response.jsont json with

     

       253
       253
       +
                 | Ok resp -> Response resp

     

       254
       254
       +
                 | Error msg -> failwith ("Failed to decode response: " ^ msg)

     

       255
       255
       +
               else

     

       256
       256
       +
                 failwith "Invalid JSON-RPC message: missing method or result/error"

     

       257
       257
       +
           | _ ->

     

       258
       258
       +
               failwith "Invalid JSON-RPC message: not an object"

     

       259
       259
       +
       

     

       260
       260
       +
         let jsont : t Jsont.t =

     

       261
       261
       +
           let enc = function

     

       262
       262
       +
             | Request req ->

     

       263
       263
       +
                 (match Jsont.Json.encode Request.jsont req with

     

       264
       264
       +
                  | Ok json -> json

     

       265
       265
       +
                  | Error msg -> failwith ("Failed to encode request: " ^ msg))

     

       266
       266
       +
             | Response resp ->

     

       267
       267
       +
                 (match Jsont.Json.encode Response.jsont resp with

     

       268
       268
       +
                  | Ok json -> json

     

       269
       269
       +
                  | Error msg -> failwith ("Failed to encode response: " ^ msg))

     

       270
       270
       +
           in

     

       271
       271
       +
           let dec json =

     

       272
       272
       +
             classify json

     

       273
       273
       +
           in

     

       274
       274
       +
           Jsont.map ~kind:"JSONRPCMessage" ~dec ~enc Jsont.json

     

       275
       275
       +
       

     

       276
       276
       +
         let pp fmt = function

     

       277
       277
       +
           | Request req -> Format.fprintf fmt "Request(%a)" Request.pp req

     

       278
       278
       +
           | Response resp -> Format.fprintf fmt "Response(%a)" Response.pp resp

     

       279
       279
       +
       end

+161

claudeio/lib_mcp/jsonrpc.mli

···

       1
       1
       +
       (** JSON-RPC 2.0 protocol implementation using jsont.

     

       2
       2
       +
       

     

       3
       3
       +
           Based on the JSON-RPC 2.0 specification: https://www.jsonrpc.org/

     

       4
       4
       +
       

     

       5
       5
       +
           This module provides type-safe encoding/decoding of JSON-RPC messages

     

       6
       6
       +
           with forward-compatible unknown field preservation. *)

     

       7
       7
       +
       

     

       8
       8
       +
       (** {1 Protocol Version} *)

     

       9
       9
       +
       

     

       10
       10
       +
       type jsonrpc = [ `V2 ]

     

       11
       11
       +
       (** JSON-RPC protocol version *)

     

       12
       12
       +
       

     

       13
       13
       +
       val jsonrpc_jsont : jsonrpc Jsont.t

     

       14
       14
       +
       (** Codec for protocol version *)

     

       15
       15
       +
       

     

       16
       16
       +
       (** {1 Request/Response Identifiers} *)

     

       17
       17
       +
       

     

       18
       18
       +
       module Id : sig

     

       19
       19
       +
         type t = [ `String of string | `Number of float | `Null ]

     

       20
       20
       +
         (** Request/response correlation ID.

     

       21
       21
       +
             Can be a string, number, or null. *)

     

       22
       22
       +
       

     

       23
       23
       +
         val jsont : t Jsont.t

     

       24
       24
       +
         (** Codec for IDs *)

     

       25
       25
       +
       

     

       26
       26
       +
         val to_string : t -> string

     

       27
       27
       +
         (** Convert ID to string representation *)

     

       28
       28
       +
       

     

       29
       29
       +
         val compare : t -> t -> int

     

       30
       30
       +
         (** Compare IDs for ordering *)

     

       31
       31
       +
       

     

       32
       32
       +
         val pp : Format.formatter -> t -> unit

     

       33
       33
       +
         (** Pretty-print an ID *)

     

       34
       34
       +
       end

     

       35
       35
       +
       

     

       36
       36
       +
       (** {1 Error Codes} *)

     

       37
       37
       +
       

     

       38
       38
       +
       module Error_code : sig

     

       39
       39
       +
         type t =

     

       40
       40
       +
           | Parse_error           (** -32700: Invalid JSON *)

     

       41
       41
       +
           | Invalid_request       (** -32600: Invalid Request object *)

     

       42
       42
       +
           | Method_not_found      (** -32601: Method does not exist *)

     

       43
       43
       +
           | Invalid_params        (** -32602: Invalid method parameters *)

     

       44
       44
       +
           | Internal_error        (** -32603: Internal JSON-RPC error *)

     

       45
       45
       +
           | Connection_closed     (** -32000: MCP-specific: connection closed *)

     

       46
       46
       +
           | Server_error of int   (** -32099 to -32000: Server error *)

     

       47
       47
       +
           | Other of int          (** Implementation-defined error *)

     

       48
       48
       +
       

     

       49
       49
       +
         val jsont : t Jsont.t

     

       50
       50
       +
         (** Codec for error codes *)

     

       51
       51
       +
       

     

       52
       52
       +
         val to_int : t -> int

     

       53
       53
       +
         (** Convert error code to integer *)

     

       54
       54
       +
       

     

       55
       55
       +
         val of_int : int -> t

     

       56
       56
       +
         (** Convert integer to error code *)

     

       57
       57
       +
       

     

       58
       58
       +
         val pp : Format.formatter -> t -> unit

     

       59
       59
       +
         (** Pretty-print an error code *)

     

       60
       60
       +
       end

     

       61
       61
       +
       

     

       62
       62
       +
       (** {1 Error Data} *)

     

       63
       63
       +
       

     

       64
       64
       +
       module Error_data : sig

     

       65
       65
       +
         type t = {

     

       66
       66
       +
           code : Error_code.t;

     

       67
       67
       +
           message : string;

     

       68
       68
       +
           data : Jsont.json option;

     

       69
       69
       +
           unknown : Jsont.json;

     

       70
       70
       +
         }

     

       71
       71
       +
         (** Error information *)

     

       72
       72
       +
       

     

       73
       73
       +
         val make : code:Error_code.t -> message:string -> ?data:Jsont.json -> unit -> t

     

       74
       74
       +
         (** Create error data *)

     

       75
       75
       +
       

     

       76
       76
       +
         val jsont : t Jsont.t

     

       77
       77
       +
         (** Codec for error data *)

     

       78
       78
       +
       

     

       79
       79
       +
         val pp : Format.formatter -> t -> unit

     

       80
       80
       +
         (** Pretty-print error data *)

     

       81
       81
       +
       end

     

       82
       82
       +
       

     

       83
       83
       +
       (** {1 Params} *)

     

       84
       84
       +
       

     

       85
       85
       +
       type params = Jsont.json

     

       86
       86
       +
       (** Parameters for requests (must be Array or Object) *)

     

       87
       87
       +
       

     

       88
       88
       +
       val params_jsont : params Jsont.t

     

       89
       89
       +
       (** Codec for params (validates array or object) *)

     

       90
       90
       +
       

     

       91
       91
       +
       (** {1 Request Message} *)

     

       92
       92
       +
       

     

       93
       93
       +
       module Request : sig

     

       94
       94
       +
         type t = {

     

       95
       95
       +
           jsonrpc : jsonrpc;

     

       96
       96
       +
           method_ : string;

     

       97
       97
       +
           params : params option;

     

       98
       98
       +
           id : Id.t option;

     

       99
       99
       +
           unknown : Jsont.json;

     

       100
       100
       +
         }

     

       101
       101
       +
         (** JSON-RPC request.

     

       102
       102
       +
             - If [id] is [Some _], expects a response

     

       103
       103
       +
             - If [id] is [None], it's a notification (no response) *)

     

       104
       104
       +
       

     

       105
       105
       +
         val make :

     

       106
       106
       +
           method_:string ->

     

       107
       107
       +
           ?params:params ->

     

       108
       108
       +
           ?id:Id.t ->

     

       109
       109
       +
           unit ->

     

       110
       110
       +
           t

     

       111
       111
       +
         (** Create a request *)

     

       112
       112
       +
       

     

       113
       113
       +
         val jsont : t Jsont.t

     

       114
       114
       +
         (** Codec for requests *)

     

       115
       115
       +
       

     

       116
       116
       +
         val pp : Format.formatter -> t -> unit

     

       117
       117
       +
         (** Pretty-print a request *)

     

       118
       118
       +
       end

     

       119
       119
       +
       

     

       120
       120
       +
       (** {1 Response Message} *)

     

       121
       121
       +
       

     

       122
       122
       +
       module Response : sig

     

       123
       123
       +
         type t = {

     

       124
       124
       +
           jsonrpc : jsonrpc;

     

       125
       125
       +
           value : (Jsont.json, Error_data.t) result;

     

       126
       126
       +
           id : Id.t;

     

       127
       127
       +
           unknown : Jsont.json;

     

       128
       128
       +
         }

     

       129
       129
       +
         (** JSON-RPC response.

     

       130
       130
       +
             Either contains [Ok result] or [Error error]. *)

     

       131
       131
       +
       

     

       132
       132
       +
         val make_result : id:Id.t -> result:Jsont.json -> t

     

       133
       133
       +
         (** Create a successful response *)

     

       134
       134
       +
       

     

       135
       135
       +
         val make_error : id:Id.t -> error:Error_data.t -> t

     

       136
       136
       +
         (** Create an error response *)

     

       137
       137
       +
       

     

       138
       138
       +
         val jsont : t Jsont.t

     

       139
       139
       +
         (** Codec for responses *)

     

       140
       140
       +
       

     

       141
       141
       +
         val pp : Format.formatter -> t -> unit

     

       142
       142
       +
         (** Pretty-print a response *)

     

       143
       143
       +
       end

     

       144
       144
       +
       

     

       145
       145
       +
       (** {1 Message Union} *)

     

       146
       146
       +
       

     

       147
       147
       +
       module Message : sig

     

       148
       148
       +
         type t =

     

       149
       149
       +
           | Request of Request.t

     

       150
       150
       +
           | Response of Response.t

     

       151
       151
       +
         (** Union of all JSON-RPC message types *)

     

       152
       152
       +
       

     

       153
       153
       +
         val jsont : t Jsont.t

     

       154
       154
       +
         (** Codec for messages *)

     

       155
       155
       +
       

     

       156
       156
       +
         val classify : Jsont.json -> t

     

       157
       157
       +
         (** Classify a JSON value as a specific message type *)

     

       158
       158
       +
       

     

       159
       159
       +
         val pp : Format.formatter -> t -> unit

     

       160
       160
       +
         (** Pretty-print a message *)

     

       161
       161
       +
       end

+11

claudeio/lib_mcp/mcp.ml

···

       1
       1
       +
       (** Model Context Protocol (MCP) OCaml Implementation *)

     

       2
       2
       +
       

     

       3
       3
       +
       module Jsonrpc = Jsonrpc

     

       4
       4
       +
       module Content = Content

     

       5
       5
       +
       module Capabilities = Capabilities

     

       6
       6
       +
       module Messages = Messages

     

       7
       7
       +
       module Session = Session

     

       8
       8
       +
       module Transport = Transport

     

       9
       9
       +
       module Transport_stdio = Transport_stdio

     

       10
       10
       +
       module Server_session = Server_session

     

       11
       11
       +
       module Client_session = Client_session

+63

claudeio/lib_mcp/mcp.mli

···

       1
       1
       +
       (** Model Context Protocol (MCP) OCaml Implementation.

     

       2
       2
       +
       

     

       3
       3
       +
           This library provides a type-safe, Eio-based implementation of the Model Context Protocol,

     

       4
       4
       +
           using jsont for JSON serialization with forward-compatible unknown field preservation.

     

       5
       5
       +
       

     

       6
       6
       +
           {1 Quick Start}

     

       7
       7
       +
       

     

       8
       8
       +
           The MCP library is organized into several modules:

     

       9
       9
       +
       

     

       10
       10
       +
           - {!Jsonrpc}: JSON-RPC 2.0 protocol layer

     

       11
       11
       +
           - {!Content}: Content block types (text, image, audio, resources)

     

       12
       12
       +
           - {!Capabilities}: Client and server capability negotiation

     

       13
       13
       +
       

     

       14
       14
       +
           {1 Example}

     

       15
       15
       +
       

     

       16
       16
       +
           {[

     

       17
       17
       +
             open Mcp

     

       18
       18
       +
       

     

       19
       19
       +
             (* Create client capabilities *)

     

       20
       20
       +
             let client_caps = Capabilities.Client.make

     

       21
       21
       +
               ~sampling:(Capabilities.Sampling.make ~tools:true ())

     

       22
       22
       +
               ()

     

       23
       23
       +
       

     

       24
       24
       +
             (* Create content blocks *)

     

       25
       25
       +
             let text_block = Content.text "Hello, MCP!"

     

       26
       26
       +
             let image_block = Content.image ~data:"..." ~mime_type:"image/png"

     

       27
       27
       +
           ]}

     

       28
       28
       +
       

     

       29
       29
       +
           {1 Design Principles}

     

       30
       30
       +
       

     

       31
       31
       +
           - {b Type Safety}: All protocol types use jsont codecs for bidirectional JSON serialization

     

       32
       32
       +
           - {b Forward Compatibility}: Unknown fields are preserved in all types

     

       33
       33
       +
           - {b Eio Integration}: Uses Eio for structured concurrency

     

       34
       34
       +
           - {b Protocol Compliance}: Follows MCP specification exactly

     

       35
       35
       +
       

     

       36
       36
       +
           {1 Modules} *)

     

       37
       37
       +
       

     

       38
       38
       +
       (** JSON-RPC 2.0 protocol implementation *)

     

       39
       39
       +
       module Jsonrpc : module type of Jsonrpc

     

       40
       40
       +
       

     

       41
       41
       +
       (** MCP content block types *)

     

       42
       42
       +
       module Content : module type of Content

     

       43
       43
       +
       

     

       44
       44
       +
       (** Client and server capability negotiation *)

     

       45
       45
       +
       module Capabilities : module type of Capabilities

     

       46
       46
       +
       

     

       47
       47
       +
       (** MCP protocol messages (initialize, resources, tools, prompts, logging, etc.) *)

     

       48
       48
       +
       module Messages : module type of Messages

     

       49
       49
       +
       

     

       50
       50
       +
       (** Bidirectional JSON-RPC session management *)

     

       51
       51
       +
       module Session : module type of Session

     

       52
       52
       +
       

     

       53
       53
       +
       (** Transport layer for JSON-RPC communication *)

     

       54
       54
       +
       module Transport : module type of Transport

     

       55
       55
       +
       

     

       56
       56
       +
       (** Stdio transport implementation *)

     

       57
       57
       +
       module Transport_stdio : module type of Transport_stdio

     

       58
       58
       +
       

     

       59
       59
       +
       (** High-level MCP server session API *)

     

       60
       60
       +
       module Server_session : module type of Server_session

     

       61
       61
       +
       

     

       62
       62
       +
       (** High-level MCP client session API *)

     

       63
       63
       +
       module Client_session : module type of Client_session

+900

claudeio/lib_mcp/messages.ml

···

       1
       1
       +
       (** MCP Protocol Messages *)

     

       2
       2
       +
       

     

       3
       3
       +
       (* Protocol Version *)

     

       4
       4
       +
       

     

       5
       5
       +
       type protocol_version = string

     

       6
       6
       +
       

     

       7
       7
       +
       let protocol_version_jsont = Jsont.string

     

       8
       8
       +
       

     

       9
       9
       +
       (* Initialize Protocol *)

     

       10
       10
       +
       

     

       11
       11
       +
       module Initialize = struct

     

       12
       12
       +
         type request_params = {

     

       13
       13
       +
           protocol_version : protocol_version;

     

       14
       14
       +
           capabilities : Capabilities.Client.t;

     

       15
       15
       +
           client_info : Capabilities.Implementation.t;

     

       16
       16
       +
           unknown : Jsont.json;

     

       17
       17
       +
         }

     

       18
       18
       +
       

     

       19
       19
       +
         let make_request_params ~protocol_version ~capabilities ~client_info () =

     

       20
       20
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       21
       21
       +
           { protocol_version; capabilities; client_info; unknown }

     

       22
       22
       +
       

     

       23
       23
       +
         let request_params_jsont : request_params Jsont.t =

     

       24
       24
       +
           let make protocol_version capabilities client_info unknown =

     

       25
       25
       +
             { protocol_version; capabilities; client_info; unknown }

     

       26
       26
       +
           in

     

       27
       27
       +
           Jsont.Object.map ~kind:"InitializeRequestParams" make

     

       28
       28
       +
           |> Jsont.Object.mem "protocolVersion" protocol_version_jsont

     

       29
       29
       +
               ~enc:(fun p -> p.protocol_version)

     

       30
       30
       +
           |> Jsont.Object.mem "capabilities" Capabilities.Client.jsont

     

       31
       31
       +
               ~enc:(fun p -> p.capabilities)

     

       32
       32
       +
           |> Jsont.Object.mem "clientInfo" Capabilities.Implementation.jsont

     

       33
       33
       +
               ~enc:(fun p -> p.client_info)

     

       34
       34
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun p -> p.unknown)

     

       35
       35
       +
           |> Jsont.Object.finish

     

       36
       36
       +
       

     

       37
       37
       +
         type result = {

     

       38
       38
       +
           protocol_version : protocol_version;

     

       39
       39
       +
           capabilities : Capabilities.Server.t;

     

       40
       40
       +
           server_info : Capabilities.Implementation.t;

     

       41
       41
       +
           instructions : string option;

     

       42
       42
       +
           unknown : Jsont.json;

     

       43
       43
       +
         }

     

       44
       44
       +
       

     

       45
       45
       +
         let make_result ~protocol_version ~capabilities ~server_info ?instructions () =

     

       46
       46
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       47
       47
       +
           { protocol_version; capabilities; server_info; instructions; unknown }

     

       48
       48
       +
       

     

       49
       49
       +
         let result_jsont : result Jsont.t =

     

       50
       50
       +
           let make protocol_version capabilities server_info instructions unknown =

     

       51
       51
       +
             { protocol_version; capabilities; server_info; instructions; unknown }

     

       52
       52
       +
           in

     

       53
       53
       +
           Jsont.Object.map ~kind:"InitializeResult" make

     

       54
       54
       +
           |> Jsont.Object.mem "protocolVersion" protocol_version_jsont

     

       55
       55
       +
               ~enc:(fun r -> r.protocol_version)

     

       56
       56
       +
           |> Jsont.Object.mem "capabilities" Capabilities.Server.jsont

     

       57
       57
       +
               ~enc:(fun r -> r.capabilities)

     

       58
       58
       +
           |> Jsont.Object.mem "serverInfo" Capabilities.Implementation.jsont

     

       59
       59
       +
               ~enc:(fun r -> r.server_info)

     

       60
       60
       +
           |> Jsont.Object.opt_mem "instructions" Jsont.string

     

       61
       61
       +
               ~enc:(fun r -> r.instructions)

     

       62
       62
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)

     

       63
       63
       +
           |> Jsont.Object.finish

     

       64
       64
       +
       

     

       65
       65
       +
         let method_ = "initialize"

     

       66
       66
       +
       end

     

       67
       67
       +
       

     

       68
       68
       +
       module Initialized = struct

     

       69
       69
       +
         type notification = {

     

       70
       70
       +
           unknown : Jsont.json;

     

       71
       71
       +
         }

     

       72
       72
       +
       

     

       73
       73
       +
         let make_notification () =

     

       74
       74
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       75
       75
       +
           { unknown }

     

       76
       76
       +
       

     

       77
       77
       +
         let notification_jsont : notification Jsont.t =

     

       78
       78
       +
           let make unknown = { unknown } in

     

       79
       79
       +
           Jsont.Object.map ~kind:"InitializedNotification" make

     

       80
       80
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun n -> n.unknown)

     

       81
       81
       +
           |> Jsont.Object.finish

     

       82
       82
       +
       

     

       83
       83
       +
         let method_ = "notifications/initialized"

     

       84
       84
       +
       end

     

       85
       85
       +
       

     

       86
       86
       +
       module Ping = struct

     

       87
       87
       +
         type params = {

     

       88
       88
       +
           unknown : Jsont.json;

     

       89
       89
       +
         }

     

       90
       90
       +
       

     

       91
       91
       +
         let make_params () =

     

       92
       92
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       93
       93
       +
           { unknown }

     

       94
       94
       +
       

     

       95
       95
       +
         let params_jsont : params Jsont.t =

     

       96
       96
       +
           let make unknown = { unknown } in

     

       97
       97
       +
           Jsont.Object.map ~kind:"PingParams" make

     

       98
       98
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun p -> p.unknown)

     

       99
       99
       +
           |> Jsont.Object.finish

     

       100
       100
       +
       

     

       101
       101
       +
         type result = {

     

       102
       102
       +
           unknown : Jsont.json;

     

       103
       103
       +
         }

     

       104
       104
       +
       

     

       105
       105
       +
         let make_result () =

     

       106
       106
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       107
       107
       +
           { unknown }

     

       108
       108
       +
       

     

       109
       109
       +
         let result_jsont : result Jsont.t =

     

       110
       110
       +
           let make unknown = { unknown } in

     

       111
       111
       +
           Jsont.Object.map ~kind:"PingResult" make

     

       112
       112
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)

     

       113
       113
       +
           |> Jsont.Object.finish

     

       114
       114
       +
       

     

       115
       115
       +
         let method_ = "ping"

     

       116
       116
       +
       end

     

       117
       117
       +
       

     

       118
       118
       +
       (* Resources *)

     

       119
       119
       +
       

     

       120
       120
       +
       module Resources = struct

     

       121
       121
       +
         type resource = {

     

       122
       122
       +
           uri : string;

     

       123
       123
       +
           name : string;

     

       124
       124
       +
           description : string option;

     

       125
       125
       +
           mime_type : string option;

     

       126
       126
       +
           unknown : Jsont.json;

     

       127
       127
       +
         }

     

       128
       128
       +
       

     

       129
       129
       +
         let make_resource ~uri ~name ?description ?mime_type () =

     

       130
       130
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       131
       131
       +
           { uri; name; description; mime_type; unknown }

     

       132
       132
       +
       

     

       133
       133
       +
         let resource_jsont : resource Jsont.t =

     

       134
       134
       +
           let make uri name description mime_type unknown =

     

       135
       135
       +
             { uri; name; description; mime_type; unknown }

     

       136
       136
       +
           in

     

       137
       137
       +
           Jsont.Object.map ~kind:"Resource" make

     

       138
       138
       +
           |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)

     

       139
       139
       +
           |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)

     

       140
       140
       +
           |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)

     

       141
       141
       +
           |> Jsont.Object.opt_mem "mimeType" Jsont.string ~enc:(fun r -> r.mime_type)

     

       142
       142
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)

     

       143
       143
       +
           |> Jsont.Object.finish

     

       144
       144
       +
       

     

       145
       145
       +
         type resource_template = {

     

       146
       146
       +
           uri_template : string;

     

       147
       147
       +
           name : string;

     

       148
       148
       +
           description : string option;

     

       149
       149
       +
           mime_type : string option;

     

       150
       150
       +
           unknown : Jsont.json;

     

       151
       151
       +
         }

     

       152
       152
       +
       

     

       153
       153
       +
         let make_resource_template ~uri_template ~name ?description ?mime_type () =

     

       154
       154
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       155
       155
       +
           { uri_template; name; description; mime_type; unknown }

     

       156
       156
       +
       

     

       157
       157
       +
         let resource_template_jsont : resource_template Jsont.t =

     

       158
       158
       +
           let make uri_template name description mime_type unknown =

     

       159
       159
       +
             { uri_template; name; description; mime_type; unknown }

     

       160
       160
       +
           in

     

       161
       161
       +
           Jsont.Object.map ~kind:"ResourceTemplate" make

     

       162
       162
       +
           |> Jsont.Object.mem "uriTemplate" Jsont.string ~enc:(fun t -> t.uri_template)

     

       163
       163
       +
           |> Jsont.Object.mem "name" Jsont.string ~enc:(fun t -> t.name)

     

       164
       164
       +
           |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun t -> t.description)

     

       165
       165
       +
           |> Jsont.Object.opt_mem "mimeType" Jsont.string ~enc:(fun t -> t.mime_type)

     

       166
       166
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun t -> t.unknown)

     

       167
       167
       +
           |> Jsont.Object.finish

     

       168
       168
       +
       

     

       169
       169
       +
         type resource_contents = {

     

       170
       170
       +
           uri : string;

     

       171
       171
       +
           mime_type : string option;

     

       172
       172
       +
           text : string option;

     

       173
       173
       +
           blob : string option;

     

       174
       174
       +
           unknown : Jsont.json;

     

       175
       175
       +
         }

     

       176
       176
       +
       

     

       177
       177
       +
         let make_text_contents ~uri ~text ?mime_type () =

     

       178
       178
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       179
       179
       +
           { uri; mime_type; text = Some text; blob = None; unknown }

     

       180
       180
       +
       

     

       181
       181
       +
         let make_blob_contents ~uri ~blob ~mime_type =

     

       182
       182
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       183
       183
       +
           { uri; mime_type = Some mime_type; text = None; blob = Some blob; unknown }

     

       184
       184
       +
       

     

       185
       185
       +
         let resource_contents_jsont : resource_contents Jsont.t =

     

       186
       186
       +
           let make uri mime_type text blob unknown =

     

       187
       187
       +
             { uri; mime_type; text; blob; unknown }

     

       188
       188
       +
           in

     

       189
       189
       +
           Jsont.Object.map ~kind:"ResourceContents" make

     

       190
       190
       +
           |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun c -> c.uri)

     

       191
       191
       +
           |> Jsont.Object.opt_mem "mimeType" Jsont.string ~enc:(fun c -> c.mime_type)

     

       192
       192
       +
           |> Jsont.Object.opt_mem "text" Jsont.string ~enc:(fun c -> c.text)

     

       193
       193
       +
           |> Jsont.Object.opt_mem "blob" Jsont.string ~enc:(fun c -> c.blob)

     

       194
       194
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun c -> c.unknown)

     

       195
       195
       +
           |> Jsont.Object.finish

     

       196
       196
       +
       

     

       197
       197
       +
         type list_request = {

     

       198
       198
       +
           cursor : string option;

     

       199
       199
       +
           unknown : Jsont.json;

     

       200
       200
       +
         }

     

       201
       201
       +
       

     

       202
       202
       +
         let make_list_request ?cursor () =

     

       203
       203
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       204
       204
       +
           { cursor; unknown }

     

       205
       205
       +
       

     

       206
       206
       +
         let list_request_jsont : list_request Jsont.t =

     

       207
       207
       +
           let make cursor unknown = { cursor; unknown } in

     

       208
       208
       +
           Jsont.Object.map ~kind:"ResourcesListRequest" make

     

       209
       209
       +
           |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)

     

       210
       210
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)

     

       211
       211
       +
           |> Jsont.Object.finish

     

       212
       212
       +
       

     

       213
       213
       +
         type list_result = {

     

       214
       214
       +
           resources : resource list;

     

       215
       215
       +
           next_cursor : string option;

     

       216
       216
       +
           unknown : Jsont.json;

     

       217
       217
       +
         }

     

       218
       218
       +
       

     

       219
       219
       +
         let make_list_result ~resources ?next_cursor () =

     

       220
       220
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       221
       221
       +
           { resources; next_cursor; unknown }

     

       222
       222
       +
       

     

       223
       223
       +
         let list_result_jsont : list_result Jsont.t =

     

       224
       224
       +
           let make resources next_cursor unknown =

     

       225
       225
       +
             { resources; next_cursor; unknown }

     

       226
       226
       +
           in

     

       227
       227
       +
           Jsont.Object.map ~kind:"ResourcesListResult" make

     

       228
       228
       +
           |> Jsont.Object.mem "resources" (Jsont.list resource_jsont)

     

       229
       229
       +
               ~enc:(fun r -> r.resources)

     

       230
       230
       +
           |> Jsont.Object.opt_mem "nextCursor" Jsont.string

     

       231
       231
       +
               ~enc:(fun r -> r.next_cursor)

     

       232
       232
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)

     

       233
       233
       +
           |> Jsont.Object.finish

     

       234
       234
       +
       

     

       235
       235
       +
         type read_request = {

     

       236
       236
       +
           uri : string;

     

       237
       237
       +
           unknown : Jsont.json;

     

       238
       238
       +
         }

     

       239
       239
       +
       

     

       240
       240
       +
         let make_read_request ~uri =

     

       241
       241
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       242
       242
       +
           { uri; unknown }

     

       243
       243
       +
       

     

       244
       244
       +
         let read_request_jsont : read_request Jsont.t =

     

       245
       245
       +
           let make uri unknown = { uri; unknown } in

     

       246
       246
       +
           Jsont.Object.map ~kind:"ResourcesReadRequest" make

     

       247
       247
       +
           |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)

     

       248
       248
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)

     

       249
       249
       +
           |> Jsont.Object.finish

     

       250
       250
       +
       

     

       251
       251
       +
         type read_result = {

     

       252
       252
       +
           contents : resource_contents list;

     

       253
       253
       +
           unknown : Jsont.json;

     

       254
       254
       +
         }

     

       255
       255
       +
       

     

       256
       256
       +
         let make_read_result ~contents =

     

       257
       257
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       258
       258
       +
           { contents; unknown }

     

       259
       259
       +
       

     

       260
       260
       +
         let read_result_jsont : read_result Jsont.t =

     

       261
       261
       +
           let make contents unknown = { contents; unknown } in

     

       262
       262
       +
           Jsont.Object.map ~kind:"ResourcesReadResult" make

     

       263
       263
       +
           |> Jsont.Object.mem "contents" (Jsont.list resource_contents_jsont)

     

       264
       264
       +
               ~enc:(fun r -> r.contents)

     

       265
       265
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)

     

       266
       266
       +
           |> Jsont.Object.finish

     

       267
       267
       +
       

     

       268
       268
       +
         type subscribe_request = {

     

       269
       269
       +
           uri : string;

     

       270
       270
       +
           unknown : Jsont.json;

     

       271
       271
       +
         }

     

       272
       272
       +
       

     

       273
       273
       +
         let make_subscribe_request ~uri =

     

       274
       274
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       275
       275
       +
           { uri; unknown }

     

       276
       276
       +
       

     

       277
       277
       +
         let subscribe_request_jsont : subscribe_request Jsont.t =

     

       278
       278
       +
           let make uri unknown = { uri; unknown } in

     

       279
       279
       +
           Jsont.Object.map ~kind:"ResourcesSubscribeRequest" make

     

       280
       280
       +
           |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)

     

       281
       281
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)

     

       282
       282
       +
           |> Jsont.Object.finish

     

       283
       283
       +
       

     

       284
       284
       +
         type unsubscribe_request = {

     

       285
       285
       +
           uri : string;

     

       286
       286
       +
           unknown : Jsont.json;

     

       287
       287
       +
         }

     

       288
       288
       +
       

     

       289
       289
       +
         let make_unsubscribe_request ~uri =

     

       290
       290
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       291
       291
       +
           { uri; unknown }

     

       292
       292
       +
       

     

       293
       293
       +
         let unsubscribe_request_jsont : unsubscribe_request Jsont.t =

     

       294
       294
       +
           let make uri unknown = { uri; unknown } in

     

       295
       295
       +
           Jsont.Object.map ~kind:"ResourcesUnsubscribeRequest" make

     

       296
       296
       +
           |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)

     

       297
       297
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)

     

       298
       298
       +
           |> Jsont.Object.finish

     

       299
       299
       +
       

     

       300
       300
       +
         type updated_notification = {

     

       301
       301
       +
           uri : string;

     

       302
       302
       +
           unknown : Jsont.json;

     

       303
       303
       +
         }

     

       304
       304
       +
       

     

       305
       305
       +
         let make_updated_notification ~uri =

     

       306
       306
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       307
       307
       +
           { uri; unknown }

     

       308
       308
       +
       

     

       309
       309
       +
         let updated_notification_jsont : updated_notification Jsont.t =

     

       310
       310
       +
           let make uri unknown = { uri; unknown } in

     

       311
       311
       +
           Jsont.Object.map ~kind:"ResourceUpdatedNotification" make

     

       312
       312
       +
           |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun n -> n.uri)

     

       313
       313
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun n -> n.unknown)

     

       314
       314
       +
           |> Jsont.Object.finish

     

       315
       315
       +
       

     

       316
       316
       +
         type list_changed_notification = {

     

       317
       317
       +
           unknown : Jsont.json;

     

       318
       318
       +
         }

     

       319
       319
       +
       

     

       320
       320
       +
         let make_list_changed_notification () =

     

       321
       321
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       322
       322
       +
           { unknown }

     

       323
       323
       +
       

     

       324
       324
       +
         let list_changed_notification_jsont : list_changed_notification Jsont.t =

     

       325
       325
       +
           let make unknown = { unknown } in

     

       326
       326
       +
           Jsont.Object.map ~kind:"ResourceListChangedNotification" make

     

       327
       327
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun n -> n.unknown)

     

       328
       328
       +
           |> Jsont.Object.finish

     

       329
       329
       +
       

     

       330
       330
       +
         let list_method = "resources/list"

     

       331
       331
       +
         let read_method = "resources/read"

     

       332
       332
       +
         let subscribe_method = "resources/subscribe"

     

       333
       333
       +
         let unsubscribe_method = "resources/unsubscribe"

     

       334
       334
       +
         let updated_notification_method = "notifications/resources/updated"

     

       335
       335
       +
         let list_changed_notification_method = "notifications/resources/list_changed"

     

       336
       336
       +
       end

     

       337
       337
       +
       

     

       338
       338
       +
       (* Tools *)

     

       339
       339
       +
       

     

       340
       340
       +
       module Tools = struct

     

       341
       341
       +
         type tool = {

     

       342
       342
       +
           name : string;

     

       343
       343
       +
           description : string option;

     

       344
       344
       +
           input_schema : Jsont.json;

     

       345
       345
       +
           unknown : Jsont.json;

     

       346
       346
       +
         }

     

       347
       347
       +
       

     

       348
       348
       +
         let make_tool ~name ?description ~input_schema () =

     

       349
       349
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       350
       350
       +
           { name; description; input_schema; unknown }

     

       351
       351
       +
       

     

       352
       352
       +
         let tool_jsont : tool Jsont.t =

     

       353
       353
       +
           let make name description input_schema unknown =

     

       354
       354
       +
             { name; description; input_schema; unknown }

     

       355
       355
       +
           in

     

       356
       356
       +
           Jsont.Object.map ~kind:"Tool" make

     

       357
       357
       +
           |> Jsont.Object.mem "name" Jsont.string ~enc:(fun t -> t.name)

     

       358
       358
       +
           |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun t -> t.description)

     

       359
       359
       +
           |> Jsont.Object.mem "inputSchema" Jsont.json ~enc:(fun t -> t.input_schema)

     

       360
       360
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun t -> t.unknown)

     

       361
       361
       +
           |> Jsont.Object.finish

     

       362
       362
       +
       

     

       363
       363
       +
         type list_request = {

     

       364
       364
       +
           cursor : string option;

     

       365
       365
       +
           unknown : Jsont.json;

     

       366
       366
       +
         }

     

       367
       367
       +
       

     

       368
       368
       +
         let make_list_request ?cursor () =

     

       369
       369
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       370
       370
       +
           { cursor; unknown }

     

       371
       371
       +
       

     

       372
       372
       +
         let list_request_jsont : list_request Jsont.t =

     

       373
       373
       +
           let make cursor unknown = { cursor; unknown } in

     

       374
       374
       +
           Jsont.Object.map ~kind:"ToolsListRequest" make

     

       375
       375
       +
           |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)

     

       376
       376
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)

     

       377
       377
       +
           |> Jsont.Object.finish

     

       378
       378
       +
       

     

       379
       379
       +
         type list_result = {

     

       380
       380
       +
           tools : tool list;

     

       381
       381
       +
           next_cursor : string option;

     

       382
       382
       +
           unknown : Jsont.json;

     

       383
       383
       +
         }

     

       384
       384
       +
       

     

       385
       385
       +
         let make_list_result ~tools ?next_cursor () =

     

       386
       386
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       387
       387
       +
           { tools; next_cursor; unknown }

     

       388
       388
       +
       

     

       389
       389
       +
         let list_result_jsont : list_result Jsont.t =

     

       390
       390
       +
           let make tools next_cursor unknown =

     

       391
       391
       +
             { tools; next_cursor; unknown }

     

       392
       392
       +
           in

     

       393
       393
       +
           Jsont.Object.map ~kind:"ToolsListResult" make

     

       394
       394
       +
           |> Jsont.Object.mem "tools" (Jsont.list tool_jsont)

     

       395
       395
       +
               ~enc:(fun r -> r.tools)

     

       396
       396
       +
           |> Jsont.Object.opt_mem "nextCursor" Jsont.string

     

       397
       397
       +
               ~enc:(fun r -> r.next_cursor)

     

       398
       398
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)

     

       399
       399
       +
           |> Jsont.Object.finish

     

       400
       400
       +
       

     

       401
       401
       +
         type call_request = {

     

       402
       402
       +
           name : string;

     

       403
       403
       +
           arguments : Jsont.json option;

     

       404
       404
       +
           unknown : Jsont.json;

     

       405
       405
       +
         }

     

       406
       406
       +
       

     

       407
       407
       +
         let make_call_request ~name ?arguments () =

     

       408
       408
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       409
       409
       +
           { name; arguments; unknown }

     

       410
       410
       +
       

     

       411
       411
       +
         let call_request_jsont : call_request Jsont.t =

     

       412
       412
       +
           let make name arguments unknown = { name; arguments; unknown } in

     

       413
       413
       +
           Jsont.Object.map ~kind:"ToolsCallRequest" make

     

       414
       414
       +
           |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)

     

       415
       415
       +
           |> Jsont.Object.opt_mem "arguments" Jsont.json ~enc:(fun r -> r.arguments)

     

       416
       416
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)

     

       417
       417
       +
           |> Jsont.Object.finish

     

       418
       418
       +
       

     

       419
       419
       +
         type call_result = {

     

       420
       420
       +
           content : Content.block list;

     

       421
       421
       +
           is_error : bool option;

     

       422
       422
       +
           unknown : Jsont.json;

     

       423
       423
       +
         }

     

       424
       424
       +
       

     

       425
       425
       +
         let make_call_result ~content ?is_error () =

     

       426
       426
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       427
       427
       +
           { content; is_error; unknown }

     

       428
       428
       +
       

     

       429
       429
       +
         let call_result_jsont : call_result Jsont.t =

     

       430
       430
       +
           let make content is_error unknown =

     

       431
       431
       +
             { content; is_error; unknown }

     

       432
       432
       +
           in

     

       433
       433
       +
           Jsont.Object.map ~kind:"ToolsCallResult" make

     

       434
       434
       +
           |> Jsont.Object.mem "content" (Jsont.list Content.block_jsont)

     

       435
       435
       +
               ~enc:(fun r -> r.content)

     

       436
       436
       +
           |> Jsont.Object.opt_mem "isError" Jsont.bool ~enc:(fun r -> r.is_error)

     

       437
       437
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)

     

       438
       438
       +
           |> Jsont.Object.finish

     

       439
       439
       +
       

     

       440
       440
       +
         type list_changed_notification = {

     

       441
       441
       +
           unknown : Jsont.json;

     

       442
       442
       +
         }

     

       443
       443
       +
       

     

       444
       444
       +
         let make_list_changed_notification () =

     

       445
       445
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       446
       446
       +
           { unknown }

     

       447
       447
       +
       

     

       448
       448
       +
         let list_changed_notification_jsont : list_changed_notification Jsont.t =

     

       449
       449
       +
           let make unknown = { unknown } in

     

       450
       450
       +
           Jsont.Object.map ~kind:"ToolsListChangedNotification" make

     

       451
       451
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun n -> n.unknown)

     

       452
       452
       +
           |> Jsont.Object.finish

     

       453
       453
       +
       

     

       454
       454
       +
         let list_method = "tools/list"

     

       455
       455
       +
         let call_method = "tools/call"

     

       456
       456
       +
         let list_changed_notification_method = "notifications/tools/list_changed"

     

       457
       457
       +
       end

     

       458
       458
       +
       

     

       459
       459
       +
       (* Prompts *)

     

       460
       460
       +
       

     

       461
       461
       +
       module Prompts = struct

     

       462
       462
       +
         type prompt_argument = {

     

       463
       463
       +
           name : string;

     

       464
       464
       +
           description : string option;

     

       465
       465
       +
           required : bool option;

     

       466
       466
       +
           unknown : Jsont.json;

     

       467
       467
       +
         }

     

       468
       468
       +
       

     

       469
       469
       +
         let make_prompt_argument ~name ?description ?required () =

     

       470
       470
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       471
       471
       +
           { name; description; required; unknown }

     

       472
       472
       +
       

     

       473
       473
       +
         let prompt_argument_jsont : prompt_argument Jsont.t =

     

       474
       474
       +
           let make name description required unknown =

     

       475
       475
       +
             { name; description; required; unknown }

     

       476
       476
       +
           in

     

       477
       477
       +
           Jsont.Object.map ~kind:"PromptArgument" make

     

       478
       478
       +
           |> Jsont.Object.mem "name" Jsont.string ~enc:(fun a -> a.name)

     

       479
       479
       +
           |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun a -> a.description)

     

       480
       480
       +
           |> Jsont.Object.opt_mem "required" Jsont.bool ~enc:(fun a -> a.required)

     

       481
       481
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun a -> a.unknown)

     

       482
       482
       +
           |> Jsont.Object.finish

     

       483
       483
       +
       

     

       484
       484
       +
         type prompt = {

     

       485
       485
       +
           name : string;

     

       486
       486
       +
           description : string option;

     

       487
       487
       +
           arguments : prompt_argument list option;

     

       488
       488
       +
           unknown : Jsont.json;

     

       489
       489
       +
         }

     

       490
       490
       +
       

     

       491
       491
       +
         let make_prompt ~name ?description ?arguments () =

     

       492
       492
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       493
       493
       +
           { name; description; arguments; unknown }

     

       494
       494
       +
       

     

       495
       495
       +
         let prompt_jsont : prompt Jsont.t =

     

       496
       496
       +
           let make name description arguments unknown =

     

       497
       497
       +
             { name; description; arguments; unknown }

     

       498
       498
       +
           in

     

       499
       499
       +
           Jsont.Object.map ~kind:"Prompt" make

     

       500
       500
       +
           |> Jsont.Object.mem "name" Jsont.string ~enc:(fun p -> p.name)

     

       501
       501
       +
           |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun p -> p.description)

     

       502
       502
       +
           |> Jsont.Object.opt_mem "arguments" (Jsont.list prompt_argument_jsont)

     

       503
       503
       +
               ~enc:(fun p -> p.arguments)

     

       504
       504
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun p -> p.unknown)

     

       505
       505
       +
           |> Jsont.Object.finish

     

       506
       506
       +
       

     

       507
       507
       +
         type role = User | Assistant

     

       508
       508
       +
       

     

       509
       509
       +
         let role_jsont : role Jsont.t =

     

       510
       510
       +
           Jsont.enum [

     

       511
       511
       +
             "user", User;

     

       512
       512
       +
             "assistant", Assistant;

     

       513
       513
       +
           ]

     

       514
       514
       +
       

     

       515
       515
       +
         type prompt_message = {

     

       516
       516
       +
           role : role;

     

       517
       517
       +
           content : Content.block list;

     

       518
       518
       +
           unknown : Jsont.json;

     

       519
       519
       +
         }

     

       520
       520
       +
       

     

       521
       521
       +
         let make_prompt_message ~role ~content () =

     

       522
       522
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       523
       523
       +
           { role; content; unknown }

     

       524
       524
       +
       

     

       525
       525
       +
         let prompt_message_jsont : prompt_message Jsont.t =

     

       526
       526
       +
           let make role content unknown = { role; content; unknown } in

     

       527
       527
       +
           Jsont.Object.map ~kind:"PromptMessage" make

     

       528
       528
       +
           |> Jsont.Object.mem "role" role_jsont ~enc:(fun m -> m.role)

     

       529
       529
       +
           |> Jsont.Object.mem "content" (Jsont.list Content.block_jsont)

     

       530
       530
       +
               ~enc:(fun m -> m.content)

     

       531
       531
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun m -> m.unknown)

     

       532
       532
       +
           |> Jsont.Object.finish

     

       533
       533
       +
       

     

       534
       534
       +
         type list_request = {

     

       535
       535
       +
           cursor : string option;

     

       536
       536
       +
           unknown : Jsont.json;

     

       537
       537
       +
         }

     

       538
       538
       +
       

     

       539
       539
       +
         let make_list_request ?cursor () =

     

       540
       540
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       541
       541
       +
           { cursor; unknown }

     

       542
       542
       +
       

     

       543
       543
       +
         let list_request_jsont : list_request Jsont.t =

     

       544
       544
       +
           let make cursor unknown = { cursor; unknown } in

     

       545
       545
       +
           Jsont.Object.map ~kind:"PromptsListRequest" make

     

       546
       546
       +
           |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)

     

       547
       547
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)

     

       548
       548
       +
           |> Jsont.Object.finish

     

       549
       549
       +
       

     

       550
       550
       +
         type list_result = {

     

       551
       551
       +
           prompts : prompt list;

     

       552
       552
       +
           next_cursor : string option;

     

       553
       553
       +
           unknown : Jsont.json;

     

       554
       554
       +
         }

     

       555
       555
       +
       

     

       556
       556
       +
         let make_list_result ~prompts ?next_cursor () =

     

       557
       557
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       558
       558
       +
           { prompts; next_cursor; unknown }

     

       559
       559
       +
       

     

       560
       560
       +
         let list_result_jsont : list_result Jsont.t =

     

       561
       561
       +
           let make prompts next_cursor unknown =

     

       562
       562
       +
             { prompts; next_cursor; unknown }

     

       563
       563
       +
           in

     

       564
       564
       +
           Jsont.Object.map ~kind:"PromptsListResult" make

     

       565
       565
       +
           |> Jsont.Object.mem "prompts" (Jsont.list prompt_jsont)

     

       566
       566
       +
               ~enc:(fun r -> r.prompts)

     

       567
       567
       +
           |> Jsont.Object.opt_mem "nextCursor" Jsont.string

     

       568
       568
       +
               ~enc:(fun r -> r.next_cursor)

     

       569
       569
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)

     

       570
       570
       +
           |> Jsont.Object.finish

     

       571
       571
       +
       

     

       572
       572
       +
         (* Arguments as object with string keys *)

     

       573
       573
       +
         let arguments_jsont : (string * string) list Jsont.t =

     

       574
       574
       +
           let enc_obj args =

     

       575
       575
       +
             let pairs = List.map (fun (k, v) ->

     

       576
       576
       +
               ((k, Jsont.Meta.none), Jsont.String (v, Jsont.Meta.none))

     

       577
       577
       +
             ) args in

     

       578
       578
       +
             Jsont.Object (pairs, Jsont.Meta.none)

     

       579
       579
       +
           in

     

       580
       580
       +
           let dec_obj = function

     

       581
       581
       +
             | Jsont.Object (members, _) ->

     

       582
       582
       +
                 List.map (fun ((k, _), v) ->

     

       583
       583
       +
                   match v with

     

       584
       584
       +
                   | Jsont.String (s, _) -> (k, s)

     

       585
       585
       +
                   | _ -> Jsont.Error.msgf Jsont.Meta.none

     

       586
       586
       +
                       "Argument values must be strings"

     

       587
       587
       +
                 ) members

     

       588
       588
       +
             | _ ->

     

       589
       589
       +
                 Jsont.Error.msgf Jsont.Meta.none "Arguments must be an object"

     

       590
       590
       +
           in

     

       591
       591
       +
           Jsont.map ~kind:"PromptArguments" ~dec:dec_obj ~enc:enc_obj Jsont.json

     

       592
       592
       +
       

     

       593
       593
       +
         type get_request = {

     

       594
       594
       +
           name : string;

     

       595
       595
       +
           arguments : (string * string) list option;

     

       596
       596
       +
           unknown : Jsont.json;

     

       597
       597
       +
         }

     

       598
       598
       +
       

     

       599
       599
       +
         let make_get_request ~name ?arguments () =

     

       600
       600
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       601
       601
       +
           { name; arguments; unknown }

     

       602
       602
       +
       

     

       603
       603
       +
         let get_request_jsont : get_request Jsont.t =

     

       604
       604
       +
           let make name arguments unknown = { name; arguments; unknown } in

     

       605
       605
       +
           Jsont.Object.map ~kind:"PromptsGetRequest" make

     

       606
       606
       +
           |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)

     

       607
       607
       +
           |> Jsont.Object.opt_mem "arguments" arguments_jsont ~enc:(fun r -> r.arguments)

     

       608
       608
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)

     

       609
       609
       +
           |> Jsont.Object.finish

     

       610
       610
       +
       

     

       611
       611
       +
         type get_result = {

     

       612
       612
       +
           description : string option;

     

       613
       613
       +
           messages : prompt_message list;

     

       614
       614
       +
           unknown : Jsont.json;

     

       615
       615
       +
         }

     

       616
       616
       +
       

     

       617
       617
       +
         let make_get_result ?description ~messages () =

     

       618
       618
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       619
       619
       +
           { description; messages; unknown }

     

       620
       620
       +
       

     

       621
       621
       +
         let get_result_jsont : get_result Jsont.t =

     

       622
       622
       +
           let make description messages unknown =

     

       623
       623
       +
             { description; messages; unknown }

     

       624
       624
       +
           in

     

       625
       625
       +
           Jsont.Object.map ~kind:"PromptsGetResult" make

     

       626
       626
       +
           |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)

     

       627
       627
       +
           |> Jsont.Object.mem "messages" (Jsont.list prompt_message_jsont)

     

       628
       628
       +
               ~enc:(fun r -> r.messages)

     

       629
       629
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)

     

       630
       630
       +
           |> Jsont.Object.finish

     

       631
       631
       +
       

     

       632
       632
       +
         type list_changed_notification = {

     

       633
       633
       +
           unknown : Jsont.json;

     

       634
       634
       +
         }

     

       635
       635
       +
       

     

       636
       636
       +
         let make_list_changed_notification () =

     

       637
       637
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       638
       638
       +
           { unknown }

     

       639
       639
       +
       

     

       640
       640
       +
         let list_changed_notification_jsont : list_changed_notification Jsont.t =

     

       641
       641
       +
           let make unknown = { unknown } in

     

       642
       642
       +
           Jsont.Object.map ~kind:"PromptsListChangedNotification" make

     

       643
       643
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun n -> n.unknown)

     

       644
       644
       +
           |> Jsont.Object.finish

     

       645
       645
       +
       

     

       646
       646
       +
         let list_method = "prompts/list"

     

       647
       647
       +
         let get_method = "prompts/get"

     

       648
       648
       +
         let list_changed_notification_method = "notifications/prompts/list_changed"

     

       649
       649
       +
       end

     

       650
       650
       +
       

     

       651
       651
       +
       (* Logging *)

     

       652
       652
       +
       

     

       653
       653
       +
       module Logging = struct

     

       654
       654
       +
         type level =

     

       655
       655
       +
           | Debug

     

       656
       656
       +
           | Info

     

       657
       657
       +
           | Notice

     

       658
       658
       +
           | Warning

     

       659
       659
       +
           | Error

     

       660
       660
       +
           | Critical

     

       661
       661
       +
           | Alert

     

       662
       662
       +
           | Emergency

     

       663
       663
       +
       

     

       664
       664
       +
         let level_jsont : level Jsont.t =

     

       665
       665
       +
           Jsont.enum [

     

       666
       666
       +
             "debug", Debug;

     

       667
       667
       +
             "info", Info;

     

       668
       668
       +
             "notice", Notice;

     

       669
       669
       +
             "warning", Warning;

     

       670
       670
       +
             "error", Error;

     

       671
       671
       +
             "critical", Critical;

     

       672
       672
       +
             "alert", Alert;

     

       673
       673
       +
             "emergency", Emergency;

     

       674
       674
       +
           ]

     

       675
       675
       +
       

     

       676
       676
       +
         let level_to_string = function

     

       677
       677
       +
           | Debug -> "debug"

     

       678
       678
       +
           | Info -> "info"

     

       679
       679
       +
           | Notice -> "notice"

     

       680
       680
       +
           | Warning -> "warning"

     

       681
       681
       +
           | Error -> "error"

     

       682
       682
       +
           | Critical -> "critical"

     

       683
       683
       +
           | Alert -> "alert"

     

       684
       684
       +
           | Emergency -> "emergency"

     

       685
       685
       +
       

     

       686
       686
       +
         type notification = {

     

       687
       687
       +
           level : level;

     

       688
       688
       +
           logger : string option;

     

       689
       689
       +
           data : Jsont.json option;

     

       690
       690
       +
           unknown : Jsont.json;

     

       691
       691
       +
         }

     

       692
       692
       +
       

     

       693
       693
       +
         let make_notification ~level ?logger ?data () =

     

       694
       694
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       695
       695
       +
           { level; logger; data; unknown }

     

       696
       696
       +
       

     

       697
       697
       +
         let notification_jsont : notification Jsont.t =

     

       698
       698
       +
           let make level logger data unknown =

     

       699
       699
       +
             { level; logger; data; unknown }

     

       700
       700
       +
           in

     

       701
       701
       +
           Jsont.Object.map ~kind:"LoggingNotification" make

     

       702
       702
       +
           |> Jsont.Object.mem "level" level_jsont ~enc:(fun n -> n.level)

     

       703
       703
       +
           |> Jsont.Object.opt_mem "logger" Jsont.string ~enc:(fun n -> n.logger)

     

       704
       704
       +
           |> Jsont.Object.opt_mem "data" Jsont.json ~enc:(fun n -> n.data)

     

       705
       705
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun n -> n.unknown)

     

       706
       706
       +
           |> Jsont.Object.finish

     

       707
       707
       +
       

     

       708
       708
       +
         let method_ = "notifications/message"

     

       709
       709
       +
       end

     

       710
       710
       +
       

     

       711
       711
       +
       (* Completions *)

     

       712
       712
       +
       

     

       713
       713
       +
       module Completions = struct

     

       714
       714
       +
         type completion_ref = {

     

       715
       715
       +
           ref_type : string;

     

       716
       716
       +
           uri : string;

     

       717
       717
       +
           unknown : Jsont.json;

     

       718
       718
       +
         }

     

       719
       719
       +
       

     

       720
       720
       +
         let make_completion_ref ~ref_type ~uri () =

     

       721
       721
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       722
       722
       +
           { ref_type; uri; unknown }

     

       723
       723
       +
       

     

       724
       724
       +
         let completion_ref_jsont : completion_ref Jsont.t =

     

       725
       725
       +
           let make ref_type uri unknown = { ref_type; uri; unknown } in

     

       726
       726
       +
           Jsont.Object.map ~kind:"CompletionRef" make

     

       727
       727
       +
           |> Jsont.Object.mem "type" Jsont.string ~enc:(fun r -> r.ref_type)

     

       728
       728
       +
           |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)

     

       729
       729
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)

     

       730
       730
       +
           |> Jsont.Object.finish

     

       731
       731
       +
       

     

       732
       732
       +
         type request = {

     

       733
       733
       +
           ref_ : completion_ref;

     

       734
       734
       +
           argument : string option;

     

       735
       735
       +
           unknown : Jsont.json;

     

       736
       736
       +
         }

     

       737
       737
       +
       

     

       738
       738
       +
         let make_request ~ref_ ?argument () =

     

       739
       739
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       740
       740
       +
           { ref_; argument; unknown }

     

       741
       741
       +
       

     

       742
       742
       +
         let request_jsont : request Jsont.t =

     

       743
       743
       +
           let make ref_ argument unknown = { ref_; argument; unknown } in

     

       744
       744
       +
           Jsont.Object.map ~kind:"CompletionRequest" make

     

       745
       745
       +
           |> Jsont.Object.mem "ref" completion_ref_jsont ~enc:(fun r -> r.ref_)

     

       746
       746
       +
           |> Jsont.Object.opt_mem "argument" Jsont.string ~enc:(fun r -> r.argument)

     

       747
       747
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)

     

       748
       748
       +
           |> Jsont.Object.finish

     

       749
       749
       +
       

     

       750
       750
       +
         type result = {

     

       751
       751
       +
           completion : string list;

     

       752
       752
       +
           total : int option;

     

       753
       753
       +
           has_more : bool option;

     

       754
       754
       +
           unknown : Jsont.json;

     

       755
       755
       +
         }

     

       756
       756
       +
       

     

       757
       757
       +
         let make_result ~completion ?total ?has_more () =

     

       758
       758
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       759
       759
       +
           { completion; total; has_more; unknown }

     

       760
       760
       +
       

     

       761
       761
       +
         let result_jsont : result Jsont.t =

     

       762
       762
       +
           let make completion total has_more unknown =

     

       763
       763
       +
             { completion; total; has_more; unknown }

     

       764
       764
       +
           in

     

       765
       765
       +
           Jsont.Object.map ~kind:"CompletionResult" make

     

       766
       766
       +
           |> Jsont.Object.mem "completion" (Jsont.list Jsont.string)

     

       767
       767
       +
               ~enc:(fun r -> r.completion)

     

       768
       768
       +
           |> Jsont.Object.opt_mem "total" Jsont.int ~enc:(fun r -> r.total)

     

       769
       769
       +
           |> Jsont.Object.opt_mem "hasMore" Jsont.bool ~enc:(fun r -> r.has_more)

     

       770
       770
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)

     

       771
       771
       +
           |> Jsont.Object.finish

     

       772
       772
       +
       

     

       773
       773
       +
         let method_ = "completion/complete"

     

       774
       774
       +
       end

     

       775
       775
       +
       

     

       776
       776
       +
       (* Roots *)

     

       777
       777
       +
       

     

       778
       778
       +
       module Roots = struct

     

       779
       779
       +
         type root = {

     

       780
       780
       +
           uri : string;

     

       781
       781
       +
           name : string option;

     

       782
       782
       +
           unknown : Jsont.json;

     

       783
       783
       +
         }

     

       784
       784
       +
       

     

       785
       785
       +
         let make_root ~uri ?name () =

     

       786
       786
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       787
       787
       +
           { uri; name; unknown }

     

       788
       788
       +
       

     

       789
       789
       +
         let root_jsont : root Jsont.t =

     

       790
       790
       +
           let make uri name unknown = { uri; name; unknown } in

     

       791
       791
       +
           Jsont.Object.map ~kind:"Root" make

     

       792
       792
       +
           |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)

     

       793
       793
       +
           |> Jsont.Object.opt_mem "name" Jsont.string ~enc:(fun r -> r.name)

     

       794
       794
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)

     

       795
       795
       +
           |> Jsont.Object.finish

     

       796
       796
       +
       

     

       797
       797
       +
         type list_request = {

     

       798
       798
       +
           unknown : Jsont.json;

     

       799
       799
       +
         }

     

       800
       800
       +
       

     

       801
       801
       +
         let make_list_request () =

     

       802
       802
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       803
       803
       +
           { unknown }

     

       804
       804
       +
       

     

       805
       805
       +
         let list_request_jsont : list_request Jsont.t =

     

       806
       806
       +
           let make unknown = { unknown } in

     

       807
       807
       +
           Jsont.Object.map ~kind:"RootsListRequest" make

     

       808
       808
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)

     

       809
       809
       +
           |> Jsont.Object.finish

     

       810
       810
       +
       

     

       811
       811
       +
         type list_result = {

     

       812
       812
       +
           roots : root list;

     

       813
       813
       +
           unknown : Jsont.json;

     

       814
       814
       +
         }

     

       815
       815
       +
       

     

       816
       816
       +
         let make_list_result ~roots =

     

       817
       817
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       818
       818
       +
           { roots; unknown }

     

       819
       819
       +
       

     

       820
       820
       +
         let list_result_jsont : list_result Jsont.t =

     

       821
       821
       +
           let make roots unknown = { roots; unknown } in

     

       822
       822
       +
           Jsont.Object.map ~kind:"RootsListResult" make

     

       823
       823
       +
           |> Jsont.Object.mem "roots" (Jsont.list root_jsont)

     

       824
       824
       +
               ~enc:(fun r -> r.roots)

     

       825
       825
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)

     

       826
       826
       +
           |> Jsont.Object.finish

     

       827
       827
       +
       

     

       828
       828
       +
         type list_changed_notification = {

     

       829
       829
       +
           unknown : Jsont.json;

     

       830
       830
       +
         }

     

       831
       831
       +
       

     

       832
       832
       +
         let make_list_changed_notification () =

     

       833
       833
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       834
       834
       +
           { unknown }

     

       835
       835
       +
       

     

       836
       836
       +
         let list_changed_notification_jsont : list_changed_notification Jsont.t =

     

       837
       837
       +
           let make unknown = { unknown } in

     

       838
       838
       +
           Jsont.Object.map ~kind:"RootsListChangedNotification" make

     

       839
       839
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun n -> n.unknown)

     

       840
       840
       +
           |> Jsont.Object.finish

     

       841
       841
       +
       

     

       842
       842
       +
         let list_method = "roots/list"

     

       843
       843
       +
         let list_changed_notification_method = "notifications/roots/list_changed"

     

       844
       844
       +
       end

     

       845
       845
       +
       

     

       846
       846
       +
       (* Progress *)

     

       847
       847
       +
       

     

       848
       848
       +
       module Progress = struct

     

       849
       849
       +
         type notification = {

     

       850
       850
       +
           progress_token : string;

     

       851
       851
       +
           progress : float;

     

       852
       852
       +
           total : float option;

     

       853
       853
       +
           unknown : Jsont.json;

     

       854
       854
       +
         }

     

       855
       855
       +
       

     

       856
       856
       +
         let make_notification ~progress_token ~progress ?total () =

     

       857
       857
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       858
       858
       +
           { progress_token; progress; total; unknown }

     

       859
       859
       +
       

     

       860
       860
       +
         let notification_jsont : notification Jsont.t =

     

       861
       861
       +
           let make progress_token progress total unknown =

     

       862
       862
       +
             { progress_token; progress; total; unknown }

     

       863
       863
       +
           in

     

       864
       864
       +
           Jsont.Object.map ~kind:"ProgressNotification" make

     

       865
       865
       +
           |> Jsont.Object.mem "progressToken" Jsont.string

     

       866
       866
       +
               ~enc:(fun n -> n.progress_token)

     

       867
       867
       +
           |> Jsont.Object.mem "progress" Jsont.number ~enc:(fun n -> n.progress)

     

       868
       868
       +
           |> Jsont.Object.opt_mem "total" Jsont.number ~enc:(fun n -> n.total)

     

       869
       869
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun n -> n.unknown)

     

       870
       870
       +
           |> Jsont.Object.finish

     

       871
       871
       +
       

     

       872
       872
       +
         let method_ = "notifications/progress"

     

       873
       873
       +
       end

     

       874
       874
       +
       

     

       875
       875
       +
       (* Cancellation *)

     

       876
       876
       +
       

     

       877
       877
       +
       module Cancellation = struct

     

       878
       878
       +
         type notification = {

     

       879
       879
       +
           request_id : Jsonrpc.Id.t;

     

       880
       880
       +
           reason : string option;

     

       881
       881
       +
           unknown : Jsont.json;

     

       882
       882
       +
         }

     

       883
       883
       +
       

     

       884
       884
       +
         let make_notification ~request_id ?reason () =

     

       885
       885
       +
           let unknown = Jsont.Object ([], Jsont.Meta.none) in

     

       886
       886
       +
           { request_id; reason; unknown }

     

       887
       887
       +
       

     

       888
       888
       +
         let notification_jsont : notification Jsont.t =

     

       889
       889
       +
           let make request_id reason unknown =

     

       890
       890
       +
             { request_id; reason; unknown }

     

       891
       891
       +
           in

     

       892
       892
       +
           Jsont.Object.map ~kind:"CancellationNotification" make

     

       893
       893
       +
           |> Jsont.Object.mem "requestId" Jsonrpc.Id.jsont

     

       894
       894
       +
               ~enc:(fun n -> n.request_id)

     

       895
       895
       +
           |> Jsont.Object.opt_mem "reason" Jsont.string ~enc:(fun n -> n.reason)

     

       896
       896
       +
           |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun n -> n.unknown)

     

       897
       897
       +
           |> Jsont.Object.finish

     

       898
       898
       +
       

     

       899
       899
       +
         let method_ = "notifications/cancelled"

     

       900
       900
       +
       end

+660

claudeio/lib_mcp/messages.mli

···

       1
       1
       +
       (** MCP Protocol Messages.

     

       2
       2
       +
       

     

       3
       3
       +
           This module provides all protocol message types for the Model Context Protocol (MCP).

     

       4
       4
       +
           It includes initialization, resources, tools, prompts, logging, and other protocol messages.

     

       5
       5
       +
       

     

       6
       6
       +
           All types include unknown field preservation for forward compatibility. *)

     

       7
       7
       +
       

     

       8
       8
       +
       (** {1 Protocol Version} *)

     

       9
       9
       +
       

     

       10
       10
       +
       type protocol_version = string

     

       11
       11
       +
       (** MCP protocol version string (e.g., "2024-11-05") *)

     

       12
       12
       +
       

     

       13
       13
       +
       val protocol_version_jsont : protocol_version Jsont.t

     

       14
       14
       +
       

     

       15
       15
       +
       (** {1 Initialize Protocol} *)

     

       16
       16
       +
       

     

       17
       17
       +
       module Initialize : sig

     

       18
       18
       +
         (** Initialize request parameters *)

     

       19
       19
       +
         type request_params = {

     

       20
       20
       +
           protocol_version : protocol_version;

     

       21
       21
       +
           capabilities : Capabilities.Client.t;

     

       22
       22
       +
           client_info : Capabilities.Implementation.t;

     

       23
       23
       +
           unknown : Jsont.json;

     

       24
       24
       +
         }

     

       25
       25
       +
       

     

       26
       26
       +
         val make_request_params :

     

       27
       27
       +
           protocol_version:protocol_version ->

     

       28
       28
       +
           capabilities:Capabilities.Client.t ->

     

       29
       29
       +
           client_info:Capabilities.Implementation.t ->

     

       30
       30
       +
           unit ->

     

       31
       31
       +
           request_params

     

       32
       32
       +
       

     

       33
       33
       +
         val request_params_jsont : request_params Jsont.t

     

       34
       34
       +
       

     

       35
       35
       +
         (** Initialize result *)

     

       36
       36
       +
         type result = {

     

       37
       37
       +
           protocol_version : protocol_version;

     

       38
       38
       +
           capabilities : Capabilities.Server.t;

     

       39
       39
       +
           server_info : Capabilities.Implementation.t;

     

       40
       40
       +
           instructions : string option;

     

       41
       41
       +
           unknown : Jsont.json;

     

       42
       42
       +
         }

     

       43
       43
       +
       

     

       44
       44
       +
         val make_result :

     

       45
       45
       +
           protocol_version:protocol_version ->

     

       46
       46
       +
           capabilities:Capabilities.Server.t ->

     

       47
       47
       +
           server_info:Capabilities.Implementation.t ->

     

       48
       48
       +
           ?instructions:string ->

     

       49
       49
       +
           unit ->

     

       50
       50
       +
           result

     

       51
       51
       +
       

     

       52
       52
       +
         val result_jsont : result Jsont.t

     

       53
       53
       +
       

     

       54
       54
       +
         val method_ : string

     

       55
       55
       +
         (** Method name: "initialize" *)

     

       56
       56
       +
       end

     

       57
       57
       +
       

     

       58
       58
       +
       module Initialized : sig

     

       59
       59
       +
         (** Initialized notification (sent after initialize completes) *)

     

       60
       60
       +
         type notification = {

     

       61
       61
       +
           unknown : Jsont.json;

     

       62
       62
       +
         }

     

       63
       63
       +
       

     

       64
       64
       +
         val make_notification : unit -> notification

     

       65
       65
       +
         val notification_jsont : notification Jsont.t

     

       66
       66
       +
       

     

       67
       67
       +
         val method_ : string

     

       68
       68
       +
         (** Method name: "notifications/initialized" *)

     

       69
       69
       +
       end

     

       70
       70
       +
       

     

       71
       71
       +
       module Ping : sig

     

       72
       72
       +
         (** Ping request (keepalive) *)

     

       73
       73
       +
         type params = {

     

       74
       74
       +
           unknown : Jsont.json;

     

       75
       75
       +
         }

     

       76
       76
       +
       

     

       77
       77
       +
         val make_params : unit -> params

     

       78
       78
       +
         val params_jsont : params Jsont.t

     

       79
       79
       +
       

     

       80
       80
       +
         (** Ping result (empty object) *)

     

       81
       81
       +
         type result = {

     

       82
       82
       +
           unknown : Jsont.json;

     

       83
       83
       +
         }

     

       84
       84
       +
       

     

       85
       85
       +
         val make_result : unit -> result

     

       86
       86
       +
         val result_jsont : result Jsont.t

     

       87
       87
       +
       

     

       88
       88
       +
         val method_ : string

     

       89
       89
       +
         (** Method name: "ping" *)

     

       90
       90
       +
       end

     

       91
       91
       +
       

     

       92
       92
       +
       (** {1 Resources} *)

     

       93
       93
       +
       

     

       94
       94
       +
       module Resources : sig

     

       95
       95
       +
         (** Resource descriptor *)

     

       96
       96
       +
         type resource = {

     

       97
       97
       +
           uri : string;

     

       98
       98
       +
           name : string;

     

       99
       99
       +
           description : string option;

     

       100
       100
       +
           mime_type : string option;

     

       101
       101
       +
           unknown : Jsont.json;

     

       102
       102
       +
         }

     

       103
       103
       +
       

     

       104
       104
       +
         val make_resource :

     

       105
       105
       +
           uri:string ->

     

       106
       106
       +
           name:string ->

     

       107
       107
       +
           ?description:string ->

     

       108
       108
       +
           ?mime_type:string ->

     

       109
       109
       +
           unit ->

     

       110
       110
       +
           resource

     

       111
       111
       +
       

     

       112
       112
       +
         val resource_jsont : resource Jsont.t

     

       113
       113
       +
       

     

       114
       114
       +
         (** Resource template (URI template with placeholders) *)

     

       115
       115
       +
         type resource_template = {

     

       116
       116
       +
           uri_template : string;

     

       117
       117
       +
           name : string;

     

       118
       118
       +
           description : string option;

     

       119
       119
       +
           mime_type : string option;

     

       120
       120
       +
           unknown : Jsont.json;

     

       121
       121
       +
         }

     

       122
       122
       +
       

     

       123
       123
       +
         val make_resource_template :

     

       124
       124
       +
           uri_template:string ->

     

       125
       125
       +
           name:string ->

     

       126
       126
       +
           ?description:string ->

     

       127
       127
       +
           ?mime_type:string ->

     

       128
       128
       +
           unit ->

     

       129
       129
       +
           resource_template

     

       130
       130
       +
       

     

       131
       131
       +
         val resource_template_jsont : resource_template Jsont.t

     

       132
       132
       +
       

     

       133
       133
       +
         (** Resource contents (from read request) *)

     

       134
       134
       +
         type resource_contents = {

     

       135
       135
       +
           uri : string;

     

       136
       136
       +
           mime_type : string option;

     

       137
       137
       +
           text : string option;

     

       138
       138
       +
           blob : string option;  (** Base64-encoded binary data *)

     

       139
       139
       +
           unknown : Jsont.json;

     

       140
       140
       +
         }

     

       141
       141
       +
       

     

       142
       142
       +
         val make_text_contents :

     

       143
       143
       +
           uri:string ->

     

       144
       144
       +
           text:string ->

     

       145
       145
       +
           ?mime_type:string ->

     

       146
       146
       +
           unit ->

     

       147
       147
       +
           resource_contents

     

       148
       148
       +
       

     

       149
       149
       +
         val make_blob_contents :

     

       150
       150
       +
           uri:string ->

     

       151
       151
       +
           blob:string ->

     

       152
       152
       +
           mime_type:string ->

     

       153
       153
       +
           resource_contents

     

       154
       154
       +
       

     

       155
       155
       +
         val resource_contents_jsont : resource_contents Jsont.t

     

       156
       156
       +
       

     

       157
       157
       +
         (** List resources request *)

     

       158
       158
       +
         type list_request = {

     

       159
       159
       +
           cursor : string option;

     

       160
       160
       +
           unknown : Jsont.json;

     

       161
       161
       +
         }

     

       162
       162
       +
       

     

       163
       163
       +
         val make_list_request : ?cursor:string -> unit -> list_request

     

       164
       164
       +
         val list_request_jsont : list_request Jsont.t

     

       165
       165
       +
       

     

       166
       166
       +
         (** List resources result *)

     

       167
       167
       +
         type list_result = {

     

       168
       168
       +
           resources : resource list;

     

       169
       169
       +
           next_cursor : string option;

     

       170
       170
       +
           unknown : Jsont.json;

     

       171
       171
       +
         }

     

       172
       172
       +
       

     

       173
       173
       +
         val make_list_result :

     

       174
       174
       +
           resources:resource list ->

     

       175
       175
       +
           ?next_cursor:string ->

     

       176
       176
       +
           unit ->

     

       177
       177
       +
           list_result

     

       178
       178
       +
       

     

       179
       179
       +
         val list_result_jsont : list_result Jsont.t

     

       180
       180
       +
       

     

       181
       181
       +
         (** Read resource request *)

     

       182
       182
       +
         type read_request = {

     

       183
       183
       +
           uri : string;

     

       184
       184
       +
           unknown : Jsont.json;

     

       185
       185
       +
         }

     

       186
       186
       +
       

     

       187
       187
       +
         val make_read_request : uri:string -> read_request

     

       188
       188
       +
         val read_request_jsont : read_request Jsont.t

     

       189
       189
       +
       

     

       190
       190
       +
         (** Read resource result *)

     

       191
       191
       +
         type read_result = {

     

       192
       192
       +
           contents : resource_contents list;

     

       193
       193
       +
           unknown : Jsont.json;

     

       194
       194
       +
         }

     

       195
       195
       +
       

     

       196
       196
       +
         val make_read_result : contents:resource_contents list -> read_result

     

       197
       197
       +
         val read_result_jsont : read_result Jsont.t

     

       198
       198
       +
       

     

       199
       199
       +
         (** Subscribe to resource updates *)

     

       200
       200
       +
         type subscribe_request = {

     

       201
       201
       +
           uri : string;

     

       202
       202
       +
           unknown : Jsont.json;

     

       203
       203
       +
         }

     

       204
       204
       +
       

     

       205
       205
       +
         val make_subscribe_request : uri:string -> subscribe_request

     

       206
       206
       +
         val subscribe_request_jsont : subscribe_request Jsont.t

     

       207
       207
       +
       

     

       208
       208
       +
         (** Unsubscribe from resource updates *)

     

       209
       209
       +
         type unsubscribe_request = {

     

       210
       210
       +
           uri : string;

     

       211
       211
       +
           unknown : Jsont.json;

     

       212
       212
       +
         }

     

       213
       213
       +
       

     

       214
       214
       +
         val make_unsubscribe_request : uri:string -> unsubscribe_request

     

       215
       215
       +
         val unsubscribe_request_jsont : unsubscribe_request Jsont.t

     

       216
       216
       +
       

     

       217
       217
       +
         (** Resource updated notification *)

     

       218
       218
       +
         type updated_notification = {

     

       219
       219
       +
           uri : string;

     

       220
       220
       +
           unknown : Jsont.json;

     

       221
       221
       +
         }

     

       222
       222
       +
       

     

       223
       223
       +
         val make_updated_notification : uri:string -> updated_notification

     

       224
       224
       +
         val updated_notification_jsont : updated_notification Jsont.t

     

       225
       225
       +
       

     

       226
       226
       +
         (** Resource list changed notification *)

     

       227
       227
       +
         type list_changed_notification = {

     

       228
       228
       +
           unknown : Jsont.json;

     

       229
       229
       +
         }

     

       230
       230
       +
       

     

       231
       231
       +
         val make_list_changed_notification : unit -> list_changed_notification

     

       232
       232
       +
         val list_changed_notification_jsont : list_changed_notification Jsont.t

     

       233
       233
       +
       

     

       234
       234
       +
         val list_method : string

     

       235
       235
       +
         (** Method name: "resources/list" *)

     

       236
       236
       +
       

     

       237
       237
       +
         val read_method : string

     

       238
       238
       +
         (** Method name: "resources/read" *)

     

       239
       239
       +
       

     

       240
       240
       +
         val subscribe_method : string

     

       241
       241
       +
         (** Method name: "resources/subscribe" *)

     

       242
       242
       +
       

     

       243
       243
       +
         val unsubscribe_method : string

     

       244
       244
       +
         (** Method name: "resources/unsubscribe" *)

     

       245
       245
       +
       

     

       246
       246
       +
         val updated_notification_method : string

     

       247
       247
       +
         (** Method name: "notifications/resources/updated" *)

     

       248
       248
       +
       

     

       249
       249
       +
         val list_changed_notification_method : string

     

       250
       250
       +
         (** Method name: "notifications/resources/list_changed" *)

     

       251
       251
       +
       end

     

       252
       252
       +
       

     

       253
       253
       +
       (** {1 Tools} *)

     

       254
       254
       +
       

     

       255
       255
       +
       module Tools : sig

     

       256
       256
       +
         (** Tool descriptor *)

     

       257
       257
       +
         type tool = {

     

       258
       258
       +
           name : string;

     

       259
       259
       +
           description : string option;

     

       260
       260
       +
           input_schema : Jsont.json;  (** JSON Schema for tool inputs *)

     

       261
       261
       +
           unknown : Jsont.json;

     

       262
       262
       +
         }

     

       263
       263
       +
       

     

       264
       264
       +
         val make_tool :

     

       265
       265
       +
           name:string ->

     

       266
       266
       +
           ?description:string ->

     

       267
       267
       +
           input_schema:Jsont.json ->

     

       268
       268
       +
           unit ->

     

       269
       269
       +
           tool

     

       270
       270
       +
       

     

       271
       271
       +
         val tool_jsont : tool Jsont.t

     

       272
       272
       +
       

     

       273
       273
       +
         (** List tools request *)

     

       274
       274
       +
         type list_request = {

     

       275
       275
       +
           cursor : string option;

     

       276
       276
       +
           unknown : Jsont.json;

     

       277
       277
       +
         }

     

       278
       278
       +
       

     

       279
       279
       +
         val make_list_request : ?cursor:string -> unit -> list_request

     

       280
       280
       +
         val list_request_jsont : list_request Jsont.t

     

       281
       281
       +
       

     

       282
       282
       +
         (** List tools result *)

     

       283
       283
       +
         type list_result = {

     

       284
       284
       +
           tools : tool list;

     

       285
       285
       +
           next_cursor : string option;

     

       286
       286
       +
           unknown : Jsont.json;

     

       287
       287
       +
         }

     

       288
       288
       +
       

     

       289
       289
       +
         val make_list_result :

     

       290
       290
       +
           tools:tool list ->

     

       291
       291
       +
           ?next_cursor:string ->

     

       292
       292
       +
           unit ->

     

       293
       293
       +
           list_result

     

       294
       294
       +
       

     

       295
       295
       +
         val list_result_jsont : list_result Jsont.t

     

       296
       296
       +
       

     

       297
       297
       +
         (** Call tool request *)

     

       298
       298
       +
         type call_request = {

     

       299
       299
       +
           name : string;

     

       300
       300
       +
           arguments : Jsont.json option;

     

       301
       301
       +
           unknown : Jsont.json;

     

       302
       302
       +
         }

     

       303
       303
       +
       

     

       304
       304
       +
         val make_call_request :

     

       305
       305
       +
           name:string ->

     

       306
       306
       +
           ?arguments:Jsont.json ->

     

       307
       307
       +
           unit ->

     

       308
       308
       +
           call_request

     

       309
       309
       +
       

     

       310
       310
       +
         val call_request_jsont : call_request Jsont.t

     

       311
       311
       +
       

     

       312
       312
       +
         (** Call tool result *)

     

       313
       313
       +
         type call_result = {

     

       314
       314
       +
           content : Content.block list;

     

       315
       315
       +
           is_error : bool option;

     

       316
       316
       +
           unknown : Jsont.json;

     

       317
       317
       +
         }

     

       318
       318
       +
       

     

       319
       319
       +
         val make_call_result :

     

       320
       320
       +
           content:Content.block list ->

     

       321
       321
       +
           ?is_error:bool ->

     

       322
       322
       +
           unit ->

     

       323
       323
       +
           call_result

     

       324
       324
       +
       

     

       325
       325
       +
         val call_result_jsont : call_result Jsont.t

     

       326
       326
       +
       

     

       327
       327
       +
         (** Tool list changed notification *)

     

       328
       328
       +
         type list_changed_notification = {

     

       329
       329
       +
           unknown : Jsont.json;

     

       330
       330
       +
         }

     

       331
       331
       +
       

     

       332
       332
       +
         val make_list_changed_notification : unit -> list_changed_notification

     

       333
       333
       +
         val list_changed_notification_jsont : list_changed_notification Jsont.t

     

       334
       334
       +
       

     

       335
       335
       +
         val list_method : string

     

       336
       336
       +
         (** Method name: "tools/list" *)

     

       337
       337
       +
       

     

       338
       338
       +
         val call_method : string

     

       339
       339
       +
         (** Method name: "tools/call" *)

     

       340
       340
       +
       

     

       341
       341
       +
         val list_changed_notification_method : string

     

       342
       342
       +
         (** Method name: "notifications/tools/list_changed" *)

     

       343
       343
       +
       end

     

       344
       344
       +
       

     

       345
       345
       +
       (** {1 Prompts} *)

     

       346
       346
       +
       

     

       347
       347
       +
       module Prompts : sig

     

       348
       348
       +
         (** Prompt argument descriptor *)

     

       349
       349
       +
         type prompt_argument = {

     

       350
       350
       +
           name : string;

     

       351
       351
       +
           description : string option;

     

       352
       352
       +
           required : bool option;

     

       353
       353
       +
           unknown : Jsont.json;

     

       354
       354
       +
         }

     

       355
       355
       +
       

     

       356
       356
       +
         val make_prompt_argument :

     

       357
       357
       +
           name:string ->

     

       358
       358
       +
           ?description:string ->

     

       359
       359
       +
           ?required:bool ->

     

       360
       360
       +
           unit ->

     

       361
       361
       +
           prompt_argument

     

       362
       362
       +
       

     

       363
       363
       +
         val prompt_argument_jsont : prompt_argument Jsont.t

     

       364
       364
       +
       

     

       365
       365
       +
         (** Prompt descriptor *)

     

       366
       366
       +
         type prompt = {

     

       367
       367
       +
           name : string;

     

       368
       368
       +
           description : string option;

     

       369
       369
       +
           arguments : prompt_argument list option;

     

       370
       370
       +
           unknown : Jsont.json;

     

       371
       371
       +
         }

     

       372
       372
       +
       

     

       373
       373
       +
         val make_prompt :

     

       374
       374
       +
           name:string ->

     

       375
       375
       +
           ?description:string ->

     

       376
       376
       +
           ?arguments:prompt_argument list ->

     

       377
       377
       +
           unit ->

     

       378
       378
       +
           prompt

     

       379
       379
       +
       

     

       380
       380
       +
         val prompt_jsont : prompt Jsont.t

     

       381
       381
       +
       

     

       382
       382
       +
         (** Prompt message role *)

     

       383
       383
       +
         type role = User | Assistant

     

       384
       384
       +
       

     

       385
       385
       +
         val role_jsont : role Jsont.t

     

       386
       386
       +
       

     

       387
       387
       +
         (** Prompt message *)

     

       388
       388
       +
         type prompt_message = {

     

       389
       389
       +
           role : role;

     

       390
       390
       +
           content : Content.block list;

     

       391
       391
       +
           unknown : Jsont.json;

     

       392
       392
       +
         }

     

       393
       393
       +
       

     

       394
       394
       +
         val make_prompt_message :

     

       395
       395
       +
           role:role ->

     

       396
       396
       +
           content:Content.block list ->

     

       397
       397
       +
           unit ->

     

       398
       398
       +
           prompt_message

     

       399
       399
       +
       

     

       400
       400
       +
         val prompt_message_jsont : prompt_message Jsont.t

     

       401
       401
       +
       

     

       402
       402
       +
         (** List prompts request *)

     

       403
       403
       +
         type list_request = {

     

       404
       404
       +
           cursor : string option;

     

       405
       405
       +
           unknown : Jsont.json;

     

       406
       406
       +
         }

     

       407
       407
       +
       

     

       408
       408
       +
         val make_list_request : ?cursor:string -> unit -> list_request

     

       409
       409
       +
         val list_request_jsont : list_request Jsont.t

     

       410
       410
       +
       

     

       411
       411
       +
         (** List prompts result *)

     

       412
       412
       +
         type list_result = {

     

       413
       413
       +
           prompts : prompt list;

     

       414
       414
       +
           next_cursor : string option;

     

       415
       415
       +
           unknown : Jsont.json;

     

       416
       416
       +
         }

     

       417
       417
       +
       

     

       418
       418
       +
         val make_list_result :

     

       419
       419
       +
           prompts:prompt list ->

     

       420
       420
       +
           ?next_cursor:string ->

     

       421
       421
       +
           unit ->

     

       422
       422
       +
           list_result

     

       423
       423
       +
       

     

       424
       424
       +
         val list_result_jsont : list_result Jsont.t

     

       425
       425
       +
       

     

       426
       426
       +
         (** Get prompt request *)

     

       427
       427
       +
         type get_request = {

     

       428
       428
       +
           name : string;

     

       429
       429
       +
           arguments : (string * string) list option;  (** Key-value pairs *)

     

       430
       430
       +
           unknown : Jsont.json;

     

       431
       431
       +
         }

     

       432
       432
       +
       

     

       433
       433
       +
         val make_get_request :

     

       434
       434
       +
           name:string ->

     

       435
       435
       +
           ?arguments:(string * string) list ->

     

       436
       436
       +
           unit ->

     

       437
       437
       +
           get_request

     

       438
       438
       +
       

     

       439
       439
       +
         val get_request_jsont : get_request Jsont.t

     

       440
       440
       +
       

     

       441
       441
       +
         (** Get prompt result *)

     

       442
       442
       +
         type get_result = {

     

       443
       443
       +
           description : string option;

     

       444
       444
       +
           messages : prompt_message list;

     

       445
       445
       +
           unknown : Jsont.json;

     

       446
       446
       +
         }

     

       447
       447
       +
       

     

       448
       448
       +
         val make_get_result :

     

       449
       449
       +
           ?description:string ->

     

       450
       450
       +
           messages:prompt_message list ->

     

       451
       451
       +
           unit ->

     

       452
       452
       +
           get_result

     

       453
       453
       +
       

     

       454
       454
       +
         val get_result_jsont : get_result Jsont.t

     

       455
       455
       +
       

     

       456
       456
       +
         (** Prompt list changed notification *)

     

       457
       457
       +
         type list_changed_notification = {

     

       458
       458
       +
           unknown : Jsont.json;

     

       459
       459
       +
         }

     

       460
       460
       +
       

     

       461
       461
       +
         val make_list_changed_notification : unit -> list_changed_notification

     

       462
       462
       +
         val list_changed_notification_jsont : list_changed_notification Jsont.t

     

       463
       463
       +
       

     

       464
       464
       +
         val list_method : string

     

       465
       465
       +
         (** Method name: "prompts/list" *)

     

       466
       466
       +
       

     

       467
       467
       +
         val get_method : string

     

       468
       468
       +
         (** Method name: "prompts/get" *)

     

       469
       469
       +
       

     

       470
       470
       +
         val list_changed_notification_method : string

     

       471
       471
       +
         (** Method name: "notifications/prompts/list_changed" *)

     

       472
       472
       +
       end

     

       473
       473
       +
       

     

       474
       474
       +
       (** {1 Logging} *)

     

       475
       475
       +
       

     

       476
       476
       +
       module Logging : sig

     

       477
       477
       +
         (** Log level *)

     

       478
       478
       +
         type level =

     

       479
       479
       +
           | Debug

     

       480
       480
       +
           | Info

     

       481
       481
       +
           | Notice

     

       482
       482
       +
           | Warning

     

       483
       483
       +
           | Error

     

       484
       484
       +
           | Critical

     

       485
       485
       +
           | Alert

     

       486
       486
       +
           | Emergency

     

       487
       487
       +
       

     

       488
       488
       +
         val level_jsont : level Jsont.t

     

       489
       489
       +
         val level_to_string : level -> string

     

       490
       490
       +
       

     

       491
       491
       +
         (** Logging message notification *)

     

       492
       492
       +
         type notification = {

     

       493
       493
       +
           level : level;

     

       494
       494
       +
           logger : string option;

     

       495
       495
       +
           data : Jsont.json option;

     

       496
       496
       +
           unknown : Jsont.json;

     

       497
       497
       +
         }

     

       498
       498
       +
       

     

       499
       499
       +
         val make_notification :

     

       500
       500
       +
           level:level ->

     

       501
       501
       +
           ?logger:string ->

     

       502
       502
       +
           ?data:Jsont.json ->

     

       503
       503
       +
           unit ->

     

       504
       504
       +
           notification

     

       505
       505
       +
       

     

       506
       506
       +
         val notification_jsont : notification Jsont.t

     

       507
       507
       +
       

     

       508
       508
       +
         val method_ : string

     

       509
       509
       +
         (** Method name: "notifications/message" *)

     

       510
       510
       +
       end

     

       511
       511
       +
       

     

       512
       512
       +
       (** {1 Completions} *)

     

       513
       513
       +
       

     

       514
       514
       +
       module Completions : sig

     

       515
       515
       +
         (** Completion reference (argument or resource URI) *)

     

       516
       516
       +
         type completion_ref = {

     

       517
       517
       +
           ref_type : string;  (** "ref/prompt" or "ref/resource" *)

     

       518
       518
       +
           uri : string;

     

       519
       519
       +
           unknown : Jsont.json;

     

       520
       520
       +
         }

     

       521
       521
       +
       

     

       522
       522
       +
         val make_completion_ref :

     

       523
       523
       +
           ref_type:string ->

     

       524
       524
       +
           uri:string ->

     

       525
       525
       +
           unit ->

     

       526
       526
       +
           completion_ref

     

       527
       527
       +
       

     

       528
       528
       +
         val completion_ref_jsont : completion_ref Jsont.t

     

       529
       529
       +
       

     

       530
       530
       +
         (** Completion request *)

     

       531
       531
       +
         type request = {

     

       532
       532
       +
           ref_ : completion_ref;

     

       533
       533
       +
           argument : string option;

     

       534
       534
       +
           unknown : Jsont.json;

     

       535
       535
       +
         }

     

       536
       536
       +
       

     

       537
       537
       +
         val make_request :

     

       538
       538
       +
           ref_:completion_ref ->

     

       539
       539
       +
           ?argument:string ->

     

       540
       540
       +
           unit ->

     

       541
       541
       +
           request

     

       542
       542
       +
       

     

       543
       543
       +
         val request_jsont : request Jsont.t

     

       544
       544
       +
       

     

       545
       545
       +
         (** Completion result *)

     

       546
       546
       +
         type result = {

     

       547
       547
       +
           completion : string list;

     

       548
       548
       +
           total : int option;

     

       549
       549
       +
           has_more : bool option;

     

       550
       550
       +
           unknown : Jsont.json;

     

       551
       551
       +
         }

     

       552
       552
       +
       

     

       553
       553
       +
         val make_result :

     

       554
       554
       +
           completion:string list ->

     

       555
       555
       +
           ?total:int ->

     

       556
       556
       +
           ?has_more:bool ->

     

       557
       557
       +
           unit ->

     

       558
       558
       +
           result

     

       559
       559
       +
       

     

       560
       560
       +
         val result_jsont : result Jsont.t

     

       561
       561
       +
       

     

       562
       562
       +
         val method_ : string

     

       563
       563
       +
         (** Method name: "completion/complete" *)

     

       564
       564
       +
       end

     

       565
       565
       +
       

     

       566
       566
       +
       (** {1 Roots} *)

     

       567
       567
       +
       

     

       568
       568
       +
       module Roots : sig

     

       569
       569
       +
         (** Root descriptor *)

     

       570
       570
       +
         type root = {

     

       571
       571
       +
           uri : string;

     

       572
       572
       +
           name : string option;

     

       573
       573
       +
           unknown : Jsont.json;

     

       574
       574
       +
         }

     

       575
       575
       +
       

     

       576
       576
       +
         val make_root :

     

       577
       577
       +
           uri:string ->

     

       578
       578
       +
           ?name:string ->

     

       579
       579
       +
           unit ->

     

       580
       580
       +
           root

     

       581
       581
       +
       

     

       582
       582
       +
         val root_jsont : root Jsont.t

     

       583
       583
       +
       

     

       584
       584
       +
         (** List roots request *)

     

       585
       585
       +
         type list_request = {

     

       586
       586
       +
           unknown : Jsont.json;

     

       587
       587
       +
         }

     

       588
       588
       +
       

     

       589
       589
       +
         val make_list_request : unit -> list_request

     

       590
       590
       +
         val list_request_jsont : list_request Jsont.t

     

       591
       591
       +
       

     

       592
       592
       +
         (** List roots result *)

     

       593
       593
       +
         type list_result = {

     

       594
       594
       +
           roots : root list;

     

       595
       595
       +
           unknown : Jsont.json;

     

       596
       596
       +
         }

     

       597
       597
       +
       

     

       598
       598
       +
         val make_list_result : roots:root list -> list_result

     

       599
       599
       +
         val list_result_jsont : list_result Jsont.t

     

       600
       600
       +
       

     

       601
       601
       +
         (** Roots list changed notification *)

     

       602
       602
       +
         type list_changed_notification = {

     

       603
       603
       +
           unknown : Jsont.json;

     

       604
       604
       +
         }

     

       605
       605
       +
       

     

       606
       606
       +
         val make_list_changed_notification : unit -> list_changed_notification

     

       607
       607
       +
         val list_changed_notification_jsont : list_changed_notification Jsont.t

     

       608
       608
       +
       

     

       609
       609
       +
         val list_method : string

     

       610
       610
       +
         (** Method name: "roots/list" *)

     

       611
       611
       +
       

     

       612
       612
       +
         val list_changed_notification_method : string

     

       613
       613
       +
         (** Method name: "notifications/roots/list_changed" *)

     

       614
       614
       +
       end

     

       615
       615
       +
       

     

       616
       616
       +
       (** {1 Progress} *)

     

       617
       617
       +
       

     

       618
       618
       +
       module Progress : sig

     

       619
       619
       +
         (** Progress notification *)

     

       620
       620
       +
         type notification = {

     

       621
       621
       +
           progress_token : string;  (** Unique token identifying the operation *)

     

       622
       622
       +
           progress : float;         (** Progress value (0.0 to 1.0) *)

     

       623
       623
       +
           total : float option;     (** Optional total value *)

     

       624
       624
       +
           unknown : Jsont.json;

     

       625
       625
       +
         }

     

       626
       626
       +
       

     

       627
       627
       +
         val make_notification :

     

       628
       628
       +
           progress_token:string ->

     

       629
       629
       +
           progress:float ->

     

       630
       630
       +
           ?total:float ->

     

       631
       631
       +
           unit ->

     

       632
       632
       +
           notification

     

       633
       633
       +
       

     

       634
       634
       +
         val notification_jsont : notification Jsont.t

     

       635
       635
       +
       

     

       636
       636
       +
         val method_ : string

     

       637
       637
       +
         (** Method name: "notifications/progress" *)

     

       638
       638
       +
       end

     

       639
       639
       +
       

     

       640
       640
       +
       (** {1 Cancellation} *)

     

       641
       641
       +
       

     

       642
       642
       +
       module Cancellation : sig

     

       643
       643
       +
         (** Cancel request notification *)

     

       644
       644
       +
         type notification = {

     

       645
       645
       +
           request_id : Jsonrpc.Id.t;

     

       646
       646
       +
           reason : string option;

     

       647
       647
       +
           unknown : Jsont.json;

     

       648
       648
       +
         }

     

       649
       649
       +
       

     

       650
       650
       +
         val make_notification :

     

       651
       651
       +
           request_id:Jsonrpc.Id.t ->

     

       652
       652
       +
           ?reason:string ->

     

       653
       653
       +
           unit ->

     

       654
       654
       +
           notification

     

       655
       655
       +
       

     

       656
       656
       +
         val notification_jsont : notification Jsont.t

     

       657
       657
       +
       

     

       658
       658
       +
         val method_ : string

     

       659
       659
       +
         (** Method name: "notifications/cancelled" *)

     

       660
       660
       +
       end

+371

claudeio/lib_mcp/server_session.ml

···

       1
       1
       +
       (** High-level MCP server session API *)

     

       2
       2
       +
       

     

       3
       3
       +
       (** {1 Types} *)

     

       4
       4
       +
       

     

       5
       5
       +
       type config = {

     

       6
       6
       +
         server_info : Capabilities.Implementation.t;

     

       7
       7
       +
         server_capabilities : Capabilities.Server.t;

     

       8
       8
       +
         instructions : string option;

     

       9
       9
       +
       }

     

       10
       10
       +
       

     

       11
       11
       +
       type handlers = {

     

       12
       12
       +
         list_resources : (cursor:string option -> Messages.Resources.list_result) option;

     

       13
       13
       +
         list_resource_templates : (cursor:string option -> Messages.Resources.list_result) option;

     

       14
       14
       +
         read_resource : (uri:string -> Messages.Resources.read_result) option;

     

       15
       15
       +
         subscribe_resource : (uri:string -> unit) option;

     

       16
       16
       +
         unsubscribe_resource : (uri:string -> unit) option;

     

       17
       17
       +
         list_tools : (cursor:string option -> Messages.Tools.list_result) option;

     

       18
       18
       +
         call_tool : (name:string -> arguments:Jsont.json option -> Messages.Tools.call_result) option;

     

       19
       19
       +
         list_prompts : (cursor:string option -> Messages.Prompts.list_result) option;

     

       20
       20
       +
         get_prompt : (name:string -> arguments:(string * string) list option -> Messages.Prompts.get_result) option;

     

       21
       21
       +
         complete : (ref_:Messages.Completions.completion_ref -> argument:string -> Messages.Completions.result) option;

     

       22
       22
       +
         ping : (unit -> unit) option;

     

       23
       23
       +
       }

     

       24
       24
       +
       

     

       25
       25
       +
       type t = {

     

       26
       26
       +
         session : Session.t;

     

       27
       27
       +
         config : config;

     

       28
       28
       +
         handlers : handlers;

     

       29
       29
       +
         mutable client_capabilities : Capabilities.Client.t option;

     

       30
       30
       +
         mutable client_info : Capabilities.Implementation.t option;

     

       31
       31
       +
         mutable protocol_version : string option;

     

       32
       32
       +
         mutable initialized : bool;

     

       33
       33
       +
       }

     

       34
       34
       +
       

     

       35
       35
       +
       (** {1 Helper Functions} *)

     

       36
       36
       +
       

     

       37
       37
       +
       let encode_json jsont value =

     

       38
       38
       +
         match Jsont.Json.encode jsont value with

     

       39
       39
       +
         | Ok json -> json

     

       40
       40
       +
         | Error e -> failwith ("Failed to encode JSON: " ^ e)

     

       41
       41
       +
       

     

       42
       42
       +
       let decode_json jsont json =

     

       43
       43
       +
         match Jsont.Json.decode jsont json with

     

       44
       44
       +
         | Ok value -> value

     

       45
       45
       +
         | Error e -> failwith ("Failed to decode JSON: " ^ e)

     

       46
       46
       +
       

     

       47
       47
       +
       let method_not_found method_ =

     

       48
       48
       +
         let error = Jsonrpc.Error_data.make

     

       49
       49
       +
           ~code:Method_not_found

     

       50
       50
       +
           ~message:(Printf.sprintf "Method not found: %s" method_)

     

       51
       51
       +
           ()

     

       52
       52
       +
         in

     

       53
       53
       +
         raise (Session.Remote_error error)

     

       54
       54
       +
       

     

       55
       55
       +
       let invalid_params method_ msg =

     

       56
       56
       +
         let error = Jsonrpc.Error_data.make

     

       57
       57
       +
           ~code:Invalid_params

     

       58
       58
       +
           ~message:(Printf.sprintf "Invalid params for %s: %s" method_ msg)

     

       59
       59
       +
           ()

     

       60
       60
       +
         in

     

       61
       61
       +
         raise (Session.Remote_error error)

     

       62
       62
       +
       

     

       63
       63
       +
       (** {1 Request Handler} *)

     

       64
       64
       +
       

     

       65
       65
       +
       let handle_request t ~method_ ~params =

     

       66
       66
       +
         (* Ensure initialization has completed for non-init requests *)

     

       67
       67
       +
         if method_ <> Messages.Initialize.method_ && not t.initialized then begin

     

       68
       68
       +
           let error = Jsonrpc.Error_data.make

     

       69
       69
       +
             ~code:Internal_error

     

       70
       70
       +
             ~message:"Server not initialized"

     

       71
       71
       +
             ()

     

       72
       72
       +
           in

     

       73
       73
       +
           raise (Session.Remote_error error)

     

       74
       74
       +
         end;

     

       75
       75
       +
       

     

       76
       76
       +
         (* Route to appropriate handler *)

     

       77
       77
       +
         match method_ with

     

       78
       78
       +
         | m when m = Messages.Initialize.method_ ->

     

       79
       79
       +
             (* Handle initialization *)

     

       80
       80
       +
             let req_params = match params with

     

       81
       81
       +
               | Some p -> decode_json Messages.Initialize.request_params_jsont p

     

       82
       82
       +
               | None -> invalid_params method_ "missing params"

     

       83
       83
       +
             in

     

       84
       84
       +
       

     

       85
       85
       +
             (* Store client info *)

     

       86
       86
       +
             t.client_capabilities <- Some req_params.capabilities;

     

       87
       87
       +
             t.client_info <- Some req_params.client_info;

     

       88
       88
       +
             t.protocol_version <- Some req_params.protocol_version;

     

       89
       89
       +
       

     

       90
       90
       +
             (* Build response *)

     

       91
       91
       +
             let result = Messages.Initialize.make_result

     

       92
       92
       +
               ~protocol_version:req_params.protocol_version

     

       93
       93
       +
               ~capabilities:t.config.server_capabilities

     

       94
       94
       +
               ~server_info:t.config.server_info

     

       95
       95
       +
               ?instructions:t.config.instructions

     

       96
       96
       +
               ()

     

       97
       97
       +
             in

     

       98
       98
       +
             encode_json Messages.Initialize.result_jsont result

     

       99
       99
       +
       

     

       100
       100
       +
         | m when m = Messages.Ping.method_ ->

     

       101
       101
       +
             let handler = t.handlers.ping in

     

       102
       102
       +
             (match handler with

     

       103
       103
       +
              | None -> method_not_found method_

     

       104
       104
       +
              | Some h ->

     

       105
       105
       +
                  h ();

     

       106
       106
       +
                  let result = Messages.Ping.make_result () in

     

       107
       107
       +
                  encode_json Messages.Ping.result_jsont result)

     

       108
       108
       +
       

     

       109
       109
       +
         | m when m = Messages.Resources.list_method ->

     

       110
       110
       +
             let handler = t.handlers.list_resources in

     

       111
       111
       +
             (match handler with

     

       112
       112
       +
              | None -> method_not_found method_

     

       113
       113
       +
              | Some h ->

     

       114
       114
       +
                  let req = match params with

     

       115
       115
       +
                    | Some p -> decode_json Messages.Resources.list_request_jsont p

     

       116
       116
       +
                    | None -> Messages.Resources.make_list_request ()

     

       117
       117
       +
                  in

     

       118
       118
       +
                  let result = h ~cursor:req.cursor in

     

       119
       119
       +
                  encode_json Messages.Resources.list_result_jsont result)

     

       120
       120
       +
       

     

       121
       121
       +
         | m when m = Messages.Resources.read_method ->

     

       122
       122
       +
             let handler = t.handlers.read_resource in

     

       123
       123
       +
             (match handler with

     

       124
       124
       +
              | None -> method_not_found method_

     

       125
       125
       +
              | Some h ->

     

       126
       126
       +
                  let req = match params with

     

       127
       127
       +
                    | Some p -> decode_json Messages.Resources.read_request_jsont p

     

       128
       128
       +
                    | None -> invalid_params method_ "missing params"

     

       129
       129
       +
                  in

     

       130
       130
       +
                  let result = h ~uri:req.uri in

     

       131
       131
       +
                  encode_json Messages.Resources.read_result_jsont result)

     

       132
       132
       +
       

     

       133
       133
       +
         | m when m = Messages.Resources.subscribe_method ->

     

       134
       134
       +
             let handler = t.handlers.subscribe_resource in

     

       135
       135
       +
             (match handler with

     

       136
       136
       +
              | None -> method_not_found method_

     

       137
       137
       +
              | Some h ->

     

       138
       138
       +
                  let req = match params with

     

       139
       139
       +
                    | Some p -> decode_json Messages.Resources.subscribe_request_jsont p

     

       140
       140
       +
                    | None -> invalid_params method_ "missing params"

     

       141
       141
       +
                  in

     

       142
       142
       +
                  h ~uri:req.uri;

     

       143
       143
       +
                  Jsont.Object ([], Jsont.Meta.none))  (* Empty response *)

     

       144
       144
       +
       

     

       145
       145
       +
         | m when m = Messages.Resources.unsubscribe_method ->

     

       146
       146
       +
             let handler = t.handlers.unsubscribe_resource in

     

       147
       147
       +
             (match handler with

     

       148
       148
       +
              | None -> method_not_found method_

     

       149
       149
       +
              | Some h ->

     

       150
       150
       +
                  let req = match params with

     

       151
       151
       +
                    | Some p -> decode_json Messages.Resources.unsubscribe_request_jsont p

     

       152
       152
       +
                    | None -> invalid_params method_ "missing params"

     

       153
       153
       +
                  in

     

       154
       154
       +
                  h ~uri:req.uri;

     

       155
       155
       +
                  Jsont.Object ([], Jsont.Meta.none))  (* Empty response *)

     

       156
       156
       +
       

     

       157
       157
       +
         | m when m = Messages.Tools.list_method ->

     

       158
       158
       +
             let handler = t.handlers.list_tools in

     

       159
       159
       +
             (match handler with

     

       160
       160
       +
              | None -> method_not_found method_

     

       161
       161
       +
              | Some h ->

     

       162
       162
       +
                  let req = match params with

     

       163
       163
       +
                    | Some p -> decode_json Messages.Tools.list_request_jsont p

     

       164
       164
       +
                    | None -> Messages.Tools.make_list_request ()

     

       165
       165
       +
                  in

     

       166
       166
       +
                  let result = h ~cursor:req.cursor in

     

       167
       167
       +
                  encode_json Messages.Tools.list_result_jsont result)

     

       168
       168
       +
       

     

       169
       169
       +
         | m when m = Messages.Tools.call_method ->

     

       170
       170
       +
             let handler = t.handlers.call_tool in

     

       171
       171
       +
             (match handler with

     

       172
       172
       +
              | None -> method_not_found method_

     

       173
       173
       +
              | Some h ->

     

       174
       174
       +
                  let req = match params with

     

       175
       175
       +
                    | Some p -> decode_json Messages.Tools.call_request_jsont p

     

       176
       176
       +
                    | None -> invalid_params method_ "missing params"

     

       177
       177
       +
                  in

     

       178
       178
       +
                  let result = h ~name:req.name ~arguments:req.arguments in

     

       179
       179
       +
                  encode_json Messages.Tools.call_result_jsont result)

     

       180
       180
       +
       

     

       181
       181
       +
         | m when m = Messages.Prompts.list_method ->

     

       182
       182
       +
             let handler = t.handlers.list_prompts in

     

       183
       183
       +
             (match handler with

     

       184
       184
       +
              | None -> method_not_found method_

     

       185
       185
       +
              | Some h ->

     

       186
       186
       +
                  let req = match params with

     

       187
       187
       +
                    | Some p -> decode_json Messages.Prompts.list_request_jsont p

     

       188
       188
       +
                    | None -> Messages.Prompts.make_list_request ()

     

       189
       189
       +
                  in

     

       190
       190
       +
                  let result = h ~cursor:req.cursor in

     

       191
       191
       +
                  encode_json Messages.Prompts.list_result_jsont result)

     

       192
       192
       +
       

     

       193
       193
       +
         | m when m = Messages.Prompts.get_method ->

     

       194
       194
       +
             let handler = t.handlers.get_prompt in

     

       195
       195
       +
             (match handler with

     

       196
       196
       +
              | None -> method_not_found method_

     

       197
       197
       +
              | Some h ->

     

       198
       198
       +
                  let req = match params with

     

       199
       199
       +
                    | Some p -> decode_json Messages.Prompts.get_request_jsont p

     

       200
       200
       +
                    | None -> invalid_params method_ "missing params"

     

       201
       201
       +
                  in

     

       202
       202
       +
                  let result = h ~name:req.name ~arguments:req.arguments in

     

       203
       203
       +
                  encode_json Messages.Prompts.get_result_jsont result)

     

       204
       204
       +
       

     

       205
       205
       +
         | m when m = Messages.Completions.method_ ->

     

       206
       206
       +
             let handler = t.handlers.complete in

     

       207
       207
       +
             (match handler with

     

       208
       208
       +
              | None -> method_not_found method_

     

       209
       209
       +
              | Some h ->

     

       210
       210
       +
                  let req = match params with

     

       211
       211
       +
                    | Some p -> decode_json Messages.Completions.request_jsont p

     

       212
       212
       +
                    | None -> invalid_params method_ "missing params"

     

       213
       213
       +
                  in

     

       214
       214
       +
                  let argument = match req.argument with

     

       215
       215
       +
                    | Some a -> a

     

       216
       216
       +
                    | None -> ""

     

       217
       217
       +
                  in

     

       218
       218
       +
                  let result = h ~ref_:req.ref_ ~argument in

     

       219
       219
       +
                  encode_json Messages.Completions.result_jsont result)

     

       220
       220
       +
       

     

       221
       221
       +
         | _ ->

     

       222
       222
       +
             method_not_found method_

     

       223
       223
       +
       

     

       224
       224
       +
       (** {1 Notification Handler} *)

     

       225
       225
       +
       

     

       226
       226
       +
       let handle_notification t ~method_ ~params =

     

       227
       227
       +
         match method_ with

     

       228
       228
       +
         | m when m = Messages.Initialized.method_ ->

     

       229
       229
       +
             (* Client has confirmed initialization *)

     

       230
       230
       +
             let _notif = match params with

     

       231
       231
       +
               | Some p -> decode_json Messages.Initialized.notification_jsont p

     

       232
       232
       +
               | None -> Messages.Initialized.make_notification ()

     

       233
       233
       +
             in

     

       234
       234
       +
             t.initialized <- true

     

       235
       235
       +
       

     

       236
       236
       +
         | _ ->

     

       237
       237
       +
             (* Ignore unknown notifications *)

     

       238
       238
       +
             ()

     

       239
       239
       +
       

     

       240
       240
       +
       (** {1 Public API} *)

     

       241
       241
       +
       

     

       242
       242
       +
       let create ~sw ~transport ?timeout ?clock config handlers =

     

       243
       243
       +
         (* Create session with handlers *)

     

       244
       244
       +
         let t_ref = ref None in

     

       245
       245
       +
       

     

       246
       246
       +
         let request_handler ~method_ ~params =

     

       247
       247
       +
           match !t_ref with

     

       248
       248
       +
           | None -> failwith "Server session not initialized"

     

       249
       249
       +
           | Some t -> handle_request t ~method_ ~params

     

       250
       250
       +
         in

     

       251
       251
       +
       

     

       252
       252
       +
         let notification_handler ~method_ ~params =

     

       253
       253
       +
           match !t_ref with

     

       254
       254
       +
           | None -> ()

     

       255
       255
       +
           | Some t -> handle_notification t ~method_ ~params

     

       256
       256
       +
         in

     

       257
       257
       +
       

     

       258
       258
       +
         let session_config = {

     

       259
       259
       +
           Session.transport;

     

       260
       260
       +
           request_handler;

     

       261
       261
       +
           notification_handler;

     

       262
       262
       +
           timeout;

     

       263
       263
       +
           clock;

     

       264
       264
       +
         } in

     

       265
       265
       +
       

     

       266
       266
       +
         let session = Session.create ~sw session_config in

     

       267
       267
       +
       

     

       268
       268
       +
         let t = {

     

       269
       269
       +
           session;

     

       270
       270
       +
           config;

     

       271
       271
       +
           handlers;

     

       272
       272
       +
           client_capabilities = None;

     

       273
       273
       +
           client_info = None;

     

       274
       274
       +
           protocol_version = None;

     

       275
       275
       +
           initialized = false;

     

       276
       276
       +
         } in

     

       277
       277
       +
       

     

       278
       278
       +
         t_ref := Some t;

     

       279
       279
       +
       

     

       280
       280
       +
         t

     

       281
       281
       +
       

     

       282
       282
       +
       let client_capabilities t =

     

       283
       283
       +
         match t.client_capabilities with

     

       284
       284
       +
         | Some c -> c

     

       285
       285
       +
         | None -> invalid_arg "Server_session.client_capabilities: not initialized"

     

       286
       286
       +
       

     

       287
       287
       +
       let client_info t =

     

       288
       288
       +
         match t.client_info with

     

       289
       289
       +
         | Some i -> i

     

       290
       290
       +
         | None -> invalid_arg "Server_session.client_info: not initialized"

     

       291
       291
       +
       

     

       292
       292
       +
       let protocol_version t =

     

       293
       293
       +
         match t.protocol_version with

     

       294
       294
       +
         | Some v -> v

     

       295
       295
       +
         | None -> invalid_arg "Server_session.protocol_version: not initialized"

     

       296
       296
       +
       

     

       297
       297
       +
       (** {1 Sending Notifications} *)

     

       298
       298
       +
       

     

       299
       299
       +
       let send_notification t method_ params_jsont params =

     

       300
       300
       +
         let params_json = encode_json params_jsont params in

     

       301
       301
       +
         Session.send_notification t.session ~method_ ~params:params_json ()

     

       302
       302
       +
       

     

       303
       303
       +
       let send_resource_updated t ~uri =

     

       304
       304
       +
         let notif = Messages.Resources.make_updated_notification ~uri in

     

       305
       305
       +
         send_notification t

     

       306
       306
       +
           Messages.Resources.updated_notification_method

     

       307
       307
       +
           Messages.Resources.updated_notification_jsont

     

       308
       308
       +
           notif

     

       309
       309
       +
       

     

       310
       310
       +
       let send_resource_list_changed t =

     

       311
       311
       +
         let notif = Messages.Resources.make_list_changed_notification () in

     

       312
       312
       +
         send_notification t

     

       313
       313
       +
           Messages.Resources.list_changed_notification_method

     

       314
       314
       +
           Messages.Resources.list_changed_notification_jsont

     

       315
       315
       +
           notif

     

       316
       316
       +
       

     

       317
       317
       +
       let send_tool_list_changed t =

     

       318
       318
       +
         let notif = Messages.Tools.make_list_changed_notification () in

     

       319
       319
       +
         send_notification t

     

       320
       320
       +
           Messages.Tools.list_changed_notification_method

     

       321
       321
       +
           Messages.Tools.list_changed_notification_jsont

     

       322
       322
       +
           notif

     

       323
       323
       +
       

     

       324
       324
       +
       let send_prompt_list_changed t =

     

       325
       325
       +
         let notif = Messages.Prompts.make_list_changed_notification () in

     

       326
       326
       +
         send_notification t

     

       327
       327
       +
           Messages.Prompts.list_changed_notification_method

     

       328
       328
       +
           Messages.Prompts.list_changed_notification_jsont

     

       329
       329
       +
           notif

     

       330
       330
       +
       

     

       331
       331
       +
       let send_roots_list_changed t =

     

       332
       332
       +
         let notif = Messages.Roots.make_list_changed_notification () in

     

       333
       333
       +
         send_notification t

     

       334
       334
       +
           Messages.Roots.list_changed_notification_method

     

       335
       335
       +
           Messages.Roots.list_changed_notification_jsont

     

       336
       336
       +
           notif

     

       337
       337
       +
       

     

       338
       338
       +
       let send_log_message t ~level ?logger ~data () =

     

       339
       339
       +
         let notif = Messages.Logging.make_notification ~level ?logger ~data () in

     

       340
       340
       +
         send_notification t

     

       341
       341
       +
           Messages.Logging.method_

     

       342
       342
       +
           Messages.Logging.notification_jsont

     

       343
       343
       +
           notif

     

       344
       344
       +
       

     

       345
       345
       +
       let send_progress t ~progress_token ~progress ?total () =

     

       346
       346
       +
         let notif = Messages.Progress.make_notification ~progress_token ~progress ?total () in

     

       347
       347
       +
         send_notification t

     

       348
       348
       +
           Messages.Progress.method_

     

       349
       349
       +
           Messages.Progress.notification_jsont

     

       350
       350
       +
           notif

     

       351
       351
       +
       

     

       352
       352
       +
       (** {1 Requesting from Client} *)

     

       353
       353
       +
       

     

       354
       354
       +
       let request_roots_list t =

     

       355
       355
       +
         match client_capabilities t with

     

       356
       356
       +
         | { roots = None; _ } -> None

     

       357
       357
       +
         | { roots = Some _; _ } ->

     

       358
       358
       +
             let req = Messages.Roots.make_list_request () in

     

       359
       359
       +
             let params = encode_json Messages.Roots.list_request_jsont req in

     

       360
       360
       +
             let result_json = Session.send_request t.session

     

       361
       361
       +
               ~method_:Messages.Roots.list_method

     

       362
       362
       +
               ~params

     

       363
       363
       +
               ()

     

       364
       364
       +
             in

     

       365
       365
       +
             let result = decode_json Messages.Roots.list_result_jsont result_json in

     

       366
       366
       +
             Some result

     

       367
       367
       +
       

     

       368
       368
       +
       (** {1 Session Management} *)

     

       369
       369
       +
       

     

       370
       370
       +
       let close t =

     

       371
       371
       +
         Session.close t.session

+208

claudeio/lib_mcp/server_session.mli

···

       1
       1
       +
       (** High-level MCP server session API.

     

       2
       2
       +
       

     

       3
       3
       +
           This module provides a convenient server-side API for hosting MCP servers.

     

       4
       4
       +
           It handles the initialization handshake, routes incoming requests to handlers,

     

       5
       5
       +
           and provides helpers for sending notifications to clients.

     

       6
       6
       +
       

     

       7
       7
       +
           {1 Example Usage}

     

       8
       8
       +
       

     

       9
       9
       +
           {[

     

       10
       10
       +
             let config = {

     

       11
       11
       +
               server_info = Capabilities.Implementation.make

     

       12
       12
       +
                 ~name:"my-server"

     

       13
       13
       +
                 ~version:"1.0.0";

     

       14
       14
       +
               server_capabilities = Capabilities.Server.make

     

       15
       15
       +
                 ~tools:(Some (Capabilities.Tools.make ()))

     

       16
       16
       +
                 ();

     

       17
       17
       +
               instructions = Some "This is my MCP server";

     

       18
       18
       +
             } in

     

       19
       19
       +
       

     

       20
       20
       +
             let handlers = {

     

       21
       21
       +
               list_tools = Some (fun ~cursor ->

     

       22
       22
       +
                 Messages.Tools.make_list_result

     

       23
       23
       +
                   ~tools:[

     

       24
       24
       +
                     Messages.Tools.make_tool

     

       25
       25
       +
                       ~name:"example"

     

       26
       26
       +
                       ~description:"An example tool"

     

       27
       27
       +
                       ~input_schema:(`Object [])

     

       28
       28
       +
                       ();

     

       29
       29
       +
                   ]

     

       30
       30
       +
                   ()

     

       31
       31
       +
               );

     

       32
       32
       +
               call_tool = Some (fun ~name ~arguments ->

     

       33
       33
       +
                 Messages.Tools.make_call_result

     

       34
       34
       +
                   ~content:[Content.text "Tool result"]

     

       35
       35
       +
                   ()

     

       36
       36
       +
               );

     

       37
       37
       +
               (* ... other handlers ... *)

     

       38
       38
       +
               list_resources = None;

     

       39
       39
       +
               list_resource_templates = None;

     

       40
       40
       +
               read_resource = None;

     

       41
       41
       +
               subscribe_resource = None;

     

       42
       42
       +
               unsubscribe_resource = None;

     

       43
       43
       +
               list_prompts = None;

     

       44
       44
       +
               get_prompt = None;

     

       45
       45
       +
               complete = None;

     

       46
       46
       +
               ping = None;

     

       47
       47
       +
             } in

     

       48
       48
       +
       

     

       49
       49
       +
             Eio.Switch.run @@ fun sw ->

     

       50
       50
       +
               let server = Server_session.create

     

       51
       51
       +
                 ~sw

     

       52
       52
       +
                 ~transport

     

       53
       53
       +
                 config

     

       54
       54
       +
                 handlers

     

       55
       55
       +
               in

     

       56
       56
       +
               (* Server is now running and handling requests *)

     

       57
       57
       +
               (* Send notifications as needed *)

     

       58
       58
       +
               Server_session.send_tool_list_changed server

     

       59
       59
       +
           ]} *)

     

       60
       60
       +
       

     

       61
       61
       +
       (** {1 Types} *)

     

       62
       62
       +
       

     

       63
       63
       +
       type t

     

       64
       64
       +
       (** Server session handle *)

     

       65
       65
       +
       

     

       66
       66
       +
       (** {1 Configuration} *)

     

       67
       67
       +
       

     

       68
       68
       +
       type config = {

     

       69
       69
       +
         server_info : Capabilities.Implementation.t;

     

       70
       70
       +
         (** Server implementation information (name, version) *)

     

       71
       71
       +
         server_capabilities : Capabilities.Server.t;

     

       72
       72
       +
         (** Server capabilities to advertise to client *)

     

       73
       73
       +
         instructions : string option;

     

       74
       74
       +
         (** Optional instructions for using the server *)

     

       75
       75
       +
       }

     

       76
       76
       +
       (** Server configuration *)

     

       77
       77
       +
       

     

       78
       78
       +
       (** {1 Request Handlers} *)

     

       79
       79
       +
       

     

       80
       80
       +
       type handlers = {

     

       81
       81
       +
         (* Resources *)

     

       82
       82
       +
         list_resources : (cursor:string option -> Messages.Resources.list_result) option;

     

       83
       83
       +
         (** Handler for resources/list requests *)

     

       84
       84
       +
       

     

       85
       85
       +
         list_resource_templates : (cursor:string option -> Messages.Resources.list_result) option;

     

       86
       86
       +
         (** Handler for resources/templates/list requests *)

     

       87
       87
       +
       

     

       88
       88
       +
         read_resource : (uri:string -> Messages.Resources.read_result) option;

     

       89
       89
       +
         (** Handler for resources/read requests *)

     

       90
       90
       +
       

     

       91
       91
       +
         subscribe_resource : (uri:string -> unit) option;

     

       92
       92
       +
         (** Handler for resources/subscribe requests *)

     

       93
       93
       +
       

     

       94
       94
       +
         unsubscribe_resource : (uri:string -> unit) option;

     

       95
       95
       +
         (** Handler for resources/unsubscribe requests *)

     

       96
       96
       +
       

     

       97
       97
       +
         (* Tools *)

     

       98
       98
       +
         list_tools : (cursor:string option -> Messages.Tools.list_result) option;

     

       99
       99
       +
         (** Handler for tools/list requests *)

     

       100
       100
       +
       

     

       101
       101
       +
         call_tool : (name:string -> arguments:Jsont.json option -> Messages.Tools.call_result) option;

     

       102
       102
       +
         (** Handler for tools/call requests *)

     

       103
       103
       +
       

     

       104
       104
       +
         (* Prompts *)

     

       105
       105
       +
         list_prompts : (cursor:string option -> Messages.Prompts.list_result) option;

     

       106
       106
       +
         (** Handler for prompts/list requests *)

     

       107
       107
       +
       

     

       108
       108
       +
         get_prompt : (name:string -> arguments:(string * string) list option -> Messages.Prompts.get_result) option;

     

       109
       109
       +
         (** Handler for prompts/get requests *)

     

       110
       110
       +
       

     

       111
       111
       +
         (* Completions *)

     

       112
       112
       +
         complete : (ref_:Messages.Completions.completion_ref -> argument:string -> Messages.Completions.result) option;

     

       113
       113
       +
         (** Handler for completion/complete requests *)

     

       114
       114
       +
       

     

       115
       115
       +
         (* Ping *)

     

       116
       116
       +
         ping : (unit -> unit) option;

     

       117
       117
       +
         (** Handler for ping requests *)

     

       118
       118
       +
       }

     

       119
       119
       +
       (** Request handler callbacks.

     

       120
       120
       +
           Set to [None] to indicate the method is not supported.

     

       121
       121
       +
           If a request is received for an unsupported method, a METHOD_NOT_FOUND error is returned. *)

     

       122
       122
       +
       

     

       123
       123
       +
       (** {1 Server Creation} *)

     

       124
       124
       +
       

     

       125
       125
       +
       val create :

     

       126
       126
       +
         sw:Eio.Switch.t ->

     

       127
       127
       +
         transport:Transport.t ->

     

       128
       128
       +
         ?timeout:float ->

     

       129
       129
       +
         ?clock:Session.clock ->

     

       130
       130
       +
         config ->

     

       131
       131
       +
         handlers ->

     

       132
       132
       +
         t

     

       133
       133
       +
       (** Create and initialize a server session.

     

       134
       134
       +
       

     

       135
       135
       +
           This function:

     

       136
       136
       +
           1. Creates an underlying Session

     

       137
       137
       +
           2. Waits for the Initialize request from the client

     

       138
       138
       +
           3. Returns the Initialize response with server capabilities

     

       139
       139
       +
           4. Waits for the Initialized notification

     

       140
       140
       +
           5. Returns a ready-to-use server session

     

       141
       141
       +
       

     

       142
       142
       +
           The server will then handle incoming requests by routing them to the provided handlers.

     

       143
       143
       +
       

     

       144
       144
       +
           @param sw Switch for the session background fibers

     

       145
       145
       +
           @param transport Transport layer for communication

     

       146
       146
       +
           @param timeout Optional request timeout in seconds

     

       147
       147
       +
           @param clock Optional clock for timeout handling (required if timeout is set)

     

       148
       148
       +
           @raise Invalid_argument if initialization fails or times out *)

     

       149
       149
       +
       

     

       150
       150
       +
       (** {1 Client Information} *)

     

       151
       151
       +
       

     

       152
       152
       +
       val client_capabilities : t -> Capabilities.Client.t

     

       153
       153
       +
       (** Get the client's advertised capabilities *)

     

       154
       154
       +
       

     

       155
       155
       +
       val client_info : t -> Capabilities.Implementation.t

     

       156
       156
       +
       (** Get the client's implementation information *)

     

       157
       157
       +
       

     

       158
       158
       +
       val protocol_version : t -> string

     

       159
       159
       +
       (** Get the negotiated protocol version *)

     

       160
       160
       +
       

     

       161
       161
       +
       (** {1 Sending Notifications} *)

     

       162
       162
       +
       

     

       163
       163
       +
       val send_resource_updated : t -> uri:string -> unit

     

       164
       164
       +
       (** Send a notification that a resource has been updated.

     

       165
       165
       +
           Only works if client supports resource subscriptions.

     

       166
       166
       +
           @param uri The URI of the updated resource *)

     

       167
       167
       +
       

     

       168
       168
       +
       val send_resource_list_changed : t -> unit

     

       169
       169
       +
       (** Send a notification that the resource list has changed.

     

       170
       170
       +
           Only works if client supports resource list_changed capability. *)

     

       171
       171
       +
       

     

       172
       172
       +
       val send_tool_list_changed : t -> unit

     

       173
       173
       +
       (** Send a notification that the tool list has changed.

     

       174
       174
       +
           Only works if server advertised tools capability. *)

     

       175
       175
       +
       

     

       176
       176
       +
       val send_prompt_list_changed : t -> unit

     

       177
       177
       +
       (** Send a notification that the prompt list has changed.

     

       178
       178
       +
           Only works if server advertised prompts capability. *)

     

       179
       179
       +
       

     

       180
       180
       +
       val send_roots_list_changed : t -> unit

     

       181
       181
       +
       (** Send a notification that the roots list has changed.

     

       182
       182
       +
           Only works if client supports roots capability. *)

     

       183
       183
       +
       

     

       184
       184
       +
       val send_log_message : t -> level:Messages.Logging.level -> ?logger:string -> data:Jsont.json -> unit -> unit

     

       185
       185
       +
       (** Send a log message notification.

     

       186
       186
       +
           Only works if server advertised logging capability.

     

       187
       187
       +
           @param level Log level

     

       188
       188
       +
           @param logger Optional logger name

     

       189
       189
       +
           @param data Log message data (any JSON value) *)

     

       190
       190
       +
       

     

       191
       191
       +
       val send_progress : t -> progress_token:string -> progress:float -> ?total:float -> unit -> unit

     

       192
       192
       +
       (** Send a progress notification.

     

       193
       193
       +
           @param progress_token Unique token identifying the operation

     

       194
       194
       +
           @param progress Progress value (0.0 to 1.0)

     

       195
       195
       +
           @param total Optional total value *)

     

       196
       196
       +
       

     

       197
       197
       +
       (** {1 Requesting from Client} *)

     

       198
       198
       +
       

     

       199
       199
       +
       val request_roots_list : t -> Messages.Roots.list_result option

     

       200
       200
       +
       (** Request the list of roots from the client.

     

       201
       201
       +
           Returns [None] if the client doesn't support the roots capability.

     

       202
       202
       +
           @raise Session.Timeout if the request times out

     

       203
       203
       +
           @raise Session.Remote_error if the client returns an error *)

     

       204
       204
       +
       

     

       205
       205
       +
       (** {1 Session Management} *)

     

       206
       206
       +
       

     

       207
       207
       +
       val close : t -> unit

     

       208
       208
       +
       (** Close the server session and underlying transport *)

+254

claudeio/lib_mcp/session.ml

···

       1
       1
       +
       (** Bidirectional JSON-RPC session management with request/response correlation *)

     

       2
       2
       +
       

     

       3
       3
       +
       (** {1 Handlers} *)

     

       4
       4
       +
       

     

       5
       5
       +
       type request_handler =

     

       6
       6
       +
         method_:string ->

     

       7
       7
       +
         params:Jsont.json option ->

     

       8
       8
       +
         Jsont.json

     

       9
       9
       +
       

     

       10
       10
       +
       type notification_handler =

     

       11
       11
       +
         method_:string ->

     

       12
       12
       +
         params:Jsont.json option ->

     

       13
       13
       +
         unit

     

       14
       14
       +
       

     

       15
       15
       +
       (** {1 Configuration} *)

     

       16
       16
       +
       

     

       17
       17
       +
       type clock = C : _ Eio.Time.clock -> clock

     

       18
       18
       +
       

     

       19
       19
       +
       type config = {

     

       20
       20
       +
         transport : Transport.t;

     

       21
       21
       +
         request_handler : request_handler;

     

       22
       22
       +
         notification_handler : notification_handler;

     

       23
       23
       +
         timeout : float option;

     

       24
       24
       +
         clock : clock option;

     

       25
       25
       +
         (** Clock for timeout handling. Required if timeout is set. *)

     

       26
       26
       +
       }

     

       27
       27
       +
       

     

       28
       28
       +
       (** {1 Exceptions} *)

     

       29
       29
       +
       

     

       30
       30
       +
       exception Timeout of string

     

       31
       31
       +
       exception Session_closed

     

       32
       32
       +
       exception Unknown_response of Jsonrpc.Id.t

     

       33
       33
       +
       exception Remote_error of Jsonrpc.Error_data.t

     

       34
       34
       +
       

     

       35
       35
       +
       (** {1 Internal Types} *)

     

       36
       36
       +
       

     

       37
       37
       +
       type response_result =

     

       38
       38
       +
         | Success of Jsont.json

     

       39
       39
       +
         | Error of exn

     

       40
       40
       +
       

     

       41
       41
       +
       type pending_request = {

     

       42
       42
       +
         id : Jsonrpc.Id.t;

     

       43
       43
       +
         resolver : response_result Eio.Promise.u;

     

       44
       44
       +
         mutable cancelled : bool;  (* Flag to indicate request was completed *)

     

       45
       45
       +
       }

     

       46
       46
       +
       

     

       47
       47
       +
       type t = {

     

       48
       48
       +
         transport : Transport.t;

     

       49
       49
       +
         mutable next_id : int;

     

       50
       50
       +
         pending : (Jsonrpc.Id.t, pending_request) Hashtbl.t;

     

       51
       51
       +
         request_handler : request_handler;

     

       52
       52
       +
         notification_handler : notification_handler;

     

       53
       53
       +
         timeout : float option;

     

       54
       54
       +
         clock : clock option;

     

       55
       55
       +
         sw : Eio.Switch.t;

     

       56
       56
       +
         mutable closed : bool;

     

       57
       57
       +
       }

     

       58
       58
       +
       

     

       59
       59
       +
       (** {1 Helper Functions} *)

     

       60
       60
       +
       

     

       61
       61
       +
       let encode_message msg =

     

       62
       62
       +
         match Jsont.Json.encode Jsonrpc.Message.jsont msg with

     

       63
       63
       +
         | Ok json -> json

     

       64
       64
       +
         | Error e -> failwith ("Failed to encode message: " ^ e)

     

       65
       65
       +
       

     

       66
       66
       +
       let send_json t json =

     

       67
       67
       +
         if t.closed then raise Session_closed;

     

       68
       68
       +
         Transport.send t.transport json

     

       69
       69
       +
       

     

       70
       70
       +
       (** Handle an incoming request by calling the user's handler and sending response *)

     

       71
       71
       +
       let handle_request t req =

     

       72
       72
       +
         let open Jsonrpc in

     

       73
       73
       +
         let id = match req.Request.id with

     

       74
       74
       +
           | Some id -> id

     

       75
       75
       +
           | None ->

     

       76
       76
       +
               (* This is a notification, not a request - no response needed *)

     

       77
       77
       +
               t.notification_handler

     

       78
       78
       +
                 ~method_:req.Request.method_

     

       79
       79
       +
                 ~params:req.Request.params;

     

       80
       80
       +
               raise Exit  (* Exit this handler without sending response *)

     

       81
       81
       +
         in

     

       82
       82
       +
       

     

       83
       83
       +
         try

     

       84
       84
       +
           (* Call user's request handler *)

     

       85
       85
       +
           let result = t.request_handler

     

       86
       86
       +
             ~method_:req.Request.method_

     

       87
       87
       +
             ~params:req.Request.params

     

       88
       88
       +
           in

     

       89
       89
       +
           (* Send success response *)

     

       90
       90
       +
           let response = Response.make_result ~id ~result in

     

       91
       91
       +
           let msg = Message.Response response in

     

       92
       92
       +
           let json = encode_message msg in

     

       93
       93
       +
           send_json t json

     

       94
       94
       +
         with

     

       95
       95
       +
         | Exit -> ()  (* Notification, no response *)

     

       96
       96
       +
         | exn ->

     

       97
       97
       +
             (* Convert exception to error response *)

     

       98
       98
       +
             let error = Error_data.make

     

       99
       99
       +
               ~code:Internal_error

     

       100
       100
       +
               ~message:(Printexc.to_string exn)

     

       101
       101
       +
               ()

     

       102
       102
       +
             in

     

       103
       103
       +
             let response = Response.make_error ~id ~error in

     

       104
       104
       +
             let msg = Message.Response response in

     

       105
       105
       +
             let json = encode_message msg in

     

       106
       106
       +
             send_json t json

     

       107
       107
       +
       

     

       108
       108
       +
       (** Resolve a pending request with a response *)

     

       109
       109
       +
       let resolve_response t resp =

     

       110
       110
       +
         let open Jsonrpc in

     

       111
       111
       +
         let id = resp.Response.id in

     

       112
       112
       +
         match Hashtbl.find_opt t.pending id with

     

       113
       113
       +
         | None ->

     

       114
       114
       +
             (* Received response for unknown request ID *)

     

       115
       115
       +
             raise (Unknown_response id)

     

       116
       116
       +
         | Some pending ->

     

       117
       117
       +
             Hashtbl.remove t.pending id;

     

       118
       118
       +
             (* Mark as cancelled so timeout doesn't fire *)

     

       119
       119
       +
             pending.cancelled <- true;

     

       120
       120
       +
             (* Resolve the promise with result or error *)

     

       121
       121
       +
             (match resp.Response.value with

     

       122
       122
       +
             | Ok result ->

     

       123
       123
       +
                 Eio.Promise.resolve pending.resolver (Success result)

     

       124
       124
       +
             | Stdlib.Result.Error error ->

     

       125
       125
       +
                 Eio.Promise.resolve pending.resolver (Error (Remote_error error)))

     

       126
       126
       +
       

     

       127
       127
       +
       (** Background receive loop - reads messages and routes them *)

     

       128
       128
       +
       let rec receive_loop t =

     

       129
       129
       +
         if t.closed then () else

     

       130
       130
       +
         match Transport.receive t.transport with

     

       131
       131
       +
         | None ->

     

       132
       132
       +
             (* Transport closed *)

     

       133
       133
       +
             t.closed <- true;

     

       134
       134
       +
             (* Cancel all pending requests *)

     

       135
       135
       +
             Hashtbl.iter (fun _ pending ->

     

       136
       136
       +
               Eio.Promise.resolve pending.resolver (Error Session_closed)

     

       137
       137
       +
             ) t.pending;

     

       138
       138
       +
             Hashtbl.clear t.pending

     

       139
       139
       +
         | Some json ->

     

       140
       140
       +
             (try

     

       141
       141
       +
                let msg = Jsonrpc.Message.classify json in

     

       142
       142
       +
                match msg with

     

       143
       143
       +
                | Request req ->

     

       144
       144
       +
                    (* Handle request in new fibre so it doesn't block receive loop *)

     

       145
       145
       +
                    Eio.Fiber.fork_promise ~sw:t.sw (fun () ->

     

       146
       146
       +
                      handle_request t req

     

       147
       147
       +
                    ) |> ignore

     

       148
       148
       +
                | Response resp ->

     

       149
       149
       +
                    (* Resolve pending promise *)

     

       150
       150
       +
                    resolve_response t resp

     

       151
       151
       +
              with exn ->

     

       152
       152
       +
                (* Log error but continue receive loop *)

     

       153
       153
       +
                Printf.eprintf "Error in receive loop: %s\n%!" (Printexc.to_string exn)

     

       154
       154
       +
             );

     

       155
       155
       +
             receive_loop t

     

       156
       156
       +
       

     

       157
       157
       +
       (** {1 Public API} *)

     

       158
       158
       +
       

     

       159
       159
       +
       let create ~sw (config : config) : t =

     

       160
       160
       +
         (* Validate that clock is provided if timeout is set *)

     

       161
       161
       +
         (match config.timeout with

     

       162
       162
       +
          | Some _ when config.clock = None ->

     

       163
       163
       +
              invalid_arg "Session.create: clock must be provided when timeout is set"

     

       164
       164
       +
          | _ -> ());

     

       165
       165
       +
       

     

       166
       166
       +
         let t = {

     

       167
       167
       +
           transport = config.transport;

     

       168
       168
       +
           next_id = 1;

     

       169
       169
       +
           pending = Hashtbl.create 16;

     

       170
       170
       +
           request_handler = config.request_handler;

     

       171
       171
       +
           notification_handler = config.notification_handler;

     

       172
       172
       +
           timeout = config.timeout;

     

       173
       173
       +
           clock = config.clock;

     

       174
       174
       +
           sw;

     

       175
       175
       +
           closed = false;

     

       176
       176
       +
         } in

     

       177
       177
       +
       

     

       178
       178
       +
         (* Start background receive loop *)

     

       179
       179
       +
         Eio.Fiber.fork ~sw (fun () -> receive_loop t);

     

       180
       180
       +
       

     

       181
       181
       +
         t

     

       182
       182
       +
       

     

       183
       183
       +
       let send_request t ~method_ ?params () =

     

       184
       184
       +
         if t.closed then raise Session_closed;

     

       185
       185
       +
       

     

       186
       186
       +
         (* Generate unique request ID *)

     

       187
       187
       +
         let id = `Number (float_of_int t.next_id) in

     

       188
       188
       +
         t.next_id <- t.next_id + 1;

     

       189
       189
       +
       

     

       190
       190
       +
         (* Create promise for response *)

     

       191
       191
       +
         let promise, resolver = Eio.Promise.create () in

     

       192
       192
       +
       

     

       193
       193
       +
         (* Register pending request *)

     

       194
       194
       +
         let pending = {

     

       195
       195
       +
           id;

     

       196
       196
       +
           resolver;

     

       197
       197
       +
           cancelled = false;

     

       198
       198
       +
         } in

     

       199
       199
       +
         Hashtbl.add t.pending id pending;

     

       200
       200
       +
       

     

       201
       201
       +
         (* Setup timeout if configured *)

     

       202
       202
       +
         (match t.timeout, t.clock with

     

       203
       203
       +
          | None, _ | _, None -> ()

     

       204
       204
       +
          | Some timeout_sec, Some (C clock) ->

     

       205
       205
       +
              (* Start timeout fiber *)

     

       206
       206
       +
              Eio.Fiber.fork ~sw:t.sw (fun () ->

     

       207
       207
       +
                Eio.Time.sleep clock timeout_sec;

     

       208
       208
       +
                (* Timeout expired - check if request is still pending and not cancelled *)

     

       209
       209
       +
                if not pending.cancelled then begin

     

       210
       210
       +
                  match Hashtbl.find_opt t.pending id with

     

       211
       211
       +
                  | Some _ ->

     

       212
       212
       +
                      Hashtbl.remove t.pending id;

     

       213
       213
       +
                      let msg = Printf.sprintf "Request timeout after %.1fs: %s" timeout_sec method_ in

     

       214
       214
       +
                      Eio.Promise.resolve pending.resolver (Error (Timeout msg))

     

       215
       215
       +
                  | None ->

     

       216
       216
       +
                      (* Request already completed, nothing to do *)

     

       217
       217
       +
                      ()

     

       218
       218
       +
                end

     

       219
       219
       +
              )

     

       220
       220
       +
         );

     

       221
       221
       +
       

     

       222
       222
       +
         (* Send request *)

     

       223
       223
       +
         let req = Jsonrpc.Request.make ~method_ ?params ~id () in

     

       224
       224
       +
         let msg = Jsonrpc.Message.Request req in

     

       225
       225
       +
         let json = encode_message msg in

     

       226
       226
       +
         send_json t json;

     

       227
       227
       +
       

     

       228
       228
       +
         (* Wait for response *)

     

       229
       229
       +
         match Eio.Promise.await promise with

     

       230
       230
       +
         | Success result -> result

     

       231
       231
       +
         | Error exn -> raise exn

     

       232
       232
       +
       

     

       233
       233
       +
       let send_notification t ~method_ ?params () =

     

       234
       234
       +
         if t.closed then raise Session_closed;

     

       235
       235
       +
       

     

       236
       236
       +
         (* Create notification (request with no ID) *)

     

       237
       237
       +
         let req = Jsonrpc.Request.make ~method_ ?params () in

     

       238
       238
       +
         let msg = Jsonrpc.Message.Request req in

     

       239
       239
       +
         let json = encode_message msg in

     

       240
       240
       +
         send_json t json

     

       241
       241
       +
       

     

       242
       242
       +
       let close t =

     

       243
       243
       +
         if not t.closed then begin

     

       244
       244
       +
           t.closed <- true;

     

       245
       245
       +
           (* Cancel all pending requests *)

     

       246
       246
       +
           Hashtbl.iter (fun _ pending ->

     

       247
       247
       +
             Eio.Promise.resolve pending.resolver (Error Session_closed)

     

       248
       248
       +
           ) t.pending;

     

       249
       249
       +
           Hashtbl.clear t.pending;

     

       250
       250
       +
           (* Close transport *)

     

       251
       251
       +
           Transport.close t.transport

     

       252
       252
       +
         end

     

       253
       253
       +
       

     

       254
       254
       +
       let is_closed t = t.closed

+140

claudeio/lib_mcp/session.mli

···

       1
       1
       +
       (** Bidirectional JSON-RPC session management with request/response correlation.

     

       2
       2
       +
       

     

       3
       3
       +
           This module provides a high-level session abstraction over a transport layer,

     

       4
       4
       +
           handling request ID generation, response correlation via promises, and

     

       5
       5
       +
           bidirectional message routing using Eio structured concurrency.

     

       6
       6
       +
       

     

       7
       7
       +
           {1 Architecture}

     

       8
       8
       +
       

     

       9
       9
       +
           Sessions run a background receive loop in an Eio fiber that continuously

     

       10
       10
       +
           reads from the transport and routes messages:

     

       11
       11
       +
           - Incoming requests → dispatched to request_handler in new fiber

     

       12
       12
       +
           - Incoming responses → resolve pending promises

     

       13
       13
       +
           - Incoming notifications → dispatched to notification_handler

     

       14
       14
       +
       

     

       15
       15
       +
           Outgoing messages (requests and notifications) are sent directly on the

     

       16
       16
       +
           transport. Requests return promises that are resolved when the corresponding

     

       17
       17
       +
           response arrives.

     

       18
       18
       +
       

     

       19
       19
       +
           {1 Example Usage}

     

       20
       20
       +
       

     

       21
       21
       +
           {[

     

       22
       22
       +
             Eio_main.run @@ fun env ->

     

       23
       23
       +
             let config = {

     

       24
       24
       +
               transport;

     

       25
       25
       +
               request_handler = (fun ~method_ ~params ->

     

       26
       26
       +
                 (* Handle incoming requests *)

     

       27
       27
       +
                 match method_ with

     

       28
       28
       +
                 | "ping" -> `String "pong"

     

       29
       29
       +
                 | _ -> failwith "Unknown method"

     

       30
       30
       +
               );

     

       31
       31
       +
               notification_handler = (fun ~method_ ~params ->

     

       32
       32
       +
                 (* Handle incoming notifications *)

     

       33
       33
       +
                 Printf.printf "Notification: %s\n" method_

     

       34
       34
       +
               );

     

       35
       35
       +
               timeout = Some 30.0;  (* 30 second timeout *)

     

       36
       36
       +
               clock = Some (C (Eio.Stdenv.clock env));

     

       37
       37
       +
             }

     

       38
       38
       +
             in

     

       39
       39
       +
       

     

       40
       40
       +
             Eio.Switch.run @@ fun sw ->

     

       41
       41
       +
               let session = Session.create ~sw config in

     

       42
       42
       +
       

     

       43
       43
       +
               (* Send a request and wait for response *)

     

       44
       44
       +
               let response = Session.send_request session

     

       45
       45
       +
                 ~method_:"initialize"

     

       46
       46
       +
                 ~params:(`Object [("version", `String "1.0")])

     

       47
       47
       +
                 ()

     

       48
       48
       +
               in

     

       49
       49
       +
       

     

       50
       50
       +
               (* Send a notification (no response expected) *)

     

       51
       51
       +
               Session.send_notification session

     

       52
       52
       +
                 ~method_:"progress"

     

       53
       53
       +
                 ~params:(`Object [("percent", `Number 50.0)])

     

       54
       54
       +
                 ()

     

       55
       55
       +
           ]} *)

     

       56
       56
       +
       

     

       57
       57
       +
       (** {1 Handlers} *)

     

       58
       58
       +
       

     

       59
       59
       +
       type request_handler =

     

       60
       60
       +
         method_:string ->

     

       61
       61
       +
         params:Jsont.json option ->

     

       62
       62
       +
         Jsont.json

     

       63
       63
       +
       (** Handler for incoming requests. Should return the result value.

     

       64
       64
       +
           May raise exceptions which will be converted to JSON-RPC errors. *)

     

       65
       65
       +
       

     

       66
       66
       +
       type notification_handler =

     

       67
       67
       +
         method_:string ->

     

       68
       68
       +
         params:Jsont.json option ->

     

       69
       69
       +
         unit

     

       70
       70
       +
       (** Handler for incoming notifications. No response is expected. *)

     

       71
       71
       +
       

     

       72
       72
       +
       (** {1 Configuration} *)

     

       73
       73
       +
       

     

       74
       74
       +
       type clock = C : _ Eio.Time.clock -> clock

     

       75
       75
       +
       (** Wrapper for existential clock type *)

     

       76
       76
       +
       

     

       77
       77
       +
       type config = {

     

       78
       78
       +
         transport : Transport.t;

     

       79
       79
       +
         (** Transport layer for sending/receiving JSON messages *)

     

       80
       80
       +
         request_handler : request_handler;

     

       81
       81
       +
         (** Handler for incoming requests *)

     

       82
       82
       +
         notification_handler : notification_handler;

     

       83
       83
       +
         (** Handler for incoming notifications *)

     

       84
       84
       +
         timeout : float option;

     

       85
       85
       +
         (** Request timeout in seconds. [None] means no timeout. *)

     

       86
       86
       +
         clock : clock option;

     

       87
       87
       +
         (** Clock for timeout handling. Required if [timeout] is set. *)

     

       88
       88
       +
       }

     

       89
       89
       +
       (** Session configuration *)

     

       90
       90
       +
       

     

       91
       91
       +
       (** {1 Session Management} *)

     

       92
       92
       +
       

     

       93
       93
       +
       type t

     

       94
       94
       +
       (** Session handle *)

     

       95
       95
       +
       

     

       96
       96
       +
       exception Timeout of string

     

       97
       97
       +
       (** Raised when a request times out *)

     

       98
       98
       +
       

     

       99
       99
       +
       exception Session_closed

     

       100
       100
       +
       (** Raised when attempting to use a closed session *)

     

       101
       101
       +
       

     

       102
       102
       +
       exception Unknown_response of Jsonrpc.Id.t

     

       103
       103
       +
       (** Raised when receiving a response for an unknown request ID *)

     

       104
       104
       +
       

     

       105
       105
       +
       exception Remote_error of Jsonrpc.Error_data.t

     

       106
       106
       +
       (** Raised when the remote side returns an error response *)

     

       107
       107
       +
       

     

       108
       108
       +
       val create :

     

       109
       109
       +
         sw:Eio.Switch.t ->

     

       110
       110
       +
         config ->

     

       111
       111
       +
         t

     

       112
       112
       +
       (** Create and start a session with a background receive loop.

     

       113
       113
       +
           The receive loop runs in a background fiber attached to [sw]. *)

     

       114
       114
       +
       

     

       115
       115
       +
       val send_request :

     

       116
       116
       +
         t ->

     

       117
       117
       +
         method_:string ->

     

       118
       118
       +
         ?params:Jsont.json ->

     

       119
       119
       +
         unit ->

     

       120
       120
       +
         Jsont.json

     

       121
       121
       +
       (** Send a request and await the response.

     

       122
       122
       +
           Raises [Timeout] if the request times out.

     

       123
       123
       +
           Raises [Remote_error] if the server returns an error.

     

       124
       124
       +
           Raises [Session_closed] if the session is closed. *)

     

       125
       125
       +
       

     

       126
       126
       +
       val send_notification :

     

       127
       127
       +
         t ->

     

       128
       128
       +
         method_:string ->

     

       129
       129
       +
         ?params:Jsont.json ->

     

       130
       130
       +
         unit ->

     

       131
       131
       +
         unit

     

       132
       132
       +
       (** Send a notification (no response expected).

     

       133
       133
       +
           Raises [Session_closed] if the session is closed. *)

     

       134
       134
       +
       

     

       135
       135
       +
       val close : t -> unit

     

       136
       136
       +
       (** Close the session and underlying transport.

     

       137
       137
       +
           This will cancel all pending requests. *)

     

       138
       138
       +
       

     

       139
       139
       +
       val is_closed : t -> bool

     

       140
       140
       +
       (** Check if the session is closed *)

+29

claudeio/lib_mcp/transport.ml

···

       1
       1
       +
       (** Abstract transport layer for MCP communication *)

     

       2
       2
       +
       

     

       3
       3
       +
       exception Connection_error of string

     

       4
       4
       +
       

     

       5
       5
       +
       (** Internal module type that transport implementations must satisfy *)

     

       6
       6
       +
       module type TRANSPORT = sig

     

       7
       7
       +
         type state

     

       8
       8
       +
       

     

       9
       9
       +
         val send : state -> Jsont.json -> unit

     

       10
       10
       +
         val receive : state -> Jsont.json option

     

       11
       11
       +
         val close : state -> unit

     

       12
       12
       +
         val is_closed : state -> bool

     

       13
       13
       +
       end

     

       14
       14
       +
       

     

       15
       15
       +
       (** The abstract transport type - hides the concrete implementation *)

     

       16
       16
       +
       type t = T : (module TRANSPORT with type state = 'a) * 'a -> t

     

       17
       17
       +
         [@@warning "-37"] (* Constructor T is used in transport implementations *)

     

       18
       18
       +
       

     

       19
       19
       +
       let send (T ((module M), state)) json =

     

       20
       20
       +
         M.send state json

     

       21
       21
       +
       

     

       22
       22
       +
       let receive (T ((module M), state)) =

     

       23
       23
       +
         M.receive state

     

       24
       24
       +
       

     

       25
       25
       +
       let close (T ((module M), state)) =

     

       26
       26
       +
         M.close state

     

       27
       27
       +
       

     

       28
       28
       +
       let is_closed (T ((module M), state)) =

     

       29
       29
       +
         M.is_closed state

+34

claudeio/lib_mcp/transport.mli

···

       1
       1
       +
       (** Abstract transport layer for MCP communication *)

     

       2
       2
       +
       

     

       3
       3
       +
       (** Module type that transport implementations must satisfy *)

     

       4
       4
       +
       module type TRANSPORT = sig

     

       5
       5
       +
         type state

     

       6
       6
       +
       

     

       7
       7
       +
         val send : state -> Jsont.json -> unit

     

       8
       8
       +
         val receive : state -> Jsont.json option

     

       9
       9
       +
         val close : state -> unit

     

       10
       10
       +
         val is_closed : state -> bool

     

       11
       11
       +
       end

     

       12
       12
       +
       

     

       13
       13
       +
       (** The abstract transport type for sending/receiving JSON messages *)

     

       14
       14
       +
       type t = T : (module TRANSPORT with type state = 'a) * 'a -> t

     

       15
       15
       +
       

     

       16
       16
       +
       (** [send t json] sends a JSON message through the transport.

     

       17
       17
       +
           @raise Connection_error if the transport is closed or sending fails *)

     

       18
       18
       +
       val send : t -> Jsont.json -> unit

     

       19
       19
       +
       

     

       20
       20
       +
       (** [receive t] receives a JSON message from the transport (blocking).

     

       21
       21
       +
           Returns [None] on EOF or when the transport is closed.

     

       22
       22
       +
           @raise Connection_error if receiving fails for reasons other than EOF *)

     

       23
       23
       +
       val receive : t -> Jsont.json option

     

       24
       24
       +
       

     

       25
       25
       +
       (** [close t] closes the transport and releases all associated resources.

     

       26
       26
       +
           This is idempotent - calling close multiple times is safe. *)

     

       27
       27
       +
       val close : t -> unit

     

       28
       28
       +
       

     

       29
       29
       +
       (** [is_closed t] checks if the transport is closed.

     

       30
       30
       +
           Returns [true] if the transport has been closed, [false] otherwise. *)

     

       31
       31
       +
       val is_closed : t -> bool

     

       32
       32
       +
       

     

       33
       33
       +
       (** Exception raised when transport operations fail *)

     

       34
       34
       +
       exception Connection_error of string

+179

claudeio/lib_mcp/transport_stdio.ml

···

       1
       1
       +
       (** Stdio transport implementation for MCP *)

     

       2
       2
       +
       

     

       3
       3
       +
       let src = Logs.Src.create "mcp.transport.stdio" ~doc:"MCP stdio transport"

     

       4
       4
       +
       module Log = (val Logs.src_log src : Logs.LOG)

     

       5
       5
       +
       

     

       6
       6
       +
       exception Process_spawn_error of string

     

       7
       7
       +
       

     

       8
       8
       +
       (** Parameters for creating a stdio transport *)

     

       9
       9
       +
       type params = {

     

       10
       10
       +
         command : string;

     

       11
       11
       +
         args : string list;

     

       12
       12
       +
         env : (string * string) list option;

     

       13
       13
       +
         max_buffer_size : int option;

     

       14
       14
       +
       }

     

       15
       15
       +
       

     

       16
       16
       +
       (** Wrapper for existential process type *)

     

       17
       17
       +
       type process = P : _ Eio.Process.t -> process

     

       18
       18
       +
       

     

       19
       19
       +
       (** Internal state for stdio transport *)

     

       20
       20
       +
       type state = {

     

       21
       21
       +
         process : process;

     

       22
       22
       +
         stdin : Eio.Flow.sink_ty Eio.Resource.t;

     

       23
       23
       +
         stdin_close : [`Close | `Flow] Eio.Resource.t;

     

       24
       24
       +
         stdout : Eio.Buf_read.t;

     

       25
       25
       +
         mutable closed : bool;

     

       26
       26
       +
         sw : Eio.Switch.t;

     

       27
       27
       +
       }

     

       28
       28
       +
       

     

       29
       29
       +
       (** Send a JSON message by encoding to a line-delimited string *)

     

       30
       30
       +
       let send state json =

     

       31
       31
       +
         if state.closed then

     

       32
       32
       +
           raise (Transport.Connection_error "Transport is closed");

     

       33
       33
       +
       

     

       34
       34
       +
         let data = match Jsont_bytesrw.encode_string' Jsont.json json with

     

       35
       35
       +
           | Ok s -> s

     

       36
       36
       +
           | Error err ->

     

       37
       37
       +
               let msg = Jsont.Error.to_string err in

     

       38
       38
       +
               raise (Transport.Connection_error ("JSON encoding failed: " ^ msg))

     

       39
       39
       +
         in

     

       40
       40
       +
       

     

       41
       41
       +
         Log.debug (fun m -> m "Sending: %s" data);

     

       42
       42
       +
       

     

       43
       43
       +
         try

     

       44
       44
       +
           Eio.Flow.write state.stdin [Cstruct.of_string (data ^ "\n")]

     

       45
       45
       +
         with

     

       46
       46
       +
         | exn ->

     

       47
       47
       +
             Log.err (fun m -> m "Failed to send message: %s" (Printexc.to_string exn));

     

       48
       48
       +
             raise (Transport.Connection_error

     

       49
       49
       +
               (Printf.sprintf "Failed to send message: %s" (Printexc.to_string exn)))

     

       50
       50
       +
       

     

       51
       51
       +
       (** Receive a JSON message by reading a line and decoding *)

     

       52
       52
       +
       let receive state =

     

       53
       53
       +
         if state.closed then

     

       54
       54
       +
           None

     

       55
       55
       +
         else

     

       56
       56
       +
           try

     

       57
       57
       +
             match Eio.Buf_read.line state.stdout with

     

       58
       58
       +
             | line ->

     

       59
       59
       +
                 Log.debug (fun m -> m "Received: %s" line);

     

       60
       60
       +
                 (match Jsont_bytesrw.decode_string' Jsont.json line with

     

       61
       61
       +
                  | Ok json -> Some json

     

       62
       62
       +
                  | Error err ->

     

       63
       63
       +
                      let msg = Jsont.Error.to_string err in

     

       64
       64
       +
                      Log.err (fun m -> m "JSON decoding failed: %s" msg);

     

       65
       65
       +
                      raise (Transport.Connection_error ("JSON decoding failed: " ^ msg)))

     

       66
       66
       +
             | exception End_of_file ->

     

       67
       67
       +
                 Log.debug (fun m -> m "Received EOF");

     

       68
       68
       +
                 state.closed <- true;

     

       69
       69
       +
                 None

     

       70
       70
       +
           with

     

       71
       71
       +
           | Transport.Connection_error _ as e -> raise e

     

       72
       72
       +
           | exn ->

     

       73
       73
       +
               Log.err (fun m -> m "Failed to receive message: %s" (Printexc.to_string exn));

     

       74
       74
       +
               raise (Transport.Connection_error

     

       75
       75
       +
                 (Printf.sprintf "Failed to receive message: %s" (Printexc.to_string exn)))

     

       76
       76
       +
       

     

       77
       77
       +
       (** Close the transport and cleanup resources *)

     

       78
       78
       +
       let close state =

     

       79
       79
       +
         if not state.closed then begin

     

       80
       80
       +
           state.closed <- true;

     

       81
       81
       +
           try

     

       82
       82
       +
             Eio.Flow.close state.stdin_close;

     

       83
       83
       +
             let (P process) = state.process in

     

       84
       84
       +
             Eio.Process.await_exn process

     

       85
       85
       +
           with _ -> ()

     

       86
       86
       +
         end

     

       87
       87
       +
       

     

       88
       88
       +
       (** Check if transport is closed *)

     

       89
       89
       +
       let is_closed state =

     

       90
       90
       +
         state.closed

     

       91
       91
       +
       

     

       92
       92
       +
       (** The transport module implementation *)

     

       93
       93
       +
       module Stdio_transport : Transport.TRANSPORT with type state = state = struct

     

       94
       94
       +
         type nonrec state = state

     

       95
       95
       +
       

     

       96
       96
       +
         let send = send

     

       97
       97
       +
         let receive = receive

     

       98
       98
       +
         let close = close

     

       99
       99
       +
         let is_closed = is_closed

     

       100
       100
       +
       end

     

       101
       101
       +
       

     

       102
       102
       +
       (** Create a new stdio transport *)

     

       103
       103
       +
       let create ~sw ~process_mgr params =

     

       104
       104
       +
         (* Build command arguments *)

     

       105
       105
       +
         let cmd = params.command :: params.args in

     

       106
       106
       +
       

     

       107
       107
       +
         (* Build environment - preserve essential vars and add custom ones *)

     

       108
       108
       +
         let home = try Unix.getenv "HOME" with Not_found -> "/tmp" in

     

       109
       109
       +
         let path = try Unix.getenv "PATH" with Not_found -> "/usr/bin:/bin" in

     

       110
       110
       +
       

     

       111
       111
       +
         (* Preserve other potentially important environment variables *)

     

       112
       112
       +
         let preserve_vars = [

     

       113
       113
       +
           "USER"; "LOGNAME"; "SHELL"; "TERM";

     

       114
       114
       +
           "XDG_CONFIG_HOME"; "XDG_DATA_HOME"; "XDG_CACHE_HOME";

     

       115
       115
       +
         ] in

     

       116
       116
       +
       

     

       117
       117
       +
         let preserved = List.filter_map (fun var ->

     

       118
       118
       +
           try Some (Printf.sprintf "%s=%s" var (Unix.getenv var))

     

       119
       119
       +
           with Not_found -> None

     

       120
       120
       +
         ) preserve_vars in

     

       121
       121
       +
       

     

       122
       122
       +
         let base_env = [

     

       123
       123
       +
           Printf.sprintf "HOME=%s" home;

     

       124
       124
       +
           Printf.sprintf "PATH=%s" path;

     

       125
       125
       +
         ] @ preserved in

     

       126
       126
       +
       

     

       127
       127
       +
         let custom_env = match params.env with

     

       128
       128
       +
           | None -> []

     

       129
       129
       +
           | Some vars -> List.map (fun (k, v) -> Printf.sprintf "%s=%s" k v) vars

     

       130
       130
       +
         in

     

       131
       131
       +
       

     

       132
       132
       +
         let env = Array.of_list (base_env @ custom_env) in

     

       133
       133
       +
       

     

       134
       134
       +
         Log.debug (fun m -> m "Environment: HOME=%s, PATH=%s" home path);

     

       135
       135
       +
         Log.info (fun m -> m "Spawning command: %s" (String.concat " " cmd));

     

       136
       136
       +
       

     

       137
       137
       +
         (* Create pipes for stdin/stdout *)

     

       138
       138
       +
         let stdin_r, stdin_w = Eio.Process.pipe ~sw process_mgr in

     

       139
       139
       +
         let stdout_r, stdout_w = Eio.Process.pipe ~sw process_mgr in

     

       140
       140
       +
       

     

       141
       141
       +
         (* Spawn the process *)

     

       142
       142
       +
         let process =

     

       143
       143
       +
           try

     

       144
       144
       +
             Eio.Process.spawn ~sw process_mgr

     

       145
       145
       +
               ~env

     

       146
       146
       +
               ~stdin:(stdin_r :> Eio.Flow.source_ty Eio.Resource.t)

     

       147
       147
       +
               ~stdout:(stdout_w :> Eio.Flow.sink_ty Eio.Resource.t)

     

       148
       148
       +
               cmd

     

       149
       149
       +
           with

     

       150
       150
       +
           | exn ->

     

       151
       151
       +
               Log.err (fun m -> m "Failed to spawn process: %s" (Printexc.to_string exn));

     

       152
       152
       +
               raise (Process_spawn_error

     

       153
       153
       +
                 (Printf.sprintf "Failed to spawn process: %s" (Printexc.to_string exn)))

     

       154
       154
       +
         in

     

       155
       155
       +
       

     

       156
       156
       +
         (* Setup stdin for writing *)

     

       157
       157
       +
         let stdin = (stdin_w :> Eio.Flow.sink_ty Eio.Resource.t) in

     

       158
       158
       +
         let stdin_close = (stdin_w :> [`Close | `Flow] Eio.Resource.t) in

     

       159
       159
       +
       

     

       160
       160
       +
         (* Setup stdout for reading with buffering *)

     

       161
       161
       +
         let max_size = match params.max_buffer_size with

     

       162
       162
       +
           | Some size -> size

     

       163
       163
       +
           | None -> 1_000_000  (* Default 1MB *)

     

       164
       164
       +
         in

     

       165
       165
       +
         let stdout = Eio.Buf_read.of_flow ~max_size

     

       166
       166
       +
           (stdout_r :> Eio.Flow.source_ty Eio.Resource.t) in

     

       167
       167
       +
       

     

       168
       168
       +
         (* Create the state *)

     

       169
       169
       +
         let state = {

     

       170
       170
       +
           process = P process;

     

       171
       171
       +
           stdin;

     

       172
       172
       +
           stdin_close;

     

       173
       173
       +
           stdout;

     

       174
       174
       +
           closed = false;

     

       175
       175
       +
           sw;

     

       176
       176
       +
         } in

     

       177
       177
       +
       

     

       178
       178
       +
         (* Wrap in abstract transport type *)

     

       179
       179
       +
         Transport.T ((module Stdio_transport), state)

+38

claudeio/lib_mcp/transport_stdio.mli

···

       1
       1
       +
       (** Stdio transport implementation for MCP *)

     

       2
       2
       +
       

     

       3
       3
       +
       (** Parameters for creating a stdio transport *)

     

       4
       4
       +
       type params = {

     

       5
       5
       +
         command : string;

     

       6
       6
       +
         (** The command to execute (executable path or name in PATH) *)

     

       7
       7
       +
       

     

       8
       8
       +
         args : string list;

     

       9
       9
       +
         (** Command-line arguments to pass to the command *)

     

       10
       10
       +
       

     

       11
       11
       +
         env : (string * string) list option;

     

       12
       12
       +
         (** Optional environment variables to set. If [None], inherits parent environment.

     

       13
       13
       +
             If [Some vars], these are ADDED to essential preserved variables (HOME, PATH, etc.) *)

     

       14
       14
       +
       

     

       15
       15
       +
         max_buffer_size : int option;

     

       16
       16
       +
         (** Maximum buffer size for reading from stdout. Defaults to 1MB if [None] *)

     

       17
       17
       +
       }

     

       18
       18
       +
       

     

       19
       19
       +
       (** [create ~sw ~process_mgr params] creates a new stdio transport by spawning

     

       20
       20
       +
           a subprocess with the given parameters.

     

       21
       21
       +
       

     

       22
       22
       +
           The subprocess communicates via line-delimited JSON on stdin/stdout:

     

       23
       23
       +
           - Each message is a single JSON object on one line

     

       24
       24
       +
           - Lines are terminated with newline ('\n')

     

       25
       25
       +
           - The transport handles encoding/decoding automatically

     

       26
       26
       +
       

     

       27
       27
       +
           @param sw The Eio switch that manages the subprocess lifetime

     

       28
       28
       +
           @param process_mgr The Eio process manager for spawning subprocesses

     

       29
       29
       +
           @param params Configuration parameters for the subprocess

     

       30
       30
       +
           @raise Transport.Connection_error if subprocess spawning fails *)

     

       31
       31
       +
       val create :

     

       32
       32
       +
         sw:Eio.Switch.t ->

     

       33
       33
       +
         process_mgr:_ Eio.Process.mgr ->

     

       34
       34
       +
         params ->

     

       35
       35
       +
         Transport.t

     

       36
       36
       +
       

     

       37
       37
       +
       (** Exception raised when subprocess spawning fails *)

     

       38
       38
       +
       exception Process_spawn_error of string

+30

claudeio/mcp.opam

···

       1
       1
       +
       # This file is generated by dune, edit dune-project instead

     

       2
       2
       +
       opam-version: "2.0"

     

       3
       3
       +
       synopsis: "Model Context Protocol (MCP) implementation in OCaml"

     

       4
       4
       +
       description:

     

       5
       5
       +
         "An Eio-based OCaml library implementing the Model Context Protocol for connecting AI assistants with tools and data sources"

     

       6
       6
       +
       depends: [

     

       7
       7
       +
         "ocaml"

     

       8
       8
       +
         "dune" {>= "3.0"}

     

       9
       9
       +
         "eio"

     

       10
       10
       +
         "fmt"

     

       11
       11
       +
         "logs"

     

       12
       12
       +
         "jsont" {>= "0.2.0"}

     

       13
       13
       +
         "jsont_bytesrw" {>= "0.2.0"}

     

       14
       14
       +
         "alcotest" {with-test}

     

       15
       15
       +
         "odoc" {with-doc}

     

       16
       16
       +
       ]

     

       17
       17
       +
       build: [

     

       18
       18
       +
         ["dune" "subst"] {dev}

     

       19
       19
       +
         [

     

       20
       20
       +
           "dune"

     

       21
       21
       +
           "build"

     

       22
       22
       +
           "-p"

     

       23
       23
       +
           name

     

       24
       24
       +
           "-j"

     

       25
       25
       +
           jobs

     

       26
       26
       +
           "@install"

     

       27
       27
       +
           "@runtest" {with-test}

     

       28
       28
       +
           "@doc" {with-doc}

     

       29
       29
       +
         ]

     

       30
       30
       +
       ]