moonbitstack/moonmcp/layers

README
U
Bearer
U
CacheScope
U
Caching
U
Call
U
Cancellations
U
Channel
U
Client
U
Context
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/layers does not have a README file

Bucket

type Bucket

One caller's bucket.

Caching

source

pub struct Caching {
  // private fields
}

Answers a call from memory when the same call was made recently (← FastMCP's CachingMiddleware).

The key is the operation, the name and the arguments, with object keys sorted at every depth, so a client that sends the same arguments in another order still gets the stored answer. Errors and asks for client input are never stored: repeating them would hide the reason and replay a state the client has already answered.

ttl_ms is how long an answer stays good — five minutes, the default of FastMCP's cache. capacity is how many answers are kept before the oldest goes; shared says whether one caller's answer may be handed to another, which is only safe when the answer does not depend on who asked.

Caching::clear

source

fn Caching::clear(self : Caching) -> Unit

Forget everything.

Caching::hits

source

fn Caching::hits(self : Caching) -> Int

How many calls were answered without asking the server.

Caching::layer

source

fn Caching::layer(self : Caching) -> Layer

The layer this cache installs on a server.

Caching::misses

source

fn Caching::misses(self : Caching) -> Int

How many went through.

Caching::new

source

fn Caching::new(ttl_ms? : Int, capacity? : Int, operations? : Array[Operation], shared? : Bool) -> Caching

A cache of every call and every listing, kept for five minutes.

Caching::size

source

fn Caching::size(self : Caching) -> Int

How many answers are held right now.

Call

source

pub(all) struct Call {
  operation : Operation
  name : String
  arguments : Map[String, @moonbitlang/core/json.Json
Json]
  context : @moonbitstack/moonmcp/context.Context
Context
}

One request on its way through the chain: what it is, what it names, the arguments it carries, and the request context it will be served in.

Call::fingerprint

source

fn Call::fingerprint(self : Call) -> String

The arguments as one string: keys sorted at every depth, so two calls that mean the same thing also spell the same thing. A cache keys on it, and a rate limiter that counts by argument does too.

Call::new

source

fn Call::new(operation~ : Operation, name~ : String, arguments? : Map[String, @moonbitlang/core/json.Json
Json], context~ : @moonbitstack/moonmcp/context.Context
Context) -> Call

The call a request makes.

Call::subject

source

fn Call::subject(self : Call) -> String

Who is calling, as the authorisation check named them; empty when the request carried no identity.

Entry

source

type Entry

One stored answer and the moment it was made.

Layer

source

pub(all) struct Layer {
  name : String
  // private fields
}

One step of a chain (← FastMCP's middleware): a name for the logs and spans, and the function that sees every call passing through it.

A layer may answer without going on, pass the call along with next.then(call), look at what came back, or refuse it by raising @exceptions.Mcp with the code it wants sent.

Layer::new

source

fn Layer::new(name? : String, run~ : async (Call, Next) -> @moonbitlang/core/json.Json
Json raise @moonbitstack/moonmcp/exceptions.FastMCPError
FastMCPError) -> Layer

A layer made of a function.

Layer::serve

source

async fn Layer::serve(self : Layer, call : Call, next : Next) -> @moonbitlang/core/json.Json
Json raise @moonbitstack/moonmcp/exceptions.FastMCPError
FastMCPError

Serve the call through this layer alone, with next behind it.

source

pub(all) struct Next {
  // private fields
}

The rest of the chain, as a layer is handed it.

Next::then

source

async fn Next::then(self : Next, call : Call) -> @moonbitlang/core/json.Json
Json raise @moonbitstack/moonmcp/exceptions.FastMCPError
FastMCPError

Serve the call with everything behind this point in the chain.

Operation

source

pub(all) enum Operation {
  ListTools
  ListResources
  ListTemplates
  ListPrompts
  CallTool
  ReadResource
  GetPrompt
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

The request kinds a layer is asked about: the three that run a component, and the four that list them.

Operation::code

source

fn Operation::code(self : Operation) -> String

The JSON-RPC method an operation answers.

Operation::equal

source

fn Operation::equal(Operation, Operation) -> Bool

Operation::is_list

source

fn Operation::is_list(self : Operation) -> Bool

Whether the operation lists components rather than running one.

Operation::not_equal

source

fn Operation::not_equal(x : Operation, y : Operation) -> Bool

Operation::to_repr

source

fn Operation::to_repr(Operation) -> @moonbitlang/core/debug.Repr
Repr

RateLimiting

source

pub struct RateLimiting {
  // private fields
}

A token bucket per caller (← FastMCP's RateLimitingMiddleware).

Each caller starts with a full bucket of burst tokens, spends one per call, and gains rate tokens a second up to that ceiling. A caller with none left is refused with refused_code and told how long to wait; the bucket keeps no token for them, so a caller that keeps asking only waits longer.

Ten a second, twenty at once, is FastMCP's default. The caller is the subject the authorisation check named, and everyone unauthenticated shares one bucket — give key to count by a header or a tool instead. clock reads seconds from any fixed origin; the default is the monotonic clock.

RateLimiting::callers

source

fn RateLimiting::callers(self : RateLimiting) -> Int

How many callers are being counted.

RateLimiting::layer

source

fn RateLimiting::layer(self : RateLimiting) -> Layer

The layer this limiter installs on a server.

RateLimiting::new

source

fn RateLimiting::new(rate? : Int, burst? : Int, operations? : Array[Operation], key? : (Call) -> String, clock? : () -> Double) -> RateLimiting

A limiter of ten calls a second per caller, twenty in a burst.

RateLimiting::refused

source

fn RateLimiting::refused(self : RateLimiting) -> Int

How many calls were refused.

RateLimiting::reset

source

fn RateLimiting::reset(self : RateLimiting) -> Unit

Refill everyone to a full burst, as if no one had called yet.

Span

source

pub(all) struct Span {
  operation : Operation
  name : String
  duration_us : Double
  failed : Bool
} derive(@moonbitlang/core/debug.Debug
Debug)

One served request, as the telemetry layer saw it.

Span::to_repr

source

fn Span::to_repr(Span) -> @moonbitlang/core/debug.Repr
Repr

Telemetry

source

pub struct Telemetry {
  // private fields
}

Timing and counting for every request that passes through (← FastMCP's timing and logging middleware, kept as one record a caller can read or forward).

The last capacity spans are kept in memory and every one is handed to sink, so a program can print them, write them to its logger, or forward them to a tracing system of its own. A span is recorded whether the request was answered or raised, so a failure is counted where it happened rather than where the client noticed.

Telemetry::clear

source

fn Telemetry::clear(self : Telemetry) -> Unit

Forget every span and counter recorded so far.

Telemetry::count

source

fn Telemetry::count(self : Telemetry, operation : Operation) -> Int

How many requests of operation were served.

Telemetry::failures

source

fn Telemetry::failures(self : Telemetry) -> Int

How many of them ended in an error.

Telemetry::layer

source

fn Telemetry::layer(self : Telemetry) -> Layer

The layer this recorder installs on a server.

Telemetry::new

source

fn Telemetry::new(capacity? : Int, sink? : (Span) -> Unit) -> Telemetry

A recorder of the last 128 spans, keeping nothing else.

Telemetry::spans

source

fn Telemetry::spans(self : Telemetry) -> Array[Span]

The spans kept so far, oldest first.

Telemetry::total

source

fn Telemetry::total(self : Telemetry) -> Int

How many requests were served, all operations together.

chain

source

async fn chain(layers : Array[Layer], call : Call, end : async (Call) -> @moonbitlang/core/json.Json
Json raise @moonbitstack/moonmcp/exceptions.FastMCPError
FastMCPError) -> @moonbitlang/core/json.Json
Json raise @moonbitstack/moonmcp/exceptions.FastMCPError
FastMCPError

Serve call through layers in the order they were added, the first one outermost, and end in the middle. An empty list calls end directly.

refused_code

source

let refused_code : Int

The JSON-RPC code a refusal carries: -32000, the first of the range JSON-RPC leaves to the server for errors of its own.

Source Files

Install

Download zip

Model Context Protocol servers and clients for MoonBit.

mcpmodel-context-protocolllmagentaiai-agenttoolstool-callingpromptsresourceselicitationserverclientjson-rpcjsonrpcstdiostreamable-httpsseoauthasgiannotationsfastmcpprovidertransformmiddlewarecachingrate-limitingtelemetryobservabilitymoonbit

moonbitstack

Apache-2.0

github.com/moonbitstack/moonmcp

Updated 8 hours ago

126 downloads

Site source Report issue Modules Skills CLI Build queue Statistics

#Bucket

#Caching

#Caching::clear

#Caching::hits

#Caching::layer

#Caching::misses

#Caching::new

#Caching::size

#Call

#Call::fingerprint

#Call::new

#Call::subject

#Entry

#Layer

#Layer::new

#Layer::serve

#Next

#Next::then

#Operation

#Operation::code

#Operation::equal

#Operation::is_list

#Operation::not_equal

#Operation::to_repr

#RateLimiting

#RateLimiting::callers

#RateLimiting::layer

#RateLimiting::new

#RateLimiting::refused

#RateLimiting::reset

#Span

#Span::to_repr

#Telemetry

#Telemetry::clear

#Telemetry::count

#Telemetry::failures

#Telemetry::layer

#Telemetry::new

#Telemetry::spans

#Telemetry::total

#chain

#refused_code

Source Files

Bucket

Caching

Caching::clear

Caching::hits

Caching::layer

Caching::misses

Caching::new

Caching::size

Call

Call::fingerprint

Call::new

Call::subject

Entry

Layer

Layer::new

Layer::serve

Next

Next::then

Operation

Operation::code

Operation::equal

Operation::is_list

Operation::not_equal

Operation::to_repr

RateLimiting

RateLimiting::callers

RateLimiting::layer

RateLimiting::new

RateLimiting::refused

RateLimiting::reset

Span

Span::to_repr

Telemetry

Telemetry::clear

Telemetry::count

Telemetry::failures

Telemetry::layer

Telemetry::new

Telemetry::spans

Telemetry::total

chain

refused_code