···

       
333
       
333
       
 
       
let query t prompt =

     

       
334
       
334
       
 
       
  let msg = Message.user_string prompt in

     

       
335
       
335
       
 
       
  Log.info (fun m -> m "→ %a" Message.pp msg);

     

       
336
       
336
       
-
       
  let json = match Jsont.Json.encode Message.jsont msg with

     

       
337
       
337
       
-
       
    | Ok j -> j

     

       
338
       
338
       
-
       
    | Error err -> failwith ("Failed to encode message: " ^ err)

     

       
339
       
339
       
-
       
  in

     

       
336
       
336
       
+
       
  let json = Message.to_json msg in

     

       
340
       
337
       
 
       
  Transport.send t.transport json

     

       
341
       
338
       
 
       


     

       
342
       
339
       
 
       
let send_message t msg =

     

       
343
       
340
       
 
       
  Log.info (fun m -> m "→ %a" Message.pp msg);

     

       
344
       
344
       
-
       
  let json = match Jsont.Json.encode Message.jsont msg with

     

       
345
       
345
       
-
       
    | Ok j -> j

     

       
346
       
346
       
-
       
    | Error err -> failwith ("Failed to encode message: " ^ err)

     

       
347
       
347
       
-
       
  in

     

       
341
       
341
       
+
       
  let json = Message.to_json msg in

     

       
348
       
342
       
 
       
  Transport.send t.transport json

     

       
349
       
343
       
 
       


     

       
350
       
344
       
 
       
let send_user_message t user_msg =

     

       
351
       
345
       
 
       
  let msg = Message.User user_msg in

     

       
352
       
346
       
 
       
  Log.info (fun m -> m "→ %a" Message.pp msg);

     

       
353
       
353
       
-
       
  let json = match Jsont.Json.encode Message.User.jsont user_msg with

     

       
354
       
354
       
-
       
    | Ok j -> j

     

       
355
       
355
       
-
       
    | Error err -> failwith ("Failed to encode user message: " ^ err)

     

       
356
       
356
       
-
       
  in

     

       
347
       
347
       
+
       
  let json = Message.User.to_json user_msg in

     

       
357
       
348
       
 
       
  Transport.send t.transport json

     

       
358
       
349
       
 
       


     

       
359
       
350
       
 
       
let receive t =

     

···

       
374
       
374
       
 
       
  let data t = t.data

     

       
375
       
375
       
 
       
  let unknown t = t.unknown

     

       
376
       
376
       
 
       


     

       
377
       
377
       
+
       
  (* Custom jsont that handles both formats:

     

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

     

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

     

       
380
       
380
       
+
       
     When data field is not present, we use the entire object as data *)

     

       
377
       
381
       
 
       
  let jsont : t Jsont.t =

     

       
378
       
378
       
-
       
    Jsont.Object.map ~kind:"System" make

     

       
382
       
382
       
+
       
    let make_with_optional_data subtype opt_data unknown_json =

     

       
383
       
383
       
+
       
      let data = match opt_data with

     

       
384
       
384
       
+
       
        | Some d -> d

     

       
385
       
385
       
+
       
        | None -> unknown_json  (* Use the full unknown object as data *)

     

       
386
       
386
       
+
       
      in

     

       
387
       
387
       
+
       
      make subtype data Unknown.empty

     

       
388
       
388
       
+
       
    in

     

       
389
       
389
       
+
       
    Jsont.Object.map ~kind:"System" make_with_optional_data

     

       
379
       
390
       
 
       
    |> Jsont.Object.mem "subtype" Jsont.string ~enc:subtype

     

       
380
       
380
       
-
       
    |> Jsont.Object.mem "data" Data.jsont ~enc:data

     

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

     

       
391
       
391
       
+
       
    |> Jsont.Object.opt_mem "data" Data.jsont ~enc:(fun t -> Some (data t))

     

       
392
       
392
       
+
       
    |> Jsont.Object.keep_unknown Jsont.json_mems ~enc:(fun _ -> Unknown.empty)

     

       
382
       
393
       
 
       
    |> Jsont.Object.finish

     

       
383
       
394
       
 
       


     

       
384
       
395
       
 
       
  let to_json t =

     
···

       
683
       
694
       
 
       
  Result (Result.create ~subtype ~duration_ms ~duration_api_ms ~is_error

     

       
684
       
695
       
 
       
    ~num_turns ~session_id ?total_cost_usd ?usage ?result ?structured_output ())

     

       
685
       
696
       
 
       


     

       
686
       
686
       
-
       
(* Jsont codec for the main Message variant type *)

     

       
687
       
687
       
-
       
let jsont : t Jsont.t =

     

       
688
       
688
       
-
       
  let case_map kind obj dec = Jsont.Object.Case.map kind obj ~dec in

     

       
689
       
689
       
-
       


     

       
690
       
690
       
-
       
  let case_user = case_map "user" User.jsont (fun v -> User v) in

     

       
691
       
691
       
-
       
  let case_assistant = case_map "assistant" Assistant.jsont (fun v -> Assistant v) in

     

       
692
       
692
       
-
       
  let case_system = case_map "system" System.jsont (fun v -> System v) in

     

       
693
       
693
       
-
       
  let case_result = case_map "result" Result.jsont (fun v -> Result v) in

     

       
694
       
694
       
-
       


     

       
695
       
695
       
-
       
  let enc_case = function

     

       
696
       
696
       
-
       
    | User v -> Jsont.Object.Case.value case_user v

     

       
697
       
697
       
-
       
    | Assistant v -> Jsont.Object.Case.value case_assistant v

     

       
698
       
698
       
-
       
    | System v -> Jsont.Object.Case.value case_system v

     

       
699
       
699
       
-
       
    | Result v -> Jsont.Object.Case.value case_result v

     

       
700
       
700
       
-
       
  in

     

       
701
       
701
       
-
       


     

       
702
       
702
       
-
       
  let cases = Jsont.Object.Case.[

     

       
703
       
703
       
-
       
    make case_user;

     

       
704
       
704
       
-
       
    make case_assistant;

     

       
705
       
705
       
-
       
    make case_system;

     

       
706
       
706
       
-
       
    make case_result

     

       
707
       
707
       
-
       
  ] in

     

       
708
       
708
       
-
       


     

       
709
       
709
       
-
       
  Jsont.Object.map ~kind:"Message" Fun.id

     

       
710
       
710
       
-
       
  |> Jsont.Object.case_mem "type" Jsont.string ~enc:Fun.id ~enc_case cases

     

       
711
       
711
       
-
       
      ~tag_to_string:Fun.id ~tag_compare:String.compare

     

       
712
       
712
       
-
       
  |> Jsont.Object.finish

     

       
713
       
713
       
-
       


     

       
714
       
697
       
 
       
let to_json = function

     

       
715
       
698
       
 
       
  | User t -> User.to_json t

     

       
716
       
699
       
 
       
  | Assistant t -> Assistant.to_json t

     
···

       
729
       
712
       
 
       
      | None -> raise (Invalid_argument "Message.of_json: missing type field")

     

       
730
       
713
       
 
       
    )

     

       
731
       
714
       
 
       
  | _ -> raise (Invalid_argument "Message.of_json: expected object")

     

       
715
       
715
       
+
       


     

       
716
       
716
       
+
       
(* Jsont codec for the main Message variant type.

     

       
717
       
717
       
+
       
   Uses a custom decoder to handle both old and new formats. *)

     

       
718
       
718
       
+
       
let jsont : t Jsont.t =

     

       
719
       
719
       
+
       
  Jsont.map ~kind:"Message" ~dec:of_json ~enc:to_json Jsont.json

     

       
732
       
720
       
 
       


     

       
733
       
721
       
 
       
let pp fmt = function

     

       
734
       
722
       
 
       
  | User t -> User.pp fmt t