#marianoguerra/mcp-server

moon add marianoguerra/mcp-server           # define a server
moon add marianoguerra/mcp-server-native    # and serve it

#Defining a server

let srv = @server.new("weather", "1.0.0")
srv
..instructions("Weather lookups. Call get_forecast before booking anything outdoors.")
..tool(
  "get_forecast",
  (args, _ctx) => @server.structured({
    "temperature": 22.5,
    "conditions": Json::string("Partly cloudy in " + args.str("city")),
  }),
  description="Get the forecast for a city",
  input_schema={
    "type": "object",
    "properties": { "city": { "type": "string" } },
    "required": ["city"],
  },
  output_schema={
    "type": "object",
    "properties": {
      "temperature": { "type": "number" },
      "conditions": { "type": "string" },
    },
    "required": ["temperature", "conditions"],
  },
)
..resource(
  "readme",
  "docs://readme",
  (_uri, _ctx) => @server.resource_text("Ask about the weather.", mime_type="text/plain"),
  description="How to use this server",
)
.prompt(
  "plan-trip",
  (args, _ctx) => @server.messages([
    @server.user_text("Plan a trip to " + args.str("city")),
  ]),
  arguments=[{ name: "city", description: Some("Destination"), required: true }],
)

#What it does for you

#The split: a pure core

pub fn Server::route(self : Self, inbound : @transport.Inbound) -> Route

pub enum Route {
  Answer(Json, status~ : Int)   // decided outright: discovery, a listing, or a rejection
  Drop                          // a notification, which MUST NOT get a reply
  Invoke(...)                   // call a handler; everything else is already decided
}

#Handlers

pub type ToolHandler     = async (Args, Ctx) -> ToolResult
pub type ResourceHandler = async (String, Ctx) -> ResourceResult
pub type PromptHandler   = async (Args, Ctx) -> PromptResult

ctx.client_info()          // who the client says it is (unverified, for display only)
ctx.has_capability("roots")
ctx.cancelled()            // on HTTP, a closed stream IS cancellation
ctx.progress(0.5, total=1.0)   // no-op unless the request sent a progressToken
ctx.log("debug", data)         // no-op unless the request opted in; a server MUST NOT
                               // emit notifications/message otherwise
ctx.params                 // the whole params object, for what sits beside `arguments`

#Transports

pub(open) trait ServerTransport {
  async fn serve(Self, async (Inbound, &Responder) -> Unit noraise) -> Unit
  fn close(Self) -> Unit
  fn describe(Self) -> String
}

#No transport at all

let caller = @transport_memory.Caller::new(build_server())

let ex = caller.call_tool("get_weather", args={ "city": "Montevideo" })
assert_eq(ex.text(), Some("It is sunny in Montevideo"))
assert_false(ex.is_error())

pub enum Outcome {
  Ok(Json)                   // a result body
  Failed(@jsonrpc.RpcError)  // the server refused, or a handler raised ProtocolFailure
  ToolFailed(Json)           // a *successful* exchange carrying isError: the tool said no
  Silent                     // a notification, or a raw handler that answered otherwise
  Suspended                  // the handler suspended; there is no scheduler here to resume it
}

ex.outcome()  ex.body()  ex.error()  ex.rpc_code()  ex.is_error()
ex.text()     ex.structured()        ex.notifications()  ex.progress()  ex.logs()
ex.status()   ex.frame()

#What this version does not do