ezmcp

Search uses release 0.1.0.0 · 416 definitions

Releases (1)

0.1.0.0 indexed

Definitions (416)

src/openapi.bend

def params.putparameters with `new` in the place of the first that is the same parameter (`same`), else last
def params.mergea Path Item's parameters `ps`, each of its operation's `ops` in turn put in them (`params.put`)
def placewhere a parameter goes, from its `in`
def param.of
def params.ofthe parameters a request is built from: each with a non-empty name, and where it goes
type Inan input schema being built: its properties and its required names
def described.at
def describeda schema with its description set to `desc`, in its place or last, when it is an object and there is one to set
def need`name` added to the end of the required names when `want`
def schema.okwhether a value stands as a schema: an object or `true`
def input.param.put
def input.param.ofa parameter as an input property: one with a name and a schema is the property of that name, its schema mapped (`schema`) and described by the parameter's description when that is a non-empty string, and required when the parameter is; any other leaves the input as it is
def input.param
def input.params
def media.first
def media.at
def mediaa request body's media type: application/json when its content has a schema for it, else the first media type of its content, else none ("")
def body.json
def body.text
def body.schema
def input.body.of
def input.body.at
def input.bodya Request Body Object as the `requestBody` property, with its media type `mt` (`media`): application/json's schema, mapped and described by the body's description, else the schema's, else "The JSON request body."; for another media type a string; required when the body is.
def strsstrings as JSON strings
def requiredthe `required` member of an input schema, none for no names
def input.ofthe input schema built: an object schema of the properties, with the required names when there are any
def methodsthe methods a Path Item may have an operation for, in the order their tools are listed
def media.ofa request body's media type, "" for none
def opone operation of a Path Item at `path`, `oper` its Operation Object, its references followed in `doc`, after the Path Item's parameters `ips`
def item.at
def itema Path Item's operations for the methods `ms`, in their order: one for each method whose member is an object (`op`), none for any other
def pathsthe operations of the Path Items `ps`, in order, each one's in the order of `methods`, after its parameters with their references followed
def opsevery operation of a document, in the order of its paths (`paths`)
def toolan operation's tool
def namean operation's tool name
def renamedan operation under another tool name, all else as it was
def arg.at
def argan argument's value when it is there and not null
def plain.scalar
def plain.item
def plain.items
def plaina value as the text of a parameter: a string as itself, a number as its text, a boolean as `true` or `false`, an array as its items' texts joined by `,` (style simple), anything else as its JSON
def swap.at
def swapa string with its first `pat` replaced by `rep`
def filla path template with its first `{name}` replaced by the value's text, percent-encoded as a path segment
def query.item
def query.items
def querya query parameter's pairs: one for each item of an array that is not null, else one of the value's text (style form, explode true)
type Reqa request being built: the path, the query's pairs and the header fields
def req.put.ata parameter's value put in a request: a path parameter filled into the path (`fill`), a query parameter's pairs added to the query (`query`), a header parameter a header field of its name in lower case and its text (`plain`); a cookie parameter, or one of no known location, changes nothing
def req.put
def req.arg
def req.paramsa request with each parameter that has an argument there and not null put in it (`req.put`), in order
def body.text.of
def body.of
def body.arga request's body: the `requestBody` argument, when the operation has a body and the argument is there and not null, as JSON for application/json, else a string as itself and anything else as its JSON
def ctypethe header field naming a body's media type, when there is a body
def query.texta query string: none for no pairs, else `?` and the pairs form-encoded
def call.sendthe request built, or the path when a template expression is still in it
def call.of
def callthe request a call of an operation stands for, with these arguments: each parameter with an argument there and not null put in the request (`req.params`), the header fields Accept: application/json, then the header parameters', then Content-Type when there is a body (`body.arg`); or Unfilled when the path still holds a `{`
def digitswhether every character is a digit
def int.textwhether a number's text is an integer: an optional `-`, then digits
def kind.int
def kind.str
def kind.num
def kind.bool
def kind.namethe JSON type of a value, as JSON Schema names it
def kindwhether a value is of the JSON Schema type named `typ`: string, number, integer (a number whose text is an integer), boolean, array, object or null; true for a name JSON Schema does not have
def kindswhether a value is of one of the types an array of names lists
def typedwhether a value is of a schema's `type`: the type it names, or one of the types an array of names lists; true for a schema with no `type`
def altswhether a value is of one of the `anyOf` alternatives' types
def same.json
def fitswhether a value fits a property's schema, one level deep: its `type` (`typed`), one of its `anyOf` alternatives' types when it has `anyOf`, and one of its `enum` values when it has `enum`
def missing.at
def missingwhat the first required name the arguments do not have is missing
def wanted.of
def wantedwhat is wrong with a value that does not fit its schema: the type it should have had, when the schema names one, and the type it has
def bad.at
def badwhat is wrong with the first property whose argument is there and does not fit its schema (`fits`)
def check.of
def checkwhat is wrong with a call's arguments, when anything is: a required name they do not have (`missing`), else a property they have whose value does not fit its schema (`bad`); none when neither

src/rpc.bend

type Msgwhat one incoming message is (JSON-RPC 2.0 §4, MCP basic#messages)
type Headthe fields of a message the classification looks at
type Codethe error codes JSON-RPC 2.0 §5.1 predefines
type Outhow a request ends: a result, or an error with its code and message
type Replywhat a reply a client reads says
def digits.andthe rest of a test that holds so far: false once one char fails
def digits.gowhether every char of a text is an ASCII digit (true for the empty text)
def digitswhether a text is one or more ASCII digits
def int.text.ofan integer's text after its first char: digits after a minus, else the first char a digit and digits after it
def int.textwhether a number's text is an integer: an optional minus, then digits
def id.num
def id.str
def id.okwhether a value is a request id MCP allows: a string or an integer, never null (basic#requests)
def is.v2
def headthe fields of one decoded message
def head.idthe id an error reply to a message carries: its own when it has a valid one, null otherwise (JSON-RPC 2.0 §5)
def decide.methoda message with a method: a request when it has an id, which must be a valid one; a notification when it has none
def onewhether exactly one of two is true