@datalayer/agent-runtimes 1.3.114 → 1.4.0

package/lib/apps/apps/appspec.d.ts

@@ -87,6 +87,19 @@ export interface ParsedAppspec {
  * is always whole, so an editor can open it and show what is wrong.
  */
 export declare function parseAppspec(document: unknown): ParsedAppspec;
+/**
+ * What is wrong with the UI an application says its answers render in
+ * (AGENT_PROTOCOLS PS-04), as agentspecs says it: an id the catalogue does not
+ * know or said twice, one not enabled while it is offered.
+ */
+export declare function uiProblems(app: Pick<AppSpec, 'ui' | 'enabled'>): string[];
+/**
+ * What is wrong with the protocols an application says it speaks
+ * (AGENT_PROTOCOLS PS-02), as agentspecs says it: an id the catalogue does not
+ * know or said twice, a planned protocol while it is offered, and a `pap`,
+ * `pact` or `a2a` block configuring a protocol it does not list.
+ */
+export declare function protocolsProblems(app: Pick<AppSpec, 'protocols' | 'enabled' | 'pap' | 'pact' | 'a2a'>): string[];
 /**
  * An application as the document its file holds.
  *

package/lib/apps/apps/appspec.js

@@ -3,6 +3,8 @@
  * Distributed under the terms of the Modified BSD License.
  */
 import { BEHAVIOURS } from './rules';
+import { PROTOCOL_CATALOGUE } from '../../specs/protocols';
+import { UI_CATALOGUE } from '../../specs/ui';
 import { DEFAULT_MAX_FILES, DEFAULT_UPLOAD_MB } from './uploads';
 /** The version of the spec itself. */
 export const APP_SCHEMA = 'loop.app/v1';
@@ -130,6 +132,8 @@ export function emptyAppspec(kind = 'chat') {
         context: [],
         contents: [],
         connections: [],
+        protocols: [],
+        ui: [],
         rules: [],
         permissions: {
             spaces: [],
@@ -195,6 +199,8 @@ const KNOWN_KEYS = [
     'context',
     'contents',
     'connections',
+    'protocols',
+    'ui',
     'pap',
     'pact',
     'a2a',
@@ -809,6 +815,8 @@ export function parseAppspec(document) {
         context: texts(data.context),
         contents: texts(data.contents),
         connections: records(data.connections).map(parseConnection),
+        protocols: texts(data.protocols),
+        ui: texts(data.ui),
         rules: records(data.rules).map(parseRule),
         permissions: {
             spaces: records(permissions.spaces).map(grant => ({
@@ -894,8 +902,69 @@ export function parseAppspec(document) {
     if (isData(data.a2a)) {
         app.a2a = parseA2A(data.a2a);
     }
+    problems.push(...protocolsProblems(app), ...uiProblems(app));
     return { app, problems };
 }
+/**
+ * What is wrong with the UI an application says its answers render in
+ * (AGENT_PROTOCOLS PS-04), as agentspecs says it: an id the catalogue does not
+ * know or said twice, one not enabled while it is offered.
+ */
+export function uiProblems(app) {
+    const problems = [];
+    const seen = [];
+    for (const id of app.ui) {
+        if (seen.includes(id)) {
+            problems.push(`It lists the UI '${id}' twice.`);
+            continue;
+        }
+        seen.push(id);
+        const spec = UI_CATALOGUE[id];
+        if (!spec) {
+            problems.push(`There is no UI named '${id}': one of ${Object.keys(UI_CATALOGUE).sort().join(', ')}.`);
+        }
+        else if (app.enabled && !spec.enabled) {
+            problems.push(`The UI ${spec.name} ('${id}') is not enabled: an application cannot render in it yet.`);
+        }
+    }
+    return problems;
+}
+/**
+ * What is wrong with the protocols an application says it speaks
+ * (AGENT_PROTOCOLS PS-02), as agentspecs says it: an id the catalogue does not
+ * know or said twice, a planned protocol while it is offered, and a `pap`,
+ * `pact` or `a2a` block configuring a protocol it does not list.
+ */
+export function protocolsProblems(app) {
+    const problems = [];
+    const seen = [];
+    for (const id of app.protocols) {
+        if (seen.includes(id)) {
+            problems.push(`It lists the protocol '${id}' twice.`);
+            continue;
+        }
+        seen.push(id);
+        const spec = PROTOCOL_CATALOGUE[id];
+        if (!spec) {
+            problems.push(`There is no protocol named '${id}': one of ${Object.keys(PROTOCOL_CATALOGUE).sort().join(', ')}.`);
+        }
+        else if (app.enabled && spec.status === 'planned') {
+            problems.push(`${spec.name} ('${id}') is planned, not shipped: an application cannot speak it yet.`);
+        }
+    }
+    const configured = {
+        pap: Boolean(app.pap && (app.pap.connections.length > 0 || app.pap.company.enabled)),
+        pact: Boolean(app.pact && app.pact.connections.length > 0),
+        a2a: Boolean(app.a2a && app.a2a.extensions.length > 0),
+    };
+    for (const spec of Object.values(PROTOCOL_CATALOGUE)) {
+        const block = spec.appspecBlock;
+        if (block && configured[block] && !app.protocols.includes(spec.id)) {
+            problems.push(`Its \`${block}\` block configures ${spec.name}, which it does not list: add '${spec.id}' to \`protocols\`.`);
+        }
+    }
+    return problems;
+}
 // --- writing --------------------------------------------------------------------------
 const sameList = (a, b) => a.length === b.length && a.every((item, index) => item === b[index]);
 /** A document with a key only when its value says something. */
@@ -1148,6 +1217,8 @@ export function dumpAppspec(app) {
         .value('access', connection.access, 'read')
         .value('as', connection.as, 'owner')
         .list('only', connection.only).data))
+        .list('protocols', app.protocols)
+        .list('ui', app.ui)
         .part('pap', dumpPap(app.pap))
         .part('pact', dumpPact(app.pact))
         .part('a2a', dumpA2A(app.a2a))

package/lib/apps/apps/checks.d.ts

@@ -11,7 +11,7 @@ export interface AppCheck {
 }
 /**
  * The component a layout names (LOOP C-13), from the catalogs of the enabled
- * UI plugins, by the name a surface gives it.
+ * UI specs, by the name a surface gives it.
  */
 export declare const componentNamed: (name: string) => ComponentSpec | undefined;
 /**

package/lib/apps/apps/checks.js

@@ -29,7 +29,7 @@ import { getCog } from '../../specs/cogs';
 import { getFrame } from '../../specs/frames';
 import { getGate } from '../../specs/gates';
 import { GUARD_CATALOGUE } from '../../specs/guards';
-import { getComponent } from '../../specs/uiPlugins';
+import { getComponent } from '../../specs/ui';
 import { MCP_SERVER_LIBRARY } from '../../specs/mcpServers';
 import { getMemory } from '../../specs/memory';
 import { getModel } from '../../specs/models';
@@ -57,7 +57,7 @@ const idOf = (ref) => {
 };
 /**
  * The component a layout names (LOOP C-13), from the catalogs of the enabled
- * UI plugins, by the name a surface gives it.
+ * UI specs, by the name a surface gives it.
  */
 export const componentNamed = (name) => getComponent(name);
 const own = (record, key) => Object.prototype.hasOwnProperty.call(record, key) ? record[key] : undefined;

package/lib/apps/apps/customComponents.js

@@ -16,7 +16,7 @@
  *
  * @module apps/apps/customComponents
  */
-import { getComponent } from '../../specs/uiPlugins';
+import { getComponent } from '../../specs/ui';
 /** Its name: a word starting with a capital letter, as the catalog's are named. */
 export const CUSTOM_COMPONENT_NAME = /^[A-Z][A-Za-z0-9]{0,63}$/;
 /** What one of its properties may be typed: what the renderer tells apart. */

package/lib/apps/core/canvasBlocks.d.ts

@@ -1,7 +1,7 @@
 import type { ComponentSpec } from '../../types/agentspecs';
 /**
  * A block the Canvas may place (LOOP C-12): one component of the catalog of
- * visual components (C-13), contributed by the plugin of the UI plugin that
+ * visual components (C-13), contributed by the plugin of the UI that
  * renders it. The Canvas's palette is what the enabled plugins contribute
  * here, and nothing else: a plugin disabled takes its blocks off it, and an
  * application that uses one of them says so in its setup notes.
@@ -9,8 +9,8 @@ import type { ComponentSpec } from '../../types/agentspecs';
 export type CanvasBlockContribution = {
     /** The name a surface gives it, the component's id (e.g. 'Table'). */
     id: string;
-    /** The UI plugin of the catalogue that renders it (e.g. 'a2ui'). */
-    uiPlugin: string;
+    /** The UI of the catalogue that renders it (e.g. 'a2ui'). */
+    ui: string;
     component: ComponentSpec;
 };
 export declare const LoopCanvasBlock: import("@datalayer/reactor").ContributionPoint<CanvasBlockContribution>;

package/lib/apps/core/canvasParts.d.ts

@@ -1,8 +1,10 @@
 /** The kinds of part an agent is built from on the Canvas. */
-export type CanvasPartKind = 'connection' | 'rule' | 'skill' | 'test' | 'event' | 'model';
+export type CanvasPartKind = 'connection' | 'rule' | 'skill' | 'test' | 'event' | 'model' | 'protocol' | 'ui' | 'character';
 /**
  * A part of an agent the Canvas may place (LOOP C-20): a connection to a
- * server of the catalogue, a skill, a model, a rule, a test, an event —
+ * server of the catalogue, a skill, a model, a rule, a test, an event, a
+ * protocol it speaks, a UI its answers render in, the character it shows
+ * (AGENT_PROTOCOLS PS-04, PS-05) —
  * contributed by the plugin of what it comes from. The toolbox is what the
  * enabled plugins contribute here, and nothing else: a plugin disabled takes
  * its parts off it, as it takes its blocks off the palette.
@@ -18,8 +20,8 @@ export type CanvasPartContribution = {
     emoji?: string;
     /**
      * What it arrives with, spelled as the Appspec's text spells it: a
-     * connection's, a rule's, a test's or an event's object, a skill's or a
-     * model's id. Every example is one the Appspec's schema takes as it is.
+     * connection's, a rule's, a test's or an event's object, a skill's, a
+     * model's, a protocol's, a UI's or a character's id. Every example is one the Appspec's schema takes as it is.
      */
     example: unknown;
     /** Whether what it names is enabled today; a part that is not is offered, and its application's setup notes say so. */

package/lib/apps/embed/AppEmbed.js

@@ -157,18 +157,14 @@ export function useWindowPort({ serverUrl, embedToken, session, host, }) {
             if (!uid.current) {
                 throw new Error(WINDOW_NOT_YET);
             }
-            const said = await postWindowMessage({
+            // What its code answers comes on the ui socket, raised as any
+            // window message is (REACTOR_UI RU-W).
+            await postWindowMessage({
                 serverUrl,
                 uid: uid.current,
                 ...(embedToken ? { token: embedToken } : {}),
                 data,
             });
-            for (const answer of said) {
-                hostRef.current?.onEvent?.({
-                    type: 'window-message',
-                    detail: { data: answer },
-                });
-            }
         });
         return () => port(null);
     }, [serverUrl, embedToken, host]);

package/lib/apps/embed/embedSession.d.ts

@@ -51,7 +51,9 @@ export declare function forgetSessionsInMemory(): void;
 /**
  * A session's conversation as the chat draws it, from the AG-UI messages
  * the runtime says (`GET …/sessions/{uid}/messages`): what was said and
- * answered, in words. A page an answer drew is not drawn again here.
+ * answered, in words. What its messages showed comes on the conversation's
+ * ui socket once the chat opens it (REACTOR_UI RU-W), never here: a
+ * `reactor.ui` activity in a thread is refused.
  */
 export declare function messagesOfThread(messages: unknown): ChatMessage[];
 /** What asking for a kept session found. */
@@ -79,8 +81,10 @@ export declare function reattachSession({ serverUrl, uid, token, fetcher, }: {
 export declare const WINDOW_NOT_YET = "The application takes a window message once its conversation has started, on its own server (the \"server\" attribute).";
 /**
  * Post a window message to a session (LOOP P-25): its code's `@app.window`
- * runs on it. Returns what the code told the page back; refused — the
- * runtime's sentence — when the session or its code takes none.
+ * runs on it. What the code tells the page back arrives on the
+ * conversation's ui socket (REACTOR_UI RU-W), raised as any window message
+ * is; refused — the runtime's sentence — when the session or its code takes
+ * none.
  */
 export declare function postWindowMessage({ serverUrl, uid, token, data, fetcher, }: {
     serverUrl: string;
@@ -88,6 +92,6 @@ export declare function postWindowMessage({ serverUrl, uid, token, data, fetcher
     token?: string;
     data: unknown;
     fetcher?: typeof fetch;
-}): Promise<unknown[]>;
+}): Promise<void>;
 /** What the page says, once, when the conversation it kept is gone. */
 export declare const sessionGoneSentence: (name: string) => string;

package/lib/apps/embed/embedSession.js

@@ -2,7 +2,8 @@
  * Copyright (c) 2025-2026 Datalayer, Inc.
  * Distributed under the terms of the Modified BSD License.
  */
-import { windowTurnOf } from '../../chat/base/loopWindow';
+import { windowTurnErrorOf } from '../../chat/base/loopWindow';
+import { AGUI_NAME } from '@datalayer/reactor/ui';
 /** Where a visit's session is kept in the host's storage: `<prefix>:<app>:<visit>`. */
 export const EMBED_SESSION_KEY_PREFIX = 'datalayer-app:session';
 /**
@@ -93,7 +94,9 @@ export function forgetSessionsInMemory() {
 /**
  * A session's conversation as the chat draws it, from the AG-UI messages
  * the runtime says (`GET …/sessions/{uid}/messages`): what was said and
- * answered, in words. A page an answer drew is not drawn again here.
+ * answered, in words. What its messages showed comes on the conversation's
+ * ui socket once the chat opens it (REACTOR_UI RU-W), never here: a
+ * `reactor.ui` activity in a thread is refused.
  */
 export function messagesOfThread(messages) {
     if (!Array.isArray(messages)) {
@@ -104,7 +107,10 @@ export function messagesOfThread(messages) {
         if (!message || typeof message !== 'object') {
             continue;
         }
-        const { id, role, content } = message;
+        const { id, role, content, activityType } = message;
+        if (role === 'activity' && activityType === AGUI_NAME) {
+            throw new Error(`Activity ${String(id)}: what a message showed comes on the ui socket (REACTOR_UI RU-W)`);
+        }
         if ((role === 'user' || role === 'assistant') &&
             typeof id === 'string' &&
             typeof content === 'string' &&
@@ -137,8 +143,10 @@ export async function reattachSession({ serverUrl, uid, token, fetcher = fetch,
 export const WINDOW_NOT_YET = 'The application takes a window message once its conversation has started, on its own server (the "server" attribute).';
 /**
  * Post a window message to a session (LOOP P-25): its code's `@app.window`
- * runs on it. Returns what the code told the page back; refused — the
- * runtime's sentence — when the session or its code takes none.
+ * runs on it. What the code tells the page back arrives on the
+ * conversation's ui socket (REACTOR_UI RU-W), raised as any window message
+ * is; refused — the runtime's sentence — when the session or its code takes
+ * none.
  */
 export async function postWindowMessage({ serverUrl, uid, token, data, fetcher = fetch, }) {
     const response = await fetcher(`${serverUrl.replace(/\/+$/, '')}/api/v1/apps/sessions/${encodeURIComponent(uid)}/window`, {
@@ -160,11 +168,10 @@ export async function postWindowMessage({ serverUrl, uid, token, data, fetcher =
         }
         throw new Error(detail || `The window message was refused (${response.status}).`);
     }
-    const turn = windowTurnOf(await response.text());
-    if (turn.error) {
-        throw new Error(turn.error);
+    const error = windowTurnErrorOf(await response.text());
+    if (error) {
+        throw new Error(error);
     }
-    return turn.said;
 }
 /** What the page says, once, when the conversation it kept is gone. */
 export const sessionGoneSentence = (name) => `Your earlier conversation with ${name} has ended, so this is a new one.`;

package/lib/apps/plugins/a2ui-surface/AnswerShows.d.ts

@@ -0,0 +1,21 @@
+/**
+ * What an application's answer shows, drawn from its display (LOOP P-04,
+ * REACTOR_UI RU-2): the A2UI surface in its data, and its buttons pressing
+ * only the actions the display offered, each with the token the session
+ * minted for it. The answer under its message and an element in a panel or
+ * a page of its own are drawn by this one view.
+ *
+ * @module apps/plugins/a2ui-surface/AnswerShows
+ */
+import type { JSX } from 'react';
+import type { Display } from '@datalayer/reactor/ui';
+export type AnswerShowsViewProps = {
+    display: Display;
+    /**
+     * Say something as the reader, with what goes with the run besides it;
+     * `false` when the chat cannot take it.
+     */
+    send: (message: string, forwardedProps?: Record<string, unknown>) => boolean;
+};
+export declare function AnswerShowsView({ display, send, }: AnswerShowsViewProps): JSX.Element;
+export default AnswerShowsView;

package/lib/apps/plugins/a2ui-surface/AnswerShows.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo, useState } from 'react';
+import { Text } from '@primer/react';
+import { InlineSurface, SURFACE_CATALOG_ID } from './InlineSurface';
+import { useOwnCatalog } from './ownComponents';
+import { answerPress, answerSurface } from './toolResult';
+export function AnswerShowsView({ display, send, }) {
+    const parsed = useMemo(() => answerSurface(display, SURFACE_CATALOG_ID), [display]);
+    // With the components the application's developer wrote (LOOP P-17).
+    const catalog = useOwnCatalog();
+    const [said, setSaid] = useState(null);
+    if (!parsed?.messages || parsed.messages.length === 0) {
+        return _jsx(Text, { sx: { color: 'fg.muted' }, children: display.text });
+    }
+    const onAction = (action) => {
+        const pressed = answerPress(display, action);
+        if ('refused' in pressed) {
+            setSaid(pressed.refused);
+            return;
+        }
+        setSaid(send(pressed.message, pressed.forwardedProps)
+            ? null
+            : 'The chat is not ready to take it yet.');
+    };
+    return (_jsx(InlineSurface
+    // Drawn again whole when the code changes it.
+    , { messages: parsed.messages, onAction: onAction, validationError: said, catalog: catalog }, JSON.stringify(display)));
+}
+export default AnswerShowsView;

package/lib/apps/plugins/a2ui-surface/SurfaceToolResult.js

@@ -5,7 +5,7 @@ import { Box } from '@datalayer/primer-addons';
 import { encodeFormSubmission } from '../../../chat/messages/formSubmission';
 import { InlineSurface, SURFACE_CATALOG_ID } from './InlineSurface';
 import { useOwnCatalog } from './ownComponents';
-import { answerAction, readA2uiToolResult, validateA2uiSubmission, } from './toolResult';
+import { readA2uiToolResult, validateA2uiSubmission, } from './toolResult';
 export function SurfaceToolResult({ context, send, onRendered, onSubmitted, }) {
     const parsed = useMemo(() => context.status === 'complete'
         ? readA2uiToolResult(context.result, SURFACE_CATALOG_ID)
@@ -30,12 +30,9 @@ export function SurfaceToolResult({ context, send, onRendered, onSubmitted, }) {
     }, [parsed, context.toolCallId]);
     const handleAction = useCallback((action) => {
         if (action.name !== 'submit_a2ui_form') {
-            // A button of what an application's answer shows: its action goes to
-            // the application, as a button of its page does (LOOP P-04).
-            const pressed = answerAction(action);
-            if (pressed && !send(pressed.message, pressed.forwardedProps)) {
-                setValidationError('The chat is not ready to take it yet.');
-            }
+            // A tool's surface submits its form, and nothing else: the buttons
+            // of what an application's answer shows are its display's
+            // (`AnswerShowsView`, REACTOR_UI RU-2).
             return;
         }
         const values = (action.context ?? {});

package/lib/apps/plugins/a2ui-surface/index.d.ts

@@ -32,5 +32,6 @@ export declare function createA2uiSurfacePlugin(options?: A2uiSurfacePluginOptio
 /** The instance the preset mounts: no host callbacks. */
 export declare const A2uiSurfacePlugin: ReactorPlugin<Record<string, never>, unknown, unknown>;
 export type { SurfaceRendered, SurfaceSubmitted } from './SurfaceToolResult';
-export { answerAction, readA2uiToolResult, validateA2uiField, validateA2uiSubmission, type A2uiFieldRule, type A2uiToolResult, } from './toolResult';
+export { AnswerShowsView } from './AnswerShows';
+export { ANSWER_DISPLAY_TYPE, answerPress, answerSurface, readA2uiToolResult, validateA2uiField, validateA2uiSubmission, type A2uiFieldRule, type A2uiToolResult, type AnswerPress, } from './toolResult';
 export default A2uiSurfacePlugin;

package/lib/apps/plugins/a2ui-surface/index.js

@@ -5,6 +5,8 @@ import { Renderers, ToolBindings } from '@datalayer/reactor/ui';
 import { defineRenderer, } from '@datalayer/reactor/ui/react';
 import { AGENTSPECS } from '../../../specs/agents';
 import { LoopSlots } from '../../core';
+import { AnswerShowsView } from './AnswerShows';
+import { ANSWER_DISPLAY_TYPE } from './toolResult';
 import { SurfaceToolResult, } from './SurfaceToolResult';
 export const A2UI_SURFACE_PLUGIN_NAME = '@datalayer/loop-plugin-a2ui-surface';
 /** The renderer name a spec binds a tool to. */
@@ -74,6 +76,11 @@ export function createA2uiSurfacePlugin(options = {}) {
         }
         return (_jsx(SurfaceToolResult, { context: context, send: send, onRendered: options.onRendered, onSubmitted: options.onSubmitted }, context.toolCallId));
     }
+    // What an application's answer shows (REACTOR_UI RU-2): its buttons press
+    // what the display offered, through the workspace's chat.
+    function Answer({ display }) {
+        return _jsx(AnswerShowsView, { display: display, send: send });
+    }
     const plugin = definePlugin({
         name: counter === 1
             ? A2UI_SURFACE_PLUGIN_NAME
@@ -89,6 +96,7 @@ export function createA2uiSurfacePlugin(options = {}) {
                 // A host's own instance, with its callbacks, over the preset's.
                 rank: options.onRendered || options.onSubmitted ? 1 : 0,
             }), { id }),
+            contribution(Renderers, defineRenderer({ type: ANSWER_DISPLAY_TYPE, component: Answer }), { id: `${id}:answer` }),
             ...[...surfaceToolNames()].map(tool => contribution(ToolBindings, { tool, type: A2UI_SURFACE_TYPE }, { id: `${id}:${tool}` })),
         ],
         build() {
@@ -103,5 +111,6 @@ export function createA2uiSurfacePlugin(options = {}) {
 }
 /** The instance the preset mounts: no host callbacks. */
 export const A2uiSurfacePlugin = createA2uiSurfacePlugin();
-export { answerAction, readA2uiToolResult, validateA2uiField, validateA2uiSubmission, } from './toolResult';
+export { AnswerShowsView } from './AnswerShows';
+export { ANSWER_DISPLAY_TYPE, answerPress, answerSurface, readA2uiToolResult, validateA2uiField, validateA2uiSubmission, } from './toolResult';
 export default A2uiSurfacePlugin;

package/lib/apps/plugins/a2ui-surface/toolResult.d.ts

@@ -8,6 +8,7 @@
  * @module apps/plugins/a2ui-surface/toolResult
  */
 import type { A2uiMessage } from '@a2ui/web_core/v0_9';
+import type { Display } from '@datalayer/reactor/ui';
 export type A2uiRequiredField = {
     id: string;
     label: string;
@@ -50,10 +51,13 @@ export declare function isEmptyA2uiValue(value: unknown): boolean;
 export declare function validateA2uiField(rule: A2uiFieldRule, value: unknown): string | null;
 /** Every rule's complaint about a submission; empty when it passes. */
 export declare function validateA2uiSubmission(rules: A2uiFieldRule[], values: Record<string, unknown>): string[];
-/** Where the surface of what an application's answer shows is named (LOOP P-04). */
-export declare const ANSWER_SURFACE_PREFIX = "answer-";
-/** A button pressed on an answer's surface, as the chat sends it on. */
-export type AnswerAction = {
+/**
+ * The display type of what an application's answer shows (LOOP P-04,
+ * REACTOR_UI RU-2): `AnswerShows` in `agent_runtimes.loop.apps.components`.
+ */
+export declare const ANSWER_DISPLAY_TYPE = "application/vnd.datalayer.loop.answer+json";
+/** A button pressed on what an answer shows, as the chat sends it on. */
+export type AnswerPress = {
     /** The person's turn, in words: the action's name. */
     message: string;
     /** What the session API reads besides the message (`forwardedProps.loop`). */
@@ -61,19 +65,24 @@ export type AnswerAction = {
         loop: {
             action: {
                 name: string;
+                display_id: string;
+                token: string;
                 payload: Record<string, unknown>;
             };
         };
     };
 };
+/** The A2UI surface an answer's display draws, or `null` for a display that has none. */
+export declare function answerSurface(display: Display, catalogId: string): A2uiToolResult | null;
 /**
- * What a button pressed on the surface an application's answer shows sends:
- * its action, by name, with what it read — the application's code reacts
- * with its `@app.action(name)`, as to a button of its page. `null` for any
- * other surface, whose buttons stay the agent's form submission.
+ * What a button pressed on what an answer shows sends: the action the
+ * display offered under that name, with its token and what the button read
+ * — the application's code reacts with its `@app.action(name)`. A button
+ * whose action the display did not offer sends nothing: the sentence why.
  */
-export declare function answerAction(action: {
+export declare function answerPress(display: Display, action: {
     name: string;
-    surfaceId: string;
     context?: Record<string, unknown>;
-}): AnswerAction | null;
+}): AnswerPress | {
+    refused: string;
+};

package/lib/apps/plugins/a2ui-surface/toolResult.js

@@ -104,24 +104,40 @@ export function validateA2uiSubmission(rules, values) {
         .map(rule => validateA2uiField(rule, values[rule.id]))
         .filter((message) => message !== null);
 }
-/** Where the surface of what an application's answer shows is named (LOOP P-04). */
-export const ANSWER_SURFACE_PREFIX = 'answer-';
 /**
- * What a button pressed on the surface an application's answer shows sends:
- * its action, by name, with what it read — the application's code reacts
- * with its `@app.action(name)`, as to a button of its page. `null` for any
- * other surface, whose buttons stay the agent's form submission.
+ * The display type of what an application's answer shows (LOOP P-04,
+ * REACTOR_UI RU-2): `AnswerShows` in `agent_runtimes.loop.apps.components`.
  */
-export function answerAction(action) {
-    if (!action.surfaceId.startsWith(ANSWER_SURFACE_PREFIX) ||
-        !action.name.trim()) {
+export const ANSWER_DISPLAY_TYPE = 'application/vnd.datalayer.loop.answer+json';
+/** The A2UI surface an answer's display draws, or `null` for a display that has none. */
+export function answerSurface(display, catalogId) {
+    if (display.type !== ANSWER_DISPLAY_TYPE) {
         return null;
     }
+    return readA2uiToolResult(display.data?.surface, catalogId);
+}
+/**
+ * What a button pressed on what an answer shows sends: the action the
+ * display offered under that name, with its token and what the button read
+ * — the application's code reacts with its `@app.action(name)`. A button
+ * whose action the display did not offer sends nothing: the sentence why.
+ */
+export function answerPress(display, action) {
+    const name = action.name.trim();
+    const offer = (display.actions ?? []).find(one => one.name === name);
+    if (!offer) {
+        return { refused: `“${name || 'This button'}” was not offered here.` };
+    }
     return {
-        message: action.name.trim(),
+        message: name,
         forwardedProps: {
             loop: {
-                action: { name: action.name.trim(), payload: { ...action.context } },
+                action: {
+                    name,
+                    display_id: display.id,
+                    token: offer.token,
+                    payload: { ...action.context },
+                },
             },
         },
     };

package/lib/apps/plugins/app-components/index.d.ts

@@ -1,7 +1,7 @@
 /**
  * `app-components` — the components an application's developer wrote (LOOP
  * P-17), registered as that application's A2UI contributions: each a block
- * of its Canvas's palette (`loop.canvas.block`, as a UI plugin's components
+ * of its Canvas's palette (`loop.canvas.block`, as a UI's components
  * are) and a renderer of the catalog its page, its elements and its answers
  * are drawn with (`loop.a2ui.component`). One plugin per application, in its
  * workspace's preset only: the catalog grows for it, it does not open.

package/lib/apps/plugins/app-components/index.js

@@ -5,7 +5,7 @@
 /**
  * `app-components` — the components an application's developer wrote (LOOP
  * P-17), registered as that application's A2UI contributions: each a block
- * of its Canvas's palette (`loop.canvas.block`, as a UI plugin's components
+ * of its Canvas's palette (`loop.canvas.block`, as a UI's components
  * are) and a renderer of the catalog its page, its elements and its answers
  * are drawn with (`loop.a2ui.component`). One plugin per application, in its
  * workspace's preset only: the catalog grows for it, it does not open.
@@ -43,7 +43,7 @@ export function defineAppComponentsPlugin(app, fetcher) {
         contributes: own.flatMap(component => [
             contribution(LoopCanvasBlock, {
                 id: component.name,
-                uiPlugin: `app:${app.id}`,
+                ui: `app:${app.id}`,
                 component: customComponentEntry(component, app.version),
             }, { id: component.name }),
             contribution(LoopA2uiComponent, {

package/lib/apps/plugins/app-elements/AppElements.d.ts

@@ -1,9 +1,9 @@
 /**
  * The elements an application's code opened beside the conversation (LOOP
  * P-18): a side panel on the trailing edge, and a page of its own over the
- * workspace — each drawn from the same A2UI surface an answer is drawn from
- * (`InlineSurface`), its buttons sent to the application's actions as an
- * answer's are (`answerAction`), and closed with its own button.
+ * workspace — each drawn from its display as an answer is (`AnswerShowsView`),
+ * its buttons pressing the actions the display offered, and closed with its
+ * own button.
  *
  * Drawn from the workspace's root slot, positioned against the workspace:
  * nothing is drawn, and nothing is laid out, while nothing is open.