My agentic slop goes here. Not intended for anyone else!
anil.recoil.org
1(** MCP Capability negotiation types *)
2
3(* Implementation Info *)
4
5module Implementation = struct
6 type t = {
7 name : string;
8 version : string;
9 unknown : Jsont.json;
10 }
11
12 let make ~name ~version =
13 let unknown = Jsont.Object ([], Jsont.Meta.none) in
14 { name; version; unknown }
15
16 let jsont : t Jsont.t =
17 let make name version unknown = { name; version; unknown } in
18 Jsont.Object.map ~kind:"Implementation" make
19 |> Jsont.Object.mem "name" Jsont.string ~enc:(fun i -> i.name)
20 |> Jsont.Object.mem "version" Jsont.string ~enc:(fun i -> i.version)
21 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun i -> i.unknown)
22 |> Jsont.Object.finish
23
24 let pp fmt i =
25 Format.fprintf fmt "%s/%s" i.name i.version
26end
27
28(* Client Capabilities *)
29
30module Sampling = struct
31 type t = {
32 context : bool option;
33 tools : bool option;
34 unknown : Jsont.json;
35 }
36
37 let empty =
38 let unknown = Jsont.Object ([], Jsont.Meta.none) in
39 { context = None; tools = None; unknown }
40
41 let make ?context ?tools () =
42 let unknown = Jsont.Object ([], Jsont.Meta.none) in
43 { context; tools; unknown }
44
45 let jsont : t Jsont.t =
46 let make context tools unknown = { context; tools; unknown } in
47 Jsont.Object.map ~kind:"Sampling" make
48 |> Jsont.Object.opt_mem "context" Jsont.bool ~enc:(fun s -> s.context)
49 |> Jsont.Object.opt_mem "tools" Jsont.bool ~enc:(fun s -> s.tools)
50 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun s -> s.unknown)
51 |> Jsont.Object.finish
52end
53
54module Elicitation = struct
55 type t = {
56 unknown : Jsont.json;
57 }
58
59 let empty =
60 let unknown = Jsont.Object ([], Jsont.Meta.none) in
61 { unknown }
62
63 let jsont : t Jsont.t =
64 let make unknown = { unknown } in
65 Jsont.Object.map ~kind:"Elicitation" make
66 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun e -> e.unknown)
67 |> Jsont.Object.finish
68end
69
70module Roots = struct
71 type t = {
72 list_changed : bool option;
73 unknown : Jsont.json;
74 }
75
76 let empty =
77 let unknown = Jsont.Object ([], Jsont.Meta.none) in
78 { list_changed = None; unknown }
79
80 let make ?list_changed () =
81 let unknown = Jsont.Object ([], Jsont.Meta.none) in
82 { list_changed; unknown }
83
84 let jsont : t Jsont.t =
85 let make list_changed unknown = { list_changed; unknown } in
86 Jsont.Object.map ~kind:"Roots" make
87 |> Jsont.Object.opt_mem "listChanged" Jsont.bool ~enc:(fun r -> r.list_changed)
88 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)
89 |> Jsont.Object.finish
90end
91
92module Client = struct
93 type t = {
94 sampling : Sampling.t option;
95 elicitation : Elicitation.t option;
96 roots : Roots.t option;
97 experimental : Jsont.json option;
98 unknown : Jsont.json;
99 }
100
101 let empty =
102 let unknown = Jsont.Object ([], Jsont.Meta.none) in
103 { sampling = None; elicitation = None; roots = None; experimental = None; unknown }
104
105 let make ?sampling ?elicitation ?roots ?experimental () =
106 let unknown = Jsont.Object ([], Jsont.Meta.none) in
107 { sampling; elicitation; roots; experimental; unknown }
108
109 let jsont : t Jsont.t =
110 let make sampling elicitation roots experimental unknown =
111 { sampling; elicitation; roots; experimental; unknown }
112 in
113 Jsont.Object.map ~kind:"ClientCapabilities" make
114 |> Jsont.Object.opt_mem "sampling" Sampling.jsont ~enc:(fun c -> c.sampling)
115 |> Jsont.Object.opt_mem "elicitation" Elicitation.jsont ~enc:(fun c -> c.elicitation)
116 |> Jsont.Object.opt_mem "roots" Roots.jsont ~enc:(fun c -> c.roots)
117 |> Jsont.Object.opt_mem "experimental" Jsont.json ~enc:(fun c -> c.experimental)
118 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun c -> c.unknown)
119 |> Jsont.Object.finish
120
121 let pp fmt c =
122 let caps = [
123 (match c.sampling with Some _ -> Some "sampling" | None -> None);
124 (match c.elicitation with Some _ -> Some "elicitation" | None -> None);
125 (match c.roots with Some _ -> Some "roots" | None -> None);
126 ] |> List.filter_map Fun.id in
127 Format.fprintf fmt "[%s]" (String.concat ", " caps)
128end
129
130(* Server Capabilities *)
131
132module Logging = struct
133 type t = {
134 unknown : Jsont.json;
135 }
136
137 let empty =
138 let unknown = Jsont.Object ([], Jsont.Meta.none) in
139 { unknown }
140
141 let jsont : t Jsont.t =
142 let make unknown = { unknown } in
143 Jsont.Object.map ~kind:"Logging" make
144 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun l -> l.unknown)
145 |> Jsont.Object.finish
146end
147
148module Prompts = struct
149 type t = {
150 list_changed : bool option;
151 unknown : Jsont.json;
152 }
153
154 let empty =
155 let unknown = Jsont.Object ([], Jsont.Meta.none) in
156 { list_changed = None; unknown }
157
158 let make ?list_changed () =
159 let unknown = Jsont.Object ([], Jsont.Meta.none) in
160 { list_changed; unknown }
161
162 let jsont : t Jsont.t =
163 let make list_changed unknown = { list_changed; unknown } in
164 Jsont.Object.map ~kind:"Prompts" make
165 |> Jsont.Object.opt_mem "listChanged" Jsont.bool ~enc:(fun p -> p.list_changed)
166 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun p -> p.unknown)
167 |> Jsont.Object.finish
168end
169
170module Resources = struct
171 type t = {
172 subscribe : bool option;
173 list_changed : bool option;
174 unknown : Jsont.json;
175 }
176
177 let empty =
178 let unknown = Jsont.Object ([], Jsont.Meta.none) in
179 { subscribe = None; list_changed = None; unknown }
180
181 let make ?subscribe ?list_changed () =
182 let unknown = Jsont.Object ([], Jsont.Meta.none) in
183 { subscribe; list_changed; unknown }
184
185 let jsont : t Jsont.t =
186 let make subscribe list_changed unknown =
187 { subscribe; list_changed; unknown }
188 in
189 Jsont.Object.map ~kind:"Resources" make
190 |> Jsont.Object.opt_mem "subscribe" Jsont.bool ~enc:(fun r -> r.subscribe)
191 |> Jsont.Object.opt_mem "listChanged" Jsont.bool ~enc:(fun r -> r.list_changed)
192 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun r -> r.unknown)
193 |> Jsont.Object.finish
194end
195
196module Tools = struct
197 type t = {
198 list_changed : bool option;
199 unknown : Jsont.json;
200 }
201
202 let empty =
203 let unknown = Jsont.Object ([], Jsont.Meta.none) in
204 { list_changed = None; unknown }
205
206 let make ?list_changed () =
207 let unknown = Jsont.Object ([], Jsont.Meta.none) in
208 { list_changed; unknown }
209
210 let jsont : t Jsont.t =
211 let make list_changed unknown = { list_changed; unknown } in
212 Jsont.Object.map ~kind:"Tools" make
213 |> Jsont.Object.opt_mem "listChanged" Jsont.bool ~enc:(fun t -> t.list_changed)
214 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun t -> t.unknown)
215 |> Jsont.Object.finish
216end
217
218module Completions = struct
219 type t = {
220 unknown : Jsont.json;
221 }
222
223 let empty =
224 let unknown = Jsont.Object ([], Jsont.Meta.none) in
225 { unknown }
226
227 let jsont : t Jsont.t =
228 let make unknown = { unknown } in
229 Jsont.Object.map ~kind:"Completions" make
230 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun c -> c.unknown)
231 |> Jsont.Object.finish
232end
233
234module Server = struct
235 type t = {
236 logging : Logging.t option;
237 prompts : Prompts.t option;
238 resources : Resources.t option;
239 tools : Tools.t option;
240 completions : Completions.t option;
241 experimental : Jsont.json option;
242 unknown : Jsont.json;
243 }
244
245 let empty =
246 let unknown = Jsont.Object ([], Jsont.Meta.none) in
247 {
248 logging = None;
249 prompts = None;
250 resources = None;
251 tools = None;
252 completions = None;
253 experimental = None;
254 unknown;
255 }
256
257 let make ?logging ?prompts ?resources ?tools ?completions ?experimental () =
258 let unknown = Jsont.Object ([], Jsont.Meta.none) in
259 { logging; prompts; resources; tools; completions; experimental; unknown }
260
261 let jsont : t Jsont.t =
262 let make logging prompts resources tools completions experimental unknown =
263 { logging; prompts; resources; tools; completions; experimental; unknown }
264 in
265 Jsont.Object.map ~kind:"ServerCapabilities" make
266 |> Jsont.Object.opt_mem "logging" Logging.jsont ~enc:(fun s -> s.logging)
267 |> Jsont.Object.opt_mem "prompts" Prompts.jsont ~enc:(fun s -> s.prompts)
268 |> Jsont.Object.opt_mem "resources" Resources.jsont ~enc:(fun s -> s.resources)
269 |> Jsont.Object.opt_mem "tools" Tools.jsont ~enc:(fun s -> s.tools)
270 |> Jsont.Object.opt_mem "completions" Completions.jsont ~enc:(fun s -> s.completions)
271 |> Jsont.Object.opt_mem "experimental" Jsont.json ~enc:(fun s -> s.experimental)
272 |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun s -> s.unknown)
273 |> Jsont.Object.finish
274
275 let pp fmt s =
276 let caps = [
277 (match s.logging with Some _ -> Some "logging" | None -> None);
278 (match s.prompts with Some _ -> Some "prompts" | None -> None);
279 (match s.resources with Some _ -> Some "resources" | None -> None);
280 (match s.tools with Some _ -> Some "tools" | None -> None);
281 (match s.completions with Some _ -> Some "completions" | None -> None);
282 ] |> List.filter_map Fun.id in
283 Format.fprintf fmt "[%s]" (String.concat ", " caps)
284end