@datalayer/agent-runtimes 1.3.114 → 1.5.0

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

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

package/lib/apps/apps/appspec.js

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

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

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

package/lib/apps/apps/checks.js

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

package/lib/apps/apps/customComponents.js

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

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

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

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

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

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

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

package/lib/apps/embed/embedSession.js

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

package/lib/apps/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