@datalayer/agent-runtimes 1.3.113 → 1.4.0

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 } from '@datalayer/reactor/ui';
 import { type ChatDensity } from './ChatMarkdown';
 import { type MarkedMcpServer } from '../marks';
 import type { DisplayItem, AvatarConfig } from '../../types/chat';
@@ -13,6 +14,12 @@ 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;
     /** Whether the agent is loading */
     isLoading: boolean;
     /** Whether the agent is currently streaming */
@@ -97,5 +104,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, 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, 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) }, 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;

package/lib/config/AgentConfiguration.d.ts

@@ -29,7 +29,7 @@ export interface LibraryAgentspec {
     welcomeDocument?: string | null;
     sandboxVariant?: string | null;
     protocol?: string | null;
-    uiPlugin?: string | null;
+    ui?: string | null;
     trigger?: Record<string, unknown> | null;
     modelConfig?: Record<string, unknown> | null;
     mcpServerTools?: Array<Record<string, unknown>> | null;

package/lib/protocols/AGUIAdapter.d.ts

@@ -7,6 +7,8 @@ import type { ProtocolAdapterConfig } from '../types';
 import type { ChatMessage } from '../types/messages';
 import type { ToolDefinition, ToolExecutionResult } from '../types/tools';
 import { BaseProtocolAdapter } from './BaseProtocolAdapter';
+/** What the page says when a run's stream closes before the run said how it ended. */
+export declare const RUN_CUT_SHORT = "The run stopped before it finished, without an answer or an error: send it again.";
 /**
  * AG-UI specific configuration
  */
@@ -110,6 +112,11 @@ export declare class AGUIAdapter extends BaseProtocolAdapter {
      * Parse SSE stream from AG-UI response
      */
     private parseSSEStream;
+    /**
+     * A `reactor.ui` op on the run stream: refused, and said as an error. The
+     * ops come over the conversation's ui socket (REACTOR_UI RU-W).
+     */
+    private refuseUiOnRun;
     /**
      * Handle individual AG-UI events
      *

package/lib/protocols/AGUIAdapter.js

@@ -5,6 +5,9 @@
 import { generateMessageId, createAssistantMessage } from '../types/messages';
 import { agUiRefusal, refusalBody } from './agUiRefusal';
 import { BaseProtocolAdapter } from './BaseProtocolAdapter';
+import { AGUI_NAME } from '@datalayer/reactor/ui';
+/** What the page says when a run's stream closes before the run said how it ended. */
+export const RUN_CUT_SHORT = 'The run stopped before it finished, without an answer or an error: send it again.';
 /**
  * AG-UI protocol adapter
  * Uses HTTP POST with SSE streaming for responses
@@ -426,11 +429,20 @@ export class AGUIAdapter extends BaseProtocolAdapter {
             });
         }
         this._streamParsingDepth++;
+        // Whether the run said how it ended. A stream that closes without
+        // RUN_FINISHED or RUN_ERROR is a run cut short — by the runtime, a proxy
+        // or the network — and the page says so instead of waiting for an answer
+        // that is not coming (a Preview gave no answer for minutes, 2026-10-12).
+        let ended = false;
         try {
             while (true) {
                 const { done, value } = await reader.read();
-                if (done)
+                if (done) {
+                    if (!ended) {
+                        throw new Error(RUN_CUT_SHORT);
+                    }
                     break;
+                }
                 buffer += decoder.decode(value, { stream: true });
                 const lines = buffer.split('\n');
                 buffer = lines.pop() || '';
@@ -444,6 +456,10 @@ export class AGUIAdapter extends BaseProtocolAdapter {
                         const data = line.slice(6);
                         try {
                             const event = JSON.parse(data);
+                            const kind = event.type;
+                            if (kind === 'RUN_FINISHED' || kind === 'RUN_ERROR') {
+                                ended = true;
+                            }
                             this.handleAGUIEvent(event, {
                                 getCurrentMessageId: () => currentMessageId,
                                 setCurrentMessageId: id => {
@@ -483,6 +499,17 @@ export class AGUIAdapter extends BaseProtocolAdapter {
             }
         }
     }
+    /**
+     * A `reactor.ui` op on the run stream: refused, and said as an error. The
+     * ops come over the conversation's ui socket (REACTOR_UI RU-W).
+     */
+    refuseUiOnRun() {
+        this.emit({
+            type: 'error',
+            error: new Error('A reactor.ui op came on the run stream: it comes over the ui socket (REACTOR_UI RU-W).'),
+            timestamp: new Date(),
+        });
+    }
     /**
      * Handle individual AG-UI events
      *
@@ -684,14 +711,27 @@ export class AGUIAdapter extends BaseProtocolAdapter {
                 });
                 break;
             }
+            case 'ACTIVITY_SNAPSHOT':
+            case 'ACTIVITY_DELTA': {
+                // `reactor.ui` ops come over the conversation's ui socket, never
+                // the run stream (REACTOR_UI RU-W): one here is refused. Any other
+                // activity is nobody's here.
+                if (event.activityType === AGUI_NAME) {
+                    this.refuseUiOnRun();
+                }
+                break;
+            }
             case 'CUSTOM': {
                 const name = event.name;
-                const value = event.value;
+                if (name === AGUI_NAME) {
+                    this.refuseUiOnRun();
+                    break;
+                }
                 this.emit({
                     type: 'activity',
                     activity: {
                         type: name || 'custom',
-                        data: value,
+                        data: event.value,
                     },
                     timestamp: new Date(),
                 });

package/lib/protocols/agentic-commerce/index.d.ts

@@ -19,15 +19,11 @@ import { AGENTIC_COMMERCE_VERSION } from './models';
 export { AGENTIC_COMMERCE_VERSION };
 export declare const DISCOVERY_PATH = "/.well-known/acp.json";
 export declare const AGENTIC_COMMERCE_PLUGIN = "agent-runtimes.protocols.agentic-commerce";
-/** Each operation's action class (F-10), for Rules (R-05). */
-export declare const AGENTIC_COMMERCE_ACTION_CLASSES: {
-    readonly proposeCompletion: "read";
-    readonly getCheckout: "read";
-    readonly createCheckout: "write";
-    readonly updateCheckout: "write";
-    readonly cancelCheckout: "write";
-    readonly complete: "buy";
-};
+/**
+ * Each operation's action class (F-10), for Rules (R-05): agentspecs'
+ * `protocol-tools/agentic-commerce.yaml` (AGENT_PROTOCOLS PR-54).
+ */
+export declare const AGENTIC_COMMERCE_ACTION_CLASSES: Record<string, import("../../types").ActionClass>;
 export declare class AgenticCommerceError extends Error {
 }
 type Json = Record<string, any>;

package/lib/protocols/agentic-commerce/index.js

@@ -17,21 +17,17 @@
  * @module protocols/agentic-commerce
  */
 import { contribution, defineContributionPoint, definePlugin, } from '@datalayer/reactor';
-import { InMemoryProposalStore, digest, } from '../commerce';
+import { InMemoryProposalStore, digest, operationClasses, } from '../commerce';
 import { DEFAULT_ORDER, ProtocolDescriptions, firstContribution, } from '../core';
 import { AGENTIC_COMMERCE_VERSION } from './models';
 export { AGENTIC_COMMERCE_VERSION };
 export const DISCOVERY_PATH = '/.well-known/acp.json';
 export const AGENTIC_COMMERCE_PLUGIN = 'agent-runtimes.protocols.agentic-commerce';
-/** Each operation's action class (F-10), for Rules (R-05). */
-export const AGENTIC_COMMERCE_ACTION_CLASSES = {
-    proposeCompletion: 'read',
-    getCheckout: 'read',
-    createCheckout: 'write',
-    updateCheckout: 'write',
-    cancelCheckout: 'write',
-    complete: 'buy',
-};
+/**
+ * Each operation's action class (F-10), for Rules (R-05): agentspecs'
+ * `protocol-tools/agentic-commerce.yaml` (AGENT_PROTOCOLS PR-54).
+ */
+export const AGENTIC_COMMERCE_ACTION_CLASSES = operationClasses('agentic-commerce');
 export class AgenticCommerceError extends Error {
 }
 export const AgenticCommerceApprovers = defineContributionPoint('agentic_commerce.approver');