@datalayer/agent-runtimes 1.4.0 → 1.5.1

package/lib/apps/apps/appspec.js

@@ -145,6 +145,7 @@ export function emptyAppspec(kind = 'chat') {
             starters: [],
             commands: [],
             modes: [],
+            actions: [],
             profiles: [],
             language: DEFAULT_LANGUAGE,
             translations: {},
@@ -374,6 +375,17 @@ function parseRule(data) {
     };
 }
 /** A slash command (LOOP P-19); a wrong one is said by the checks. */
+/** An action of its code, typed (REACTOR_UI RU-5): its payload's schema kept as written. */
+function parseAction(data) {
+    const action = { name: text(data.name) };
+    if (text(data.description)) {
+        action.description = text(data.description);
+    }
+    if (isData(data.payload)) {
+        action.payload = JSON.parse(JSON.stringify(data.payload));
+    }
+    return action;
+}
 function parseCommand(data) {
     return {
         name: text(data.name),
@@ -615,6 +627,7 @@ function parseInterface(data, kind) {
         starters: records(data.starters).map(parseStarter),
         commands: records(data.commands).map(parseCommand),
         modes: records(data.modes).map(parseMode),
+        actions: records(data.actions).map(parseAction),
         profiles: records(data.profiles).map(parseProfile),
         language: text(data.language, DEFAULT_LANGUAGE),
         translations: mapValues(recordsBy(data.translations), parseTranslation),
@@ -1084,6 +1097,15 @@ function dumpInterface(spec, kind) {
             written.data.default = mode.default;
         }
         return written.data;
+    }))
+        .list('actions', (spec.actions ?? []).map(action => {
+        const written = new Writer()
+            .text('name', action.name, '\u0000')
+            .text('description', action.description ?? '');
+        if (action.payload) {
+            written.data.payload = { ...action.payload };
+        }
+        return written.data;
     }))
         .list('profiles', (spec.profiles ?? []).map(profile => new Writer()
         .text('id', profile.id, '\u0000')

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

@@ -634,6 +634,14 @@ export type LoopChatExtrasValue = {
      * client tool — A2UI Jupyter Output's `run_jupyter_output_demo`.
      */
     frontendTools?: FrontendToolDefinition[];
+    /**
+     * The ids of the `AgentTools` bundles (Reactor's) the chat hands its agent
+     * wherever it runs — on a runtime too, where the plugins' bundles are not
+     * otherwise given — each tool running its command on this workspace's
+     * reactor (REACTOR_UI RU-7): the host page's (`host`), which an embedded
+     * application calls as `host_<name>`.
+     */
+    agentToolBundles?: string[];
     /**
      * Take the composer off the screen, live.
      *

package/lib/apps/embed/AppEmbed.js

@@ -51,8 +51,7 @@ import { ChatFloating } from '../../chat/ChatFloating';
 import { AppRenderer, } from '../apps/AppRenderer';
 import { AssistantCharactersPlugin, assistantCharacterFor, assistantCharactersFrom, } from '../plugins/assistant-characters';
 import { floatingViewOf } from './embedConfig';
-import { createChatExtrasPlugin } from '../plugins/chat-extras';
-import { hostFrontendTools, hostUserRunProps, } from './hostBridge';
+import { hostPlugin, hostUserRunProps } from './hostBridge';
 import { LoopRunProps } from '../core';
 import { embedThemeOverrides, embedThemeStyles } from './embedTheme';
 import { WINDOW_NOT_YET, embedSessionKey, postWindowMessage, reattachSession, sessionGoneSentence, sessionKeeper, visitOfToken, } from './embedSession';
@@ -185,16 +184,14 @@ const NO_HOST_PLUGINS = [];
 export function useHostBridge(app, host) {
     const hostRef = useRef(host);
     hostRef.current = host;
-    const handle = useMemo(() => createChatExtrasPlugin(), []);
     const bridge = app.deployment.embedded?.host;
     const key = JSON.stringify([bridge ?? null, app.rules, app.connections]);
-    useEffect(() => {
-        handle.setExtras({
-            frontendTools: hostFrontendTools(app, () => hostRef.current ?? {}),
-        });
-        // The tools change with what the Appspec names, and the rules that decide them.
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [handle, key]);
+    // The host's plugin (REACTOR_UI RU-7): the page's functions as its
+    // commands, named for the agent by its agent tools bundle — made again
+    // when what the Appspec names, or the rules that decide them, change.
+    const hosting = useMemo(() => hostPlugin(app, () => hostRef.current ?? {}), 
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [app.id, key]);
     // Who its user is (D-21): the token the host's server signed goes with
     // every run, for an application that takes only a signed user.
     const signed = bridge?.user === 'signed';
@@ -215,9 +212,9 @@ export function useHostBridge(app, host) {
         // Made again only when whether it is signed changes.
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [app.id, signed]);
-    const plugins = useMemo(() => bridge
-        ? [handle.plugin, ...(userPlugin ? [userPlugin] : [])]
-        : NO_HOST_PLUGINS, [bridge, handle, userPlugin]);
+    const plugins = useMemo(() => hosting
+        ? [hosting, ...(userPlugin ? [userPlugin] : [])]
+        : NO_HOST_PLUGINS, [hosting, userPlugin]);
     // What its code tells the page during a turn (LOOP P-25), raised on it.
     useEffect(() => onLoopWindowMessage(data => hostRef.current?.onEvent?.({
         type: 'window-message',

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

@@ -27,20 +27,26 @@
  * reaches the page.
  *
  * Offered: the functions of the page its Appspec names
- * (`deployment.embedded.host.functions`), each called by its agent as the
- * tool `host_<name>`. Every one of these tools is decided in the page by
- * the rule that names it (`behaviourFor`), before the page is called: one no
- * rule names, or *leave it to me*, is refused; *ask me first* and *do it if
- * I asked* ask the person on the page (`ask`, else the browser's `confirm`),
- * and a call they do not allow is refused; *do it* is done.
+ * (`deployment.embedded.host.functions`), as Reactor has a plugin offer
+ * what it does (REACTOR_UI RU-7): each a **command** of the host's plugin,
+ * `host.<name>` (`host.context` for the values it passes), and the plugin's
+ * **agent tools** bundle (`AgentTools`, id `host`) naming them for its agent
+ * as the tools `host_<name>` and `host_context` — which the chat turns into
+ * tools that run `reactor.executeCommand`, as for any plugin's bundle, and
+ * hands its agent wherever it runs (`agentToolBundles`). Every one of these
+ * commands is decided in the page by the rule that names its tool
+ * (`behaviourFor`), before the page is called: one no rule names, or
+ * *leave it to me*, is refused; *ask me first* and *do it if I asked* ask
+ * the person on the page (`ask`, else the browser's `confirm`), and a call
+ * they do not allow is refused; *do it* is done.
  *
- * Pure: the tools call the page, and ask, through what they are given.
+ * Pure: the commands call the page, and ask, through what they are given.
  *
  * @module apps/embed/hostBridge
  */
+import { type AgentToolBundle, type ReactorCommand, type ReactorPlugin } from '@datalayer/reactor';
 import type { AppSpec } from '../../types/agentspecs';
-import type { FrontendToolDefinition } from '../../types/tools';
-import type { RunPropsContribution } from '../core';
+import { type RunPropsContribution } from '../core';
 import { HOST_CONTEXT_TOOL, HOST_NAME, hostTool, hostToolsOf, signedUser } from '../apps/hostTools';
 export { HOST_CONTEXT_TOOL, HOST_NAME, hostTool, hostToolsOf, signedUser };
 /** What the application tells the page it sits in. */
@@ -109,12 +115,40 @@ export type HostQuestion = {
 export declare const hostRefused: (tool: string) => string;
 /** The sentence a call is refused with when the person did not allow it. */
 export declare const hostNotAllowed: (tool: string) => string;
+/** The command that reads what the page passes (`host_context`). */
+export declare const HOST_CONTEXT_COMMAND = "host.context";
+/** The command a function of the page runs as. */
+export declare const hostCommand: (name: string) => string;
+/** The id of the host plugin's agent tools bundle. */
+export declare const HOST_TOOLS_BUNDLE = "host";
+/** What a command of the host answers its tool: what came back, or why not. */
+export type HostAnswer = {
+    values: Record<string, unknown>;
+    unsaid?: string[];
+} | {
+    result?: unknown;
+    error?: string;
+};
+type HostCommand = ReactorCommand<Record<string, unknown> | undefined, HostAnswer>;
+/**
+ * The host plugin's commands (REACTOR_UI RU-7): `host.context` when the
+ * Appspec names values, and `host.<name>` for each function it names, each
+ * decided by the rule naming its tool before the page is called. `host` is
+ * read at each call, so that what the page passes is the newest.
+ */
+export declare function hostCommands(app: Pick<AppSpec, 'name' | 'connections' | 'rules' | 'deployment'>, host: () => AppEmbedHost): HostCommand[];
+/**
+ * The host plugin's agent tools (REACTOR_UI RU-7): `host_context` and
+ * `host_<name>`, each running its command; `null` for an application the
+ * Appspec embeds with no host bridge.
+ */
+export declare function hostAgentTools(app: Pick<AppSpec, 'name' | 'deployment'>): AgentToolBundle | null;
 /**
- * The frontend tools its agent is given for the page: `host_context` when
- * the Appspec names values, and `host_<name>` for each function it names.
- * `host` is read at each call, so that what the page passes is the newest.
+ * The host's plugin (REACTOR_UI RU-7): its commands, its agent tools bundle,
+ * and the chat extras that hand the bundle to the chat's agent wherever it
+ * runs. `null` for an application with no host bridge.
  */
-export declare function hostFrontendTools(app: Pick<AppSpec, 'connections' | 'rules' | 'deployment'>, host: () => AppEmbedHost): FrontendToolDefinition[];
+export declare function hostPlugin(app: Pick<AppSpec, 'id' | 'name' | 'connections' | 'rules' | 'deployment'>, host: () => AppEmbedHost): ReactorPlugin<Record<string, never>, unknown, unknown> | null;
 /**
  * What goes with every run for the host's user (LOOP D-21): the token the
  * host's server signed, as `forwardedProps.loop.user_token`, for an

package/lib/apps/embed/hostBridge.js

@@ -2,6 +2,54 @@
  * Copyright (c) 2025-2026 Datalayer, Inc.
  * Distributed under the terms of the Modified BSD License.
  */
+/**
+ * The host page and an embedded application, talking (LOOP D-10).
+ *
+ * In: the values the page passes — `user`, `page`, or names of its own —
+ * read by the application's agent with the tool `host_context`, only those
+ * its Appspec names (`deployment.embedded.host.context`).
+ *
+ * Out: what the application does, as events — `message` when it has said
+ * something, `action` when it called a function of the page,
+ * `window-message` when its code told the page something outside the
+ * conversation (LOOP P-25, `session.send_window_message`) — beside the
+ * `decision` and `token-expired` the element raises already.
+ *
+ * Window messages, in (P-25): the page posts one with
+ * `element.postWindowMessage(data)`; its code's `@app.window` reads it, on
+ * the host's own server (`server`), and what it answers comes back as
+ * `window-message` events.
+ *
+ * Who its user is (LOOP D-21): what the page says as `user` is a claim.
+ * An application whose Appspec says `deployment.embedded.host.user: signed`
+ * takes only a token the host's **server** signed with the deployment's
+ * secret (HS256: `sub`, `name`, `exp` at most an hour away), which the page
+ * hands over as `userToken` (the element's `user-token`). It goes with every
+ * run as `forwardedProps.loop.user_token` (`hostUserRunProps`); the runtime
+ * verifies it where the session opens, refuses the session without it, and
+ * answers `host_context`'s `user` with the user it names. The secret never
+ * reaches the page.
+ *
+ * Offered: the functions of the page its Appspec names
+ * (`deployment.embedded.host.functions`), as Reactor has a plugin offer
+ * what it does (REACTOR_UI RU-7): each a **command** of the host's plugin,
+ * `host.<name>` (`host.context` for the values it passes), and the plugin's
+ * **agent tools** bundle (`AgentTools`, id `host`) naming them for its agent
+ * as the tools `host_<name>` and `host_context` — which the chat turns into
+ * tools that run `reactor.executeCommand`, as for any plugin's bundle, and
+ * hands its agent wherever it runs (`agentToolBundles`). Every one of these
+ * commands is decided in the page by the rule that names its tool
+ * (`behaviourFor`), before the page is called: one no rule names, or
+ * *leave it to me*, is refused; *ask me first* and *do it if I asked* ask
+ * the person on the page (`ask`, else the browser's `confirm`), and a call
+ * they do not allow is refused; *do it* is done.
+ *
+ * Pure: the commands call the page, and ask, through what they are given.
+ *
+ * @module apps/embed/hostBridge
+ */
+import { AgentTools, contribution, defineAgentTools, definePlugin, signal, } from '@datalayer/reactor';
+import { LoopChatExtras, } from '../core';
 import { behaviourFor } from '../apps/rules';
 import { HOST_CONTEXT_TOOL, HOST_NAME, hostTool, hostToolsOf, signedUser, } from '../apps/hostTools';
 export { HOST_CONTEXT_TOOL, HOST_NAME, hostTool, hostToolsOf, signedUser };
@@ -15,26 +63,33 @@ const confirmOnPage = (question) => typeof window !== 'undefined' && typeof wind
     : false;
 /** The words of the rule that names the tool, for the question. */
 const actionOf = (app, tool) => app.rules.find(rule => rule.appliesTo.includes(tool))?.action;
+/** The command that reads what the page passes (`host_context`). */
+export const HOST_CONTEXT_COMMAND = 'host.context';
+/** The command a function of the page runs as. */
+export const hostCommand = (name) => `host.${name}`;
+/** The id of the host plugin's agent tools bundle. */
+export const HOST_TOOLS_BUNDLE = 'host';
 /**
- * The frontend tools its agent is given for the page: `host_context` when
- * the Appspec names values, and `host_<name>` for each function it names.
- * `host` is read at each call, so that what the page passes is the newest.
+ * The host plugin's commands (REACTOR_UI RU-7): `host.context` when the
+ * Appspec names values, and `host.<name>` for each function it names, each
+ * decided by the rule naming its tool before the page is called. `host` is
+ * read at each call, so that what the page passes is the newest.
  */
-export function hostFrontendTools(app, host) {
+export function hostCommands(app, host) {
     const bridge = app.deployment.embedded?.host;
     if (!bridge) {
         return [];
     }
     const behaviour = (tool) => behaviourFor(app, tool);
     const ruled = (tool) => behaviour(tool) !== 'leave_to_me';
-    const tools = [];
+    const commands = [];
     if (bridge.context.length > 0) {
-        tools.push({
-            name: HOST_CONTEXT_TOOL,
-            description: `What the page you are embedded in says of its visitor and of itself: ${bridge.context.join(', ')}. Read it before answering what depends on them.`,
-            parameters: { type: 'object', properties: {} },
-            location: 'frontend',
-            handler: async () => {
+        commands.push({
+            id: HOST_CONTEXT_COMMAND,
+            name: `What the page says to ${app.name}`,
+            description: `Read ${bridge.context.join(', ')} from the page.`,
+            category: 'Host',
+            execute: async () => {
                 if (!ruled(HOST_CONTEXT_TOOL)) {
                     return { error: hostRefused(HOST_CONTEXT_TOOL) };
                 }
@@ -55,12 +110,13 @@ export function hostFrontendTools(app, host) {
     }
     for (const fn of bridge.functions) {
         const tool = hostTool(fn.name);
-        tools.push({
-            name: tool,
-            description: fn.description,
-            parameters: fn.parameters,
-            location: 'frontend',
-            handler: async (args) => {
+        commands.push({
+            id: hostCommand(fn.name),
+            name: fn.description,
+            description: `The page's ${fn.name}.`,
+            category: 'Host',
+            execute: async (given) => {
+                const args = given ?? {};
                 const said = (detail) => {
                     host().onEvent?.({
                         type: 'action',
@@ -100,7 +156,68 @@ export function hostFrontendTools(app, host) {
             },
         });
     }
-    return tools;
+    return commands;
+}
+/**
+ * The host plugin's agent tools (REACTOR_UI RU-7): `host_context` and
+ * `host_<name>`, each running its command; `null` for an application the
+ * Appspec embeds with no host bridge.
+ */
+export function hostAgentTools(app) {
+    const bridge = app.deployment.embedded?.host;
+    if (!bridge) {
+        return null;
+    }
+    return defineAgentTools({
+        id: HOST_TOOLS_BUNDLE,
+        name: `The page ${app.name} is embedded in`,
+        description: 'What the host page passes, and the functions it offers.',
+        commands: [
+            ...(bridge.context.length > 0
+                ? [
+                    {
+                        name: HOST_CONTEXT_TOOL,
+                        command: HOST_CONTEXT_COMMAND,
+                        description: `What the page you are embedded in says of its visitor and of itself: ${bridge.context.join(', ')}. Read it before answering what depends on them.`,
+                        parameters: { type: 'object', properties: {} },
+                    },
+                ]
+                : []),
+            ...bridge.functions.map(fn => ({
+                name: hostTool(fn.name),
+                command: hostCommand(fn.name),
+                description: fn.description,
+                parameters: fn.parameters,
+            })),
+        ],
+    });
+}
+/**
+ * The host's plugin (REACTOR_UI RU-7): its commands, its agent tools bundle,
+ * and the chat extras that hand the bundle to the chat's agent wherever it
+ * runs. `null` for an application with no host bridge.
+ */
+export function hostPlugin(app, host) {
+    const bundle = hostAgentTools(app);
+    if (!bundle) {
+        return null;
+    }
+    const extras = {
+        id: `host-${app.id}`,
+        extras: signal({ agentToolBundles: [bundle.id] }),
+    };
+    return definePlugin({
+        name: `loop-host-${app.id}`,
+        displayName: `${app.name}: its host page`,
+        description: `The values the page passes ${app.name} and the functions it offers, as commands and agent tools.`,
+        octicon: 'browser',
+        emoji: '\u{1F310}',
+        commands: hostCommands(app, host),
+        contributes: [
+            contribution(AgentTools, bundle, { id: bundle.id }),
+            contribution(LoopChatExtras, extras, { id: extras.id }),
+        ],
+    });
 }
 /**
  * What goes with every run for the host's user (LOOP D-21): the token the

package/lib/apps/index.d.ts

@@ -57,7 +57,7 @@ export { APP_ACTIVITY_PLUGIN_NAME, APP_ACTIVITY_WORDS, AppActivity, defineAppAct
 export { APP_COMPUTER_PLUGIN_NAME, AppComputer, defineAppComputerPlugin, } from './plugins/app-computer';
 export { GraphViewPlugin, GRAPH_PLUGIN_NAME, GRAPH_VIEW_TYPE, } from './plugins/graph';
 export { PluginsPanelPlugin, PLUGINS_PANEL_PLUGIN_NAME, PluginsPanel, } from './plugins/plugins-panel';
-export { AGENTS_PLUGIN_NAME, AgentsPlugin, SandboxSelector, browserSource, createBrowserSandboxService, createServerSandboxService, createSwitchableSandboxService, suppliedSource, useOptionalSandboxService, useSandboxService, type AgentsConfig, type AgentsOutput, type SandboxExecution, type SandboxService, type SandboxTarget, type ServiceManagerSource, type SwitchableSandboxService, } from './plugins/agents';
+export { AGENTS_PLUGIN_NAME, AgentsPlugin, DEFAULT_DATALAYER_AGENTSPEC, SandboxSelector, browserSource, createBrowserSandboxService, createServerSandboxService, createSwitchableSandboxService, suppliedSource, useOptionalSandboxService, useSandboxService, type AgentsConfig, type AgentsOutput, type SandboxExecution, type SandboxService, type SandboxTarget, type ServiceManagerSource, type SwitchableSandboxService, } from './plugins/agents';
 export { DocumentPlugin, DOCUMENT_PLUGIN_NAME } from './plugins/document';
 export { DocumentToolbarPlugin, DOCUMENT_TOOLBAR_PLUGIN_NAME, } from './plugins/document-toolbar';
 export { ShellPlugin, EditorSelector, SHELL_PLUGIN_NAME, NONE_EDITOR, chooseEditor, EditorsPlugin, EDITORS_PLUGIN_NAME, type ShellPluginConfig, } from './plugins/shell';
@@ -70,7 +70,7 @@ export { PromptPlugin, PROMPT_PLUGIN_NAME } from './plugins/prompt';
 export { LoopEmbed, type LoopEmbedProps } from './embed/LoopEmbed';
 export { AppEmbed, AppFloating, embedAssistantCharacter, type AppEmbedProps, type AppFloatingProps, type EmbedSession, useEmbedSession, useHostBridge, } from './embed/AppEmbed';
 export { EMBED_SESSION_KEY_PREFIX, embedSessionKey, visitOfToken, } from './embed/embedSession';
-export { HOST_CONTEXT_TOOL, hostFrontendTools, hostNotAllowed, hostRefused, hostTool, hostToolsOf, hostUserRunProps, fetchUserToken, signedUser, type SignedUserToken, type AppEmbedHost, type HostEvent, type HostFunction, type HostQuestion, } from './embed/hostBridge';
+export { HOST_CONTEXT_COMMAND, HOST_CONTEXT_TOOL, HOST_TOOLS_BUNDLE, hostAgentTools, hostCommand, hostCommands, hostPlugin, hostNotAllowed, hostRefused, hostTool, hostToolsOf, hostUserRunProps, fetchUserToken, signedUser, type SignedUserToken, type AppEmbedHost, type HostEvent, type HostFunction, type HostQuestion, } from './embed/hostBridge';
 export { defineDatalayerAppElement, type DatalayerAppElementOptions, } from './embed/element';
 export { EMBED_ATTRIBUTES, EMBED_HOST_VARIABLES, EMBED_TAG, embedLookOf, embedSnippetOf, floatingViewOf, languageOf, resumeOf, type EmbedLook, type EmbedSnippetOptions, } from './embed/embedConfig';
 export { SubagentActivityPlugin, SubagentPulse, SUBAGENT_ACTIVITY_PLUGIN_NAME, } from './plugins/subagent-activity';

package/lib/apps/index.js

@@ -70,7 +70,7 @@ export { APP_ACTIVITY_PLUGIN_NAME, APP_ACTIVITY_WORDS, AppActivity, defineAppAct
 export { APP_COMPUTER_PLUGIN_NAME, AppComputer, defineAppComputerPlugin, } from './plugins/app-computer';
 export { GraphViewPlugin, GRAPH_PLUGIN_NAME, GRAPH_VIEW_TYPE, } from './plugins/graph';
 export { PluginsPanelPlugin, PLUGINS_PANEL_PLUGIN_NAME, PluginsPanel, } from './plugins/plugins-panel';
-export { AGENTS_PLUGIN_NAME, AgentsPlugin, SandboxSelector, browserSource, createBrowserSandboxService, createServerSandboxService, createSwitchableSandboxService, suppliedSource, useOptionalSandboxService, useSandboxService, } from './plugins/agents';
+export { AGENTS_PLUGIN_NAME, AgentsPlugin, DEFAULT_DATALAYER_AGENTSPEC, SandboxSelector, browserSource, createBrowserSandboxService, createServerSandboxService, createSwitchableSandboxService, suppliedSource, useOptionalSandboxService, useSandboxService, } from './plugins/agents';
 export { DocumentPlugin, DOCUMENT_PLUGIN_NAME } from './plugins/document';
 export { DocumentToolbarPlugin, DOCUMENT_TOOLBAR_PLUGIN_NAME, } from './plugins/document-toolbar';
 export { ShellPlugin, EditorSelector, SHELL_PLUGIN_NAME, NONE_EDITOR, chooseEditor, 
@@ -91,7 +91,7 @@ export { LoopEmbed } from './embed/LoopEmbed';
 export { AppEmbed, AppFloating, embedAssistantCharacter, useEmbedSession, useHostBridge, } from './embed/AppEmbed';
 export { EMBED_SESSION_KEY_PREFIX, embedSessionKey, visitOfToken, } from './embed/embedSession';
 // The host page and an embedded application, talking (LOOP D-10).
-export { HOST_CONTEXT_TOOL, hostFrontendTools, hostNotAllowed, hostRefused, hostTool, hostToolsOf, hostUserRunProps, fetchUserToken, signedUser, } from './embed/hostBridge';
+export { HOST_CONTEXT_COMMAND, HOST_CONTEXT_TOOL, HOST_TOOLS_BUNDLE, hostAgentTools, hostCommand, hostCommands, hostPlugin, hostNotAllowed, hostRefused, hostTool, hostToolsOf, hostUserRunProps, fetchUserToken, signedUser, } from './embed/hostBridge';
 export { defineDatalayerAppElement, } from './embed/element';
 export { EMBED_ATTRIBUTES, EMBED_HOST_VARIABLES, EMBED_TAG, embedLookOf, embedSnippetOf, floatingViewOf, languageOf, resumeOf, } from './embed/embedConfig';
 export { SubagentActivityPlugin, SubagentPulse, SUBAGENT_ACTIVITY_PLUGIN_NAME, } from './plugins/subagent-activity';

package/lib/apps/plugins/agents/DatalayerAgentBridge.js

@@ -9,16 +9,8 @@ import { ensureVisitorAgent } from '../../apps/visitorToken';
 import { AGENTSPECS } from '../../../specs/agents/agents';
 import { IDLE_SANDBOX_TARGET_SIGNAL } from '../../core';
 import { appLaunchOf } from './appLaunch';
-import { AGENTS_PLUGIN_NAME } from './plugin';
+import { AGENTS_PLUGIN_NAME, DEFAULT_DATALAYER_AGENTSPEC, } from './plugin';
 import { useOptionalSandboxService } from './useSandboxService';
-/**
- * The tutor.
- *
- * The front door of the notebook team, and the agent a person landing on a
- * Datalayer runtime should meet first. A host that wants another names it in
- * this plugin's config.
- */
-const DEFAULT_DATALAYER_AGENTSPEC = 'jupyter-tutor';
 export function DatalayerAgentBridge() {
     const reactor = useReactorPlatform();
     const agentsConfig = reactor.getConfig(AGENTS_PLUGIN_NAME);
@@ -107,13 +99,16 @@ export function DatalayerAgentBridge() {
      */
     // An application names its own agent and transport; a bare spec, the spec's.
     const agentName = typeof createPayload?.name === 'string' ? createPayload.name : agentSpecId;
-    const protocol = createPayload?.transport === 'ag-ui' ||
-        createPayload?.transport === 'vercel-ai'
-        ? createPayload.transport
-        : undefined;
+    /*
+     * AG-UI unless the application names another: the workspace's chat speaks
+     * AG-UI to an agent on a server (`/api/v1/ag-ui/<agent>/`). Left unsaid, a
+     * bare spec's agent was created with the runtime's default, Vercel AI, and
+     * every message the workspace sent it on Datalayer was a 404 (2026-10-12).
+     */
+    const protocol = createPayload?.transport === 'vercel-ai' ? 'vercel-ai' : 'ag-ui';
     const agentConfig = useMemo(() => ({
         name: agentName,
-        ...(protocol ? { protocol } : {}),
+        protocol,
         agentSpecId,
         model: AGENTSPECS[agentSpecId]?.model,
         description: AGENTSPECS[agentSpecId]?.description,

package/lib/apps/plugins/agents/index.d.ts

@@ -3,7 +3,7 @@
  *
  * @module apps/plugins/agents
  */
-export { AGENTS_PLUGIN_NAME, AgentsPlugin, type AgentsConfig, type AgentsOutput, } from './plugin';
+export { AGENTS_PLUGIN_NAME, AgentsPlugin, DEFAULT_DATALAYER_AGENTSPEC, type AgentsConfig, type AgentsOutput, } from './plugin';
 export { AgentsPlugin as default } from './plugin';
 export { browserSource, createBrowserSandboxService, suppliedSource, type BrowserSandboxService, type ServiceManagerSource, } from './browserService';
 export { createServerSandboxService, summarize, type SandboxExecution, type SandboxService, type SandboxStatusPayload, } from './service';

package/lib/apps/plugins/agents/index.js

@@ -7,7 +7,7 @@
  *
  * @module apps/plugins/agents
  */
-export { AGENTS_PLUGIN_NAME, AgentsPlugin, } from './plugin';
+export { AGENTS_PLUGIN_NAME, AgentsPlugin, DEFAULT_DATALAYER_AGENTSPEC, } from './plugin';
 export { AgentsPlugin as default } from './plugin';
 export { browserSource, createBrowserSandboxService, suppliedSource, } from './browserService';
 export { createServerSandboxService, summarize, } from './service';

package/lib/apps/plugins/agents/plugin.d.ts

@@ -20,6 +20,16 @@ import type { ReactorSlotComponent } from '@datalayer/reactor/react';
 import type { ServiceManagerSource } from './browserService';
 import { type TeamSelection } from './team';
 import { type SandboxTarget, type SwitchableSandboxService } from './switchable';
+/**
+ * The tutor.
+ *
+ * The front door of the notebook team, and the agent a person landing on a
+ * Datalayer runtime should meet first. A host that wants another names it in
+ * this plugin's config. Here, beside the plugin rather than in the bridge, so
+ * that a host describing the agent its workspace runs on Datalayer can name
+ * it without loading the bridge's runtime stack.
+ */
+export declare const DEFAULT_DATALAYER_AGENTSPEC = "jupyter-tutor";
 export declare const AGENTS_PLUGIN_NAME = "@datalayer/loop-plugin-agents";
 export type AgentsConfig = {
     /** Server the server-backed targets are reached through. */

package/lib/apps/plugins/agents/plugin.js

@@ -13,6 +13,16 @@ import { SandboxSelector } from './SandboxSelector';
 import { TeamMemberPicker } from './TeamMemberPicker';
 import { createTeamSelection } from './team';
 import { createSwitchableSandboxService, heldTargetReason, TARGET_SPECS, targetHasAgent, } from './switchable';
+/**
+ * The tutor.
+ *
+ * The front door of the notebook team, and the agent a person landing on a
+ * Datalayer runtime should meet first. A host that wants another names it in
+ * this plugin's config. Here, beside the plugin rather than in the bridge, so
+ * that a host describing the agent its workspace runs on Datalayer can name
+ * it without loading the bridge's runtime stack.
+ */
+export const DEFAULT_DATALAYER_AGENTSPEC = 'jupyter-tutor';
 export const AGENTS_PLUGIN_NAME = '@datalayer/loop-plugin-agents';
 /** The target asked for, or the page itself when this page holds it. */
 const offeredTarget = (target, serverUrl) => (heldTargetReason(target, serverUrl) ? 'browser' : target);

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

@@ -4,8 +4,10 @@
  * message that asks it in words. A choice is its buttons — a rule's prompt
  * is Allow and Refuse — the words a field, a form its fields; each press of
  * it is `reactor.answer`, through the display's `act`, which the chat sends
- * up the conversation's ui socket. A file is attached in the composer (until
- * RU-6). Answered, it says what answered it, and offers nothing.
+ * up the conversation's ui socket. A file is chosen here, uploaded first
+ * through the display's `upload`, and its ref is the answer (RU-6): its
+ * bytes never ride in the press. Answered, it says what answered it, and
+ * offers nothing.
  *
  * @module apps/plugins/app-elements/QuestionView
  */
@@ -24,5 +26,5 @@ export declare function questionOf(display: Display): {
     answered: string | null;
     answerable: boolean;
 };
-export declare function QuestionView({ display, act }: RendererProps): JSX.Element;
+export declare function QuestionView({ display, act, upload, }: RendererProps): JSX.Element;
 export default QuestionView;

package/lib/apps/plugins/app-elements/QuestionView.js

@@ -32,7 +32,7 @@ export function questionOf(display) {
         answerable: (display.actions ?? []).some(offer => offer.name === ANSWER_ACTION),
     };
 }
-export function QuestionView({ display, act }) {
+export function QuestionView({ display, act, upload, }) {
     const question = questionOf(display);
     const [words, setWords] = useState('');
     const [said, setSaid] = useState(null);
@@ -52,6 +52,19 @@ export function QuestionView({ display, act }) {
                     event.preventDefault();
                     if (words.trim())
                         answer(words.trim());
-                }, children: [_jsx(TextInput, { "aria-label": question.prompt, value: words, disabled: !live, onChange: event => setWords(event.target.value) }), _jsx(Button, { type: "submit", size: "small", disabled: !live || !words.trim(), children: "Answer" })] })) : null, question.kind === 'form' ? (_jsx(Suspense, { fallback: null, children: _jsx(SchemaForm, { schema: question.form, disabled: !live, onSubmit: ({ formData }) => answer(formData ?? {}) }) })) : null, question.kind === 'file' ? (_jsxs(Text, { as: "p", sx: { color: 'fg.muted', fontSize: 1, m: 0 }, children: ["Attach the file in the message box", question.accept.length ? ` (${question.accept.join(', ')})` : '', "."] })) : null, said ? (_jsx(Text, { as: "p", sx: { color: 'danger.fg', fontSize: 1, m: 0 }, children: said })) : null] }));
+                }, children: [_jsx(TextInput, { "aria-label": question.prompt, value: words, disabled: !live, onChange: event => setWords(event.target.value) }), _jsx(Button, { type: "submit", size: "small", disabled: !live || !words.trim(), children: "Answer" })] })) : null, question.kind === 'form' ? (_jsx(Suspense, { fallback: null, children: _jsx(SchemaForm, { schema: question.form, disabled: !live, onSubmit: ({ formData }) => answer(formData ?? {}) }) })) : null, question.kind === 'file' ? (_jsx("input", { type: "file", "aria-label": question.prompt, accept: question.accept.join(',') || undefined, disabled: !live || !upload, onChange: event => {
+                    const chosen = event.target.files?.[0];
+                    if (!chosen)
+                        return;
+                    if (!upload) {
+                        setSaid('The chat cannot take a file here.');
+                        return;
+                    }
+                    setSaid(null);
+                    // Uploaded first: the answer is its ref (REACTOR_UI RU-6).
+                    void upload(chosen)
+                        .then(ref => answer(ref))
+                        .catch((failure) => setSaid(failure instanceof Error ? failure.message : String(failure)));
+                } })) : null, said ? (_jsx(Text, { as: "p", sx: { color: 'danger.fg', fontSize: 1, m: 0 }, children: said })) : null] }));
 }
 export default QuestionView;

package/lib/apps/plugins/app-page/appPageModel.d.ts

@@ -162,16 +162,14 @@ export declare function settingsOf(app: Pick<AppSpec, 'interface'>, inputs: unkn
  */
 export declare function pageInputsOf(app: Pick<AppSpec, 'kind' | 'interface'>, inputs: unknown): Record<string, unknown>;
 /**
- * What the page did besides its message, for the session API: the action of
- * the block pressed, the files given with it, the settings it holds. Sent
- * with the chat's own run (AG-UI's `forwardedProps.loop`), so that what it
- * answers streams in the conversation (LOOP R-04).
+ * What the page did besides its message, for the session API: the files
+ * given with it, the settings it holds. Sent with the chat's own run (AG-UI's
+ * `forwardedProps.loop`), so that what it answers streams in the
+ * conversation (LOOP R-04). A block sends a message, never an action of its
+ * own: an action of the application's code is pressed with the token its
+ * session offered, up the ui socket (REACTOR_UI RU-5).
  */
 export type AppPageLoop = {
-    action: {
-        name: string;
-        payload: Record<string, unknown>;
-    };
     files?: GivenFile[];
     settings?: Record<string, unknown>;
 };

package/lib/apps/plugins/app-page/appPageModel.js

@@ -474,9 +474,7 @@ export function appPageAction(app, event, read, lastInputs = '') {
     const message = typeof given === 'string' ? given.trim() : '';
     const inputs = paths.inputs ? inputsInWords(app, read('/inputs')) : '';
     const settings = paths.inputs ? settingsOf(app, read('/inputs')) : undefined;
-    const payload = Object.fromEntries(Object.entries(event.context ?? {}).filter(([key]) => key !== 'message' && key !== 'files'));
     const loop = (files) => ({
-        action: { name: event.name, payload },
         ...(files && files.length > 0 ? { files } : {}),
         ...(settings ? { settings } : {}),
     });

package/lib/apps/plugins/app-page/pageRun.d.ts

@@ -3,8 +3,8 @@
  *
  * The page opens a session of the application's agent on its runtime
  * (`POST /api/v1/apps/sessions`), then, each time an input changes, sends
- * them all as the session's `page` action (`POST …/sessions/{uid}/actions`,
- * `{name: "page", payload: {inputs}}`). The runtime checks them against the
+ * them all to its page (`POST …/sessions/{uid}/page`, `{inputs}`) — not an
+ * action of its code (REACTOR_UI RU-5). The runtime checks them against the
  * page's form — refused with 422 and a sentence — runs its code's
  * `@app.page` on them, and answers its outputs as a `CUSTOM` event named
  * `loop.page`, `{inputs, outputs}`, which the page shows in place. Nothing is