commit 0353e16af92683e09fc7f4dcefb43f783fddb49e · anil.recoil.org/slop

+8 -6

claudeio/lib/client.ml

···

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

     

       85
       85
        
                       (match msg with

     

       86
       86
        
                       | Message.System sys when Message.System.subtype sys = "init" ->

     

       87
       87
       -
                           (try

     

       88
       88
       -
                             let data = Message.System.data sys in

     

       89
       89
       -
                             let session_id = Ezjsonm.find data ["session_id"] |> Ezjsonm.get_string in

     

       87
       87
       +
                           (match Message.System.Data.get_string (Message.System.data sys) "session_id" with

     

       88
       88
       +
                           | Some session_id ->

     

       90
       89
        
                             t.session_id <- Some session_id;

     

       91
       90
        
                             Log.info (fun m -> m "Session ID: %s" session_id)

     

       92
       92
       -
                           with Not_found -> ())

     

       91
       91
       +
                           | None -> ())

     

       93
       92
        
                       | _ -> ());

     

       94
       93
        
                       

     

       95
       94
        
                       Seq.Cons (msg, loop)

     
···

       115
       114
        
         let msg = Message.user_string prompt in

     

       116
       115
        
         Transport.send t.transport (Message.to_json msg)

     

       117
       116
        
       

     

       118
       118
       -
       let send_message t json =

     

       119
       119
       -
         Transport.send t.transport json

     

       117
       117
       +
       let send_message t msg =

     

       118
       118
       +
         Transport.send t.transport (Message.to_json msg)

     

       119
       119
       +
       

     

       120
       120
       +
       let send_user_message t user_msg =

     

       121
       121
       +
         Transport.send t.transport (Message.User.to_json user_msg)

     

       120
       122
        
       

     

       121
       123
        
       let receive t =

     

       122
       124
        
         handle_messages t

+2 -1

claudeio/lib/client.mli

···

       10
       10
        
         unit -> t

     

       11
       11
        
       

     

       12
       12
        
       val query : t -> string -> unit

     

       13
       13
       -
       val send_message : t -> Ezjsonm.value -> unit

     

       13
       13
       +
       val send_message : t -> Message.t -> unit

     

       14
       14
       +
       val send_user_message : t -> Message.User.t -> unit

     

       14
       15
        
       

     

       15
       16
        
       val receive : t -> Message.t Seq.t

     

       16
       17
        
       val receive_all : t -> Message.t list

+49 -4

claudeio/lib/content_block.ml

···

       27
       27
        
       end

     

       28
       28
        
       

     

       29
       29
        
       module Tool_use = struct

     

       30
       30
       +
         module Input = struct

     

       31
       31
       +
           type t = value

     

       32
       32
       +
           

     

       33
       33
       +
           let of_string_pairs pairs =

     

       34
       34
       +
             `O (List.map (fun (k, v) -> (k, `String v)) pairs)

     

       35
       35
       +
           

     

       36
       36
       +
           let of_assoc assoc = `O assoc

     

       37
       37
       +
           

     

       38
       38
       +
           let get_string t key =

     

       39
       39
       +
             match t with

     

       40
       40
       +
             | `O fields ->

     

       41
       41
       +
                 (try Some (get_string (List.assoc key fields))

     

       42
       42
       +
                  with Not_found | _ -> None)

     

       43
       43
       +
             | _ -> None

     

       44
       44
       +
           

     

       45
       45
       +
           let get_int t key =

     

       46
       46
       +
             match t with

     

       47
       47
       +
             | `O fields ->

     

       48
       48
       +
                 (try Some (get_int (List.assoc key fields))

     

       49
       49
       +
                  with Not_found | _ -> None)

     

       50
       50
       +
             | _ -> None

     

       51
       51
       +
           

     

       52
       52
       +
           let get_bool t key =

     

       53
       53
       +
             match t with

     

       54
       54
       +
             | `O fields ->

     

       55
       55
       +
                 (try Some (get_bool (List.assoc key fields))

     

       56
       56
       +
                  with Not_found | _ -> None)

     

       57
       57
       +
             | _ -> None

     

       58
       58
       +
           

     

       59
       59
       +
           let get_float t key =

     

       60
       60
       +
             match t with

     

       61
       61
       +
             | `O fields ->

     

       62
       62
       +
                 (try Some (get_float (List.assoc key fields))

     

       63
       63
       +
                  with Not_found | _ -> None)

     

       64
       64
       +
             | _ -> None

     

       65
       65
       +
           

     

       66
       66
       +
           let keys t =

     

       67
       67
       +
             match t with

     

       68
       68
       +
             | `O fields -> List.map fst fields

     

       69
       69
       +
             | _ -> []

     

       70
       70
       +
           

     

       71
       71
       +
           let to_json t = t

     

       72
       72
       +
           let of_json json = json

     

       73
       73
       +
         end

     

       74
       74
       +
         

     

       30
       75
        
         type t = {

     

       31
       76
        
           id : string;

     

       32
       77
        
           name : string;

     

       33
       33
       -
           input : value;

     

       78
       78
       +
           input : Input.t;

     

       34
       79
        
         }

     

       35
       80
        
         

     

       36
       81
        
         let create ~id ~name ~input = { id; name; input }

     
···

       43
       88
        
             ("type", `String "tool_use");

     

       44
       89
        
             ("id", `String t.id);

     

       45
       90
        
             ("name", `String t.name);

     

       46
       46
       -
             ("input", t.input);

     

       91
       91
       +
             ("input", Input.to_json t.input);

     

       47
       92
        
           ]

     

       48
       93
        
         

     

       49
       94
        
         let of_json = function

     

       50
       95
        
           | `O fields ->

     

       51
       96
        
               let id = get_string (List.assoc "id" fields) in

     

       52
       97
        
               let name = get_string (List.assoc "name" fields) in

     

       53
       53
       -
               let input = List.assoc "input" fields in

     

       98
       98
       +
               let input = Input.of_json (List.assoc "input" fields) in

     

       54
       99
        
               { id; name; input }

     

       55
       100
        
           | _ -> raise (Invalid_argument "Tool_use.of_json: expected object")

     

       56
       101
        
         

     

       57
       102
        
         let pp fmt t =

     

       58
       103
        
           Fmt.pf fmt "@[<2>Tool_use@ { id = %S;@ name = %S;@ input = %a }@]"

     

       59
       59
       -
             t.id t.name pp_json t.input

     

       104
       104
       +
             t.id t.name pp_json (Input.to_json t.input)

     

       60
       105
        
       end

     

       61
       106
        
       

     

       62
       107
        
       module Tool_result = struct

+49 -17

claudeio/lib/content_block.mli

···

       3
       3
        
           This module defines the various types of content blocks that can appear

     

       4
       4
        
           in Claude messages, including text, tool use, tool results, and thinking blocks. *)

     

       5
       5
        
       

     

       6
       6
       -
       open Ezjsonm

     

       7
       7
       -
       

     

       8
       6
        
       (** The log source for content block operations *)

     

       9
       7
        
       val src : Logs.Src.t

     

       10
       8
        
       

     
···

       22
       20
        
         val text : t -> string

     

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

     

       24
       22
        
         

     

       25
       25
       -
         val to_json : t -> value

     

       23
       23
       +
         val to_json : t -> Ezjsonm.value

     

       26
       24
        
         (** [to_json t] converts the text block to its JSON representation. *)

     

       27
       25
        
         

     

       28
       28
       -
         val of_json : value -> t

     

       26
       26
       +
         val of_json : Ezjsonm.value -> t

     

       29
       27
        
         (** [of_json json] parses a text block from JSON. 

     

       30
       28
        
             @raise Invalid_argument if the JSON is not a valid text block. *)

     

       31
       29
        
         

     
···

       38
       36
        
       module Tool_use : sig

     

       39
       37
        
         (** Tool invocation requests from the assistant. *)

     

       40
       38
        
         

     

       39
       39
       +
         module Input : sig

     

       40
       40
       +
           (** Tool input parameters. *)

     

       41
       41
       +
           

     

       42
       42
       +
           type t

     

       43
       43
       +
           (** Abstract type for tool inputs. *)

     

       44
       44
       +
           

     

       45
       45
       +
           val of_string_pairs : (string * string) list -> t

     

       46
       46
       +
           (** [of_string_pairs pairs] creates tool input from string key-value pairs. *)

     

       47
       47
       +
           

     

       48
       48
       +
           val of_assoc : (string * Ezjsonm.value) list -> t

     

       49
       49
       +
           (** [of_assoc assoc] creates tool input from an association list. *)

     

       50
       50
       +
           

     

       51
       51
       +
           val get_string : t -> string -> string option

     

       52
       52
       +
           (** [get_string t key] returns the string value for [key], if present. *)

     

       53
       53
       +
           

     

       54
       54
       +
           val get_int : t -> string -> int option

     

       55
       55
       +
           (** [get_int t key] returns the integer value for [key], if present. *)

     

       56
       56
       +
           

     

       57
       57
       +
           val get_bool : t -> string -> bool option

     

       58
       58
       +
           (** [get_bool t key] returns the boolean value for [key], if present. *)

     

       59
       59
       +
           

     

       60
       60
       +
           val get_float : t -> string -> float option

     

       61
       61
       +
           (** [get_float t key] returns the float value for [key], if present. *)

     

       62
       62
       +
           

     

       63
       63
       +
           val keys : t -> string list

     

       64
       64
       +
           (** [keys t] returns all keys in the input. *)

     

       65
       65
       +
           

     

       66
       66
       +
           val to_json : t -> Ezjsonm.value

     

       67
       67
       +
           (** [to_json t] converts to JSON representation. Internal use only. *)

     

       68
       68
       +
           

     

       69
       69
       +
           val of_json : Ezjsonm.value -> t

     

       70
       70
       +
           (** [of_json json] parses from JSON. Internal use only. *)

     

       71
       71
       +
         end

     

       72
       72
       +
         

     

       41
       73
        
         type t

     

       42
       74
        
         (** The type of tool use blocks. *)

     

       43
       75
        
         

     

       44
       44
       -
         val create : id:string -> name:string -> input:value -> t

     

       76
       76
       +
         val create : id:string -> name:string -> input:Input.t -> t

     

       45
       77
        
         (** [create ~id ~name ~input] creates a new tool use block.

     

       46
       78
        
             @param id Unique identifier for this tool invocation

     

       47
       79
        
             @param name Name of the tool to invoke

     

       48
       48
       -
             @param input JSON parameters for the tool *)

     

       80
       80
       +
             @param input Parameters for the tool *)

     

       49
       81
        
         

     

       50
       82
        
         val id : t -> string

     

       51
       83
        
         (** [id t] returns the unique identifier of the tool use. *)

     
···

       53
       85
        
         val name : t -> string

     

       54
       86
        
         (** [name t] returns the name of the tool being invoked. *)

     

       55
       87
        
         

     

       56
       56
       -
         val input : t -> value

     

       57
       57
       -
         (** [input t] returns the JSON input parameters for the tool. *)

     

       88
       88
       +
         val input : t -> Input.t

     

       89
       89
       +
         (** [input t] returns the input parameters for the tool. *)

     

       58
       90
        
         

     

       59
       59
       -
         val to_json : t -> value

     

       91
       91
       +
         val to_json : t -> Ezjsonm.value

     

       60
       92
        
         (** [to_json t] converts the tool use block to its JSON representation. *)

     

       61
       93
        
         

     

       62
       62
       -
         val of_json : value -> t

     

       94
       94
       +
         val of_json : Ezjsonm.value -> t

     

       63
       95
        
         (** [of_json json] parses a tool use block from JSON.

     

       64
       96
        
             @raise Invalid_argument if the JSON is not a valid tool use block. *)

     

       65
       97
        
         

     
···

       90
       122
        
         val is_error : t -> bool option

     

       91
       123
        
         (** [is_error t] returns whether this result represents an error. *)

     

       92
       124
        
         

     

       93
       93
       -
         val to_json : t -> value

     

       125
       125
       +
         val to_json : t -> Ezjsonm.value

     

       94
       126
        
         (** [to_json t] converts the tool result block to its JSON representation. *)

     

       95
       127
        
         

     

       96
       96
       -
         val of_json : value -> t

     

       128
       128
       +
         val of_json : Ezjsonm.value -> t

     

       97
       129
        
         (** [of_json json] parses a tool result block from JSON.

     

       98
       130
        
             @raise Invalid_argument if the JSON is not a valid tool result block. *)

     

       99
       131
        
         

     
···

       120
       152
        
         val signature : t -> string

     

       121
       153
        
         (** [signature t] returns the cryptographic signature. *)

     

       122
       154
        
         

     

       123
       123
       -
         val to_json : t -> value

     

       155
       155
       +
         val to_json : t -> Ezjsonm.value

     

       124
       156
        
         (** [to_json t] converts the thinking block to its JSON representation. *)

     

       125
       157
        
         

     

       126
       126
       -
         val of_json : value -> t

     

       158
       158
       +
         val of_json : Ezjsonm.value -> t

     

       127
       159
        
         (** [of_json json] parses a thinking block from JSON.

     

       128
       160
        
             @raise Invalid_argument if the JSON is not a valid thinking block. *)

     

       129
       161
        
         

     
···

       143
       175
        
       val text : string -> t

     

       144
       176
        
       (** [text s] creates a text content block. *)

     

       145
       177
        
       

     

       146
       146
       -
       val tool_use : id:string -> name:string -> input:value -> t

     

       178
       178
       +
       val tool_use : id:string -> name:string -> input:Tool_use.Input.t -> t

     

       147
       179
        
       (** [tool_use ~id ~name ~input] creates a tool use content block. *)

     

       148
       180
        
       

     

       149
       181
        
       val tool_result : tool_use_id:string -> ?content:string -> ?is_error:bool -> unit -> t

     
···

       152
       184
        
       val thinking : thinking:string -> signature:string -> t

     

       153
       185
        
       (** [thinking ~thinking ~signature] creates a thinking content block. *)

     

       154
       186
        
       

     

       155
       155
       -
       val to_json : t -> value

     

       187
       187
       +
       val to_json : t -> Ezjsonm.value

     

       156
       188
        
       (** [to_json t] converts any content block to its JSON representation. *)

     

       157
       189
        
       

     

       158
       158
       -
       val of_json : value -> t

     

       190
       190
       +
       val of_json : Ezjsonm.value -> t

     

       159
       191
        
       (** [of_json json] parses a content block from JSON.

     

       160
       192
        
           @raise Invalid_argument if the JSON is not a valid content block. *)

     

       161
       193

+82 -8

claudeio/lib/message.ml

···

       97
       97
        
       end

     

       98
       98
        
       

     

       99
       99
        
       module System = struct

     

       100
       100
       +
         module Data = struct

     

       101
       101
       +
           type t = value

     

       102
       102
       +
           

     

       103
       103
       +
           let empty = `O []

     

       104
       104
       +
           

     

       105
       105
       +
           let of_assoc assoc = `O assoc

     

       106
       106
       +
           

     

       107
       107
       +
           let get_string t key =

     

       108
       108
       +
             match t with

     

       109
       109
       +
             | `O fields ->

     

       110
       110
       +
                 (try Some (get_string (List.assoc key fields))

     

       111
       111
       +
                  with Not_found | _ -> None)

     

       112
       112
       +
             | _ -> None

     

       113
       113
       +
           

     

       114
       114
       +
           let get_int t key =

     

       115
       115
       +
             match t with

     

       116
       116
       +
             | `O fields ->

     

       117
       117
       +
                 (try Some (get_int (List.assoc key fields))

     

       118
       118
       +
                  with Not_found | _ -> None)

     

       119
       119
       +
             | _ -> None

     

       120
       120
       +
           

     

       121
       121
       +
           let get_bool t key =

     

       122
       122
       +
             match t with

     

       123
       123
       +
             | `O fields ->

     

       124
       124
       +
                 (try Some (get_bool (List.assoc key fields))

     

       125
       125
       +
                  with Not_found | _ -> None)

     

       126
       126
       +
             | _ -> None

     

       127
       127
       +
           

     

       128
       128
       +
           let to_json t = t

     

       129
       129
       +
           let of_json json = json

     

       130
       130
       +
         end

     

       131
       131
       +
         

     

       100
       132
        
         type t = {

     

       101
       133
        
           subtype : string;

     

       102
       102
       -
           data : value;

     

       134
       134
       +
           data : Data.t;

     

       103
       135
        
         }

     

       104
       136
        
         

     

       105
       137
        
         let create ~subtype ~data = { subtype; data }

     
···

       110
       142
        
           `O [

     

       111
       143
        
             ("type", `String "system");

     

       112
       144
        
             ("subtype", `String t.subtype);

     

       113
       113
       -
             ("data", t.data);

     

       145
       145
       +
             ("data", Data.to_json t.data);

     

       114
       146
        
           ]

     

       115
       147
        
         

     

       116
       148
        
         let of_json = function

     

       117
       149
        
           | `O fields ->

     

       118
       150
        
               let subtype = get_string (List.assoc "subtype" fields) in

     

       119
       119
       -
               let data = try List.assoc "data" fields with Not_found -> `O fields in

     

       151
       151
       +
               let data = Data.of_json (try List.assoc "data" fields with Not_found -> `O fields) in

     

       120
       152
        
               { subtype; data }

     

       121
       153
        
           | _ -> raise (Invalid_argument "System.of_json: expected object")

     

       122
       154
        
         

     

       123
       155
        
         let pp fmt t =

     

       124
       156
        
           Fmt.pf fmt "@[<2>System@ { subtype = %S;@ data = %a }@]"

     

       125
       157
        
             t.subtype

     

       126
       126
       -
             pp_json t.data

     

       158
       158
       +
             pp_json (Data.to_json t.data)

     

       127
       159
        
       end

     

       128
       160
        
       

     

       129
       161
        
       module Result = struct

     

       162
       162
       +
         module Usage = struct

     

       163
       163
       +
           type t = value

     

       164
       164
       +
           

     

       165
       165
       +
           let input_tokens t =

     

       166
       166
       +
             match t with

     

       167
       167
       +
             | `O fields ->

     

       168
       168
       +
                 (try Some (get_int (List.assoc "input_tokens" fields))

     

       169
       169
       +
                  with Not_found | _ -> None)

     

       170
       170
       +
             | _ -> None

     

       171
       171
       +
           

     

       172
       172
       +
           let output_tokens t =

     

       173
       173
       +
             match t with

     

       174
       174
       +
             | `O fields ->

     

       175
       175
       +
                 (try Some (get_int (List.assoc "output_tokens" fields))

     

       176
       176
       +
                  with Not_found | _ -> None)

     

       177
       177
       +
             | _ -> None

     

       178
       178
       +
           

     

       179
       179
       +
           let total_tokens t =

     

       180
       180
       +
             match t with

     

       181
       181
       +
             | `O fields ->

     

       182
       182
       +
                 (try Some (get_int (List.assoc "total_tokens" fields))

     

       183
       183
       +
                  with Not_found | _ -> None)

     

       184
       184
       +
             | _ -> None

     

       185
       185
       +
           

     

       186
       186
       +
           let cache_creation_input_tokens t =

     

       187
       187
       +
             match t with

     

       188
       188
       +
             | `O fields ->

     

       189
       189
       +
                 (try Some (get_int (List.assoc "cache_creation_input_tokens" fields))

     

       190
       190
       +
                  with Not_found | _ -> None)

     

       191
       191
       +
             | _ -> None

     

       192
       192
       +
           

     

       193
       193
       +
           let cache_read_input_tokens t =

     

       194
       194
       +
             match t with

     

       195
       195
       +
             | `O fields ->

     

       196
       196
       +
                 (try Some (get_int (List.assoc "cache_read_input_tokens" fields))

     

       197
       197
       +
                  with Not_found | _ -> None)

     

       198
       198
       +
             | _ -> None

     

       199
       199
       +
           

     

       200
       200
       +
           let to_json t = t

     

       201
       201
       +
           let of_json json = json

     

       202
       202
       +
         end

     

       203
       203
       +
         

     

       130
       204
        
         type t = {

     

       131
       205
        
           subtype : string;

     

       132
       206
        
           duration_ms : int;

     
···

       135
       209
        
           num_turns : int;

     

       136
       210
        
           session_id : string;

     

       137
       211
        
           total_cost_usd : float option;

     

       138
       138
       -
           usage : value option;

     

       212
       212
       +
           usage : Usage.t option;

     

       139
       213
        
           result : string option;

     

       140
       214
        
         }

     

       141
       215
        
         

     
···

       169
       243
        
             | None -> fields

     

       170
       244
        
           in

     

       171
       245
        
           let fields = match t.usage with

     

       172
       172
       -
             | Some usage -> ("usage", usage) :: fields

     

       246
       246
       +
             | Some usage -> ("usage", Usage.to_json usage) :: fields

     

       173
       247
        
             | None -> fields

     

       174
       248
        
           in

     

       175
       249
        
           let fields = match t.result with

     
···

       190
       264
        
                 try Some (get_float (List.assoc "total_cost_usd" fields))

     

       191
       265
        
                 with Not_found -> None

     

       192
       266
        
               in

     

       193
       193
       -
               let usage = List.assoc_opt "usage" fields in

     

       267
       267
       +
               let usage = Option.map Usage.of_json (List.assoc_opt "usage" fields) in

     

       194
       268
        
               let result = 

     

       195
       269
        
                 try Some (get_string (List.assoc "result" fields))

     

       196
       270
        
                 with Not_found -> None

     
···

       206
       280
        
             t.subtype t.duration_ms t.duration_api_ms t.is_error t.num_turns

     

       207
       281
        
             t.session_id

     

       208
       282
        
             Fmt.(option float) t.total_cost_usd

     

       209
       209
       -
             Fmt.(option pp_json) t.usage

     

       283
       283
       +
             Fmt.(option (fun fmt u -> pp_json fmt (Usage.to_json u))) t.usage

     

       210
       284
        
             Fmt.(option string) t.result

     

       211
       285
        
       end

     

       212
       286

+73 -19

claudeio/lib/message.mli

···

       4
       4
        
           received from Claude, including user input, assistant responses, system 

     

       5
       5
        
           messages, and result metadata. *)

     

       6
       6
        
       

     

       7
       7
       -
       open Ezjsonm

     

       8
       8
       -
       

     

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

     

       10
       8
        
       val src : Logs.Src.t

     

       11
       9
        
       

     
···

       31
       29
        
         val content : t -> content

     

       32
       30
        
         (** [content t] returns the content of the user message. *)

     

       33
       31
        
         

     

       34
       34
       -
         val to_json : t -> value

     

       32
       32
       +
         val to_json : t -> Ezjsonm.value

     

       35
       33
        
         (** [to_json t] converts the user message to its JSON representation. *)

     

       36
       34
        
         

     

       37
       37
       -
         val of_json : value -> t

     

       35
       35
       +
         val of_json : Ezjsonm.value -> t

     

       38
       36
        
         (** [of_json json] parses a user message from JSON.

     

       39
       37
        
             @raise Invalid_argument if the JSON is not a valid user message. *)

     

       40
       38
        
         

     
···

       61
       59
        
         val model : t -> string

     

       62
       60
        
         (** [model t] returns the model identifier. *)

     

       63
       61
        
         

     

       64
       64
       -
         val to_json : t -> value

     

       62
       62
       +
         val to_json : t -> Ezjsonm.value

     

       65
       63
        
         (** [to_json t] converts the assistant message to its JSON representation. *)

     

       66
       64
        
         

     

       67
       67
       -
         val of_json : value -> t

     

       65
       65
       +
         val of_json : Ezjsonm.value -> t

     

       68
       66
        
         (** [of_json json] parses an assistant message from JSON.

     

       69
       67
        
             @raise Invalid_argument if the JSON is not a valid assistant message. *)

     

       70
       68
        
         

     
···

       77
       75
        
       module System : sig

     

       78
       76
        
         (** System control and status messages. *)

     

       79
       77
        
         

     

       78
       78
       +
         module Data : sig

     

       79
       79
       +
           (** System message data. *)

     

       80
       80
       +
           

     

       81
       81
       +
           type t

     

       82
       82
       +
           (** Abstract type for system message data. *)

     

       83
       83
       +
           

     

       84
       84
       +
           val empty : t

     

       85
       85
       +
           (** [empty] creates empty data. *)

     

       86
       86
       +
           

     

       87
       87
       +
           val of_assoc : (string * Ezjsonm.value) list -> t

     

       88
       88
       +
           (** [of_assoc assoc] creates data from an association list. *)

     

       89
       89
       +
           

     

       90
       90
       +
           val get_string : t -> string -> string option

     

       91
       91
       +
           (** [get_string t key] returns the string value for [key], if present. *)

     

       92
       92
       +
           

     

       93
       93
       +
           val get_int : t -> string -> int option

     

       94
       94
       +
           (** [get_int t key] returns the integer value for [key], if present. *)

     

       95
       95
       +
           

     

       96
       96
       +
           val get_bool : t -> string -> bool option

     

       97
       97
       +
           (** [get_bool t key] returns the boolean value for [key], if present. *)

     

       98
       98
       +
           

     

       99
       99
       +
           val to_json : t -> Ezjsonm.value

     

       100
       100
       +
           (** [to_json t] converts to JSON representation. Internal use only. *)

     

       101
       101
       +
           

     

       102
       102
       +
           val of_json : Ezjsonm.value -> t

     

       103
       103
       +
           (** [of_json json] parses from JSON. Internal use only. *)

     

       104
       104
       +
         end

     

       105
       105
       +
         

     

       80
       106
        
         type t

     

       81
       107
        
         (** The type of system messages. *)

     

       82
       108
        
         

     

       83
       83
       -
         val create : subtype:string -> data:value -> t

     

       109
       109
       +
         val create : subtype:string -> data:Data.t -> t

     

       84
       110
        
         (** [create ~subtype ~data] creates a system message.

     

       85
       111
        
             @param subtype The subtype of the system message

     

       86
       86
       -
             @param data Additional JSON data for the message *)

     

       112
       112
       +
             @param data Additional data for the message *)

     

       87
       113
        
         

     

       88
       114
        
         val subtype : t -> string

     

       89
       115
        
         (** [subtype t] returns the subtype of the system message. *)

     

       90
       116
        
         

     

       91
       91
       -
         val data : t -> value

     

       117
       117
       +
         val data : t -> Data.t

     

       92
       118
        
         (** [data t] returns the additional data of the system message. *)

     

       93
       119
        
         

     

       94
       94
       -
         val to_json : t -> value

     

       120
       120
       +
         val to_json : t -> Ezjsonm.value

     

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

     

       96
       122
        
         

     

       97
       97
       -
         val of_json : value -> t

     

       123
       123
       +
         val of_json : Ezjsonm.value -> t

     

       98
       124
        
         (** [of_json json] parses a system message from JSON.

     

       99
       125
        
             @raise Invalid_argument if the JSON is not a valid system message. *)

     

       100
       126
        
         

     
···

       107
       133
        
       module Result : sig

     

       108
       134
        
         (** Final result messages with metadata about the conversation. *)

     

       109
       135
        
         

     

       136
       136
       +
         module Usage : sig

     

       137
       137
       +
           (** Usage statistics for API calls. *)

     

       138
       138
       +
           

     

       139
       139
       +
           type t

     

       140
       140
       +
           (** Abstract type for usage statistics. *)

     

       141
       141
       +
           

     

       142
       142
       +
           val input_tokens : t -> int option

     

       143
       143
       +
           (** [input_tokens t] returns the number of input tokens used. *)

     

       144
       144
       +
           

     

       145
       145
       +
           val output_tokens : t -> int option

     

       146
       146
       +
           (** [output_tokens t] returns the number of output tokens generated. *)

     

       147
       147
       +
           

     

       148
       148
       +
           val total_tokens : t -> int option

     

       149
       149
       +
           (** [total_tokens t] returns the total number of tokens. *)

     

       150
       150
       +
           

     

       151
       151
       +
           val cache_creation_input_tokens : t -> int option

     

       152
       152
       +
           (** [cache_creation_input_tokens t] returns cache creation input tokens. *)

     

       153
       153
       +
           

     

       154
       154
       +
           val cache_read_input_tokens : t -> int option

     

       155
       155
       +
           (** [cache_read_input_tokens t] returns cache read input tokens. *)

     

       156
       156
       +
           

     

       157
       157
       +
           val to_json : t -> Ezjsonm.value

     

       158
       158
       +
           (** [to_json t] converts to JSON representation. Internal use only. *)

     

       159
       159
       +
           

     

       160
       160
       +
           val of_json : Ezjsonm.value -> t

     

       161
       161
       +
           (** [of_json json] parses from JSON. Internal use only. *)

     

       162
       162
       +
         end

     

       163
       163
       +
         

     

       110
       164
        
         type t

     

       111
       165
        
         (** The type of result messages. *)

     

       112
       166
        
         

     
···

       118
       172
        
           num_turns:int -> 

     

       119
       173
        
           session_id:string -> 

     

       120
       174
        
           ?total_cost_usd:float -> 

     

       121
       121
       -
           ?usage:value -> 

     

       175
       175
       +
           ?usage:Usage.t -> 

     

       122
       176
        
           ?result:string -> 

     

       123
       177
        
           unit -> t

     

       124
       178
        
         (** [create ~subtype ~duration_ms ~duration_api_ms ~is_error ~num_turns 

     
···

       154
       208
        
         val total_cost_usd : t -> float option

     

       155
       209
        
         (** [total_cost_usd t] returns the optional total cost in USD. *)

     

       156
       210
        
         

     

       157
       157
       -
         val usage : t -> value option

     

       211
       211
       +
         val usage : t -> Usage.t option

     

       158
       212
        
         (** [usage t] returns the optional usage statistics. *)

     

       159
       213
        
         

     

       160
       214
        
         val result : t -> string option

     

       161
       215
        
         (** [result t] returns the optional result string. *)

     

       162
       216
        
         

     

       163
       163
       -
         val to_json : t -> value

     

       217
       217
       +
         val to_json : t -> Ezjsonm.value

     

       164
       218
        
         (** [to_json t] converts the result message to its JSON representation. *)

     

       165
       219
        
         

     

       166
       166
       -
         val of_json : value -> t

     

       220
       220
       +
         val of_json : Ezjsonm.value -> t

     

       167
       221
        
         (** [of_json json] parses a result message from JSON.

     

       168
       222
        
             @raise Invalid_argument if the JSON is not a valid result message. *)

     

       169
       223
        
         

     
···

       189
       243
        
       val assistant : content:Content_block.t list -> model:string -> t

     

       190
       244
        
       (** [assistant ~content ~model] creates an assistant message. *)

     

       191
       245
        
       

     

       192
       192
       -
       val system : subtype:string -> data:value -> t

     

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

     

       193
       247
        
       (** [system ~subtype ~data] creates a system message. *)

     

       194
       248
        
       

     

       195
       249
        
       val result : 

     
···

       200
       254
        
         num_turns:int -> 

     

       201
       255
        
         session_id:string -> 

     

       202
       256
        
         ?total_cost_usd:float -> 

     

       203
       203
       -
         ?usage:value -> 

     

       257
       257
       +
         ?usage:Result.Usage.t -> 

     

       204
       258
        
         ?result:string -> 

     

       205
       259
        
         unit -> t

     

       206
       260
        
       (** [result ~subtype ~duration_ms ~duration_api_ms ~is_error ~num_turns 

     

       207
       261
        
           ~session_id ?total_cost_usd ?usage ?result ()] creates a result message. *)

     

       208
       262
        
       

     

       209
       209
       -
       val to_json : t -> value

     

       263
       263
       +
       val to_json : t -> Ezjsonm.value

     

       210
       264
        
       (** [to_json t] converts any message to its JSON representation. *)

     

       211
       265
        
       

     

       212
       212
       -
       val of_json : value -> t

     

       266
       266
       +
       val of_json : Ezjsonm.value -> t

     

       213
       267
        
       (** [of_json json] parses a message from JSON.

     

       214
       268
        
           @raise Invalid_argument if the JSON is not a valid message. *)

     

       215
       269