Build a server, step by step

///|
/// Add two numbers.
#mcp.tool(description="Add two numbers")
fn add(a : Double, b : Double) -> Double {
  a + b
}

///|
/// Greet someone, in Chinese when asked. An optional parameter is left out of
/// the schema's `required`, and a missing one arrives as `None`.
#mcp.tool(description="Greet someone, in Chinese when asked")
fn greet(name : String, language? : String) -> String {
  match language {
    Some("zh") => "你好，" + name
    _ => "hello, " + name
  }
}

///|
/// Two tools, each one call on the server.
pub fn add_tools(mcp : @moonmcp.Server) -> Unit {
  mcp.tool(
    "add",
    args => {
      guard args.get("a") is Some(Number(a, ..)) &&
        args.get("b") is Some(Number(b, ..)) else {
        raise @exceptions.Tool("a and b must be numbers")
      }
      Json(a + b)
    },
    description="Add two numbers",
    input_schema={
      "type": "object",
      "properties": { "a": { "type": "number" }, "b": { "type": "number" } },
      "required": ["a", "b"],
    },
  )
  mcp.tool(
    "greet",
    args => {
      let name = match args.get("name") {
        Some(String(name)) => name
        _ => "stranger"
      }
      let language = match args.get("language") {
        Some(String(language)) => language
        _ => ""
      }
      if language == "zh" {
        Json("你好，" + name)
      } else {
        Json("hello, " + name)
      }
    },
    description="Greet someone, in Chinese when asked",
    input_schema={
      "type": "object",
      "properties": {
        "name": { "type": "string" },
        "language": { "type": "string" },
      },
      "required": ["name"],
    },
  )
}

///|
/// The arithmetic tools, and how many times they were used.
pub struct Arithmetic {
  priv mut calls : Int32
}

///|
/// A set of arithmetic tools that has not been used yet.
pub fn Arithmetic::new() -> Arithmetic {
  { calls: 0, }
}

///|
/// How many calls the tools have answered.
pub fn Arithmetic::calls(self : Arithmetic) -> Int32 {
  self.calls
}

///|
fn Arithmetic::add(
  self : Arithmetic,
  a : Double,
  b : Double,
) -> @tools.ToolResult raise @exceptions.FastMCPError {
  self.calls = self.calls + 1
  @tools.ToolResult::new(content=[@types.text_block("\{a + b}")])
}

///|
fn Arithmetic::greet(
  self : Arithmetic,
  name : String,
  language : String,
) -> @tools.ToolResult raise @exceptions.FastMCPError {
  self.calls = self.calls + 1
  let greeting = if language == "zh" {
    "你好，" + name
  } else {
    "hello, " + name
  }
  @tools.ToolResult::new(content=[@types.text_block(greeting)])
}

///|
impl @providers.Provider for Arithmetic with fn tools(self) {
  [
    @tools.Tool::new(
      "add",
      parameters={
        "type": "object",
        "properties": { "a": { "type": "number" }, "b": { "type": "number" } },
        "required": ["a", "b"],
      },
      run_fn=args => {
        let a = match args.get("a") {
          Some(Number(value, ..)) => value
          _ => 0.0
        }
        let b = match args.get("b") {
          Some(Number(value, ..)) => value
          _ => 0.0
        }
        self.add(a, b)
      },
    ) catch {
      e => abort("add: \{e}")
    },
    @tools.Tool::new(
      "greet",
      parameters={
        "type": "object",
        "properties": {
          "name": { "type": "string" },
          "language": { "type": "string" },
        },
        "required": ["name"],
      },
      run_fn=args => {
        let name = match args.get("name") {
          Some(String(name)) => name
          _ => "stranger"
        }
        let language = match args.get("language") {
          Some(String(language)) => language
          _ => ""
        }
        self.greet(name, language)
      },
    ) catch {
      e => abort("greet: \{e}")
    },
  ]
}

///|
/// The application's settings. A resource that answers something other than
/// text is sent as JSON.
#mcp.resource("config://app", description="The application settings")
fn config() -> Json {
  { "theme": "dark", "language": "en" }
}

///|
/// A profile per user: `{id}` makes a template, and the value it matched is
/// read as an `Int`.
#mcp.resource("users://{id}/profile")
fn profile(id : Int32) -> String {
  "profile of user \{id}"
}

///|
/// A resource at a fixed URI, and a template for the ones with an id in them.
pub fn add_resources(mcp : @moonmcp.Server) -> Unit {
  mcp.resource(
    "config://app",
    () => "{\"theme\":\"dark\",\"language\":\"en\"}",
    description="The application settings",
    mime_type="application/json",
  )
  mcp.template("users://{id}/profile", params => {
    let id = match params.get("id") {
      Some(String(id)) => id
      _ => "?"
    }
    "profile of user " + id
  })
}

///|
/// The application's settings, and one resource per user.
pub struct Catalog {}

///|
fn Catalog::settings(self : Catalog) -> String {
  let _ = self
  "{\"theme\":\"dark\",\"language\":\"en\"}"
}

///|
fn Catalog::profile(self : Catalog, id : String) -> String {
  let _ = self
  "profile of user " + id
}

///|
impl @providers.Provider for Catalog with fn resources(self) {
  [
    @resources.Resource::new(
      "config://app",
      read_fn=() => Text(self.settings()),
      description="The application settings",
      mime_type="application/json",
    ),
  ]
}

///|
impl @providers.Provider for Catalog with fn templates(self) {
  [
    @resources.ResourceTemplate::new(
      "users://{id}/profile",
      parameters={
        "type": "object",
        "properties": { "id": { "type": "string" } },
      },
      read_fn=params => {
        let id = match params.get("id") {
          Some(String(id)) => id
          _ => "?"
        }
        Text(self.profile(id))
      },
    ) catch {
      e => abort("users://{id}/profile: \{e}")
    },
  ]
}

///|
/// Ask for a code review. The parameters become the prompt's arguments.
#mcp.prompt(description="Ask for a code review")
fn review(code : String, focus? : String) -> String {
  let what = match focus {
    Some(focus) => " Focus on \{focus}."
    None => ""
  }
  "Review this code.\{what}\n\n\{code}"
}

///|
/// A prompt whose arguments a client fills in.
pub fn add_review(mcp : @moonmcp.Server) -> Unit {
  mcp.prompt(
    "review",
    args => {
      let code = match args.get("code") {
        Some(String(code)) => code
        _ => ""
      }
      let what = match args.get("focus") {
        Some(String(focus)) => " Focus on " + focus + "."
        _ => ""
      }
      "Review this code." + what + "\n\n" + code
    },
    description="Ask for a code review",
    arguments=[
      { name: "code", title: None, description: None, required: Some(true), },
      { name: "focus", title: None, description: None, required: Some(false), },
    ],
  )
}

///|
/// The reviewer: one method, one prompt.
pub struct Reviewer {}

///|
fn Reviewer::review(self : Reviewer, code : String, focus : String) -> String {
  let _ = self
  let what = if focus.is_empty() { "" } else { " Focus on " + focus + "." }
  "Review this code." + what + "\n\n" + code
}

///|
impl @providers.Provider for Reviewer with fn prompts(self) {
  [
    @prompts.Prompt::new(
      "review",
      render_fn=args => {
        let code = match args.get("code") {
          Some(String(code)) => code
          _ => ""
        }
        let focus = match args.get("focus") {
          Some(String(focus)) => focus
          _ => ""
        }
        Text(self.review(code, focus))
      },
      description="Ask for a code review",
      arguments=[
        { name: "code", title: None, description: None, required: Some(true), },
        {
          name: "focus",
          title: None,
          description: None,
          required: Some(false),
        },
      ],
    ),
  ]
}

///|
/// A tool that sees the request it serves, and reports on it while it works.
pub fn add_counter(mcp : @moonmcp.Server) -> Unit {
  mcp.tool_context(
    "count",
    async fn(args : Map[String, Json], context : @context.Context) {
      let up_to = match args.get("up_to") {
        Some(Number(value, ..)) => value.to_int()
        _ => 3
      }
      if up_to < 0 {
        raise @exceptions.Tool("up_to must not be negative")
      }
      for step in 0..<up_to {
        context.report_progress(
          progress=(step + 1).to_double(),
          total=up_to.to_double(),
          message="step \{step + 1}",
        ) catch {
          _ => ()
        }
      }
      @tools.ToolResult::new(content=[@types.text_block("counted to \{up_to}")])
    },
    description="Count to a number, reporting progress as it goes",
    input_schema={
      "type": "object",
      "properties": { "up_to": { "type": "number" } },
    },
  )
}

///|
/// A counter that reports how far it has got, through the request it serves.
pub struct Counter {}

///|
impl @providers.Provider for Counter with fn tools(self) {
  [
    @tools.Tool::new(
      "count",
      parameters={
        "type": "object",
        "properties": { "up_to": { "type": "number" } },
      },
      run_fn=_ => {
        let _ = self
        abort("count is served with its request, through context_run_fn")
      },
      description="Count to a number, reporting progress as it goes",
      context_run_fn=async fn(
        args,
        context,
      ) -> @tools.ToolResult raise @exceptions.FastMCPError {
        let up_to = match args.get("up_to") {
          Some(Number(value, ..)) => value.to_int()
          _ => 3
        }
        if up_to < 0 {
          raise @exceptions.Tool("up_to must not be negative")
        }
        for step in 0..<up_to {
          context.report_progress(
            progress=(step + 1).to_double(),
            total=up_to.to_double(),
            message="step \{step + 1}",
          ) catch {
            _ => ()
          }
        }
        @tools.ToolResult::new(content=[
          @types.text_block("counted to \{up_to}"),
        ])
      },
    ) catch {
      e => abort("count: \{e}")
    },
  ]
}

///|
/// Hold a capability back from the listing, and put a cache in front of every
/// request.
pub fn with_extensions(mcp : @moonmcp.Server) -> @moonmcp.Server {
  mcp.add_transform(@transforms.Hidden::new(names=["greet"]))
  mcp.use_layer(@layers.Caching::new(ttl_ms=1_000).layer())
  mcp
}

///|
/// A filter is a contract, so holding the greeting back is a type of its own.
pub struct Quiet {}

///|
impl @transforms.Transform for Quiet with fn tools(self, tools) {
  let _ = self
  tools.filter(tool => tool.component.name != "greet")
}

///|
/// Hold a capability back from the listing, and put a cache in front of every
/// request.
pub fn with_extensions(mcp : @moonmcp.Server) -> @moonmcp.Server {
  mcp.add_transform(Quiet::{ })
  mcp.use_layer(@layers.Caching::new(ttl_ms=1_000).layer())
  mcp
}