-module(glopenai@completion).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/glopenai/completion.gleam").
-export([new_create_request/2, with_suffix/2, with_max_tokens/2, with_temperature/2, with_top_p/2, with_n/2, with_stream/2, with_logprobs/2, with_echo_prompt/2, with_stop/2, with_presence_penalty/2, with_frequency_penalty/2, with_best_of/2, with_user/2, with_seed/2, completion_finish_reason_to_json/1, prompt_to_json/1, stop_configuration_to_json/1, create_completion_request_to_json/1, completion_finish_reason_decoder/0, logprobs_decoder/0, completion_choice_decoder/0, create_request/2, create_response/1]).
-export_type([completion_finish_reason/0, prompt/0, stop_configuration/0, logprobs/0, completion_choice/0, create_completion_request/0, create_completion_response/0]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

-type completion_finish_reason() :: finish_reason_stop |
    finish_reason_length |
    finish_reason_content_filter.

-type prompt() :: {prompt_string, binary()} |
    {prompt_string_array, list(binary())} |
    {prompt_integer_array, list(integer())} |
    {prompt_array_of_integer_array, list(list(integer()))}.

-type stop_configuration() :: {stop_string, binary()} |
    {stop_string_array, list(binary())}.

-type logprobs() :: {logprobs,
        list(binary()),
        list(gleam@option:option(float())),
        list(gleam@dynamic:dynamic_()),
        list(integer())}.

-type completion_choice() :: {completion_choice,
        binary(),
        integer(),
        gleam@option:option(logprobs()),
        gleam@option:option(completion_finish_reason())}.

-type create_completion_request() :: {create_completion_request,
        binary(),
        prompt(),
        gleam@option:option(binary()),
        gleam@option:option(integer()),
        gleam@option:option(float()),
        gleam@option:option(float()),
        gleam@option:option(integer()),
        gleam@option:option(boolean()),
        gleam@option:option(integer()),
        gleam@option:option(boolean()),
        gleam@option:option(stop_configuration()),
        gleam@option:option(float()),
        gleam@option:option(float()),
        gleam@option:option(integer()),
        gleam@option:option(gleam@dynamic:dynamic_()),
        gleam@option:option(binary()),
        gleam@option:option(integer())}.

-type create_completion_response() :: {create_completion_response,
        binary(),
        list(completion_choice()),
        integer(),
        binary(),
        gleam@option:option(binary()),
        binary(),
        gleam@option:option(glopenai@shared:completion_usage())}.

-file("src/glopenai/completion.gleam", 105).
?DOC(" Create a new completion request with required fields.\n").
-spec new_create_request(binary(), prompt()) -> create_completion_request().
new_create_request(Model, Prompt) ->
    {create_completion_request,
        Model,
        Prompt,
        none,
        none,
        none,
        none,
        none,
        none,
        none,
        none,
        none,
        none,
        none,
        none,
        none,
        none,
        none}.

-file("src/glopenai/completion.gleam", 130).
-spec with_suffix(create_completion_request(), binary()) -> create_completion_request().
with_suffix(Request, Suffix) ->
    {create_completion_request,
        erlang:element(2, Request),
        erlang:element(3, Request),
        {some, Suffix},
        erlang:element(5, Request),
        erlang:element(6, Request),
        erlang:element(7, Request),
        erlang:element(8, Request),
        erlang:element(9, Request),
        erlang:element(10, Request),
        erlang:element(11, Request),
        erlang:element(12, Request),
        erlang:element(13, Request),
        erlang:element(14, Request),
        erlang:element(15, Request),
        erlang:element(16, Request),
        erlang:element(17, Request),
        erlang:element(18, Request)}.

-file("src/glopenai/completion.gleam", 137).
-spec with_max_tokens(create_completion_request(), integer()) -> create_completion_request().
with_max_tokens(Request, Max_tokens) ->
    {create_completion_request,
        erlang:element(2, Request),
        erlang:element(3, Request),
        erlang:element(4, Request),
        {some, Max_tokens},
        erlang:element(6, Request),
        erlang:element(7, Request),
        erlang:element(8, Request),
        erlang:element(9, Request),
        erlang:element(10, Request),
        erlang:element(11, Request),
        erlang:element(12, Request),
        erlang:element(13, Request),
        erlang:element(14, Request),
        erlang:element(15, Request),
        erlang:element(16, Request),
        erlang:element(17, Request),
        erlang:element(18, Request)}.

-file("src/glopenai/completion.gleam", 144).
-spec with_temperature(create_completion_request(), float()) -> create_completion_request().
with_temperature(Request, Temperature) ->
    {create_completion_request,
        erlang:element(2, Request),
        erlang:element(3, Request),
        erlang:element(4, Request),
        erlang:element(5, Request),
        {some, Temperature},
        erlang:element(7, Request),
        erlang:element(8, Request),
        erlang:element(9, Request),
        erlang:element(10, Request),
        erlang:element(11, Request),
        erlang:element(12, Request),
        erlang:element(13, Request),
        erlang:element(14, Request),
        erlang:element(15, Request),
        erlang:element(16, Request),
        erlang:element(17, Request),
        erlang:element(18, Request)}.

-file("src/glopenai/completion.gleam", 151).
-spec with_top_p(create_completion_request(), float()) -> create_completion_request().
with_top_p(Request, Top_p) ->
    {create_completion_request,
        erlang:element(2, Request),
        erlang:element(3, Request),
        erlang:element(4, Request),
        erlang:element(5, Request),
        erlang:element(6, Request),
        {some, Top_p},
        erlang:element(8, Request),
        erlang:element(9, Request),
        erlang:element(10, Request),
        erlang:element(11, Request),
        erlang:element(12, Request),
        erlang:element(13, Request),
        erlang:element(14, Request),
        erlang:element(15, Request),
        erlang:element(16, Request),
        erlang:element(17, Request),
        erlang:element(18, Request)}.

-file("src/glopenai/completion.gleam", 158).
-spec with_n(create_completion_request(), integer()) -> create_completion_request().
with_n(Request, N) ->
    {create_completion_request,
        erlang:element(2, Request),
        erlang:element(3, Request),
        erlang:element(4, Request),
        erlang:element(5, Request),
        erlang:element(6, Request),
        erlang:element(7, Request),
        {some, N},
        erlang:element(9, Request),
        erlang:element(10, Request),
        erlang:element(11, Request),
        erlang:element(12, Request),
        erlang:element(13, Request),
        erlang:element(14, Request),
        erlang:element(15, Request),
        erlang:element(16, Request),
        erlang:element(17, Request),
        erlang:element(18, Request)}.

-file("src/glopenai/completion.gleam", 165).
-spec with_stream(create_completion_request(), boolean()) -> create_completion_request().
with_stream(Request, Stream) ->
    {create_completion_request,
        erlang:element(2, Request),
        erlang:element(3, Request),
        erlang:element(4, Request),
        erlang:element(5, Request),
        erlang:element(6, Request),
        erlang:element(7, Request),
        erlang:element(8, Request),
        {some, Stream},
        erlang:element(10, Request),
        erlang:element(11, Request),
        erlang:element(12, Request),
        erlang:element(13, Request),
        erlang:element(14, Request),
        erlang:element(15, Request),
        erlang:element(16, Request),
        erlang:element(17, Request),
        erlang:element(18, Request)}.

-file("src/glopenai/completion.gleam", 172).
-spec with_logprobs(create_completion_request(), integer()) -> create_completion_request().
with_logprobs(Request, Logprobs) ->
    {create_completion_request,
        erlang:element(2, Request),
        erlang:element(3, Request),
        erlang:element(4, Request),
        erlang:element(5, Request),
        erlang:element(6, Request),
        erlang:element(7, Request),
        erlang:element(8, Request),
        erlang:element(9, Request),
        {some, Logprobs},
        erlang:element(11, Request),
        erlang:element(12, Request),
        erlang:element(13, Request),
        erlang:element(14, Request),
        erlang:element(15, Request),
        erlang:element(16, Request),
        erlang:element(17, Request),
        erlang:element(18, Request)}.

-file("src/glopenai/completion.gleam", 179).
-spec with_echo_prompt(create_completion_request(), boolean()) -> create_completion_request().
with_echo_prompt(Request, Echo_prompt) ->
    {create_completion_request,
        erlang:element(2, Request),
        erlang:element(3, Request),
        erlang:element(4, Request),
        erlang:element(5, Request),
        erlang:element(6, Request),
        erlang:element(7, Request),
        erlang:element(8, Request),
        erlang:element(9, Request),
        erlang:element(10, Request),
        {some, Echo_prompt},
        erlang:element(12, Request),
        erlang:element(13, Request),
        erlang:element(14, Request),
        erlang:element(15, Request),
        erlang:element(16, Request),
        erlang:element(17, Request),
        erlang:element(18, Request)}.

-file("src/glopenai/completion.gleam", 186).
-spec with_stop(create_completion_request(), stop_configuration()) -> create_completion_request().
with_stop(Request, Stop) ->
    {create_completion_request,
        erlang:element(2, Request),
        erlang:element(3, Request),
        erlang:element(4, Request),
        erlang:element(5, Request),
        erlang:element(6, Request),
        erlang:element(7, Request),
        erlang:element(8, Request),
        erlang:element(9, Request),
        erlang:element(10, Request),
        erlang:element(11, Request),
        {some, Stop},
        erlang:element(13, Request),
        erlang:element(14, Request),
        erlang:element(15, Request),
        erlang:element(16, Request),
        erlang:element(17, Request),
        erlang:element(18, Request)}.

-file("src/glopenai/completion.gleam", 193).
-spec with_presence_penalty(create_completion_request(), float()) -> create_completion_request().
with_presence_penalty(Request, Presence_penalty) ->
    {create_completion_request,
        erlang:element(2, Request),
        erlang:element(3, Request),
        erlang:element(4, Request),
        erlang:element(5, Request),
        erlang:element(6, Request),
        erlang:element(7, Request),
        erlang:element(8, Request),
        erlang:element(9, Request),
        erlang:element(10, Request),
        erlang:element(11, Request),
        erlang:element(12, Request),
        {some, Presence_penalty},
        erlang:element(14, Request),
        erlang:element(15, Request),
        erlang:element(16, Request),
        erlang:element(17, Request),
        erlang:element(18, Request)}.

-file("src/glopenai/completion.gleam", 200).
-spec with_frequency_penalty(create_completion_request(), float()) -> create_completion_request().
with_frequency_penalty(Request, Frequency_penalty) ->
    {create_completion_request,
        erlang:element(2, Request),
        erlang:element(3, Request),
        erlang:element(4, Request),
        erlang:element(5, Request),
        erlang:element(6, Request),
        erlang:element(7, Request),
        erlang:element(8, Request),
        erlang:element(9, Request),
        erlang:element(10, Request),
        erlang:element(11, Request),
        erlang:element(12, Request),
        erlang:element(13, Request),
        {some, Frequency_penalty},
        erlang:element(15, Request),
        erlang:element(16, Request),
        erlang:element(17, Request),
        erlang:element(18, Request)}.

-file("src/glopenai/completion.gleam", 207).
-spec with_best_of(create_completion_request(), integer()) -> create_completion_request().
with_best_of(Request, Best_of) ->
    {create_completion_request,
        erlang:element(2, Request),
        erlang:element(3, Request),
        erlang:element(4, Request),
        erlang:element(5, Request),
        erlang:element(6, Request),
        erlang:element(7, Request),
        erlang:element(8, Request),
        erlang:element(9, Request),
        erlang:element(10, Request),
        erlang:element(11, Request),
        erlang:element(12, Request),
        erlang:element(13, Request),
        erlang:element(14, Request),
        {some, Best_of},
        erlang:element(16, Request),
        erlang:element(17, Request),
        erlang:element(18, Request)}.

-file("src/glopenai/completion.gleam", 214).
-spec with_user(create_completion_request(), binary()) -> create_completion_request().
with_user(Request, User) ->
    {create_completion_request,
        erlang:element(2, Request),
        erlang:element(3, Request),
        erlang:element(4, Request),
        erlang:element(5, Request),
        erlang:element(6, Request),
        erlang:element(7, Request),
        erlang:element(8, Request),
        erlang:element(9, Request),
        erlang:element(10, Request),
        erlang:element(11, Request),
        erlang:element(12, Request),
        erlang:element(13, Request),
        erlang:element(14, Request),
        erlang:element(15, Request),
        erlang:element(16, Request),
        {some, User},
        erlang:element(18, Request)}.

-file("src/glopenai/completion.gleam", 221).
-spec with_seed(create_completion_request(), integer()) -> create_completion_request().
with_seed(Request, Seed) ->
    {create_completion_request,
        erlang:element(2, Request),
        erlang:element(3, Request),
        erlang:element(4, Request),
        erlang:element(5, Request),
        erlang:element(6, Request),
        erlang:element(7, Request),
        erlang:element(8, Request),
        erlang:element(9, Request),
        erlang:element(10, Request),
        erlang:element(11, Request),
        erlang:element(12, Request),
        erlang:element(13, Request),
        erlang:element(14, Request),
        erlang:element(15, Request),
        erlang:element(16, Request),
        erlang:element(17, Request),
        {some, Seed}}.

-file("src/glopenai/completion.gleam", 232).
-spec completion_finish_reason_to_json(completion_finish_reason()) -> gleam@json:json().
completion_finish_reason_to_json(Reason) ->
    gleam@json:string(case Reason of
            finish_reason_stop ->
                <<"stop"/utf8>>;

            finish_reason_length ->
                <<"length"/utf8>>;

            finish_reason_content_filter ->
                <<"content_filter"/utf8>>
        end).

-file("src/glopenai/completion.gleam", 242).
-spec prompt_to_json(prompt()) -> gleam@json:json().
prompt_to_json(Prompt) ->
    case Prompt of
        {prompt_string, S} ->
            gleam@json:string(S);

        {prompt_string_array, Arr} ->
            gleam@json:array(Arr, fun gleam@json:string/1);

        {prompt_integer_array, Arr@1} ->
            gleam@json:array(Arr@1, fun gleam@json:int/1);

        {prompt_array_of_integer_array, Arr@2} ->
            gleam@json:array(
                Arr@2,
                fun(Inner) -> gleam@json:array(Inner, fun gleam@json:int/1) end
            )
    end.

-file("src/glopenai/completion.gleam", 252).
-spec stop_configuration_to_json(stop_configuration()) -> gleam@json:json().
stop_configuration_to_json(Stop) ->
    case Stop of
        {stop_string, S} ->
            gleam@json:string(S);

        {stop_string_array, Arr} ->
            gleam@json:array(Arr, fun gleam@json:string/1)
    end.

-file("src/glopenai/completion.gleam", 259).
-spec create_completion_request_to_json(create_completion_request()) -> gleam@json:json().
create_completion_request_to_json(Request) ->
    glopenai@internal@codec:object_with_optional(
        [{<<"model"/utf8>>, gleam@json:string(erlang:element(2, Request))},
            {<<"prompt"/utf8>>, prompt_to_json(erlang:element(3, Request))}],
        [glopenai@internal@codec:optional_field(
                <<"suffix"/utf8>>,
                erlang:element(4, Request),
                fun gleam@json:string/1
            ),
            glopenai@internal@codec:optional_field(
                <<"max_tokens"/utf8>>,
                erlang:element(5, Request),
                fun gleam@json:int/1
            ),
            glopenai@internal@codec:optional_field(
                <<"temperature"/utf8>>,
                erlang:element(6, Request),
                fun gleam@json:float/1
            ),
            glopenai@internal@codec:optional_field(
                <<"top_p"/utf8>>,
                erlang:element(7, Request),
                fun gleam@json:float/1
            ),
            glopenai@internal@codec:optional_field(
                <<"n"/utf8>>,
                erlang:element(8, Request),
                fun gleam@json:int/1
            ),
            glopenai@internal@codec:optional_field(
                <<"stream"/utf8>>,
                erlang:element(9, Request),
                fun gleam@json:bool/1
            ),
            glopenai@internal@codec:optional_field(
                <<"logprobs"/utf8>>,
                erlang:element(10, Request),
                fun gleam@json:int/1
            ),
            glopenai@internal@codec:optional_field(
                <<"echo"/utf8>>,
                erlang:element(11, Request),
                fun gleam@json:bool/1
            ),
            glopenai@internal@codec:optional_field(
                <<"stop"/utf8>>,
                erlang:element(12, Request),
                fun stop_configuration_to_json/1
            ),
            glopenai@internal@codec:optional_field(
                <<"presence_penalty"/utf8>>,
                erlang:element(13, Request),
                fun gleam@json:float/1
            ),
            glopenai@internal@codec:optional_field(
                <<"frequency_penalty"/utf8>>,
                erlang:element(14, Request),
                fun gleam@json:float/1
            ),
            glopenai@internal@codec:optional_field(
                <<"best_of"/utf8>>,
                erlang:element(15, Request),
                fun gleam@json:int/1
            ),
            glopenai@internal@codec:optional_field(
                <<"logit_bias"/utf8>>,
                erlang:element(16, Request),
                fun glopenai_codec_ffi:dynamic_to_json/1
            ),
            glopenai@internal@codec:optional_field(
                <<"user"/utf8>>,
                erlang:element(17, Request),
                fun gleam@json:string/1
            ),
            glopenai@internal@codec:optional_field(
                <<"seed"/utf8>>,
                erlang:element(18, Request),
                fun gleam@json:int/1
            )]
    ).

-file("src/glopenai/completion.gleam", 305).
-spec completion_finish_reason_decoder() -> gleam@dynamic@decode:decoder(completion_finish_reason()).
completion_finish_reason_decoder() ->
    gleam@dynamic@decode:then(
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(Value) -> case Value of
                <<"stop"/utf8>> ->
                    gleam@dynamic@decode:success(finish_reason_stop);

                <<"length"/utf8>> ->
                    gleam@dynamic@decode:success(finish_reason_length);

                <<"content_filter"/utf8>> ->
                    gleam@dynamic@decode:success(finish_reason_content_filter);

                _ ->
                    gleam@dynamic@decode:failure(
                        finish_reason_stop,
                        <<"CompletionFinishReason"/utf8>>
                    )
            end end
    ).

-file("src/glopenai/completion.gleam", 317).
-spec logprobs_decoder() -> gleam@dynamic@decode:decoder(logprobs()).
logprobs_decoder() ->
    gleam@dynamic@decode:field(
        <<"tokens"/utf8>>,
        gleam@dynamic@decode:list(
            {decoder, fun gleam@dynamic@decode:decode_string/1}
        ),
        fun(Tokens) ->
            gleam@dynamic@decode:field(
                <<"token_logprobs"/utf8>>,
                gleam@dynamic@decode:list(
                    gleam@dynamic@decode:optional(
                        {decoder, fun gleam@dynamic@decode:decode_float/1}
                    )
                ),
                fun(Token_logprobs) ->
                    gleam@dynamic@decode:field(
                        <<"top_logprobs"/utf8>>,
                        gleam@dynamic@decode:list(
                            {decoder, fun gleam@dynamic@decode:decode_dynamic/1}
                        ),
                        fun(Top_logprobs) ->
                            gleam@dynamic@decode:field(
                                <<"text_offset"/utf8>>,
                                gleam@dynamic@decode:list(
                                    {decoder,
                                        fun gleam@dynamic@decode:decode_int/1}
                                ),
                                fun(Text_offset) ->
                                    gleam@dynamic@decode:success(
                                        {logprobs,
                                            Tokens,
                                            Token_logprobs,
                                            Top_logprobs,
                                            Text_offset}
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/glopenai/completion.gleam", 333).
-spec completion_choice_decoder() -> gleam@dynamic@decode:decoder(completion_choice()).
completion_choice_decoder() ->
    gleam@dynamic@decode:field(
        <<"text"/utf8>>,
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(Text) ->
            gleam@dynamic@decode:field(
                <<"index"/utf8>>,
                {decoder, fun gleam@dynamic@decode:decode_int/1},
                fun(Index) ->
                    gleam@dynamic@decode:optional_field(
                        <<"logprobs"/utf8>>,
                        none,
                        gleam@dynamic@decode:optional(logprobs_decoder()),
                        fun(Logprobs) ->
                            gleam@dynamic@decode:optional_field(
                                <<"finish_reason"/utf8>>,
                                none,
                                gleam@dynamic@decode:optional(
                                    completion_finish_reason_decoder()
                                ),
                                fun(Finish_reason) ->
                                    gleam@dynamic@decode:success(
                                        {completion_choice,
                                            Text,
                                            Index,
                                            Logprobs,
                                            Finish_reason}
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/glopenai/completion.gleam", 354).
-spec create_completion_response_decoder() -> gleam@dynamic@decode:decoder(create_completion_response()).
create_completion_response_decoder() ->
    gleam@dynamic@decode:field(
        <<"id"/utf8>>,
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(Id) ->
            gleam@dynamic@decode:field(
                <<"choices"/utf8>>,
                gleam@dynamic@decode:list(completion_choice_decoder()),
                fun(Choices) ->
                    gleam@dynamic@decode:field(
                        <<"created"/utf8>>,
                        {decoder, fun gleam@dynamic@decode:decode_int/1},
                        fun(Created) ->
                            gleam@dynamic@decode:field(
                                <<"model"/utf8>>,
                                {decoder,
                                    fun gleam@dynamic@decode:decode_string/1},
                                fun(Model) ->
                                    gleam@dynamic@decode:optional_field(
                                        <<"system_fingerprint"/utf8>>,
                                        none,
                                        gleam@dynamic@decode:optional(
                                            {decoder,
                                                fun gleam@dynamic@decode:decode_string/1}
                                        ),
                                        fun(System_fingerprint) ->
                                            gleam@dynamic@decode:field(
                                                <<"object"/utf8>>,
                                                {decoder,
                                                    fun gleam@dynamic@decode:decode_string/1},
                                                fun(Object) ->
                                                    gleam@dynamic@decode:optional_field(
                                                        <<"usage"/utf8>>,
                                                        none,
                                                        gleam@dynamic@decode:optional(
                                                            glopenai@shared:completion_usage_decoder(
                                                                
                                                            )
                                                        ),
                                                        fun(Usage) ->
                                                            gleam@dynamic@decode:success(
                                                                {create_completion_response,
                                                                    Id,
                                                                    Choices,
                                                                    Created,
                                                                    Model,
                                                                    System_fingerprint,
                                                                    Object,
                                                                    Usage}
                                                            )
                                                        end
                                                    )
                                                end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/glopenai/completion.gleam", 391).
?DOC(" Build a request to create a legacy text completion.\n").
-spec create_request(glopenai@config:config(), create_completion_request()) -> gleam@http@request:request(binary()).
create_request(Config, Params) ->
    glopenai@internal:post_request(
        Config,
        <<"/completions"/utf8>>,
        create_completion_request_to_json(Params)
    ).

-file("src/glopenai/completion.gleam", 403).
?DOC(" Parse the response from creating a legacy text completion.\n").
-spec create_response(gleam@http@response:response(binary())) -> {ok,
        create_completion_response()} |
    {error, glopenai@error:glopenai_error()}.
create_response(Response) ->
    glopenai@internal:parse_response(
        Response,
        create_completion_response_decoder()
    ).