AnyEvent-MCP

 view release on metacpan or  search on metacpan

lib/AnyEvent/MCP/Server/HTTP.pm  view on Meta::CPAN

      $handle->{mcp_origin} = $wildcard ? "*" : $hdr->{origin};
   }

   if ($hdr->{method} eq "OPTIONS" && @{$self->{origins}}) {
      return $self->_respond ($handle, 405, "Method Not Allowed", "")
         if exists $hdr->{"access-control-request-method"}
            && $hdr->{"access-control-request-method"} ne "POST";

      return $self->_respond ($handle, 204, "No Content", "");
   }

   return $self->_respond ($handle, 405, "Method Not Allowed", "")
      unless $hdr->{method} eq "POST";

   my $authenticated = $path_token;
   if ($self->{tokens}) {
      my $authorization = $hdr->{authorization};

      if ($authorization =~ /\ABearer ([^\s]+)\z/i) {
         my $token = $1;
         if (grep $_ eq $token, @{$self->{tokens}}) {
            return $self->_respond ($handle, 401, "Unauthorized", "")
               if defined $authenticated && $authenticated ne $token;
            $authenticated = $token;
         }
      }

      return $self->_respond ($handle, 401, "Unauthorized", "")
         unless defined $authenticated;
   }

   return $self->_respond ($handle, 415, "Unsupported Media Type", "")
      unless $hdr->{"content-type"} =~ m{\Aapplication/json(?:\s*;|\z)}i;

   my $message = eval { JSON::XS::decode_json $body };

   if ($@) {
      return $self->_rpc_error (sub {
         $self->_respond ($handle, 400, "Bad Request", JSON::XS::encode_json $_[0]);
      }, undef, -32700, "Parse error");
   }

   my $params = ref $message eq "HASH" && ref $message->{params} eq "HASH" ? $message->{params} : {};
   my $meta   = ref $params->{_meta} eq "HASH" ? $params->{_meta} : {};
   my $modern = exists $meta->{"io.modelcontextprotocol/protocolVersion"}
      || $hdr->{"mcp-protocol-version"} ge "2026";

   if ($modern && ref $message eq "HASH" && exists $message->{id}) {
      my %expected = (
         "mcp-protocol-version" => $meta->{"io.modelcontextprotocol/protocolVersion"},
         "mcp-method"           => $message->{method},
      );

      $expected{"mcp-name"} = exists $params->{name} ? $params->{name} : $params->{uri}
         if $message->{method} =~ /\A(?:tools\/call|prompts\/get|resources\/read)\z/;

      for my $name (keys %expected) {
         my $value = $hdr->{$name};

         if ($name eq "mcp-name" && $value =~ /\A=\?base64\?([A-Za-z0-9+\/=]*)\?=\z/) {
            $value = eval { AnyEvent::MCP::utf8dec (MIME::Base64::decode_base64 ($1)) };
         }

         unless (defined $value && defined $expected{$name} && $value eq $expected{$name}) {
            return $self->_rpc_error (sub {
               $self->_respond ($handle, 400, "Bad Request", JSON::XS::encode_json $_[0]);
            }, $message->{id}, -32020, "Header mismatch: $name");
         }
      }
   }

   weaken $self;

   my $streaming;
   my $sse = sub {
      my ($message) = @_;

      return unless $self && !$handle->{mcp_closed};
      unless ($streaming) {
         $streaming = 1;
         $handle->push_write (
            "HTTP/1.1 200 OK\r\n"
            . "Content-Type: text/event-stream\r\n"
            . "Cache-Control: no-cache\r\n"
            . "X-Accel-Buffering: no\r\n"
            . "Transfer-Encoding: chunked\r\n"
            . "Connection: close\r\n"
            . (defined $handle->{mcp_origin} ? "Access-Control-Allow-Origin: $handle->{mcp_origin}\r\n"
               . ($handle->{mcp_origin} ne "*" ? "Vary: Origin\r\n" : "") : "")
            . "\r\n"
         );
      }
      my $data = "data: " . JSON::XS::encode_json ($message) . "\r\n\r\n";
      $handle->push_write (sprintf "%x\r\n%s\r\n", length $data, $data);
   };

   $self->rpc ($message, sub {
      my ($response) = @_;

      return unless $self && !$handle->{mcp_closed};

      if ($streaming) {
         $sse->($response) if defined $response;
         $handle->push_write ("0\r\n\r\n");
         $handle->on_drain (sub { $self->_close ($_[0]) if $self });
         return;
      }

      my ($status, $reason) = defined $response ? (200, "OK") : (202, "Accepted");

      if ($modern && defined $response && $response->{error}) {
         ($status, $reason) = $response->{error}{code} == -32601
            ? (404, "Not Found") : (400, "Bad Request");
      }

      $self->_respond ($handle, $status, $reason, defined $response ? JSON::XS::encode_json $response : "");
   },
      peer             => $handle->{mcp_peer},
      user             => defined $authenticated ? $self->{token_users}{$authenticated} : undef,
      protocol_version => $hdr->{"mcp-protocol-version"} || "2025-03-26",
      (($hdr->{accept} || "") =~ m{\btext/event-stream\b}i



( run in 1.015 second using v1.01-cache-2.11-cpan-234fa220139 )