commit e73459d27b0d65f99b4143f567ea1b194cb43dbe · anil.recoil.org/slop

claudeio/.gitignore

···

       1
       1
       +
       _build

claudeio/CLAUDE.md

···

       1
       1
       +
       I want a high quality OCaml Eio library that wraps `claude` Claude Code CLI invocations in an Eio style library. It should use the JSON input and output streaming modes of the CLI, and expose these as JSON messages using ezjsonm and good Eio abstractions (like using Buf_read and Seq)

+27

claudeio/claude.opam

···

       1
       1
       +
       # This file is generated by dune, edit dune-project instead

     

       2
       2
       +
       opam-version: "2.0"

     

       3
       3
       +
       synopsis: "OCaml client library for Claude CLI"

     

       4
       4
       +
       description:

     

       5
       5
       +
         "An Eio-based OCaml library for interacting with the Claude CLI using JSON streaming"

     

       6
       6
       +
       depends: [

     

       7
       7
       +
         "ocaml"

     

       8
       8
       +
         "dune" {>= "3.0"}

     

       9
       9
       +
         "eio"

     

       10
       10
       +
         "ezjsonm"

     

       11
       11
       +
         "alcotest" {with-test}

     

       12
       12
       +
         "odoc" {with-doc}

     

       13
       13
       +
       ]

     

       14
       14
       +
       build: [

     

       15
       15
       +
         ["dune" "subst"] {dev}

     

       16
       16
       +
         [

     

       17
       17
       +
           "dune"

     

       18
       18
       +
           "build"

     

       19
       19
       +
           "-p"

     

       20
       20
       +
           name

     

       21
       21
       +
           "-j"

     

       22
       22
       +
           jobs

     

       23
       23
       +
           "@install"

     

       24
       24
       +
           "@runtest" {with-test}

     

       25
       25
       +
           "@doc" {with-doc}

     

       26
       26
       +
         ]

     

       27
       27
       +
       ]

+14

claudeio/dune-project

···

       1
       1
       +
       (lang dune 3.0)

     

       2
       2
       +
       (name claude)

     

       3
       3
       +
       (generate_opam_files true)

     

       4
       4
       +
       

     

       5
       5
       +
       (package

     

       6
       6
       +
        (name claude)

     

       7
       7
       +
        (synopsis "OCaml client library for Claude CLI")

     

       8
       8
       +
        (description "An Eio-based OCaml library for interacting with the Claude CLI using JSON streaming")

     

       9
       9
       +
        (depends

     

       10
       10
       +
         ocaml

     

       11
       11
       +
         dune

     

       12
       12
       +
         eio

     

       13
       13
       +
         ezjsonm

     

       14
       14
       +
         (alcotest :with-test)))

claudeio/lib/claude.ml

···

       1
       1
       +
       module Types = Types

     

       2
       2
       +
       module Message = Message

     

       3
       3
       +
       module Permissions = Permissions

     

       4
       4
       +
       module Options = Options

     

       5
       5
       +
       module Transport = Transport

     

       6
       6
       +
       module Client = Client

claudeio/lib/claude.mli

···

       1
       1
       +
       module Types = Types

     

       2
       2
       +
       module Message = Message

     

       3
       3
       +
       module Permissions = Permissions

     

       4
       4
       +
       module Options = Options

     

       5
       5
       +
       module Transport = Transport

     

       6
       6
       +
       module Client = Client

+153

claudeio/lib/client.ml

···

       1
       1
       +
       open Eio.Std

     

       2
       2
       +
       

     

       3
       3
       +
       type t = {

     

       4
       4
       +
         transport : Transport.t;

     

       5
       5
       +
         receive_stream : Types.message Eio.Stream.t;

     

       6
       6
       +
         receive_fiber : unit Eio.Promise.or_exn;

     

       7
       7
       +
         control_stream : Types.control_message Eio.Stream.t;

     

       8
       8
       +
         permission_callback : Permissions.callback option;

     

       9
       9
       +
         permission_log : Permissions.rule list ref option;

     

       10
       10
       +
         mutable session_id : string option;

     

       11
       11
       +
       }

     

       12
       12
       +
       

     

       13
       13
       +
       let handle_control_request t control_msg =

     

       14
       14
       +
         let open Ezjsonm in

     

       15
       15
       +
         match find control_msg.Types.data ["request"; "subtype"] |> get_string with

     

       16
       16
       +
         | "can_use_tool" ->

     

       17
       17
       +
             let tool_name = find control_msg.data ["request"; "tool_name"] |> get_string in

     

       18
       18
       +
             let input = find control_msg.data ["request"; "input"] in

     

       19
       19
       +
             let suggestions = 

     

       20
       20
       +
               try

     

       21
       21
       +
                 let sugg_json = find control_msg.data ["request"; "permission_suggestions"] in

     

       22
       22
       +
                 match sugg_json with

     

       23
       23
       +
                 | `A _ -> 

     

       24
       24
       +
                     (* TODO: Parse permission suggestions *)

     

       25
       25
       +
                     []

     

       26
       26
       +
                 | _ -> []

     

       27
       27
       +
               with Not_found -> []

     

       28
       28
       +
             in

     

       29
       29
       +
             let context = Permissions.{ suggestions } in

     

       30
       30
       +
             

     

       31
       31
       +
             let result = match t.permission_callback with

     

       32
       32
       +
               | Some callback -> callback ~tool_name ~input ~context

     

       33
       33
       +
               | None -> Permissions.default_allow_callback ~tool_name ~input ~context

     

       34
       34
       +
             in

     

       35
       35
       +
             

     

       36
       36
       +
             let response = dict [

     

       37
       37
       +
               "type", string "control_response";

     

       38
       38
       +
               "response", dict [

     

       39
       39
       +
                 "subtype", string "success";

     

       40
       40
       +
                 "request_id", string control_msg.request_id;

     

       41
       41
       +
                 "response", Permissions.serialize_result result

     

       42
       42
       +
               ]

     

       43
       43
       +
             ] in

     

       44
       44
       +
             Transport.send t.transport response

     

       45
       45
       +
         

     

       46
       46
       +
         | subtype ->

     

       47
       47
       +
             (* Respond with error for unknown control requests *)

     

       48
       48
       +
             let response = dict [

     

       49
       49
       +
               "type", string "control_response";

     

       50
       50
       +
               "response", dict [

     

       51
       51
       +
                 "subtype", string "error";

     

       52
       52
       +
                 "request_id", string control_msg.request_id;

     

       53
       53
       +
                 "error", string (Printf.sprintf "Unsupported control request: %s" subtype)

     

       54
       54
       +
               ]

     

       55
       55
       +
             ] in

     

       56
       56
       +
             Transport.send t.transport response

     

       57
       57
       +
       

     

       58
       58
       +
       let receiver_loop t =

     

       59
       59
       +
         let rec loop () =

     

       60
       60
       +
           match Transport.receive_line t.transport with

     

       61
       61
       +
           | None -> ()  (* EOF *)

     

       62
       62
       +
           | Some line ->

     

       63
       63
       +
                 try

     

       64
       64
       +
                   let json = Ezjsonm.value_from_string line in

     

       65
       65
       +
                   

     

       66
       66
       +
                   (* Check if it's a control request *)

     

       67
       67
       +
                   match Ezjsonm.find json ["type"] |> Ezjsonm.get_string with

     

       68
       68
       +
                   | "control_request" ->

     

       69
       69
       +
                       let control_msg = Types.{

     

       70
       70
       +
                         request_id = Ezjsonm.find json ["request_id"] |> Ezjsonm.get_string;

     

       71
       71
       +
                         subtype = Ezjsonm.find json ["request"; "subtype"] |> Ezjsonm.get_string;

     

       72
       72
       +
                         data = json;

     

       73
       73
       +
                       } in

     

       74
       74
       +
                       Eio.Stream.add t.control_stream control_msg;

     

       75
       75
       +
                       handle_control_request t control_msg

     

       76
       76
       +
                   

     

       77
       77
       +
                   | _ ->

     

       78
       78
       +
                       (* Regular message *)

     

       79
       79
       +
                       let msg = Message.parse json in

     

       80
       80
       +
                       

     

       81
       81
       +
                       (* Extract session ID from system messages *)

     

       82
       82
       +
                       (match msg with

     

       83
       83
       +
                       | Types.System { subtype = "init"; data } ->

     

       84
       84
       +
                           (try

     

       85
       85
       +
                             t.session_id <- Some (Ezjsonm.find data ["session_id"] |> Ezjsonm.get_string)

     

       86
       86
       +
                           with Not_found -> ())

     

       87
       87
       +
                       | _ -> ());

     

       88
       88
       +
                       

     

       89
       89
       +
                       Eio.Stream.add t.receive_stream msg

     

       90
       90
       +
                 with

     

       91
       91
       +
                 | exn ->

     

       92
       92
       +
                     traceln "Failed to parse message: %s\nLine: %s" 

     

       93
       93
       +
                       (Printexc.to_string exn) line;

     

       94
       94
       +
                 loop ()

     

       95
       95
       +
         in

     

       96
       96
       +
         try

     

       97
       97
       +
           loop ()

     

       98
       98
       +
         with

     

       99
       99
       +
         | exn ->

     

       100
       100
       +
             traceln "Receiver loop error: %s" (Printexc.to_string exn);

     

       101
       101
       +
             raise exn

     

       102
       102
       +
       

     

       103
       103
       +
       let create ?(options = Options.default) ~sw ~process_mgr ~fs () =

     

       104
       104
       +
         let transport = Transport.create ~sw ~process_mgr ~fs ~options () in

     

       105
       105
       +
         let receive_stream = Eio.Stream.create 100 in

     

       106
       106
       +
         let control_stream = Eio.Stream.create 10 in

     

       107
       107
       +
         

     

       108
       108
       +
         let t = {

     

       109
       109
       +
           transport;

     

       110
       110
       +
           receive_stream;

     

       111
       111
       +
           receive_fiber = Eio.Promise.create_resolved (Ok ());  (* Placeholder *)

     

       112
       112
       +
           control_stream;

     

       113
       113
       +
           permission_callback = options.permission_callback;

     

       114
       114
       +
           permission_log = None;

     

       115
       115
       +
           session_id = None;

     

       116
       116
       +
         } in

     

       117
       117
       +
         

     

       118
       118
       +
         (* Start receiver fiber *)

     

       119
       119
       +
         let receive_fiber = Fiber.fork_promise ~sw (fun () -> receiver_loop t) in

     

       120
       120
       +
         

     

       121
       121
       +
         { t with receive_fiber }

     

       122
       122
       +
       

     

       123
       123
       +
       let query t prompt =

     

       124
       124
       +
         let msg = Message.serialize_user_message (`String prompt) in

     

       125
       125
       +
         Transport.send t.transport msg

     

       126
       126
       +
       

     

       127
       127
       +
       let send_message t json =

     

       128
       128
       +
         Transport.send t.transport json

     

       129
       129
       +
       

     

       130
       130
       +
       let receive t =

     

       131
       131
       +
         t.receive_stream

     

       132
       132
       +
       

     

       133
       133
       +
       let receive_all t =

     

       134
       134
       +
         let rec collect acc =

     

       135
       135
       +
           match Eio.Stream.take t.receive_stream with

     

       136
       136
       +
           | Types.Result _ as msg -> List.rev (msg :: acc)

     

       137
       137
       +
           | msg -> collect (msg :: acc)

     

       138
       138
       +
         in

     

       139
       139
       +
         collect []

     

       140
       140
       +
       

     

       141
       141
       +
       let interrupt t =

     

       142
       142
       +
         Transport.interrupt t.transport

     

       143
       143
       +
       

     

       144
       144
       +
       let discover_permissions t =

     

       145
       145
       +
         let log = ref [] in

     

       146
       146
       +
         let callback = Permissions.discovery_callback log in

     

       147
       147
       +
         { t with 

     

       148
       148
       +
           permission_callback = Some callback;

     

       149
       149
       +
           permission_log = Some log

     

       150
       150
       +
         }

     

       151
       151
       +
       

     

       152
       152
       +
       let with_permission_callback t callback =

     

       153
       153
       +
         { t with permission_callback = Some callback }

+19

claudeio/lib/client.mli

···

       1
       1
       +
       type t

     

       2
       2
       +
       

     

       3
       3
       +
       val create : 

     

       4
       4
       +
         ?options:Options.t -> 

     

       5
       5
       +
         sw:Eio.Switch.t -> 

     

       6
       6
       +
         process_mgr:_ Eio.Process.mgr ->

     

       7
       7
       +
         fs:Eio.Fs.dir_ty Eio.Path.t ->

     

       8
       8
       +
         unit -> t

     

       9
       9
       +
       

     

       10
       10
       +
       val query : t -> string -> unit

     

       11
       11
       +
       val send_message : t -> Ezjsonm.value -> unit

     

       12
       12
       +
       

     

       13
       13
       +
       val receive : t -> Types.message Eio.Stream.t

     

       14
       14
       +
       val receive_all : t -> Types.message list

     

       15
       15
       +
       

     

       16
       16
       +
       val interrupt : t -> unit

     

       17
       17
       +
       

     

       18
       18
       +
       val discover_permissions : t -> t

     

       19
       19
       +
       val with_permission_callback : t -> Permissions.callback -> t

claudeio/lib/dune

···

       1
       1
       +
       (library

     

       2
       2
       +
        (public_name claude)

     

       3
       3
       +
        (name claude)

     

       4
       4
       +
        (libraries eio eio.unix ezjsonm))

+109

claudeio/lib/message.ml

···

       1
       1
       +
       open Types

     

       2
       2
       +
       

     

       3
       3
       +
       exception Message_parse_error of string * Ezjsonm.value

     

       4
       4
       +
       

     

       5
       5
       +
       let parse_content_block json =

     

       6
       6
       +
         let open Ezjsonm in

     

       7
       7
       +
         match find json ["type"] |> get_string with

     

       8
       8
       +
         | "text" ->

     

       9
       9
       +
             Text { text = find json ["text"] |> get_string }

     

       10
       10
       +
         | "tool_use" ->

     

       11
       11
       +
             ToolUse {

     

       12
       12
       +
               id = find json ["id"] |> get_string;

     

       13
       13
       +
               name = find json ["name"] |> get_string;

     

       14
       14
       +
               input = find json ["input"];

     

       15
       15
       +
             }

     

       16
       16
       +
         | "tool_result" ->

     

       17
       17
       +
             ToolResult {

     

       18
       18
       +
               tool_use_id = find json ["tool_use_id"] |> get_string;

     

       19
       19
       +
               content = (try Some (find json ["content"] |> get_string) with Not_found -> None);

     

       20
       20
       +
               is_error = (try Some (find json ["is_error"] |> get_bool) with Not_found -> None);

     

       21
       21
       +
             }

     

       22
       22
       +
         | "thinking" ->

     

       23
       23
       +
             Thinking {

     

       24
       24
       +
               thinking = find json ["thinking"] |> get_string;

     

       25
       25
       +
               signature = find json ["signature"] |> get_string;

     

       26
       26
       +
             }

     

       27
       27
       +
         | t -> raise (Message_parse_error (Printf.sprintf "Unknown content block type: %s" t, json))

     

       28
       28
       +
       

     

       29
       29
       +
       let parse json =

     

       30
       30
       +
         let open Ezjsonm in

     

       31
       31
       +
         try

     

       32
       32
       +
           match find json ["type"] |> get_string with

     

       33
       33
       +
           | "user" ->

     

       34
       34
       +
               let message = find json ["message"] in

     

       35
       35
       +
               let content_json = find message ["content"] in

     

       36
       36
       +
               let content = 

     

       37
       37
       +
                 match content_json with

     

       38
       38
       +
                 | `String s -> `String s

     

       39
       39
       +
                 | `A blocks ->

     

       40
       40
       +
                     let parsed_blocks = List.map parse_content_block blocks in

     

       41
       41
       +
                     `Blocks parsed_blocks

     

       42
       42
       +
                 | _ -> `String (value_to_string content_json)

     

       43
       43
       +
               in

     

       44
       44
       +
               User { content }

     

       45
       45
       +
           

     

       46
       46
       +
           | "assistant" ->

     

       47
       47
       +
               let message = find json ["message"] in

     

       48
       48
       +
               let content_blocks = find message ["content"] |> get_list parse_content_block in

     

       49
       49
       +
               let model = find message ["model"] |> get_string in

     

       50
       50
       +
               Assistant { content = content_blocks; model }

     

       51
       51
       +
           

     

       52
       52
       +
           | "system" ->

     

       53
       53
       +
               let subtype = find json ["subtype"] |> get_string in

     

       54
       54
       +
               System { subtype; data = json }

     

       55
       55
       +
           

     

       56
       56
       +
           | "result" ->

     

       57
       57
       +
               Result {

     

       58
       58
       +
                 subtype = find json ["subtype"] |> get_string;

     

       59
       59
       +
                 duration_ms = find json ["duration_ms"] |> get_int;

     

       60
       60
       +
                 duration_api_ms = find json ["duration_api_ms"] |> get_int;

     

       61
       61
       +
                 is_error = find json ["is_error"] |> get_bool;

     

       62
       62
       +
                 num_turns = find json ["num_turns"] |> get_int;

     

       63
       63
       +
                 session_id = find json ["session_id"] |> get_string;

     

       64
       64
       +
                 total_cost_usd = (try Some (find json ["total_cost_usd"] |> get_float) with Not_found -> None);

     

       65
       65
       +
                 usage = (try Some (find json ["usage"]) with Not_found -> None);

     

       66
       66
       +
                 result = (try Some (find json ["result"] |> get_string) with Not_found -> None);

     

       67
       67
       +
               }

     

       68
       68
       +
           

     

       69
       69
       +
           | msg_type -> 

     

       70
       70
       +
               raise (Message_parse_error (Printf.sprintf "Unknown message type: %s" msg_type, json))

     

       71
       71
       +
         with

     

       72
       72
       +
         | Message_parse_error _ as e -> raise e

     

       73
       73
       +
         | e -> 

     

       74
       74
       +
             raise (Message_parse_error (Printf.sprintf "Failed to parse message: %s" (Printexc.to_string e), json))

     

       75
       75
       +
       

     

       76
       76
       +
       let serialize_user_message content =

     

       77
       77
       +
         let open Ezjsonm in

     

       78
       78
       +
         let content_json = 

     

       79
       79
       +
           match content with

     

       80
       80
       +
           | `String s -> string s

     

       81
       81
       +
           | `Blocks blocks ->

     

       82
       82
       +
               let serialize_block = function

     

       83
       83
       +
                 | Text { text } ->

     

       84
       84
       +
                     dict [ "type", string "text"; "text", string text ]

     

       85
       85
       +
                 | ToolUse { id; name; input } ->

     

       86
       86
       +
                     dict [ "type", string "tool_use"; "id", string id; "name", string name; "input", input ]

     

       87
       87
       +
                 | ToolResult { tool_use_id; content; is_error } ->

     

       88
       88
       +
                     let fields = [ "type", string "tool_result"; "tool_use_id", string tool_use_id ] in

     

       89
       89
       +
                     let fields = match content with

     

       90
       90
       +
                       | Some c -> ("content", string c) :: fields

     

       91
       91
       +
                       | None -> fields

     

       92
       92
       +
                     in

     

       93
       93
       +
                     let fields = match is_error with

     

       94
       94
       +
                       | Some e -> ("is_error", bool e) :: fields

     

       95
       95
       +
                       | None -> fields

     

       96
       96
       +
                     in

     

       97
       97
       +
                     dict fields

     

       98
       98
       +
                 | Thinking { thinking; signature } ->

     

       99
       99
       +
                     dict [ "type", string "thinking"; "thinking", string thinking; "signature", string signature ]

     

       100
       100
       +
               in

     

       101
       101
       +
               list serialize_block blocks

     

       102
       102
       +
         in

     

       103
       103
       +
         dict [

     

       104
       104
       +
           "type", string "user";

     

       105
       105
       +
           "message", dict [

     

       106
       106
       +
             "role", string "user";

     

       107
       107
       +
             "content", content_json

     

       108
       108
       +
           ]

     

       109
       109
       +
         ]

claudeio/lib/message.mli

···

       1
       1
       +
       exception Message_parse_error of string * Ezjsonm.value

     

       2
       2
       +
       

     

       3
       3
       +
       val parse : Ezjsonm.value -> Types.message

     

       4
       4
       +
       

     

       5
       5
       +
       val serialize_user_message : 

     

       6
       6
       +
         [ `String of string | `Blocks of Types.content_block list ] -> 

     

       7
       7
       +
         Ezjsonm.value

+25

claudeio/lib/options.ml

···

       1
       1
       +
       type t = {

     

       2
       2
       +
         allowed_tools : string list;

     

       3
       3
       +
         disallowed_tools : string list;

     

       4
       4
       +
         max_thinking_tokens : int;

     

       5
       5
       +
         system_prompt : string option;

     

       6
       6
       +
         append_system_prompt : string option;

     

       7
       7
       +
         permission_mode : [ `Default | `AcceptEdits | `Plan | `BypassPermissions ] option;

     

       8
       8
       +
         permission_callback : Permissions.callback option;

     

       9
       9
       +
         model : string option;

     

       10
       10
       +
         cwd : Eio.Fs.dir_ty Eio.Path.t option;

     

       11
       11
       +
         env : (string * string) list;

     

       12
       12
       +
       }

     

       13
       13
       +
       

     

       14
       14
       +
       let default = {

     

       15
       15
       +
         allowed_tools = [];

     

       16
       16
       +
         disallowed_tools = [];

     

       17
       17
       +
         max_thinking_tokens = 8000;

     

       18
       18
       +
         system_prompt = None;

     

       19
       19
       +
         append_system_prompt = None;

     

       20
       20
       +
         permission_mode = None;

     

       21
       21
       +
         permission_callback = Some Permissions.default_allow_callback;

     

       22
       22
       +
         model = None;

     

       23
       23
       +
         cwd = None;

     

       24
       24
       +
         env = [];

     

       25
       25
       +
       }

+14

claudeio/lib/options.mli

···

       1
       1
       +
       type t = {

     

       2
       2
       +
         allowed_tools : string list;

     

       3
       3
       +
         disallowed_tools : string list;

     

       4
       4
       +
         max_thinking_tokens : int;

     

       5
       5
       +
         system_prompt : string option;

     

       6
       6
       +
         append_system_prompt : string option;

     

       7
       7
       +
         permission_mode : [ `Default | `AcceptEdits | `Plan | `BypassPermissions ] option;

     

       8
       8
       +
         permission_callback : Permissions.callback option;

     

       9
       9
       +
         model : string option;

     

       10
       10
       +
         cwd : Eio.Fs.dir_ty Eio.Path.t option;

     

       11
       11
       +
         env : (string * string) list;

     

       12
       12
       +
       }

     

       13
       13
       +
       

     

       14
       14
       +
       val default : t

+59

claudeio/lib/permissions.ml

···

       1
       1
       +
       type behavior = Allow | Deny | Ask

     

       2
       2
       +
       

     

       3
       3
       +
       type rule = {

     

       4
       4
       +
         tool_name : string;

     

       5
       5
       +
         rule_content : string option;

     

       6
       6
       +
       }

     

       7
       7
       +
       

     

       8
       8
       +
       type update = {

     

       9
       9
       +
         behavior : behavior;

     

       10
       10
       +
         rules : rule list;

     

       11
       11
       +
       }

     

       12
       12
       +
       

     

       13
       13
       +
       type context = {

     

       14
       14
       +
         suggestions : update list;

     

       15
       15
       +
       }

     

       16
       16
       +
       

     

       17
       17
       +
       type result =

     

       18
       18
       +
         | Allow of {

     

       19
       19
       +
             updated_input : Ezjsonm.value option;

     

       20
       20
       +
             updated_permissions : update list option;

     

       21
       21
       +
           }

     

       22
       22
       +
         | Deny of {

     

       23
       23
       +
             message : string;

     

       24
       24
       +
             interrupt : bool;

     

       25
       25
       +
           }

     

       26
       26
       +
       

     

       27
       27
       +
       type callback = 

     

       28
       28
       +
         tool_name:string -> 

     

       29
       29
       +
         input:Ezjsonm.value -> 

     

       30
       30
       +
         context:context -> 

     

       31
       31
       +
         result

     

       32
       32
       +
       

     

       33
       33
       +
       let serialize_result = function

     

       34
       34
       +
         | Allow { updated_input; updated_permissions = _ } ->

     

       35
       35
       +
             let open Ezjsonm in

     

       36
       36
       +
             let fields = [ "behavior", string "allow" ] in

     

       37
       37
       +
             let fields = match updated_input with

     

       38
       38
       +
               | Some input -> ("updated_input", input) :: fields

     

       39
       39
       +
               | None -> fields

     

       40
       40
       +
             in

     

       41
       41
       +
             dict fields

     

       42
       42
       +
         | Deny { message; interrupt } ->

     

       43
       43
       +
             let open Ezjsonm in

     

       44
       44
       +
             dict [

     

       45
       45
       +
               "behavior", string "deny";

     

       46
       46
       +
               "message", string message;

     

       47
       47
       +
               "interrupt", bool interrupt

     

       48
       48
       +
             ]

     

       49
       49
       +
       

     

       50
       50
       +
       let default_allow_callback ~tool_name:_ ~input:_ ~context:_ =

     

       51
       51
       +
         Allow { updated_input = None; updated_permissions = None }

     

       52
       52
       +
       

     

       53
       53
       +
       let discovery_callback log ~tool_name:_ ~input:_ ~context =

     

       54
       54
       +
         List.iter (fun update ->

     

       55
       55
       +
           List.iter (fun rule ->

     

       56
       56
       +
             log := rule :: !log

     

       57
       57
       +
           ) update.rules

     

       58
       58
       +
         ) context.suggestions;

     

       59
       59
       +
         Allow { updated_input = None; updated_permissions = None }

+37

claudeio/lib/permissions.mli

···

       1
       1
       +
       type behavior = Allow | Deny | Ask

     

       2
       2
       +
       

     

       3
       3
       +
       type rule = {

     

       4
       4
       +
         tool_name : string;

     

       5
       5
       +
         rule_content : string option;

     

       6
       6
       +
       }

     

       7
       7
       +
       

     

       8
       8
       +
       type update = {

     

       9
       9
       +
         behavior : behavior;

     

       10
       10
       +
         rules : rule list;

     

       11
       11
       +
       }

     

       12
       12
       +
       

     

       13
       13
       +
       type context = {

     

       14
       14
       +
         suggestions : update list;

     

       15
       15
       +
       }

     

       16
       16
       +
       

     

       17
       17
       +
       type result =

     

       18
       18
       +
         | Allow of {

     

       19
       19
       +
             updated_input : Ezjsonm.value option;

     

       20
       20
       +
             updated_permissions : update list option;

     

       21
       21
       +
           }

     

       22
       22
       +
         | Deny of {

     

       23
       23
       +
             message : string;

     

       24
       24
       +
             interrupt : bool;

     

       25
       25
       +
           }

     

       26
       26
       +
       

     

       27
       27
       +
       type callback = 

     

       28
       28
       +
         tool_name:string -> 

     

       29
       29
       +
         input:Ezjsonm.value -> 

     

       30
       30
       +
         context:context -> 

     

       31
       31
       +
         result

     

       32
       32
       +
       

     

       33
       33
       +
       val serialize_result : result -> Ezjsonm.value

     

       34
       34
       +
       

     

       35
       35
       +
       val default_allow_callback : callback

     

       36
       36
       +
       

     

       37
       37
       +
       val discovery_callback : rule list ref -> callback

+154

claudeio/lib/transport.ml

···

       1
       1
       +
       open Eio.Std

     

       2
       2
       +
       

     

       3
       3
       +
       exception CLI_not_found of string

     

       4
       4
       +
       exception Process_error of string

     

       5
       5
       +
       exception Connection_error of string

     

       6
       6
       +
       

     

       7
       7
       +
       type process = P : _ Eio.Process.t -> process

     

       8
       8
       +
       

     

       9
       9
       +
       type t = {

     

       10
       10
       +
         process : process;

     

       11
       11
       +
         stdin : Eio.Flow.sink_ty r;

     

       12
       12
       +
         stdin_close : [`Close | `Flow] r;

     

       13
       13
       +
         stdout : Eio.Buf_read.t;

     

       14
       14
       +
         sw : Switch.t;

     

       15
       15
       +
       }

     

       16
       16
       +
       

     

       17
       17
       +
       let find_claude_cli ~fs =

     

       18
       18
       +
         let ( / ) = Eio.Path.( / ) in

     

       19
       19
       +
         let paths = [

     

       20
       20
       +
           fs / "usr" / "local" / "bin" / "claude";

     

       21
       21
       +
           fs / "opt" / "homebrew" / "bin" / "claude";

     

       22
       22
       +
         ] in

     

       23
       23
       +
         

     

       24
       24
       +
         let rec check_paths = function

     

       25
       25
       +
           | [] -> 

     

       26
       26
       +
               (* Try using 'which' *)

     

       27
       27
       +
               None

     

       28
       28
       +
           | path :: rest ->

     

       29
       29
       +
               if Eio.Path.is_file path then

     

       30
       30
       +
                 Some (Eio.Path.native_exn path)

     

       31
       31
       +
               else

     

       32
       32
       +
                 check_paths rest

     

       33
       33
       +
         in

     

       34
       34
       +
         

     

       35
       35
       +
         match check_paths paths with

     

       36
       36
       +
         | Some path -> path

     

       37
       37
       +
         | None ->

     

       38
       38
       +
             (* Try to find using shell *)

     

       39
       39
       +
             "claude"

     

       40
       40
       +
       

     

       41
       41
       +
       let build_command ~claude_path ~options =

     

       42
       42
       +
         let open Options in

     

       43
       43
       +
         let cmd = [claude_path; "--output-format"; "stream-json"; "--verbose"] in

     

       44
       44
       +
         

     

       45
       45
       +
         let cmd = match options.system_prompt with

     

       46
       46
       +
           | Some prompt -> cmd @ ["--system-prompt"; prompt]

     

       47
       47
       +
           | None -> cmd

     

       48
       48
       +
         in

     

       49
       49
       +
         

     

       50
       50
       +
         let cmd = match options.append_system_prompt with

     

       51
       51
       +
           | Some prompt -> cmd @ ["--append-system-prompt"; prompt]

     

       52
       52
       +
           | None -> cmd

     

       53
       53
       +
         in

     

       54
       54
       +
         

     

       55
       55
       +
         let cmd = match options.allowed_tools with

     

       56
       56
       +
           | [] -> cmd

     

       57
       57
       +
           | tools -> cmd @ ["--allowedTools"; String.concat "," tools]

     

       58
       58
       +
         in

     

       59
       59
       +
         

     

       60
       60
       +
         let cmd = match options.disallowed_tools with

     

       61
       61
       +
           | [] -> cmd

     

       62
       62
       +
           | tools -> cmd @ ["--disallowedTools"; String.concat "," tools]

     

       63
       63
       +
         in

     

       64
       64
       +
         

     

       65
       65
       +
         let cmd = match options.model with

     

       66
       66
       +
           | Some model -> cmd @ ["--model"; model]

     

       67
       67
       +
           | None -> cmd

     

       68
       68
       +
         in

     

       69
       69
       +
         

     

       70
       70
       +
         let cmd = match options.permission_mode with

     

       71
       71
       +
           | Some `Default -> cmd @ ["--permission-mode"; "default"]

     

       72
       72
       +
           | Some `AcceptEdits -> cmd @ ["--permission-mode"; "acceptEdits"]

     

       73
       73
       +
           | Some `Plan -> cmd @ ["--permission-mode"; "plan"]

     

       74
       74
       +
           | Some `BypassPermissions -> cmd @ ["--permission-mode"; "bypassPermissions"]

     

       75
       75
       +
           | None -> cmd

     

       76
       76
       +
         in

     

       77
       77
       +
         

     

       78
       78
       +
         (* Use streaming input mode *)

     

       79
       79
       +
         cmd @ ["--input-format"; "stream-json"]

     

       80
       80
       +
       

     

       81
       81
       +
       let create ~sw ~process_mgr ~fs ~options () =

     

       82
       82
       +
         let claude_path = find_claude_cli ~fs in

     

       83
       83
       +
         let cmd = build_command ~claude_path ~options in

     

       84
       84
       +
         

     

       85
       85
       +
         let env = 

     

       86
       86
       +
           Array.of_list (

     

       87
       87
       +
             List.map (fun (k, v) -> Printf.sprintf "%s=%s" k v) (

     

       88
       88
       +
               ("CLAUDE_CODE_ENTRYPOINT", "sdk-ocaml") ::

     

       89
       89
       +
               options.Options.env

     

       90
       90
       +
             )

     

       91
       91
       +
           )

     

       92
       92
       +
         in

     

       93
       93
       +
         

     

       94
       94
       +
         let stdin_r, stdin_w = Eio.Process.pipe ~sw process_mgr in

     

       95
       95
       +
         let stdout_r, stdout_w = Eio.Process.pipe ~sw process_mgr in

     

       96
       96
       +
         let stderr_r, stderr_w = Eio.Process.pipe ~sw process_mgr in

     

       97
       97
       +
         (* Close stderr pipes - we don't need them *)

     

       98
       98
       +
         Eio.Flow.close stderr_r;

     

       99
       99
       +
         Eio.Flow.close stderr_w;

     

       100
       100
       +
         

     

       101
       101
       +
         let process = 

     

       102
       102
       +
           try

     

       103
       103
       +
             Eio.Process.spawn ~sw process_mgr 

     

       104
       104
       +
               ~env

     

       105
       105
       +
               ~stdin:(stdin_r :> Eio.Flow.source_ty r)

     

       106
       106
       +
               ~stdout:(stdout_w :> Eio.Flow.sink_ty r)

     

       107
       107
       +
               ?cwd:options.Options.cwd

     

       108
       108
       +
               cmd

     

       109
       109
       +
           with

     

       110
       110
       +
           | exn ->

     

       111
       111
       +
               raise (CLI_not_found (Printf.sprintf "Failed to spawn claude CLI: %s" (Printexc.to_string exn)))

     

       112
       112
       +
         in

     

       113
       113
       +
         

     

       114
       114
       +
         let stdin = (stdin_w :> Eio.Flow.sink_ty r) in

     

       115
       115
       +
         let stdin_close = (stdin_w :> [`Close | `Flow] r) in

     

       116
       116
       +
         let stdout = Eio.Buf_read.of_flow ~max_size:1_000_000 (stdout_r :> Eio.Flow.source_ty r) in

     

       117
       117
       +
         

     

       118
       118
       +
         { process = P process; stdin; stdin_close; stdout; sw }

     

       119
       119
       +
       

     

       120
       120
       +
       let send t json =

     

       121
       121
       +
         let data = Ezjsonm.value_to_string json in

     

       122
       122
       +
         try

     

       123
       123
       +
           Eio.Flow.write t.stdin [Cstruct.of_string (data ^ "\n")]

     

       124
       124
       +
         with

     

       125
       125
       +
         | exn ->

     

       126
       126
       +
             raise (Connection_error (Printf.sprintf "Failed to send message: %s" (Printexc.to_string exn)))

     

       127
       127
       +
       

     

       128
       128
       +
       let receive_line t =

     

       129
       129
       +
         try

     

       130
       130
       +
           match Eio.Buf_read.line t.stdout with

     

       131
       131
       +
           | line -> Some line

     

       132
       132
       +
           | exception End_of_file -> None

     

       133
       133
       +
         with

     

       134
       134
       +
         | exn ->

     

       135
       135
       +
             raise (Connection_error (Printf.sprintf "Failed to receive message: %s" (Printexc.to_string exn)))

     

       136
       136
       +
       

     

       137
       137
       +
       let interrupt t =

     

       138
       138
       +
         let interrupt_msg = 

     

       139
       139
       +
           Ezjsonm.dict [

     

       140
       140
       +
             "type", Ezjsonm.string "control_response";

     

       141
       141
       +
             "response", Ezjsonm.dict [

     

       142
       142
       +
               "subtype", Ezjsonm.string "interrupt";

     

       143
       143
       +
               "request_id", Ezjsonm.string "";

     

       144
       144
       +
             ]

     

       145
       145
       +
           ]

     

       146
       146
       +
         in

     

       147
       147
       +
         send t interrupt_msg

     

       148
       148
       +
       

     

       149
       149
       +
       let close t =

     

       150
       150
       +
         try

     

       151
       151
       +
           Eio.Flow.close t.stdin_close;

     

       152
       152
       +
           let (P process) = t.process in

     

       153
       153
       +
           Eio.Process.await_exn process

     

       154
       154
       +
         with _ -> ()

+17

claudeio/lib/transport.mli

···

       1
       1
       +
       exception CLI_not_found of string

     

       2
       2
       +
       exception Process_error of string

     

       3
       3
       +
       exception Connection_error of string

     

       4
       4
       +
       

     

       5
       5
       +
       type t

     

       6
       6
       +
       

     

       7
       7
       +
       val create : 

     

       8
       8
       +
         sw:Eio.Switch.t ->

     

       9
       9
       +
         process_mgr:_ Eio.Process.mgr ->

     

       10
       10
       +
         fs:Eio.Fs.dir_ty Eio.Path.t ->

     

       11
       11
       +
         options:Options.t ->

     

       12
       12
       +
         unit -> t

     

       13
       13
       +
       

     

       14
       14
       +
       val send : t -> Ezjsonm.value -> unit

     

       15
       15
       +
       val receive_line : t -> string option

     

       16
       16
       +
       val interrupt : t -> unit

     

       17
       17
       +
       val close : t -> unit

+62

claudeio/lib/types.ml

···

       1
       1
       +
       type text_block = { text : string }

     

       2
       2
       +
       

     

       3
       3
       +
       type tool_use_block = { 

     

       4
       4
       +
         id : string; 

     

       5
       5
       +
         name : string; 

     

       6
       6
       +
         input : Ezjsonm.value 

     

       7
       7
       +
       }

     

       8
       8
       +
       

     

       9
       9
       +
       type tool_result_block = { 

     

       10
       10
       +
         tool_use_id : string; 

     

       11
       11
       +
         content : string option; 

     

       12
       12
       +
         is_error : bool option 

     

       13
       13
       +
       }

     

       14
       14
       +
       

     

       15
       15
       +
       type thinking_block = {

     

       16
       16
       +
         thinking : string;

     

       17
       17
       +
         signature : string;

     

       18
       18
       +
       }

     

       19
       19
       +
       

     

       20
       20
       +
       type content_block =

     

       21
       21
       +
         | Text of text_block

     

       22
       22
       +
         | ToolUse of tool_use_block

     

       23
       23
       +
         | ToolResult of tool_result_block

     

       24
       24
       +
         | Thinking of thinking_block

     

       25
       25
       +
       

     

       26
       26
       +
       type user_message = { 

     

       27
       27
       +
         content : [ `String of string | `Blocks of content_block list ] 

     

       28
       28
       +
       }

     

       29
       29
       +
       

     

       30
       30
       +
       type assistant_message = { 

     

       31
       31
       +
         content : content_block list; 

     

       32
       32
       +
         model : string 

     

       33
       33
       +
       }

     

       34
       34
       +
       

     

       35
       35
       +
       type system_message = { 

     

       36
       36
       +
         subtype : string; 

     

       37
       37
       +
         data : Ezjsonm.value 

     

       38
       38
       +
       }

     

       39
       39
       +
       

     

       40
       40
       +
       type result_message = {

     

       41
       41
       +
         subtype : string;

     

       42
       42
       +
         duration_ms : int;

     

       43
       43
       +
         duration_api_ms : int;

     

       44
       44
       +
         is_error : bool;

     

       45
       45
       +
         num_turns : int;

     

       46
       46
       +
         session_id : string;

     

       47
       47
       +
         total_cost_usd : float option;

     

       48
       48
       +
         usage : Ezjsonm.value option;

     

       49
       49
       +
         result : string option;

     

       50
       50
       +
       }

     

       51
       51
       +
       

     

       52
       52
       +
       type message =

     

       53
       53
       +
         | User of user_message

     

       54
       54
       +
         | Assistant of assistant_message

     

       55
       55
       +
         | System of system_message

     

       56
       56
       +
         | Result of result_message

     

       57
       57
       +
       

     

       58
       58
       +
       type control_message = {

     

       59
       59
       +
         request_id : string;

     

       60
       60
       +
         subtype : string;

     

       61
       61
       +
         data : Ezjsonm.value;

     

       62
       62
       +
       }

+62

claudeio/lib/types.mli

···

       1
       1
       +
       type text_block = { text : string }

     

       2
       2
       +
       

     

       3
       3
       +
       type tool_use_block = { 

     

       4
       4
       +
         id : string; 

     

       5
       5
       +
         name : string; 

     

       6
       6
       +
         input : Ezjsonm.value 

     

       7
       7
       +
       }

     

       8
       8
       +
       

     

       9
       9
       +
       type tool_result_block = { 

     

       10
       10
       +
         tool_use_id : string; 

     

       11
       11
       +
         content : string option; 

     

       12
       12
       +
         is_error : bool option 

     

       13
       13
       +
       }

     

       14
       14
       +
       

     

       15
       15
       +
       type thinking_block = {

     

       16
       16
       +
         thinking : string;

     

       17
       17
       +
         signature : string;

     

       18
       18
       +
       }

     

       19
       19
       +
       

     

       20
       20
       +
       type content_block =

     

       21
       21
       +
         | Text of text_block

     

       22
       22
       +
         | ToolUse of tool_use_block

     

       23
       23
       +
         | ToolResult of tool_result_block

     

       24
       24
       +
         | Thinking of thinking_block

     

       25
       25
       +
       

     

       26
       26
       +
       type user_message = { 

     

       27
       27
       +
         content : [ `String of string | `Blocks of content_block list ] 

     

       28
       28
       +
       }

     

       29
       29
       +
       

     

       30
       30
       +
       type assistant_message = { 

     

       31
       31
       +
         content : content_block list; 

     

       32
       32
       +
         model : string 

     

       33
       33
       +
       }

     

       34
       34
       +
       

     

       35
       35
       +
       type system_message = { 

     

       36
       36
       +
         subtype : string; 

     

       37
       37
       +
         data : Ezjsonm.value 

     

       38
       38
       +
       }

     

       39
       39
       +
       

     

       40
       40
       +
       type result_message = {

     

       41
       41
       +
         subtype : string;

     

       42
       42
       +
         duration_ms : int;

     

       43
       43
       +
         duration_api_ms : int;

     

       44
       44
       +
         is_error : bool;

     

       45
       45
       +
         num_turns : int;

     

       46
       46
       +
         session_id : string;

     

       47
       47
       +
         total_cost_usd : float option;

     

       48
       48
       +
         usage : Ezjsonm.value option;

     

       49
       49
       +
         result : string option;

     

       50
       50
       +
       }

     

       51
       51
       +
       

     

       52
       52
       +
       type message =

     

       53
       53
       +
         | User of user_message

     

       54
       54
       +
         | Assistant of assistant_message

     

       55
       55
       +
         | System of system_message

     

       56
       56
       +
         | Result of result_message

     

       57
       57
       +
       

     

       58
       58
       +
       type control_message = {

     

       59
       59
       +
         request_id : string;

     

       60
       60
       +
         subtype : string;

     

       61
       61
       +
         data : Ezjsonm.value;

     

       62
       62
       +
       }

+65

claudeio/test/camel_jokes.ml

···

       1
       1
       +
       open Eio.Std

     

       2
       2
       +
       

     

       3
       3
       +
       let process_claude_response client name =

     

       4
       4
       +
         traceln "\n=== %s's Response ===" name;

     

       5
       5
       +
         let messages = Claude.Client.receive_all client in

     

       6
       6
       +
         List.iter (fun msg ->

     

       7
       7
       +
           match msg with

     

       8
       8
       +
           | Claude.Types.Assistant msg ->

     

       9
       9
       +
               List.iter (function

     

       10
       10
       +
                 | Claude.Types.Text { text } -> 

     

       11
       11
       +
                     traceln "%s: %s" name text

     

       12
       12
       +
                 | _ -> ()

     

       13
       13
       +
               ) msg.content

     

       14
       14
       +
           | Claude.Types.Result msg ->

     

       15
       15
       +
               if msg.is_error then

     

       16
       16
       +
                 traceln "Error from %s!" name

     

       17
       17
       +
               else

     

       18
       18
       +
                 (match msg.total_cost_usd with

     

       19
       19
       +
                 | Some cost -> traceln "%s's joke cost: $%.6f" name cost

     

       20
       20
       +
                 | None -> ())

     

       21
       21
       +
           | _ -> ()

     

       22
       22
       +
         ) messages

     

       23
       23
       +
       

     

       24
       24
       +
       let run_claude ~sw ~env name prompt =

     

       25
       25
       +
         traceln "Starting %s..." name;

     

       26
       26
       +
         let options = Claude.Options.{

     

       27
       27
       +
           default with

     

       28
       28
       +
           model = Some "claude-3-5-sonnet-20241022";

     

       29
       29
       +
           (* Allow Claude to be creative *)

     

       30
       30
       +
           allowed_tools = [];

     

       31
       31
       +
         } in

     

       32
       32
       +
         

     

       33
       33
       +
         let client = Claude.Client.create ~options ~sw 

     

       34
       34
       +
           ~process_mgr:env#process_mgr 

     

       35
       35
       +
           ~fs:env#fs 

     

       36
       36
       +
           () in

     

       37
       37
       +
         

     

       38
       38
       +
         Claude.Client.query client prompt;

     

       39
       39
       +
         process_claude_response client name

     

       40
       40
       +
       

     

       41
       41
       +
       let main ~env =

     

       42
       42
       +
         Switch.run @@ fun sw ->

     

       43
       43
       +
         

     

       44
       44
       +
         traceln "🐪 Starting the Great Camel Joke Competition! 🐪";

     

       45
       45
       +
         traceln "================================================\n";

     

       46
       46
       +
         

     

       47
       47
       +
         let prompts = [

     

       48
       48
       +
           "Claude 1", "Tell me a short, funny joke about camels! Make it original and clever.";

     

       49
       49
       +
           "Claude 2", "Give me your best camel joke - something witty and unexpected!";

     

       50
       50
       +
           "Claude 3", "Share a hilarious camel joke that will make everyone laugh!";

     

       51
       51
       +
         ] in

     

       52
       52
       +
         

     

       53
       53
       +
         (* Run all three Claudes concurrently *)

     

       54
       54
       +
         Fiber.all (

     

       55
       55
       +
           List.map (fun (name, prompt) ->

     

       56
       56
       +
             fun () -> run_claude ~sw ~env name prompt

     

       57
       57
       +
           ) prompts

     

       58
       58
       +
         );

     

       59
       59
       +
         

     

       60
       60
       +
         traceln "\n================================================";

     

       61
       61
       +
         traceln "🎉 The Camel Joke Competition is complete! 🎉"

     

       62
       62
       +
       

     

       63
       63
       +
       let () =

     

       64
       64
       +
         Eio_main.run @@ fun env ->

     

       65
       65
       +
         main ~env

claudeio/test/dune

···

       1
       1
       +
       (executable

     

       2
       2
       +
        (public_name camel_jokes)

     

       3
       3
       +
        (name camel_jokes)

     

       4
       4
       +
        (libraries claude eio_main))