@datalayer/agent-runtimes 1.3.114 → 1.5.0

package/lib/chat/base/loopWindow.js

@@ -6,21 +6,25 @@
  * Window messages (LOOP P-25): what an application's code tells the page it
  * sits in, outside the conversation — ``session.send_window_message(data)``.
  *
- * The session API says it with a `CUSTOM` event named `loop.window` —
- * `{data}` — which the AG-UI adapter hands on as an `activity`. The chat
- * does not draw it: it hands it to whoever listens here — the embed's host
- * bridge, which raises it on the element as its `window-message` event.
+ * The session says it with a `reactor.ui` `window` op named `message`, its
+ * `args` `{data}` (REACTOR_UI RU-3), on the conversation's ui socket (RU-W). The chat does not draw it: it hands
+ * it to whoever listens here — the embed's host bridge, which raises it on
+ * the element as its `window-message` event. A window op of another name is
+ * not one this page acts on: refused, it throws.
  */
-/** The `CUSTOM` event's name. */
-export const LOOP_WINDOW = 'loop.window';
-/** What an activity says to the page, or `null` when it is not a window message. */
-export function loopWindowMessage(activity) {
-    if (!activity || activity.type !== LOOP_WINDOW)
-        return null;
-    const said = activity.data;
-    if (!said || typeof said !== 'object' || !('data' in said))
-        return null;
-    return { data: said.data };
+import { AGUI_NAME } from '@datalayer/reactor/ui';
+/** The name of the window op that hands the page a message. */
+export const WINDOW_MESSAGE = 'message';
+/** What a window op hands the page. Throws for a window op of another name. */
+export function windowMessageOf(op) {
+    if (op.body.name !== WINDOW_MESSAGE) {
+        throw new Error(`A window op named ${op.body.name} is not one this page acts on`);
+    }
+    const args = op.body.args;
+    if (!args || !('data' in args)) {
+        throw new Error('A window message says no data');
+    }
+    return args.data;
 }
 const listeners = new Set();
 /** Hand a window message to whoever listens. */
@@ -36,12 +40,12 @@ export function onLoopWindowMessage(listener) {
     };
 }
 /**
- * What a turn's stream says to the page — the `loop.window` events of the
- * turn a window message posted by the page ran — and the sentence its
- * `RUN_ERROR` said, if it failed.
+ * Why the turn a window message posted by the page ran failed — its
+ * `RUN_ERROR`'s sentence — or `null`. What its code tells the page back comes
+ * on the conversation's ui socket (REACTOR_UI RU-W), never on this stream: a
+ * `reactor.ui` event here is refused.
  */
-export function windowTurnOf(stream) {
-    const said = [];
+export function windowTurnErrorOf(stream) {
     let error = null;
     for (const block of stream.split('\n\n')) {
         const data = block
@@ -61,14 +65,9 @@ export function windowTurnOf(stream) {
         if (event.type === 'RUN_ERROR') {
             error = String(event.message ?? 'The turn failed.');
         }
-        else if (event.type === 'CUSTOM') {
-            const message = loopWindowMessage({
-                type: String(event.name),
-                data: event.value,
-            });
-            if (message)
-                said.push(message.data);
+        else if (event.type === 'CUSTOM' && event.name === AGUI_NAME) {
+            throw new Error('A reactor.ui op came on the run stream: it comes over the ui socket.');
         }
     }
-    return { said, error };
+    return error;
 }

package/lib/chat/base/uiFiles.d.ts

@@ -0,0 +1,29 @@
+/**
+ * A conversation's files as references (REACTOR_UI RU-6).
+ *
+ * What the page holds of a file it was given — File upload and the composer
+ * read it as `{name, type, data_url}` — is uploaded to the application's
+ * runtime before the run that names it (Reactor's `uploadFile`), and the run
+ * carries the ref it answers (`forwardedProps.loop.files`): a file's bytes
+ * never ride in the run.
+ *
+ * @module chat/base/uiFiles
+ */
+import { type FileRef } from '@datalayer/reactor/ui';
+/** How a file is uploaded to the conversation: its ref. */
+export type UploadToConversation = (file: Blob & {
+    name: string;
+}) => Promise<FileRef>;
+/** A file's bytes from the data URL the page read it as. */
+export declare function blobOfDataUrl(dataUrl: string, name: string, type?: string): Blob & {
+    name: string;
+};
+/** Whether a run's `forwardedProps` names files. */
+export declare function namesFiles(forwardedProps: Record<string, unknown> | undefined): boolean;
+/**
+ * The run's `forwardedProps` with its files uploaded: each file the page
+ * holds replaced by the ref its upload answered, a ref kept as it is.
+ *
+ * @throws for a file that is neither, or an upload refused (its sentence).
+ */
+export declare function withUploadedFiles(forwardedProps: Record<string, unknown>, upload: UploadToConversation): Promise<Record<string, unknown>>;

package/lib/chat/base/uiFiles.js

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * A conversation's files as references (REACTOR_UI RU-6).
+ *
+ * What the page holds of a file it was given — File upload and the composer
+ * read it as `{name, type, data_url}` — is uploaded to the application's
+ * runtime before the run that names it (Reactor's `uploadFile`), and the run
+ * carries the ref it answers (`forwardedProps.loop.files`): a file's bytes
+ * never ride in the run.
+ *
+ * @module chat/base/uiFiles
+ */
+import { isFileRef } from '@datalayer/reactor/ui';
+/** A file's bytes from the data URL the page read it as. */
+export function blobOfDataUrl(dataUrl, name, type) {
+    const [head, body] = [
+        dataUrl.slice(0, dataUrl.indexOf(',')),
+        dataUrl.slice(dataUrl.indexOf(',') + 1),
+    ];
+    if (!head.startsWith('data:') || dataUrl.indexOf(',') < 0) {
+        throw new Error(`${name} could not be read: it is not a data URL.`);
+    }
+    const mediaType = type || head.slice('data:'.length).split(';')[0];
+    // Backed by an ArrayBuffer, as Blob takes it (a SharedArrayBuffer-backed view it refuses).
+    let bytes;
+    if (head.endsWith(';base64')) {
+        const binary = atob(body);
+        bytes = new Uint8Array(binary.length);
+        for (let index = 0; index < binary.length; index += 1) {
+            bytes[index] = binary.charCodeAt(index);
+        }
+    }
+    else {
+        bytes = new TextEncoder().encode(decodeURIComponent(body));
+    }
+    return Object.assign(new Blob([bytes], { type: mediaType }), { name });
+}
+/** Whether a run's `forwardedProps` names files. */
+export function namesFiles(forwardedProps) {
+    const files = forwardedProps?.loop
+        ?.files;
+    return Array.isArray(files) && files.length > 0;
+}
+/**
+ * The run's `forwardedProps` with its files uploaded: each file the page
+ * holds replaced by the ref its upload answered, a ref kept as it is.
+ *
+ * @throws for a file that is neither, or an upload refused (its sentence).
+ */
+export async function withUploadedFiles(forwardedProps, upload) {
+    const loop = forwardedProps.loop;
+    const files = loop.files;
+    const refs = [];
+    for (const given of files) {
+        if (isFileRef(given)) {
+            refs.push(given);
+            continue;
+        }
+        const held = given;
+        if (typeof held.name !== 'string' || typeof held.data_url !== 'string') {
+            throw new Error('A file given is neither the page’s nor a ref.');
+        }
+        refs.push(await upload(blobOfDataUrl(held.data_url, held.name, typeof held.type === 'string' ? held.type : undefined)));
+    }
+    return { ...forwardedProps, loop: { ...loop, files: refs } };
+}

package/lib/chat/base/uiOps.d.ts

@@ -0,0 +1,96 @@
+/**
+ * What a server says to a conversation's page, as `reactor.ui` ops
+ * (REACTOR_UI RU-2, RU-3), and what the page presses back (RU-W).
+ *
+ * The ops arrive on the conversation's ui socket (Reactor's `UiSocket`,
+ * one per session, beside the run stream that carries the conversation's
+ * text); `routeUiOp` says where each goes:
+ *
+ * - a `window` op to the page the conversation sits in (`loopWindow`);
+ * - a step's display to its row (`loopStep`), patched as it streams;
+ * - a display that says it shows in a panel or on a page to the elements
+ *   open (`loopElement`), a `remove` of its id closing it;
+ * - everything else to the messages (`withUiOp`): a display under a message
+ *   (`data.message_id`) kept on it (`ChatMessage.displays`) and drawn by the
+ *   renderer a plugin contributed for its type; a `meta` op's `author` the
+ *   message's voice; a `remove` of a message's id the message gone.
+ *
+ * An op about a message that has not arrived on the run stream yet — the
+ * two are separate connections — waits until it has (`placeable`). A press
+ * of what a display offered goes up the socket (`displayPressOf`), and the
+ * run that answers it names it only (`withPress`).
+ *
+ * Pure: the chat applies it to what it draws, and to its store. Nothing it
+ * was not told to expect is guessed at: an op it cannot place throws.
+ *
+ * @module chat/base/uiOps
+ */
+import { type Display, type UiAction, type UiModel, type UiOp } from '@datalayer/reactor/ui';
+import type { MessageSpeaker } from '../../types/messages';
+import { type LoopElementChange } from './loopElement';
+import { type LoopStep } from './loopStep';
+/** The message a display is under: its `data.message_id`. */
+export declare function messageOfDisplay(display: Display): string;
+/** Who a message is by, as the chat draws a named voice. */
+export declare function speakerOf(author: string): MessageSpeaker;
+type WithDisplays = {
+    id?: string;
+    displays?: Display[];
+    speaker?: MessageSpeaker;
+};
+/**
+ * The messages with an op applied: a display shown (or asked) kept on its
+ * message, replacing one of its id; patched, appended to or removed where it
+ * is. A `remove` of a message's own id takes the message away, with what it
+ * showed; a `meta` op about a message gives it its `author`. `state` ops are
+ * not about the messages: they come back as they were.
+ *
+ * Throws for a display under no message here, for a change to a display no
+ * message shows, for a removal of nothing here, and for a `meta` op that
+ * says anything but a message's author: the server said something the page
+ * never saw, or does not read.
+ */
+export declare function withUiOp<T extends WithDisplays>(items: T[], op: UiOp): T[];
+/** Where an op goes (`routeUiOp`). */
+export type RoutedUiOp = {
+    to: 'window';
+    data: unknown;
+} | {
+    to: 'step';
+    step: LoopStep;
+} | {
+    to: 'element';
+    change: LoopElementChange;
+} | {
+    to: 'messages';
+    op: UiOp;
+};
+/**
+ * Where an op goes, and the steps kept after it: a step's display is kept
+ * (in a Reactor `UiModel`) so a patch of its output applies to it.
+ *
+ * `elements` is the ids of the elements shown in this conversation: a
+ * `remove` of one closes it (a no-op when the person closed it already).
+ */
+export declare function routeUiOp(op: UiOp, steps: UiModel, elements: ReadonlySet<string>): {
+    routed: RoutedUiOp;
+    steps: UiModel;
+};
+/**
+ * Whether the messages hold what an op is about: the message a display is
+ * under, the message a `meta` op names, the display a change is to, what a
+ * `remove` takes away. An op about what has not arrived yet waits.
+ */
+export declare function placeable<T extends WithDisplays>(items: readonly T[], op: UiOp): boolean;
+/**
+ * The press a run's `forwardedProps` carries for a display's button — what
+ * `AnswerShowsView` hands the chat — or `null` for a run that presses
+ * nothing of a display's. It goes up the ui socket, never in the run.
+ */
+export declare function displayPressOf(forwardedProps: Record<string, unknown> | undefined): UiAction | null;
+/**
+ * The run's `forwardedProps` once its press was checked on the socket: the
+ * press named by the id the runtime answered, the action itself gone.
+ */
+export declare function withPress(forwardedProps: Record<string, unknown>, answered: unknown): Record<string, unknown>;
+export {};

package/lib/chat/base/uiOps.js

@@ -0,0 +1,251 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * What a server says to a conversation's page, as `reactor.ui` ops
+ * (REACTOR_UI RU-2, RU-3), and what the page presses back (RU-W).
+ *
+ * The ops arrive on the conversation's ui socket (Reactor's `UiSocket`,
+ * one per session, beside the run stream that carries the conversation's
+ * text); `routeUiOp` says where each goes:
+ *
+ * - a `window` op to the page the conversation sits in (`loopWindow`);
+ * - a step's display to its row (`loopStep`), patched as it streams;
+ * - a display that says it shows in a panel or on a page to the elements
+ *   open (`loopElement`), a `remove` of its id closing it;
+ * - everything else to the messages (`withUiOp`): a display under a message
+ *   (`data.message_id`) kept on it (`ChatMessage.displays`) and drawn by the
+ *   renderer a plugin contributed for its type; a `meta` op's `author` the
+ *   message's voice; a `remove` of a message's id the message gone.
+ *
+ * An op about a message that has not arrived on the run stream yet — the
+ * two are separate connections — waits until it has (`placeable`). A press
+ * of what a display offered goes up the socket (`displayPressOf`), and the
+ * run that answers it names it only (`withPress`).
+ *
+ * Pure: the chat applies it to what it draws, and to its store. Nothing it
+ * was not told to expect is guessed at: an op it cannot place throws.
+ *
+ * @module chat/base/uiOps
+ */
+import { applyPatch, applyUiOp, } from '@datalayer/reactor/ui';
+import { elementOfDisplay } from './loopElement';
+import { isStepDisplay, stepOfDisplay } from './loopStep';
+import { windowMessageOf } from './loopWindow';
+/** The message a display is under: its `data.message_id`. */
+export function messageOfDisplay(display) {
+    const id = display.data?.message_id;
+    if (typeof id !== 'string' || !id) {
+        throw new Error(`Display ${display.id} says no message it is under`);
+    }
+    return id;
+}
+/** Who a message is by, as the chat draws a named voice. */
+export function speakerOf(author) {
+    return { id: `author:${author}`, name: author };
+}
+/** The messages with one display changed by `change`, or taken away when it answers nothing. */
+function changed(items, id, change) {
+    const at = items.findIndex(item => (item.displays ?? []).some(display => display.id === id));
+    if (at < 0) {
+        throw new Error(`Display ${id} is shown under no message here`);
+    }
+    return items.map((item, index) => {
+        if (index !== at)
+            return item;
+        const displays = [];
+        for (const display of item.displays ?? []) {
+            if (display.id !== id) {
+                displays.push(display);
+                continue;
+            }
+            const next = change(display);
+            if (next)
+                displays.push({ ...next, id });
+        }
+        return { ...item, displays };
+    });
+}
+function replaced(displays, display) {
+    const at = displays.findIndex(one => one.id === display.id);
+    return at < 0
+        ? [...displays, display]
+        : displays.map((one, index) => (index === at ? display : one));
+}
+/**
+ * The messages with an op applied: a display shown (or asked) kept on its
+ * message, replacing one of its id; patched, appended to or removed where it
+ * is. A `remove` of a message's own id takes the message away, with what it
+ * showed; a `meta` op about a message gives it its `author`. `state` ops are
+ * not about the messages: they come back as they were.
+ *
+ * Throws for a display under no message here, for a change to a display no
+ * message shows, for a removal of nothing here, and for a `meta` op that
+ * says anything but a message's author: the server said something the page
+ * never saw, or does not read.
+ */
+export function withUiOp(items, op) {
+    switch (op.op) {
+        case 'show':
+        case 'ask': {
+            const shown = op.body;
+            const messageId = messageOfDisplay(shown);
+            if (!items.some(item => item.id === messageId)) {
+                throw new Error(`Display ${shown.id} is under message ${messageId}, which is not here`);
+            }
+            return items.map(item => item.id === messageId
+                ? { ...item, displays: replaced(item.displays ?? [], shown) }
+                : item);
+        }
+        case 'remove': {
+            const showsIt = items.some(item => (item.displays ?? []).some(display => display.id === op.id));
+            if (showsIt)
+                return changed(items, op.id, () => undefined);
+            if (!items.some(item => item.id === op.id)) {
+                throw new Error(`Nothing here is ${op.id}: it cannot be removed`);
+            }
+            return items.filter(item => item.id !== op.id);
+        }
+        case 'patch': {
+            const operations = op.body;
+            return changed(items, op.id, display => applyPatch(display, operations));
+        }
+        case 'append': {
+            const { path, value } = op.body;
+            return changed(items, op.id, display => applyPatch(display, [{ op: 'add', path: `${path}/-`, value }]));
+        }
+        case 'meta': {
+            const author = op.body.author;
+            const keys = Object.keys(op.body);
+            if (!op.id ||
+                keys.length !== 1 ||
+                typeof author !== 'string' ||
+                !author.trim()) {
+                throw new Error(`A meta op says ${JSON.stringify(op.body)}: only a message's author is read`);
+            }
+            if (!items.some(item => item.id === op.id)) {
+                throw new Error(`Message ${op.id} is not here: it has no author to say`);
+            }
+            return items.map(item => item.id === op.id
+                ? { ...item, speaker: speakerOf(author.trim()) }
+                : item);
+        }
+        case 'window':
+            throw new Error('A window op is for the page, not the messages');
+        default:
+            return items;
+    }
+}
+/**
+ * Where an op goes, and the steps kept after it: a step's display is kept
+ * (in a Reactor `UiModel`) so a patch of its output applies to it.
+ *
+ * `elements` is the ids of the elements shown in this conversation: a
+ * `remove` of one closes it (a no-op when the person closed it already).
+ */
+export function routeUiOp(op, steps, elements) {
+    switch (op.op) {
+        case 'window':
+            return { routed: { to: 'window', data: windowMessageOf(op) }, steps };
+        case 'show':
+        case 'ask': {
+            if (isStepDisplay(op.body)) {
+                const kept = applyUiOp(steps, op);
+                return {
+                    routed: { to: 'step', step: stepOfDisplay(op.body) },
+                    steps: kept,
+                };
+            }
+            const element = elementOfDisplay(op.body);
+            if (element) {
+                return { routed: { to: 'element', change: element }, steps };
+            }
+            return { routed: { to: 'messages', op }, steps };
+        }
+        case 'patch':
+        case 'append': {
+            if (op.id in steps.displays) {
+                const kept = applyUiOp(steps, op);
+                return {
+                    routed: { to: 'step', step: stepOfDisplay(kept.displays[op.id]) },
+                    steps: kept,
+                };
+            }
+            return { routed: { to: 'messages', op }, steps };
+        }
+        case 'remove': {
+            if (op.id in steps.displays) {
+                throw new Error(`Step ${op.id} is never removed: it ends`);
+            }
+            if (elements.has(op.id)) {
+                return {
+                    routed: { to: 'element', change: { id: op.id, closed: true } },
+                    steps,
+                };
+            }
+            return { routed: { to: 'messages', op }, steps };
+        }
+        default:
+            return { routed: { to: 'messages', op }, steps };
+    }
+}
+/**
+ * Whether the messages hold what an op is about: the message a display is
+ * under, the message a `meta` op names, the display a change is to, what a
+ * `remove` takes away. An op about what has not arrived yet waits.
+ */
+export function placeable(items, op) {
+    const hasItem = (id) => !!id && items.some(item => item.id === id);
+    const hasDisplay = (id) => !!id &&
+        items.some(item => (item.displays ?? []).some(display => display.id === id));
+    switch (op.op) {
+        case 'show':
+        case 'ask': {
+            const under = op.body.data?.message_id;
+            return typeof under === 'string' && hasItem(under);
+        }
+        case 'meta':
+            return hasItem(op.id);
+        case 'patch':
+        case 'append':
+            return hasDisplay(op.id);
+        case 'remove':
+            return hasDisplay(op.id) || hasItem(op.id);
+        default:
+            return true;
+    }
+}
+/**
+ * The press a run's `forwardedProps` carries for a display's button — what
+ * `AnswerShowsView` hands the chat — or `null` for a run that presses
+ * nothing of a display's. It goes up the ui socket, never in the run.
+ */
+export function displayPressOf(forwardedProps) {
+    const loop = forwardedProps?.loop;
+    const action = loop?.action;
+    if (!action || typeof action.display_id !== 'string')
+        return null;
+    if (typeof action.name !== 'string' || typeof action.token !== 'string') {
+        throw new Error('A press of a display says its action and its token');
+    }
+    return {
+        action: action.name,
+        display_id: action.display_id,
+        token: action.token,
+        payload: action.payload ?? {},
+    };
+}
+/**
+ * The run's `forwardedProps` once its press was checked on the socket: the
+ * press named by the id the runtime answered, the action itself gone.
+ */
+export function withPress(forwardedProps, answered) {
+    const press = answered?.press;
+    if (typeof press !== 'string' || !press) {
+        throw new Error('The runtime checked the press but named none');
+    }
+    const loop = { ...forwardedProps.loop };
+    delete loop.action;
+    return { ...forwardedProps, loop: { ...loop, press } };
+}

package/lib/chat/messages/ChatMessageList.d.ts

@@ -1,4 +1,5 @@
 import { type ReactNode, type RefObject } from 'react';
+import { type Display, type UiAct, type UiUpload } from '@datalayer/reactor/ui';
 import { type ChatDensity } from './ChatMarkdown';
 import { type MarkedMcpServer } from '../marks';
 import type { DisplayItem, AvatarConfig } from '../../types/chat';
@@ -13,6 +14,17 @@ export interface ToolApprovalConfig {
 export interface ChatMessageListProps {
     /** All display items (messages + tool calls) */
     displayItems: DisplayItem[];
+    /**
+     * How a message's display presses what it offered (REACTOR_UI RU-4, RU-W):
+     * the chat sends it up the conversation's ui socket. Absent, its
+     * displays offer nothing to press.
+     */
+    actOn?: (display: Display) => UiAct;
+    /**
+     * How a message's display uploads a file the person chose (REACTOR_UI
+     * RU-6): its ref, to press with. Absent, nothing is uploaded.
+     */
+    upload?: UiUpload;
     /** Whether the agent is loading */
     isLoading: boolean;
     /** Whether the agent is currently streaming */
@@ -97,5 +109,5 @@ export interface SubagentChatPanelProps {
  * approval decisions are sent over the shared monitoring socket.
  */
 export declare function SubagentChatPanel({ toolCallId, subagentName: subagentNameHint, height, avatarConfig, }: SubagentChatPanelProps): React.ReactElement | null;
-export declare function ChatMessageList({ displayItems, isLoading, isStreaming, showLoadingIndicator, hideMessagesAfterToolUI, avatarConfig, padding, notebookToolSurfacesId, emptyContent, messagesEndRef, onRespond, approvalConfig, showTurnFooters, agentUsage, onRemoveItems, renderMessageFooter, mcpServers, density, }: ChatMessageListProps): import("react").JSX.Element;
+export declare function ChatMessageList({ displayItems, actOn, upload, isLoading, isStreaming, showLoadingIndicator, hideMessagesAfterToolUI, avatarConfig, padding, notebookToolSurfacesId, emptyContent, messagesEndRef, onRespond, approvalConfig, showTurnFooters, agentUsage, onRemoveItems, renderMessageFooter, mcpServers, density, }: ChatMessageListProps): import("react").JSX.Element;
 export {};

package/lib/chat/messages/ChatMessageList.js

@@ -12,8 +12,8 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 import { MicrophoneIcon } from '@datalayer/icons-react';
 import { Fragment, lazy, Suspense, useState, useCallback, useEffect, useMemo, useRef, useSyncExternalStore, } from 'react';
 import { useOptionalReactorPlatform } from '@datalayer/reactor/react';
-import { resolveToolResult } from '@datalayer/reactor/ui';
-import { ReactorDisplay } from '@datalayer/reactor/ui/react';
+import { resolveToolResult, } from '@datalayer/reactor/ui';
+import { DisplayText, ReactorDisplay } from '@datalayer/reactor/ui/react';
 import { Text, Spinner, Link, Label, RelativeTime } from '@primer/react';
 import { ArrowRightIcon, BroadcastIcon, ClockIcon, DependabotIcon, PersonIcon, SkipIcon, ToolsIcon, XCircleFillIcon, } from '@primer/octicons-react';
 import { Box } from '@datalayer/primer-addons';
@@ -366,7 +366,7 @@ function DefaultToolCallRenderer({ item, onRespond, mcpServers, density, }) {
 // ---------------------------------------------------------------------------
 // Component
 // ---------------------------------------------------------------------------
-export function ChatMessageList({ displayItems, isLoading, isStreaming, showLoadingIndicator, hideMessagesAfterToolUI, avatarConfig, padding, notebookToolSurfacesId, emptyContent, messagesEndRef, onRespond, approvalConfig, showTurnFooters = false, agentUsage, onRemoveItems, renderMessageFooter, mcpServers, density = 'comfortable', }) {
+export function ChatMessageList({ displayItems, actOn, upload, isLoading, isStreaming, showLoadingIndicator, hideMessagesAfterToolUI, avatarConfig, padding, notebookToolSurfacesId, emptyContent, messagesEndRef, onRespond, approvalConfig, showTurnFooters = false, agentUsage, onRemoveItems, renderMessageFooter, mcpServers, density = 'comfortable', }) {
     /*
      * Who draws a tool call: the Reactor plugins of the page, when it has a
      * platform. Each plugin binds its own tools (`ToolBindings`) and renders its
@@ -611,7 +611,7 @@ export function ChatMessageList({ displayItems, isLoading, isStreaming, showLoad
                                                 whiteSpace: 'pre-wrap',
                                                 wordBreak: 'break-word',
                                             }, children: [message.metadata?.input === 'voice' ? (_jsx(Box, { as: "span", "data-spoken": "", title: "Said aloud", "aria-label": "Said aloud:", display: "inline-flex", verticalAlign: "text-bottom", mr: 1, opacity: 0.85, children: _jsx(MicrophoneIcon, { size: 14, "aria-hidden": "true" }) })) : null, text] }));
-                                    })()) : message.live && !getMessageText(message) ? (_jsx(TypingDots, { size: 6 })) : (_jsx(ChatMarkdown, { density: density, text: getMessageText(message) || (isStreaming ? '...' : '') }))] }), renderMessageFooter ? (_jsx(Box, { display: "flex", gap: 2, alignItems: "center", mt: 1, flexWrap: "wrap", flexDirection: isUser ? 'row-reverse' : 'row', children: renderMessageFooter(message) })) : null] })] }) }, message.id));
+                                    })()) : message.live && !getMessageText(message) ? (_jsx(TypingDots, { size: 6 })) : (_jsx(ChatMarkdown, { density: density, text: getMessageText(message) || (isStreaming ? '...' : '') }))] }), message.displays?.length ? (_jsx(Box, { "data-chat-displays": "", display: "flex", flexDirection: "column", gap: 2, mt: 2, width: "100%", children: message.displays.map(display => platform ? (_jsx(ReactorDisplay, { display: display, act: actOn?.(display), upload: upload }, display.id)) : (_jsx(DisplayText, { display: display }, display.id))) })) : null, renderMessageFooter ? (_jsx(Box, { display: "flex", gap: 2, alignItems: "center", mt: 1, flexWrap: "wrap", flexDirection: isUser ? 'row-reverse' : 'row', children: renderMessageFooter(message) })) : null] })] }) }, message.id));
     };
     return (_jsxs(_Fragment, { children: [displayItems.map((item, index) => {
                 const itemUI = renderItem(item, index);

package/lib/components/a2ui/datalayer/Chart.d.ts

@@ -121,7 +121,7 @@ export declare function chartOption(points: Record<string, unknown>[], props: Pi
     };
     series: {
         name: string;
-        type: "line" | "bar" | "scatter";
+        type: "bar" | "line" | "scatter";
         areaStyle: {} | undefined;
         data: number[][] | (number | null)[];
     }[];

package/lib/components/a2ui/datalayer/schema.js

@@ -19,7 +19,7 @@
  */
 import { z } from 'zod/v3';
 import { ActionSchema, DataBindingSchema } from '@a2ui/web_core/v0_9';
-import { COMPONENT_CATALOGUE } from '../../../specs/uiPlugins';
+import { COMPONENT_CATALOGUE } from '../../../specs/ui';
 /** The components of Datalayer's own the catalog has, by id. */
 export const OWN_COMPONENT_IDS = Object.values(COMPONENT_CATALOGUE)
     .filter(component => !component.standard)

package/lib/components/teams/AnswerSurfaces.d.ts

@@ -30,8 +30,9 @@ export type AnswerPressed = {
     does: string;
 };
 /**
- * What a button pressed on an answer's surface sends back, or `null` for an
- * action that is not one of an answer's buttons (a form's submission).
+ * What a button pressed on a member's surface sends back, or `null` for an
+ * action that is not one of its buttons (a form's submission). A member's
+ * surface is an answer by how it came — an A2A artifact — not by its id.
  */
 export declare function pressedOf(action: {
     name: string;

package/lib/components/teams/AnswerSurfaces.js

@@ -1,21 +1,21 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Suspense, lazy } from 'react';
 import { Text } from '@primer/react';
-import { answerAction } from '../../apps/plugins/a2ui-surface/toolResult';
 /** The renderer itself: A2UI and the catalog, loaded when a surface is drawn. */
 const AnswerSurfacesView = lazy(() => import('./AnswerSurfacesView'));
 /**
- * What a button pressed on an answer's surface sends back, or `null` for an
- * action that is not one of an answer's buttons (a form's submission).
+ * What a button pressed on a member's surface sends back, or `null` for an
+ * action that is not one of its buttons (a form's submission). A member's
+ * surface is an answer by how it came — an A2A artifact — not by its id.
  */
 export function pressedOf(action) {
-    const pressed = answerAction(action);
-    if (!pressed) {
+    const name = action.name.trim();
+    if (!name || name === 'submit_a2ui_form') {
         return null;
     }
-    const { name, payload } = pressed.forwardedProps.loop.action;
+    const payload = { ...action.context };
     const does = typeof payload.does === 'string' ? payload.does : 'read';
-    return { message: pressed.message, action: { name, payload }, does };
+    return { message: name, action: { name, payload }, does };
 }
 /** The surfaces the members showed, each under who showed it; nothing when there is none. */
 export function AnswerSurfaces(props) {

package/lib/components/teams/useA2ATeam.d.ts

@@ -59,7 +59,7 @@ export declare const NOTEBOOK_AND_WORDS: readonly string[];
 export declare const COMPONENTS_NOTEBOOK_AND_WORDS: readonly string[];
 /** A surface of components a member showed with an answer: who gave it, and the surface. */
 export type A2ATeamSurface = {
-    /** Its surface's id: `answer-…`. */
+    /** Its surface's id. */
     id: string;
     /** The member that showed it, by its id. */
     giver: string;