MCP Field Reference

The describe_type tool tells a model what fields an object has before it reads, builds or edits one. This page explains what it returns. The fields of each type are generated from QIE's own field list, so they always match what the read tools return.

What describe_type returns

describe_type takes a type, such as channel, and returns:

Member	Holds
type	The type asked for
title	The name of a top-level type, such as "Web Service Connection"; empty for a nested type
description	What the type is for and how a model uses it, for the types a model works with when it builds a channel: mapping and condition nodes, each kind of mapping function and condition, function targets and query parameters, and each zone object type; empty for the rest
operations	What the tools can do with a top-level type: get, and list for every type except system_config
subtypes	For a channel, a destination node and a system variable's external source, the field that holds the kind (messageSource, messageDestination, sourceType) and the type each kind's own fields belong to, such as source_node.http; for a mapping function and a condition, $kind and the kinds it takes, such as mapping_function.case. A kind with no fields of its own, such as the Discard destination, names none
lockRule	What a locked package allows, for a type that can be in a package; empty otherwise
rules	For a top-level type, every check a save must pass (see Rules); empty for a nested type, whose checks are listed on the type that holds it
fields	One entry per field, in the order the object carries them

Each field gives:

Member	Holds
name	The field's name, as get_object returns it
type	The kind of value (see below)
required	Whether a save is refused when the field is missing or blank. A field required only in some cases, such as a variable's external source when it is linked to one, reads false, and its rule says when it is required
allowedValues	The values the field takes, where they form a fixed list: every choice of a fixed list, and the codes of a coded field such as a source's responseType; empty where the list is open, and the meaning then says what is known
default	The value a new object holds when the field is not sent; empty when it starts empty, for a nested object, and for secret, time and server-managed fields. The console can preset other values in its dialogs, so this is what QIE stores, not what a dialog shows
secret	Whether the field holds a credential; a secret field reads {"$secret": "set"} or {"$secret": "unset"} and its value is never returned
serverManaged	Whether QIE sets the value; leave it as read
lockState	What happens to the field while the object is in a locked package: always (can be changed), if-editable (only while the package's configuration is editable), locked (kept as stored) or n/a
meaning	One plain sentence saying what the field does
helpPage	The help page that covers the field, as its path in the help source with an optional anchor, such as channels/visual-editor.md#node-types; the page is the qie://help resource named by that path with underscores for slashes (see MCP Help and Code Wizard Tools); empty when no page does

Types

The top-level types are the ones get_object takes (see MCP Read Tools). A top-level object holds nested objects, and each nested kind has a type of its own, such as channel_node, source_node.http for the fields an HTTP source uses, or mapping_function.custom. An unknown type is refused with the list of valid ones.

A field's type is one of:

Value	Meaning
string, integer, number, boolean	A plain value; a choice from a fixed list is a string
timestamp	A date and time, written as an ISO 8601 instant
base64	Bytes, such as a stored file, written as a base64 string
secret	A credential, never returned
reference:<type>	A reference to another object, read as {"id", "name"}; a save reads only the id, so a model sends {"id": "..."}
object:<type>	A nested object of that type
list:<type>	A list of values or nested objects of that type
object	A set of named values

A nested object or list is named by the type of what it holds, such as list:mapping_function for a mapping's functions or list:condition for a condition list's conditions. Where no single type fits, the Java class name stands in: a channel's channelNodes is list:ClientChannelNode, because it holds mapping, condition and destination nodes, each described by its own type.

Rules

The rules of a top-level type are the checks QIE makes before it saves an object of that type, taken from the checks the console's dialogs and channel editor make before they save. Each rule gives:

Member	Holds
id	The rule's id, which a refused save names, such as zone.name_max_length
appliesTo	The tools that make the check
field	The field the rule checks, as a path from the object, such as publishedFunctionParameters[*].name for each parameter's name; empty for a channel rule, which can involve several nodes
rule	The rule in one plain sentence

A channel's rules cover its source, format and nodes, and how its nodes may be linked. They are also served, with how a channel is put together and how its nodes are numbered, as the qie://guide/build-a-channel resource (see Building a Channel Through the MCP).

Mapping functions and conditions have no field that holds their kind, so every mapping function and condition in a read carries $kind, such as mapping_function.custom, and a new one sent in a save must carry it too.

Guides to functions and conditions

Two resources explain the kinds a model meets most when it builds a channel. qie://guide/mapping-functions says what each kind of mapping function is for, when to choose it, where it reads its value and writes its result, and how to run it only for some messages. qie://guide/conditions does the same for conditions, with the operators and data types each comparison takes and how conditions combine. Each gives a complete example of every kind, in the form add_node takes, and a test checks that QIE accepts every example, so the guides cannot drift from what a save allows. qie://guide/zone-objects does the same for the objects channels share, with an example of each that save_object accepts as new.