commit 0353e16af92683e09fc7f4dcefb43f783fddb49e · anil.recoil.org/slop

+8 -6

claudeio/lib/client.ml

···

       84
        
                       (* Extract session ID from system messages *)

     

       85
        
                       (match msg with

     

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

     

       87
       -
                           (try

     

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

     

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

     

       90
        
                             t.session_id <- Some session_id;

     

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

     

       92
       -
                           with Not_found -> ())

     

       93
        
                       | _ -> ());

     

       94
        
                       

     

       95
        
                       Seq.Cons (msg, loop)

     
···

       115
        
         let msg = Message.user_string prompt in

     

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

     

       117
        
       

     

       118
       -
       let send_message t json =

     

       119
       -
         Transport.send t.transport json

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       120
        
       

     

       121
        
       let receive t =

     

       122
        
         handle_messages t

···

       84
        
                       (* Extract session ID from system messages *)

     

       85
        
                       (match msg with

     

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

     

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

     

       88
       +
                           | Some session_id ->

     

       0
        
       
     

       89
        
                             t.session_id <- Some session_id;

     

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

     

       91
       +
                           | None -> ())

     

       92
        
                       | _ -> ());

     

       93
        
                       

     

       94
        
                       Seq.Cons (msg, loop)

     
···

       114
        
         let msg = Message.user_string prompt in

     

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

     

       116
        
       

     

       117
       +
       let send_message t msg =

     

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

     

       119
       +
       

     

       120
       +
       let send_user_message t user_msg =

     

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

     

       122
        
       

     

       123
        
       let receive t =

     

       124
        
         handle_messages t

+2 -1

claudeio/lib/client.mli

···

       10
        
         unit -> t

     

       11
        
       

     

       12
        
       val query : t -> string -> unit

     

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

     

       0
        
       
     

       14
        
       

     

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

     

       16
        
       val receive_all : t -> Message.t list

···

       10
        
         unit -> t

     

       11
        
       

     

       12
        
       val query : t -> string -> unit

     

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

     

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

     

       15
        
       

     

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

     

       17
        
       val receive_all : t -> Message.t list

+49 -4

claudeio/lib/content_block.ml

···

       27
        
       end

     

       28
        
       

     

       29
        
       module Tool_use = struct

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       30
        
         type t = {

     

       31
        
           id : string;

     

       32
        
           name : string;

     

       33
       -
           input : value;

     

       34
        
         }

     

       35
        
         

     

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

     
···

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

     

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

     

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

     

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

     

       47
        
           ]

     

       48
        
         

     

       49
        
         let of_json = function

     

       50
        
           | `O fields ->

     

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

     

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

     

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

     

       54
        
               { id; name; input }

     

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

     

       56
        
         

     

       57
        
         let pp fmt t =

     

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

     

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

     

       60
        
       end

     

       61
        
       

     

       62
        
       module Tool_result = struct

···

       27
        
       end

     

       28
        
       

     

       29
        
       module Tool_use = struct

     

       30
       +
         module Input = struct

     

       31
       +
           type t = value

     

       32
       +
           

     

       33
       +
           let of_string_pairs pairs =

     

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

     

       35
       +
           

     

       36
       +
           let of_assoc assoc = `O assoc

     

       37
       +
           

     

       38
       +
           let get_string t key =

     

       39
       +
             match t with

     

       40
       +
             | `O fields ->

     

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

     

       42
       +
                  with Not_found | _ -> None)

     

       43
       +
             | _ -> None

     

       44
       +
           

     

       45
       +
           let get_int t key =

     

       46
       +
             match t with

     

       47
       +
             | `O fields ->

     

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

     

       49
       +
                  with Not_found | _ -> None)

     

       50
       +
             | _ -> None

     

       51
       +
           

     

       52
       +
           let get_bool t key =

     

       53
       +
             match t with

     

       54
       +
             | `O fields ->

     

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

     

       56
       +
                  with Not_found | _ -> None)

     

       57
       +
             | _ -> None

     

       58
       +
           

     

       59
       +
           let get_float t key =

     

       60
       +
             match t with

     

       61
       +
             | `O fields ->

     

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

     

       63
       +
                  with Not_found | _ -> None)

     

       64
       +
             | _ -> None

     

       65
       +
           

     

       66
       +
           let keys t =

     

       67
       +
             match t with

     

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

     

       69
       +
             | _ -> []

     

       70
       +
           

     

       71
       +
           let to_json t = t

     

       72
       +
           let of_json json = json

     

       73
       +
         end

     

       74
       +
         

     

       75
        
         type t = {

     

       76
        
           id : string;

     

       77
        
           name : string;

     

       78
       +
           input : Input.t;

     

       79
        
         }

     

       80
        
         

     

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

     
···

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

     

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

     

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

     

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

     

       92
        
           ]

     

       93
        
         

     

       94
        
         let of_json = function

     

       95
        
           | `O fields ->

     

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

     

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

     

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

     

       99
        
               { id; name; input }

     

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

     

       101
        
         

     

       102
        
         let pp fmt t =

     

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

     

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

     

       105
        
       end

     

       106
        
       

     

       107
        
       module Tool_result = struct

+49 -17

claudeio/lib/content_block.mli

···

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

     

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

     

       5
        
       

     

       6
       -
       open Ezjsonm

     

       7
       -
       

     

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

     

       9
        
       val src : Logs.Src.t

     

       10
        
       

     
···

       22
        
         val text : t -> string

     

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

     

       24
        
         

     

       25
       -
         val to_json : t -> value

     

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

     

       27
        
         

     

       28
       -
         val of_json : value -> t

     

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

     

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

     

       31
        
         

     
···

       38
        
       module Tool_use : sig

     

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

     

       40
        
         

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       41
        
         type t

     

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

     

       43
        
         

     

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

     

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

     

       46
        
             @param id Unique identifier for this tool invocation

     

       47
        
             @param name Name of the tool to invoke

     

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

     

       49
        
         

     

       50
        
         val id : t -> string

     

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

     
···

       53
        
         val name : t -> string

     

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

     

       55
        
         

     

       56
       -
         val input : t -> value

     

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

     

       58
        
         

     

       59
       -
         val to_json : t -> value

     

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

     

       61
        
         

     

       62
       -
         val of_json : value -> t

     

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

     

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

     

       65
        
         

     
···

       90
        
         val is_error : t -> bool option

     

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

     

       92
        
         

     

       93
       -
         val to_json : t -> value

     

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

     

       95
        
         

     

       96
       -
         val of_json : value -> t

     

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

     

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

     

       99
        
         

     
···

       120
        
         val signature : t -> string

     

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

     

       122
        
         

     

       123
       -
         val to_json : t -> value

     

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

     

       125
        
         

     

       126
       -
         val of_json : value -> t

     

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

     

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

     

       129
        
         

     
···

       143
        
       val text : string -> t

     

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

     

       145
        
       

     

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

     

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

     

       148
        
       

     

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

     
···

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

     

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

     

       154
        
       

     

       155
       -
       val to_json : t -> value

     

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

     

       157
        
       

     

       158
       -
       val of_json : value -> t

     

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

     

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

     

       161

···

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

     

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

     

       5
        
       

     

       0
        
       
     

       0
        
       
     

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

     

       7
        
       val src : Logs.Src.t

     

       8
        
       

     
···

       20
        
         val text : t -> string

     

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

     

       22
        
         

     

       23
       +
         val to_json : t -> Ezjsonm.value

     

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

     

       25
        
         

     

       26
       +
         val of_json : Ezjsonm.value -> t

     

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

     

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

     

       29
        
         

     
···

       36
        
       module Tool_use : sig

     

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

     

       38
        
         

     

       39
       +
         module Input : sig

     

       40
       +
           (** Tool input parameters. *)

     

       41
       +
           

     

       42
       +
           type t

     

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

     

       44
       +
           

     

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

     

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

     

       47
       +
           

     

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

     

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

     

       50
       +
           

     

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

     

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

     

       53
       +
           

     

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

     

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

     

       56
       +
           

     

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

     

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

     

       59
       +
           

     

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

     

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

     

       62
       +
           

     

       63
       +
           val keys : t -> string list

     

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

     

       65
       +
           

     

       66
       +
           val to_json : t -> Ezjsonm.value

     

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

     

       68
       +
           

     

       69
       +
           val of_json : Ezjsonm.value -> t

     

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

     

       71
       +
         end

     

       72
       +
         

     

       73
        
         type t

     

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

     

       75
        
         

     

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

     

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

     

       78
        
             @param id Unique identifier for this tool invocation

     

       79
        
             @param name Name of the tool to invoke

     

       80
       +
             @param input Parameters for the tool *)

     

       81
        
         

     

       82
        
         val id : t -> string

     

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

     
···

       85
        
         val name : t -> string

     

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

     

       87
        
         

     

       88
       +
         val input : t -> Input.t

     

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

     

       90
        
         

     

       91
       +
         val to_json : t -> Ezjsonm.value

     

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

     

       93
        
         

     

       94
       +
         val of_json : Ezjsonm.value -> t

     

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

     

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

     

       97
        
         

     
···

       122
        
         val is_error : t -> bool option

     

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

     

       124
        
         

     

       125
       +
         val to_json : t -> Ezjsonm.value

     

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

     

       127
        
         

     

       128
       +
         val of_json : Ezjsonm.value -> t

     

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

     

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

     

       131
        
         

     
···

       152
        
         val signature : t -> string

     

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

     

       154
        
         

     

       155
       +
         val to_json : t -> Ezjsonm.value

     

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

     

       157
        
         

     

       158
       +
         val of_json : Ezjsonm.value -> t

     

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

     

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

     

       161
        
         

     
···

       175
        
       val text : string -> t

     

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

     

       177
        
       

     

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

     

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

     

       180
        
       

     

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

     
···

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

     

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

     

       186
        
       

     

       187
       +
       val to_json : t -> Ezjsonm.value

     

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

     

       189
        
       

     

       190
       +
       val of_json : Ezjsonm.value -> t

     

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

     

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

     

       193

+82 -8

claudeio/lib/message.ml

···

       97
        
       end

     

       98
        
       

     

       99
        
       module System = struct

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       100
        
         type t = {

     

       101
        
           subtype : string;

     

       102
       -
           data : value;

     

       103
        
         }

     

       104
        
         

     

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

     
···

       110
        
           `O [

     

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

     

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

     

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

     

       114
        
           ]

     

       115
        
         

     

       116
        
         let of_json = function

     

       117
        
           | `O fields ->

     

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

     

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

     

       120
        
               { subtype; data }

     

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

     

       122
        
         

     

       123
        
         let pp fmt t =

     

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

     

       125
        
             t.subtype

     

       126
       -
             pp_json t.data

     

       127
        
       end

     

       128
        
       

     

       129
        
       module Result = struct

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       130
        
         type t = {

     

       131
        
           subtype : string;

     

       132
        
           duration_ms : int;

     
···

       135
        
           num_turns : int;

     

       136
        
           session_id : string;

     

       137
        
           total_cost_usd : float option;

     

       138
       -
           usage : value option;

     

       139
        
           result : string option;

     

       140
        
         }

     

       141
        
         

     
···

       169
        
             | None -> fields

     

       170
        
           in

     

       171
        
           let fields = match t.usage with

     

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

     

       173
        
             | None -> fields

     

       174
        
           in

     

       175
        
           let fields = match t.result with

     
···

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

     

       191
        
                 with Not_found -> None

     

       192
        
               in

     

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

     

       194
        
               let result = 

     

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

     

       196
        
                 with Not_found -> None

     
···

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

     

       207
        
             t.session_id

     

       208
        
             Fmt.(option float) t.total_cost_usd

     

       209
       -
             Fmt.(option pp_json) t.usage

     

       210
        
             Fmt.(option string) t.result

     

       211
        
       end

     

       212

···

       97
        
       end

     

       98
        
       

     

       99
        
       module System = struct

     

       100
       +
         module Data = struct

     

       101
       +
           type t = value

     

       102
       +
           

     

       103
       +
           let empty = `O []

     

       104
       +
           

     

       105
       +
           let of_assoc assoc = `O assoc

     

       106
       +
           

     

       107
       +
           let get_string t key =

     

       108
       +
             match t with

     

       109
       +
             | `O fields ->

     

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

     

       111
       +
                  with Not_found | _ -> None)

     

       112
       +
             | _ -> None

     

       113
       +
           

     

       114
       +
           let get_int t key =

     

       115
       +
             match t with

     

       116
       +
             | `O fields ->

     

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

     

       118
       +
                  with Not_found | _ -> None)

     

       119
       +
             | _ -> None

     

       120
       +
           

     

       121
       +
           let get_bool t key =

     

       122
       +
             match t with

     

       123
       +
             | `O fields ->

     

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

     

       125
       +
                  with Not_found | _ -> None)

     

       126
       +
             | _ -> None

     

       127
       +
           

     

       128
       +
           let to_json t = t

     

       129
       +
           let of_json json = json

     

       130
       +
         end

     

       131
       +
         

     

       132
        
         type t = {

     

       133
        
           subtype : string;

     

       134
       +
           data : Data.t;

     

       135
        
         }

     

       136
        
         

     

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

     
···

       142
        
           `O [

     

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

     

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

     

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

     

       146
        
           ]

     

       147
        
         

     

       148
        
         let of_json = function

     

       149
        
           | `O fields ->

     

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

     

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

     

       152
        
               { subtype; data }

     

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

     

       154
        
         

     

       155
        
         let pp fmt t =

     

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

     

       157
        
             t.subtype

     

       158
       +
             pp_json (Data.to_json t.data)

     

       159
        
       end

     

       160
        
       

     

       161
        
       module Result = struct

     

       162
       +
         module Usage = struct

     

       163
       +
           type t = value

     

       164
       +
           

     

       165
       +
           let input_tokens t =

     

       166
       +
             match t with

     

       167
       +
             | `O fields ->

     

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

     

       169
       +
                  with Not_found | _ -> None)

     

       170
       +
             | _ -> None

     

       171
       +
           

     

       172
       +
           let output_tokens t =

     

       173
       +
             match t with

     

       174
       +
             | `O fields ->

     

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

     

       176
       +
                  with Not_found | _ -> None)

     

       177
       +
             | _ -> None

     

       178
       +
           

     

       179
       +
           let total_tokens t =

     

       180
       +
             match t with

     

       181
       +
             | `O fields ->

     

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

     

       183
       +
                  with Not_found | _ -> None)

     

       184
       +
             | _ -> None

     

       185
       +
           

     

       186
       +
           let cache_creation_input_tokens t =

     

       187
       +
             match t with

     

       188
       +
             | `O fields ->

     

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

     

       190
       +
                  with Not_found | _ -> None)

     

       191
       +
             | _ -> None

     

       192
       +
           

     

       193
       +
           let cache_read_input_tokens t =

     

       194
       +
             match t with

     

       195
       +
             | `O fields ->

     

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

     

       197
       +
                  with Not_found | _ -> None)

     

       198
       +
             | _ -> None

     

       199
       +
           

     

       200
       +
           let to_json t = t

     

       201
       +
           let of_json json = json

     

       202
       +
         end

     

       203
       +
         

     

       204
        
         type t = {

     

       205
        
           subtype : string;

     

       206
        
           duration_ms : int;

     
···

       209
        
           num_turns : int;

     

       210
        
           session_id : string;

     

       211
        
           total_cost_usd : float option;

     

       212
       +
           usage : Usage.t option;

     

       213
        
           result : string option;

     

       214
        
         }

     

       215
        
         

     
···

       243
        
             | None -> fields

     

       244
        
           in

     

       245
        
           let fields = match t.usage with

     

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

     

       247
        
             | None -> fields

     

       248
        
           in

     

       249
        
           let fields = match t.result with

     
···

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

     

       265
        
                 with Not_found -> None

     

       266
        
               in

     

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

     

       268
        
               let result = 

     

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

     

       270
        
                 with Not_found -> None

     
···

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

     

       281
        
             t.session_id

     

       282
        
             Fmt.(option float) t.total_cost_usd

     

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

     

       284
        
             Fmt.(option string) t.result

     

       285
        
       end

     

       286

+73 -19

claudeio/lib/message.mli

···

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

     

       5
        
           messages, and result metadata. *)

     

       6
        
       

     

       7
       -
       open Ezjsonm

     

       8
       -
       

     

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

     

       10
        
       val src : Logs.Src.t

     

       11
        
       

     
···

       31
        
         val content : t -> content

     

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

     

       33
        
         

     

       34
       -
         val to_json : t -> value

     

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

     

       36
        
         

     

       37
       -
         val of_json : value -> t

     

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

     

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

     

       40
        
         

     
···

       61
        
         val model : t -> string

     

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

     

       63
        
         

     

       64
       -
         val to_json : t -> value

     

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

     

       66
        
         

     

       67
       -
         val of_json : value -> t

     

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

     

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

     

       70
        
         

     
···

       77
        
       module System : sig

     

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

     

       79
        
         

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       80
        
         type t

     

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

     

       82
        
         

     

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

     

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

     

       85
        
             @param subtype The subtype of the system message

     

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

     

       87
        
         

     

       88
        
         val subtype : t -> string

     

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

     

       90
        
         

     

       91
       -
         val data : t -> value

     

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

     

       93
        
         

     

       94
       -
         val to_json : t -> value

     

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

     

       96
        
         

     

       97
       -
         val of_json : value -> t

     

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

     

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

     

       100
        
         

     
···

       107
        
       module Result : sig

     

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

     

       109
        
         

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       110
        
         type t

     

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

     

       112
        
         

     
···

       118
        
           num_turns:int -> 

     

       119
        
           session_id:string -> 

     

       120
        
           ?total_cost_usd:float -> 

     

       121
       -
           ?usage:value -> 

     

       122
        
           ?result:string -> 

     

       123
        
           unit -> t

     

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

     
···

       154
        
         val total_cost_usd : t -> float option

     

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

     

       156
        
         

     

       157
       -
         val usage : t -> value option

     

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

     

       159
        
         

     

       160
        
         val result : t -> string option

     

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

     

       162
        
         

     

       163
       -
         val to_json : t -> value

     

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

     

       165
        
         

     

       166
       -
         val of_json : value -> t

     

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

     

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

     

       169
        
         

     
···

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

     

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

     

       191
        
       

     

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

     

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

     

       194
        
       

     

       195
        
       val result : 

     
···

       200
        
         num_turns:int -> 

     

       201
        
         session_id:string -> 

     

       202
        
         ?total_cost_usd:float -> 

     

       203
       -
         ?usage:value -> 

     

       204
        
         ?result:string -> 

     

       205
        
         unit -> t

     

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

     

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

     

       208
        
       

     

       209
       -
       val to_json : t -> value

     

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

     

       211
        
       

     

       212
       -
       val of_json : value -> t

     

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

     

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

     

       215

···

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

     

       5
        
           messages, and result metadata. *)

     

       6
        
       

     

       0
        
       
     

       0
        
       
     

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

     

       8
        
       val src : Logs.Src.t

     

       9
        
       

     
···

       29
        
         val content : t -> content

     

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

     

       31
        
         

     

       32
       +
         val to_json : t -> Ezjsonm.value

     

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

     

       34
        
         

     

       35
       +
         val of_json : Ezjsonm.value -> t

     

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

     

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

     

       38
        
         

     
···

       59
        
         val model : t -> string

     

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

     

       61
        
         

     

       62
       +
         val to_json : t -> Ezjsonm.value

     

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

     

       64
        
         

     

       65
       +
         val of_json : Ezjsonm.value -> t

     

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

     

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

     

       68
        
         

     
···

       75
        
       module System : sig

     

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

     

       77
        
         

     

       78
       +
         module Data : sig

     

       79
       +
           (** System message data. *)

     

       80
       +
           

     

       81
       +
           type t

     

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

     

       83
       +
           

     

       84
       +
           val empty : t

     

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

     

       86
       +
           

     

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

     

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

     

       89
       +
           

     

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

     

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

     

       92
       +
           

     

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

     

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

     

       95
       +
           

     

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

     

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

     

       98
       +
           

     

       99
       +
           val to_json : t -> Ezjsonm.value

     

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

     

       101
       +
           

     

       102
       +
           val of_json : Ezjsonm.value -> t

     

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

     

       104
       +
         end

     

       105
       +
         

     

       106
        
         type t

     

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

     

       108
        
         

     

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

     

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

     

       111
        
             @param subtype The subtype of the system message

     

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

     

       113
        
         

     

       114
        
         val subtype : t -> string

     

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

     

       116
        
         

     

       117
       +
         val data : t -> Data.t

     

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

     

       119
        
         

     

       120
       +
         val to_json : t -> Ezjsonm.value

     

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

     

       122
        
         

     

       123
       +
         val of_json : Ezjsonm.value -> t

     

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

     

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

     

       126
        
         

     
···

       133
        
       module Result : sig

     

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

     

       135
        
         

     

       136
       +
         module Usage : sig

     

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

     

       138
       +
           

     

       139
       +
           type t

     

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

     

       141
       +
           

     

       142
       +
           val input_tokens : t -> int option

     

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

     

       144
       +
           

     

       145
       +
           val output_tokens : t -> int option

     

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

     

       147
       +
           

     

       148
       +
           val total_tokens : t -> int option

     

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

     

       150
       +
           

     

       151
       +
           val cache_creation_input_tokens : t -> int option

     

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

     

       153
       +
           

     

       154
       +
           val cache_read_input_tokens : t -> int option

     

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

     

       156
       +
           

     

       157
       +
           val to_json : t -> Ezjsonm.value

     

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

     

       159
       +
           

     

       160
       +
           val of_json : Ezjsonm.value -> t

     

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

     

       162
       +
         end

     

       163
       +
         

     

       164
        
         type t

     

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

     

       166
        
         

     
···

       172
        
           num_turns:int -> 

     

       173
        
           session_id:string -> 

     

       174
        
           ?total_cost_usd:float -> 

     

       175
       +
           ?usage:Usage.t -> 

     

       176
        
           ?result:string -> 

     

       177
        
           unit -> t

     

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

     
···

       208
        
         val total_cost_usd : t -> float option

     

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

     

       210
        
         

     

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

     

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

     

       213
        
         

     

       214
        
         val result : t -> string option

     

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

     

       216
        
         

     

       217
       +
         val to_json : t -> Ezjsonm.value

     

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

     

       219
        
         

     

       220
       +
         val of_json : Ezjsonm.value -> t

     

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

     

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

     

       223
        
         

     
···

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

     

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

     

       245
        
       

     

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

     

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

     

       248
        
       

     

       249
        
       val result : 

     
···

       254
        
         num_turns:int -> 

     

       255
        
         session_id:string -> 

     

       256
        
         ?total_cost_usd:float -> 

     

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

     

       258
        
         ?result:string -> 

     

       259
        
         unit -> t

     

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

     

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

     

       262
        
       

     

       263
       +
       val to_json : t -> Ezjsonm.value

     

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

     

       265
        
       

     

       266
       +
       val of_json : Ezjsonm.value -> t

     

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

     

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

     

       269