-module(mcp_toolkit@core@server).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/mcp_toolkit/core/server.gleam").
-export([new/2, description/2, instructions/2, add_resource/3, add_resource_template/3, add_tool/4, add_prompt/3, resource_capabilities/3, prompt_capabilities/2, tool_capabilities/2, enable_logging/1, page_limit/2, build/1, initialize/2, ping/2, list_resources/2, list_resource_templates/2, read_resource/2, list_prompts/2, get_prompt/2, list_tools/2, call_tool/2, handle_message/2]).
-export_type([builder/0, server/0, server_prompt/0, server_resource/0, server_resource_template/0, server_tool/0]).

-type builder() :: {builder,
        binary(),
        binary(),
        gleam@option:option(binary()),
        gleam@option:option(binary()),
        gleam@dict:dict(binary(), server_resource()),
        gleam@dict:dict(binary(), server_resource_template()),
        gleam@dict:dict(binary(), server_tool()),
        gleam@dict:dict(binary(), server_prompt()),
        mcp_toolkit@core@protocol:server_capabilities(),
        gleam@option:option(integer())}.

-opaque server() :: {server,
        binary(),
        binary(),
        gleam@option:option(binary()),
        gleam@option:option(binary()),
        gleam@dict:dict(binary(), server_resource()),
        gleam@dict:dict(binary(), server_resource_template()),
        gleam@dict:dict(binary(), server_tool()),
        gleam@dict:dict(binary(), server_prompt()),
        mcp_toolkit@core@protocol:server_capabilities(),
        gleam@option:option(integer())}.

-opaque server_prompt() :: {server_prompt,
        mcp_toolkit@core@protocol:prompt(),
        fun((mcp_toolkit@core@protocol:get_prompt_request()) -> {ok,
                mcp_toolkit@core@protocol:get_prompt_result()} |
            {error, binary()})}.

-opaque server_resource() :: {server_resource,
        mcp_toolkit@core@protocol:resource(),
        fun((mcp_toolkit@core@protocol:read_resource_request()) -> {ok,
                mcp_toolkit@core@protocol:read_resource_result()} |
            {error, binary()})}.

-opaque server_resource_template() :: {server_resource_template,
        mcp_toolkit@core@protocol:resource_template(),
        fun((mcp_toolkit@core@protocol:read_resource_request()) -> {ok,
                mcp_toolkit@core@protocol:read_resource_result()} |
            {error, binary()})}.

-opaque server_tool() :: {server_tool,
        mcp_toolkit@core@protocol:tool(),
        fun((mcp_toolkit@core@protocol:call_tool_request(gleam@dynamic:dynamic_())) -> {ok,
                mcp_toolkit@core@protocol:call_tool_result()} |
            {error, mcp_toolkit@core@protocol:mcp_error()})}.

-file("src/mcp_toolkit/core/server.gleam", 28).
-spec new(binary(), binary()) -> builder().
new(Name, Version) ->
    {builder,
        Name,
        Version,
        none,
        none,
        maps:new(),
        maps:new(),
        maps:new(),
        maps:new(),
        {server_capabilities, none, none, none, none, none},
        none}.

-file("src/mcp_toolkit/core/server.gleam", 43).
-spec description(builder(), binary()) -> builder().
description(Builder, Description) ->
    {builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        {some, Description},
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        erlang:element(10, Builder),
        erlang:element(11, Builder)}.

-file("src/mcp_toolkit/core/server.gleam", 47).
-spec instructions(builder(), binary()) -> builder().
instructions(Builder, Instructions) ->
    {builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        {some, Instructions},
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        erlang:element(10, Builder),
        erlang:element(11, Builder)}.

-file("src/mcp_toolkit/core/server.gleam", 51).
-spec add_resource(
    builder(),
    mcp_toolkit@core@protocol:resource(),
    fun((mcp_toolkit@core@protocol:read_resource_request()) -> {ok,
            mcp_toolkit@core@protocol:read_resource_result()} |
        {error, binary()})
) -> builder().
add_resource(Builder, Resource, Handler) ->
    Capabilities = case erlang:element(5, erlang:element(10, Builder)) of
        none ->
            _record = erlang:element(10, Builder),
            {server_capabilities,
                erlang:element(2, _record),
                erlang:element(3, _record),
                erlang:element(4, _record),
                {some,
                    {server_capabilities_resources,
                        {some, false},
                        {some, false}}},
                erlang:element(6, _record)};

        {some, _} ->
            erlang:element(10, Builder)
    end,
    {builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        gleam@dict:insert(
            erlang:element(6, Builder),
            erlang:element(7, Resource),
            {server_resource, Resource, Handler}
        ),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        Capabilities,
        erlang:element(11, Builder)}.

-file("src/mcp_toolkit/core/server.gleam", 79).
-spec add_resource_template(
    builder(),
    mcp_toolkit@core@protocol:resource_template(),
    fun((mcp_toolkit@core@protocol:read_resource_request()) -> {ok,
            mcp_toolkit@core@protocol:read_resource_result()} |
        {error, binary()})
) -> builder().
add_resource_template(Builder, Template, Handler) ->
    Capabilities = case erlang:element(5, erlang:element(10, Builder)) of
        none ->
            _record = erlang:element(10, Builder),
            {server_capabilities,
                erlang:element(2, _record),
                erlang:element(3, _record),
                erlang:element(4, _record),
                {some,
                    {server_capabilities_resources,
                        {some, false},
                        {some, false}}},
                erlang:element(6, _record)};

        {some, _} ->
            erlang:element(10, Builder)
    end,
    {builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        gleam@dict:insert(
            erlang:element(7, Builder),
            erlang:element(5, Template),
            {server_resource_template, Template, Handler}
        ),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        Capabilities,
        erlang:element(11, Builder)}.

-file("src/mcp_toolkit/core/server.gleam", 133).
-spec prompt_handler(
    gleam@dynamic@decode:decoder(YTA),
    fun((mcp_toolkit@core@protocol:call_tool_request(YTA)) -> {ok,
            mcp_toolkit@core@protocol:call_tool_result()} |
        {error, binary()})
) -> fun((mcp_toolkit@core@protocol:call_tool_request(gleam@dynamic:dynamic_())) -> {ok,
        mcp_toolkit@core@protocol:call_tool_result()} |
    {error, mcp_toolkit@core@protocol:mcp_error()}).
prompt_handler(Arguments_decoder, Handler) ->
    fun(Request) -> case erlang:element(3, Request) of
            none ->
                _pipe = {call_tool_request, erlang:element(2, Request), none},
                _pipe@1 = Handler(_pipe),
                gleam@result:map_error(
                    _pipe@1,
                    fun(Field@0) -> {application_error, Field@0} end
                );

            {some, Dyn} ->
                case gleam@dynamic@decode:run(Dyn, Arguments_decoder) of
                    {ok, Args} ->
                        _pipe@2 = {call_tool_request,
                            erlang:element(2, Request),
                            {some, Args}},
                        _pipe@3 = Handler(_pipe@2),
                        gleam@result:map_error(
                            _pipe@3,
                            fun(Field@0) -> {application_error, Field@0} end
                        );

                    {error, _} ->
                        {error, invalid_params}
                end
        end end.

-file("src/mcp_toolkit/core/server.gleam", 107).
-spec add_tool(
    builder(),
    mcp_toolkit@core@protocol:tool(),
    gleam@dynamic@decode:decoder(YSV),
    fun((mcp_toolkit@core@protocol:call_tool_request(YSV)) -> {ok,
            mcp_toolkit@core@protocol:call_tool_result()} |
        {error, binary()})
) -> builder().
add_tool(Builder, Tool, Arguments_decoder, Handler) ->
    Capabilities = case erlang:element(6, erlang:element(10, Builder)) of
        none ->
            _record = erlang:element(10, Builder),
            {server_capabilities,
                erlang:element(2, _record),
                erlang:element(3, _record),
                erlang:element(4, _record),
                erlang:element(5, _record),
                {some, {server_capabilities_tools, none}}};

        {some, _} ->
            erlang:element(10, Builder)
    end,
    {builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        gleam@dict:insert(
            erlang:element(8, Builder),
            erlang:element(5, Tool),
            {server_tool, Tool, prompt_handler(Arguments_decoder, Handler)}
        ),
        erlang:element(9, Builder),
        Capabilities,
        erlang:element(11, Builder)}.

-file("src/mcp_toolkit/core/server.gleam", 159).
-spec add_prompt(
    builder(),
    mcp_toolkit@core@protocol:prompt(),
    fun((mcp_toolkit@core@protocol:get_prompt_request()) -> {ok,
            mcp_toolkit@core@protocol:get_prompt_result()} |
        {error, binary()})
) -> builder().
add_prompt(Builder, Prompt, Handler) ->
    Capabilities = case erlang:element(4, erlang:element(10, Builder)) of
        none ->
            _record = erlang:element(10, Builder),
            {server_capabilities,
                erlang:element(2, _record),
                erlang:element(3, _record),
                {some, {server_capabilities_prompts, none}},
                erlang:element(5, _record),
                erlang:element(6, _record)};

        {some, _} ->
            erlang:element(10, Builder)
    end,
    {builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        gleam@dict:insert(
            erlang:element(9, Builder),
            erlang:element(4, Prompt),
            {server_prompt, Prompt, Handler}
        ),
        Capabilities,
        erlang:element(11, Builder)}.

-file("src/mcp_toolkit/core/server.gleam", 183).
-spec resource_capabilities(builder(), boolean(), boolean()) -> builder().
resource_capabilities(Builder, Subscribe, List_changed) ->
    Capabilities = begin
        _record = erlang:element(10, Builder),
        {server_capabilities,
            erlang:element(2, _record),
            erlang:element(3, _record),
            erlang:element(4, _record),
            {some,
                {server_capabilities_resources,
                    {some, Subscribe},
                    {some, List_changed}}},
            erlang:element(6, _record)}
    end,
    {builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        Capabilities,
        erlang:element(11, Builder)}.

-file("src/mcp_toolkit/core/server.gleam", 199).
-spec prompt_capabilities(builder(), boolean()) -> builder().
prompt_capabilities(Builder, List_changed) ->
    Capabilities = begin
        _record = erlang:element(10, Builder),
        {server_capabilities,
            erlang:element(2, _record),
            erlang:element(3, _record),
            {some, {server_capabilities_prompts, {some, List_changed}}},
            erlang:element(5, _record),
            erlang:element(6, _record)}
    end,
    {builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        Capabilities,
        erlang:element(11, Builder)}.

-file("src/mcp_toolkit/core/server.gleam", 208).
-spec tool_capabilities(builder(), boolean()) -> builder().
tool_capabilities(Builder, List_changed) ->
    Capabilities = begin
        _record = erlang:element(10, Builder),
        {server_capabilities,
            erlang:element(2, _record),
            erlang:element(3, _record),
            erlang:element(4, _record),
            erlang:element(5, _record),
            {some, {server_capabilities_tools, {some, List_changed}}}}
    end,
    {builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        Capabilities,
        erlang:element(11, Builder)}.

-file("src/mcp_toolkit/core/server.gleam", 217).
-spec enable_logging(builder()) -> builder().
enable_logging(Builder) ->
    Capabilities = begin
        _record = erlang:element(10, Builder),
        {server_capabilities,
            erlang:element(2, _record),
            {some, server_capabilities_logging},
            erlang:element(4, _record),
            erlang:element(5, _record),
            erlang:element(6, _record)}
    end,
    {builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        Capabilities,
        erlang:element(11, Builder)}.

-file("src/mcp_toolkit/core/server.gleam", 226).
-spec page_limit(builder(), integer()) -> builder().
page_limit(Builder, Page_limit) ->
    {builder,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        erlang:element(10, Builder),
        {some, Page_limit}}.

-file("src/mcp_toolkit/core/server.gleam", 245).
-spec build(builder()) -> server().
build(Builder) ->
    {server,
        erlang:element(2, Builder),
        erlang:element(3, Builder),
        erlang:element(4, Builder),
        erlang:element(5, Builder),
        erlang:element(6, Builder),
        erlang:element(7, Builder),
        erlang:element(8, Builder),
        erlang:element(9, Builder),
        erlang:element(10, Builder),
        erlang:element(11, Builder)}.

-file("src/mcp_toolkit/core/server.gleam", 463).
-spec handle_notification(
    server(),
    jsonrpcx:notification(gleam@dynamic:dynamic_())
) -> nil.
handle_notification(_, Notification) ->
    case erlang:element(3, Notification) of
        _ ->
            nil
    end.

-file("src/mcp_toolkit/core/server.gleam", 476).
-spec initialize(server(), mcp_toolkit@core@protocol:initialize_request()) -> {ok,
        mcp_toolkit@core@protocol:initialize_result()} |
    {error, gleam@json:json()}.
initialize(Server, _) ->
    {ok,
        {initialize_result,
            none,
            erlang:element(10, Server),
            erlang:element(5, Server),
            <<"2025-06-18"/utf8>>,
            {implementation,
                erlang:element(2, Server),
                erlang:element(3, Server)}}}.

-file("src/mcp_toolkit/core/server.gleam", 489).
-spec ping(server(), mcp_toolkit@core@protocol:ping_request()) -> {ok,
        mcp_toolkit@core@protocol:ping_result()} |
    {error, gleam@json:json()}.
ping(_, _) ->
    {ok, ping_result}.

-file("src/mcp_toolkit/core/server.gleam", 496).
-spec list_resources(server(), mcp_toolkit@core@protocol:list_request()) -> {ok,
        mcp_toolkit@core@protocol:list_resources_result()} |
    {error, gleam@json:json()}.
list_resources(Server, _) ->
    Resources = begin
        _pipe = maps:values(erlang:element(6, Server)),
        gleam@list:map(_pipe, fun(R) -> erlang:element(2, R) end)
    end,
    {ok, {list_resources_result, none, none, Resources}}.

-file("src/mcp_toolkit/core/server.gleam", 506).
-spec list_resource_templates(
    server(),
    mcp_toolkit@core@protocol:list_request()
) -> {ok, mcp_toolkit@core@protocol:list_resource_templates_result()} |
    {error, gleam@json:json()}.
list_resource_templates(Server, _) ->
    Resource_templates = begin
        _pipe = maps:values(erlang:element(7, Server)),
        gleam@list:map(_pipe, fun(R) -> erlang:element(2, R) end)
    end,
    {ok, {list_resource_templates_result, none, none, Resource_templates}}.

-file("src/mcp_toolkit/core/server.gleam", 528).
-spec read_resource(server(), mcp_toolkit@core@protocol:read_resource_request()) -> {ok,
        mcp_toolkit@core@protocol:read_resource_result()} |
    {error, binary()}.
read_resource(Server, Request) ->
    case gleam_stdlib:map_get(
        erlang:element(6, Server),
        erlang:element(2, Request)
    ) of
        {ok, Resource} ->
            case (erlang:element(3, Resource))(Request) of
                {ok, Res} ->
                    {ok, Res};

                {error, Err} ->
                    {error, Err}
            end;

        {error, _} ->
            {error,
                <<"Resource not found: "/utf8,
                    (erlang:element(2, Request))/binary>>}
    end.

-file("src/mcp_toolkit/core/server.gleam", 520).
-spec read_resource_handler(
    server(),
    mcp_toolkit@core@protocol:read_resource_request()
) -> {ok, mcp_toolkit@core@protocol:read_resource_result()} |
    {error, gleam@json:json()}.
read_resource_handler(Server, Request) ->
    _pipe = read_resource(Server, Request),
    gleam@result:map_error(
        _pipe,
        fun(Err) ->
            gleam@json:object([{<<"error"/utf8>>, gleam@json:string(Err)}])
        end
    ).

-file("src/mcp_toolkit/core/server.gleam", 545).
-spec list_prompts(server(), mcp_toolkit@core@protocol:list_request()) -> {ok,
        mcp_toolkit@core@protocol:list_prompts_result()} |
    {error, gleam@json:json()}.
list_prompts(Server, _) ->
    Prompts = begin
        _pipe = maps:values(erlang:element(9, Server)),
        gleam@list:map(_pipe, fun(P) -> erlang:element(2, P) end)
    end,
    {ok, {list_prompts_result, none, none, Prompts}}.

-file("src/mcp_toolkit/core/server.gleam", 563).
-spec get_prompt(server(), mcp_toolkit@core@protocol:get_prompt_request()) -> {ok,
        mcp_toolkit@core@protocol:get_prompt_result()} |
    {error, binary()}.
get_prompt(Server, Request) ->
    case gleam_stdlib:map_get(
        erlang:element(9, Server),
        erlang:element(3, Request)
    ) of
        {ok, Prompt} ->
            case (erlang:element(3, Prompt))(Request) of
                {ok, Res} ->
                    {ok, Res};

                {error, Err} ->
                    {error, Err}
            end;

        {error, _} ->
            {error,
                <<"Prompt not found: "/utf8,
                    (erlang:element(3, Request))/binary>>}
    end.

-file("src/mcp_toolkit/core/server.gleam", 555).
-spec get_prompt_handler(
    server(),
    mcp_toolkit@core@protocol:get_prompt_request()
) -> {ok, mcp_toolkit@core@protocol:get_prompt_result()} |
    {error, gleam@json:json()}.
get_prompt_handler(Server, Request) ->
    _pipe = get_prompt(Server, Request),
    gleam@result:map_error(
        _pipe,
        fun(Err) ->
            gleam@json:object([{<<"error"/utf8>>, gleam@json:string(Err)}])
        end
    ).

-file("src/mcp_toolkit/core/server.gleam", 580).
-spec list_tools(server(), mcp_toolkit@core@protocol:list_request()) -> {ok,
        mcp_toolkit@core@protocol:list_tools_result()} |
    {error, gleam@json:json()}.
list_tools(Server, _) ->
    Tools = begin
        _pipe = maps:values(erlang:element(8, Server)),
        gleam@list:map(_pipe, fun(T) -> erlang:element(2, T) end)
    end,
    {ok, {list_tools_result, none, none, Tools}}.

-file("src/mcp_toolkit/core/server.gleam", 603).
-spec call_tool(
    server(),
    mcp_toolkit@core@protocol:call_tool_request(gleam@dynamic:dynamic_())
) -> {ok, mcp_toolkit@core@protocol:call_tool_result()} |
    {error, mcp_toolkit@core@protocol:mcp_error()}.
call_tool(Server, Request) ->
    case gleam_stdlib:map_get(
        erlang:element(8, Server),
        erlang:element(2, Request)
    ) of
        {ok, Tool} ->
            case (erlang:element(3, Tool))(Request) of
                {ok, Res} ->
                    {ok, Res};

                {error, Err} ->
                    {error, Err}
            end;

        {error, _} ->
            {error,
                {application_error,
                    <<"Tool not found: "/utf8,
                        (erlang:element(2, Request))/binary>>}}
    end.

-file("src/mcp_toolkit/core/server.gleam", 590).
-spec call_tool_handler(
    server(),
    mcp_toolkit@core@protocol:call_tool_request(gleam@dynamic:dynamic_())
) -> {ok, mcp_toolkit@core@protocol:call_tool_result()} |
    {error, gleam@json:json()}.
call_tool_handler(Server, Request) ->
    _pipe = call_tool(Server, Request),
    gleam@result:map_error(_pipe, fun(Err) -> case Err of
                {application_error, Msg} ->
                    gleam@json:object(
                        [{<<"error"/utf8>>, gleam@json:string(Msg)}]
                    );

                _ ->
                    gleam@json:object(
                        [{<<"error"/utf8>>,
                                gleam@json:string(<<"Tool error"/utf8>>)}]
                    )
            end end).

-file("src/mcp_toolkit/core/server.gleam", 648).
-spec decode_errors_json(
    {ok, YVJ} | {error, list(gleam@dynamic@decode:decode_error())},
    jsonrpcx:id()
) -> {ok, YVJ} | {error, gleam@json:json()}.
decode_errors_json(Result, Id) ->
    _pipe = Result,
    _pipe@1 = gleam@result:map_error(_pipe, fun jsonrpcx:decode_errors/1),
    _pipe@2 = gleam@result:map_error(
        _pipe@1,
        fun(_capture) -> jsonrpcx:error_response(_capture, Id) end
    ),
    gleam@result:map_error(
        _pipe@2,
        fun(_capture@1) ->
            jsonrpcx:error_response_to_json(
                _capture@1,
                fun jsonrpcx:nothing_to_json/1
            )
        end
    ).

-file("src/mcp_toolkit/core/server.gleam", 420).
-spec require_params(
    server(),
    jsonrpcx:request(gleam@dynamic:dynamic_()),
    fun((server(), YTV) -> {ok, YTW} | {error, gleam@json:json()}),
    gleam@dynamic@decode:decoder(YTV),
    fun((YTW) -> gleam@json:json())
) -> {ok, gleam@json:json()} | {error, gleam@json:json()}.
require_params(Server, Request, Handler, Params_decoder, Result_encoder) ->
    case erlang:element(5, Request) of
        none ->
            _pipe = {json_rpc_error, -32602, <<"Invalid params"/utf8>>},
            _pipe@1 = jsonrpcx:error_response(_pipe, erlang:element(4, Request)),
            _pipe@2 = jsonrpcx:error_response_to_json(
                _pipe@1,
                fun jsonrpcx:nothing_to_json/1
            ),
            {error, _pipe@2};

        {some, Params} ->
            _pipe@3 = gleam@dynamic@decode:run(Params, Params_decoder),
            _pipe@4 = decode_errors_json(_pipe@3, erlang:element(4, Request)),
            _pipe@5 = gleam@result:'try'(
                _pipe@4,
                fun(_capture) -> Handler(Server, _capture) end
            ),
            _pipe@6 = gleam@result:map(
                _pipe@5,
                fun(_capture@1) ->
                    jsonrpcx:response(_capture@1, erlang:element(4, Request))
                end
            ),
            gleam@result:map(
                _pipe@6,
                fun(_capture@2) ->
                    jsonrpcx:response_to_json(_capture@2, Result_encoder)
                end
            )
    end.

-file("src/mcp_toolkit/core/server.gleam", 442).
-spec paginated_params(
    server(),
    jsonrpcx:request(gleam@dynamic:dynamic_()),
    fun((server(), mcp_toolkit@core@protocol:list_request()) -> {ok, YUD} |
        {error, gleam@json:json()}),
    fun((YUD) -> gleam@json:json())
) -> {ok, gleam@json:json()} | {error, gleam@json:json()}.
paginated_params(Server, Request, Handler, Encoder) ->
    case erlang:element(5, Request) of
        none ->
            _pipe = Handler(Server, {list_request, none}),
            _pipe@1 = gleam@result:map(
                _pipe,
                fun(_capture) ->
                    jsonrpcx:response(_capture, erlang:element(4, Request))
                end
            ),
            gleam@result:map(
                _pipe@1,
                fun(_capture@1) ->
                    jsonrpcx:response_to_json(_capture@1, Encoder)
                end
            );

        {some, Params} ->
            _pipe@2 = gleam@dynamic@decode:run(
                Params,
                mcp_toolkit@core@protocol:list_request_decoder()
            ),
            _pipe@3 = decode_errors_json(_pipe@2, erlang:element(4, Request)),
            _pipe@4 = gleam@result:'try'(
                _pipe@3,
                fun(_capture@2) -> Handler(Server, _capture@2) end
            ),
            _pipe@5 = gleam@result:map(
                _pipe@4,
                fun(_capture@3) ->
                    jsonrpcx:response(_capture@3, erlang:element(4, Request))
                end
            ),
            gleam@result:map(
                _pipe@5,
                fun(_capture@4) ->
                    jsonrpcx:response_to_json(_capture@4, Encoder)
                end
            )
    end.

-file("src/mcp_toolkit/core/server.gleam", 318).
-spec handle_request(server(), jsonrpcx:request(gleam@dynamic:dynamic_())) -> {ok,
        gleam@json:json()} |
    {error, gleam@json:json()}.
handle_request(Server, Request) ->
    case erlang:element(3, Request) of
        M when M =:= <<"initialize"/utf8>> ->
            require_params(
                Server,
                Request,
                fun initialize/2,
                mcp_toolkit@core@protocol:initialize_request_decoder(),
                fun mcp_toolkit@core@protocol:initialize_result_to_json/1
            );

        M@1 when M@1 =:= <<"ping"/utf8>> ->
            case erlang:element(5, Request) of
                none ->
                    _pipe = ping(Server, {ping_request, none}),
                    gleam@result:map(
                        _pipe,
                        fun mcp_toolkit@core@protocol:ping_result_to_json/1
                    );

                {some, Params} ->
                    _pipe@1 = gleam@dynamic@decode:run(
                        Params,
                        mcp_toolkit@core@protocol:ping_request_decoder()
                    ),
                    _pipe@2 = decode_errors_json(
                        _pipe@1,
                        erlang:element(4, Request)
                    ),
                    _pipe@3 = gleam@result:'try'(
                        _pipe@2,
                        fun(_capture) -> ping(Server, _capture) end
                    ),
                    _pipe@4 = gleam@result:map(
                        _pipe@3,
                        fun(_capture@1) ->
                            jsonrpcx:response(
                                _capture@1,
                                erlang:element(4, Request)
                            )
                        end
                    ),
                    gleam@result:map(
                        _pipe@4,
                        fun(_capture@2) ->
                            jsonrpcx:response_to_json(
                                _capture@2,
                                fun mcp_toolkit@core@protocol:ping_result_to_json/1
                            )
                        end
                    )
            end;

        M@2 when M@2 =:= <<"resources/list"/utf8>> ->
            paginated_params(
                Server,
                Request,
                fun list_resources/2,
                fun mcp_toolkit@core@protocol:list_resources_result_to_json/1
            );

        M@3 when M@3 =:= <<"resources/read"/utf8>> ->
            require_params(
                Server,
                Request,
                fun read_resource_handler/2,
                mcp_toolkit@core@protocol:read_resource_request_decoder(),
                fun mcp_toolkit@core@protocol:read_resource_result_to_json/1
            );

        M@4 when M@4 =:= <<"resources/templates/list"/utf8>> ->
            paginated_params(
                Server,
                Request,
                fun list_resource_templates/2,
                fun mcp_toolkit@core@protocol:list_resource_templates_result_to_json/1
            );

        M@5 when M@5 =:= <<"prompts/list"/utf8>> ->
            paginated_params(
                Server,
                Request,
                fun list_prompts/2,
                fun mcp_toolkit@core@protocol:list_prompts_result_to_json/1
            );

        M@6 when M@6 =:= <<"prompts/get"/utf8>> ->
            require_params(
                Server,
                Request,
                fun get_prompt_handler/2,
                mcp_toolkit@core@protocol:get_prompt_request_decoder(),
                fun mcp_toolkit@core@protocol:get_prompt_result_to_json/1
            );

        M@7 when M@7 =:= <<"tools/list"/utf8>> ->
            paginated_params(
                Server,
                Request,
                fun list_tools/2,
                fun mcp_toolkit@core@protocol:list_tools_result_to_json/1
            );

        M@8 when M@8 =:= <<"tools/call"/utf8>> ->
            require_params(
                Server,
                Request,
                fun call_tool_handler/2,
                mcp_toolkit@core@protocol:call_tool_request_decoder(
                    {decoder, fun gleam@dynamic@decode:decode_dynamic/1}
                ),
                fun mcp_toolkit@core@protocol:call_tool_result_to_json/1
            );

        _ ->
            _pipe@5 = {json_rpc_error, -32601, <<"Method not found"/utf8>>},
            _pipe@6 = jsonrpcx:error_response(
                _pipe@5,
                erlang:element(4, Request)
            ),
            _pipe@7 = jsonrpcx:error_response_to_json(
                _pipe@6,
                fun jsonrpcx:nothing_to_json/1
            ),
            {ok, _pipe@7}
    end.

-file("src/mcp_toolkit/core/server.gleam", 291).
-spec handle_message(server(), binary()) -> {ok,
        gleam@option:option(gleam@json:json())} |
    {error, gleam@json:json()}.
handle_message(Server, Message) ->
    Result = begin
        _pipe = gleam@json:parse(Message, jsonrpcx:message_decoder()),
        _pipe@1 = gleam@result:map_error(_pipe, fun jsonrpcx:json_error/1),
        _pipe@2 = gleam@result:map_error(
            _pipe@1,
            fun(_capture) -> jsonrpcx:error_response(_capture, null_id) end
        ),
        gleam@result:map_error(
            _pipe@2,
            fun(_capture@1) ->
                jsonrpcx:error_response_to_json(
                    _capture@1,
                    fun jsonrpcx:nothing_to_json/1
                )
            end
        )
    end,
    gleam@result:'try'(Result, fun(Msg) -> case Msg of
                {request_message, Request} ->
                    _pipe@3 = handle_request(Server, Request),
                    gleam@result:map(
                        _pipe@3,
                        fun(Field@0) -> {some, Field@0} end
                    );

                {notification_message, Notification} ->
                    _ = handle_notification(Server, Notification),
                    {ok, none};

                _ ->
                    {ok, none}
            end end).