AnyEvent-MCP

 view release on metacpan or  search on metacpan

t/c04_client.t  view on Meta::CPAN

sub wait_for {
   my ($start) = @_;
   my $cv = AnyEvent->condvar;
   my $timer = AnyEvent->timer (after => 30, cb => sub { die "Client test timeout\n" });
   $start->(sub { $cv->send ([@_]) });
   @{$cv->recv}
}

my $dir = File::Temp::tempdir (CLEANUP => 1);
local $ENV{XDG_CONFIG_HOME} = "$dir/config";
my $toolset = AnyEvent::MCP::Server::Toolset->new;
my $pending;
$toolset->tool (echo => "echo", {}, sub { $_[0]->result ($_[1]) });
$toolset->tool (slow => "slow", {}, sub { $pending = $_[0] });
$toolset->tool (fail => "fail", {}, sub { $_[0]->error ("tool failure") });

my $server = AnyEvent::MCP::Server::HTTP->new (
   toolsets => [$toolset], tokens => ["secret"],
);
$server->listen;
my $ready = 0;
my $client = AnyEvent::MCP::Client::HTTP->new (url => $server->url (0), bearer => "secret",
   on_ready => sub { ++$ready });
ok !-e "$dir/config", "unnamed server and client read no config";

my ($success, $result) = wait_for (sub { $client->call (echo => { text => "hello" }, $_[0]) });
ok $success && $result->{structuredContent}{text} eq "hello", "modern HTTP tool call";
ok $ready == 1, "ready event fires after successful MCP discovery";
($success, $result) = wait_for (sub { $client->connect ($_[0]) });
ok $success && $ready == 1, "reusing an initialized connection does not repeat ready event";
ok $client->{protocol_version} eq "2026-07-28", "modern discovery";
ok $client->{server_info}{name} eq "AnyEvent::MCP", "server identity";
ok ref $client->{server_capabilities}{tools} eq "HASH", "server capabilities";
($success, $result) = wait_for (sub { $client->tools ($_[0]) });
ok $success && @$result == 3, "list tools";
($success, $result) = wait_for (sub { $client->call (fail => {}, $_[0]) });
ok $success && $result->{isError}, "tool failure remains successful RPC";
($success, $result) = wait_for (sub { $client->rpc ("unknown", {}, $_[0]) });
ok !$success && $result->{code} == -32601, "HTTP protocol error preserved";
($success, $result) = wait_for (sub { $client->notify ("notifications/initialized", {}, $_[0]) });
ok $success, "HTTP notification";
$client->close;
($success, $result) = wait_for (sub { $client->call (echo => {}, $_[0]) });
ok $success && $ready == 2, "ready event fires again after reconnect";
$client->close;

$client = AnyEvent::MCP::Client::HTTP->new (url => $server->url);
($success, $result) = wait_for (sub { $client->call (echo => {}, $_[0]) });
ok $success, "URL cookie without header auth";
$client->close;
my $url = $server->url;
chop $url;
$client = AnyEvent::MCP::Client::HTTP->new (url => $url);
($success, $result) = wait_for (sub { $client->rpc ("ping", {}, $_[0]) });
ok $success, "URL token works without trailing slash";
$client->close;
$url = $server->url (0);
chop $url;
$client = AnyEvent::MCP::Client::HTTP->new (url => $url, bearer => "secret");
($success, $result) = wait_for (sub { $client->rpc ("ping", {}, $_[0]) });
ok $success, "bearer-authenticated endpoint works without trailing slash";
$client->close;
$url = $server->url;
$url =~ s{/secret/mcp/\z}{/wrong/mcp};
$client = AnyEvent::MCP::Client::HTTP->new (url => $url);
($success, $result) = wait_for (sub { $client->rpc ("ping", {}, $_[0]) });
ok !$success && $result->{transport} && $result->{message} =~ /404/,
   "unknown URL token without trailing slash still rejected";
$client->close;
$client = AnyEvent::MCP::Client::HTTP->new (url => $server->url . "extra");
($success, $result) = wait_for (sub { $client->rpc ("ping", {}, $_[0]) });
ok !$success && $result->{transport} && $result->{message} =~ /404/,
   "extra path component still rejected";
$client->close;
$client = AnyEvent::MCP::Client::HTTP->new (url => $server->url (0), bearer => "wrong");
($success, $result) = wait_for (sub { $client->rpc ("ping", {}, $_[0]) });
ok !$success && $result->{transport} && $result->{message} =~ /401/, "wrong bearer fails";
$client->close;
$server->close;

$server = AnyEvent::MCP::Server::HTTP->new (toolsets => [$toolset],
   tokens => ["secret"], path => "/custom/");
$server->listen;
$url = $server->url;
chop $url;
$client = AnyEvent::MCP::Client::HTTP->new (url => $url);
($success, $result) = wait_for (sub { $client->rpc ("ping", {}, $_[0]) });
ok $success, "configured endpoint path accepts omitted trailing slash";
$client->close;
$server->close;

$server = AnyEvent::MCP::Server::HTTP->new (toolsets => [$toolset],
   tokens => ["secret"], path => "/custom");
$server->listen;
$client = AnyEvent::MCP::Client::HTTP->new (url => $server->url . "/");
($success, $result) = wait_for (sub { $client->rpc ("ping", {}, $_[0]) });
ok !$success && $result->{transport} && $result->{message} =~ /404/,
   "endpoint without trailing slash still rejects an added slash";
$client->close;
$server->close;

$server = AnyEvent::MCP::Server::HTTP->new (toolsets => [$toolset], tokens => ["alpha", "beta"]);
$server->listen;
$client = AnyEvent::MCP::Client::HTTP->new (url => $server->url (0), bearer => "beta");
($success, $result) = wait_for (sub { $client->call (echo => {}, $_[0]) });
ok $success, "second token accepted in Authorization header";
$client->close;
$server->close;
eval { AnyEvent::MCP::Client::HTTP->new (url => "http://localhost/", bearer => "token", username => "alice", password => "pw") };
ok $@ =~ /Basic authentication is unsupported/, "Basic credentials rejected even with bearer";
eval { AnyEvent::MCP::Client::HTTP->new (url => "http://localhost/", username => "alice") };
ok $@ =~ /Basic authentication is unsupported/, "Basic client credentials rejected";

$server = AnyEvent::MCP::Server::HTTP->new (auth => "none", toolsets => [$toolset], versions => ["2025-06-18"]);
$server->listen;
$client = AnyEvent::MCP::Client::HTTP->new (url => $server->url);
($success, $result) = wait_for (sub { $client->call (echo => { value => 42 }, $_[0]) });
ok $success && $result->{structuredContent}{value} == 42, "legacy fallback tool call";
ok $client->{protocol_version} eq "2025-06-18", "negotiated legacy version";
ok $client->{server_info}{name} eq "AnyEvent::MCP", "legacy wire identity preserved";
$client->close;
$server->close;

# Old dispatchers can return an internal error for an unknown discovery method.
my $discoveries = 0;
$server = AnyEvent::MCP::Server::HTTP->new (auth => "none", 
   toolsets => [$toolset],
   on_request => sub {
      if ($_[1]{method} eq "server/discover") {
         ++$discoveries;
         die "Undefined discovery handler\n"
      }
   },
);
$server->listen;
$client = AnyEvent::MCP::Client::HTTP->new (url => $server->url);
($success, $result) = wait_for (sub { $client->call (echo => { value => 42 }, $_[0]) });
ok $success && $result->{structuredContent}{value} == 42, "discovery internal error falls back to initialization";
ok $discoveries == 1 && $client->{protocol_version} eq "2025-11-25", "fallback negotiates legacy once";
$client->close;
$server->close;

my $calls = 0;
my @input;
$server = AnyEvent::MCP::Server::HTTP->new (auth => "none", on_tools_call => sub {
   my ($server, $req, $args) = @_;
   ++$calls;
   if (exists $req->{params}{inputResponses}) {
      ok $req->{params}{requestState} eq "opaque", "request state echoed";
      ok $req->{params}{inputResponses}{question}{content}{answer} == 42, "input answer echoed";
      ok $args->{original} eq "keep", "original tool arguments preserved";
      $req->result ({ answer => 42 });
   } else {
      $req->reply ({
         resultType => "input_required", requestState => "opaque",
         inputRequests => { question => {
            method => "elicitation/create", params => { message => "question" },
         } },



( run in 0.929 second using v1.01-cache-2.11-cpan-1bcd28dbaf1 )