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

+45 -2

lib/mcp.ml

···

       128
       128
        
       

     

       129
       129
        
         let yojson_of_t { data; mime_type; annotations } =

     

       130
       130
        
           let assoc = [

     

       131
       131
       +
             ("type", `String "image");

     

       131
       132
        
             ("data", `String data);

     

       132
       133
        
             ("mimeType", `String mime_type);

     

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

     

       134
       134
        
           ] in

     

       135
       135
        
           let assoc = match annotations with

     

       136
       136
        
             | Some annotations -> ("annotations", Annotated.yojson_of_annotation annotations) :: assoc

     
···

       155
       155
        
             let annotations = List.assoc_opt "annotations" fields |> Option.map Annotated.annotation_of_yojson in

     

       156
       156
        
             { data; mime_type; annotations }

     

       157
       157
        
           | j -> raise (Json.Of_json ("Expected object for ImageContent", j))

     

       158
       158
       +
       end

     

       159
       159
       +
       

     

       160
       160
       +
       module AudioContent = struct

     

       161
       161
       +
         type t = {

     

       162
       162
       +
           data: string;

     

       163
       163
       +
           mime_type: string;

     

       164
       164
       +
           annotations: Annotated.annotation option;

     

       165
       165
       +
         }

     

       166
       166
       +
       

     

       167
       167
       +
         let yojson_of_t { data; mime_type; annotations } =

     

       168
       168
       +
           let assoc = [

     

       169
       169
       +
             ("type", `String "audio");

     

       170
       170
       +
             ("data", `String data);

     

       171
       171
       +
             ("mimeType", `String mime_type);

     

       172
       172
       +
           ] in

     

       173
       173
       +
           let assoc = match annotations with

     

       174
       174
       +
             | Some annotations -> ("annotations", Annotated.yojson_of_annotation annotations) :: assoc

     

       175
       175
       +
             | None -> assoc

     

       176
       176
       +
           in

     

       177
       177
       +
           `Assoc assoc

     

       178
       178
       +
       

     

       179
       179
       +
         let t_of_yojson = function

     

       180
       180
       +
           | `Assoc fields ->

     

       181
       181
       +
             let data = match List.assoc_opt "data" fields with

     

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

     

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

     

       184
       184
       +
             in

     

       185
       185
       +
             let mime_type = match List.assoc_opt "mimeType" fields with

     

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

     

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

     

       188
       188
       +
             in

     

       189
       189
       +
             let _ = match List.assoc_opt "type" fields with

     

       190
       190
       +
               | Some (`String "audio") -> ()

     

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

     

       192
       192
       +
             in

     

       193
       193
       +
             let annotations = List.assoc_opt "annotations" fields |> Option.map Annotated.annotation_of_yojson in

     

       194
       194
       +
             { data; mime_type; annotations }

     

       195
       195
       +
           | j -> raise (Json.Of_json ("Expected object for AudioContent", j))

     

       158
       196
        
       end

     

       159
       197
        
       

     

       160
       198
        
       module ResourceContents = struct

     
···

       304
       342
        
       type content = 

     

       305
       343
        
         | Text of TextContent.t

     

       306
       344
        
         | Image of ImageContent.t

     

       345
       345
       +
         | Audio of AudioContent.t

     

       307
       346
        
         | Resource of EmbeddedResource.t

     

       308
       347
        
       

     

       309
       348
        
       let yojson_of_content = function

     

       310
       349
        
         | Text t -> TextContent.yojson_of_t t

     

       311
       350
        
         | Image i -> ImageContent.yojson_of_t i

     

       351
       351
       +
         | Audio a -> AudioContent.yojson_of_t a

     

       312
       352
        
         | Resource r -> EmbeddedResource.yojson_of_t r

     

       313
       353
        
       

     

       314
       354
        
       let content_of_yojson = function

     
···

       316
       356
        
           (match List.assoc_opt "type" fields with

     

       317
       357
        
            | Some (`String "text") -> Text (TextContent.t_of_yojson (`Assoc fields))

     

       318
       358
        
            | Some (`String "image") -> Image (ImageContent.t_of_yojson (`Assoc fields))

     

       359
       359
       +
            | Some (`String "audio") -> Audio (AudioContent.t_of_yojson (`Assoc fields))

     

       319
       360
        
            | Some (`String "resource") -> Resource (EmbeddedResource.t_of_yojson (`Assoc fields))

     

       320
       361
        
            | _ -> raise (Json.Of_json ("Invalid or missing content type", `Assoc fields)))

     

       321
       362
        
         | j -> raise (Json.Of_json ("Expected object for content", j))

     
···

       351
       392
        
       module SamplingMessage = struct

     

       352
       393
        
         type t = {

     

       353
       394
        
           role: Role.t;

     

       354
       354
       -
           content: [ `Text of TextContent.t | `Image of ImageContent.t ];

     

       395
       395
       +
           content: [ `Text of TextContent.t | `Image of ImageContent.t | `Audio of AudioContent.t ];

     

       355
       396
        
         }

     

       356
       397
        
       

     

       357
       398
        
         let yojson_of_t { role; content } =

     

       358
       399
        
           let content_json = match content with

     

       359
       400
        
             | `Text t -> TextContent.yojson_of_t t

     

       360
       401
        
             | `Image i -> ImageContent.yojson_of_t i

     

       402
       402
       +
             | `Audio a -> AudioContent.yojson_of_t a

     

       361
       403
        
           in

     

       362
       404
        
           `Assoc [

     

       363
       405
        
             ("role", Role.yojson_of_t role);

     
···

       375
       417
        
                 (match List.assoc_opt "type" content_fields with

     

       376
       418
        
                  | Some (`String "text") -> `Text (TextContent.t_of_yojson (`Assoc content_fields))

     

       377
       419
        
                  | Some (`String "image") -> `Image (ImageContent.t_of_yojson (`Assoc content_fields))

     

       420
       420
       +
                  | Some (`String "audio") -> `Audio (AudioContent.t_of_yojson (`Assoc content_fields))

     

       378
       421
        
                  | _ -> raise (Json.Of_json ("Invalid content type", `Assoc content_fields)))

     

       379
       422
        
               | _ -> raise (Json.Of_json ("Missing or invalid content field", `Assoc fields))

     

       380
       423
        
             in

+14 -1

lib/mcp.mli

···

       77
       77
        
         val t_of_yojson : Json.t -> t

     

       78
       78
        
       end

     

       79
       79
        
       

     

       80
       80
       +
       (** Audio content *)

     

       81
       81
       +
       module AudioContent : sig

     

       82
       82
       +
         type t = {

     

       83
       83
       +
           data: string;

     

       84
       84
       +
           mime_type: string;

     

       85
       85
       +
           annotations: Annotated.annotation option;

     

       86
       86
       +
         }

     

       87
       87
       +
       

     

       88
       88
       +
         val yojson_of_t : t -> Json.t

     

       89
       89
       +
         val t_of_yojson : Json.t -> t

     

       90
       90
       +
       end

     

       91
       91
       +
       

     

       80
       92
        
       (** Base resource contents *)

     

       81
       93
        
       module ResourceContents : sig

     

       82
       94
        
         type t = {

     
···

       127
       139
        
       type content = 

     

       128
       140
        
         | Text of TextContent.t

     

       129
       141
        
         | Image of ImageContent.t

     

       142
       142
       +
         | Audio of AudioContent.t

     

       130
       143
        
         | Resource of EmbeddedResource.t

     

       131
       144
        
       

     

       132
       145
        
       val yojson_of_content : content -> Json.t

     
···

       147
       160
        
       module SamplingMessage : sig

     

       148
       161
        
         type t = {

     

       149
       162
        
           role: Role.t;

     

       150
       150
       -
           content: [ `Text of TextContent.t | `Image of ImageContent.t ];

     

       163
       163
       +
           content: [ `Text of TextContent.t | `Image of ImageContent.t | `Audio of AudioContent.t ];

     

       151
       164
        
         }

     

       152
       165
        
       

     

       153
       166
        
         val yojson_of_t : t -> Json.t

+128

lib/mcp_sdk.ml

···

       166
       166
        
       end

     

       167
       167
        
       

     

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

     

       169
       169
       +
       (* Content type constructors *)

     

       169
       170
        
       let make_text_content text =

     

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

     

       171
       172
        
       

     

       173
       173
       +
       let make_image_content data mime_type =

     

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

     

       175
       175
       +
       

     

       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 }

     

       198
       198
       +
       

     

       199
       199
       +
       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
       +
               ]

     

       240
       240
       +
         ) contents in

     

       241
       241
       +
         

     

       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

     

       257
       257
       +
       

     

       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

     

       267
       267
       +
       

     

       172
       268
        
       let make_tool_schema properties required =

     

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

     

       174
       270
        
           (name, `Assoc [

     
···

       260
       356
        
       let register_tool server tool =

     

       261
       357
        
         server.tools <- tool :: server.tools;

     

       262
       358
        
         tool

     

       359
       359
       +
       

     

       360
       360
       +
       (* Create a rich tool result with multiple content types *)

     

       361
       361
       +
       let create_rich_tool_result ?(text=None) ?(image=None) ?(audio=None) ?(resource=None) ~is_error () =

     

       362
       362
       +
         let contents = [] in

     

       363
       363
       +
         

     

       364
       364
       +
         (* Add text content if provided *)

     

       365
       365
       +
         let contents = match text with

     

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

     

       367
       367
       +
           | None -> contents

     

       368
       368
       +
         in

     

       369
       369
       +
         

     

       370
       370
       +
         (* Add image content if provided *)

     

       371
       371
       +
         let contents = match image with

     

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

     

       373
       373
       +
           | None -> contents

     

       374
       374
       +
         in

     

       375
       375
       +
         

     

       376
       376
       +
         (* Add audio content if provided *)

     

       377
       377
       +
         let contents = match audio with

     

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

     

       379
       379
       +
           | None -> contents

     

       380
       380
       +
         in

     

       381
       381
       +
         

     

       382
       382
       +
         (* Add resource content if provided *)

     

       383
       383
       +
         let contents = match resource with

     

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

     

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

     

       386
       386
       +
           | None -> contents

     

       387
       387
       +
         in

     

       388
       388
       +
         

     

       389
       389
       +
         (* Create the final tool result *)

     

       390
       390
       +
         create_tool_result (List.rev contents) ~is_error

     

       263
       391
        
       

     

       264
       392
        
       (* Create and register a tool in one step *)

     

       265
       393
        
       let add_tool server ~name ?description ?(schema_properties=[]) ?(schema_required=[]) handler =

+38 -1

lib/mcp_sdk.mli

···

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

     

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

     

       132
       132
        
       

     

       133
       133
       +
       (** Content type constructors *)

     

       134
       134
       +
       val make_text_content : string -> content

     

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

     

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

     

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

     

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

     

       139
       139
       +
       

     

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

     

       141
       141
       +
       type error_code = 

     

       142
       142
       +
         | ParseError (** -32700 *)

     

       143
       143
       +
         | InvalidRequest (** -32600 *)

     

       144
       144
       +
         | MethodNotFound (** -32601 *)

     

       145
       145
       +
         | InvalidParams (** -32602 *)

     

       146
       146
       +
         | InternalError (** -32603 *)

     

       147
       147
       +
         | ResourceNotFound (** -32002 Custom code for MCP *)

     

       148
       148
       +
         | AuthenticationRequired (** -32001 Custom code for MCP *)

     

       149
       149
       +
         | CustomError of int

     

       150
       150
       +
       

     

       151
       151
       +
       val error_code_to_int : error_code -> int

     

       152
       152
       +
       

     

       153
       153
       +
       (** Tool result handling *)

     

       154
       154
       +
       type tool_content = 

     

       155
       155
       +
         | TextContent of string

     

       156
       156
       +
         | ImageContent of { data: string; mime_type: string }

     

       157
       157
       +
         | AudioContent of { data: string; mime_type: string }

     

       158
       158
       +
         | ResourceContent of { uri: string; data: string; is_blob: bool; mime_type: string option }

     

       159
       159
       +
       

     

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

     

       161
       161
       +
       

     

       162
       162
       +
       (** Create a rich tool result with multiple content types *)

     

       163
       163
       +
       val create_rich_tool_result : 

     

       164
       164
       +
         ?text:string option -> 

     

       165
       165
       +
         ?image:(string * string) option -> 

     

       166
       166
       +
         ?audio:(string * string) option ->

     

       167
       167
       +
         ?resource:(string * string * bool * string option) option -> 

     

       168
       168
       +
         is_error:bool -> 

     

       169
       169
       +
         unit -> Json.t

     

       170
       170
       +
       

     

       133
       171
        
       (** Helper functions for creating common objects *)

     

       134
       134
       -
       val make_text_content : string -> content

     

       135
       172
        
       val make_tool_schema : (string * string * string) list -> string list -> Json.t

+51 -18

lib/mcp_server.ml

···

       51
       51
        
         let result = `Assoc [("resources", `List resource_list)] in

     

       52
       52
        
         Some (create_response ~id:req.id ~result)

     

       53
       53
        
       

     

       54
       54
       -
       (* Create an error result with text content *)

     

       55
       55
       -
       let create_error_content err =

     

       56
       56
       -
         let error_content = TextContent.{

     

       57
       57
       -
           text = err;

     

       58
       58
       -
           annotations = None

     

       59
       59
       -
         } in

     

       60
       60
       -
         `Assoc [

     

       61
       61
       -
           ("content", `List [TextContent.yojson_of_t error_content]);

     

       62
       62
       -
           ("isError", `Bool true)

     

       63
       63
       -
         ]

     

       64
       64
       -
       

     

       65
       54
        
       (* Extract the tool name from params *)

     

       66
       55
        
       let extract_tool_name params =

     

       67
       56
        
         match List.assoc_opt "name" params with

     
···

       82
       71
        
               Log.debug "No arguments provided for tool call, using empty object";

     

       83
       72
        
               `Assoc [] (* Empty arguments is valid *)

     

       84
       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

     

       77
       77
       +
         let error_data = match data with

     

       78
       78
       +
           | Some d -> d

     

       79
       79
       +
           | None -> `Null

     

       80
       80
       +
         in

     

       81
       81
       +
         create_error ~id ~code:error_code ~message ~data:(Some error_data) ()

     

       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

     

       86
       86
       +
       

     

       85
       87
        
       (* Handle tool execution errors *)

     

       86
       88
        
       let handle_tool_execution_error err =

     

       87
       89
        
         Log.error (Printf.sprintf "Tool execution failed: %s" err);

     

       88
       88
       -
         create_error_content (Printf.sprintf "Error executing tool: %s" err)

     

       90
       90
       +
         create_tool_error_result (Printf.sprintf "Error executing tool: %s" err)

     

       89
       91
        
       

     

       90
       92
        
       (* Handle unknown tool error *)

     

       91
       93
        
       let handle_unknown_tool_error name =

     

       92
       94
        
         Log.error (Printf.sprintf "Unknown tool: %s" name);

     

       93
       93
       -
         create_error_content (Printf.sprintf "Unknown tool: %s" name)

     

       95
       95
       +
         create_tool_error_result (Printf.sprintf "Unknown tool: %s" name)

     

       94
       96
        
       

     

       95
       97
        
       (* Handle general tool execution exception *)

     

       96
       98
        
       let handle_tool_execution_exception exn =

     

       97
       99
        
         Log.error (Printf.sprintf "Exception executing tool: %s" (Printexc.to_string exn));

     

       98
       98
       -
         create_error_content (Printf.sprintf "Internal error: %s" (Printexc.to_string exn))

     

       100
       100
       +
         create_tool_error_result (Printf.sprintf "Internal error: %s" (Printexc.to_string exn))

     

       99
       101
        
       

     

       100
       102
        
       (* Execute a tool *)

     

       101
       103
        
       let execute_tool server ctx name args =

     
···

       123
       125
        
               let args = extract_tool_arguments params in

     

       124
       126
        
               

     

       125
       127
        
               (* Create context for this request *)

     

       126
       126
       -
               let ctx = Context.create ?request_id:req.progress_token () in

     

       128
       128
       +
               let ctx = Context.create 

     

       129
       129
       +
                 ?request_id:(Some req.id) (* Store request ID for progress reporting *)

     

       130
       130
       +
                 ~lifespan_context:[("tools/call", `Assoc params)] (* Store params for reference *)

     

       131
       131
       +
                 () 

     

       132
       132
       +
               in

     

       133
       133
       +
               

     

       134
       134
       +
               (* Set progress token if present *)

     

       135
       135
       +
               ctx.progress_token <- req.progress_token;

     

       127
       136
        
               

     

       128
       137
        
               (* Execute the tool *)

     

       129
       138
        
               let result = execute_tool server ctx name args in

     

       139
       139
       +
               

     

       140
       140
       +
               (* Process progress messages if any *)

     

       141
       141
       +
               let progress_msg = Context.report_progress ctx 1.0 1.0 in

     

       142
       142
       +
               (match progress_msg with

     

       143
       143
       +
                | Some msg -> Log.debug "Progress complete notification would be sent here";

     

       144
       144
       +
                | None -> ());

     

       145
       145
       +
               

     

       130
       146
        
               Some (create_response ~id:req.id ~result)

     

       131
       147
        
           | None ->

     

       132
       132
       -
               Some (create_error ~id:req.id ~code:(-32602) ~message:"Missing tool name parameter" ()))

     

       148
       148
       +
               Some (create_jsonrpc_error req.id InvalidParams "Missing tool name parameter" ()))

     

       133
       149
        
         | _ ->

     

       134
       150
        
           Log.error "Invalid params format for tools/call";

     

       135
       135
       -
           Some (create_error ~id:req.id ~code:(-32602) ~message:"Invalid params for tools/call" ())

     

       151
       151
       +
           Some (create_jsonrpc_error req.id InvalidParams "Invalid params format for tools/call" ())

     

       136
       152
        
       

     

       137
       153
        
       (* Process ping request *)

     

       138
       154
        
       let handle_ping (req:JSONRPCMessage.request) =

     
···

       164
       180
        
              | "ping" -> handle_ping req

     

       165
       181
        
              | _ -> 

     

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

     

       167
       167
       -
                 Some (create_error ~id:req.id ~code:(-32601) ~message:("Method not found: " ^ req.method_) ()))

     

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

     

       168
       184
        
           | JSONRPCMessage.Notification notif ->

     

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

     

       170
       186
        
             (match notif.method_ with

     
···

       181
       197
        
         with

     

       182
       198
        
         | Json.Of_json (msg, _) ->

     

       183
       199
        
           Log.error (Printf.sprintf "JSON error: %s" msg);

     

       200
       200
       +
           (* Can't respond with error because we don't have a request ID *)

     

       201
       201
       +
           None

     

       202
       202
       +
         | Yojson.Json_error msg -> 

     

       203
       203
       +
           Log.error (Printf.sprintf "JSON parse error: %s" msg);

     

       204
       204
       +
           (* Can't respond with error because we don't have a request ID *)

     

       184
       205
        
           None

     

       185
       206
        
         | exc ->

     

       186
       207
        
           Log.error (Printf.sprintf "Exception during message processing: %s" (Printexc.to_string exc));

     

       187
       208
        
           Log.error (Printf.sprintf "Backtrace: %s" (Printexc.get_backtrace()));

     

       188
       209
        
           Log.error (Printf.sprintf "Message was: %s" (Yojson.Safe.to_string message));

     

       189
       210
        
           None

     

       211
       211
       +
       

     

       212
       212
       +
       (* Extract a request ID from a potentially malformed message *)

     

       213
       213
       +
       let extract_request_id json =

     

       214
       214
       +
         try

     

       215
       215
       +
           match json with

     

       216
       216
       +
           | `Assoc fields ->

     

       217
       217
       +
             (match List.assoc_opt "id" fields with

     

       218
       218
       +
              | Some (`Int id) -> Some (`Int id)

     

       219
       219
       +
              | Some (`String id) -> Some (`String id)

     

       220
       220
       +
              | _ -> None)

     

       221
       221
       +
           | _ -> None

     

       222
       222
       +
         with _ -> None

     

       190
       223
        
       

     

       191
       224
        
       (* Handle processing for an input line *)

     

       192
       225
        
       let process_input_line server line =