commit e4ed4f1f1d7d1b3e6269d2d29b2a3cabad28cd41 · anil.recoil.org/slop

+1 -1

claudeio/lib/client.ml

···

       159
       159
        
                   (* Extract session ID from system messages *)

     

       160
       160
        
                   (match msg with

     

       161
       161
        
                   | Message.System sys ->

     

       162
       162
       -
                       (match Message.System.Data.session_id (Message.System.data sys) with

     

       162
       162
       +
                       (match Message.System.session_id sys with

     

       163
       163
        
                       | Some session_id ->

     

       164
       164
        
                         t.session_id <- Some session_id;

     

       165
       165
        
                         Log.debug (fun m -> m "Stored session ID: %s" session_id)

+1 -29

claudeio/lib/content_block.ml

···

       3
       3
        
       

     

       4
       4
        
       

     

       5
       5
        
       module Text = struct

     

       6
       6
       -
         module Unknown = struct

     

       7
       7
       -
           type t = Jsont.json

     

       8
       8
       -
           let empty = Jsont.Object ([], Jsont.Meta.none)

     

       9
       9
       -
           let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       10
       10
       -
           let jsont = Jsont.json

     

       11
       11
       -
         end

     

       12
       12
       -
       

     

       13
       6
        
         type t = {

     

       14
       7
        
           text : string;

     

       15
       8
        
           unknown : Unknown.t;

     
···

       85
       78
        
           let of_json json = json

     

       86
       79
        
         end

     

       87
       80
        
       

     

       88
       88
       -
         module Unknown = struct

     

       89
       89
       -
           type t = Jsont.json

     

       90
       90
       -
           let empty = Jsont.Object ([], Jsont.Meta.none)

     

       91
       91
       -
           let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       92
       92
       -
           let jsont = Jsont.json

     

       93
       93
       -
         end

     

       94
       94
       -
       

     

       95
       81
        
         type t = {

     

       96
       82
        
           id : string;

     

       97
       83
        
           name : string;

     
···

       136
       122
        
       end

     

       137
       123
        
       

     

       138
       124
        
       module Tool_result = struct

     

       139
       139
       -
         module Unknown = struct

     

       140
       140
       -
           type t = Jsont.json

     

       141
       141
       -
           let empty = Jsont.Object ([], Jsont.Meta.none)

     

       142
       142
       -
           let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       143
       143
       -
           let jsont = Jsont.json

     

       144
       144
       -
         end

     

       145
       145
       -
       

     

       146
       125
        
         type t = {

     

       147
       126
        
           tool_use_id : string;

     

       148
       127
        
           content : string option;

     
···

       196
       175
        
       end

     

       197
       176
        
       

     

       198
       177
        
       module Thinking = struct

     

       199
       199
       -
         module Unknown = struct

     

       200
       200
       -
           type t = Jsont.json

     

       201
       201
       -
           let empty = Jsont.Object ([], Jsont.Meta.none)

     

       202
       202
       -
           let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       203
       203
       -
           let jsont = Jsont.json

     

       204
       204
       -
         end

     

       205
       205
       -
       

     

       206
       178
        
         type t = {

     

       207
       179
        
           thinking : string;

     

       208
       180
        
           signature : string;

     
···

       301
       273
        
         Log.debug (fun m -> m "Received content block: %a" pp t)

     

       302
       274
        
       

     

       303
       275
        
       let log_sending t =

     

       304
       304
       -
         Log.debug (fun m -> m "Sending content block: %a" pp t)
     

       276
       276
       +
         Log.debug (fun m -> m "Sending content block: %a" pp t)

+13 -29

claudeio/lib/content_block.mli

···

       11
       11
        
       module Text : sig

     

       12
       12
        
         (** Plain text content blocks. *)

     

       13
       13
        
       

     

       14
       14
       -
         module Unknown : sig

     

       15
       15
       -
           type t = Jsont.json

     

       16
       16
       -
           val empty : t

     

       17
       17
       -
           val is_empty : t -> bool

     

       18
       18
       -
           val jsont : t Jsont.t

     

       19
       19
       -
         end

     

       20
       20
       -
       

     

       21
       14
        
         type t

     

       22
       15
        
         (** The type of text blocks. *)

     

       23
       16
        
       

     
···

       26
       19
        
       

     

       27
       20
        
         val text : t -> string

     

       28
       21
        
         (** [text t] returns the text content of the block. *)

     

       22
       22
       +
       

     

       23
       23
       +
         val unknown : t -> Unknown.t

     

       24
       24
       +
         (** [unknown t] returns any unknown fields from JSON parsing. *)

     

       29
       25
        
       

     

       30
       26
        
         val jsont : t Jsont.t

     

       31
       27
        
         (** [jsont] is the Jsont codec for text blocks. *)

     
···

       83
       79
        
           (** [of_json json] parses from JSON. Internal use only. *)

     

       84
       80
        
         end

     

       85
       81
        
       

     

       86
       86
       -
         module Unknown : sig

     

       87
       87
       -
           type t = Jsont.json

     

       88
       88
       -
           val empty : t

     

       89
       89
       -
           val is_empty : t -> bool

     

       90
       90
       -
           val jsont : t Jsont.t

     

       91
       91
       -
         end

     

       92
       92
       -
       

     

       93
       82
        
         type t

     

       94
       83
        
         (** The type of tool use blocks. *)

     

       95
       84
        
       

     
···

       107
       96
        
       

     

       108
       97
        
         val input : t -> Input.t

     

       109
       98
        
         (** [input t] returns the input parameters for the tool. *)

     

       99
       99
       +
       

     

       100
       100
       +
         val unknown : t -> Unknown.t

     

       101
       101
       +
         (** [unknown t] returns any unknown fields from JSON parsing. *)

     

       110
       102
        
       

     

       111
       103
        
         val jsont : t Jsont.t

     

       112
       104
        
         (** [jsont] is the Jsont codec for tool use blocks. *)

     
···

       127
       119
        
       module Tool_result : sig

     

       128
       120
        
         (** Results from tool invocations. *)

     

       129
       121
        
       

     

       130
       130
       -
         module Unknown : sig

     

       131
       131
       -
           type t = Jsont.json

     

       132
       132
       -
           val empty : t

     

       133
       133
       -
           val is_empty : t -> bool

     

       134
       134
       -
           val jsont : t Jsont.t

     

       135
       135
       -
         end

     

       136
       136
       -
       

     

       137
       122
        
         type t

     

       138
       123
        
         (** The type of tool result blocks. *)

     

       139
       124
        
       

     
···

       152
       137
        
         val is_error : t -> bool option

     

       153
       138
        
         (** [is_error t] returns whether this result represents an error. *)

     

       154
       139
        
       

     

       140
       140
       +
         val unknown : t -> Unknown.t

     

       141
       141
       +
         (** [unknown t] returns any unknown fields from JSON parsing. *)

     

       142
       142
       +
       

     

       155
       143
        
         val jsont : t Jsont.t

     

       156
       144
        
         (** [jsont] is the Jsont codec for tool result blocks. *)

     

       157
       145
        
       

     
···

       171
       159
        
       module Thinking : sig

     

       172
       160
        
         (** Assistant's internal reasoning blocks. *)

     

       173
       161
        
       

     

       174
       174
       -
         module Unknown : sig

     

       175
       175
       -
           type t = Jsont.json

     

       176
       176
       -
           val empty : t

     

       177
       177
       -
           val is_empty : t -> bool

     

       178
       178
       -
           val jsont : t Jsont.t

     

       179
       179
       -
         end

     

       180
       180
       -
       

     

       181
       162
        
         type t

     

       182
       163
        
         (** The type of thinking blocks. *)

     

       183
       164
        
       

     
···

       191
       172
        
       

     

       192
       173
        
         val signature : t -> string

     

       193
       174
        
         (** [signature t] returns the cryptographic signature. *)

     

       175
       175
       +
       

     

       176
       176
       +
         val unknown : t -> Unknown.t

     

       177
       177
       +
         (** [unknown t] returns any unknown fields from JSON parsing. *)

     

       194
       178
        
       

     

       195
       179
        
         val jsont : t Jsont.t

     

       196
       180
        
         (** [jsont] is the Jsont codec for thinking blocks. *)

     
···

       246
       230
        
       (** [log_received t] logs that a content block was received. *)

     

       247
       231
        
       

     

       248
       232
        
       val log_sending : t -> unit

     

       249
       249
       -
       (** [log_sending t] logs that a content block is being sent. *)
     

       233
       233
       +
       (** [log_sending t] logs that a content block is being sent. *)

-7

claudeio/lib/control.ml

···

       9
       9
        
         in

     

       10
       10
        
         Fmt.string fmt s

     

       11
       11
        
       

     

       12
       12
       -
       module Unknown = struct

     

       13
       13
       -
         type t = Jsont.json

     

       14
       14
       -
         let empty = Jsont.Object ([], Jsont.Meta.none)

     

       15
       15
       -
         let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       16
       16
       -
         let jsont = Jsont.json

     

       17
       17
       -
       end

     

       18
       18
       -
       

     

       19
       12
        
       type t = {

     

       20
       13
        
         request_id : string;

     

       21
       14
        
         subtype : string;

-8

claudeio/lib/control.mli

···

       7
       7
        
       (** The log source for control message operations *)

     

       8
       8
        
       val src : Logs.Src.t

     

       9
       9
        
       

     

       10
       10
       -
       (** Unknown field preservation *)

     

       11
       11
       -
       module Unknown : sig

     

       12
       12
       -
         type t = Jsont.json

     

       13
       13
       -
         val empty : t

     

       14
       14
       -
         val is_empty : t -> bool

     

       15
       15
       -
         val jsont : t Jsont.t

     

       16
       16
       -
       end

     

       17
       17
       -
       

     

       18
       10
        
       type t

     

       19
       11
        
       (** The type of control messages. *)

     

       20
       12

+22 -99

claudeio/lib/hooks.ml

···

       39
       39
        
       

     

       40
       40
        
       (** Context provided to hook callbacks *)

     

       41
       41
        
       module Context = struct

     

       42
       42
       -
         module Unknown = struct

     

       43
       43
       -
           type t = Jsont.json

     

       44
       44
       -
           let empty = Jsont.Object ([], Jsont.Meta.none)

     

       45
       45
       -
           let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       46
       46
       -
           let jsont = Jsont.json

     

       47
       47
       -
         end

     

       48
       48
       -
       

     

       49
       42
        
         type t = {

     

       50
       43
        
           signal: unit option;  (* Future: abort signal support *)

     

       51
       44
        
           unknown : Unknown.t;

     
···

       75
       68
        
         ]

     

       76
       69
        
       

     

       77
       70
        
       (** Generic hook result *)

     

       78
       78
       -
       module Result_unknown = struct

     

       79
       79
       -
         type t = Jsont.json

     

       80
       80
       -
         let empty = Jsont.Object ([], Jsont.Meta.none)

     

       81
       81
       -
         let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       82
       82
       -
         let jsont = Jsont.json

     

       83
       83
       -
       end

     

       84
       84
       -
       

     

       85
       71
        
       type result = {

     

       86
       72
        
         decision: decision option;

     

       87
       73
        
         system_message: string option;

     

       88
       74
        
         hook_specific_output: Jsont.json option;

     

       89
       89
       -
         unknown : Result_unknown.t;

     

       75
       75
       +
         unknown : Unknown.t;

     

       90
       76
        
       }

     

       91
       77
        
       

     

       92
       78
        
       let result_jsont : result Jsont.t =

     
···

       102
       88
        
       

     

       103
       89
        
       (** {1 PreToolUse Hook} *)

     

       104
       90
        
       module PreToolUse = struct

     

       105
       105
       -
         module Input_unknown = struct

     

       106
       106
       -
           type t = Jsont.json

     

       107
       107
       -
           let empty = Jsont.Object ([], Jsont.Meta.none)

     

       108
       108
       -
           let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       109
       109
       -
           let jsont = Jsont.json

     

       110
       110
       -
         end

     

       111
       111
       -
       

     

       112
       91
        
         type input = {

     

       113
       92
        
           session_id: string;

     

       114
       93
        
           transcript_path: string;

     

       115
       94
        
           tool_name: string;

     

       116
       95
        
           tool_input: Jsont.json;

     

       117
       117
       -
           unknown : Input_unknown.t;

     

       96
       96
       +
           unknown : Unknown.t;

     

       118
       97
        
         }

     

       119
       98
        
       

     

       120
       99
        
         type t = input

     
···

       151
       130
        
             "ask", `Ask;

     

       152
       131
        
           ]

     

       153
       132
        
       

     

       154
       154
       -
         module Output_unknown = struct

     

       155
       155
       -
           type t = Jsont.json

     

       156
       156
       -
           let empty = Jsont.Object ([], Jsont.Meta.none)

     

       157
       157
       -
           let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       158
       158
       -
           let jsont = Jsont.json

     

       159
       159
       -
         end

     

       160
       160
       -
       

     

       161
       133
        
         type output = {

     

       162
       134
        
           permission_decision: permission_decision option;

     

       163
       135
        
           permission_decision_reason: string option;

     

       164
       136
        
           updated_input: Jsont.json option;

     

       165
       165
       -
           unknown : Output_unknown.t;

     

       137
       137
       +
           unknown : Unknown.t;

     

       166
       138
        
         }

     

       167
       139
        
       

     

       168
       140
        
         let output_jsont : output Jsont.t =

     
···

       181
       153
        
           | Ok json -> json

     

       182
       154
        
           | Error msg -> failwith ("PreToolUse.output_to_json: " ^ msg)

     

       183
       155
        
       

     

       184
       184
       -
         let allow ?reason ?updated_input ?(unknown = Output_unknown.empty) () =

     

       156
       156
       +
         let allow ?reason ?updated_input ?(unknown = Unknown.empty) () =

     

       185
       157
        
           { permission_decision = Some `Allow; permission_decision_reason = reason;

     

       186
       158
        
             updated_input; unknown }

     

       187
       159
        
       

     

       188
       188
       -
         let deny ?reason ?(unknown = Output_unknown.empty) () =

     

       160
       160
       +
         let deny ?reason ?(unknown = Unknown.empty) () =

     

       189
       161
        
           { permission_decision = Some `Deny; permission_decision_reason = reason;

     

       190
       162
        
             updated_input = None; unknown }

     

       191
       163
        
       

     

       192
       192
       -
         let ask ?reason ?(unknown = Output_unknown.empty) () =

     

       164
       164
       +
         let ask ?reason ?(unknown = Unknown.empty) () =

     

       193
       165
        
           { permission_decision = Some `Ask; permission_decision_reason = reason;

     

       194
       166
        
             updated_input = None; unknown }

     

       195
       167
        
       

     

       196
       196
       -
         let continue ?(unknown = Output_unknown.empty) () =

     

       168
       168
       +
         let continue ?(unknown = Unknown.empty) () =

     

       197
       169
        
           { permission_decision = None; permission_decision_reason = None;

     

       198
       170
        
             updated_input = None; unknown }

     

       199
       171
        
       end

     

       200
       172
        
       

     

       201
       173
        
       (** {1 PostToolUse Hook} *)

     

       202
       174
        
       module PostToolUse = struct

     

       203
       203
       -
         module Input_unknown = struct

     

       204
       204
       -
           type t = Jsont.json

     

       205
       205
       -
           let empty = Jsont.Object ([], Jsont.Meta.none)

     

       206
       206
       -
           let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       207
       207
       -
           let jsont = Jsont.json

     

       208
       208
       -
         end

     

       209
       209
       -
       

     

       210
       175
        
         type input = {

     

       211
       176
        
           session_id: string;

     

       212
       177
        
           transcript_path: string;

     

       213
       178
        
           tool_name: string;

     

       214
       179
        
           tool_input: Jsont.json;

     

       215
       180
        
           tool_response: Jsont.json;

     

       216
       216
       -
           unknown : Input_unknown.t;

     

       181
       181
       +
           unknown : Unknown.t;

     

       217
       182
        
         }

     

       218
       183
        
       

     

       219
       184
        
         type t = input

     
···

       243
       208
        
           | Ok v -> v

     

       244
       209
        
           | Error msg -> raise (Invalid_argument ("PostToolUse: " ^ msg))

     

       245
       210
        
       

     

       246
       246
       -
         module Output_unknown = struct

     

       247
       247
       -
           type t = Jsont.json

     

       248
       248
       -
           let empty = Jsont.Object ([], Jsont.Meta.none)

     

       249
       249
       -
           let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       250
       250
       -
           let jsont = Jsont.json

     

       251
       251
       -
         end

     

       252
       252
       -
       

     

       253
       211
        
         type output = {

     

       254
       212
        
           decision: decision option;

     

       255
       213
        
           reason: string option;

     

       256
       214
        
           additional_context: string option;

     

       257
       257
       -
           unknown : Output_unknown.t;

     

       215
       215
       +
           unknown : Unknown.t;

     

       258
       216
        
         }

     

       259
       217
        
       

     

       260
       218
        
         let output_jsont : output Jsont.t =

     
···

       273
       231
        
           | Ok json -> json

     

       274
       232
        
           | Error msg -> failwith ("PostToolUse.output_to_json: " ^ msg)

     

       275
       233
        
       

     

       276
       276
       -
         let continue ?additional_context ?(unknown = Output_unknown.empty) () =

     

       234
       234
       +
         let continue ?additional_context ?(unknown = Unknown.empty) () =

     

       277
       235
        
           { decision = None; reason = None; additional_context; unknown }

     

       278
       236
        
       

     

       279
       279
       -
         let block ?reason ?additional_context ?(unknown = Output_unknown.empty) () =

     

       237
       237
       +
         let block ?reason ?additional_context ?(unknown = Unknown.empty) () =

     

       280
       238
        
           { decision = Some Block; reason; additional_context; unknown }

     

       281
       239
        
       end

     

       282
       240
        
       

     

       283
       241
        
       (** {1 UserPromptSubmit Hook} *)

     

       284
       242
        
       module UserPromptSubmit = struct

     

       285
       285
       -
         module Input_unknown = struct

     

       286
       286
       -
           type t = Jsont.json

     

       287
       287
       -
           let empty = Jsont.Object ([], Jsont.Meta.none)

     

       288
       288
       -
           let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       289
       289
       -
           let jsont = Jsont.json

     

       290
       290
       -
         end

     

       291
       291
       -
       

     

       292
       243
        
         type input = {

     

       293
       244
        
           session_id: string;

     

       294
       245
        
           transcript_path: string;

     

       295
       246
        
           prompt: string;

     

       296
       296
       -
           unknown : Input_unknown.t;

     

       247
       247
       +
           unknown : Unknown.t;

     

       297
       248
        
         }

     

       298
       249
        
       

     

       299
       250
        
         type t = input

     
···

       319
       270
        
           | Ok v -> v

     

       320
       271
        
           | Error msg -> raise (Invalid_argument ("UserPromptSubmit: " ^ msg))

     

       321
       272
        
       

     

       322
       322
       -
         module Output_unknown = struct

     

       323
       323
       -
           type t = Jsont.json

     

       324
       324
       -
           let empty = Jsont.Object ([], Jsont.Meta.none)

     

       325
       325
       -
           let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       326
       326
       -
           let jsont = Jsont.json

     

       327
       327
       -
         end

     

       328
       328
       -
       

     

       329
       273
        
         type output = {

     

       330
       274
        
           decision: decision option;

     

       331
       275
        
           reason: string option;

     

       332
       276
        
           additional_context: string option;

     

       333
       333
       -
           unknown : Output_unknown.t;

     

       277
       277
       +
           unknown : Unknown.t;

     

       334
       278
        
         }

     

       335
       279
        
       

     

       336
       280
        
         let output_jsont : output Jsont.t =

     
···

       349
       293
        
           | Ok json -> json

     

       350
       294
        
           | Error msg -> failwith ("UserPromptSubmit.output_to_json: " ^ msg)

     

       351
       295
        
       

     

       352
       352
       -
         let continue ?additional_context ?(unknown = Output_unknown.empty) () =

     

       296
       296
       +
         let continue ?additional_context ?(unknown = Unknown.empty) () =

     

       353
       297
        
           { decision = None; reason = None; additional_context; unknown }

     

       354
       298
        
       

     

       355
       355
       -
         let block ?reason ?(unknown = Output_unknown.empty) () =

     

       299
       299
       +
         let block ?reason ?(unknown = Unknown.empty) () =

     

       356
       300
        
           { decision = Some Block; reason; additional_context = None; unknown }

     

       357
       301
        
       end

     

       358
       302
        
       

     

       359
       303
        
       (** {1 Stop Hook} *)

     

       360
       304
        
       module Stop = struct

     

       361
       361
       -
         module Input_unknown = struct

     

       362
       362
       -
           type t = Jsont.json

     

       363
       363
       -
           let empty = Jsont.Object ([], Jsont.Meta.none)

     

       364
       364
       -
           let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       365
       365
       -
           let jsont = Jsont.json

     

       366
       366
       -
         end

     

       367
       367
       -
       

     

       368
       305
        
         type input = {

     

       369
       306
        
           session_id: string;

     

       370
       307
        
           transcript_path: string;

     

       371
       308
        
           stop_hook_active: bool;

     

       372
       372
       -
           unknown : Input_unknown.t;

     

       309
       309
       +
           unknown : Unknown.t;

     

       373
       310
        
         }

     

       374
       311
        
       

     

       375
       312
        
         type t = input

     
···

       395
       332
        
           | Ok v -> v

     

       396
       333
        
           | Error msg -> raise (Invalid_argument ("Stop: " ^ msg))

     

       397
       334
        
       

     

       398
       398
       -
         module Output_unknown = struct

     

       399
       399
       -
           type t = Jsont.json

     

       400
       400
       -
           let empty = Jsont.Object ([], Jsont.Meta.none)

     

       401
       401
       -
           let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       402
       402
       -
           let jsont = Jsont.json

     

       403
       403
       -
         end

     

       404
       404
       -
       

     

       405
       335
        
         type output = {

     

       406
       336
        
           decision: decision option;

     

       407
       337
        
           reason: string option;

     

       408
       408
       -
           unknown : Output_unknown.t;

     

       338
       338
       +
           unknown : Unknown.t;

     

       409
       339
        
         }

     

       410
       340
        
       

     

       411
       341
        
         let output_jsont : output Jsont.t =

     
···

       423
       353
        
           | Ok json -> json

     

       424
       354
        
           | Error msg -> failwith ("Stop.output_to_json: " ^ msg)

     

       425
       355
        
       

     

       426
       426
       -
         let continue ?(unknown = Output_unknown.empty) () = { decision = None; reason = None; unknown }

     

       427
       427
       -
         let block ?reason ?(unknown = Output_unknown.empty) () = { decision = Some Block; reason; unknown }

     

       356
       356
       +
         let continue ?(unknown = Unknown.empty) () = { decision = None; reason = None; unknown }

     

       357
       357
       +
         let block ?reason ?(unknown = Unknown.empty) () = { decision = Some Block; reason; unknown }

     

       428
       358
        
       end

     

       429
       359
        
       

     

       430
       360
        
       (** {1 SubagentStop Hook} - Same structure as Stop *)

     
···

       434
       364
        
       

     

       435
       365
        
       (** {1 PreCompact Hook} *)

     

       436
       366
        
       module PreCompact = struct

     

       437
       437
       -
         module Input_unknown = struct

     

       438
       438
       -
           type t = Jsont.json

     

       439
       439
       -
           let empty = Jsont.Object ([], Jsont.Meta.none)

     

       440
       440
       -
           let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       441
       441
       -
           let jsont = Jsont.json

     

       442
       442
       -
         end

     

       443
       443
       -
       

     

       444
       367
        
         type input = {

     

       445
       368
        
           session_id: string;

     

       446
       369
        
           transcript_path: string;

     

       447
       447
       -
           unknown : Input_unknown.t;

     

       370
       370
       +
           unknown : Unknown.t;

     

       448
       371
        
         }

     

       449
       372
        
       

     

       450
       373
        
         type t = input

     
···

       491
       414
        
       type config = (event * matcher list) list

     

       492
       415
        
       

     

       493
       416
        
       (** {1 Result Builders} *)

     

       494
       494
       -
       let continue ?system_message ?hook_specific_output ?(unknown = Result_unknown.empty) () =

     

       417
       417
       +
       let continue ?system_message ?hook_specific_output ?(unknown = Unknown.empty) () =

     

       495
       418
        
         { decision = None; system_message; hook_specific_output; unknown }

     

       496
       419
        
       

     

       497
       497
       -
       let block ?system_message ?hook_specific_output ?(unknown = Result_unknown.empty) () =

     

       420
       420
       +
       let block ?system_message ?hook_specific_output ?(unknown = Unknown.empty) () =

     

       498
       421
        
         { decision = Some Block; system_message; hook_specific_output; unknown }

     

       499
       422
        
       

     

       500
       423
        
       (** {1 Matcher Builders} *)

+27 -104

claudeio/lib/hooks.mli

···

       73
       73
        
       (** {1 Context} *)

     

       74
       74
        
       

     

       75
       75
        
       module Context : sig

     

       76
       76
       -
         module Unknown : sig

     

       77
       77
       -
           type t = Jsont.json

     

       78
       78
       -
           val empty : t

     

       79
       79
       -
           val is_empty : t -> bool

     

       80
       80
       -
           val jsont : t Jsont.t

     

       81
       81
       -
         end

     

       82
       82
       -
       

     

       83
       76
        
         type t = {

     

       84
       77
        
           signal: unit option;

     

       85
       78
        
           unknown : Unknown.t;

     
···

       101
       94
        
       

     

       102
       95
        
       (** {1 Generic Hook Result} *)

     

       103
       96
        
       

     

       104
       104
       -
       module Result_unknown : sig

     

       105
       105
       -
         type t = Jsont.json

     

       106
       106
       -
         val empty : t

     

       107
       107
       -
         val is_empty : t -> bool

     

       108
       108
       -
         val jsont : t Jsont.t

     

       109
       109
       -
       end

     

       110
       110
       -
       

     

       111
       97
        
       (** Generic result structure for hooks *)

     

       112
       98
        
       type result = {

     

       113
       99
        
         decision: decision option;

     

       114
       100
        
         system_message: string option;

     

       115
       101
        
         hook_specific_output: Jsont.json option;

     

       116
       116
       -
         unknown: Result_unknown.t;

     

       102
       102
       +
         unknown: Unknown.t;

     

       117
       103
        
       }

     

       118
       104
        
       

     

       119
       105
        
       val result_jsont : result Jsont.t

     
···

       122
       108
        
       

     

       123
       109
        
       (** PreToolUse hook - fires before tool execution *)

     

       124
       110
        
       module PreToolUse : sig

     

       125
       125
       -
         module Input_unknown : sig

     

       126
       126
       -
           type t = Jsont.json

     

       127
       127
       -
           val empty : t

     

       128
       128
       -
           val is_empty : t -> bool

     

       129
       129
       -
           val jsont : t Jsont.t

     

       130
       130
       -
         end

     

       131
       131
       -
       

     

       132
       111
        
         (** Typed input for PreToolUse hooks *)

     

       133
       112
        
         type input = {

     

       134
       113
        
           session_id: string;

     

       135
       114
        
           transcript_path: string;

     

       136
       115
        
           tool_name: string;

     

       137
       116
        
           tool_input: Jsont.json;

     

       138
       138
       -
           unknown: Input_unknown.t;

     

       117
       117
       +
           unknown: Unknown.t;

     

       139
       118
        
         }

     

       140
       119
        
       

     

       141
       120
        
         type t = input

     
···

       148
       127
        
         val transcript_path : t -> string

     

       149
       128
        
         val tool_name : t -> string

     

       150
       129
        
         val tool_input : t -> Jsont.json

     

       151
       151
       -
         val unknown : t -> Input_unknown.t

     

       130
       130
       +
         val unknown : t -> Unknown.t

     

       152
       131
        
       

     

       153
       132
        
         val input_jsont : input Jsont.t

     

       154
       133
        
       

     
···

       157
       136
        
       

     

       158
       137
        
         val permission_decision_jsont : permission_decision Jsont.t

     

       159
       138
        
       

     

       160
       160
       -
         module Output_unknown : sig

     

       161
       161
       -
           type t = Jsont.json

     

       162
       162
       -
           val empty : t

     

       163
       163
       -
           val is_empty : t -> bool

     

       164
       164
       -
           val jsont : t Jsont.t

     

       165
       165
       -
         end

     

       166
       166
       -
       

     

       167
       139
        
         (** Typed output for PreToolUse hooks *)

     

       168
       140
        
         type output = {

     

       169
       141
        
           permission_decision: permission_decision option;

     

       170
       142
        
           permission_decision_reason: string option;

     

       171
       143
        
           updated_input: Jsont.json option;

     

       172
       172
       -
           unknown: Output_unknown.t;

     

       144
       144
       +
           unknown: Unknown.t;

     

       173
       145
        
         }

     

       174
       146
        
       

     

       175
       147
        
         val output_jsont : output Jsont.t

     

       176
       148
        
       

     

       177
       149
        
         (** {2 Response Builders} *)

     

       178
       178
       -
         val allow : ?reason:string -> ?updated_input:Jsont.json -> ?unknown:Output_unknown.t -> unit -> output

     

       179
       179
       -
         val deny : ?reason:string -> ?unknown:Output_unknown.t -> unit -> output

     

       180
       180
       -
         val ask : ?reason:string -> ?unknown:Output_unknown.t -> unit -> output

     

       181
       181
       -
         val continue : ?unknown:Output_unknown.t -> unit -> output

     

       150
       150
       +
         val allow : ?reason:string -> ?updated_input:Jsont.json -> ?unknown:Unknown.t -> unit -> output

     

       151
       151
       +
         val deny : ?reason:string -> ?unknown:Unknown.t -> unit -> output

     

       152
       152
       +
         val ask : ?reason:string -> ?unknown:Unknown.t -> unit -> output

     

       153
       153
       +
         val continue : ?unknown:Unknown.t -> unit -> output

     

       182
       154
        
       

     

       183
       155
        
         (** Convert output to JSON for hook_specific_output *)

     

       184
       156
        
         val output_to_json : output -> Jsont.json

     
···

       186
       158
        
       

     

       187
       159
        
       (** PostToolUse hook - fires after tool execution *)

     

       188
       160
        
       module PostToolUse : sig

     

       189
       189
       -
         module Input_unknown : sig

     

       190
       190
       -
           type t = Jsont.json

     

       191
       191
       -
           val empty : t

     

       192
       192
       -
           val is_empty : t -> bool

     

       193
       193
       -
           val jsont : t Jsont.t

     

       194
       194
       -
         end

     

       195
       195
       -
       

     

       196
       161
        
         type input = {

     

       197
       162
        
           session_id: string;

     

       198
       163
        
           transcript_path: string;

     

       199
       164
        
           tool_name: string;

     

       200
       165
        
           tool_input: Jsont.json;

     

       201
       166
        
           tool_response: Jsont.json;

     

       202
       202
       -
           unknown: Input_unknown.t;

     

       167
       167
       +
           unknown: Unknown.t;

     

       203
       168
        
         }

     

       204
       169
        
       

     

       205
       170
        
         type t = input

     
···

       211
       176
        
         val tool_name : t -> string

     

       212
       177
        
         val tool_input : t -> Jsont.json

     

       213
       178
        
         val tool_response : t -> Jsont.json

     

       214
       214
       -
         val unknown : t -> Input_unknown.t

     

       179
       179
       +
         val unknown : t -> Unknown.t

     

       215
       180
        
       

     

       216
       181
        
         val input_jsont : input Jsont.t

     

       217
       182
        
       

     

       218
       218
       -
         module Output_unknown : sig

     

       219
       219
       -
           type t = Jsont.json

     

       220
       220
       -
           val empty : t

     

       221
       221
       -
           val is_empty : t -> bool

     

       222
       222
       -
           val jsont : t Jsont.t

     

       223
       223
       -
         end

     

       224
       224
       -
       

     

       225
       183
        
         type output = {

     

       226
       184
        
           decision: decision option;

     

       227
       185
        
           reason: string option;

     

       228
       186
        
           additional_context: string option;

     

       229
       229
       -
           unknown: Output_unknown.t;

     

       187
       187
       +
           unknown: Unknown.t;

     

       230
       188
        
         }

     

       231
       189
        
       

     

       232
       190
        
         val output_jsont : output Jsont.t

     

       233
       191
        
       

     

       234
       234
       -
         val continue : ?additional_context:string -> ?unknown:Output_unknown.t -> unit -> output

     

       235
       235
       -
         val block : ?reason:string -> ?additional_context:string -> ?unknown:Output_unknown.t -> unit -> output

     

       192
       192
       +
         val continue : ?additional_context:string -> ?unknown:Unknown.t -> unit -> output

     

       193
       193
       +
         val block : ?reason:string -> ?additional_context:string -> ?unknown:Unknown.t -> unit -> output

     

       236
       194
        
         val output_to_json : output -> Jsont.json

     

       237
       195
        
       end

     

       238
       196
        
       

     

       239
       197
        
       (** UserPromptSubmit hook - fires when user submits a prompt *)

     

       240
       198
        
       module UserPromptSubmit : sig

     

       241
       241
       -
         module Input_unknown : sig

     

       242
       242
       -
           type t = Jsont.json

     

       243
       243
       -
           val empty : t

     

       244
       244
       -
           val is_empty : t -> bool

     

       245
       245
       -
           val jsont : t Jsont.t

     

       246
       246
       -
         end

     

       247
       247
       -
       

     

       248
       199
        
         type input = {

     

       249
       200
        
           session_id: string;

     

       250
       201
        
           transcript_path: string;

     

       251
       202
        
           prompt: string;

     

       252
       252
       -
           unknown: Input_unknown.t;

     

       203
       203
       +
           unknown: Unknown.t;

     

       253
       204
        
         }

     

       254
       205
        
       

     

       255
       206
        
         type t = input

     
···

       259
       210
        
         val session_id : t -> string

     

       260
       211
        
         val transcript_path : t -> string

     

       261
       212
        
         val prompt : t -> string

     

       262
       262
       -
         val unknown : t -> Input_unknown.t

     

       213
       213
       +
         val unknown : t -> Unknown.t

     

       263
       214
        
       

     

       264
       215
        
         val input_jsont : input Jsont.t

     

       265
       216
        
       

     

       266
       266
       -
         module Output_unknown : sig

     

       267
       267
       -
           type t = Jsont.json

     

       268
       268
       -
           val empty : t

     

       269
       269
       -
           val is_empty : t -> bool

     

       270
       270
       -
           val jsont : t Jsont.t

     

       271
       271
       -
         end

     

       272
       272
       -
       

     

       273
       217
        
         type output = {

     

       274
       218
        
           decision: decision option;

     

       275
       219
        
           reason: string option;

     

       276
       220
        
           additional_context: string option;

     

       277
       277
       -
           unknown: Output_unknown.t;

     

       221
       221
       +
           unknown: Unknown.t;

     

       278
       222
        
         }

     

       279
       223
        
       

     

       280
       224
        
         val output_jsont : output Jsont.t

     

       281
       225
        
       

     

       282
       282
       -
         val continue : ?additional_context:string -> ?unknown:Output_unknown.t -> unit -> output

     

       283
       283
       -
         val block : ?reason:string -> ?unknown:Output_unknown.t -> unit -> output

     

       226
       226
       +
         val continue : ?additional_context:string -> ?unknown:Unknown.t -> unit -> output

     

       227
       227
       +
         val block : ?reason:string -> ?unknown:Unknown.t -> unit -> output

     

       284
       228
        
         val output_to_json : output -> Jsont.json

     

       285
       229
        
       end

     

       286
       230
        
       

     

       287
       231
        
       (** Stop hook - fires when conversation stops *)

     

       288
       232
        
       module Stop : sig

     

       289
       289
       -
         module Input_unknown : sig

     

       290
       290
       -
           type t = Jsont.json

     

       291
       291
       -
           val empty : t

     

       292
       292
       -
           val is_empty : t -> bool

     

       293
       293
       -
           val jsont : t Jsont.t

     

       294
       294
       -
         end

     

       295
       295
       -
       

     

       296
       233
        
         type input = {

     

       297
       234
        
           session_id: string;

     

       298
       235
        
           transcript_path: string;

     

       299
       236
        
           stop_hook_active: bool;

     

       300
       300
       -
           unknown: Input_unknown.t;

     

       237
       237
       +
           unknown: Unknown.t;

     

       301
       238
        
         }

     

       302
       239
        
       

     

       303
       240
        
         type t = input

     
···

       307
       244
        
         val session_id : t -> string

     

       308
       245
        
         val transcript_path : t -> string

     

       309
       246
        
         val stop_hook_active : t -> bool

     

       310
       310
       -
         val unknown : t -> Input_unknown.t

     

       247
       247
       +
         val unknown : t -> Unknown.t

     

       311
       248
        
       

     

       312
       249
        
         val input_jsont : input Jsont.t

     

       313
       250
        
       

     

       314
       314
       -
         module Output_unknown : sig

     

       315
       315
       -
           type t = Jsont.json

     

       316
       316
       -
           val empty : t

     

       317
       317
       -
           val is_empty : t -> bool

     

       318
       318
       -
           val jsont : t Jsont.t

     

       319
       319
       -
         end

     

       320
       320
       -
       

     

       321
       251
        
         type output = {

     

       322
       252
        
           decision: decision option;

     

       323
       253
        
           reason: string option;

     

       324
       324
       -
           unknown: Output_unknown.t;

     

       254
       254
       +
           unknown: Unknown.t;

     

       325
       255
        
         }

     

       326
       256
        
       

     

       327
       257
        
         val output_jsont : output Jsont.t

     

       328
       258
        
       

     

       329
       329
       -
         val continue : ?unknown:Output_unknown.t -> unit -> output

     

       330
       330
       -
         val block : ?reason:string -> ?unknown:Output_unknown.t -> unit -> output

     

       259
       259
       +
         val continue : ?unknown:Unknown.t -> unit -> output

     

       260
       260
       +
         val block : ?reason:string -> ?unknown:Unknown.t -> unit -> output

     

       331
       261
        
         val output_to_json : output -> Jsont.json

     

       332
       262
        
       end

     

       333
       263
        
       

     
···

       339
       269
        
       

     

       340
       270
        
       (** PreCompact hook - fires before message compaction *)

     

       341
       271
        
       module PreCompact : sig

     

       342
       342
       -
         module Input_unknown : sig

     

       343
       343
       -
           type t = Jsont.json

     

       344
       344
       -
           val empty : t

     

       345
       345
       -
           val is_empty : t -> bool

     

       346
       346
       -
           val jsont : t Jsont.t

     

       347
       347
       -
         end

     

       348
       348
       -
       

     

       349
       272
        
         type input = {

     

       350
       273
        
           session_id: string;

     

       351
       274
        
           transcript_path: string;

     

       352
       352
       -
           unknown: Input_unknown.t;

     

       275
       275
       +
           unknown: Unknown.t;

     

       353
       276
        
         }

     

       354
       277
        
       

     

       355
       278
        
         type t = input

     
···

       360
       283
        
       

     

       361
       284
        
         val session_id : t -> string

     

       362
       285
        
         val transcript_path : t -> string

     

       363
       363
       -
         val unknown : t -> Input_unknown.t

     

       286
       286
       +
         val unknown : t -> Unknown.t

     

       364
       287
        
       

     

       365
       288
        
         val input_jsont : input Jsont.t

     

       366
       289
        
       

     
···

       399
       322
        
       (** {1 Generic Result Builders} *)

     

       400
       323
        
       

     

       401
       324
        
       (** [continue ?system_message ?hook_specific_output ?unknown ()] creates a continue result *)

     

       402
       402
       -
       val continue : ?system_message:string -> ?hook_specific_output:Jsont.json -> ?unknown:Result_unknown.t -> unit -> result

     

       325
       325
       +
       val continue : ?system_message:string -> ?hook_specific_output:Jsont.json -> ?unknown:Unknown.t -> unit -> result

     

       403
       326
        
       

     

       404
       327
        
       (** [block ?system_message ?hook_specific_output ?unknown ()] creates a block result *)

     

       405
       405
       -
       val block : ?system_message:string -> ?hook_specific_output:Jsont.json -> ?unknown:Result_unknown.t -> unit -> result

     

       328
       328
       +
       val block : ?system_message:string -> ?hook_specific_output:Jsont.json -> ?unknown:Unknown.t -> unit -> result

     

       406
       329
        
       

     

       407
       330
        
       (** {1 Configuration Builders} *)

     

       408
       331

+82 -199

claudeio/lib/message.ml

···

       7
       7
        
           | String of string

     

       8
       8
        
           | Blocks of Content_block.t list

     

       9
       9
        
       

     

       10
       10
       -
         module Unknown = struct

     

       11
       11
       -
           type t = Jsont.json

     

       12
       12
       -
           let empty = Jsont.Object ([], Jsont.Meta.none)

     

       13
       13
       -
           let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       14
       14
       -
           let jsont = Jsont.json

     

       15
       15
       -
         end

     

       16
       16
       -
       

     

       17
       10
        
         type t = {

     

       18
       11
        
           content : content;

     

       19
       12
        
           unknown : Unknown.t;

     
···

       173
       166
        
             ("unknown", `Unknown);

     

       174
       167
        
           ]

     

       175
       168
        
       

     

       176
       176
       -
         module Unknown = struct

     

       177
       177
       -
           type t = Jsont.json

     

       178
       178
       -
           let empty = Jsont.Object ([], Jsont.Meta.none)

     

       179
       179
       -
           let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       180
       180
       -
           let jsont = Jsont.json

     

       181
       181
       -
         end

     

       182
       182
       -
       

     

       183
       169
        
         type t = {

     

       184
       170
        
           content : Content_block.t list;

     

       185
       171
        
           model : string;

     
···

       287
       273
        
       end

     

       288
       274
        
       

     

       289
       275
        
       module System = struct

     

       290
       290
       -
         (** Typed data for system init messages *)

     

       291
       291
       -
         module Init = struct

     

       292
       292
       -
           module Unknown = struct

     

       293
       293
       -
             type t = Jsont.json

     

       294
       294
       -
             let empty = Jsont.Object ([], Jsont.Meta.none)

     

       295
       295
       -
             let _jsont = Jsont.json

     

       296
       296
       -
           end

     

       276
       276
       +
         (** System messages as a discriminated union on "subtype" field *)

     

       297
       277
        
       

     

       298
       298
       -
           type t = {

     

       299
       299
       -
             session_id : string option;

     

       300
       300
       -
             model : string option;

     

       301
       301
       -
             cwd : string option;

     

       302
       302
       -
             unknown : Unknown.t;

     

       303
       303
       -
           }

     

       278
       278
       +
         type init = {

     

       279
       279
       +
           session_id : string option;

     

       280
       280
       +
           model : string option;

     

       281
       281
       +
           cwd : string option;

     

       282
       282
       +
           unknown : Unknown.t;

     

       283
       283
       +
         }

     

       304
       284
        
       

     

       305
       305
       -
           let make session_id model cwd unknown = { session_id; model; cwd; unknown }

     

       306
       306
       -
       

     

       307
       307
       -
           let create ?session_id ?model ?cwd () =

     

       308
       308
       -
             { session_id; model; cwd; unknown = Unknown.empty }

     

       309
       309
       -
       

     

       310
       310
       -
           let session_id t = t.session_id

     

       311
       311
       -
           let model t = t.model

     

       312
       312
       -
           let cwd t = t.cwd

     

       313
       313
       -
           let unknown t = t.unknown

     

       285
       285
       +
         type error = {

     

       286
       286
       +
           error : string;

     

       287
       287
       +
           unknown : Unknown.t;

     

       288
       288
       +
         }

     

       314
       289
        
       

     

       315
       315
       -
           let jsont : t Jsont.t =

     

       316
       316
       -
             Jsont.Object.map ~kind:"SystemInit" make

     

       317
       317
       -
             |> Jsont.Object.opt_mem "session_id" Jsont.string ~enc:session_id

     

       318
       318
       -
             |> Jsont.Object.opt_mem "model" Jsont.string ~enc:model

     

       319
       319
       -
             |> Jsont.Object.opt_mem "cwd" Jsont.string ~enc:cwd

     

       320
       320
       -
             |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:unknown

     

       321
       321
       -
             |> Jsont.Object.finish

     

       322
       322
       -
         end

     

       323
       323
       -
       

     

       324
       324
       -
         (** Typed data for system error messages *)

     

       325
       325
       -
         module Error = struct

     

       326
       326
       -
           module Unknown = struct

     

       327
       327
       -
             type t = Jsont.json

     

       328
       328
       -
             let empty = Jsont.Object ([], Jsont.Meta.none)

     

       329
       329
       -
             let _jsont = Jsont.json

     

       330
       330
       -
           end

     

       331
       331
       -
       

     

       332
       332
       -
           type t = {

     

       333
       333
       -
             error : string;

     

       334
       334
       -
             unknown : Unknown.t;

     

       335
       335
       -
           }

     

       336
       336
       -
       

     

       337
       337
       -
           let make error unknown = { error; unknown }

     

       338
       338
       -
       

     

       339
       339
       -
           let create ~error = { error; unknown = Unknown.empty }

     

       340
       340
       -
       

     

       341
       341
       -
           let error t = t.error

     

       342
       342
       -
           let unknown t = t.unknown

     

       343
       343
       -
       

     

       344
       344
       -
           let jsont : t Jsont.t =

     

       345
       345
       -
             Jsont.Object.map ~kind:"SystemError" make

     

       346
       346
       -
             |> Jsont.Object.mem "error" Jsont.string ~enc:error

     

       347
       347
       -
             |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:unknown

     

       348
       348
       -
             |> Jsont.Object.finish

     

       349
       349
       -
         end

     

       350
       350
       -
       

     

       351
       351
       -
         (** Sum type for system message data *)

     

       352
       352
       -
         module Data = struct

     

       353
       353
       -
           type t =

     

       354
       354
       -
             | Init of Init.t

     

       355
       355
       -
             | Error of Error.t

     

       356
       356
       -
             | Other of Jsont.json  (** Unknown subtypes preserve raw JSON *)

     

       357
       357
       -
       

     

       358
       358
       -
           let init ?session_id ?model ?cwd () = Init (Init.create ?session_id ?model ?cwd ())

     

       359
       359
       -
           let error ~error = Error (Error.create ~error)

     

       360
       360
       -
           let other json = Other json

     

       361
       361
       -
       

     

       362
       362
       -
           let session_id = function

     

       363
       363
       -
             | Init i -> Init.session_id i

     

       364
       364
       -
             | _ -> None

     

       365
       365
       -
       

     

       366
       366
       -
           let model = function

     

       367
       367
       -
             | Init i -> Init.model i

     

       368
       368
       -
             | _ -> None

     

       369
       369
       -
       

     

       370
       370
       -
           let cwd = function

     

       371
       371
       -
             | Init i -> Init.cwd i

     

       372
       372
       -
             | _ -> None

     

       373
       373
       -
       

     

       374
       374
       -
           let error_msg = function

     

       375
       375
       -
             | Error e -> Some (Error.error e)

     

       376
       376
       -
             | _ -> None

     

       377
       377
       -
       

     

       378
       378
       -
           let to_json = function

     

       379
       379
       -
             | Init i ->

     

       380
       380
       -
                 (match Jsont.Json.encode Init.jsont i with

     

       381
       381
       -
                 | Ok json -> json

     

       382
       382
       -
                 | Error msg -> failwith ("Init.to_json: " ^ msg))

     

       383
       383
       -
             | Error e ->

     

       384
       384
       -
                 (match Jsont.Json.encode Error.jsont e with

     

       385
       385
       -
                 | Ok json -> json

     

       386
       386
       -
                 | Error msg -> failwith ("Error.to_json: " ^ msg))

     

       387
       387
       -
             | Other json -> json

     

       388
       388
       -
       

     

       389
       389
       -
           let of_json ~subtype json =

     

       390
       390
       -
             match subtype with

     

       391
       391
       -
             | "init" ->

     

       392
       392
       -
                 (match Jsont.Json.decode Init.jsont json with

     

       393
       393
       -
                 | Ok i -> Init i

     

       394
       394
       -
                 | Error _ -> Other json)

     

       395
       395
       -
             | "error" ->

     

       396
       396
       -
                 (match Jsont.Json.decode Error.jsont json with

     

       397
       397
       -
                 | Ok e -> Error e

     

       398
       398
       -
                 | Error _ -> Other json)

     

       399
       399
       -
             | _ -> Other json

     

       400
       400
       -
         end

     

       401
       401
       -
       

     

       402
       402
       -
         module Unknown = struct

     

       403
       403
       -
           type t = Jsont.json

     

       404
       404
       -
           let empty = Jsont.Object ([], Jsont.Meta.none)

     

       405
       405
       -
           let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       406
       406
       -
           let jsont = Jsont.json

     

       407
       407
       -
         end

     

       408
       408
       -
       

     

       409
       409
       -
         type t = {

     

       290
       290
       +
         type other = {

     

       410
       291
        
           subtype : string;

     

       411
       411
       -
           data : Data.t;

     

       412
       292
        
           unknown : Unknown.t;

     

       413
       293
        
         }

     

       414
       294
        
       

     

       415
       415
       -
         let create ~subtype ~data = { subtype; data; unknown = Unknown.empty }

     

       416
       416
       -
         let subtype t = t.subtype

     

       417
       417
       -
         let data t = t.data

     

       418
       418
       -
         let unknown t = t.unknown

     

       295
       295
       +
         type t =

     

       296
       296
       +
           | Init of init

     

       297
       297
       +
           | Error of error

     

       298
       298
       +
           | Other of other

     

       299
       299
       +
       

     

       300
       300
       +
         (* Accessors *)

     

       301
       301
       +
         let session_id = function Init i -> i.session_id | _ -> None

     

       302
       302
       +
         let model = function Init i -> i.model | _ -> None

     

       303
       303
       +
         let cwd = function Init i -> i.cwd | _ -> None

     

       304
       304
       +
         let error_msg = function Error e -> Some e.error | _ -> None

     

       305
       305
       +
         let subtype = function Init _ -> "init" | Error _ -> "error" | Other o -> o.subtype

     

       306
       306
       +
         let unknown = function

     

       307
       307
       +
           | Init i -> i.unknown

     

       308
       308
       +
           | Error e -> e.unknown

     

       309
       309
       +
           | Other o -> o.unknown

     

       419
       310
        
       

     

       420
       420
       -
         (** Create a system init message *)

     

       311
       311
       +
         (* Constructors *)

     

       421
       312
        
         let init ?session_id ?model ?cwd () =

     

       422
       422
       -
           { subtype = "init";

     

       423
       423
       -
             data = Data.init ?session_id ?model ?cwd ();

     

       424
       424
       -
             unknown = Unknown.empty }

     

       313
       313
       +
           Init { session_id; model; cwd; unknown = Unknown.empty }

     

       425
       314
        
       

     

       426
       426
       -
         (** Create a system error message *)

     

       427
       315
        
         let error ~error =

     

       428
       428
       -
           { subtype = "error";

     

       429
       429
       -
             data = Data.error ~error;

     

       430
       430
       -
             unknown = Unknown.empty }

     

       316
       316
       +
           Error { error; unknown = Unknown.empty }

     

       431
       317
        
       

     

       432
       432
       -
         (* Custom jsont that handles both formats:

     

       433
       433
       -
            - Old format: {"type":"system","subtype":"init","data":{...}}

     

       434
       434
       -
            - New format: {"type":"system","subtype":"init","cwd":"...","session_id":"...",...}

     

       435
       435
       -
            When data field is not present, we use the entire object as data *)

     

       318
       318
       +
         let other ~subtype =

     

       319
       319
       +
           Other { subtype; unknown = Unknown.empty }

     

       320
       320
       +
       

     

       321
       321
       +
         (* Individual record codecs *)

     

       322
       322
       +
         let init_jsont : init Jsont.t =

     

       323
       323
       +
           let make session_id model cwd unknown : init = { session_id; model; cwd; unknown } in

     

       324
       324
       +
           Jsont.Object.map ~kind:"SystemInit" make

     

       325
       325
       +
           |> Jsont.Object.opt_mem "session_id" Jsont.string ~enc:(fun (r : init) -> r.session_id)

     

       326
       326
       +
           |> Jsont.Object.opt_mem "model" Jsont.string ~enc:(fun (r : init) -> r.model)

     

       327
       327
       +
           |> Jsont.Object.opt_mem "cwd" Jsont.string ~enc:(fun (r : init) -> r.cwd)

     

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

     

       329
       329
       +
           |> Jsont.Object.finish

     

       330
       330
       +
       

     

       331
       331
       +
         let error_jsont : error Jsont.t =

     

       332
       332
       +
           let make err unknown : error = { error = err; unknown } in

     

       333
       333
       +
           Jsont.Object.map ~kind:"SystemError" make

     

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

     

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

     

       336
       336
       +
           |> Jsont.Object.finish

     

       337
       337
       +
       

     

       338
       338
       +
         (* Main codec using case_mem for "subtype" discriminator *)

     

       436
       339
        
         let jsont : t Jsont.t =

     

       437
       437
       -
           let dec json =

     

       438
       438
       -
             (* First decode just the subtype *)

     

       439
       439
       -
             let subtype_codec = Jsont.Object.map ~kind:"SystemSubtype" Fun.id

     

       440
       440
       -
               |> Jsont.Object.mem "subtype" Jsont.string ~enc:Fun.id

     

       340
       340
       +
           let case_init = Jsont.Object.Case.map "init" init_jsont ~dec:(fun v -> Init v) in

     

       341
       341
       +
           let case_error = Jsont.Object.Case.map "error" error_jsont ~dec:(fun v -> Error v) in

     

       342
       342
       +
           let case_other tag =

     

       343
       343
       +
             (* For unknown subtypes, create Other with the tag as subtype *)

     

       344
       344
       +
             let other_codec : other Jsont.t =

     

       345
       345
       +
               let make unknown : other = { subtype = tag; unknown } in

     

       346
       346
       +
               Jsont.Object.map ~kind:"SystemOther" make

     

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

     

       441
       348
        
               |> Jsont.Object.finish

     

       442
       349
        
             in

     

       443
       443
       -
             match Jsont.Json.decode subtype_codec json with

     

       444
       444
       -
             | Error msg -> failwith ("System.jsont: " ^ msg)

     

       445
       445
       -
             | Ok subtype ->

     

       446
       446
       -
                 (* Try to get data field, otherwise use full object *)

     

       447
       447
       -
                 let data_codec = Jsont.Object.map ~kind:"SystemDataField" Fun.id

     

       448
       448
       -
                   |> Jsont.Object.opt_mem "data" Jsont.json ~enc:Fun.id

     

       449
       449
       -
                   |> Jsont.Object.finish

     

       450
       450
       -
                 in

     

       451
       451
       -
                 let data_json = match Jsont.Json.decode data_codec json with

     

       452
       452
       -
                   | Ok (Some d) -> d

     

       453
       453
       -
                   | _ -> json

     

       454
       454
       -
                 in

     

       455
       455
       -
                 let data = Data.of_json ~subtype data_json in

     

       456
       456
       -
                 { subtype; data; unknown = Unknown.empty }

     

       350
       350
       +
             Jsont.Object.Case.map tag other_codec ~dec:(fun v -> Other v)

     

       457
       351
        
           in

     

       458
       458
       -
           let enc t =

     

       459
       459
       -
             Jsont.Json.object' [

     

       460
       460
       -
               Jsont.Json.mem (Jsont.Json.name "type") (Jsont.Json.string "system");

     

       461
       461
       -
               Jsont.Json.mem (Jsont.Json.name "subtype") (Jsont.Json.string t.subtype);

     

       462
       462
       -
               Jsont.Json.mem (Jsont.Json.name "data") (Data.to_json t.data);

     

       463
       463
       -
             ]

     

       352
       352
       +
           let enc_case = function

     

       353
       353
       +
             | Init v -> Jsont.Object.Case.value case_init v

     

       354
       354
       +
             | Error v -> Jsont.Object.Case.value case_error v

     

       355
       355
       +
             | Other v -> Jsont.Object.Case.value (case_other v.subtype) v

     

       464
       356
        
           in

     

       465
       465
       -
           Jsont.map ~kind:"System" ~dec ~enc Jsont.json

     

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

     

       358
       358
       +
             make case_init;

     

       359
       359
       +
             make case_error;

     

       360
       360
       +
           ] in

     

       361
       361
       +
           Jsont.Object.map ~kind:"System" Fun.id

     

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

     

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

     

       364
       364
       +
           |> Jsont.Object.finish

     

       466
       365
        
       

     

       467
       366
        
         let to_json t =

     

       468
       367
        
           match Jsont.Json.encode jsont t with

     
···

       474
       373
        
           | Ok v -> v

     

       475
       374
        
           | Error msg -> raise (Invalid_argument ("System.of_json: " ^ msg))

     

       476
       375
        
       

     

       477
       477
       -
         let pp fmt t =

     

       478
       478
       -
           match t.data with

     

       479
       479
       -
           | Data.Init i ->

     

       376
       376
       +
         let pp fmt = function

     

       377
       377
       +
           | Init i ->

     

       480
       378
        
               Fmt.pf fmt "@[<2>System.init@ { session_id = %a;@ model = %a;@ cwd = %a }@]"

     

       481
       481
       -
                 Fmt.(option string) (Init.session_id i)

     

       482
       482
       -
                 Fmt.(option string) (Init.model i)

     

       483
       483
       -
                 Fmt.(option string) (Init.cwd i)

     

       484
       484
       -
           | Data.Error e ->

     

       485
       485
       -
               Fmt.pf fmt "@[<2>System.error@ { error = %s }@]" (Error.error e)

     

       486
       486
       -
           | Data.Other _ ->

     

       487
       487
       -
               Fmt.pf fmt "@[<2>System.%s@ { ... }@]" t.subtype

     

       379
       379
       +
                 Fmt.(option string) i.session_id

     

       380
       380
       +
                 Fmt.(option string) i.model

     

       381
       381
       +
                 Fmt.(option string) i.cwd

     

       382
       382
       +
           | Error e ->

     

       383
       383
       +
               Fmt.pf fmt "@[<2>System.error@ { error = %s }@]" e.error

     

       384
       384
       +
           | Other o ->

     

       385
       385
       +
               Fmt.pf fmt "@[<2>System.%s@ { ... }@]" o.subtype

     

       488
       386
        
       end

     

       489
       387
        
       

     

       490
       388
        
       module Result = struct

     

       491
       389
        
         module Usage = struct

     

       492
       492
       -
           module Unknown = struct

     

       493
       493
       -
             type t = Jsont.json

     

       494
       494
       -
             let empty = Jsont.Object ([], Jsont.Meta.none)

     

       495
       495
       -
             let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       496
       496
       -
             let jsont = Jsont.json

     

       497
       497
       -
           end

     

       498
       498
       -
       

     

       499
       390
        
           type t = {

     

       500
       391
        
             input_tokens : int option;

     

       501
       392
        
             output_tokens : int option;

     
···

       568
       459
        
             | Error msg -> raise (Invalid_argument ("Usage.of_json: " ^ msg))

     

       569
       460
        
         end

     

       570
       461
        
       

     

       571
       571
       -
         module Unknown = struct

     

       572
       572
       -
           type t = Jsont.json

     

       573
       573
       -
           let empty = Jsont.Object ([], Jsont.Meta.none)

     

       574
       574
       -
           let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       575
       575
       -
           let jsont = Jsont.json

     

       576
       576
       -
         end

     

       577
       577
       -
       

     

       578
       462
        
         type t = {

     

       579
       463
        
           subtype : string;

     

       580
       464
        
           duration_ms : int;

     
···

       700
       584
        
       let assistant_text ~text ~model ?error () =

     

       701
       585
        
         Assistant (Assistant.create ~content:[Content_block.text text] ~model ?error ())

     

       702
       586
        
       

     

       703
       703
       -
       let system ~subtype ~data = System (System.create ~subtype ~data)

     

       704
       587
        
       let system_init ~session_id =

     

       705
       588
        
         System (System.init ~session_id ())

     

       706
       589
        
       let system_error ~error =

     
···

       775
       658
        
         | _ -> []

     

       776
       659
        
       

     

       777
       660
        
       let get_session_id = function

     

       778
       778
       -
         | System s -> System.Data.session_id (System.data s)

     

       661
       661
       +
         | System s -> System.session_id s

     

       779
       662
        
         | Result r -> Some (Result.session_id r)

     

       780
       663
        
         | _ -> None

     

       781
       664

+53 -122

claudeio/lib/message.mli

···

       17
       17
        
           | Blocks of Content_block.t list  (** Complex message with multiple content blocks *)

     

       18
       18
        
         (** The content of a user message. *)

     

       19
       19
        
       

     

       20
       20
       -
         module Unknown : sig

     

       21
       21
       -
           type t = Jsont.json

     

       22
       22
       -
           val empty : t

     

       23
       23
       -
           val is_empty : t -> bool

     

       24
       24
       -
           val jsont : t Jsont.t

     

       25
       25
       -
         end

     

       26
       26
       -
       

     

       27
       20
        
         type t

     

       28
       21
        
         (** The type of user messages. *)

     

       29
       22
        
       

     
···

       92
       85
        
         val error_of_string : string -> error

     

       93
       86
        
         (** [error_of_string s] parses an error string. Unknown strings become [`Unknown]. *)

     

       94
       87
        
       

     

       95
       95
       -
         module Unknown : sig

     

       96
       96
       -
           type t = Jsont.json

     

       97
       97
       -
           val empty : t

     

       98
       98
       -
           val is_empty : t -> bool

     

       99
       99
       -
           val jsont : t Jsont.t

     

       100
       100
       -
         end

     

       101
       101
       -
       

     

       102
       88
        
         type t

     

       103
       89
        
         (** The type of assistant messages. *)

     

       104
       90
        
       

     
···

       152
       138
        
       (** {1 System Messages} *)

     

       153
       139
        
       

     

       154
       140
        
       module System : sig

     

       155
       155
       -
         (** System control and status messages. *)

     

       141
       141
       +
         (** System control and status messages.

     

       156
       142
        
       

     

       157
       157
       -
         (** Typed data for system init messages *)

     

       158
       158
       -
         module Init : sig

     

       159
       159
       -
           type t

     

       160
       160
       -
           (** Type of init message data. *)

     

       143
       143
       +
             System messages use a discriminated union on the "subtype" field:

     

       144
       144
       +
             - "init": Session initialization with session_id, model, cwd

     

       145
       145
       +
             - "error": Error messages with error string

     

       146
       146
       +
             - Other subtypes are preserved as [Other] *)

     

       161
       147
        
       

     

       162
       162
       -
           val create : ?session_id:string -> ?model:string -> ?cwd:string -> unit -> t

     

       163
       163
       -
           (** [create ?session_id ?model ?cwd ()] creates init data. *)

     

       148
       148
       +
         type init = {

     

       149
       149
       +
           session_id : string option;

     

       150
       150
       +
           model : string option;

     

       151
       151
       +
           cwd : string option;

     

       152
       152
       +
           unknown : Unknown.t;

     

       153
       153
       +
         }

     

       154
       154
       +
         (** Init message fields. *)

     

       164
       155
        
       

     

       165
       165
       -
           val session_id : t -> string option

     

       166
       166
       -
           (** [session_id t] returns the session ID if present. *)

     

       156
       156
       +
         type error = {

     

       157
       157
       +
           error : string;

     

       158
       158
       +
           unknown : Unknown.t;

     

       159
       159
       +
         }

     

       160
       160
       +
         (** Error message fields. *)

     

       167
       161
        
       

     

       168
       168
       -
           val model : t -> string option

     

       169
       169
       -
           (** [model t] returns the model name if present. *)

     

       162
       162
       +
         type other = {

     

       163
       163
       +
           subtype : string;

     

       164
       164
       +
           unknown : Unknown.t;

     

       165
       165
       +
         }

     

       166
       166
       +
         (** Unknown subtype fields. *)

     

       170
       167
        
       

     

       171
       171
       -
           val cwd : t -> string option

     

       172
       172
       -
           (** [cwd t] returns the current working directory if present. *)

     

       168
       168
       +
         type t =

     

       169
       169
       +
           | Init of init

     

       170
       170
       +
           | Error of error

     

       171
       171
       +
           | Other of other

     

       172
       172
       +
         (** The type of system messages. *)

     

       173
       173
        
       

     

       174
       174
       -
           val jsont : t Jsont.t

     

       175
       175
       -
           (** [jsont] is the Jsont codec for init data. *)

     

       176
       176
       -
         end

     

       174
       174
       +
         val jsont : t Jsont.t

     

       175
       175
       +
         (** [jsont] is the Jsont codec for system messages. *)

     

       177
       176
        
       

     

       178
       178
       -
         (** Typed data for system error messages *)

     

       179
       179
       -
         module Error : sig

     

       180
       180
       -
           type t

     

       181
       181
       -
           (** Type of error message data. *)

     

       177
       177
       +
         (** {2 Constructors} *)

     

       182
       178
        
       

     

       183
       183
       -
           val create : error:string -> t

     

       184
       184
       -
           (** [create ~error] creates error data. *)

     

       179
       179
       +
         val init : ?session_id:string -> ?model:string -> ?cwd:string -> unit -> t

     

       180
       180
       +
         (** [init ?session_id ?model ?cwd ()] creates an init message. *)

     

       185
       181
        
       

     

       186
       186
       -
           val error : t -> string

     

       187
       187
       -
           (** [error t] returns the error message. *)

     

       182
       182
       +
         val error : error:string -> t

     

       183
       183
       +
         (** [error ~error] creates an error message. *)

     

       188
       184
        
       

     

       189
       189
       -
           val jsont : t Jsont.t

     

       190
       190
       -
           (** [jsont] is the Jsont codec for error data. *)

     

       191
       191
       -
         end

     

       185
       185
       +
         val other : subtype:string -> t

     

       186
       186
       +
         (** [other ~subtype] creates a message with unknown subtype. *)

     

       192
       187
        
       

     

       193
       193
       -
         (** System message data variants *)

     

       194
       194
       -
         module Data : sig

     

       195
       195
       -
           type t =

     

       196
       196
       -
             | Init of Init.t      (** Init message data *)

     

       197
       197
       -
             | Error of Error.t    (** Error message data *)

     

       198
       198
       -
             | Other of Jsont.json (** Unknown subtype data *)

     

       199
       199
       -
           (** Variant type for system message data. *)

     

       188
       188
       +
         (** {2 Accessors} *)

     

       200
       189
        
       

     

       201
       201
       -
           val init : ?session_id:string -> ?model:string -> ?cwd:string -> unit -> t

     

       202
       202
       -
           (** [init ?session_id ?model ?cwd ()] creates init data. *)

     

       203
       203
       -
       

     

       204
       204
       -
           val error : error:string -> t

     

       205
       205
       -
           (** [error ~error] creates error data. *)

     

       206
       206
       -
       

     

       207
       207
       -
           val other : Jsont.json -> t

     

       208
       208
       -
           (** [other json] creates data for unknown subtypes. *)

     

       209
       209
       -
       

     

       210
       210
       -
           val session_id : t -> string option

     

       211
       211
       -
           (** [session_id t] extracts session_id from Init data, None otherwise. *)

     

       212
       212
       -
       

     

       213
       213
       -
           val model : t -> string option

     

       214
       214
       -
           (** [model t] extracts model from Init data, None otherwise. *)

     

       215
       215
       -
       

     

       216
       216
       -
           val cwd : t -> string option

     

       217
       217
       -
           (** [cwd t] extracts cwd from Init data, None otherwise. *)

     

       218
       218
       -
       

     

       219
       219
       -
           val error_msg : t -> string option

     

       220
       220
       -
           (** [error_msg t] extracts error from Error data, None otherwise. *)

     

       221
       221
       -
       

     

       222
       222
       -
           val to_json : t -> Jsont.json

     

       223
       223
       -
           (** [to_json t] converts to JSON representation. *)

     

       190
       190
       +
         val session_id : t -> string option

     

       191
       191
       +
         (** [session_id t] returns session_id from Init, None otherwise. *)

     

       224
       192
        
       

     

       225
       225
       -
           val of_json : subtype:string -> Jsont.json -> t

     

       226
       226
       -
           (** [of_json ~subtype json] parses data based on subtype. *)

     

       227
       227
       -
         end

     

       228
       228
       -
       

     

       229
       229
       -
         module Unknown : sig

     

       230
       230
       -
           type t = Jsont.json

     

       231
       231
       -
           val empty : t

     

       232
       232
       -
           val is_empty : t -> bool

     

       233
       233
       -
           val jsont : t Jsont.t

     

       234
       234
       -
         end

     

       193
       193
       +
         val model : t -> string option

     

       194
       194
       +
         (** [model t] returns model from Init, None otherwise. *)

     

       235
       195
        
       

     

       236
       236
       -
         type t

     

       237
       237
       -
         (** The type of system messages. *)

     

       196
       196
       +
         val cwd : t -> string option

     

       197
       197
       +
         (** [cwd t] returns cwd from Init, None otherwise. *)

     

       238
       198
        
       

     

       239
       239
       -
         val jsont : t Jsont.t

     

       240
       240
       -
         (** [jsont] is the Jsont codec for system messages. *)

     

       241
       241
       -
       

     

       242
       242
       -
         val create : subtype:string -> data:Data.t -> t

     

       243
       243
       -
         (** [create ~subtype ~data] creates a system message.

     

       244
       244
       -
             @param subtype The subtype of the system message

     

       245
       245
       -
             @param data Additional data for the message *)

     

       246
       246
       -
       

     

       247
       247
       -
         val init : ?session_id:string -> ?model:string -> ?cwd:string -> unit -> t

     

       248
       248
       -
         (** [init ?session_id ?model ?cwd ()] creates a system init message. *)

     

       249
       249
       -
       

     

       250
       250
       -
         val error : error:string -> t

     

       251
       251
       -
         (** [error ~error] creates a system error message. *)

     

       199
       199
       +
         val error_msg : t -> string option

     

       200
       200
       +
         (** [error_msg t] returns error from Error, None otherwise. *)

     

       252
       201
        
       

     

       253
       202
        
         val subtype : t -> string

     

       254
       254
       -
         (** [subtype t] returns the subtype of the system message. *)

     

       255
       255
       -
       

     

       256
       256
       -
         val data : t -> Data.t

     

       257
       257
       -
         (** [data t] returns the additional data of the system message. *)

     

       203
       203
       +
         (** [subtype t] returns the subtype string. *)

     

       258
       204
        
       

     

       259
       205
        
         val unknown : t -> Unknown.t

     

       260
       260
       -
         (** [unknown t] returns the unknown fields preserved from JSON. *)

     

       206
       206
       +
         (** [unknown t] returns the unknown fields. *)

     

       207
       207
       +
       

     

       208
       208
       +
         (** {2 Conversion} *)

     

       261
       209
        
       

     

       262
       210
        
         val to_json : t -> Jsont.json

     

       263
       263
       -
         (** [to_json t] converts the system message to its JSON representation. *)

     

       211
       211
       +
         (** [to_json t] converts to JSON representation. *)

     

       264
       212
        
       

     

       265
       213
        
         val of_json : Jsont.json -> t

     

       266
       266
       -
         (** [of_json json] parses a system message from JSON.

     

       267
       267
       -
             @raise Invalid_argument if the JSON is not a valid system message. *)

     

       214
       214
       +
         (** [of_json json] parses from JSON.

     

       215
       215
       +
             @raise Invalid_argument if invalid. *)

     

       268
       216
        
       

     

       269
       217
        
         val pp : Format.formatter -> t -> unit

     

       270
       270
       -
         (** [pp fmt t] pretty-prints the system message. *)

     

       218
       218
       +
         (** [pp fmt t] pretty-prints the message. *)

     

       271
       219
        
       end

     

       272
       220
        
       

     

       273
       221
        
       (** {1 Result Messages} *)

     
···

       277
       225
        
       

     

       278
       226
        
         module Usage : sig

     

       279
       227
        
           (** Usage statistics for API calls. *)

     

       280
       280
       -
       

     

       281
       281
       -
           module Unknown : sig

     

       282
       282
       -
             type t = Jsont.json

     

       283
       283
       -
             val empty : t

     

       284
       284
       -
             val is_empty : t -> bool

     

       285
       285
       -
             val jsont : t Jsont.t

     

       286
       286
       -
           end

     

       287
       228
        
       

     

       288
       229
        
           type t

     

       289
       230
        
           (** Type for usage statistics. *)

     
···

       334
       275
        
       

     

       335
       276
        
           val of_json : Jsont.json -> t

     

       336
       277
        
           (** [of_json json] parses from JSON. Internal use only. *)

     

       337
       337
       -
         end

     

       338
       338
       -
       

     

       339
       339
       -
         module Unknown : sig

     

       340
       340
       -
           type t = Jsont.json

     

       341
       341
       -
           val empty : t

     

       342
       342
       -
           val is_empty : t -> bool

     

       343
       343
       -
           val jsont : t Jsont.t

     

       344
       278
        
         end

     

       345
       279
        
       

     

       346
       280
        
         type t

     
···

       445
       379
        
       

     

       446
       380
        
       val assistant_text : text:string -> model:string -> ?error:Assistant.error -> unit -> t

     

       447
       381
        
       (** [assistant_text ~text ~model ?error ()] creates an assistant message with only text content. *)

     

       448
       448
       -
       

     

       449
       449
       -
       val system : subtype:string -> data:System.Data.t -> t

     

       450
       450
       -
       (** [system ~subtype ~data] creates a system message. *)

     

       451
       382
        
       

     

       452
       383
        
       val system_init : session_id:string -> t

     

       453
       384
        
       (** [system_init ~session_id] creates a system init message. *)

-28

claudeio/lib/permissions.ml

···

       68
       68
        
       

     

       69
       69
        
       (** Permission rules *)

     

       70
       70
        
       module Rule = struct

     

       71
       71
       -
         module Unknown = struct

     

       72
       72
       -
           type t = Jsont.json

     

       73
       73
       -
           let empty = Jsont.Object ([], Jsont.Meta.none)

     

       74
       74
       -
           let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       75
       75
       -
           let jsont = Jsont.json

     

       76
       76
       -
         end

     

       77
       77
       -
       

     

       78
       71
        
         type t = {

     

       79
       72
        
           tool_name : string;

     

       80
       73
        
           rule_content : string option;

     
···

       163
       156
        
             "addDirectories", Add_directories;

     

       164
       157
        
             "removeDirectories", Remove_directories;

     

       165
       158
        
           ]

     

       166
       166
       -
         

     

       167
       167
       -
         module Unknown = struct

     

       168
       168
       -
           type t = Jsont.json

     

       169
       169
       -
           let empty = Jsont.Object ([], Jsont.Meta.none)

     

       170
       170
       -
           let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       171
       171
       -
           let jsont = Jsont.json

     

       172
       172
       -
         end

     

       173
       159
        
       

     

       174
       160
        
         type t = {

     

       175
       161
        
           update_type : update_type;

     
···

       219
       205
        
       

     

       220
       206
        
       (** Permission context for callbacks *)

     

       221
       207
        
       module Context = struct

     

       222
       222
       -
         module Unknown = struct

     

       223
       223
       -
           type t = Jsont.json

     

       224
       224
       -
           let empty = Jsont.Object ([], Jsont.Meta.none)

     

       225
       225
       -
           let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       226
       226
       -
           let jsont = Jsont.json

     

       227
       227
       -
         end

     

       228
       228
       -
       

     

       229
       208
        
         type t = {

     

       230
       209
        
           suggestions : Update.t list;

     

       231
       210
        
           unknown : Unknown.t;

     
···

       249
       228
        
       

     

       250
       229
        
       (** Permission results *)

     

       251
       230
        
       module Result = struct

     

       252
       252
       -
         module Unknown = struct

     

       253
       253
       -
           type t = Jsont.json

     

       254
       254
       -
           let empty = Jsont.Object ([], Jsont.Meta.none)

     

       255
       255
       -
           let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       256
       256
       -
           let jsont = Jsont.json

     

       257
       257
       -
         end

     

       258
       258
       -
       

     

       259
       231
        
         type t =

     

       260
       232
        
           | Allow of {

     

       261
       233
        
               updated_input : Jsont.json option;

-28

claudeio/lib/permissions.mli

···

       63
       63
        
       module Rule : sig

     

       64
       64
        
         (** Rules define specific permissions for tools. *)

     

       65
       65
        
       

     

       66
       66
       -
         module Unknown : sig

     

       67
       67
       -
           type t = Jsont.json

     

       68
       68
       -
           val empty : t

     

       69
       69
       -
           val is_empty : t -> bool

     

       70
       70
       -
           val jsont : t Jsont.t

     

       71
       71
       -
         end

     

       72
       72
       -
       

     

       73
       66
        
         type t = {

     

       74
       67
        
           tool_name : string;  (** Name of the tool *)

     

       75
       68
        
           rule_content : string option;  (** Optional rule specification *)

     
···

       119
       112
        
           | Add_directories  (** Add allowed directories *)

     

       120
       113
        
           | Remove_directories  (** Remove allowed directories *)

     

       121
       114
        
         (** The type of permission update. *)

     

       122
       122
       -
       

     

       123
       123
       -
         module Unknown : sig

     

       124
       124
       -
           type t = Jsont.json

     

       125
       125
       -
           val empty : t

     

       126
       126
       -
           val is_empty : t -> bool

     

       127
       127
       -
           val jsont : t Jsont.t

     

       128
       128
       -
         end

     

       129
       115
        
       

     

       130
       116
        
         type t

     

       131
       117
        
         (** The type of permission updates. *)

     
···

       182
       168
        
       module Context : sig

     

       183
       169
        
         (** Context provided to permission callbacks. *)

     

       184
       170
        
       

     

       185
       185
       -
         module Unknown : sig

     

       186
       186
       -
           type t = Jsont.json

     

       187
       187
       -
           val empty : t

     

       188
       188
       -
           val is_empty : t -> bool

     

       189
       189
       -
           val jsont : t Jsont.t

     

       190
       190
       -
         end

     

       191
       191
       -
       

     

       192
       171
        
         type t = {

     

       193
       172
        
           suggestions : Update.t list;  (** Suggested permission updates *)

     

       194
       173
        
           unknown : Unknown.t;  (** Unknown fields *)

     
···

       217
       196
        
       

     

       218
       197
        
       module Result : sig

     

       219
       198
        
         (** Results of permission checks. *)

     

       220
       220
       -
       

     

       221
       221
       -
         module Unknown : sig

     

       222
       222
       -
           type t = Jsont.json

     

       223
       223
       -
           val empty : t

     

       224
       224
       -
           val is_empty : t -> bool

     

       225
       225
       -
           val jsont : t Jsont.t

     

       226
       226
       -
         end

     

       227
       199
        
       

     

       228
       200
        
         type t =

     

       229
       201
        
           | Allow of {

-28

claudeio/lib/sdk_control.ml

···

       54
       54
        
       end

     

       55
       55
        
       

     

       56
       56
        
       module Request = struct

     

       57
       57
       -
         module Unknown = struct

     

       58
       58
       -
           type t = Jsont.json

     

       59
       59
       -
           let empty = Jsont.Object ([], Jsont.Meta.none)

     

       60
       60
       -
           let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       61
       61
       -
           let jsont = Jsont.json

     

       62
       62
       -
         end

     

       63
       63
       -
       

     

       64
       57
        
         type interrupt = {

     

       65
       58
        
           subtype : [`Interrupt];

     

       66
       59
        
           unknown : Unknown.t;

     
···

       280
       273
        
       end

     

       281
       274
        
       

     

       282
       275
        
       module Response = struct

     

       283
       283
       -
         module Unknown = struct

     

       284
       284
       -
           type t = Jsont.json

     

       285
       285
       -
           let empty = Jsont.Object ([], Jsont.Meta.none)

     

       286
       286
       -
           let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       287
       287
       -
           let jsont = Jsont.json

     

       288
       288
       -
         end

     

       289
       289
       -
       

     

       290
       276
        
         type success = {

     

       291
       277
        
           subtype : [`Success];

     

       292
       278
        
           request_id : string;

     
···

       371
       357
        
                 e.request_id e.error

     

       372
       358
        
       end

     

       373
       359
        
       

     

       374
       374
       -
       module Unknown = struct

     

       375
       375
       -
         type t = Jsont.json

     

       376
       376
       -
         let empty = Jsont.Object ([], Jsont.Meta.none)

     

       377
       377
       -
         let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       378
       378
       -
         let jsont = Jsont.json

     

       379
       379
       -
       end

     

       380
       380
       -
       

     

       381
       360
        
       type control_request = {

     

       382
       361
        
         type_ : [`Control_request];

     

       383
       362
        
         request_id : string;

     
···

       466
       445
        
       

     

       467
       446
        
       (** Server information *)

     

       468
       447
        
       module Server_info = struct

     

       469
       469
       -
         module Unknown = struct

     

       470
       470
       -
           type t = Jsont.json

     

       471
       471
       -
           let empty = Jsont.Object ([], Jsont.Meta.none)

     

       472
       472
       -
           let is_empty = function Jsont.Object ([], _) -> true | _ -> false

     

       473
       473
       -
           let jsont = Jsont.json

     

       474
       474
       -
         end

     

       475
       475
       -
       

     

       476
       448
        
         type t = {

     

       477
       449
        
           version : string;

     

       478
       450
        
           capabilities : string list;

-28

claudeio/lib/sdk_control.mli

···

       131
       131
        
       module Request : sig

     

       132
       132
        
         (** SDK control request types. *)

     

       133
       133
        
       

     

       134
       134
       -
         module Unknown : sig

     

       135
       135
       -
           type t = Jsont.json

     

       136
       136
       -
           val empty : t

     

       137
       137
       -
           val is_empty : t -> bool

     

       138
       138
       -
           val jsont : t Jsont.t

     

       139
       139
       -
         end

     

       140
       140
       -
       

     

       141
       134
        
         type interrupt = {

     

       142
       135
        
           subtype : [`Interrupt];

     

       143
       136
        
           unknown : Unknown.t;

     
···

       248
       241
        
       

     

       249
       242
        
       module Response : sig

     

       250
       243
        
         (** SDK control response types. *)

     

       251
       251
       -
       

     

       252
       252
       -
         module Unknown : sig

     

       253
       253
       -
           type t = Jsont.json

     

       254
       254
       -
           val empty : t

     

       255
       255
       -
           val is_empty : t -> bool

     

       256
       256
       -
           val jsont : t Jsont.t

     

       257
       257
       -
         end

     

       258
       244
        
       

     

       259
       245
        
         type success = {

     

       260
       246
        
           subtype : [`Success];

     
···

       292
       278
        
       

     

       293
       279
        
       (** {1 Control Messages} *)

     

       294
       280
        
       

     

       295
       295
       -
       module Unknown : sig

     

       296
       296
       -
         type t = Jsont.json

     

       297
       297
       -
         val empty : t

     

       298
       298
       -
         val is_empty : t -> bool

     

       299
       299
       -
         val jsont : t Jsont.t

     

       300
       300
       -
       end

     

       301
       301
       -
       

     

       302
       281
        
       type control_request = {

     

       303
       282
        
         type_ : [`Control_request];

     

       304
       283
        
         request_id : string;

     
···

       369
       348
        
       

     

       370
       349
        
       module Server_info : sig

     

       371
       350
        
         (** Server information and capabilities. *)

     

       372
       372
       -
       

     

       373
       373
       -
         module Unknown : sig

     

       374
       374
       -
           type t = Jsont.json

     

       375
       375
       -
           val empty : t

     

       376
       376
       -
           val is_empty : t -> bool

     

       377
       377
       -
           val jsont : t Jsont.t

     

       378
       378
       -
         end

     

       379
       351
        
       

     

       380
       352
        
         type t = {

     

       381
       353
        
           version : string;

+20

claudeio/lib/unknown.ml

···

       1
       1
       +
       (** Unknown fields for capturing extra JSON object members.

     

       2
       2
       +
       

     

       3
       3
       +
           This module provides a type and utilities for preserving unknown/extra

     

       4
       4
       +
           fields when parsing JSON objects with jsont. Use with

     

       5
       5
       +
           [Jsont.Object.keep_unknown] to capture fields not explicitly defined

     

       6
       6
       +
           in your codec. *)

     

       7
       7
       +
       

     

       8
       8
       +
       type t = Jsont.json

     

       9
       9
       +
       (** The type of unknown fields - stored as raw JSON. *)

     

       10
       10
       +
       

     

       11
       11
       +
       let empty = Jsont.Object ([], Jsont.Meta.none)

     

       12
       12
       +
       (** An empty unknown fields value (empty JSON object). *)

     

       13
       13
       +
       

     

       14
       14
       +
       let is_empty = function

     

       15
       15
       +
         | Jsont.Object ([], _) -> true

     

       16
       16
       +
         | _ -> false

     

       17
       17
       +
       (** [is_empty t] returns [true] if there are no unknown fields. *)

     

       18
       18
       +
       

     

       19
       19
       +
       let jsont = Jsont.json

     

       20
       20
       +
       (** Codec for unknown fields. *)

+18

claudeio/lib/unknown.mli

···

       1
       1
       +
       (** Unknown fields for capturing extra JSON object members.

     

       2
       2
       +
       

     

       3
       3
       +
           This module provides a type and utilities for preserving unknown/extra

     

       4
       4
       +
           fields when parsing JSON objects with jsont. Use with

     

       5
       5
       +
           [Jsont.Object.keep_unknown] to capture fields not explicitly defined

     

       6
       6
       +
           in your codec. *)

     

       7
       7
       +
       

     

       8
       8
       +
       type t = Jsont.json

     

       9
       9
       +
       (** The type of unknown fields - stored as raw JSON. *)

     

       10
       10
       +
       

     

       11
       11
       +
       val empty : t

     

       12
       12
       +
       (** An empty unknown fields value (empty JSON object). *)

     

       13
       13
       +
       

     

       14
       14
       +
       val is_empty : t -> bool

     

       15
       15
       +
       (** [is_empty t] returns [true] if there are no unknown fields. *)

     

       16
       16
       +
       

     

       17
       17
       +
       val jsont : t Jsont.t

     

       18
       18
       +
       (** Codec for unknown fields. *)