🥮 mooncakes.io
    Sign in

    colmugx/mcp/client does not have a README file

    CallToolResult

    source
    using @colmugx/mcp/protocol/types { type ToolResult as CallToolResult }

    CompleteRequestParams

    source

    CompletionArgument

    source

    CompletionContext

    source

    CompletionReference

    source

    CompletionResult

    source

    Complete wire result, including open completion fields and result metadata.

    DiscoverResult

    source

    Full discovery result, including cache hints and server identity metadata.

    ClientBackend

    source
    pub enum ClientBackend {
      Modern
      Legacy(
    LegacyClient    )
    }

    Backend selected after era probing. Modern clients speak the stateless 2026-07-28 protocol; Legacy clients wrap the 2025-11-25 session client.

    ListPromptsResult

    source

    ListPromptsResult::equal

    source

    ListPromptsResult::not_equal

    source
    fn ListPromptsResult::not_equal(x : ListPromptsResult, y : ListPromptsResult) -> Bool

    ListPromptsResult::to_repr

    source

    ListResourceTemplatesResult

    source
    pub(all) struct ListResourceTemplatesResult {
      resource_templates : Array[ResourceTemplate]
      next_cursor : String?
      metadata : 
    ResultMetadata
    } derive(Eq, 
    Debug    )

    ListResourceTemplatesResult::equal

    source

    ListResourceTemplatesResult::not_equal

    source

    ListResourceTemplatesResult::to_repr

    source

    ListResourcesResult

    source

    ListResourcesResult::equal

    source

    ListResourcesResult::not_equal

    source

    ListResourcesResult::to_repr

    source

    ListToolsResult

    source

    ListToolsResult::equal

    source

    ListToolsResult::not_equal

    source
    fn ListToolsResult::not_equal(x : ListToolsResult, y : ListToolsResult) -> Bool

    ListToolsResult::to_repr

    source

    ListenFilter

    source
    pub(all) struct ListenFilter {
      tools_list_changed : Bool
      prompts_list_changed : Bool
      resources_list_changed : Bool
      resource_subscriptions : Array[String]
    } derive(Eq, 
    Debug    )

    Filter for a subscriptions/listen request. Controls which server notification channels the client wants multiplexed onto this single long-lived request.

    ListenFilter::default

    source
    fn ListenFilter::default() -> ListenFilter

    Default filter: subscribe only to list-change notifications, with no per-resource subscriptions.

    ListenFilter::equal

    source

    ListenFilter::not_equal

    source
    fn ListenFilter::not_equal(x : ListenFilter, y : ListenFilter) -> Bool

    ListenFilter::to_repr

    source

    MCPClient

    source
    pub struct MCPClient {
      client_name : String
      client_version : String
      capabilities : 
    ClientCapabilities
      transport : 
    AnyTransport
      id_counter : RequestIdCounter
      server_capabilities : 
    ServerCapabilities    ?
      server_info : 
    ServerInfo    ?
      notification_handlers : NotificationHandlers
      subscription_handlers : Map[String, (Json) -> Unit]
      sampling_handler : (Json) -> Result[
    CreateMessageResult    , 
    MCPError    ]?
      roots_handler : () -> Result[Array[
    Root    ], 
    MCPError    ]?
      elicitation_handler : (Json) -> Result[
    ElicitationResult    , 
    MCPError    ]?
      response_map : Map[String, 
    Queue    [String]]
      request_cancellations : Map[String, (String?) -> Unit]
      receive_mutex : 
    Mutex
      event_loop_started : Bool
      legacy_mode : Bool
      backend : ClientBackend
    }

    MCPClient::call_tool

    source

    MCPClient::cancel_listen

    source
    async fn MCPClient::cancel_listen(self : MCPClient, subscription_id : String) -> Result[Unit, 
    MCPError    ]

    Cancel a locally owned subscriptions/listen request. Stdio sends the cancellation notification; HTTP closes the owned subscription stream.

    MCPClient::cancel_request

    source
    async fn MCPClient::cancel_request(self : MCPClient, request_id : 
    RequestId    , reason? : String) -> Result[Unit, 
    MCPError    ]

    Cancel a locally owned request and release its caller. Stdio also sends notifications/cancelled with the original id type; HTTP cancels by closing the owned response stream, never by sending a cancellation POST. An unknown HTTP id cannot identify a stream to close.

    MCPClient::close

    source
    async fn MCPClient::close(self : MCPClient) -> Unit

    MCPClient::complete

    source
    async fn MCPClient::complete(self : MCPClient, ref_type~ : String, ref_name~ : String, argument_name~ : String, argument_value~ : String, context_arguments? : Map[String, String]) -> Result[
    CompletionResult    , 
    MCPError    ]

    MCPClient::complete_reference

    source
    async fn MCPClient::complete_reference(self : MCPClient, reference : 
    CompletionReference    , argument_name~ : String, argument_value~ : String, context_arguments? : Map[String, String]) -> Result[
    CompletionResult    , 
    MCPError    ]

    MCPClient::connect_http

    source
    async fn MCPClient::connect_http(url~ : String, name~ : String, version~ : String, auth_token? : String, extra_headers? : Array[(String, String)], era? : ProtocolEra) -> Result[MCPClient, 
    MCPError    ]

    Connect to a remote MCP server over HTTP.

    era constrains how the protocol era is negotiated:

    eraserver/discover probelegacy fallback
    Autoyes (default)allowed
    Legacyskippeddirect connect
    Modernyesforbidden (Err)

    extra_headers are appended to every request this transport issues, after the built-in headers. Same-name entries override the built-ins (including the spec-mandated MCP-Protocol-Version/Mcp-Method/Mcp-Name and the auth_token-derived Authorization — extra wins), so pass reserved headers only deliberately. The same set is applied on the legacy-era fallback path, so header-gated servers (bearer, routing, session-context) see identical headers on both protocol eras.

    MCPClient::connect_stdio

    source
    async fn MCPClient::connect_stdio(cmd~ : String, args? : Array[String], name~ : String, version~ : String, extra_env? : Map[String, String], group~ : 
    TaskGroup    [Unit], era? : ProtocolEra) -> Result[MCPClient, 
    MCPError    ]

    Connect to a local MCP server by spawning it as a child process.

    era constrains era negotiation exactly like connect_http:

    eraserver/discover probelegacy fallback
    Autoyes (default)allowed
    Legacyskippeddirect connect
    Modernyesforbidden (Err)

    MCPClient::discover

    source

    Query the server's supported versions, capabilities, and identity via server/discover (required by the 2026-07-28 spec). Stores the results in server_capabilities and server_info for later use. Optional for clients per spec, but recommended — and the primary era probe for legacy fallback.

    MCPClient::discover_result

    source

    Fetch discovery without discarding cache hints, instructions or open metadata.

    MCPClient::get_prompt

    source
    async fn MCPClient::get_prompt(self : MCPClient, name : String, arguments? : String) -> Result[
    GetPromptResult    , 
    MCPError    ]

    MCPClient::list_prompts

    source
    async fn MCPClient::list_prompts(self : MCPClient, cursor? : String) -> Result[ListPromptsResult, 
    MCPError    ]

    MCPClient::list_resource_templates

    source
    async fn MCPClient::list_resource_templates(self : MCPClient, cursor? : String) -> Result[ListResourceTemplatesResult, 
    MCPError    ]

    MCPClient::list_resources

    source
    async fn MCPClient::list_resources(self : MCPClient, cursor? : String) -> Result[ListResourcesResult, 
    MCPError    ]

    MCPClient::list_tools

    source
    async fn MCPClient::list_tools(self : MCPClient, cursor? : String) -> Result[ListToolsResult, 
    MCPError    ]

    MCPClient::listen

    source
    fn MCPClient::listen(self : MCPClient, filter? : ListenFilter, handler~ : (Json) -> Unit, group~ : 
    TaskGroup    [Unit]) -> Result[String, 
    MCPError    ]

    Start a subscriptions/listen request. Returns the subscription id string on success. The caller must already have started the event loop via run; otherwise a clear error is returned. Notifications carrying the subscription id in params._meta are routed to handler until the server closes the subscription (the final JSON-RPC response causes a background cleanup task to unregister the handler).

    MCPClient::next_request_id

    source
    fn MCPClient::next_request_id(self : MCPClient) -> Int

    MCPClient::on_elicitation

    source

    MCPClient::on_notification

    source
    fn MCPClient::on_notification(self : MCPClient, handlers : NotificationHandlers) -> MCPClient

    MCPClient::on_roots

    source

    MCPClient::on_sampling

    source

    MCPClient::read_resource

    source
    async fn MCPClient::read_resource(self : MCPClient, uri : String) -> Result[ReadResourceResult, 
    MCPError    ]

    MCPClient::run

    source
    async fn MCPClient::run(self : MCPClient, group : 
    TaskGroup    [Unit]) -> Unit

    MCPClient::set_legacy_mode

    source
    fn MCPClient::set_legacy_mode(self : MCPClient, enabled : Bool) -> MCPClient

    Enable or disable legacy mode. When enabled, the event loop accepts server-initiated requests (2025-11-25 behavior); when disabled (the default), such requests are rejected with -32601 per the 2026-07-28 spec.

    MCPClient::with_capabilities

    source

    Configure explicit capabilities after registering the corresponding handlers. Advertising input support without its handler is rejected before any request.

    MCPHost

    source
    pub struct MCPHost {
      name : String
      version : String
      connections : Map[String, MCPClient]
    }

    MCPHost::MCPHost

    source
    fn MCPHost::MCPHost(name~ : String, version~ : String) -> MCPHost

    MCPHost::call_tool

    source
    async fn MCPHost::call_tool(self : MCPHost, qualified_name : String, arguments? : String) -> Result[
    ToolResult    , 
    MCPError    ]

    MCPHost::close_all

    source
    async fn MCPHost::close_all(self : MCPHost) -> Unit

    MCPHost::connect_http

    source
    async fn MCPHost::connect_http(self : MCPHost, name~ : String, url~ : String, auth_token? : String, era? : ProtocolEra) -> Result[Unit, 
    MCPError    ]

    Register a named connection to a remote MCP server over HTTP. era is passed through to MCPClient::connect_http:

    eraserver/discover probelegacy fallback
    Autoyes (default)allowed
    Legacyskippeddirect connect
    Modernyesforbidden (Err)

    MCPHost::connect_stdio

    source
    async fn MCPHost::connect_stdio(self : MCPHost, name~ : String, cmd~ : String, args? : Array[String], extra_env? : Map[String, String], group~ : 
    TaskGroup    [Unit], era? : ProtocolEra) -> Result[Unit, 
    MCPError    ]

    Register a named connection to a spawned MCP server. era is passed through to MCPClient::connect_stdio (same semantics table as MCPHost::connect_http).

    MCPHost::list_tools

    source

    NotificationHandlers

    source
    pub(all) struct NotificationHandlers {
      on_tools_changed : () -> Unit?
      on_resources_changed : () -> Unit?
      on_prompts_changed : () -> Unit?
      on_progress : (
    ProgressNotification    ) -> Unit?
      on_cancelled : (
    CancelledNotification    ) -> Unit?
      on_resource_updated : (
    ResourceUpdatedNotification    ) -> Unit?
      on_message : (String, Json?) -> Unit?
    }

    NotificationHandlers::empty

    source

    ProtocolEra

    source
    pub(all) enum ProtocolEra {
      Auto
      Legacy
      Modern
    } derive(Eq)

    Protocol era a client should assume when connecting.

    ProtocolEra::equal

    source
    fn ProtocolEra::equal(ProtocolEra, ProtocolEra) -> Bool

    ProtocolEra::not_equal

    source
    fn ProtocolEra::not_equal(x : ProtocolEra, y : ProtocolEra) -> Bool

    ReadResourceResult

    source

    ReadResourceResult::equal

    source

    ReadResourceResult::not_equal

    source

    ReadResourceResult::to_repr

    source

    RequestIdCounter

    source
    type RequestIdCounter

    ResourceTemplate

    source
    pub(all) struct ResourceTemplate {
      uri_template : String
      name : String
      title : String?
      description : String?
      mime_type : String?
      icons : Array[
    Icon    ]?
      metadata : 
    ContentMetadata
    } derive(Eq, 
    Debug    )

    ResourceTemplate::equal

    source

    ResourceTemplate::not_equal

    source
    fn ResourceTemplate::not_equal(x : ResourceTemplate, y : ResourceTemplate) -> Bool

    ResourceTemplate::to_repr

    source

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io