hermes: Return bytes for bytes output

hermes-cli/lib/codegen.ml

···
   (* generate output type *)
   ( if output_is_bytes then begin
       emitln out "  (** raw bytes output with content type *)" ;
-      emitln out "  type output = string * string" ;
+      emitln out "  type output = bytes * string" ;
       emit_newline out
     end
     else
···
   (* generate output type *)
   ( if output_is_bytes then begin
       emitln out "  (** raw bytes output with content type *)" ;
-      emitln out "  type output = (string * string) option" ;
+      emitln out "  type output = (bytes * string) option" ;
       emit_newline out
     end
     else

hermes-cli/test/test_codegen.ml

···
       [make_def "result" (Lexicon_types.Union union_spec)]
   in
   let code = Codegen.gen_lexicon_module doc in
-  check bool "contains type result" true (contains code "type result =") ;
+  check bool "contains type result" true (contains code "type result_ =") ;
   check bool "contains TypeA variant" true (contains code "| TypeA of") ;
   check bool "contains TypeB variant" true (contains code "| TypeB of") ;
   check bool "contains Unknown (open)" true
···
   in
   let code = Codegen.gen_lexicon_module doc in
   check bool "contains module Main" true (contains code "module Main = struct") ;
-  check bool "output is string * string tuple" true
-    (contains code "type output = string * string") ;
+  check bool "output is bytes * string tuple" true
+    (contains code "type output = bytes * string") ;
   check bool "calls Hermes.query_bytes" true
     (contains code "Hermes.query_bytes")
 

hermes/README.md

···
 Endpoints with non-JSON encoding are automatically detected and handled:
 
 - **Queries with bytes output** (e.g., `com.atproto.sync.getBlob` with `encoding: "*/*"`):
-    - Output type is `string * string` (data, content_type)
+    - Output type is `bytes * string` (data, content_type)
     - Generated code uses `Hermes.query_bytes`
 
 - **Procedures with bytes input**:

hermes/lib/client.ml

···
     -> (Yojson.Safe.t -> ('a, string) result)
     -> 'a Lwt.t
 
-  val query_bytes : t -> string -> Yojson.Safe.t -> (string * string) Lwt.t
+  val query_bytes : t -> string -> Yojson.Safe.t -> (bytes * string) Lwt.t
 
   val procedure_bytes :
        t
     -> string
     -> Yojson.Safe.t
-    -> string option
+    -> bytes option
     -> content_type:string
-    -> (string * string) option Lwt.t
+    -> (bytes * string) option Lwt.t
 
   val procedure_blob :
        t
···
       Types.raise_xrpc_error ~status payload
 
   let query_bytes (t : t) (nsid : string) (params : Yojson.Safe.t) :
-      (string * string) Lwt.t =
+      (bytes * string) Lwt.t =
     (* call interceptor if present for token refresh *)
     let* () =
       match t.on_request with Some f -> f t | None -> Lwt.return_unit
···
     in
     let status = Cohttp.Response.status resp |> Cohttp.Code.code_of_status in
     let* body_str = Cohttp_lwt.Body.to_string body in
+    let body = Bytes.of_string body_str in
     if status >= 200 && status < 300 then
       let content_type =
         Cohttp.Response.headers resp
···
         Cohttp.Header.get h "content-type"
         |> Option.value ~default:"application/octet-stream"
       in
-      Lwt.return (body_str, content_type)
+      Lwt.return (body, content_type)
     else
       let payload =
         try
···
 
   (* execute procedure with raw bytes input, returns raw bytes or none if no output *)
   let procedure_bytes (t : t) (nsid : string) (params : Yojson.Safe.t)
-      (input : string option) ~(content_type : string) :
-      (string * string) option Lwt.t =
+      (input : bytes option) ~(content_type : string) :
+      (bytes * string) option Lwt.t =
     (* call interceptor if present for token refresh *)
     let* () =
       match t.on_request with Some f -> f t | None -> Lwt.return_unit
···
     let body =
       match input with
       | Some data ->
-          Cohttp_lwt.Body.of_string data
+          Cohttp_lwt.Body.of_string (Bytes.to_string data)
       | None ->
           Cohttp_lwt.Body.empty
     in
···
     in
     let status = Cohttp.Response.status resp |> Cohttp.Code.code_of_status in
     let* body_str = Cohttp_lwt.Body.to_string resp_body in
+    let body = Bytes.of_string body_str in
     if status >= 200 && status < 300 then
-      if String.length body_str = 0 then Lwt.return None
+      if Bytes.length body = 0 then Lwt.return None
       else
         let resp_content_type =
           Cohttp.Response.headers resp
···
           Cohttp.Header.get h "content-type"
           |> Option.value ~default:"application/octet-stream"
         in
-        Lwt.return (Some (body_str, resp_content_type))
+        Lwt.return (Some (body, resp_content_type))
     else
       let payload =
         try

hermes/lib/hermes.mli

···
   -> (Yojson.Safe.t -> ('a, string) result)
   -> 'a Lwt.t
 
-val query_bytes : client -> string -> Yojson.Safe.t -> (string * string) Lwt.t
+val query_bytes : client -> string -> Yojson.Safe.t -> (bytes * string) Lwt.t
 
 val procedure_bytes :
      client
   -> string
   -> Yojson.Safe.t
-  -> string option
+  -> bytes option
   -> content_type:string
-  -> (string * string) option Lwt.t
+  -> (bytes * string) option Lwt.t
 
 val session_to_yojson : session -> Yojson.Safe.t
 
···
       -> (Yojson.Safe.t -> ('a, string) result)
       -> 'a Lwt.t
 
-    val query_bytes : t -> string -> Yojson.Safe.t -> (string * string) Lwt.t
+    val query_bytes : t -> string -> Yojson.Safe.t -> (bytes * string) Lwt.t
 
     val procedure_bytes :
          t
       -> string
       -> Yojson.Safe.t
-      -> string option
+      -> bytes option
       -> content_type:string
-      -> (string * string) option Lwt.t
+      -> (bytes * string) option Lwt.t
 
     val procedure_blob :
          t

hermes/test/test_client.ml

···
 (* helpers *)
 let test_string = testable Fmt.string String.equal
 
+let test_bytes =
+  testable
+    (Fmt.of_to_string (fun b -> String.sub (Bytes.to_string b) 0 10))
+    Bytes.equal
+
 (** query tests *)
 
 let test_query_success () =
···
         C.query_bytes client "com.atproto.sync.getBlob"
           (`Assoc [("did", `String "did:plc:123"); ("cid", `String "bafyabc")]) )
   in
-  check test_string "data" "fake-image-data" data ;
+  check test_bytes "data" (Bytes.of_string "fake-image-data") data ;
   check test_string "content_type" "image/jpeg" content_type ;
   let req = List.hd requests in
   Test_utils.assert_request_has_header "accept" "*/*" req ;
···
   let* result, requests =
     Test_utils.with_mock_responses [response] (fun (module C) client ->
         C.procedure_bytes client "com.atproto.repo.importRepo" (`Assoc [])
-          (Some "fake-car-data") ~content_type:"application/vnd.ipld.car" )
+          (Some (Bytes.of_string "fake-car-data"))
+          ~content_type:"application/vnd.ipld.car" )
   in
-  check (option (pair test_string test_string)) "result" None result ;
+  check (option (pair test_bytes test_string)) "result" None result ;
   let req = List.hd requests in
   Test_utils.assert_request_has_header "content-type" "application/vnd.ipld.car"
     req ;

hermes_ppx/test/test_ppx.ml

···
   check (list string) "single segment" ["Test"] result
 
 let test_build_call_expr () =
-  let result = Hermes_ppx.build_call_expr ~loc "app.bsky.graph.getProfile" in
-  let expected_str = "App.Bsky.Graph.GetProfile.call" in
+  let result = Hermes_ppx.build_call_expr ~loc "app.bsky.actor.getProfile" in
+  let expected_str = "App.Bsky.Actor.GetProfile.Main.call" in
   check string "call expr" expected_str
     (Ppxlib.Pprintast.string_of_expression result)
 
···
 
 let test_expand_get_nsid () =
   let actual = expand_xrpc {|[%xrpc get "app.bsky.graph.getRelationships"]|} in
-  let expected_str = "App.Bsky.Graph.GetRelationships.call" in
+  let expected_str = "App.Bsky.Graph.GetRelationships.Main.call" in
   check string "get expansion" expected_str
     (Ppxlib.Pprintast.string_of_expression actual)
 
···
   let actual =
     expand_xrpc {|[%xrpc post "com.atproto.server.createSession"]|}
   in
-  let expected_str = "Com.Atproto.Server.CreateSession.call" in
+  let expected_str = "Com.Atproto.Server.CreateSession.Main.call" in
   check string "post expansion" expected_str
     (Ppxlib.Pprintast.string_of_expression actual)
 
 let test_expand_nsid_only () =
   (* [%xrpc "nsid"] defaults to get *)
   let actual = expand_xrpc {|[%xrpc "app.bsky.actor.getProfile"]|} in
-  let expected_str = "App.Bsky.Actor.GetProfile.call" in
+  let expected_str = "App.Bsky.Actor.GetProfile.Main.call" in
   check string "nsid only expansion" expected_str
     (Ppxlib.Pprintast.string_of_expression actual)
 

pegasus/lexicons/com_atproto_sync_getBlob.ml

···
 [@@deriving yojson {strict= false}]
 
   (** raw bytes output with content type *)
-  type output = string * string
+  type output = bytes * string
 
   let call
       ~did

pegasus/lexicons/com_atproto_sync_getBlocks.ml

···
 [@@deriving yojson {strict= false}]
 
   (** raw bytes output with content type *)
-  type output = string * string
+  type output = bytes * string
 
   let call
       ~did

pegasus/lexicons/com_atproto_sync_getCheckout.ml

···
 [@@deriving yojson {strict= false}]
 
   (** raw bytes output with content type *)
-  type output = string * string
+  type output = bytes * string
 
   let call
       ~did

pegasus/lexicons/com_atproto_sync_getRecord.ml

···
 [@@deriving yojson {strict= false}]
 
   (** raw bytes output with content type *)
-  type output = string * string
+  type output = bytes * string
 
   let call
       ~did

pegasus/lexicons/com_atproto_sync_getRepo.ml

···
 [@@deriving yojson {strict= false}]
 
   (** raw bytes output with content type *)
-  type output = string * string
+  type output = bytes * string
 
   let call
       ~did

pegasus/lib/api/account_/migrate/migrate.ml

···
     match%lwt Remote.fetch_repo old_client ~did with
     | Error err ->
         render_err ~did ~handle ~old_pds ("Failed to fetch repository: " ^ err)
-    | Ok car_data -> (
-      match%lwt
-        Ops.import_repo ~did ~car_data:(Bytes.of_string (fst car_data))
-      with
+    | Ok (car_data, _) -> (
+      match%lwt Ops.import_repo ~did ~car_data with
       | Error err ->
           render_err ~did ~handle ~old_pds err
       | Ok () ->
···
   match%lwt Remote.fetch_repo old_client ~did with
   | Error e ->
       render_err ("Failed to fetch repository: " ^ e)
-  | Ok car_data -> (
-    match%lwt
-      Ops.import_repo ~did ~car_data:(Bytes.of_string (fst car_data))
-    with
+  | Ok (car_data, _) -> (
+    match%lwt Ops.import_repo ~did ~car_data with
     | Error e ->
         render_err e
     | Ok () -> (
···
                       match%lwt Remote.fetch_repo client ~did with
                       | Error e ->
                           render_err ("Failed to fetch repository: " ^ e)
-                      | Ok car_data -> (
-                        match%lwt
-                          Ops.import_repo ~did
-                            ~car_data:(Bytes.of_string @@ fst car_data)
-                        with
+                      | Ok (car_data, _) -> (
+                        match%lwt Ops.import_repo ~did ~car_data with
                         | Error e ->
                             render_err e
                         | Ok () ->
···
               | Error e ->
                   render_err ~did ~handle ~old_pds
                     ("Failed to fetch repository: " ^ e)
-              | Ok car_data -> (
-                match%lwt
-                  Ops.import_repo ~did
-                    ~car_data:(Bytes.of_string @@ fst car_data)
-                with
+              | Ok (car_data, _) -> (
+                match%lwt Ops.import_repo ~did ~car_data with
                 | Error e ->
                     render_err ~did ~handle ~old_pds e
                 | Ok () -> (

pegasus/lib/api/account_/migrate/ops.ml

···
           | Error _ ->
               Lwt.return_error cid_str
           | Ok cid ->
-              let%lwt _ =
-                User_store.put_blob user_db cid mimetype (Bytes.of_string data)
-              in
+              let%lwt _ = User_store.put_blob user_db cid mimetype data in
               Lwt.return_ok cid_str ) )
       cids
   in