A data-binding scope: the absolute path relative bindings resolve against, the collection-template iteration index, and — when built for a surface — what is needed to evaluate dynamic values.

The root scope is "/". A component rendered for item 2 of a /items template runs in the nested scope "/items/2/", so its relative path name resolves to /items/2/name.

Path resolution

Follows the reference:

• an absolute path (starting with /) is returned unchanged,

• "" and "." resolve to the scope itself,

• any other path is joined to the scope, ignoring trailing slashes on the scope.

  iex> ctx = A2UICore.Resolution.DataContext.new("/user") iex> A2UICore.Resolution.DataContext.resolve_path(ctx, "name") "/user/name" iex> A2UICore.Resolution.DataContext.resolve_path(ctx, "/other") "/other" iex> A2UICore.Resolution.DataContext.resolve_path(ctx, ".") "/user"

Dynamic values

resolve_dynamic_value/2 evaluates a literal, a data binding ({"path": …} in v0.9, {"@path": …} in v1.0) or a function call ({"call": …, "args": …} / {"@call": …, "args": …}, optionally with a catalogId) against the data model, recursing through arrays and objects. It never raises: what the reference reports through the surface comes back as effects next to the value —

• {:warning, %{code: "MISSING_DATA_BINDING", path: …, message: …}} when a bound path is absent (once per path per call),
• {:error, %{code: "EXPRESSION_ERROR", message: …, expression: …}} when a function call fails; the call's value is then nil.

A function can ask for more through its effects — the MCP catalog's functions do (A2UICore.Functions.MCP):

• {:write, %{path: path, value: value}} — write the data model;

• {:messages, %{messages: messages, source: :resource | :inline}} — apply A2UI messages.

They come back in evaluation order. A renderer applies them when they come from an action (A2UICore.Resolution.NodeResolver.invoke/5); rendering ignores them.

Agent functions

From v1.0 a function that the catalog a call resolves to does not declare, or declares without an implementation, may be the agent's: a renderer sends it to the agent as a callAgentFunction message. A scope built with the :agent_calls option routes such calls instead of failing them. The option holds what the renderer knows of the calls it sent, keyed by {name, catalog_id, args} (catalog_id is the one the call names, else nil; args are resolved):

• :pending — sent, no response yet; the call's value is nil;
• {:ok, value} — the agent's response; the call's value is value;
• {:error, payload} — the call failed; its value is nil.

Every routed call comes back as an {:agent_call, %{key: key, call: call}} effect, where call is the function call object to send ("@call", resolved "args", and the "catalogId" the call named), so that the renderer sends the calls it has not sent yet. With agent_calls: {:send, calls}, the scope of a function-call action, the call the action makes is always routed without a lookup, and its effect also carries action: true; the calls in its arguments are looked up in calls. A call that names a catalog the scope does not reach is still a catalog error.

Who may call

A function the renderer runs is refused, with an EXPRESSION_ERROR, when its catalog reserves it for the agent (allowedCallers: "agentOnly"), and when it requires a user gesture (requiresUserActivation: true, as openUrl does) and the scope was not built for one with user_activated: true. A renderer builds its action scopes that way (A2UICore.Resolution.NodeResolver.invoke/5); property bindings and check conditions never are.

v1.0 objects follow the reserved-key rule (A2UICore.Validation.ReservedKeys): @@x is the literal key @x, any other single-@ key is an INVALID_RESERVED_KEY error.