commit 077664f1f0623632f338789c1107b356b8fa6dd4 · anil.recoil.org/ocaml-mcp

+4 -4

bin/capitalize_sdk.ml

···

       72
       72
        
           [

     

       73
       73
        
             Prompt.{ 

     

       74
       74
        
               role = `User; 

     

       75
       75
       -
               content = make_text_content "Please help me capitalize the following text:"

     

       75
       75
       +
               content = Mcp.make_text_content "Please help me capitalize the following text:"

     

       76
       76
        
             };

     

       77
       77
        
             Prompt.{ 

     

       78
       78
        
               role = `User; 

     

       79
       79
       -
               content = make_text_content text

     

       79
       79
       +
               content = Mcp.make_text_content text

     

       80
       80
        
             };

     

       81
       81
        
             Prompt.{ 

     

       82
       82
        
               role = `Assistant; 

     

       83
       83
       -
               content = make_text_content "Here's the capitalized version:"

     

       83
       83
       +
               content = Mcp.make_text_content "Here's the capitalized version:"

     

       84
       84
        
             };

     

       85
       85
        
             Prompt.{ 

     

       86
       86
        
               role = `Assistant; 

     

       87
       87
       -
               content = make_text_content (String.uppercase_ascii text)

     

       87
       87
       +
               content = Mcp.make_text_content (String.uppercase_ascii text)

     

       88
       88
        
             }

     

       89
       89
        
           ]

     

       90
       90
        
         )

+13 -14

bin/multimodal_sdk.ml

···

       262
       262
        
             let audio_data = generate_sine_wave_audio (float_of_int frequency) duration in

     

       263
       263
        
             

     

       264
       264
        
             (* Create a multimodal tool result *)

     

       265
       265
       -
             create_rich_tool_result

     

       266
       266
       -
               ~text:(Some message)

     

       267
       267
       -
               ~image:(Some (image_data, "image/gif"))

     

       268
       268
       -
               ~audio:(Some (audio_data, "audio/wav"))

     

       269
       269
       -
               ~is_error:false

     

       270
       270
       -
               ()

     

       265
       265
       +
             create_tool_result [

     

       266
       266
       +
               Mcp.make_text_content message;

     

       267
       267
       +
               Mcp.make_image_content image_data "image/gif";

     

       268
       268
       +
               Mcp.make_audio_content audio_data "audio/wav"

     

       269
       269
       +
             ] ~is_error:false

     

       271
       270
        
           with

     

       272
       271
        
           | Failure msg -> 

     

       273
       272
        
             Log.error (Printf.sprintf "Error in multimodal tool: %s" msg);

     

       274
       274
       -
             create_tool_result [TextContent (Printf.sprintf "Error: %s" msg)] ~is_error:true

     

       273
       273
       +
             create_tool_result [Mcp.make_text_content (Printf.sprintf "Error: %s" msg)] ~is_error:true

     

       275
       274
        
         )

     

       276
       275
        
       

     

       277
       276
        
       (* Define and register a tool for generating only images *)

     
···

       290
       289
        
             

     

       291
       290
        
             if width < 1 || width > 1024 || height < 1 || height > 1024 then

     

       292
       291
        
               create_tool_result 

     

       293
       293
       -
                 [TextContent "Error: Dimensions must be between 1 and 1024 pixels"] 

     

       292
       292
       +
                 [Mcp.make_text_content "Error: Dimensions must be between 1 and 1024 pixels"] 

     

       294
       293
        
                 ~is_error:true

     

       295
       294
        
             else

     

       296
       295
        
               let image_data = generate_random_image width height in

     

       297
       296
        
               create_tool_result 

     

       298
       298
       -
                 [ImageContent { data = image_data; mime_type = "image/gif" }]

     

       297
       297
       +
                 [Mcp.make_image_content image_data "image/gif"]

     

       299
       298
        
                 ~is_error:false

     

       300
       299
        
           with

     

       301
       300
        
           | Failure msg ->

     

       302
       301
        
             Log.error (Printf.sprintf "Error in generate_image tool: %s" msg);

     

       303
       303
       -
             create_tool_result [TextContent (Printf.sprintf "Error: %s" msg)] ~is_error:true

     

       302
       302
       +
             create_tool_result [Mcp.make_text_content (Printf.sprintf "Error: %s" msg)] ~is_error:true

     

       304
       303
        
         )

     

       305
       304
        
       

     

       306
       305
        
       (* Define and register a tool for generating only audio *)

     
···

       319
       318
        
             

     

       320
       319
        
             if frequency < 20 || frequency > 20000 then

     

       321
       320
        
               create_tool_result 

     

       322
       322
       -
                 [TextContent "Error: Frequency must be between 20Hz and 20,000Hz"] 

     

       321
       321
       +
                 [Mcp.make_text_content "Error: Frequency must be between 20Hz and 20,000Hz"] 

     

       323
       322
        
                 ~is_error:true

     

       324
       323
        
             else if duration < 1 || duration > 10 then

     

       325
       324
        
               create_tool_result 

     

       326
       326
       -
                 [TextContent "Error: Duration must be between 1 and 10 seconds"] 

     

       325
       325
       +
                 [Mcp.make_text_content "Error: Duration must be between 1 and 10 seconds"] 

     

       327
       326
        
                 ~is_error:true

     

       328
       327
        
             else

     

       329
       328
        
               let audio_data = generate_sine_wave_audio (float_of_int frequency) duration in

     

       330
       329
        
               create_tool_result 

     

       331
       331
       -
                 [AudioContent { data = audio_data; mime_type = "audio/wav" }]

     

       330
       330
       +
                 [Mcp.make_audio_content audio_data "audio/wav"]

     

       332
       331
        
                 ~is_error:false

     

       333
       332
        
           with

     

       334
       333
        
           | Failure msg ->

     

       335
       334
        
             Log.error (Printf.sprintf "Error in generate_audio tool: %s" msg);

     

       336
       336
       -
             create_tool_result [TextContent (Printf.sprintf "Error: %s" msg)] ~is_error:true

     

       335
       335
       +
             create_tool_result [Mcp.make_text_content (Printf.sprintf "Error: %s" msg)] ~is_error:true

     

       337
       336
        
         )

     

       338
       337
        
       

     

       339
       338
        
       (* Define and register a resource example with multimodal content *)

+5 -6

bin/ocaml_eval_sdk.ml

···

       5
       5
        
       (* Create a server *)

     

       6
       6
        
       let server = create_server 

     

       7
       7
        
         ~name:"OCaml MCP Structured API Demo" 

     

       8
       8
       -
         ~version:"0.1.0" 

     

       9
       9
       -
         ~protocol_version:"2024-11-05" () |>

     

       8
       8
       +
         ~version:"0.1.0"  () |>

     

       10
       9
        
         fun server ->

     

       11
       10
        
         (* Set default capabilities *)

     

       12
       11
        
           configure_server server ~with_tools:true ~with_resources:true ~with_prompts:true ()

     
···

       135
       134
        
         ] in

     

       136
       135
        
         

     

       137
       136
        
         (* Create a typed response *)

     

       138
       138
       -
         create_resources_list_response ~id:request_id ~resources ()

     

       137
       137
       +
         ResourcesList.create_response ~id:request_id ~resources ()

     

       139
       138
        
       

     

       140
       139
        
       (* Process a tools/list request using the typed API *)

     

       141
       140
        
       let handle_tools_list_request request_id =

     
···

       158
       157
        
         ] in

     

       159
       158
        
         

     

       160
       159
        
         (* Create a typed response *)

     

       161
       161
       -
         create_tools_list_response ~id:request_id ~tools ()

     

       160
       160
       +
         ToolsList.create_response ~id:request_id ~tools ()

     

       162
       161
        
       

     

       163
       162
        
       (* Process a prompts/list request using the typed API *)

     

       164
       163
        
       let handle_prompts_list_request request_id =

     
···

       182
       181
        
         ] in

     

       183
       182
        
         

     

       184
       183
        
         (* Create a typed response *)

     

       185
       185
       -
         create_prompts_list_response ~id:request_id ~prompts ()

     

       184
       184
       +
         PromptsList.create_response ~id:request_id ~prompts ()

     

       186
       185
        
       

     

       187
       186
        
       (* Run the server *)

     

       188
       187
        
       let () =

     
···

       201
       200
        
         

     

       202
       201
        
         (* Run the server with the default scheduler *)

     

       203
       202
        
         Eio_main.run @@ fun env->

     

       204
       204
       -
           Mcp_server.run_server env server
     

       203
       203
       +
           Mcp_server.run_server env server

+58 -1

lib/mcp.ml

···

       1
       1
        
       open Jsonrpc

     

       2
       2
        
       

     

       3
       3
       +
       (* Error codes for JSON-RPC *)

     

       4
       4
       +
       module ErrorCode = struct

     

       5
       5
       +
         type t = 

     

       6
       6
       +
           | ParseError       (* -32700 - Invalid JSON *)

     

       7
       7
       +
           | InvalidRequest   (* -32600 - Invalid JSON-RPC request *)

     

       8
       8
       +
           | MethodNotFound   (* -32601 - Method not available *)

     

       9
       9
       +
           | InvalidParams    (* -32602 - Invalid method parameters *)

     

       10
       10
       +
           | InternalError    (* -32603 - Internal JSON-RPC error *)

     

       11
       11
       +
           | ResourceNotFound (* -32002 - Custom MCP error: requested resource not found *)

     

       12
       12
       +
           | AuthRequired     (* -32001 - Custom MCP error: authentication required *)

     

       13
       13
       +
           | CustomError of int (* For any other error codes *)

     

       14
       14
       +
         

     

       15
       15
       +
         (* Convert the error code to its integer representation *)

     

       16
       16
       +
         let to_int = function

     

       17
       17
       +
           | ParseError -> -32700

     

       18
       18
       +
           | InvalidRequest -> -32600

     

       19
       19
       +
           | MethodNotFound -> -32601

     

       20
       20
       +
           | InvalidParams -> -32602

     

       21
       21
       +
           | InternalError -> -32603

     

       22
       22
       +
           | ResourceNotFound -> -32002

     

       23
       23
       +
           | AuthRequired -> -32001

     

       24
       24
       +
           | CustomError code -> code

     

       25
       25
       +
         

     

       26
       26
       +
         (* Get error message for standard error codes *)

     

       27
       27
       +
         let to_message = function

     

       28
       28
       +
           | ParseError -> "Parse error"

     

       29
       29
       +
           | InvalidRequest -> "Invalid Request"

     

       30
       30
       +
           | MethodNotFound -> "Method not found"

     

       31
       31
       +
           | InvalidParams -> "Invalid params"

     

       32
       32
       +
           | InternalError -> "Internal error"

     

       33
       33
       +
           | ResourceNotFound -> "Resource not found"

     

       34
       34
       +
           | AuthRequired -> "Authentication required"

     

       35
       35
       +
           | CustomError _ -> "Error"

     

       36
       36
       +
       end

     

       37
       37
       +
       

     

       3
       38
        
       (* Protocol method strings *)

     

       4
       39
        
       module Method = struct

     

       5
       40
        
         (* Initialization and lifecycle methods *)

     
···

       817
       852
        
       let create_notification = JSONRPCMessage.create_notification

     

       818
       853
        
       let create_request = JSONRPCMessage.create_request

     

       819
       854
        
       let create_response = JSONRPCMessage.create_response

     

       820
       820
       -
       let create_error = JSONRPCMessage.create_error
     

       855
       855
       +
       let create_error = JSONRPCMessage.create_error

     

       856
       856
       +
       

     

       857
       857
       +
       (* Content type constructors *)

     

       858
       858
       +
       let make_text_content text =

     

       859
       859
       +
         Text (TextContent.{ text; annotations = None })

     

       860
       860
       +
       

     

       861
       861
       +
       let make_image_content data mime_type =

     

       862
       862
       +
         Image (ImageContent.{ data; mime_type; annotations = None })

     

       863
       863
       +
       

     

       864
       864
       +
       let make_audio_content data mime_type =

     

       865
       865
       +
         Audio (AudioContent.{ data; mime_type; annotations = None })

     

       866
       866
       +
       

     

       867
       867
       +
       let make_resource_text_content uri text mime_type =

     

       868
       868
       +
         Resource (EmbeddedResource.{

     

       869
       869
       +
           resource = `Text TextResourceContents.{ uri; text; mime_type };

     

       870
       870
       +
           annotations = None;

     

       871
       871
       +
         })

     

       872
       872
       +
       

     

       873
       873
       +
       let make_resource_blob_content uri blob mime_type =

     

       874
       874
       +
         Resource (EmbeddedResource.{

     

       875
       875
       +
           resource = `Blob BlobResourceContents.{ uri; blob; mime_type };

     

       876
       876
       +
           annotations = None;

     

       877
       877
       +
         })

+62

lib/mcp.mli

···

       23
       23
        
       

     

       24
       24
        
       open Jsonrpc

     

       25
       25
        
       

     

       26
       26
       +
       (** Error codes for JSON-RPC *)

     

       27
       27
       +
       module ErrorCode : sig

     

       28
       28
       +
         (** Standard JSON-RPC error codes with MCP-specific additions *)

     

       29
       29
       +
         type t = 

     

       30
       30
       +
           | ParseError       (** -32700 - Invalid JSON *)

     

       31
       31
       +
           | InvalidRequest   (** -32600 - Invalid JSON-RPC request *)

     

       32
       32
       +
           | MethodNotFound   (** -32601 - Method not available *)

     

       33
       33
       +
           | InvalidParams    (** -32602 - Invalid method parameters *)

     

       34
       34
       +
           | InternalError    (** -32603 - Internal JSON-RPC error *)

     

       35
       35
       +
           | ResourceNotFound (** -32002 - Custom MCP error: requested resource not found *)

     

       36
       36
       +
           | AuthRequired     (** -32001 - Custom MCP error: authentication required *)

     

       37
       37
       +
           | CustomError of int (** For any other error codes *)

     

       38
       38
       +
         

     

       39
       39
       +
         (** Convert the error code to its integer representation

     

       40
       40
       +
             @param code The error code to convert

     

       41
       41
       +
             @return The integer error code as defined in the JSON-RPC spec

     

       42
       42
       +
         *)

     

       43
       43
       +
         val to_int : t -> int

     

       44
       44
       +
         

     

       45
       45
       +
         (** Get error message for standard error codes

     

       46
       46
       +
             @param code The error code to get message for

     

       47
       47
       +
             @return A standard message for the error code

     

       48
       48
       +
         *)

     

       49
       49
       +
         val to_message : t -> string

     

       50
       50
       +
       end

     

       51
       51
       +
       

     

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

     

       27
       53
        
       module Method : sig

     

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

     
···

       952
       978
        
           @return A new JSON-RPC error message

     

       953
       979
        
       *)

     

       954
       980
        
       val create_error : id:RequestId.t -> code:int -> message:string -> ?data:Json.t option -> unit -> JSONRPCMessage.t

     

       981
       981
       +
       

     

       982
       982
       +
       (** Create a new text content object

     

       983
       983
       +
           @param text The text content

     

       984
       984
       +
           @return A content value with the text

     

       985
       985
       +
       *)

     

       986
       986
       +
       val make_text_content : string -> content

     

       987
       987
       +
       

     

       988
       988
       +
       (** Create a new image content object

     

       989
       989
       +
           @param data Base64-encoded image data

     

       990
       990
       +
           @param mime_type MIME type of the image (e.g., "image/png", "image/jpeg")  

     

       991
       991
       +
           @return A content value with the image

     

       992
       992
       +
       *)

     

       993
       993
       +
       val make_image_content : string -> string -> content

     

       994
       994
       +
       

     

       995
       995
       +
       (** Create a new audio content object

     

       996
       996
       +
           @param data Base64-encoded audio data

     

       997
       997
       +
           @param mime_type MIME type of the audio (e.g., "audio/wav", "audio/mp3")

     

       998
       998
       +
           @return A content value with the audio

     

       999
       999
       +
       *)

     

       1000
       1000
       +
       val make_audio_content : string -> string -> content

     

       1001
       1001
       +
       

     

       1002
       1002
       +
       (** Create a new text resource content object

     

       1003
       1003
       +
           @param uri URI that uniquely identifies the resource

     

       1004
       1004
       +
           @param text The text content of the resource

     

       1005
       1005
       +
           @param mime_type Optional MIME type of the text content

     

       1006
       1006
       +
           @return A content value with the text resource

     

       1007
       1007
       +
       *)

     

       1008
       1008
       +
       val make_resource_text_content : string -> string -> string option -> content

     

       1009
       1009
       +
       

     

       1010
       1010
       +
       (** Create a new binary resource content object

     

       1011
       1011
       +
           @param uri URI that uniquely identifies the resource

     

       1012
       1012
       +
           @param blob Base64-encoded binary data

     

       1013
       1013
       +
           @param mime_type Optional MIME type of the binary content

     

       1014
       1014
       +
           @return A content value with the binary resource

     

       1015
       1015
       +
       *)

     

       1016
       1016
       +
       val make_resource_blob_content : string -> string -> string option -> content

+25 -153

lib/mcp_sdk.ml

···

       165
       165
        
           `Assoc assoc

     

       166
       166
        
       end

     

       167
       167
        
       

     

       168
       168
       -
       (* Helper functions for creating common objects *)

     

       169
       169
       -
       (* Content type constructors *)

     

       170
       170
       -
       let make_text_content text =

     

       171
       171
       -
         Text (TextContent.{ text; annotations = None })

     

       172
       172
       -
       

     

       173
       173
       -
       let make_image_content data mime_type =

     

       174
       174
       -
         Image (ImageContent.{ data; mime_type; annotations = None })

     

       168
       168
       +
       (* Content type constructors have been moved to the Mcp module *)

     

       175
       169
        
       

     

       176
       176
       -
       (* Create audio content using the AudioContent module *)

     

       177
       177
       -
       let make_audio_content data mime_type =

     

       178
       178
       -
         Audio (AudioContent.{ data; mime_type; annotations = None })

     

       179
       179
       -
       

     

       180
       180
       -
       let make_resource_text_content uri text mime_type =

     

       181
       181
       -
         Resource (EmbeddedResource.{

     

       182
       182
       -
           resource = `Text TextResourceContents.{ uri; text; mime_type };

     

       183
       183
       -
           annotations = None;

     

       184
       184
       -
         })

     

       185
       185
       -
       

     

       186
       186
       -
       let make_resource_blob_content uri blob mime_type =

     

       187
       187
       -
         Resource (EmbeddedResource.{

     

       188
       188
       -
           resource = `Blob BlobResourceContents.{ uri; blob; mime_type };

     

       189
       189
       -
           annotations = None;

     

       190
       190
       -
         })

     

       191
       191
       -
       

     

       192
       192
       -
       (* Tool result handling *)

     

       193
       193
       -
       type tool_content = 

     

       194
       194
       -
         | TextContent of string

     

       195
       195
       -
         | ImageContent of { data: string; mime_type: string }

     

       196
       196
       -
         | AudioContent of { data: string; mime_type: string }

     

       197
       197
       -
         | ResourceContent of { uri: string; data: string; is_blob: bool; mime_type: string option }

     

       170
       170
       +
       (* Tool result handling using Mcp_message.ToolsCall.ToolContent *)

     

       198
       171
        
       

     

       199
       172
        
       let create_tool_result contents ~is_error =

     

       200
       200
       -
         let content_json = List.map (function

     

       201
       201
       -
           | TextContent text -> 

     

       202
       202
       -
               `Assoc [

     

       203
       203
       -
                 ("type", `String "text");

     

       204
       204
       -
                 ("text", `String text)

     

       205
       205
       -
               ]

     

       206
       206
       -
           | ImageContent { data; mime_type } ->

     

       207
       207
       -
               `Assoc [

     

       208
       208
       -
                 ("type", `String "image");

     

       209
       209
       -
                 ("data", `String data);

     

       210
       210
       -
                 ("mimeType", `String mime_type)

     

       211
       211
       -
               ]

     

       212
       212
       -
           | AudioContent { data; mime_type } ->

     

       213
       213
       -
               `Assoc [

     

       214
       214
       -
                 ("type", `String "audio");

     

       215
       215
       -
                 ("data", `String data);

     

       216
       216
       -
                 ("mimeType", `String mime_type)

     

       217
       217
       -
               ]

     

       218
       218
       -
           | ResourceContent { uri; data; is_blob; mime_type } ->

     

       219
       219
       -
               let resource_data = if is_blob then

     

       220
       220
       -
                 `Assoc (

     

       221
       221
       -
                   [("uri", `String uri); 

     

       222
       222
       -
                    ("blob", `String data)] @

     

       223
       223
       -
                   (match mime_type with 

     

       224
       224
       -
                    | Some mime -> [("mimeType", `String mime)]

     

       225
       225
       -
                    | None -> [])

     

       226
       226
       -
                 )

     

       227
       227
       -
               else

     

       228
       228
       -
                 `Assoc (

     

       229
       229
       -
                   [("uri", `String uri); 

     

       230
       230
       -
                    ("text", `String data)] @

     

       231
       231
       -
                   (match mime_type with 

     

       232
       232
       -
                    | Some mime -> [("mimeType", `String mime)]

     

       233
       233
       -
                    | None -> [])

     

       234
       234
       -
                 )

     

       235
       235
       -
               in

     

       236
       236
       -
               `Assoc [

     

       237
       237
       -
                 ("type", `String "resource");

     

       238
       238
       -
                 ("resource", resource_data)

     

       239
       239
       -
               ]

     

       173
       173
       +
         (* Use the original Mcp.content values as is *)

     

       174
       174
       +
         let content = List.map (fun content ->

     

       175
       175
       +
           match content with

     

       176
       176
       +
           | Text text_content -> 

     

       177
       177
       +
               Mcp_message.ToolsCall.ToolContent.Text text_content

     

       178
       178
       +
           | Image image_content -> 

     

       179
       179
       +
               Mcp_message.ToolsCall.ToolContent.Image image_content

     

       180
       180
       +
           | Audio audio_content -> 

     

       181
       181
       +
               Mcp_message.ToolsCall.ToolContent.Audio audio_content

     

       182
       182
       +
           | Resource resource_content ->

     

       183
       183
       +
               Mcp_message.ToolsCall.ToolContent.Resource resource_content

     

       240
       184
        
         ) contents in

     

       241
       185
        
         

     

       242
       242
       -
         `Assoc [

     

       243
       243
       -
           ("content", `List content_json);

     

       244
       244
       -
           ("isError", `Bool is_error)

     

       245
       245
       -
         ]

     

       246
       246
       -
       

     

       247
       247
       -
       (* Error types with standard JSON-RPC error codes *)

     

       248
       248
       -
       type error_code = 

     

       249
       249
       -
         | ParseError (* -32700 *)

     

       250
       250
       -
         | InvalidRequest (* -32600 *)

     

       251
       251
       -
         | MethodNotFound (* -32601 *)

     

       252
       252
       -
         | InvalidParams (* -32602 *)

     

       253
       253
       -
         | InternalError (* -32603 *)

     

       254
       254
       -
         | ResourceNotFound (* -32002 Custom code for MCP *)

     

       255
       255
       -
         | AuthenticationRequired (* -32001 Custom code for MCP *)

     

       256
       256
       -
         | CustomError of int

     

       186
       186
       +
         (* Use the ToolsCall.Response module's JSON conversion *)

     

       187
       187
       +
         Mcp_message.ToolsCall.Response.yojson_of_t { content; is_error }

     

       257
       188
        
       

     

       258
       258
       -
       let error_code_to_int = function

     

       259
       259
       -
         | ParseError -> -32700

     

       260
       260
       -
         | InvalidRequest -> -32600

     

       261
       261
       -
         | MethodNotFound -> -32601

     

       262
       262
       -
         | InvalidParams -> -32602

     

       263
       263
       -
         | InternalError -> -32603

     

       264
       264
       -
         | ResourceNotFound -> -32002

     

       265
       265
       -
         | AuthenticationRequired -> -32001

     

       266
       266
       -
         | CustomError code -> code

     

       189
       189
       +
       (* Using error codes from Mcp.ErrorCode module *)

     

       267
       190
        
       

     

       268
       191
        
       let make_tool_schema properties required =

     

       269
       192
        
         let props = List.map (fun (name, schema_type, description) ->

     
···

       363
       286
        
         

     

       364
       287
        
         (* Add text content if provided *)

     

       365
       288
        
         let contents = match text with

     

       366
       366
       -
           | Some text -> (TextContent text) :: contents

     

       289
       289
       +
           | Some text -> (Mcp.make_text_content text) :: contents

     

       367
       290
        
           | None -> contents

     

       368
       291
        
         in

     

       369
       292
        
         

     

       370
       293
        
         (* Add image content if provided *)

     

       371
       294
        
         let contents = match image with

     

       372
       372
       -
           | Some (data, mime_type) -> (ImageContent { data; mime_type }) :: contents

     

       295
       295
       +
           | Some (data, mime_type) -> (Mcp.make_image_content data mime_type) :: contents

     

       373
       296
        
           | None -> contents

     

       374
       297
        
         in

     

       375
       298
        
         

     

       376
       299
        
         (* Add audio content if provided *)

     

       377
       300
        
         let contents = match audio with

     

       378
       378
       -
           | Some (data, mime_type) -> (AudioContent { data; mime_type }) :: contents

     

       301
       301
       +
           | Some (data, mime_type) -> (Mcp.make_audio_content data mime_type) :: contents

     

       379
       302
        
           | None -> contents

     

       380
       303
        
         in

     

       381
       304
        
         

     

       382
       305
        
         (* Add resource content if provided *)

     

       383
       306
        
         let contents = match resource with

     

       384
       307
        
           | Some (uri, data, is_blob, mime_type) -> 

     

       385
       385
       -
               (ResourceContent { uri; data; is_blob; mime_type }) :: contents

     

       308
       308
       +
               (if is_blob then 

     

       309
       309
       +
                  Mcp.make_resource_blob_content uri data mime_type

     

       310
       310
       +
                else 

     

       311
       311
       +
                  Mcp.make_resource_text_content uri data mime_type) :: contents

     

       386
       312
        
           | None -> contents

     

       387
       313
        
         in

     

       388
       314
        
         

     
···

       476
       402
        
         set_capabilities server capabilities;

     

       477
       403
        
         server

     

       478
       404
        
       

     

       479
       479
       -
       (* MCP Protocol Message Helpers *)

     

       480
       480
       -
       

     

       481
       481
       -
       (* Resources helpers *)

     

       482
       482
       -
       let create_resources_list_request ?cursor ?id () =

     

       483
       483
       -
         Mcp_message.ResourcesList.create_request ?cursor ?id ()

     

       484
       484
       -
       

     

       485
       485
       -
       let create_resources_list_response ~id ~resources ?next_cursor () =

     

       486
       486
       -
         Mcp_message.ResourcesList.create_response ~id ~resources ?next_cursor ()

     

       487
       487
       -
       

     

       488
       488
       -
       let create_resources_read_request ~uri ?id () =

     

       489
       489
       -
         Mcp_message.ResourcesRead.create_request ~uri ?id ()

     

       490
       490
       -
       

     

       491
       491
       -
       let create_resources_read_response ~id ~contents () =

     

       492
       492
       -
         Mcp_message.ResourcesRead.create_response ~id ~contents ()

     

       493
       493
       -
       

     

       494
       494
       -
       let create_resources_list_changed_notification () =

     

       495
       495
       -
         Mcp_message.ListChanged.create_resources_notification ()

     

       496
       496
       -
       

     

       497
       497
       -
       let create_resources_updated_notification ~uri () =

     

       498
       498
       -
         Mcp_message.ResourceUpdated.create_notification ~uri ()

     

       499
       499
       -
       

     

       500
       500
       -
       (* Tools helpers *)

     

       501
       501
       -
       let create_tools_list_request ?cursor ?id () =

     

       502
       502
       -
         Mcp_message.ToolsList.create_request ?cursor ?id ()

     

       503
       503
       -
       

     

       504
       504
       -
       let create_tools_list_response ~id ~tools ?next_cursor () =

     

       505
       505
       -
         Mcp_message.ToolsList.create_response ~id ~tools ?next_cursor ()

     

       506
       506
       -
       

     

       507
       507
       -
       let create_tools_call_request ~name ~arguments ?id () =

     

       508
       508
       -
         Mcp_message.ToolsCall.create_request ~name ~arguments ?id ()

     

       509
       509
       -
       

     

       510
       510
       -
       let create_tools_call_response ~id ~content ~is_error () =

     

       511
       511
       -
         Mcp_message.ToolsCall.create_response ~id ~content ~is_error ()

     

       512
       512
       -
       

     

       513
       513
       -
       let create_tools_list_changed_notification () =

     

       514
       514
       -
         Mcp_message.ListChanged.create_tools_notification ()

     

       515
       515
       -
       

     

       516
       516
       -
       (* Prompts helpers *)

     

       517
       517
       -
       let create_prompts_list_request ?cursor ?id () =

     

       518
       518
       -
         Mcp_message.PromptsList.create_request ?cursor ?id ()

     

       519
       519
       -
       

     

       520
       520
       -
       let create_prompts_list_response ~id ~prompts ?next_cursor () =

     

       521
       521
       -
         Mcp_message.PromptsList.create_response ~id ~prompts ?next_cursor ()

     

       522
       522
       -
       

     

       523
       523
       -
       let create_prompts_get_request ~name ~arguments ?id () =

     

       524
       524
       -
         Mcp_message.PromptsGet.create_request ~name ~arguments ?id ()

     

       525
       525
       -
       

     

       526
       526
       -
       let create_prompts_get_response ~id ?description ~messages () =

     

       527
       527
       -
         Mcp_message.PromptsGet.create_response ~id ?description ~messages ()

     

       528
       528
       -
       

     

       529
       529
       -
       let create_prompts_list_changed_notification () =

     

       530
       530
       -
         Mcp_message.ListChanged.create_prompts_notification ()

     

       531
       531
       -
       

     

       532
       532
       -
       (* Progress notification *)

     

       533
       533
       -
       let create_progress_notification ~progress ~total ~progress_token () =

     

       534
       534
       -
         Mcp_message.Progress.create_notification ~progress ~total ~progress_token ()

     

       405
       405
       +
       (* The MCP message helpers have been moved to Mcp_message module. 

     

       406
       406
       +
          This module now reexports them through open statements. *)

+1 -57

lib/mcp_sdk.mli

···

       2
       2
        
       

     

       3
       3
        
       open Mcp

     

       4
       4
        
       open Jsonrpc

     

       5
       5
       -
       open Mcp_message

     

       6
       5
        
       

     

       7
       6
        
       (** SDK version *)

     

       8
       7
        
       val version : string

     
···

       115
       114
        
       (** Configure server with default capabilities based on registered components *)

     

       116
       115
        
       val configure_server : server -> ?with_tools:bool -> ?with_resources:bool -> ?with_prompts:bool -> unit -> server

     

       117
       116
        
       

     

       118
       118
       -
       (** Content type constructors *)

     

       119
       119
       -
       val make_text_content : string -> content

     

       120
       120
       -
       val make_image_content : string -> string -> content

     

       121
       121
       -
       val make_audio_content : string -> string -> content

     

       122
       122
       -
       val make_resource_text_content : string -> string -> string option -> content

     

       123
       123
       -
       val make_resource_blob_content : string -> string -> string option -> content

     

       124
       124
       -
       

     

       125
       125
       -
       (** Error types with standard JSON-RPC error codes *)

     

       126
       126
       -
       type error_code = 

     

       127
       127
       -
         | ParseError (** -32700 *)

     

       128
       128
       -
         | InvalidRequest (** -32600 *)

     

       129
       129
       -
         | MethodNotFound (** -32601 *)

     

       130
       130
       -
         | InvalidParams (** -32602 *)

     

       131
       131
       -
         | InternalError (** -32603 *)

     

       132
       132
       -
         | ResourceNotFound (** -32002 Custom code for MCP *)

     

       133
       133
       -
         | AuthenticationRequired (** -32001 Custom code for MCP *)

     

       134
       134
       -
         | CustomError of int

     

       135
       135
       -
       

     

       136
       136
       -
       val error_code_to_int : error_code -> int

     

       137
       137
       -
       

     

       138
       138
       -
       (** Tool result handling *)

     

       139
       139
       -
       type tool_content = 

     

       140
       140
       -
         | TextContent of string

     

       141
       141
       -
         | ImageContent of { data: string; mime_type: string }

     

       142
       142
       -
         | AudioContent of { data: string; mime_type: string }

     

       143
       143
       -
         | ResourceContent of { uri: string; data: string; is_blob: bool; mime_type: string option }

     

       144
       144
       -
       

     

       145
       145
       -
       val create_tool_result : tool_content list -> is_error:bool -> Json.t

     

       117
       117
       +
       val create_tool_result : content list -> is_error:bool -> Json.t

     

       146
       118
        
       

     

       147
       119
        
       (** Create a rich tool result with multiple content types *)

     

       148
       120
        
       val create_rich_tool_result : 

     
···

       153
       125
        
         is_error:bool -> 

     

       154
       126
        
         unit -> Json.t

     

       155
       127
        
       

     

       156
       156
       -
       (** Helper functions for creating common objects *)

     

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

     

       158
       158
       -
       

     

       159
       159
       -
       (** MCP Protocol Message Helpers for handling JSON-RPC messages *)

     

       160
       160
       -
       

     

       161
       161
       -
       (** Resource message functions *)

     

       162
       162
       -
       val create_resources_list_request : ?cursor:Cursor.t -> ?id:RequestId.t -> unit -> JSONRPCMessage.t

     

       163
       163
       -
       val create_resources_list_response : id:RequestId.t -> resources:ResourcesList.Resource.t list -> ?next_cursor:Cursor.t -> unit -> JSONRPCMessage.t

     

       164
       164
       -
       val create_resources_read_request : uri:string -> ?id:RequestId.t -> unit -> JSONRPCMessage.t

     

       165
       165
       -
       val create_resources_read_response : id:RequestId.t -> contents:ResourcesRead.ResourceContent.t list -> unit -> JSONRPCMessage.t

     

       166
       166
       -
       val create_resources_list_changed_notification : unit -> JSONRPCMessage.t

     

       167
       167
       -
       val create_resources_updated_notification : uri:string -> unit -> JSONRPCMessage.t

     

       168
       168
       -
       

     

       169
       169
       -
       (** Tool message functions *)

     

       170
       170
       -
       val create_tools_list_request : ?cursor:Cursor.t -> ?id:RequestId.t -> unit -> JSONRPCMessage.t

     

       171
       171
       -
       val create_tools_list_response : id:RequestId.t -> tools:ToolsList.Tool.t list -> ?next_cursor:Cursor.t -> unit -> JSONRPCMessage.t

     

       172
       172
       -
       val create_tools_call_request : name:string -> arguments:Json.t -> ?id:RequestId.t -> unit -> JSONRPCMessage.t

     

       173
       173
       -
       val create_tools_call_response : id:RequestId.t -> content:ToolsCall.ToolContent.t list -> is_error:bool -> unit -> JSONRPCMessage.t

     

       174
       174
       -
       val create_tools_list_changed_notification : unit -> JSONRPCMessage.t

     

       175
       175
       -
       

     

       176
       176
       -
       (** Prompt message functions *)

     

       177
       177
       -
       val create_prompts_list_request : ?cursor:Cursor.t -> ?id:RequestId.t -> unit -> JSONRPCMessage.t

     

       178
       178
       -
       val create_prompts_list_response : id:RequestId.t -> prompts:PromptsList.Prompt.t list -> ?next_cursor:Cursor.t -> unit -> JSONRPCMessage.t

     

       179
       179
       -
       val create_prompts_get_request : name:string -> arguments:(string * string) list -> ?id:RequestId.t -> unit -> JSONRPCMessage.t

     

       180
       180
       -
       val create_prompts_get_response : id:RequestId.t -> ?description:string -> messages:PromptMessage.t list -> unit -> JSONRPCMessage.t

     

       181
       181
       -
       val create_prompts_list_changed_notification : unit -> JSONRPCMessage.t

     

       182
       182
       -
       

     

       183
       183
       -
       (** Progress notification *)

     

       184
       184
       -
       val create_progress_notification : progress:float -> total:float -> progress_token:ProgressToken.t -> unit -> JSONRPCMessage.t

+2 -2

lib/mcp_server.ml

···

       73
       73
        
       

     

       74
       74
        
       (* Create a proper JSONRPC error with code and data *)

     

       75
       75
        
       let create_jsonrpc_error id code message ?data () =

     

       76
       76
       -
         let error_code = error_code_to_int code in

     

       76
       76
       +
         let error_code = ErrorCode.to_int code in

     

       77
       77
        
         let error_data = match data with

     

       78
       78
        
           | Some d -> d

     

       79
       79
        
           | None -> `Null

     
···

       82
       82
        
       

     

       83
       83
        
       (* Create a tool error result with structured content *)

     

       84
       84
        
       let create_tool_error_result error =

     

       85
       85
       -
         create_tool_result [TextContent error] ~is_error:true

     

       85
       85
       +
         create_tool_result [make_text_content error] ~is_error:true

     

       86
       86
        
       

     

       87
       87
        
       (* Handle tool execution errors *)

     

       88
       88
        
       let handle_tool_execution_error err =