moonbitstack/moonmcp/client

README
U
Bearer
U
CacheScope
U
Caching
U
Call
U
Cancellations
U
Challenge
U
Channel
U
Client
U
Context
U
ElicitResult
U
Facts
U
FastMCPError
U
Hidden
U
Layer
U
Lines
U
Listing
U
Memory
U
Message
U
Namespace
U
Next
U
Operation
U
Principal
U
Prompt
U
Provider
U
RateLimiting
U
Refused
U
Resource
U
ResourceTemplate
U
Scope
U
Server
U
Span
U
Tagged
U
Telemetry
U
Tool
U
ToolResult
U
Transform
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 : @moonbitlang/core/json.Json
Json, on_notification : async (@moonbitlang/core/json.Json
Json) -> Unit) -> @moonbitlang/core/json.Json
Json
  async fn tell(Self, message : @moonbitlang/core/json.Json
Json) -> Unit
  async fn listen(Self, message : @moonbitlang/core/json.Json
Json, on_notification : async (@moonbitlang/core/json.Json
Json) -> Unit) -> Unit
  async fn close(Self) -> Unit
  fn answer_with(Self, answer : async (@moonbitlang/core/json.Json
Json) -> @moonbitlang/core/json.Json
Json?) -> 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, and answer the requests the server makes in the middle of one of ours. Everything a client does with them — versioning, capabilities, the shape of a call — stays in Client.

Refused

source

pub suberror Refused {
  Refused(code~ : Int, message~ : String, data~ : @moonbitlang/core/json.Json
Json?)
}

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

Client

source

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

source

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

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

Client::close

source

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

Stop asking for anything on this connection.

Client::connect

source

async fn Client::connect(transport : &Transport, name? : String, version? : String, protocol_version? : String, capabilities? : @moonbitstack/moonmcp/types.ClientCapabilities
ClientCapabilities, handlers? : Handlers) -> 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

source

async fn Client::discover(self : Client) -> Map[String, @moonbitlang/core/json.Json
Json]

What the server supports and which revisions it speaks.

Client::exchange

source

async fn Client::exchange(self : Client, operation : String, params? : Map[String, @moonbitlang/core/json.Json
Json], on_notification? : async (@moonbitlang/core/json.Json
Json) -> Unit, progress_token? : @moonbitlang/core/json.Json
Json) -> Map[String, @moonbitlang/core/json.Json
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

source

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

Render the prompt name with arguments.

Client::list_prompts

source

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

The prompts the server offers.

Client::list_resources

source

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

The resources the server offers.

Client::list_tools

source

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

The tools the server offers.

Client::listen

source

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

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

Client::notify

source

async fn Client::notify(self : Client, operation : String, params? : Map[String, @moonbitlang/core/json.Json
Json]) -> Unit

Send a message that gets no reply.

Client::ping

source

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

A bare result with no payload.

Client::protocol_version

source

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

The revision in force on this connection.

Client::read_resource

source

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

Read the resource at uri.

Client::request

source

async fn Client::request(self : Client, operation : String, params? : Map[String, @moonbitlang/core/json.Json
Json]) -> Map[String, @moonbitlang/core/json.Json
Json]

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

Client::server_capabilities

source

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

What the server says it can do.

Client::server_info

source

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

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

Handlers

source

pub(all) struct Handlers {
  sampling : async (@moonbitstack/moonmcp/types.CreateMessageRequestParams
CreateMessageRequestParams) -> @moonbitstack/moonmcp/types.CreateMessageResult
CreateMessageResult?
  elicitation : async (@moonbitstack/moonmcp/types.ElicitRequestParams
ElicitRequestParams) -> @moonbitstack/moonmcp/types.ElicitResult
ElicitResult?
  roots : async () -> @moonbitstack/moonmcp/types.ListRootsResult
ListRootsResult?
  apply_defaults : Bool
}

A client's answers to the requests a server may make of it. Any of the three may be left out, and a server that asks for one the client does not do is told so with the error JSON-RPC prescribes.

apply_defaults is SEP-1034: an accepted elicitation leaves out a field the person did not touch, and the default from the requested schema is filled in before the answer goes back, so the server sees a complete form.

Handlers::answer

source

async fn Handlers::answer(self : Handlers, message : @moonbitlang/core/json.Json
Json) -> @moonbitlang/core/json.Json
Json?

What to send back for a message the server sent: a reply when it was a request, nothing when it was a notification.

Handlers::new

source

fn Handlers::new(sampling? : async (@moonbitstack/moonmcp/types.CreateMessageRequestParams
CreateMessageRequestParams) -> @moonbitstack/moonmcp/types.CreateMessageResult
CreateMessageResult, elicitation? : async (@moonbitstack/moonmcp/types.ElicitRequestParams
ElicitRequestParams) -> @moonbitstack/moonmcp/types.ElicitResult
ElicitResult, roots? : async () -> @moonbitstack/moonmcp/types.ListRootsResult
ListRootsResult, apply_defaults? : Bool) -> Handlers

The answers a client gives. Everything left out is a request the client declines to serve.

Handlers::none

source

fn Handlers::none() -> Handlers

A client that answers nothing.

Lines

source

pub struct Lines {
  lock : @moonbitlang/async.Mutex
Mutex
  answer : @moonbitlang/core/ref.Ref
Ref[async (@moonbitlang/core/json.Json
Json) -> @moonbitlang/core/json.Json
Json??]
  // private fields
}

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 message is one line. The framing and the pairing of a reply with its request are moonjrpc's: a Peer over these streams assigns the request identifiers, wakes the caller whose reply arrived, answers whatever the server asks, and ends when the stream does.

impl Transport for Lines

fn answer_with(self : Lines, answer : async (@moonbitlang/core/json.Json
Json) -> @moonbitlang/core/json.Json
Json?) -> Unit

source

Keep answer as the place the server's questions go.

async fn ask(self : Lines, message : @moonbitlang/core/json.Json
Json, on_notification : async (@moonbitlang/core/json.Json
Json) -> Unit) -> @moonbitlang/core/json.Json
Json

source

Write the request and wait for its reply, with whatever the server asks in between answered on the same stream.

async fn close(_self : Lines) -> Unit

source

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

async fn listen(self : Lines, message : @moonbitlang/core/json.Json
Json, on_notification : async (@moonbitlang/core/json.Json
Json) -> Unit) -> Unit

source

Open a subscription and hand every notification to on_notification until the server answers the request that opened it.

async fn tell(self : Lines, message : @moonbitlang/core/json.Json
Json) -> Unit

source

Write one notification; nothing is read back.

Lines::answer_with

source

fn Lines::answer_with(self : Lines, answer : async (@moonbitlang/core/json.Json
Json) -> @moonbitlang/core/json.Json
Json?) -> Unit

Lines::ask

source

async fn Lines::ask(self : Lines, message : @moonbitlang/core/json.Json
Json, on_notification : async (@moonbitlang/core/json.Json
Json) -> Unit) -> @moonbitlang/core/json.Json
Json

Lines::close

source

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

Lines::listen

source

async fn Lines::listen(self : Lines, message : @moonbitlang/core/json.Json
Json, on_notification : async (@moonbitlang/core/json.Json
Json) -> Unit) -> Unit

Lines::new

source

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

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

Lines::tell

source

async fn Lines::tell(self : Lines, message : @moonbitlang/core/json.Json
Json) -> Unit

Memory

source

pub struct Memory {
  server : @moonbitstack/moonmcp/server.Server
Server
  answer : @moonbitlang/core/ref.Ref
Ref[async (@moonbitlang/core/json.Json
Json) -> @moonbitlang/core/json.Json
Json??]
}

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

fn answer_with(self : Memory, answer : async (@moonbitlang/core/json.Json
Json) -> @moonbitlang/core/json.Json
Json?) -> Unit

source

Keep answer as the place the server's questions go.

async fn ask(self : Memory, message : @moonbitlang/core/json.Json
Json, on_notification : async (@moonbitlang/core/json.Json
Json) -> Unit) -> @moonbitlang/core/json.Json
Json

source

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

A question the server puts to the client inside a handler travels out through the same channel and comes back the same way, which is what makes sampling and elicitation work with no wire at all.

async fn close(_self : Memory) -> Unit

source

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

async fn listen(self : Memory, message : @moonbitlang/core/json.Json
Json, on_notification : async (@moonbitlang/core/json.Json
Json) -> Unit) -> Unit

source

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

async fn tell(self : Memory, message : @moonbitlang/core/json.Json
Json) -> Unit

source

Hand a notification to the server; nothing comes back.

Memory::answer_with

source

fn Memory::answer_with(self : Memory, answer : async (@moonbitlang/core/json.Json
Json) -> @moonbitlang/core/json.Json
Json?) -> Unit

Memory::ask

source

async fn Memory::ask(self : Memory, message : @moonbitlang/core/json.Json
Json, on_notification : async (@moonbitlang/core/json.Json
Json) -> Unit) -> @moonbitlang/core/json.Json
Json

Memory::close

source

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

Memory::listen

source

async fn Memory::listen(self : Memory, message : @moonbitlang/core/json.Json
Json, on_notification : async (@moonbitlang/core/json.Json
Json) -> Unit) -> Unit

Memory::new

source

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

source

async fn Memory::tell(self : Memory, message : @moonbitlang/core/json.Json
Json) -> Unit

fill_defaults

source

fn fill_defaults(schema : Map[String, @moonbitlang/core/json.Json
Json]?, content : Map[String, @moonbitlang/core/json.Json
Json]) -> Map[String, @moonbitlang/core/json.Json
Json]

content with the default of every property of schema it leaves out, one level deep: a form's fields are properties of the requested schema, and a nested object carries its own form. A property without a default stays out — the person left it empty, which the server may treat as an error.

Source Files

Install

Download zip

Model Context Protocol servers and clients for MoonBit.

mcpmodel-context-protocolllmagentaiai-agenttoolstool-callingpromptsresourceselicitationserverclientjson-rpcjsonrpcstdiostreamable-httpsseoauthoauth2pkceauthorization-coderfc9728rfc8414resource-indicatorconformanceasgiannotationsfastmcpprovidertransformmiddlewarecachingrate-limitingtelemetryobservabilitymoonbit

moonbitstack

Apache-2.0

github.com/moonbitstack/moonmcp

Updated 12 hours ago

173 downloads

Site source Report issue Modules Skills CLI Build queue Statistics

#Transport

#Refused

#Client

#Client::call_tool

#Client::close

#Client::connect

#Client::discover

#Client::exchange

#Client::get_prompt

#Client::list_prompts

#Client::list_resources

#Client::list_tools

#Client::listen

#Client::notify

#Client::ping

#Client::protocol_version

#Client::read_resource

#Client::request

#Client::server_capabilities

#Client::server_info

#Handlers

#Handlers::answer

#Handlers::new

#Handlers::none

#Lines

#Lines::answer_with

#Lines::ask

#Lines::close

#Lines::listen

#Lines::new

#Lines::tell

#Memory

#Memory::answer_with

#Memory::ask

#Memory::close

#Memory::listen

#Memory::new

#Memory::tell

#fill_defaults

Source Files

Transport

Refused

Client

Client::call_tool

Client::close

Client::connect

Client::discover

Client::exchange

Client::get_prompt

Client::list_prompts

Client::list_resources

Client::list_tools

Client::listen

Client::notify

Client::ping

Client::protocol_version

Client::read_resource

Client::request

Client::server_capabilities

Client::server_info

Handlers

Handlers::answer

Handlers::new

Handlers::none

Lines

Lines::answer_with

Lines::ask

Lines::close

Lines::listen

Lines::new

Lines::tell

Memory

Memory::answer_with

Memory::ask

Memory::close

Memory::listen

Memory::new

Memory::tell

fill_defaults