Modules
The A2UI extension of the A2A protocol: extension URIs and their negotiation, and A2UI messages carried in A2A parts.
An agent that A2UIAgent.A2A.Server and A2UIAgent.A2A.Plug serve.
Serves an agent over A2A's JSON-RPC binding with
A2UIAgent.A2A.Server.
One A2A message/send or message/stream request, as
A2UIAgent.A2A.Server hands it to the agent.
Answers the A2A JSON-RPC methods message/send and message/stream
for an agent that writes A2UI.
Carries A2UI over AG-UI, the event protocol between agents and their front ends, the way AG-UI's A2UI middleware and the renderers built on it (CopilotKit, assistant-ui) do. A2UI does not define this binding itself.
Splits model output into conversational text and the raw blocks between a format's tags.
Builds component trees in Elixir and flattens them into the component lists that A2UI messages carry.
A function for each component of the basic catalog, named after it in
snake case: text/1, text_field/1, date_time_input/1 and so on.
Each one is A2UIAgent.Builder.component/2 with the component's name.
A data binding, written as {"path": path} ({"@path": path} from
v1.0). Made by A2UIAgent.Builder.bind/1.
Children generated from a data model list: the list's path and the
template component repeated for each item, written as
{"path": path, "componentId": template_id}. Made by
A2UIAgent.Builder.child_list/2.
A component node of an A2UIAgent.Builder tree: the component name,
the id the author gave (if any) and the properties, as wire names and
values in the order given. Made by A2UIAgent.Builder.component/2.
A call of a catalog function, written as {"call": name, "args": args}
("@call" from v1.0, with the "catalogId" it names). Made by
A2UIAgent.Builder.call/3.
A reference to a component already on the surface. It is written as
its id and never emitted. Made by A2UIAgent.Builder.ref/1.
A catalog an agent registers, together with the transformers applied to it.
Loads catalog documents into A2UICore.Catalogs.
Negotiates the catalogs that are active for one renderer.
Rules applied to a catalog before it reaches a prompt or a validator.
The pruning transformer behind A2UIAgent.CatalogTransformer.component_pruning/1
and A2UIAgent.CatalogTransformer.function_pruning/1.
Checks on the list of active catalogs that a format, parser or prompt works with.
The direct JSON inference format: the model writes A2UI messages as
JSON between <a2ui-json> and </a2ui-json> tags, guided by the
protocol and catalog JSON schemas in its prompt.
Reads the JSON a model writes, which is often almost JSON.
Reads model output written in the direct JSON format: conversational
text with A2UI message lists between <a2ui-json> and </a2ui-json>
tags.
The system prompt snippet of the direct JSON format.
The Express inference format: the model writes a compact,
function-call notation between <a2ui> and </a2ui> tags, which the
agent compiles into A2UI messages.
The active catalogs of an Express format, compiler or decompiler, with a schema helper for each, and the lookups they share.
Compiles an Express block into A2UI messages.
Writes A2UI messages back as Express.
Reads model output written in Express: conversational text with
Express blocks between <a2ui> and </a2ui> tags.
The system prompt snippet of the Express format.
What Express reads from a catalog: each component's properties in positional order, each function's parameters, and the facts about a property's schema that decide how an argument compiles.
Reads Express source into statements, following the grammar
specification/inference_formats/express/Express.g4.
An inference format: how the model is told to write A2UI, and how its output is read back.
The agent-level entry point: the catalogs an agent supports, its
few-shot examples and its inference format, from which it creates one
A2UIAgent.RequestProcessor per request.
Carries A2UI over the Model Context Protocol, as the A2UI project's guide "A2UI over MCP" describes: the JSON values an MCP server puts in its responses, and the A2UI values it reads from requests. It works with any MCP server implementation.
A macro: a component the model can write that the agent expands into components of its catalog before they reach the renderer.
A macro call inside a component tree, expanded where the tree is
flattened. Made by A2UIAgent.Macro.call/2.
Puts macros (A2UIAgent.Macro) in front of a catalog: the model sees
a catalog with the macros as components, and the renderer gets the
base catalog's components they expand to.
Reads a JSON payload a model wrote, fixing the mistakes models commonly
make, as the reference SDKs' payload fixer (parse_and_fix) does.
Checks a payload an agent is about to send the way a renderer holding the same catalogs would.
Everything an agent needs to answer one request: the negotiated catalogs, the inference format bound to them, its prompt snippet and its parsers.
Prunes the protocol schemas a prompt shows the model.
A skill package: a markdown document with YAML frontmatter (name,
description and optional metadata) that teaches an agent to write
A2UI, stored as <name>/SKILL.md.
Packages an inference format's prompt as skills
(A2UIAgent.Skill).