File Coverage

blib/lib/Net/Async/MCP.pm

Criterion	Covered	Total	%
statement	72	87	82.7
branch	10	18	55.5
condition	4	9	44.4
subroutine	17	20	85.0
pod	12	12	100.0
total	115	146	78.7

package Net::Async::MCP;
# ABSTRACT: Async MCP (Model Context Protocol) client for IO::Async

use strict;
use warnings;
use parent 'IO::Async::Notifier';

use Future::AsyncAwait;
use Carp qw( croak );

our $VERSION = '0.002';


sub _init {
  my ( $self, $params ) = @_;
  for my $key (qw( server command url )) {
    $self->{$key} = delete $params->{$key} if exists $params->{$key};
  }
  $self->{_initialized} = 0;
  $self->SUPER::_init($params);
}

sub configure {
  my ( $self, %params ) = @_;
  for my $key (qw( server command url )) {
    $self->{$key} = delete $params{$key} if exists $params{$key};
  }
  $self->SUPER::configure(%params);
}

sub _add_to_loop {
  my ( $self, $loop ) = @_;
  $self->SUPER::_add_to_loop($loop);
  $self->_ensure_transport;
}

sub _ensure_transport {
  my ( $self ) = @_;
  return if $self->{transport};

  if ($self->{server}) {
    require Net::Async::MCP::Transport::InProcess;
    $self->{transport} = Net::Async::MCP::Transport::InProcess->new(
      server => $self->{server},
    );
  }
  elsif ($self->{command}) {
    croak "Stdio transport requires being added to an IO::Async::Loop"
      unless $self->loop;
    require Net::Async::MCP::Transport::Stdio;
    my $transport = Net::Async::MCP::Transport::Stdio->new(
      command => $self->{command},
    );
    $self->{transport} = $transport;
    $self->add_child($transport);
  }
  elsif ($self->{url}) {
    croak "HTTP transport requires being added to an IO::Async::Loop"
      unless $self->loop;
    require Net::Async::MCP::Transport::HTTP;
    my $transport = Net::Async::MCP::Transport::HTTP->new(
      url => $self->{url},
    );
    $self->{transport} = $transport;
    $self->add_child($transport);
  }
  else {
    croak "Must provide server, command, or url";
  }
}

sub server_info { $_[0]->{server_info} }


sub server_capabilities { $_[0]->{server_capabilities} }


async sub initialize {
  my ( $self ) = @_;
  $self->_ensure_transport;

  my $result = await $self->{transport}->send_request('initialize', {
    protocolVersion => '2025-11-25',
    capabilities => {},
    clientInfo => {
      name    => 'Net::Async::MCP',
      version => $VERSION,
    },
  });

  $self->{server_info} = $result->{serverInfo};
  $self->{server_capabilities} = $result->{capabilities};
  $self->{_initialized} = 1;

  await $self->{transport}->send_notification('notifications/initialized');

  return $result;
}


async sub list_tools {
  my ( $self ) = @_;
  my $result = await $self->{transport}->send_request('tools/list');
  return $result->{tools} // [];
}


async sub call_tool {
  my ( $self, $name, $arguments ) = @_;
  my $result = await $self->{transport}->send_request('tools/call', {
    name      => $name,
    arguments => $arguments // {},
  });
  return $result;
}


async sub list_prompts {
  my ( $self ) = @_;
  my $result = await $self->{transport}->send_request('prompts/list');
  return $result->{prompts} // [];
}


async sub get_prompt {
  my ( $self, $name, $arguments ) = @_;
  my $result = await $self->{transport}->send_request('prompts/get', {
    name      => $name,
    arguments => $arguments // {},
  });
  return $result;
}


async sub list_resources {
  my ( $self ) = @_;
  my $result = await $self->{transport}->send_request('resources/list');
  return $result->{resources} // [];
}


async sub read_resource {
  my ( $self, $uri ) = @_;
  my $result = await $self->{transport}->send_request('resources/read', {
    uri => $uri,
  });
  return $result;
}


async sub ping {
  my ( $self ) = @_;
  await $self->{transport}->send_request('ping');
  return 1;
}


async sub shutdown {
  my ( $self ) = @_;
  if ($self->{transport} && $self->{transport}->can('close')) {
    await $self->{transport}->close;
  }
  return 1;
}



1;

__END__