ezmcp

Search uses release 0.1.0.0 · 416 definitions

Releases (1)

0.1.0.0 indexed

Definitions (416)

src/line.bend

def width1 for ASCII, 2 to 4 for a lead byte, 0 for a byte that starts nothing
def dec.takea sequence whose continuation bytes are all valid is its char, and the decoding goes on after it; else the lead byte is U+FFFD and the decoding goes on at the byte after it
def dec.two
def dec.three
def dec.four
def dec.leadone sequence at a lead byte of width w, then `go` on what follows
def decode.step
def decode.godecode with fuel: every step takes at least one byte, so a buffer's length is fuel enough
def decodebytes decoded from UTF-8; a byte that starts no valid sequence is U+FFFD
def line.of
def line.text
def linewhat a server does with one line read by revision `rev`, and the revision the next line is read by: nothing for a blank one, and the revision unchanged; else the server's turn on its text
def frameone message on stdout: its JSON text and a newline

src/openapi.bend

type Placewhere a parameter goes (Parameter Object `in`); InNone for a location OpenAPI does not have
type Parama parameter a request is built from: its name and where it goes
type Opone operation as a tool: the tool's name, description and input schema, and what its calls are sent as: the method (upper case), the path template, the parameters, and the request body's media type ("" for none)
type Callthe request a tool call stands for: a method, a target (the path and its query), the header fields and the body; or the path template when a template expression is still in it
def or.elsetrue at a hit, else the rest of the search
def and.thenfalse at a miss, else the rest of the check
def Meman object member: its name and value, reusable
def cellsmembers as the cells of an object, in order
def objectthe object of members, in order
def members.go
def membersan object's members in order; none for any other value
def put.at
def putmembers with `key` set to `val`: in the place of the first member of that name, else last, as a JavaScript assignment puts it
def drop.at
def dropmembers less every one named `key`, the rest in order
def namedwhether members have one named `key`
def lookup.at
def lookupthe value of the first member named `key`
def valuea member's value, null when there is none
def fulla string when it is not empty, as JavaScript's `||` takes it
def firstthe first of two maybe strings that is there
def is_truewhether a value is JSON true
def is_nullwhether a value is JSON null
def is_str.of
def is_strwhether a value is the string `str`
def str.ata member's string, "" when it is not one
def token.go
def tokenone reference token decoded: `~1` as `/` and `~0` as `~` (RFC 6901 §4)
def walk.at
def walkthe value at a pointer's tokens, each a member name, or none when a member is missing
def resolve.at
def resolvewhat a local reference (`#/` and a JSON Pointer) points to in the document; none for a reference that is not local or points to nothing
def ref.ofa `$ref` member's string, when the cells have one
def seenwhether a reference is one being followed already
def merge.one
def merge.add
def merge.of
def mergea reference's target with the reference object's other members: the target itself when there are none; else those members first, then the target's members they do not name (Reference Object: a sibling `description` overrides the target's)
def cyclicthe schema a reference cycle stands for
def deref.found
def deref.ref
def deref.obj
def derefa value with every local reference in it replaced by its target, merged with the reference object's other members (`merge`); a reference to one of `refs`, the references being followed, is a cycle (`cyclic`), and one that does not resolve is left as it is.
def depthhow deep a value's references and schemas may nest before the rest is left as it is
def dereferenceda value of the document with its local references followed
def extrasthe OpenAPI 3.0 fields of a Schema Object that are not JSON Schema, which an input schema leaves out
def drop.allmembers less every one named by `keys`
def number`integer` as JSON Schema's `number`, any other type as it is
def with.null.arr
def any.null
def with.nulla type that also admits null (OpenAPI 3.0 `nullable`): a type name as an array of it and "null", an array of names with "null" added when it lacks it, anything else as it is
def typed.null
def typed.of
def owna schema's own members as an input schema has them: the OpenAPI 3.0 extras left out, `integer` as `number`, and `nullable` true adding null to an explicit type, every other member as it is, in order
type Kidswhat a mapped schema recurses into: its properties when its type is "object", its items when its type is "array", else nothing
def kids.props
def kids.item
def kids.array
def kids.of
def kidswhat a schema's members recurse into: its properties' cells when its type is "object" and its properties an object, its items when its type is "array" and its items an object, else nothing
def kids.put
type Propwhether a property's value is a schema to map, kept as it is, or left out
def prop.of
def prop.put
type Readwhat `shape` reads its value as: a schema, or the cells of a properties object
def shapea schema as an input schema (`own`), its properties' and items' schemas mapped the same way; or the cells of a properties object with every schema value mapped, a boolean kept and any other value left out.
def schemaa Schema Object as the JSON Schema of an input
def name.okwhether a character may stand in a tool name: an ASCII letter or digit, `_` or `-`
def name.char
def sanitizea string as a tool name: each character that may not stand in one (`name.ok`) as `_`, one for one
def title.go
def capitala string with its first character in upper case
def strip.lead.at
def strip.lead
def titlea path segment in title case, as openapi-mcp-generator writes one: lower case, each `-`, `_` or `/` and the character after it as that character in upper case, less a leading `{` and a trailing `}`, the first character in upper case
def is_paramwhether a path segment is a template expression, `{` to `}`
def segments.at
def segmentsthe pieces of a split path that are not empty
def gen.param
def gen.part
def gen.parts
def gen.root
def generatedan operation id made from the method and the path, for an operation with none, as openapi-mcp-generator makes it: the method, each path segment in title case, a parameter segment only when it is the last and then after "By", "Root" when there are no segments, the first letter in upper case
def name.ofa tool's name: the operation's id when it is a non-empty string, else one made from the method and path (`generated`), as a tool name (`sanitize`)
def describea tool's description: the operation's description, else its summary, each when it is a non-empty string, else the method and path it runs
def samewhether two Parameter Objects are one parameter: the same name and the same location
def params.put.at