starflow

-module(starflow@api_request).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([create_message/3]).
-export_type([api_error/0]).

-type api_error() :: {network_error, binary()} |
    decoding_error |
    {invalid_response, integer(), binary()}.

-file("/home/ethanthoma/projects/flow/src/starflow/api_request.gleam", 40).
-spec add_headers(
    gleam@http@request:request(JAU),
    starflow@model:model(),
    starflow@api_key:api_key()
) -> gleam@http@request:request(JAU).
add_headers(Req, Model, Api_key) ->
    _pipe = Req,
    _pipe@1 = gleam@http@request:set_header(
        _pipe,
        <<"content-type"/utf8>>,
        <<"application/json"/utf8>>
    ),
    _pipe@2 = gleam@http@request:set_header(
        _pipe@1,
        <<"x-api-key"/utf8>>,
        starflow@api_key:get(Api_key)
    ),
    gleam@http@request:set_header(
        _pipe@2,
        <<"anthropic-version"/utf8>>,
        starflow@providers:version(erlang:element(2, Model))
    ).

-file("/home/ethanthoma/projects/flow/src/starflow/api_request.gleam", 99).
-spec create_message(
    starflow@model:model(),
    list(starflow@state:message()),
    list(starflow@tool:tool())
) -> {ok, starflow@state:response()} | {error, api_error()}.
create_message(Model, Messages, Tools) ->
    gleam@result:'try'(
        begin
            _pipe = gleam@http@request:to(
                gleam@string:concat(
                    [starflow@providers:url(erlang:element(2, Model)),
                        <<"/messages"/utf8>>]
                )
            ),
            gleam@result:map_error(_pipe, fun(_) -> decoding_error end)
        end,
        fun(Req) ->
            Req@1 = begin
                _pipe@1 = Req,
                _pipe@2 = gleam@http@request:set_method(_pipe@1, post),
                _pipe@3 = add_headers(_pipe@2, Model, erlang:element(3, Model)),
                gleam@http@request:set_body(
                    _pipe@3,
                    begin
                        _pipe@4 = starflow@encoder:encode(
                            Model,
                            Messages,
                            Tools
                        ),
                        gleam@json:to_string(_pipe@4)
                    end
                )
            end,
            gleam@result:'try'(
                begin
                    _pipe@5 = gleam@httpc:send(Req@1),
                    gleam@result:map_error(_pipe@5, fun(Err) -> _pipe@6 = Err,
                            _pipe@7 = gleam@string:inspect(_pipe@6),
                            {network_error, _pipe@7} end)
                end,
                fun(Resp) -> case erlang:element(2, Resp) of
                        200 ->
                            gleam@result:'try'(
                                begin
                                    _pipe@8 = gleam@json:decode(
                                        erlang:element(4, Resp),
                                        fun starflow@decoder:response/1
                                    ),
                                    gleam@result:map_error(
                                        _pipe@8,
                                        fun(_) -> decoding_error end
                                    )
                                end,
                                fun(Response) -> {ok, Response} end
                            );

                        _ ->
                            {error,
                                {network_error,
                                    gleam@string:inspect(
                                        erlang:element(2, Resp)
                                    )}}
                    end end
            )
        end
    ).