moonbitstack/moonmcp/client - mooncakes.io

README
U
Bearer
U
CacheScope
U
Cancellations
U
Channel
U
Client
U
Context
U
Facts
U
FastMCPError
U
Lines
U
Memory
U
Message
U
Principal
U
Prompt
U
Refused
U
Resource
U
ResourceTemplate
U
Scope
U
Server
U
Tool
U
ToolResult
V
decode
V
decode_option
V
text_block

moonbitstack/moonmcp/client does not have a README file

Transport

pub(open) trait Transport {
  async fn ask(Self, message : Json, on_notification : async (Json) -> Unit) -> Json
  async fn tell(Self, message : Json) -> Unit
  async fn listen(Self, message : Json, on_notification : async (Json) -> Unit) -> Unit
  async fn close(Self) -> Unit
}

A connection that carries JSON-RPC messages. Implement it to reach a server this library does not speak to itself; the three that ship here are Memory, Lines and Http.

The trait is open: a transport only has to move messages and say which reply belongs to which request. Everything a client does with them — versioning, capabilities, the shape of a call — stays in Client.

Refused

pub suberror Refused {
  Refused(code~ : Int, message~ : String, data~ : Json?)
}

A server said no. The code and data are the JSON-RPC error as it arrived.

Client

pub struct Client {
  info : @moonbitstack/moonmcp/types.Implementation
Implementation
  capabilities : @moonbitstack/moonmcp/types.ClientCapabilities
ClientCapabilities
  // private fields
}

A connection to a server, with the handshake behind it (← FastMCP's Client).

On the 2026-07-28 revision there is no handshake: every request carries the version, the client's identity and its capabilities in _meta, and the server answers on its own. On the revisions before it, connect runs initialize and notifications/initialized once.

Client::call_tool

async fn Client::call_tool(self : Client, name : String, arguments? : Map[String, Json], on_notification? : async (Json) -> Unit, progress_token? : Json) -> @moonbitstack/moonmcp/types.CallToolResult
CallToolResult

Call name with arguments; notifications sent before the answer go to on_notification.

Client::close

async fn Client::close(self : Client) -> Unit

Stop asking for anything on this connection.

Client::connect

async fn Client::connect(transport : &Transport, name? : String, version? : String, protocol_version? : String, capabilities? : @moonbitstack/moonmcp/types.ClientCapabilities
ClientCapabilities) -> Client

Connect over transport. protocol_version picks the dialect: 2026-07-28 speaks the stateless revision, anything the server lists as older runs the handshake. The default follows the server's own latest_protocol_version.

Client::discover

async fn Client::discover(self : Client) -> Map[String, Json]

What the server supports and which revisions it speaks.

Client::exchange

async fn Client::exchange(self : Client, operation : String, params? : Map[String, Json], on_notification? : async (Json) -> Unit, progress_token? : Json) -> Map[String, Json]

The same, with somewhere to put the notifications the server sends while the answer is being worked out: progress, log messages.

Client::get_prompt

async fn Client::get_prompt(self : Client, name : String, arguments? : Map[String, Json]) -> @moonbitstack/moonmcp/types.GetPromptResult
GetPromptResult

Render the prompt name with arguments.

Client::list_prompts

async fn Client::list_prompts(self : Client) -> Array[@moonbitstack/moonmcp/types.Prompt
Prompt]

The prompts the server offers.

Client::list_resources

async fn Client::list_resources(self : Client) -> Array[@moonbitstack/moonmcp/types.Resource
Resource]

The resources the server offers.

Client::list_tools

async fn Client::list_tools(self : Client) -> Array[@moonbitstack/moonmcp/types.Tool
Tool]

The tools the server offers.

Client::listen

async fn Client::listen(self : Client, filter~ : @moonbitstack/moonmcp/types.SubscriptionFilter
SubscriptionFilter, on_notification~ : async (Json) -> Unit) -> Unit

Open a subscription and hand every notification on it to on_notification until the server ends it.

Client::notify

async fn Client::notify(self : Client, operation : String, params? : Map[String, Json]) -> Unit

Send a message that gets no reply.

Client::ping

async fn Client::ping(self : Client) -> Unit

A bare result with no payload.

Client::protocol_version

fn Client::protocol_version(self : Client) -> String

The revision in force on this connection.

Client::read_resource

async fn Client::read_resource(self : Client, uri : String) -> @moonbitstack/moonmcp/types.ReadResourceResult
ReadResourceResult

Read the resource at uri.

Client::request

async fn Client::request(self : Client, operation : String, params? : Map[String, Json]) -> Map[String, Json]

Ask operation with params and hand back the result, raising Refused when the server answers with an error.

Client::server_capabilities

fn Client::server_capabilities(self : Client) -> @moonbitstack/moonmcp/types.ServerCapabilities
ServerCapabilities?

What the server says it can do.

Client::server_info

fn Client::server_info(self : Client) -> @moonbitstack/moonmcp/types.Implementation
Implementation?

Who the server says it is, once it has said.

Lines

pub struct Lines {
  read : async () -> String?
  write : async (String) -> Unit
  lock : @moonbitlang/async.Mutex
Mutex
}

A transport over a pair of line streams: standard input and output of a child process, a socket, a pipe. The same reader and writer a server is served on, seen from the other end.

One question is in flight at a time: a reply carries only an id, so a second question would have to read past the first one's answer. The lock holds the whole exchange for that reason.

impl Transport for Lines

async fn ask(self : Lines, message : Json, on_notification : async (Json) -> Unit) -> Json

Write the request and read until the reply carrying its id arrives, handing every other message to on_notification.

async fn close(_self : Lines) -> Unit

Nothing to let go: the streams belong to whoever made them.

async fn listen(self : Lines, message : Json, on_notification : async (Json) -> Unit) -> Unit

Write the listen request and hand on every message of the stream, until the reply that closes it.

async fn tell(self : Lines, message : Json) -> Unit

Write one notification; nothing is read back.

Lines::ask

async fn Lines::ask(self : Lines, message : Json, on_notification : async (Json) -> Unit) -> Json

Lines::close

async fn Lines::close(_self : Lines) -> Unit

Lines::listen

async fn Lines::listen(self : Lines, message : Json, on_notification : async (Json) -> Unit) -> Unit

Lines::new

fn Lines::new(read~ : async () -> String?, write~ : async (String) -> Unit) -> Lines

Speak newline-delimited JSON-RPC over read and write.

Lines::tell

async fn Lines::tell(self : Lines, message : Json) -> Unit

Memory

pub struct Memory {
  server : @moonbitstack/moonmcp/server.Server
Server
}

A transport that reaches a server in the same program, with no wire between them: what an editor, a test or an embedded agent uses.

impl Transport for Memory

async fn ask(self : Memory, message : Json, on_notification : async (Json) -> Unit) -> Json

Ask the server in this program. Nothing carried the message, so its handlers see no headers and no client identity.

async fn close(_self : Memory) -> Unit

Nothing to let go: the server is in this process.

async fn listen(self : Memory, message : Json, on_notification : async (Json) -> Unit) -> Unit

Open a subscription on the server and hand its notifications on until the stream ends.

async fn tell(self : Memory, message : Json) -> Unit

Hand a notification to the server; nothing comes back.

Memory::ask

async fn Memory::ask(self : Memory, message : Json, on_notification : async (Json) -> Unit) -> Json

Memory::close

async fn Memory::close(_self : Memory) -> Unit

Memory::listen

async fn Memory::listen(self : Memory, message : Json, on_notification : async (Json) -> Unit) -> Unit

Memory::new

fn Memory::new(server : @moonbitstack/moonmcp/server.Server
Server) -> Memory

Reach server directly. Its handlers see no headers and no client identity, since nothing carried the message.

Memory::tell

async fn Memory::tell(self : Memory, message : Json) -> Unit

Source Files

Install

Model Context Protocol servers and clients for MoonBit.

mcpllmagent

Apache-2.0

github.com/moonbitstack/moonmcp

Updated 8 hours ago

91 downloads

Powered by MoonBit

Site source Report issue Modules Skills Build queue Statistics

© 2026 mooncakes.io