My agentic slop goes here. Not intended for anyone else!
anil.recoil.org
1(** MCP Protocol Messages *)
2
3(* Protocol Version *)
4
5type protocol_version = string
6
7let protocol_version_jsont = Jsont.string
8
9(* Initialize Protocol *)
10
11module Initialize = struct
12 type request_params = {
13 protocol_version : protocol_version;
14 capabilities : Capabilities.Client.t;
15 client_info : Capabilities.Implementation.t;
16 unknown : Jsont.json;
17 }
18
19 let make_request_params ~protocol_version ~capabilities ~client_info () =
20 let unknown = Jsont.Object ([], Jsont.Meta.none) in
21 { protocol_version; capabilities; client_info; unknown }
22
23 let request_params_jsont : request_params Jsont.t =
24 let make protocol_version capabilities client_info unknown =
25 { protocol_version; capabilities; client_info; unknown }
26 in
27 Jsont.Object.map ~kind:"InitializeRequestParams" make
28 |> Jsont.Object.mem "protocolVersion" protocol_version_jsont
29 ~enc:(fun p -> p.protocol_version)
30 |> Jsont.Object.mem "capabilities" Capabilities.Client.jsont
31 ~enc:(fun p -> p.capabilities)
32 |> Jsont.Object.mem "clientInfo" Capabilities.Implementation.jsont
33 ~enc:(fun p -> p.client_info)
34 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun p -> p.unknown)
35 |> Jsont.Object.finish
36
37 type result = {
38 protocol_version : protocol_version;
39 capabilities : Capabilities.Server.t;
40 server_info : Capabilities.Implementation.t;
41 instructions : string option;
42 unknown : Jsont.json;
43 }
44
45 let make_result ~protocol_version ~capabilities ~server_info ?instructions () =
46 let unknown = Jsont.Object ([], Jsont.Meta.none) in
47 { protocol_version; capabilities; server_info; instructions; unknown }
48
49 let result_jsont : result Jsont.t =
50 let make protocol_version capabilities server_info instructions unknown =
51 { protocol_version; capabilities; server_info; instructions; unknown }
52 in
53 Jsont.Object.map ~kind:"InitializeResult" make
54 |> Jsont.Object.mem "protocolVersion" protocol_version_jsont
55 ~enc:(fun r -> r.protocol_version)
56 |> Jsont.Object.mem "capabilities" Capabilities.Server.jsont
57 ~enc:(fun r -> r.capabilities)
58 |> Jsont.Object.mem "serverInfo" Capabilities.Implementation.jsont
59 ~enc:(fun r -> r.server_info)
60 |> Jsont.Object.opt_mem "instructions" Jsont.string
61 ~enc:(fun r -> r.instructions)
62 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)
63 |> Jsont.Object.finish
64
65 let method_ = "initialize"
66end
67
68module Initialized = struct
69 type notification = {
70 unknown : Jsont.json;
71 }
72
73 let make_notification () =
74 let unknown = Jsont.Object ([], Jsont.Meta.none) in
75 { unknown }
76
77 let notification_jsont : notification Jsont.t =
78 let make unknown = { unknown } in
79 Jsont.Object.map ~kind:"InitializedNotification" make
80 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun n -> n.unknown)
81 |> Jsont.Object.finish
82
83 let method_ = "notifications/initialized"
84end
85
86module Ping = struct
87 type params = {
88 unknown : Jsont.json;
89 }
90
91 let make_params () =
92 let unknown = Jsont.Object ([], Jsont.Meta.none) in
93 { unknown }
94
95 let params_jsont : params Jsont.t =
96 let make unknown = { unknown } in
97 Jsont.Object.map ~kind:"PingParams" make
98 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun p -> p.unknown)
99 |> Jsont.Object.finish
100
101 type result = {
102 unknown : Jsont.json;
103 }
104
105 let make_result () =
106 let unknown = Jsont.Object ([], Jsont.Meta.none) in
107 { unknown }
108
109 let result_jsont : result Jsont.t =
110 let make unknown = { unknown } in
111 Jsont.Object.map ~kind:"PingResult" make
112 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)
113 |> Jsont.Object.finish
114
115 let method_ = "ping"
116end
117
118(* Resources *)
119
120module Resources = struct
121 type resource = {
122 uri : string;
123 name : string;
124 description : string option;
125 mime_type : string option;
126 unknown : Jsont.json;
127 }
128
129 let make_resource ~uri ~name ?description ?mime_type () =
130 let unknown = Jsont.Object ([], Jsont.Meta.none) in
131 { uri; name; description; mime_type; unknown }
132
133 let resource_jsont : resource Jsont.t =
134 let make uri name description mime_type unknown =
135 { uri; name; description; mime_type; unknown }
136 in
137 Jsont.Object.map ~kind:"Resource" make
138 |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
139 |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
140 |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
141 |> Jsont.Object.opt_mem "mimeType" Jsont.string ~enc:(fun r -> r.mime_type)
142 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)
143 |> Jsont.Object.finish
144
145 type resource_template = {
146 uri_template : string;
147 name : string;
148 description : string option;
149 mime_type : string option;
150 unknown : Jsont.json;
151 }
152
153 let make_resource_template ~uri_template ~name ?description ?mime_type () =
154 let unknown = Jsont.Object ([], Jsont.Meta.none) in
155 { uri_template; name; description; mime_type; unknown }
156
157 let resource_template_jsont : resource_template Jsont.t =
158 let make uri_template name description mime_type unknown =
159 { uri_template; name; description; mime_type; unknown }
160 in
161 Jsont.Object.map ~kind:"ResourceTemplate" make
162 |> Jsont.Object.mem "uriTemplate" Jsont.string ~enc:(fun t -> t.uri_template)
163 |> Jsont.Object.mem "name" Jsont.string ~enc:(fun t -> t.name)
164 |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun t -> t.description)
165 |> Jsont.Object.opt_mem "mimeType" Jsont.string ~enc:(fun t -> t.mime_type)
166 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun t -> t.unknown)
167 |> Jsont.Object.finish
168
169 type resource_contents = {
170 uri : string;
171 mime_type : string option;
172 text : string option;
173 blob : string option;
174 unknown : Jsont.json;
175 }
176
177 let make_text_contents ~uri ~text ?mime_type () =
178 let unknown = Jsont.Object ([], Jsont.Meta.none) in
179 { uri; mime_type; text = Some text; blob = None; unknown }
180
181 let make_blob_contents ~uri ~blob ~mime_type =
182 let unknown = Jsont.Object ([], Jsont.Meta.none) in
183 { uri; mime_type = Some mime_type; text = None; blob = Some blob; unknown }
184
185 let resource_contents_jsont : resource_contents Jsont.t =
186 let make uri mime_type text blob unknown =
187 { uri; mime_type; text; blob; unknown }
188 in
189 Jsont.Object.map ~kind:"ResourceContents" make
190 |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun c -> c.uri)
191 |> Jsont.Object.opt_mem "mimeType" Jsont.string ~enc:(fun c -> c.mime_type)
192 |> Jsont.Object.opt_mem "text" Jsont.string ~enc:(fun c -> c.text)
193 |> Jsont.Object.opt_mem "blob" Jsont.string ~enc:(fun c -> c.blob)
194 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun c -> c.unknown)
195 |> Jsont.Object.finish
196
197 type list_request = {
198 cursor : string option;
199 unknown : Jsont.json;
200 }
201
202 let make_list_request ?cursor () =
203 let unknown = Jsont.Object ([], Jsont.Meta.none) in
204 { cursor; unknown }
205
206 let list_request_jsont : list_request Jsont.t =
207 let make cursor unknown = { cursor; unknown } in
208 Jsont.Object.map ~kind:"ResourcesListRequest" make
209 |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
210 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)
211 |> Jsont.Object.finish
212
213 type list_result = {
214 resources : resource list;
215 next_cursor : string option;
216 unknown : Jsont.json;
217 }
218
219 let make_list_result ~resources ?next_cursor () =
220 let unknown = Jsont.Object ([], Jsont.Meta.none) in
221 { resources; next_cursor; unknown }
222
223 let list_result_jsont : list_result Jsont.t =
224 let make resources next_cursor unknown =
225 { resources; next_cursor; unknown }
226 in
227 Jsont.Object.map ~kind:"ResourcesListResult" make
228 |> Jsont.Object.mem "resources" (Jsont.list resource_jsont)
229 ~enc:(fun r -> r.resources)
230 |> Jsont.Object.opt_mem "nextCursor" Jsont.string
231 ~enc:(fun r -> r.next_cursor)
232 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)
233 |> Jsont.Object.finish
234
235 type read_request = {
236 uri : string;
237 unknown : Jsont.json;
238 }
239
240 let make_read_request ~uri =
241 let unknown = Jsont.Object ([], Jsont.Meta.none) in
242 { uri; unknown }
243
244 let read_request_jsont : read_request Jsont.t =
245 let make uri unknown = { uri; unknown } in
246 Jsont.Object.map ~kind:"ResourcesReadRequest" make
247 |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
248 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)
249 |> Jsont.Object.finish
250
251 type read_result = {
252 contents : resource_contents list;
253 unknown : Jsont.json;
254 }
255
256 let make_read_result ~contents =
257 let unknown = Jsont.Object ([], Jsont.Meta.none) in
258 { contents; unknown }
259
260 let read_result_jsont : read_result Jsont.t =
261 let make contents unknown = { contents; unknown } in
262 Jsont.Object.map ~kind:"ResourcesReadResult" make
263 |> Jsont.Object.mem "contents" (Jsont.list resource_contents_jsont)
264 ~enc:(fun r -> r.contents)
265 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)
266 |> Jsont.Object.finish
267
268 type subscribe_request = {
269 uri : string;
270 unknown : Jsont.json;
271 }
272
273 let make_subscribe_request ~uri =
274 let unknown = Jsont.Object ([], Jsont.Meta.none) in
275 { uri; unknown }
276
277 let subscribe_request_jsont : subscribe_request Jsont.t =
278 let make uri unknown = { uri; unknown } in
279 Jsont.Object.map ~kind:"ResourcesSubscribeRequest" make
280 |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
281 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)
282 |> Jsont.Object.finish
283
284 type unsubscribe_request = {
285 uri : string;
286 unknown : Jsont.json;
287 }
288
289 let make_unsubscribe_request ~uri =
290 let unknown = Jsont.Object ([], Jsont.Meta.none) in
291 { uri; unknown }
292
293 let unsubscribe_request_jsont : unsubscribe_request Jsont.t =
294 let make uri unknown = { uri; unknown } in
295 Jsont.Object.map ~kind:"ResourcesUnsubscribeRequest" make
296 |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
297 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)
298 |> Jsont.Object.finish
299
300 type updated_notification = {
301 uri : string;
302 unknown : Jsont.json;
303 }
304
305 let make_updated_notification ~uri =
306 let unknown = Jsont.Object ([], Jsont.Meta.none) in
307 { uri; unknown }
308
309 let updated_notification_jsont : updated_notification Jsont.t =
310 let make uri unknown = { uri; unknown } in
311 Jsont.Object.map ~kind:"ResourceUpdatedNotification" make
312 |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun n -> n.uri)
313 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun n -> n.unknown)
314 |> Jsont.Object.finish
315
316 type list_changed_notification = {
317 unknown : Jsont.json;
318 }
319
320 let make_list_changed_notification () =
321 let unknown = Jsont.Object ([], Jsont.Meta.none) in
322 { unknown }
323
324 let list_changed_notification_jsont : list_changed_notification Jsont.t =
325 let make unknown = { unknown } in
326 Jsont.Object.map ~kind:"ResourceListChangedNotification" make
327 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun n -> n.unknown)
328 |> Jsont.Object.finish
329
330 let list_method = "resources/list"
331 let read_method = "resources/read"
332 let subscribe_method = "resources/subscribe"
333 let unsubscribe_method = "resources/unsubscribe"
334 let updated_notification_method = "notifications/resources/updated"
335 let list_changed_notification_method = "notifications/resources/list_changed"
336end
337
338(* Tools *)
339
340module Tools = struct
341 type tool = {
342 name : string;
343 description : string option;
344 input_schema : Jsont.json;
345 unknown : Jsont.json;
346 }
347
348 let make_tool ~name ?description ~input_schema () =
349 let unknown = Jsont.Object ([], Jsont.Meta.none) in
350 { name; description; input_schema; unknown }
351
352 let tool_jsont : tool Jsont.t =
353 let make name description input_schema unknown =
354 { name; description; input_schema; unknown }
355 in
356 Jsont.Object.map ~kind:"Tool" make
357 |> Jsont.Object.mem "name" Jsont.string ~enc:(fun t -> t.name)
358 |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun t -> t.description)
359 |> Jsont.Object.mem "inputSchema" Jsont.json ~enc:(fun t -> t.input_schema)
360 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun t -> t.unknown)
361 |> Jsont.Object.finish
362
363 type list_request = {
364 cursor : string option;
365 unknown : Jsont.json;
366 }
367
368 let make_list_request ?cursor () =
369 let unknown = Jsont.Object ([], Jsont.Meta.none) in
370 { cursor; unknown }
371
372 let list_request_jsont : list_request Jsont.t =
373 let make cursor unknown = { cursor; unknown } in
374 Jsont.Object.map ~kind:"ToolsListRequest" make
375 |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
376 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)
377 |> Jsont.Object.finish
378
379 type list_result = {
380 tools : tool list;
381 next_cursor : string option;
382 unknown : Jsont.json;
383 }
384
385 let make_list_result ~tools ?next_cursor () =
386 let unknown = Jsont.Object ([], Jsont.Meta.none) in
387 { tools; next_cursor; unknown }
388
389 let list_result_jsont : list_result Jsont.t =
390 let make tools next_cursor unknown =
391 { tools; next_cursor; unknown }
392 in
393 Jsont.Object.map ~kind:"ToolsListResult" make
394 |> Jsont.Object.mem "tools" (Jsont.list tool_jsont)
395 ~enc:(fun r -> r.tools)
396 |> Jsont.Object.opt_mem "nextCursor" Jsont.string
397 ~enc:(fun r -> r.next_cursor)
398 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)
399 |> Jsont.Object.finish
400
401 type call_request = {
402 name : string;
403 arguments : Jsont.json option;
404 unknown : Jsont.json;
405 }
406
407 let make_call_request ~name ?arguments () =
408 let unknown = Jsont.Object ([], Jsont.Meta.none) in
409 { name; arguments; unknown }
410
411 let call_request_jsont : call_request Jsont.t =
412 let make name arguments unknown = { name; arguments; unknown } in
413 Jsont.Object.map ~kind:"ToolsCallRequest" make
414 |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
415 |> Jsont.Object.opt_mem "arguments" Jsont.json ~enc:(fun r -> r.arguments)
416 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)
417 |> Jsont.Object.finish
418
419 type call_result = {
420 content : Content.block list;
421 is_error : bool option;
422 unknown : Jsont.json;
423 }
424
425 let make_call_result ~content ?is_error () =
426 let unknown = Jsont.Object ([], Jsont.Meta.none) in
427 { content; is_error; unknown }
428
429 let call_result_jsont : call_result Jsont.t =
430 let make content is_error unknown =
431 { content; is_error; unknown }
432 in
433 Jsont.Object.map ~kind:"ToolsCallResult" make
434 |> Jsont.Object.mem "content" (Jsont.list Content.block_jsont)
435 ~enc:(fun r -> r.content)
436 |> Jsont.Object.opt_mem "isError" Jsont.bool ~enc:(fun r -> r.is_error)
437 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)
438 |> Jsont.Object.finish
439
440 type list_changed_notification = {
441 unknown : Jsont.json;
442 }
443
444 let make_list_changed_notification () =
445 let unknown = Jsont.Object ([], Jsont.Meta.none) in
446 { unknown }
447
448 let list_changed_notification_jsont : list_changed_notification Jsont.t =
449 let make unknown = { unknown } in
450 Jsont.Object.map ~kind:"ToolsListChangedNotification" make
451 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun n -> n.unknown)
452 |> Jsont.Object.finish
453
454 let list_method = "tools/list"
455 let call_method = "tools/call"
456 let list_changed_notification_method = "notifications/tools/list_changed"
457end
458
459(* Prompts *)
460
461module Prompts = struct
462 type prompt_argument = {
463 name : string;
464 description : string option;
465 required : bool option;
466 unknown : Jsont.json;
467 }
468
469 let make_prompt_argument ~name ?description ?required () =
470 let unknown = Jsont.Object ([], Jsont.Meta.none) in
471 { name; description; required; unknown }
472
473 let prompt_argument_jsont : prompt_argument Jsont.t =
474 let make name description required unknown =
475 { name; description; required; unknown }
476 in
477 Jsont.Object.map ~kind:"PromptArgument" make
478 |> Jsont.Object.mem "name" Jsont.string ~enc:(fun a -> a.name)
479 |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun a -> a.description)
480 |> Jsont.Object.opt_mem "required" Jsont.bool ~enc:(fun a -> a.required)
481 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun a -> a.unknown)
482 |> Jsont.Object.finish
483
484 type prompt = {
485 name : string;
486 description : string option;
487 arguments : prompt_argument list option;
488 unknown : Jsont.json;
489 }
490
491 let make_prompt ~name ?description ?arguments () =
492 let unknown = Jsont.Object ([], Jsont.Meta.none) in
493 { name; description; arguments; unknown }
494
495 let prompt_jsont : prompt Jsont.t =
496 let make name description arguments unknown =
497 { name; description; arguments; unknown }
498 in
499 Jsont.Object.map ~kind:"Prompt" make
500 |> Jsont.Object.mem "name" Jsont.string ~enc:(fun p -> p.name)
501 |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun p -> p.description)
502 |> Jsont.Object.opt_mem "arguments" (Jsont.list prompt_argument_jsont)
503 ~enc:(fun p -> p.arguments)
504 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun p -> p.unknown)
505 |> Jsont.Object.finish
506
507 type role = User | Assistant
508
509 let role_jsont : role Jsont.t =
510 Jsont.enum [
511 "user", User;
512 "assistant", Assistant;
513 ]
514
515 type prompt_message = {
516 role : role;
517 content : Content.block list;
518 unknown : Jsont.json;
519 }
520
521 let make_prompt_message ~role ~content () =
522 let unknown = Jsont.Object ([], Jsont.Meta.none) in
523 { role; content; unknown }
524
525 let prompt_message_jsont : prompt_message Jsont.t =
526 let make role content unknown = { role; content; unknown } in
527 Jsont.Object.map ~kind:"PromptMessage" make
528 |> Jsont.Object.mem "role" role_jsont ~enc:(fun m -> m.role)
529 |> Jsont.Object.mem "content" (Jsont.list Content.block_jsont)
530 ~enc:(fun m -> m.content)
531 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun m -> m.unknown)
532 |> Jsont.Object.finish
533
534 type list_request = {
535 cursor : string option;
536 unknown : Jsont.json;
537 }
538
539 let make_list_request ?cursor () =
540 let unknown = Jsont.Object ([], Jsont.Meta.none) in
541 { cursor; unknown }
542
543 let list_request_jsont : list_request Jsont.t =
544 let make cursor unknown = { cursor; unknown } in
545 Jsont.Object.map ~kind:"PromptsListRequest" make
546 |> Jsont.Object.opt_mem "cursor" Jsont.string ~enc:(fun r -> r.cursor)
547 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)
548 |> Jsont.Object.finish
549
550 type list_result = {
551 prompts : prompt list;
552 next_cursor : string option;
553 unknown : Jsont.json;
554 }
555
556 let make_list_result ~prompts ?next_cursor () =
557 let unknown = Jsont.Object ([], Jsont.Meta.none) in
558 { prompts; next_cursor; unknown }
559
560 let list_result_jsont : list_result Jsont.t =
561 let make prompts next_cursor unknown =
562 { prompts; next_cursor; unknown }
563 in
564 Jsont.Object.map ~kind:"PromptsListResult" make
565 |> Jsont.Object.mem "prompts" (Jsont.list prompt_jsont)
566 ~enc:(fun r -> r.prompts)
567 |> Jsont.Object.opt_mem "nextCursor" Jsont.string
568 ~enc:(fun r -> r.next_cursor)
569 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)
570 |> Jsont.Object.finish
571
572 (* Arguments as object with string keys *)
573 let arguments_jsont : (string * string) list Jsont.t =
574 let enc_obj args =
575 let pairs = List.map (fun (k, v) ->
576 ((k, Jsont.Meta.none), Jsont.String (v, Jsont.Meta.none))
577 ) args in
578 Jsont.Object (pairs, Jsont.Meta.none)
579 in
580 let dec_obj = function
581 | Jsont.Object (members, _) ->
582 List.map (fun ((k, _), v) ->
583 match v with
584 | Jsont.String (s, _) -> (k, s)
585 | _ -> Jsont.Error.msgf Jsont.Meta.none
586 "Argument values must be strings"
587 ) members
588 | _ ->
589 Jsont.Error.msgf Jsont.Meta.none "Arguments must be an object"
590 in
591 Jsont.map ~kind:"PromptArguments" ~dec:dec_obj ~enc:enc_obj Jsont.json
592
593 type get_request = {
594 name : string;
595 arguments : (string * string) list option;
596 unknown : Jsont.json;
597 }
598
599 let make_get_request ~name ?arguments () =
600 let unknown = Jsont.Object ([], Jsont.Meta.none) in
601 { name; arguments; unknown }
602
603 let get_request_jsont : get_request Jsont.t =
604 let make name arguments unknown = { name; arguments; unknown } in
605 Jsont.Object.map ~kind:"PromptsGetRequest" make
606 |> Jsont.Object.mem "name" Jsont.string ~enc:(fun r -> r.name)
607 |> Jsont.Object.opt_mem "arguments" arguments_jsont ~enc:(fun r -> r.arguments)
608 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)
609 |> Jsont.Object.finish
610
611 type get_result = {
612 description : string option;
613 messages : prompt_message list;
614 unknown : Jsont.json;
615 }
616
617 let make_get_result ?description ~messages () =
618 let unknown = Jsont.Object ([], Jsont.Meta.none) in
619 { description; messages; unknown }
620
621 let get_result_jsont : get_result Jsont.t =
622 let make description messages unknown =
623 { description; messages; unknown }
624 in
625 Jsont.Object.map ~kind:"PromptsGetResult" make
626 |> Jsont.Object.opt_mem "description" Jsont.string ~enc:(fun r -> r.description)
627 |> Jsont.Object.mem "messages" (Jsont.list prompt_message_jsont)
628 ~enc:(fun r -> r.messages)
629 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)
630 |> Jsont.Object.finish
631
632 type list_changed_notification = {
633 unknown : Jsont.json;
634 }
635
636 let make_list_changed_notification () =
637 let unknown = Jsont.Object ([], Jsont.Meta.none) in
638 { unknown }
639
640 let list_changed_notification_jsont : list_changed_notification Jsont.t =
641 let make unknown = { unknown } in
642 Jsont.Object.map ~kind:"PromptsListChangedNotification" make
643 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun n -> n.unknown)
644 |> Jsont.Object.finish
645
646 let list_method = "prompts/list"
647 let get_method = "prompts/get"
648 let list_changed_notification_method = "notifications/prompts/list_changed"
649end
650
651(* Logging *)
652
653module Logging = struct
654 type level =
655 | Debug
656 | Info
657 | Notice
658 | Warning
659 | Error
660 | Critical
661 | Alert
662 | Emergency
663
664 let level_jsont : level Jsont.t =
665 Jsont.enum [
666 "debug", Debug;
667 "info", Info;
668 "notice", Notice;
669 "warning", Warning;
670 "error", Error;
671 "critical", Critical;
672 "alert", Alert;
673 "emergency", Emergency;
674 ]
675
676 let level_to_string = function
677 | Debug -> "debug"
678 | Info -> "info"
679 | Notice -> "notice"
680 | Warning -> "warning"
681 | Error -> "error"
682 | Critical -> "critical"
683 | Alert -> "alert"
684 | Emergency -> "emergency"
685
686 type notification = {
687 level : level;
688 logger : string option;
689 data : Jsont.json option;
690 unknown : Jsont.json;
691 }
692
693 let make_notification ~level ?logger ?data () =
694 let unknown = Jsont.Object ([], Jsont.Meta.none) in
695 { level; logger; data; unknown }
696
697 let notification_jsont : notification Jsont.t =
698 let make level logger data unknown =
699 { level; logger; data; unknown }
700 in
701 Jsont.Object.map ~kind:"LoggingNotification" make
702 |> Jsont.Object.mem "level" level_jsont ~enc:(fun n -> n.level)
703 |> Jsont.Object.opt_mem "logger" Jsont.string ~enc:(fun n -> n.logger)
704 |> Jsont.Object.opt_mem "data" Jsont.json ~enc:(fun n -> n.data)
705 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun n -> n.unknown)
706 |> Jsont.Object.finish
707
708 let method_ = "notifications/message"
709end
710
711(* Completions *)
712
713module Completions = struct
714 type completion_ref = {
715 ref_type : string;
716 uri : string;
717 unknown : Jsont.json;
718 }
719
720 let make_completion_ref ~ref_type ~uri () =
721 let unknown = Jsont.Object ([], Jsont.Meta.none) in
722 { ref_type; uri; unknown }
723
724 let completion_ref_jsont : completion_ref Jsont.t =
725 let make ref_type uri unknown = { ref_type; uri; unknown } in
726 Jsont.Object.map ~kind:"CompletionRef" make
727 |> Jsont.Object.mem "type" Jsont.string ~enc:(fun r -> r.ref_type)
728 |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
729 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)
730 |> Jsont.Object.finish
731
732 type request = {
733 ref_ : completion_ref;
734 argument : string option;
735 unknown : Jsont.json;
736 }
737
738 let make_request ~ref_ ?argument () =
739 let unknown = Jsont.Object ([], Jsont.Meta.none) in
740 { ref_; argument; unknown }
741
742 let request_jsont : request Jsont.t =
743 let make ref_ argument unknown = { ref_; argument; unknown } in
744 Jsont.Object.map ~kind:"CompletionRequest" make
745 |> Jsont.Object.mem "ref" completion_ref_jsont ~enc:(fun r -> r.ref_)
746 |> Jsont.Object.opt_mem "argument" Jsont.string ~enc:(fun r -> r.argument)
747 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)
748 |> Jsont.Object.finish
749
750 type result = {
751 completion : string list;
752 total : int option;
753 has_more : bool option;
754 unknown : Jsont.json;
755 }
756
757 let make_result ~completion ?total ?has_more () =
758 let unknown = Jsont.Object ([], Jsont.Meta.none) in
759 { completion; total; has_more; unknown }
760
761 let result_jsont : result Jsont.t =
762 let make completion total has_more unknown =
763 { completion; total; has_more; unknown }
764 in
765 Jsont.Object.map ~kind:"CompletionResult" make
766 |> Jsont.Object.mem "completion" (Jsont.list Jsont.string)
767 ~enc:(fun r -> r.completion)
768 |> Jsont.Object.opt_mem "total" Jsont.int ~enc:(fun r -> r.total)
769 |> Jsont.Object.opt_mem "hasMore" Jsont.bool ~enc:(fun r -> r.has_more)
770 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)
771 |> Jsont.Object.finish
772
773 let method_ = "completion/complete"
774end
775
776(* Roots *)
777
778module Roots = struct
779 type root = {
780 uri : string;
781 name : string option;
782 unknown : Jsont.json;
783 }
784
785 let make_root ~uri ?name () =
786 let unknown = Jsont.Object ([], Jsont.Meta.none) in
787 { uri; name; unknown }
788
789 let root_jsont : root Jsont.t =
790 let make uri name unknown = { uri; name; unknown } in
791 Jsont.Object.map ~kind:"Root" make
792 |> Jsont.Object.mem "uri" Jsont.string ~enc:(fun r -> r.uri)
793 |> Jsont.Object.opt_mem "name" Jsont.string ~enc:(fun r -> r.name)
794 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)
795 |> Jsont.Object.finish
796
797 type list_request = {
798 unknown : Jsont.json;
799 }
800
801 let make_list_request () =
802 let unknown = Jsont.Object ([], Jsont.Meta.none) in
803 { unknown }
804
805 let list_request_jsont : list_request Jsont.t =
806 let make unknown = { unknown } in
807 Jsont.Object.map ~kind:"RootsListRequest" make
808 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)
809 |> Jsont.Object.finish
810
811 type list_result = {
812 roots : root list;
813 unknown : Jsont.json;
814 }
815
816 let make_list_result ~roots =
817 let unknown = Jsont.Object ([], Jsont.Meta.none) in
818 { roots; unknown }
819
820 let list_result_jsont : list_result Jsont.t =
821 let make roots unknown = { roots; unknown } in
822 Jsont.Object.map ~kind:"RootsListResult" make
823 |> Jsont.Object.mem "roots" (Jsont.list root_jsont)
824 ~enc:(fun r -> r.roots)
825 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)
826 |> Jsont.Object.finish
827
828 type list_changed_notification = {
829 unknown : Jsont.json;
830 }
831
832 let make_list_changed_notification () =
833 let unknown = Jsont.Object ([], Jsont.Meta.none) in
834 { unknown }
835
836 let list_changed_notification_jsont : list_changed_notification Jsont.t =
837 let make unknown = { unknown } in
838 Jsont.Object.map ~kind:"RootsListChangedNotification" make
839 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun n -> n.unknown)
840 |> Jsont.Object.finish
841
842 let list_method = "roots/list"
843 let list_changed_notification_method = "notifications/roots/list_changed"
844end
845
846(* Progress *)
847
848module Progress = struct
849 type notification = {
850 progress_token : string;
851 progress : float;
852 total : float option;
853 unknown : Jsont.json;
854 }
855
856 let make_notification ~progress_token ~progress ?total () =
857 let unknown = Jsont.Object ([], Jsont.Meta.none) in
858 { progress_token; progress; total; unknown }
859
860 let notification_jsont : notification Jsont.t =
861 let make progress_token progress total unknown =
862 { progress_token; progress; total; unknown }
863 in
864 Jsont.Object.map ~kind:"ProgressNotification" make
865 |> Jsont.Object.mem "progressToken" Jsont.string
866 ~enc:(fun n -> n.progress_token)
867 |> Jsont.Object.mem "progress" Jsont.number ~enc:(fun n -> n.progress)
868 |> Jsont.Object.opt_mem "total" Jsont.number ~enc:(fun n -> n.total)
869 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun n -> n.unknown)
870 |> Jsont.Object.finish
871
872 let method_ = "notifications/progress"
873end
874
875(* Cancellation *)
876
877module Cancellation = struct
878 type notification = {
879 request_id : Jsonrpc.Id.t;
880 reason : string option;
881 unknown : Jsont.json;
882 }
883
884 let make_notification ~request_id ?reason () =
885 let unknown = Jsont.Object ([], Jsont.Meta.none) in
886 { request_id; reason; unknown }
887
888 let notification_jsont : notification Jsont.t =
889 let make request_id reason unknown =
890 { request_id; reason; unknown }
891 in
892 Jsont.Object.map ~kind:"CancellationNotification" make
893 |> Jsont.Object.mem "requestId" Jsonrpc.Id.jsont
894 ~enc:(fun n -> n.request_id)
895 |> Jsont.Object.opt_mem "reason" Jsont.string ~enc:(fun n -> n.reason)
896 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun n -> n.unknown)
897 |> Jsont.Object.finish
898
899 let method_ = "notifications/cancelled"
900end