README- UBearer
- UCacheScope
- UCaching
- UCall
- UCancellations
- UChannel
- UClient
- UContext
- UFacts
- UFastMCPError
- UHidden
- ULayer
- ULines
- UListing
- UMemory
- UMessage
- UNamespace
- UNext
- UOperation
- UPrincipal
- UPrompt
- UProvider
- URateLimiting
- URefused
- UResource
- UResourceTemplate
- UScope
- UServer
- USpan
- UTagged
- UTelemetry
- UTool
- UToolResult
- UTransform
- Vdecode
- Vdecode_option
- Vtext_block
moonbitstack/moonmcp/server does not have a README file
Cancellations
pub struct Cancellations {
// private fields
}Which requests a client has withdrawn by notifications/cancelled.
The notification names a request the client already sent, so a transport
keeps this beside its read loop: the loop records, the running requests
ask.
Cancellations::add
Record that the client no longer wants the answer to request id.
Cancellations::has
Whether the client has withdrawn request id.
Cancellations::unwatch
Stop waiting to be told: the request is over.
Cancellations::watch
Ask to be told when request id is withdrawn. A stream that waits for
something other than its own answer, a subscription above all, has no other
way to hear about it.
Channel
What a transport lends one request: the headers that carried it, the way to
send a notification before the reply, and whether the caller is still
there.
A transport that can carry nothing beside the reply passes
Channel::quiet, which is what Server::handle uses.
Channel::new
A channel over the transport that carries this request.
Scope
Who may keep a cached list result: any intermediary, or only caches inside
the same authorisation context (the cacheScope of a cacheable result).
Scope::to_cache_scope
The same scope as the wire names it.
Server
pub struct Server {
info : Implementation
instructions : String?
ttl_ms : Int
scope : Scope
// private fields
}An MCP server (← FastMCP's FastMCP): the tools, resources, resource
templates and prompts it offers, and who it says it is.
It speaks both eras of the protocol. A request carrying its protocol version
in _meta is served statelessly under the 2026-07-28 revision; an
initialize request opens the handshake of the revisions before it. The
same server is reached over Streamable HTTP with to_asgi, over stdio with
run_stdio, or by any transport of your own through handle.
ttl_ms and scope are the caching hints every list result carries under
the 2026-07-28 revision. The presets say "stale at once" and "this caller
only", the cautious end of both, since a server that changes what it lists
per caller would otherwise leak one caller's list to the next.
Server::add_prompt
Offer prompt. A second prompt under the same name replaces the first.
Server::add_provider
Take components from provider as well as from the server's own registry.
The provider is asked again on every listing, so what it supplies may change
between two of them. A name this server already answers is not taken from a
provider.
Server::add_resource
Offer resource at its URI. A second resource at the same URI replaces the
first.
Server::add_template
Offer template; a URI no fixed resource answers is matched against the
templates in the order they were added.
Server::add_tool
Offer tool. Its input schema is compiled here, so a call is checked
against it before the tool runs. A schema that does not compile is a
mistake in the program, not in a request, so it aborts now rather than
failing the first call. A second tool under the same name replaces the
first.
Server::add_transform
Apply transform to the components the server offers, in the order the
transforms were added: each one sees what the one before it produced.
Server::completion
fn Server::completion(self : Server, run : async (CompleteRequestParams, Context) -> Completion) -> UnitAnswer completion/complete: what to offer for the argument a client is filling in. Registering
this is what makes the server declare the completions capability.
Server::handle
Answer one JSON-RPC message, the way every transport does (← the
low-level server's message loop). None is the answer to a notification.
A message that is not JSON-RPC at all is answered with the error JSON-RPC
prescribes, under a null id.
This is the form for a caller with no channel of its own, so a handler's
progress reports and log messages are dropped. A transport that can carry
them calls handle_with.
Server::handle_with
Answer one message over channel, which carries the request's headers and
whatever the handlers send beside the reply.
Server::log_to
Write the server's own log through logger (← a structured logger passed
in, never reached for globally): a request served, a request refused, a
subscription opened. Context::log writes here too, beside the
notification it sends, so a client that went away does not take the record
with it.
Without one the server keeps no log of its own; the notifications/message
its handlers ask for still go to the client.
Server::new
Server::notify
Hand message to every subscription whose filter asked for it. A
subscription that has stopped reading its queue is dropped rather than
allowed to hold the change.
Server::notify_prompts_changed
Tell every subscription that the prompts changed.
Server::notify_resource_updated
Tell the subscriptions that asked for uri that it was rewritten.
Server::notify_resources_changed
Tell every subscription that the resources changed.
Server::notify_tools_changed
Tell every subscription that the tools changed. Registering a tool does
this by itself; a server whose tools come and go for reasons of its own
calls it when it knows.
Server::offered_prompts
The prompts a client is offered, after the transforms.
Server::offered_resources
The resources a client is offered, after the transforms.
Server::offered_templates
The resource templates a client is offered, after the transforms.
Server::offered_tools
The tools a client is offered: the registered ones, then whatever the
providers supply, as the transforms leave them.
Server::prompt
Offer a prompt rendered as one user message (← @mcp.prompt).
Server::prompt_context
fn Server::prompt_context(self : Server, name : String, render : async (Map[String, Json], Context) -> RenderedPrompt, title? : String, description? : String, arguments? : Array[PromptArgument]) -> UnitOffer a prompt whose renderer sees the request it serves.
Server::resource
Offer a resource read as text (← @mcp.resource(uri)).
Server::resource_context
fn Server::resource_context(self : Server, uri : String, read : async (Context) -> RawResourceValue, name? : String, title? : String, description? : String, mime_type? : String) -> UnitOffer a resource whose reader sees the request it serves. A read that needs
something from the client answers with ResourceResult::input_required
instead of contents.
Server::run_stdio
Serve over the process's standard input and output (← FastMCP's
run(transport="stdio")): one message per line each way, until standard
input closes. Anything else the program prints belongs on standard error,
since standard output carries nothing but messages.
Server::serve_lines
Serve newline-delimited JSON-RPC: read a line with read until it gives
None, answer it, and write the reply as one line (← the stdio
transport, over any pair of streams). A line that is not JSON is answered
with a parse error; a blank one is skipped.
Requests are worked on as they arrive, each in a task of its own, so a slow
tool does not hold up the next call. Replies still leave in the order their
requests came in, which is what a client that counts lines expects; a
subscription's notifications are the exception, since they are not replies
to anything.
notifications/cancelled withdraws the request it names, which the running
task sees through its context.
Server::serve_subscription
Serve one subscriptions/listen request until the transport lets go: the
acknowledgement first, then every notification the filter asked for, each
tagged with the id of the request that opened the stream.
The reply to the request itself is sent by the caller when this returns,
and only when it returns of its own accord: a stream cut by the transport
has no reply, as the specification has it.
Server::template
Offer the resources an RFC 6570 template names, read as text with the
parameters the URI matched (← @mcp.resource("users://{id}")). A template
that does not parse aborts at registration.
Server::template_context
Offer the resources an RFC 6570 template names, read in the request that
matched them.
Server::to_asgi
The server as an ASGI application serving the MCP endpoint at path
(← FastMCP's http_app). Run it with mooncat, or mount it beside a moonapi
app.
Every message is its own POST, answered with one JSON object, or 202 for a
notification. This server keeps no session, so DELETE answers 405.
A 2026-07-28 request that offers a progress token, or that opens a
subscription, is answered with text/event-stream when the client accepts
it: the notifications the handler sends arrive on that stream, and the
reply ends it.
Under the revisions before, a request becomes a stream the moment its handler
has something to send, and stays one JSON object when it has nothing. A GET
that accepts text/event-stream opens the stream those revisions hear list
changes and subscribed resources on; with no session to tie it to, every such
stream hears the updates to anything a client has subscribed to.
A request whose Origin header names another site is refused with 403, as
the transport requires against DNS rebinding. An origin passes when its host
is the request's own Host, a loopback address, or one listed in origins.
Host is checked as well, since a rebound name reaches a local server with a
Host that is not its own. hosts lists the names this server answers to; left
out, a server listening on a loopback address answers to loopback names only,
and one listening anywhere else takes any. A reverse proxy in front of a
loopback listener has to name the public host here.
docs names the path the documentation page is served at, beside the
endpoint: a browser opened on it lists what the server offers and calls it,
in both eras of the protocol. It is on at /docs unless told otherwise, as
an API framework's interactive docs are; docs=None leaves it off, and a
path equal to the endpoint's is ignored. theme picks its look, the moonmcp
website's by default. The page carries no credentials of its own.
Server::tool
Offer a tool whose handler returns any JSON value (← @mcp.tool). An object
becomes structured content as well as text; anything else becomes text. An
error the handler raises becomes a result marked isError, which the model
reads and can correct itself from. A name the protocol does not allow aborts
at registration.
Server::tool_context
fn Server::tool_context(self : Server, name : String, run : async (Map[String, Json], Context) -> ToolResult, input_schema? : Json, title? : String, description? : String, output_schema? : Json, annotations? : ToolAnnotations) -> UnitOffer a tool that also sees the request it serves (← FastMCP's Context
parameter): its identity in _meta, the headers that carried it, the
progress token it offered, and whatever the client answered on a retry.
The handler answers with a ToolResult. An ordinary one carries content;
ToolResult::input_required carries an ask instead, which the client
satisfies and then sends the same call again with inputResponses and
requestState, or with an answer if it cannot.
Server::use_layer
Put layer in front of every request: the first one added is the outermost,
so it sees a request before the ones after it and its answer last.
A layer that raises @exceptions.Mcp refuses the request with that code; a
layer that answers without calling on to the rest answers for the server.
ask_rounds
let ask_rounds : IntHow many times one request may ask before it is taken to be stuck. A handler that asks again
because it got an answer it did not like is fine; one that never stops is not.
ask_timeout_ms
let ask_timeout_ms : IntHow long a question put to the client waits for its reply: 60 seconds, the TypeScript SDK's
DEFAULT_REQUEST_TIMEOUT_MSEC.
decode
The argument name of a call, read as T; the code #mcp.tool generates
calls this for each required parameter. A string read where something else
is wanted is read again as JSON, which is how the {id} of a resource
template, always text, reaches an Int parameter.
decode_option
The argument name of a call when it may be left out: None when it is
missing or null, else the value read as decode reads it. The code
#mcp.tool generates calls this for optional parameters.
list_changed_notification
The notification that a server's tools, prompts or resources changed.
method_of
The method a message names, if it is a JSON-RPC one at all.
params_of
The parameters a message carries, empty when it carries none.
request_id_of
The id a request carries; None on a notification.
resource_updated_notification
The notification that one resource was rewritten.
Install
Download zipModel Context Protocol servers and clients for MoonBit.
mcpmodel-context-protocolllmagentaiai-agenttoolstool-callingpromptsresourceselicitationserverclientjson-rpcjsonrpcstdiostreamable-httpsseoauthasgiannotationsfastmcpprovidertransformmiddlewarecachingrate-limitingtelemetryobservabilitymoonbit
Apache-2.0
Updated 7 hours ago
126 downloads