moonbitstack/moonmcp/types

Annotations

pub(all) struct Annotations {
  audience : Array[String]?
  priority : Double?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Audience and priority hints attached to content.

impl FromJson for Annotations

impl ToJson for Annotations

Annotations::equal

source

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

Annotations::from_json

source

fn Annotations::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> Annotations raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

Annotations::not_equal

source

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

Annotations::to_json

source

fn Annotations::to_json(self : Annotations) -> @moonbitlang/core/json.Json
Json

Annotations::to_repr

source

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

CacheScope

source

pub(all) enum CacheScope {
  Public
  Private
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

The scope of a cacheable result, the cacheScope a list or a read carries: who may keep the reply. Public says it holds nothing tied to one caller; Private says a cache must belong to the authorisation context it was fetched in.

CacheScope::equal

source

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

CacheScope::not_equal

source

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

CacheScope::to_repr

source

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

CacheScope::to_wire

source

fn CacheScope::to_wire(self : CacheScope) -> String

CallToolRequestParams

source

pub(all) struct CallToolRequestParams {
  name : String
  arguments : Map[String, @moonbitlang/core/json.Json
Json]?
  meta : Map[String, @moonbitlang/core/json.Json
Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

tools/call request parameters.

impl FromJson for CallToolRequestParams

impl ToJson for CallToolRequestParams

CallToolRequestParams::equal

source

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

CallToolRequestParams::from_json

source

fn CallToolRequestParams::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> CallToolRequestParams raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

CallToolRequestParams::not_equal

source

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

CallToolRequestParams::progress_token

source

fn CallToolRequestParams::progress_token(self : CallToolRequestParams) -> String?

CallToolRequestParams::to_json

source

fn CallToolRequestParams::to_json(self : CallToolRequestParams) -> @moonbitlang/core/json.Json
Json

CallToolRequestParams::to_repr

source

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

CallToolResult

source

pub(all) struct CallToolResult {
  content : Array[ContentBlock]
  structured_content : Map[String, @moonbitlang/core/json.Json
Json]?
  is_error : Bool
  meta : Map[String, @moonbitlang/core/json.Json
Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

The result of a tools/call call.

impl FromJson for CallToolResult

impl ToJson for CallToolResult

CallToolResult::equal

source

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

CallToolResult::error

source

fn CallToolResult::error(message : String) -> CallToolResult

CallToolResult::from_json

source

fn CallToolResult::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> CallToolResult raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

CallToolResult::new

source

fn CallToolResult::new(content : Array[ContentBlock]) -> CallToolResult

CallToolResult::not_equal

source

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

CallToolResult::to_json

source

fn CallToolResult::to_json(self : CallToolResult) -> @moonbitlang/core/json.Json
Json

CallToolResult::to_repr

source

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

CancelledNotificationParams

source

pub(all) struct CancelledNotificationParams {
  request_id : RequestId
  reason : String?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

A cancelled request, sent by the side that issued it.

impl FromJson for CancelledNotificationParams

impl ToJson for CancelledNotificationParams

CancelledNotificationParams::equal

source

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

CancelledNotificationParams::from_json

source

fn CancelledNotificationParams::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> CancelledNotificationParams raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

CancelledNotificationParams::not_equal

source

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

CancelledNotificationParams::to_json

source

fn CancelledNotificationParams::to_json(self : CancelledNotificationParams) -> @moonbitlang/core/json.Json
Json

CancelledNotificationParams::to_repr

source

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

ClientCapabilities

source

pub(all) struct ClientCapabilities {
  experimental : Map[String, @moonbitlang/core/json.Json
Json]?
  extensions : Map[String, @moonbitlang/core/json.Json
Json]?
  roots_list_changed : Bool?
  sampling : Bool?
  elicitation : Bool?
  tasks : Bool?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

What a client supports.

impl FromJson for ClientCapabilities

impl ToJson for ClientCapabilities

ClientCapabilities::equal

source

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

ClientCapabilities::from_json

source

fn ClientCapabilities::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> ClientCapabilities raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ClientCapabilities::new

source

fn ClientCapabilities::new() -> ClientCapabilities

A client that asks for nothing beyond the core protocol.

ClientCapabilities::not_equal

source

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

ClientCapabilities::to_json

source

fn ClientCapabilities::to_json(self : ClientCapabilities) -> @moonbitlang/core/json.Json
Json

ClientCapabilities::to_repr

source

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

ClientRequest

source

pub(all) enum ClientRequest {
  Initialize(InitializeRequestParams)
  Ping(meta~ : Map[String, @moonbitlang/core/json.Json
Json]?)
  ListTools(PaginatedRequestParams)
  CallTool(CallToolRequestParams)
  ListResources(PaginatedRequestParams)
  ReadResource(ReadResourceRequestParams)
  Subscribe(SubscribeRequestParams)
  Unsubscribe(SubscribeRequestParams)
  ListPrompts(PaginatedRequestParams)
  GetPrompt(GetPromptRequestParams)
  Complete(CompleteRequestParams)
  SetLevel(SetLevelRequestParams)
  InputResponse(InputResponseRequestParams)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

A typed request a client can send to a server.

impl FromJson for ClientRequest

ClientRequest::equal

source

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

ClientRequest::from_json

source

fn ClientRequest::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> ClientRequest raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ClientRequest::not_equal

source

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

ClientRequest::to_repr

source

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

ClientRequest::verb

source

fn ClientRequest::verb(self : ClientRequest) -> String

The method name a typed request will be sent under.

CompleteRequestParams

source

pub(all) struct CompleteRequestParams {
  context : CompletionContext
  meta : Map[String, @moonbitlang/core/json.Json
Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

completion/complete request parameters.

impl FromJson for CompleteRequestParams

impl ToJson for CompleteRequestParams

CompleteRequestParams::equal

source

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

CompleteRequestParams::from_json

source

fn CompleteRequestParams::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> CompleteRequestParams raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

CompleteRequestParams::not_equal

source

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

CompleteRequestParams::to_json

source

fn CompleteRequestParams::to_json(self : CompleteRequestParams) -> @moonbitlang/core/json.Json
Json

CompleteRequestParams::to_repr

source

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

CompleteResult

source

pub(all) struct CompleteResult {
  completion : Completion
  meta : Map[String, @moonbitlang/core/json.Json
Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

The result of a completion/complete call.

impl FromJson for CompleteResult

impl ToJson for CompleteResult

CompleteResult::equal

source

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

CompleteResult::from_json

source

fn CompleteResult::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> CompleteResult raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

CompleteResult::not_equal

source

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

CompleteResult::to_json

source

fn CompleteResult::to_json(self : CompleteResult) -> @moonbitlang/core/json.Json
Json

CompleteResult::to_repr

source

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

Completion

source

pub(all) struct Completion {
  values : Array[String]
  total : Int?
  has_more : Bool?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Completion values returned by completion/complete.

impl FromJson for Completion

impl ToJson for Completion

Completion::equal

source

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

Completion::from_json

source

fn Completion::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> Completion raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

Completion::not_equal

source

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

Completion::to_json

source

fn Completion::to_json(self : Completion) -> @moonbitlang/core/json.Json
Json

Completion::to_repr

source

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

CompletionArgument

source

pub(all) struct CompletionArgument {
  name : String
  value : String
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

One argument offered for completion: which argument it is, and the value to complete.

impl FromJson for CompletionArgument

impl ToJson for CompletionArgument

CompletionArgument::equal

source

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

CompletionArgument::from_json

source

fn CompletionArgument::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> CompletionArgument raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

CompletionArgument::not_equal

source

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

CompletionArgument::to_json

source

fn CompletionArgument::to_json(self : CompletionArgument) -> @moonbitlang/core/json.Json
Json

CompletionArgument::to_repr

source

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

CompletionContext

source

pub(all) struct CompletionContext {
  reference : Reference
  argument : CompletionArgument
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

What the completion request is about: the argument being completed and the text around it.

impl FromJson for CompletionContext

impl ToJson for CompletionContext

CompletionContext::equal

source

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

CompletionContext::from_json

source

fn CompletionContext::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> CompletionContext raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

CompletionContext::not_equal

source

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

CompletionContext::to_json

source

fn CompletionContext::to_json(self : CompletionContext) -> @moonbitlang/core/json.Json
Json

CompletionContext::to_repr

source

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

ContentBlock

source

pub(all) enum ContentBlock {
  Text(text~ : String, annotations~ : Annotations?, meta~ : Map[String, @moonbitlang/core/json.Json
Json]?)
  Image(data~ : String, mime_type~ : String, annotations~ : Annotations?, meta~ : Map[String, @moonbitlang/core/json.Json
Json]?)
  Audio(data~ : String, mime_type~ : String, annotations~ : Annotations?, meta~ : Map[String, @moonbitlang/core/json.Json
Json]?)
  ResourceLink(uri~ : String, name~ : String, title~ : String?, description~ : String?, mime_type~ : String?, size~ : Int?, annotations~ : Annotations?, meta~ : Map[String, @moonbitlang/core/json.Json
Json]?)
  EmbeddedResource(resource~ : ResourceContents, annotations~ : Annotations?, meta~ : Map[String, @moonbitlang/core/json.Json
Json]?)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

A block of content in a tool result, sampling message or prompt message.

impl FromJson for ContentBlock

impl ToJson for ContentBlock

ContentBlock::equal

source

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

ContentBlock::from_json

source

fn ContentBlock::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> ContentBlock raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ContentBlock::not_equal

source

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

ContentBlock::to_json

source

fn ContentBlock::to_json(self : ContentBlock) -> @moonbitlang/core/json.Json
Json

ContentBlock::to_repr

source

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

CreateMessageRequestParams

source

pub(all) struct CreateMessageRequestParams {
  messages : Array[SamplingMessage]
  system_message : String?
  include_context : String?
  max_tokens : Int
  temperature : Double?
  stop_sequences : Array[String]?
  model_preferences : ModelPreferences?
  meta : Map[String, @moonbitlang/core/json.Json
Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

sampling/createMessage request parameters.

impl FromJson for CreateMessageRequestParams

impl ToJson for CreateMessageRequestParams

CreateMessageRequestParams::equal

source

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

CreateMessageRequestParams::from_json

source

fn CreateMessageRequestParams::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> CreateMessageRequestParams raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

CreateMessageRequestParams::not_equal

source

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

CreateMessageRequestParams::to_json

source

fn CreateMessageRequestParams::to_json(self : CreateMessageRequestParams) -> @moonbitlang/core/json.Json
Json

CreateMessageRequestParams::to_repr

source

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

CreateMessageResult

source

pub(all) struct CreateMessageResult {
  model : String
  stop_reason : String?
  role : Role
  content : ContentBlock
  meta : Map[String, @moonbitlang/core/json.Json
Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

The result of a sampling/createMessage call.

impl FromJson for CreateMessageResult

impl ToJson for CreateMessageResult

CreateMessageResult::equal

source

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

CreateMessageResult::from_json

source

fn CreateMessageResult::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> CreateMessageResult raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

CreateMessageResult::not_equal

source

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

CreateMessageResult::to_json

source

fn CreateMessageResult::to_json(self : CreateMessageResult) -> @moonbitlang/core/json.Json
Json

CreateMessageResult::to_repr

source

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

CreateTaskResult

source

pub(all) struct CreateTaskResult {
  task : @moonbitlang/core/json.Json
Json
  meta : Map[String, @moonbitlang/core/json.Json
Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

A task handle minted for task-augmented execution (SEP-2663).

impl FromJson for CreateTaskResult

impl ToJson for CreateTaskResult

CreateTaskResult::equal

source

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

CreateTaskResult::from_json

source

fn CreateTaskResult::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> CreateTaskResult raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

CreateTaskResult::not_equal

source

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

CreateTaskResult::to_json

source

fn CreateTaskResult::to_json(self : CreateTaskResult) -> @moonbitlang/core/json.Json
Json

CreateTaskResult::to_repr

source

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

DiscoverResult

source

pub(all) struct DiscoverResult {
  result_type : String
  result : @moonbitlang/core/json.Json
Json
  ttl_ms : Int?
  cache_scope : CacheScope?
  meta : Map[String, @moonbitlang/core/json.Json
Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

A discovery reply wrapping any core result, tagged with its type.

impl FromJson for DiscoverResult

impl ToJson for DiscoverResult

DiscoverResult::equal

source

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

DiscoverResult::from_json

source

fn DiscoverResult::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> DiscoverResult raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

DiscoverResult::not_equal

source

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

DiscoverResult::to_json

source

fn DiscoverResult::to_json(self : DiscoverResult) -> @moonbitlang/core/json.Json
Json

DiscoverResult::to_repr

source

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

ElicitRequestParams

source

pub(all) struct ElicitRequestParams {
  message : String
  requested_schema : Map[String, @moonbitlang/core/json.Json
Json]?
  url : String?
  meta : Map[String, @moonbitlang/core/json.Json
Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

elicitation/create request parameters, covering both the form- and URL-based variants.

impl FromJson for ElicitRequestParams

impl ToJson for ElicitRequestParams

ElicitRequestParams::equal

source

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

ElicitRequestParams::from_json

source

fn ElicitRequestParams::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> ElicitRequestParams raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ElicitRequestParams::not_equal

source

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

ElicitRequestParams::to_json

source

fn ElicitRequestParams::to_json(self : ElicitRequestParams) -> @moonbitlang/core/json.Json
Json

ElicitRequestParams::to_repr

source

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

ElicitResult

source

pub(all) struct ElicitResult {
  action : String
  content : Map[String, @moonbitlang/core/json.Json
Json]?
  meta : Map[String, @moonbitlang/core/json.Json
Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

The result of an elicitation round trip.

impl FromJson for ElicitResult

impl ToJson for ElicitResult

ElicitResult::accept

source

fn ElicitResult::accept(content : Map[String, @moonbitlang/core/json.Json
Json]) -> ElicitResult

ElicitResult::cancel

source

fn ElicitResult::cancel() -> ElicitResult

ElicitResult::decline

source

fn ElicitResult::decline() -> ElicitResult

ElicitResult::equal

source

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

ElicitResult::from_json

source

fn ElicitResult::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> ElicitResult raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ElicitResult::not_equal

source

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

ElicitResult::to_json

source

fn ElicitResult::to_json(self : ElicitResult) -> @moonbitlang/core/json.Json
Json

ElicitResult::to_repr

source

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

EmptyResult

source

pub(all) struct EmptyResult {
  meta : Map[String, @moonbitlang/core/json.Json
Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

A bare result with no payload.

impl FromJson for EmptyResult

impl ToJson for EmptyResult

EmptyResult::equal

source

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

EmptyResult::from_json

source

fn EmptyResult::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> EmptyResult raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

EmptyResult::not_equal

source

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

EmptyResult::to_json

source

fn EmptyResult::to_json(self : EmptyResult) -> @moonbitlang/core/json.Json
Json

EmptyResult::to_repr

source

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

ErrorData

source

pub(all) struct ErrorData {
  code : Int
  message : String
  data : @moonbitlang/core/json.Json
Json?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

Wire-format error payload carried by JSON-RPC error responses.

ErrorData::equal

source

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

ErrorData::from_json

source

fn ErrorData::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> ErrorData raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ErrorData::not_equal

source

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

ErrorData::to_json

source

fn ErrorData::to_json(ErrorData) -> @moonbitlang/core/json.Json
Json

ErrorData::to_repr

source

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

GetPromptRequestParams

source

pub(all) struct GetPromptRequestParams {
  name : String
  arguments : Map[String, @moonbitlang/core/json.Json
Json]?
  meta : Map[String, @moonbitlang/core/json.Json
Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

prompts/get request parameters.

impl FromJson for GetPromptRequestParams

impl ToJson for GetPromptRequestParams

GetPromptRequestParams::equal

source

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

GetPromptRequestParams::from_json

source

fn GetPromptRequestParams::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> GetPromptRequestParams raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

GetPromptRequestParams::not_equal

source

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

GetPromptRequestParams::to_json

source

fn GetPromptRequestParams::to_json(self : GetPromptRequestParams) -> @moonbitlang/core/json.Json
Json

GetPromptRequestParams::to_repr

source

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

GetPromptResult

source

pub(all) struct GetPromptResult {
  description : String?
  messages : Array[PromptMessage]
  meta : Map[String, @moonbitlang/core/json.Json
Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

The result of a prompts/get call.

impl FromJson for GetPromptResult

impl ToJson for GetPromptResult

GetPromptResult::equal

source

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

GetPromptResult::from_json

source

fn GetPromptResult::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> GetPromptResult raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

GetPromptResult::not_equal

source

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

GetPromptResult::to_json

source

fn GetPromptResult::to_json(self : GetPromptResult) -> @moonbitlang/core/json.Json
Json

GetPromptResult::to_repr

source

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

Icon

source

pub(all) struct Icon {
  src : String
  mime_type : String?
  sizes : Array[String]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

An icon for display in user interfaces.

impl FromJson for Icon

impl ToJson for Icon

Icon::equal

source

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

Icon::from_json

source

fn Icon::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> Icon raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

Icon::not_equal

source

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

Icon::to_json

source

fn Icon::to_json(self : Icon) -> @moonbitlang/core/json.Json
Json

Icon::to_repr

source

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

Implementation

source

pub(all) struct Implementation {
  name : String
  title : String?
  version : String
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

The name and version of an MCP implementation.

impl FromJson for Implementation

impl ToJson for Implementation

Implementation::equal

source

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

Implementation::from_json

source

fn Implementation::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> Implementation raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

Implementation::not_equal

source

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

Implementation::to_json

source

fn Implementation::to_json(self : Implementation) -> @moonbitlang/core/json.Json
Json

Implementation::to_repr

source

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

InitializeRequestParams

source

pub(all) struct InitializeRequestParams {
  protocol_version : String
  capabilities : ClientCapabilities
  client_info : Implementation
  meta : Map[String, @moonbitlang/core/json.Json
Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

initialize request parameters.

impl FromJson for InitializeRequestParams

impl ToJson for InitializeRequestParams

InitializeRequestParams::equal

source

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

InitializeRequestParams::from_json

source

fn InitializeRequestParams::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> InitializeRequestParams raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

InitializeRequestParams::not_equal

source

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

InitializeRequestParams::to_json

source

fn InitializeRequestParams::to_json(self : InitializeRequestParams) -> @moonbitlang/core/json.Json
Json

InitializeRequestParams::to_repr

source

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

InitializeResult

source

pub(all) struct InitializeResult {
  protocol_version : String
  capabilities : ServerCapabilities
  server_info : Implementation
  instructions : String?
  meta : Map[String, @moonbitlang/core/json.Json
Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

initialize result: capabilities and server description.

impl FromJson for InitializeResult

impl ToJson for InitializeResult

InitializeResult::equal

source

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

InitializeResult::from_json

source

fn InitializeResult::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> InitializeResult raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

InitializeResult::not_equal

source

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

InitializeResult::to_json

source

fn InitializeResult::to_json(self : InitializeResult) -> @moonbitlang/core/json.Json
Json

InitializeResult::to_repr

source

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

InputRequest

source

pub(all) struct InputRequest {
  id : String
  request : @moonbitlang/core/json.Json
Json
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

One guard-channel request a client must answer (SEP-2322).

impl FromJson for InputRequest

impl ToJson for InputRequest

InputRequest::equal

source

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

InputRequest::from_json

source

fn InputRequest::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> InputRequest raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

InputRequest::not_equal

source

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

InputRequest::to_json

source

fn InputRequest::to_json(self : InputRequest) -> @moonbitlang/core/json.Json
Json

InputRequest::to_repr

source

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

InputRequiredResult

source

pub(all) struct InputRequiredResult {
  input_requests : Array[InputRequest]
  request_state : String?
  meta : Map[String, @moonbitlang/core/json.Json
Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Tells the client to answer the carried requests and re-issue the call.

impl FromJson for InputRequiredResult

impl ToJson for InputRequiredResult

InputRequiredResult::equal

source

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

InputRequiredResult::from_json

source

fn InputRequiredResult::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> InputRequiredResult raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

InputRequiredResult::not_equal

source

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

InputRequiredResult::to_json

source

fn InputRequiredResult::to_json(self : InputRequiredResult) -> @moonbitlang/core/json.Json
Json

InputRequiredResult::to_repr

source

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

InputResponse

source

pub(all) struct InputResponse {
  request_id : String
  action : String
  content : Map[String, @moonbitlang/core/json.Json
Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

A client answer to a guard-channel input request (SEP-2322).

impl FromJson for InputResponse

impl ToJson for InputResponse

InputResponse::equal

source

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

InputResponse::from_json

source

fn InputResponse::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> InputResponse raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

InputResponse::not_equal

source

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

InputResponse::to_json

source

fn InputResponse::to_json(self : InputResponse) -> @moonbitlang/core/json.Json
Json

InputResponse::to_repr

source

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

InputResponseRequestParams

source

pub(all) struct InputResponseRequestParams {
  input_responses : Map[String, @moonbitlang/core/json.Json
Json]
  request_state : String?
  meta : Map[String, @moonbitlang/core/json.Json
Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

input/response request parameters: answers keyed by request id.

impl FromJson for InputResponseRequestParams

impl ToJson for InputResponseRequestParams

InputResponseRequestParams::equal

source

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

InputResponseRequestParams::from_json

source

fn InputResponseRequestParams::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> InputResponseRequestParams raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

InputResponseRequestParams::not_equal

source

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

InputResponseRequestParams::to_json

source

fn InputResponseRequestParams::to_json(self : InputResponseRequestParams) -> @moonbitlang/core/json.Json
Json

InputResponseRequestParams::to_repr

source

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

JSONRPCMessage

source

pub(all) enum JSONRPCMessage {
  Request(id~ : RequestId, verb~ : String, params~ : @moonbitlang/core/json.Json
Json?)
  Notification(verb~ : String, params~ : @moonbitlang/core/json.Json
Json?)
  Response(id~ : RequestId, result~ : @moonbitlang/core/json.Json
Json)
  Error(id~ : RequestId, error~ : ErrorData)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Any message frame on the wire.

impl FromJson for JSONRPCMessage

impl ToJson for JSONRPCMessage

JSONRPCMessage::equal

source

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

JSONRPCMessage::from_json

source

fn JSONRPCMessage::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> JSONRPCMessage raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

JSONRPCMessage::not_equal

source

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

JSONRPCMessage::to_json

source

fn JSONRPCMessage::to_json(self : JSONRPCMessage) -> @moonbitlang/core/json.Json
Json

JSONRPCMessage::to_repr

source

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

ListPromptsResult

source

pub(all) struct ListPromptsResult {
  prompts : Array[Prompt]
  next_cursor : String?
  ttl_ms : Int?
  cache_scope : CacheScope?
  meta : Map[String, @moonbitlang/core/json.Json
Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

The result of a prompts/list call.

impl FromJson for ListPromptsResult

impl ToJson for ListPromptsResult

ListPromptsResult::equal

source

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

ListPromptsResult::from_json

source

fn ListPromptsResult::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> ListPromptsResult raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ListPromptsResult::not_equal

source

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

ListPromptsResult::to_json

source

fn ListPromptsResult::to_json(self : ListPromptsResult) -> @moonbitlang/core/json.Json
Json

ListPromptsResult::to_repr

source

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

ListResourceTemplatesResult

source

pub(all) struct ListResourceTemplatesResult {
  resource_templates : Array[ResourceTemplate]
  next_cursor : String?
  ttl_ms : Int?
  cache_scope : CacheScope?
  meta : Map[String, @moonbitlang/core/json.Json
Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

The result of a resources/templates/list call.

impl FromJson for ListResourceTemplatesResult

impl ToJson for ListResourceTemplatesResult

ListResourceTemplatesResult::equal

source

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

ListResourceTemplatesResult::from_json

source

fn ListResourceTemplatesResult::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> ListResourceTemplatesResult raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ListResourceTemplatesResult::not_equal

source

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

ListResourceTemplatesResult::to_json

source

fn ListResourceTemplatesResult::to_json(self : ListResourceTemplatesResult) -> @moonbitlang/core/json.Json
Json

ListResourceTemplatesResult::to_repr

source

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

ListResourcesResult

source

pub(all) struct ListResourcesResult {
  resources : Array[Resource]
  next_cursor : String?
  ttl_ms : Int?
  cache_scope : CacheScope?
  meta : Map[String, @moonbitlang/core/json.Json
Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

The result of a resources/list call.

impl FromJson for ListResourcesResult

impl ToJson for ListResourcesResult

ListResourcesResult::equal

source

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

ListResourcesResult::from_json

source

fn ListResourcesResult::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> ListResourcesResult raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ListResourcesResult::not_equal

source

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

ListResourcesResult::to_json

source

fn ListResourcesResult::to_json(self : ListResourcesResult) -> @moonbitlang/core/json.Json
Json

ListResourcesResult::to_repr

source

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

ListRootsResult

source

pub(all) struct ListRootsResult {
  roots : Array[Root]
  meta : Map[String, @moonbitlang/core/json.Json
Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

The result of a roots/list call.

impl FromJson for ListRootsResult

impl ToJson for ListRootsResult

ListRootsResult::equal

source

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

ListRootsResult::from_json

source

fn ListRootsResult::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> ListRootsResult raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ListRootsResult::not_equal

source

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

ListRootsResult::to_json

source

fn ListRootsResult::to_json(self : ListRootsResult) -> @moonbitlang/core/json.Json
Json

ListRootsResult::to_repr

source

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

ListToolsResult

source

pub(all) struct ListToolsResult {
  tools : Array[Tool]
  next_cursor : String?
  ttl_ms : Int?
  cache_scope : CacheScope?
  meta : Map[String, @moonbitlang/core/json.Json
Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

The result of a tools/list call.

impl FromJson for ListToolsResult

impl ToJson for ListToolsResult

ListToolsResult::equal

source

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

ListToolsResult::from_json

source

fn ListToolsResult::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> ListToolsResult raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ListToolsResult::not_equal

source

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

ListToolsResult::to_json

source

fn ListToolsResult::to_json(self : ListToolsResult) -> @moonbitlang/core/json.Json
Json

ListToolsResult::to_repr

source

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

LoggingLevel

source

pub(all) enum LoggingLevel {
  Debug
  Info
  Notice
  Warning
  Error
  Critical
  Alert
  Emergency
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Verbosity levels for notifications/message, ordered debug → emergency.

LoggingLevel::equal

source

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

LoggingLevel::not_equal

source

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

LoggingLevel::to_repr

source

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

LoggingLevel::to_wire

source

fn LoggingLevel::to_wire(self : LoggingLevel) -> String

LoggingMessageNotificationParams

source

pub(all) struct LoggingMessageNotificationParams {
  level : LoggingLevel
  logger : String?
  data : @moonbitlang/core/json.Json
Json
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

A log entry streamed by the server.

impl FromJson for LoggingMessageNotificationParams

fn from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> LoggingMessageNotificationParams raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

source

impl ToJson for LoggingMessageNotificationParams

LoggingMessageNotificationParams::equal

source

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

LoggingMessageNotificationParams::from_json

source

fn LoggingMessageNotificationParams::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> LoggingMessageNotificationParams raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

LoggingMessageNotificationParams::not_equal

source

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

LoggingMessageNotificationParams::to_json

source

fn LoggingMessageNotificationParams::to_json(self : LoggingMessageNotificationParams) -> @moonbitlang/core/json.Json
Json

LoggingMessageNotificationParams::to_repr

source

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

ModelHint

source

pub(all) struct ModelHint {
  name : String
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Client hints steering server-side model selection.

impl FromJson for ModelHint

impl ToJson for ModelHint

ModelHint::equal

source

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

ModelHint::from_json

source

fn ModelHint::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> ModelHint raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ModelHint::not_equal

source

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

ModelHint::to_json

source

fn ModelHint::to_json(self : ModelHint) -> @moonbitlang/core/json.Json
Json

ModelHint::to_repr

source

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

ModelPreferences

source

pub(all) struct ModelPreferences {
  hints : Array[ModelHint]?
  cost_priority : Double?
  speed_priority : Double?
  intelligence_priority : Double?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

What a client prefers of a model: named hints, and the weight it gives cost and speed.

impl FromJson for ModelPreferences

impl ToJson for ModelPreferences

ModelPreferences::equal

source

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

ModelPreferences::from_json

source

fn ModelPreferences::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> ModelPreferences raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ModelPreferences::not_equal

source

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

ModelPreferences::to_json

source

fn ModelPreferences::to_json(self : ModelPreferences) -> @moonbitlang/core/json.Json
Json

ModelPreferences::to_repr

source

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

PaginatedRequestParams

source

pub(all) struct PaginatedRequestParams {
  cursor : String?
  meta : Map[String, @moonbitlang/core/json.Json
Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

List requests with cursor-based pagination.

impl FromJson for PaginatedRequestParams

impl ToJson for PaginatedRequestParams

PaginatedRequestParams::equal

source

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

PaginatedRequestParams::from_json

source

fn PaginatedRequestParams::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> PaginatedRequestParams raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

PaginatedRequestParams::not_equal

source

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

PaginatedRequestParams::progress_token

source

fn PaginatedRequestParams::progress_token(self : PaginatedRequestParams) -> String?

PaginatedRequestParams::to_json

source

fn PaginatedRequestParams::to_json(self : PaginatedRequestParams) -> @moonbitlang/core/json.Json
Json

PaginatedRequestParams::to_repr

source

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

ProgressNotificationParams

source

pub(all) struct ProgressNotificationParams {
  progress_token : String
  progress : Double
  message : String?
  total : Double?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Progress reported for an in-flight request.

impl FromJson for ProgressNotificationParams

impl ToJson for ProgressNotificationParams

ProgressNotificationParams::equal

source

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

ProgressNotificationParams::from_json

source

fn ProgressNotificationParams::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> ProgressNotificationParams raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ProgressNotificationParams::not_equal

source

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

ProgressNotificationParams::to_json

source

fn ProgressNotificationParams::to_json(self : ProgressNotificationParams) -> @moonbitlang/core/json.Json
Json

ProgressNotificationParams::to_repr

source

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

Prompt

source

pub(all) struct Prompt {
  name : String
  title : String?
  description : String?
  arguments : Array[PromptArgument]?
  meta : Map[String, @moonbitlang/core/json.Json
Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

A prompt template exposed to the client.

impl FromJson for Prompt

impl ToJson for Prompt

Prompt::equal

source

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

Prompt::from_json

source

fn Prompt::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> Prompt raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

Prompt::not_equal

source

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

Prompt::to_json

source

fn Prompt::to_json(self : Prompt) -> @moonbitlang/core/json.Json
Json

Prompt::to_repr

source

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

PromptArgument

source

pub(all) struct PromptArgument {
  name : String
  title : String?
  description : String?
  required : Bool?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

One argument of a prompt template.

impl FromJson for PromptArgument

impl ToJson for PromptArgument

PromptArgument::equal

source

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

PromptArgument::from_json

source

fn PromptArgument::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> PromptArgument raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

PromptArgument::not_equal

source

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

PromptArgument::to_json

source

fn PromptArgument::to_json(self : PromptArgument) -> @moonbitlang/core/json.Json
Json

PromptArgument::to_repr

source

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

PromptMessage

source

pub(all) struct PromptMessage {
  role : Role
  content : ContentBlock
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

One message in a rendered prompt.

impl FromJson for PromptMessage

impl ToJson for PromptMessage

PromptMessage::equal

source

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

PromptMessage::from_json

source

fn PromptMessage::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> PromptMessage raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

PromptMessage::not_equal

source

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

PromptMessage::to_json

source

fn PromptMessage::to_json(self : PromptMessage) -> @moonbitlang/core/json.Json
Json

PromptMessage::to_repr

source

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

PromptsCapabilities

source

pub(all) struct PromptsCapabilities {
  list_changed : Bool?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Prompt listings only need list-change notifications.

PromptsCapabilities::equal

source

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

PromptsCapabilities::not_equal

source

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

PromptsCapabilities::to_repr

source

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

ReadResourceRequestParams

source

pub(all) struct ReadResourceRequestParams {
  uri : String
  meta : Map[String, @moonbitlang/core/json.Json
Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

resources/read request parameters.

impl FromJson for ReadResourceRequestParams

impl ToJson for ReadResourceRequestParams

ReadResourceRequestParams::equal

source

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

ReadResourceRequestParams::from_json

source

fn ReadResourceRequestParams::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> ReadResourceRequestParams raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ReadResourceRequestParams::not_equal

source

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

ReadResourceRequestParams::to_json

source

fn ReadResourceRequestParams::to_json(self : ReadResourceRequestParams) -> @moonbitlang/core/json.Json
Json

ReadResourceRequestParams::to_repr

source

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

ReadResourceResult

source

pub(all) struct ReadResourceResult {
  contents : Array[ResourceContents]
  ttl_ms : Int?
  cache_scope : CacheScope?
  meta : Map[String, @moonbitlang/core/json.Json
Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

The result of a resources/read call.

impl FromJson for ReadResourceResult

impl ToJson for ReadResourceResult

ReadResourceResult::equal

source

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

ReadResourceResult::from_json

source

fn ReadResourceResult::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> ReadResourceResult raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ReadResourceResult::not_equal

source

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

ReadResourceResult::to_json

source

fn ReadResourceResult::to_json(self : ReadResourceResult) -> @moonbitlang/core/json.Json
Json

ReadResourceResult::to_repr

source

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

Reference

source

pub(all) enum Reference {
  PromptReference(name~ : String)
  ResourceTemplateReference(uri~ : String)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

A prompt reference used for completion.

impl FromJson for Reference

impl ToJson for Reference

Reference::equal

source

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

Reference::from_json

source

fn Reference::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> Reference raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

Reference::not_equal

source

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

Reference::to_json

source

fn Reference::to_json(self : Reference) -> @moonbitlang/core/json.Json
Json

Reference::to_repr

source

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

RequestId

source

pub(all) enum RequestId {
  Number(id~ : Int)
  Text(id~ : String)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

A JSON-RPC request id: either a number or a string.

impl FromJson for RequestId

impl ToJson for RequestId

RequestId::equal

source

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

RequestId::from_json

source

fn RequestId::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> RequestId raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

RequestId::not_equal

source

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

RequestId::to_json

source

fn RequestId::to_json(self : RequestId) -> @moonbitlang/core/json.Json
Json

RequestId::to_repr

source

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

RequestParamsMeta

source

pub(all) struct RequestParamsMeta {
  meta : Map[String, @moonbitlang/core/json.Json
Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Parameters common to every request; _meta.progressToken drives progress.

impl FromJson for RequestParamsMeta

impl ToJson for RequestParamsMeta

RequestParamsMeta::equal

source

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

RequestParamsMeta::from_json

source

fn RequestParamsMeta::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> RequestParamsMeta raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

RequestParamsMeta::not_equal

source

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

RequestParamsMeta::progress_token

source

fn RequestParamsMeta::progress_token(self : RequestParamsMeta) -> String?

RequestParamsMeta::to_json

source

fn RequestParamsMeta::to_json(self : RequestParamsMeta) -> @moonbitlang/core/json.Json
Json

RequestParamsMeta::to_repr

source

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

Resource

source

pub(all) struct Resource {
  uri : String
  name : String
  title : String?
  description : String?
  mime_type : String?
  size : Int?
  annotations : Annotations?
  meta : Map[String, @moonbitlang/core/json.Json
Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

A resource exposed for reading.

impl FromJson for Resource

impl ToJson for Resource

Resource::equal

source

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

Resource::from_json

source

fn Resource::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> Resource raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

Resource::not_equal

source

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

Resource::to_json

source

fn Resource::to_json(self : Resource) -> @moonbitlang/core/json.Json
Json

Resource::to_repr

source

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

ResourceContents

source

pub(all) enum ResourceContents {
  Text(uri~ : String, mime_type~ : String?, text~ : String)
  Blob(uri~ : String, mime_type~ : String?, blob~ : String)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

The contents of a resource, either inline text or base64-encoded bytes.

impl FromJson for ResourceContents

impl ToJson for ResourceContents

ResourceContents::equal

source

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

ResourceContents::from_json

source

fn ResourceContents::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> ResourceContents raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ResourceContents::not_equal

source

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

ResourceContents::to_json

source

fn ResourceContents::to_json(self : ResourceContents) -> @moonbitlang/core/json.Json
Json

ResourceContents::to_repr

source

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

ResourceContents::uri

source

fn ResourceContents::uri(self : ResourceContents) -> String

ResourceTemplate

source

pub(all) struct ResourceTemplate {
  uri_template : String
  name : String
  title : String?
  description : String?
  mime_type : String?
  annotations : Annotations?
  meta : Map[String, @moonbitlang/core/json.Json
Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

A parameterised resource address pattern.

impl FromJson for ResourceTemplate

impl ToJson for ResourceTemplate

ResourceTemplate::equal

source

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

ResourceTemplate::from_json

source

fn ResourceTemplate::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> ResourceTemplate raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ResourceTemplate::not_equal

source

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

ResourceTemplate::to_json

source

fn ResourceTemplate::to_json(self : ResourceTemplate) -> @moonbitlang/core/json.Json
Json

ResourceTemplate::to_repr

source

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

ResourcesCapabilities

source

pub(all) struct ResourcesCapabilities {
  subscribe : Bool?
  list_changed : Bool?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Resource capability flags.

ResourcesCapabilities::equal

source

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

ResourcesCapabilities::not_equal

source

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

ResourcesCapabilities::to_repr

source

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

Role

source

pub(all) enum Role {
  User
  Assistant
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

One message in a sampling round trip.

Role::equal

source

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

Role::not_equal

source

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

Role::to_repr

source

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

Role::to_wire

source

fn Role::to_wire(self : Role) -> String

Root

source

pub(all) struct Root {
  uri : String
  name : String?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

A filesystem root the client exposes to the server.

impl FromJson for Root

impl ToJson for Root

Root::equal

source

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

Root::from_json

source

fn Root::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> Root raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

Root::not_equal

source

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

Root::to_json

source

fn Root::to_json(self : Root) -> @moonbitlang/core/json.Json
Json

Root::to_repr

source

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

SamplingMessage

source

pub(all) struct SamplingMessage {
  role : Role
  content : ContentBlock
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

One message of a sampling conversation, as the client's model is shown it.

impl FromJson for SamplingMessage

impl ToJson for SamplingMessage

SamplingMessage::equal

source

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

SamplingMessage::from_json

source

fn SamplingMessage::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> SamplingMessage raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

SamplingMessage::not_equal

source

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

SamplingMessage::to_json

source

fn SamplingMessage::to_json(self : SamplingMessage) -> @moonbitlang/core/json.Json
Json

SamplingMessage::to_repr

source

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

ServerCapabilities

source

pub(all) struct ServerCapabilities {
  experimental : Map[String, @moonbitlang/core/json.Json
Json]?
  extensions : Map[String, @moonbitlang/core/json.Json
Json]?
  logging : Bool?
  completions : Bool?
  prompts : PromptsCapabilities?
  resources : ResourcesCapabilities?
  tools : ToolCapabilities?
  tasks : Bool?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

What a server supports; absent groups mean the feature is off.

impl FromJson for ServerCapabilities

impl ToJson for ServerCapabilities

ServerCapabilities::equal

source

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

ServerCapabilities::from_json

source

fn ServerCapabilities::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> ServerCapabilities raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ServerCapabilities::new

source

fn ServerCapabilities::new() -> ServerCapabilities

ServerCapabilities::not_equal

source

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

ServerCapabilities::to_json

source

fn ServerCapabilities::to_json(self : ServerCapabilities) -> @moonbitlang/core/json.Json
Json

ServerCapabilities::to_repr

source

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

ServerNotification

source

pub(all) enum ServerNotification {
  Cancelled(CancelledNotificationParams)
  Progress(ProgressNotificationParams)
  Message(LoggingMessageNotificationParams)
  ResourceUpdated(uri~ : String)
  ResourceListChanged
  ToolListChanged
  PromptListChanged
  Initialized
  RootsListChanged
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

A notification frame the server can send to a client.

impl ToJson for ServerNotification

ServerNotification::equal

source

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

ServerNotification::not_equal

source

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

ServerNotification::to_json

source

fn ServerNotification::to_json(self : ServerNotification) -> @moonbitlang/core/json.Json
Json

ServerNotification::to_repr

source

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

ServerRequest

source

pub(all) enum ServerRequest {
  Ping(meta~ : Map[String, @moonbitlang/core/json.Json
Json]?)
  CreateMessage(CreateMessageRequestParams)
  Elicit(ElicitRequestParams)
  ListRoots(meta~ : Map[String, @moonbitlang/core/json.Json
Json]?)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

A typed request a server can send to a client.

impl FromJson for ServerRequest

ServerRequest::equal

source

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

ServerRequest::from_json

source

fn ServerRequest::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> ServerRequest raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ServerRequest::not_equal

source

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

ServerRequest::to_repr

source

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

SetLevelRequestParams

source

pub(all) struct SetLevelRequestParams {
  level : LoggingLevel
  meta : Map[String, @moonbitlang/core/json.Json
Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

logging/setLevel request parameters.

impl FromJson for SetLevelRequestParams

impl ToJson for SetLevelRequestParams

SetLevelRequestParams::equal

source

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

SetLevelRequestParams::from_json

source

fn SetLevelRequestParams::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> SetLevelRequestParams raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

SetLevelRequestParams::not_equal

source

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

SetLevelRequestParams::to_json

source

fn SetLevelRequestParams::to_json(self : SetLevelRequestParams) -> @moonbitlang/core/json.Json
Json

SetLevelRequestParams::to_repr

source

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

SubscribeRequestParams

source

pub(all) struct SubscribeRequestParams {
  uri : String
  meta : Map[String, @moonbitlang/core/json.Json
Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

resources/subscribe request parameters.

impl FromJson for SubscribeRequestParams

impl ToJson for SubscribeRequestParams

SubscribeRequestParams::equal

source

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

SubscribeRequestParams::from_json

source

fn SubscribeRequestParams::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> SubscribeRequestParams raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

SubscribeRequestParams::not_equal

source

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

SubscribeRequestParams::to_json

source

fn SubscribeRequestParams::to_json(self : SubscribeRequestParams) -> @moonbitlang/core/json.Json
Json

SubscribeRequestParams::to_repr

source

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

SubscriptionFilter

source

pub(all) struct SubscriptionFilter {
  tools_list_changed : Bool?
  prompts_list_changed : Bool?
  resources_list_changed : Bool?
  resource_subscriptions : Array[String]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

The notifications a client opts in to on a subscriptions/listen stream. Every field is off unless asked for, so a server that honours this sends only what the client named.

impl FromJson for SubscriptionFilter

impl ToJson for SubscriptionFilter

SubscriptionFilter::equal

source

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

SubscriptionFilter::from_json

source

fn SubscriptionFilter::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> SubscriptionFilter raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

SubscriptionFilter::new

source

fn SubscriptionFilter::new() -> SubscriptionFilter

A filter that asks for nothing, which is what an empty object decodes to.

SubscriptionFilter::not_equal

source

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

SubscriptionFilter::to_json

source

fn SubscriptionFilter::to_json(self : SubscriptionFilter) -> @moonbitlang/core/json.Json
Json

SubscriptionFilter::to_repr

source

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

SubscriptionFilter::wants

source

fn SubscriptionFilter::wants(self : SubscriptionFilter, notification : String) -> Bool

Whether the client asked for the notification that a list changed.

Tool

source

pub(all) struct Tool {
  name : String
  title : String?
  description : String?
  input_schema : @moonbitlang/core/json.Json
Json
  output_schema : @moonbitlang/core/json.Json
Json?
  icons : Array[Icon]?
  annotations : ToolAnnotations?
  execution : ToolExecution?
  meta : Map[String, @moonbitlang/core/json.Json
Json]?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

A tool exposed to the client.

impl FromJson for Tool

impl ToJson for Tool

Tool::equal

source

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

Tool::from_json

source

fn Tool::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> Tool raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

Tool::not_equal

source

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

Tool::to_json

source

fn Tool::to_json(self : Tool) -> @moonbitlang/core/json.Json
Json

Tool::to_repr

source

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

ToolAnnotations

source

pub(all) struct ToolAnnotations {
  title : String?
  read_only_hint : Bool?
  destructive_hint : Bool?
  idempotent_hint : Bool?
  open_world_hint : Bool?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

UI hints for a tool.

impl FromJson for ToolAnnotations

impl ToJson for ToolAnnotations

ToolAnnotations::equal

source

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

ToolAnnotations::from_json

source

fn ToolAnnotations::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> ToolAnnotations raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ToolAnnotations::not_equal

source

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

ToolAnnotations::to_json

source

fn ToolAnnotations::to_json(self : ToolAnnotations) -> @moonbitlang/core/json.Json
Json

ToolAnnotations::to_repr

source

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

ToolCapabilities

source

pub(all) struct ToolCapabilities {
  list_changed : Bool?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Tool listings only need list-change notifications.

ToolCapabilities::equal

source

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

ToolCapabilities::not_equal

source

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

ToolCapabilities::to_repr

source

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

ToolExecution

source

pub(all) struct ToolExecution {
  task_support : @moonbitstack/moonmcp/tasks.TaskMode
TaskMode
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Task execution configuration advertised on a tool (SEP-1686).

impl FromJson for ToolExecution

impl ToJson for ToolExecution

ToolExecution::equal

source

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

ToolExecution::from_json

source

fn ToolExecution::from_json(json : @moonbitlang/core/json.Json
Json, path : @moonbitlang/core/json.JsonPath
JsonPath) -> ToolExecution raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ToolExecution::not_equal

source

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

ToolExecution::to_json

source

fn ToolExecution::to_json(self : ToolExecution) -> @moonbitlang/core/json.Json
Json

ToolExecution::to_repr

source

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

cache_scope_of_wire

source

fn cache_scope_of_wire(value : String) -> CacheScope?

The cache scope a wire string names, or None for one this revision does not define.

client_capabilities_meta_key

source

let client_capabilities_meta_key : String

The _meta key a request says what the client can do under.

client_info_meta_key

source

let client_info_meta_key : String

The _meta key a request says who is calling under.

client_request_frame

source

fn client_request_frame(id : RequestId, request : ClientRequest) -> @moonbitlang/core/json.Json
Json

Wrap a client request into a wire frame.

core_result_types

source

fn core_result_types() -> Array[String]

Result type names that may appear as the resultType of a discover reply.

handshake_protocol_versions

source

fn handshake_protocol_versions() -> Array[String]

The revisions a client may name in initialize, newest first. The stateless revision is not among them: it has no handshake.

internal_error

source

let internal_error : Int

The JSON-RPC code for a failure the server did not plan for.

invalid_params

source

let invalid_params : Int

The JSON-RPC code for arguments the method cannot use.

invalid_request

source

let invalid_request : Int

The JSON-RPC code for a message that is not a request at all.

latest_protocol_version

source

let latest_protocol_version : String

The protocol version this implementation speaks.

logging_level_from_wire

source

fn logging_level_from_wire(value : String) -> LoggingLevel?

The severity a notifications/message names, or None for a level the specification does not define.

method_completion_complete

source

let method_completion_complete : String

The wire name of the completion/complete request.

method_elicitation_create

source

let method_elicitation_create : String

The wire name of the elicitation/create request.

method_elicitation_create_form

source

let method_elicitation_create_form : String

The wire name of the elicitation/createForm request.

method_initialize

source

let method_initialize : String

Canonical JSON-RPC method and notification names.

method_input_response

source

let method_input_response : String

The wire name of the input/response request.

method_logging_set_level

source

let method_logging_set_level : String

The wire name of the logging/setLevel request.

method_not_found

source

let method_not_found : Int

The JSON-RPC code for a method this revision does not define.

method_ping

source

let method_ping : String

The wire name of the ping request.

method_prompts_get

source

let method_prompts_get : String

The wire name of the prompts/get request.

method_prompts_list

source

let method_prompts_list : String

The wire name of the prompts/list request.

method_resources_list

source

let method_resources_list : String

The wire name of the resources/list request.

method_resources_read

source

let method_resources_read : String

The wire name of the resources/read request.

method_resources_subscribe

source

let method_resources_subscribe : String

The wire name of the resources/subscribe request.

method_resources_unsubscribe

source

let method_resources_unsubscribe : String

The wire name of the resources/unsubscribe request.

method_roots_list

source

let method_roots_list : String

The wire name of the roots/list request.

method_sampling_create_message

source

let method_sampling_create_message : String

The wire name of the sampling/createMessage request.

method_server_discover

source

let method_server_discover : String

The wire name of the server/discover request.

method_subscriptions_listen

source

let method_subscriptions_listen : String

The wire name of the subscriptions/listen request.

method_tools_call

source

let method_tools_call : String

The wire name of the tools/call request.

method_tools_list

source

let method_tools_list : String

The wire name of the tools/list request.

modern_protocol_versions

source

fn modern_protocol_versions() -> Array[String]

Protocol versions with modern semantics (used for capability gating).

notification_cancelled

source

let notification_cancelled : String

The wire name of the notifications/cancelled notification.

notification_initialized

source

let notification_initialized : String

The wire name of the notifications/initialized notification.

notification_message

source

let notification_message : String

The wire name of the notifications/message notification.

notification_progress

source

let notification_progress : String

The wire name of the notifications/progress notification.

notification_prompt_list_changed

source

let notification_prompt_list_changed : String

The wire name of the notifications/prompts/list_changed notification.

notification_resource_list_changed

source

let notification_resource_list_changed : String

The wire name of the notifications/resources/list_changed notification.

notification_resource_updated

source

let notification_resource_updated : String

The wire name of the notifications/resources/updated notification.

notification_roots_list_changed

source

let notification_roots_list_changed : String

The wire name of the notifications/roots/list_changed notification.

notification_subscriptions_acknowledged

source

let notification_subscriptions_acknowledged : String

The wire name of the notifications/subscriptions/acknowledged notification.

notification_tool_list_changed

source

let notification_tool_list_changed : String

The wire name of the notifications/tools/list_changed notification.

parse_client_request

source

fn parse_client_request(frame : @moonbitlang/core/json.Json
Json) -> ClientRequest raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

Decode a request frame into a typed ClientRequest.

parse_error

source

let parse_error : Int

JSON-RPC error codes defined by the MCP specification.

parse_message

source

fn parse_message(json : @moonbitlang/core/json.Json
Json) -> JSONRPCMessage raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

Parse one wire frame.

parse_server_request

source

fn parse_server_request(frame : @moonbitlang/core/json.Json
Json) -> ServerRequest raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

Decode a request frame into a typed ServerRequest.

protocol_version_meta_key

source

let protocol_version_meta_key : String

The _meta key a stateless request names its protocol revision under.

role_from_wire

source

fn role_from_wire(value : String) -> Role?

The author a message names, or None for one that is neither the client nor the server.

server_info_meta_key

source

let server_info_meta_key : String

The _meta keys a 2026-07-28 request and reply carry their session facts under. The prefix is the one the specification reserves for itself, so a request from another revision is told apart by the presence of one of these alone.

server_request_frame

source

fn server_request_frame(id : RequestId, request : ServerRequest) -> @moonbitlang/core/json.Json
Json

Wrap a server request into a wire frame.

subscription_id_meta_key

source

let subscription_id_meta_key : String

The _meta key a subscription's messages carry the id of the stream that opened it under.

text_block

source

fn text_block(text : String) -> ContentBlock

Shorthand for a plain text block without annotations.

#Annotations

#Annotations::equal

#Annotations::from_json

#Annotations::not_equal

#Annotations::to_json

#Annotations::to_repr

#CacheScope

#CacheScope::equal

#CacheScope::not_equal

#CacheScope::to_repr

#CacheScope::to_wire

#CallToolRequestParams

#CallToolRequestParams::equal

#CallToolRequestParams::from_json

#CallToolRequestParams::not_equal

#CallToolRequestParams::progress_token

#CallToolRequestParams::to_json

#CallToolRequestParams::to_repr

#CallToolResult

#CallToolResult::equal

#CallToolResult::error

#CallToolResult::from_json

#CallToolResult::new

#CallToolResult::not_equal

#CallToolResult::to_json

#CallToolResult::to_repr

#CancelledNotificationParams

#CancelledNotificationParams::equal

#CancelledNotificationParams::from_json

#CancelledNotificationParams::not_equal

#CancelledNotificationParams::to_json

#CancelledNotificationParams::to_repr

#ClientCapabilities

#ClientCapabilities::equal

#ClientCapabilities::from_json

#ClientCapabilities::new

#ClientCapabilities::not_equal

#ClientCapabilities::to_json

#ClientCapabilities::to_repr

#ClientRequest

#ClientRequest::equal

#ClientRequest::from_json

#ClientRequest::not_equal

#ClientRequest::to_repr

#ClientRequest::verb

#CompleteRequestParams

#CompleteRequestParams::equal

#CompleteRequestParams::from_json

#CompleteRequestParams::not_equal

#CompleteRequestParams::to_json

#CompleteRequestParams::to_repr

#CompleteResult

#CompleteResult::equal

#CompleteResult::from_json

#CompleteResult::not_equal

#CompleteResult::to_json

#CompleteResult::to_repr

#Completion

#Completion::equal

#Completion::from_json

#Completion::not_equal

#Completion::to_json

#Completion::to_repr

#CompletionArgument

#CompletionArgument::equal

#CompletionArgument::from_json

#CompletionArgument::not_equal

#CompletionArgument::to_json

#CompletionArgument::to_repr

#CompletionContext

#CompletionContext::equal

#CompletionContext::from_json

#CompletionContext::not_equal

#CompletionContext::to_json

#CompletionContext::to_repr

#ContentBlock

#ContentBlock::equal

#ContentBlock::from_json

#ContentBlock::not_equal

#ContentBlock::to_json

Annotations

Annotations::equal

Annotations::from_json

Annotations::not_equal

Annotations::to_json

Annotations::to_repr

CacheScope

CacheScope::equal

CacheScope::not_equal

CacheScope::to_repr

CacheScope::to_wire

CallToolRequestParams

CallToolRequestParams::equal

CallToolRequestParams::from_json

CallToolRequestParams::not_equal

CallToolRequestParams::progress_token

CallToolRequestParams::to_json

CallToolRequestParams::to_repr

CallToolResult

CallToolResult::equal

CallToolResult::error

CallToolResult::from_json

CallToolResult::new

CallToolResult::not_equal

CallToolResult::to_json

CallToolResult::to_repr

CancelledNotificationParams

CancelledNotificationParams::equal

CancelledNotificationParams::from_json

CancelledNotificationParams::not_equal

CancelledNotificationParams::to_json

CancelledNotificationParams::to_repr

ClientCapabilities

ClientCapabilities::equal

ClientCapabilities::from_json

ClientCapabilities::new

ClientCapabilities::not_equal

ClientCapabilities::to_json

ClientCapabilities::to_repr

ClientRequest

ClientRequest::equal

ClientRequest::from_json

ClientRequest::not_equal

ClientRequest::to_repr

ClientRequest::verb

CompleteRequestParams

CompleteRequestParams::equal

CompleteRequestParams::from_json

CompleteRequestParams::not_equal

CompleteRequestParams::to_json

CompleteRequestParams::to_repr

CompleteResult

CompleteResult::equal

CompleteResult::from_json

CompleteResult::not_equal

CompleteResult::to_json

CompleteResult::to_repr

Completion

Completion::equal

Completion::from_json

Completion::not_equal

Completion::to_json

Completion::to_repr

CompletionArgument

CompletionArgument::equal

CompletionArgument::from_json

CompletionArgument::not_equal

CompletionArgument::to_json

CompletionArgument::to_repr

CompletionContext

CompletionContext::equal

CompletionContext::from_json

CompletionContext::not_equal

CompletionContext::to_json

CompletionContext::to_repr

ContentBlock

ContentBlock::equal

ContentBlock::from_json

ContentBlock::not_equal

ContentBlock::to_json