anthropic_gleam

-module(anthropic@streaming).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/anthropic/streaming.gleam").
-export([event_type_string/1, event_type_from_string/1, text_delta_to_json/1, input_json_delta_to_json/1, content_block_delta_to_json/1, stream_error_to_json/1, text_delta/1, input_json_delta/1, message_start/4, text_block_start/1, tool_use_block_start/3, text_delta_event/2, input_json_delta_event/2, content_block_stop/1, message_delta_event/3, stream_error/2, is_terminal_event/1, get_delta_text/1, get_delta_json/1]).
-export_type([text_delta/0, input_json_delta/0, content_block_delta/0, message_start/0, content_block_start/0, content_block_delta_event/0, content_block_stop/0, message_delta/0, message_delta_usage/0, message_delta_event/0, stream_error/0, stream_event/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.

?MODULEDOC(
    " Streaming event types for the Anthropic Messages API\n"
    "\n"
    " This module defines types for Server-Sent Events (SSE) from the streaming API,\n"
    " including message_start, content_block_start, content_block_delta,\n"
    " content_block_stop, message_delta, message_stop, ping, and error events.\n"
).

-type text_delta() :: {text_delta, binary()}.

-type input_json_delta() :: {input_json_delta, binary()}.

-type content_block_delta() :: {text_content_delta, text_delta()} |
    {input_json_content_delta, input_json_delta()}.

-type message_start() :: {message_start,
        binary(),
        binary(),
        anthropic@message:role(),
        binary(),
        anthropic@request:usage()}.

-type content_block_start() :: {content_block_start,
        integer(),
        anthropic@message:content_block()}.

-type content_block_delta_event() :: {content_block_delta_event,
        integer(),
        content_block_delta()}.

-type content_block_stop() :: {content_block_stop, integer()}.

-type message_delta() :: {message_delta,
        gleam@option:option(anthropic@request:stop_reason()),
        gleam@option:option(binary())}.

-type message_delta_usage() :: {message_delta_usage, integer()}.

-type message_delta_event() :: {message_delta_event,
        message_delta(),
        message_delta_usage()}.

-type stream_error() :: {stream_error, binary(), binary()}.

-type stream_event() :: {message_start_event, message_start()} |
    {content_block_start_event, content_block_start()} |
    {content_block_delta_event_variant, content_block_delta_event()} |
    {content_block_stop_event, content_block_stop()} |
    {message_delta_event_variant, message_delta_event()} |
    message_stop_event |
    ping_event |
    {error_event, stream_error()}.

-file("src/anthropic/streaming.gleam", 175).
?DOC(" Get the event type string for a StreamEvent\n").
-spec event_type_string(stream_event()) -> binary().
event_type_string(Event) ->
    case Event of
        {message_start_event, _} ->
            <<"message_start"/utf8>>;

        {content_block_start_event, _} ->
            <<"content_block_start"/utf8>>;

        {content_block_delta_event_variant, _} ->
            <<"content_block_delta"/utf8>>;

        {content_block_stop_event, _} ->
            <<"content_block_stop"/utf8>>;

        {message_delta_event_variant, _} ->
            <<"message_delta"/utf8>>;

        message_stop_event ->
            <<"message_stop"/utf8>>;

        ping_event ->
            <<"ping"/utf8>>;

        {error_event, _} ->
            <<"error"/utf8>>
    end.

-file("src/anthropic/streaming.gleam", 189).
?DOC(" Parse an event type string\n").
-spec event_type_from_string(binary()) -> {ok, binary()} | {error, binary()}.
event_type_from_string(Str) ->
    case Str of
        <<"message_start"/utf8>> ->
            {ok, Str};

        <<"content_block_start"/utf8>> ->
            {ok, Str};

        <<"content_block_delta"/utf8>> ->
            {ok, Str};

        <<"content_block_stop"/utf8>> ->
            {ok, Str};

        <<"message_delta"/utf8>> ->
            {ok, Str};

        <<"message_stop"/utf8>> ->
            {ok, Str};

        <<"ping"/utf8>> ->
            {ok, Str};

        <<"error"/utf8>> ->
            {ok, Str};

        _ ->
            {error, <<"Unknown event type: "/utf8, Str/binary>>}
    end.

-file("src/anthropic/streaming.gleam", 208).
?DOC(" Encode a TextDelta to JSON\n").
-spec text_delta_to_json(text_delta()) -> gleam@json:json().
text_delta_to_json(Delta) ->
    gleam@json:object(
        [{<<"type"/utf8>>, gleam@json:string(<<"text_delta"/utf8>>)},
            {<<"text"/utf8>>, gleam@json:string(erlang:element(2, Delta))}]
    ).

-file("src/anthropic/streaming.gleam", 216).
?DOC(" Encode an InputJsonDelta to JSON\n").
-spec input_json_delta_to_json(input_json_delta()) -> gleam@json:json().
input_json_delta_to_json(Delta) ->
    gleam@json:object(
        [{<<"type"/utf8>>, gleam@json:string(<<"input_json_delta"/utf8>>)},
            {<<"partial_json"/utf8>>,
                gleam@json:string(erlang:element(2, Delta))}]
    ).

-file("src/anthropic/streaming.gleam", 224).
?DOC(" Encode a ContentBlockDelta to JSON\n").
-spec content_block_delta_to_json(content_block_delta()) -> gleam@json:json().
content_block_delta_to_json(Delta) ->
    case Delta of
        {text_content_delta, D} ->
            text_delta_to_json(D);

        {input_json_content_delta, D@1} ->
            input_json_delta_to_json(D@1)
    end.

-file("src/anthropic/streaming.gleam", 232).
?DOC(" Encode a StreamError to JSON\n").
-spec stream_error_to_json(stream_error()) -> gleam@json:json().
stream_error_to_json(Error) ->
    gleam@json:object(
        [{<<"type"/utf8>>, gleam@json:string(erlang:element(2, Error))},
            {<<"message"/utf8>>, gleam@json:string(erlang:element(3, Error))}]
    ).

-file("src/anthropic/streaming.gleam", 244).
?DOC(" Create a TextDelta\n").
-spec text_delta(binary()) -> text_delta().
text_delta(Text) ->
    {text_delta, Text}.

-file("src/anthropic/streaming.gleam", 249).
?DOC(" Create an InputJsonDelta\n").
-spec input_json_delta(binary()) -> input_json_delta().
input_json_delta(Partial_json) ->
    {input_json_delta, Partial_json}.

-file("src/anthropic/streaming.gleam", 254).
?DOC(" Create a MessageStart\n").
-spec message_start(binary(), anthropic@message:role(), binary(), integer()) -> message_start().
message_start(Id, Role, Model, Input_tokens) ->
    {message_start,
        Id,
        <<"message"/utf8>>,
        Role,
        Model,
        {usage, Input_tokens, 0}}.

-file("src/anthropic/streaming.gleam", 270).
?DOC(" Create a ContentBlockStart for a text block\n").
-spec text_block_start(integer()) -> content_block_start().
text_block_start(Index) ->
    {content_block_start, Index, {text_block, <<""/utf8>>}}.

-file("src/anthropic/streaming.gleam", 275).
?DOC(" Create a ContentBlockStart for a tool use block\n").
-spec tool_use_block_start(integer(), binary(), binary()) -> content_block_start().
tool_use_block_start(Index, Id, Name) ->
    {content_block_start, Index, {tool_use_block, Id, Name, <<""/utf8>>}}.

-file("src/anthropic/streaming.gleam", 287).
?DOC(" Create a ContentBlockDeltaEvent for text\n").
-spec text_delta_event(integer(), binary()) -> content_block_delta_event().
text_delta_event(Index, Text) ->
    {content_block_delta_event, Index, {text_content_delta, {text_delta, Text}}}.

-file("src/anthropic/streaming.gleam", 295).
?DOC(" Create a ContentBlockDeltaEvent for tool input JSON\n").
-spec input_json_delta_event(integer(), binary()) -> content_block_delta_event().
input_json_delta_event(Index, Partial_json) ->
    {content_block_delta_event,
        Index,
        {input_json_content_delta, {input_json_delta, Partial_json}}}.

-file("src/anthropic/streaming.gleam", 306).
?DOC(" Create a ContentBlockStop\n").
-spec content_block_stop(integer()) -> content_block_stop().
content_block_stop(Index) ->
    {content_block_stop, Index}.

-file("src/anthropic/streaming.gleam", 311).
?DOC(" Create a MessageDeltaEvent\n").
-spec message_delta_event(
    gleam@option:option(anthropic@request:stop_reason()),
    gleam@option:option(binary()),
    integer()
) -> message_delta_event().
message_delta_event(Stop_reason, Stop_sequence, Output_tokens) ->
    {message_delta_event,
        {message_delta, Stop_reason, Stop_sequence},
        {message_delta_usage, Output_tokens}}.

-file("src/anthropic/streaming.gleam", 323).
?DOC(" Create a StreamError\n").
-spec stream_error(binary(), binary()) -> stream_error().
stream_error(Error_type, Message) ->
    {stream_error, Error_type, Message}.

-file("src/anthropic/streaming.gleam", 332).
?DOC(" Check if an event is a terminal event (message_stop or error)\n").
-spec is_terminal_event(stream_event()) -> boolean().
is_terminal_event(Event) ->
    case Event of
        message_stop_event ->
            true;

        {error_event, _} ->
            true;

        _ ->
            false
    end.

-file("src/anthropic/streaming.gleam", 341).
?DOC(" Get the text from a content block delta, if it's a text delta\n").
-spec get_delta_text(content_block_delta()) -> gleam@option:option(binary()).
get_delta_text(Delta) ->
    case Delta of
        {text_content_delta, D} ->
            {some, erlang:element(2, D)};

        {input_json_content_delta, _} ->
            none
    end.

-file("src/anthropic/streaming.gleam", 349).
?DOC(" Get the partial JSON from a content block delta, if it's an input JSON delta\n").
-spec get_delta_json(content_block_delta()) -> gleam@option:option(binary()).
get_delta_json(Delta) ->
    case Delta of
        {text_content_delta, _} ->
            none;

        {input_json_content_delta, D} ->
            {some, erlang:element(2, D)}
    end.