@datalayer/agent-runtimes 1.3.37 → 1.3.39

package/lib/chat/base/ChatBase.js

@@ -2812,7 +2812,10 @@ showToolApprovalBanner = true, pendingApprovals: pendingApprovalsProp, onApprove
     // ========================================================================
     // handleSend
     // ========================================================================
-    const handleSend = useCallback(async (messageOverride) => {
+    const handleSend = useCallback(async (messageOverride, 
+    // AG-UI's: what goes with the run besides the conversation — an
+    // application's page says there what it did (LOOP R-04).
+    forwardedProps) => {
         const messageContent = (messageOverride ?? input).trim();
         if (!messageContent || isLoading)
             return;
@@ -2915,6 +2918,7 @@ showToolApprovalBanner = true, pendingApprovals: pendingApprovalsProp, onApprove
                     builtinTools: enabledMcpToolNames,
                     skills: enabledSkillIds,
                     identities: connectedIdentitiesRef.current,
+                    ...(forwardedProps ? { forwardedProps } : {}),
                 });
             }
         }
@@ -3099,8 +3103,8 @@ showToolApprovalBanner = true, pendingApprovals: pendingApprovalsProp, onApprove
             return undefined;
         }
         onSendReady({
-            send: (message) => {
-                void handleSend(message);
+            send: (message, forwardedProps) => {
+                void handleSend(message, forwardedProps);
             },
             stop: handleStop,
             // The same reset the header's + performs, for a host whose controls

package/lib/components/a2ui/visibleWhen.d.ts

@@ -17,3 +17,10 @@ export declare function withVisibleWhen(component: ReactComponentImplementation)
  * it — with `visible_when` on every component.
  */
 export declare const datalayerCatalog: Catalog<ReactComponentImplementation, import("@a2ui/web_core/v0_9").FunctionImplementation>;
+/**
+ * Datalayer's catalog narrowed to the components named — what the enabled
+ * plugins contribute as blocks (LOOP R-01b, `loop.canvas.block`), so that an
+ * application's page draws what its Canvas can place and nothing else. Under
+ * the same id; a name the catalog does not draw is an error.
+ */
+export declare function catalogOfBlocks(names: readonly string[]): Catalog<ReactComponentImplementation>;

package/lib/components/a2ui/visibleWhen.js

@@ -55,3 +55,16 @@ export function withVisibleWhen(component) {
  * it — with `visible_when` on every component.
  */
 export const datalayerCatalog = new Catalog(basicCatalog.id, basicCatalog.protocolVersion, [...basicCatalog.components.values(), ...OWN_COMPONENTS].map(withVisibleWhen), [...basicCatalog.functions.values()], basicCatalog.themeSchema, basicCatalog.instructions);
+/**
+ * Datalayer's catalog narrowed to the components named — what the enabled
+ * plugins contribute as blocks (LOOP R-01b, `loop.canvas.block`), so that an
+ * application's page draws what its Canvas can place and nothing else. Under
+ * the same id; a name the catalog does not draw is an error.
+ */
+export function catalogOfBlocks(names) {
+    const unknown = names.filter(name => !datalayerCatalog.components.has(name));
+    if (unknown.length > 0) {
+        throw new Error(`No renderer draws ${unknown.join(', ')}: a block is contributed by a plugin whose component the catalog draws.`);
+    }
+    return new Catalog(datalayerCatalog.id, datalayerCatalog.protocolVersion, names.map(name => datalayerCatalog.components.get(name)), [...datalayerCatalog.functions.values()], datalayerCatalog.themeSchema, datalayerCatalog.instructions);
+}

package/lib/loop/apps/AppRenderer.d.ts

@@ -1,6 +1,45 @@
-import type { ReactorPlugin } from '@datalayer/reactor';
+/**
+ * An application, rendered: the LOOP workspace configured from an Appspec
+ * (LOOP R-01).
+ *
+ * One renderer for every place an application appears — the Studio's
+ * Preview, its hosted page, an embed, the home page — so that what a builder
+ * sees while building is what its users get. It is not a second shell: it is
+ * `LoopEmbed`, given
+ *
+ * - an **application plugin** (`defineAppPlugin`): the agent that answers,
+ *   created with the application in its payload — so the runtime reaches only
+ *   what the application connects to and enforces its rules before every tool
+ *   call — and the application's starters as the openers of the empty chat;
+ * - its **layout**, as `interface.layout` says (`appLayoutOptions`, LOOP
+ *   T-07), on the workspace's own `page-layout` plugin: `chat` is the
+ *   conversation alone, with the A2UI surfaces its answers draw; `page` is
+ *   the page on a sheet with the composer over it and the conversation in a
+ *   panel the composer's display modes open; `split` is the conversation and
+ *   the page side by side, a hairline between them to drag;
+ * - its **page**, when it has one (`hasAppPage`: a chat, a widget or a worker
+ *   with a `page` or `split` layout): its A2UI surface drawn by the
+ *   `app-page` plugin, in place of the notebook and the document, fed from
+ *   the conversation and answered through it (`APP_KIND_PATHS`), with the
+ *   Canvas's block plugins (`CANVAS_BLOCK_PLUGINS`), whose blocks are what
+ *   the page draws (R-01b);
+ * - a **decision**: a workspace without a conversation whose one view is the
+ *   page its host draws (`page`, R-02) — the Studio's run page, at its
+ *   address and embedded;
+ * - its **frame**, when the host asks (`frame`): the `window-frame` plugin's
+ *   window, its title the application's face and name.
+ *
+ * Which plugins a kind needs, and how its workspace is laid out, is one
+ * function: `appPreset`, the preset per kind, as `loopPlugins` is for the
+ * examples.
+ *
+ * @module loop/apps/AppRenderer
+ */
+import { type ComponentType } from 'react';
+import type { PluginRef, ReactorPlugin } from '@datalayer/reactor';
 import type { AppSpec } from '../../types/agentspecs';
 import type { ThemeOverrides } from '../../types/chat';
+import { type AppHostPageProps } from '../plugins/app-page';
 import { type LoopEmbedProps } from '../embed/LoopEmbed';
 import type { LoopPresetOptions } from '../presets';
 import type { PresenceState } from '../../chat/presence/presenceStatus';
@@ -44,6 +83,19 @@ export type AppRendererProps = Omit<LoopEmbedProps, 'agentId'> & {
      * the application's face and name. A host's own `frameTitle` wins.
      */
     frame?: boolean;
+    /**
+     * The page a host draws for a kind the workspace has no page for: a
+     * decision's (R-02). The workspace's one view. A component defined once,
+     * outside the host's render: a new one would be a new plugin, and restart
+     * the workspace.
+     */
+    page?: ComponentType<AppHostPageProps>;
+    /**
+     * The UI plugins its organization has turned off (`plugins_off`, catalogue
+     * ids such as 'a2ui'): their blocks are off its page as they are off its
+     * Canvas's palette. Compared by content.
+     */
+    pluginsOff?: readonly string[];
 };
 /** What `interface.layout` sets on the workspace. */
 export type AppLayoutOptions = Pick<LoopPresetOptions, 'editors' | 'showViewSelector' | 'defaultEditor' | 'pageLayout' | 'pageLayoutArrangement' | 'pageLayoutPrompt' | 'pageLayoutPromptAnchor' | 'pageLayoutTurnPanelFooter'>;
@@ -62,6 +114,31 @@ export type AppLayoutOptions = Pick<LoopPresetOptions, 'editors' | 'showViewSele
  * it; without one (a decision, whose page is the Studio's), the editors stay.
  */
 export declare function appLayoutOptions(app: Pick<AppSpec, 'kind' | 'interface' | 'agent'>): AppLayoutOptions;
+/** What a kind of application is drawn with: its plugins, and its workspace. */
+export type AppPreset = {
+    plugins: PluginRef[];
+    workspace: AppLayoutOptions & Pick<LoopPresetOptions, 'conversation'>;
+};
+/**
+ * The plugins an application's kind needs, and how its workspace is laid
+ * out (LOOP R-01): the preset per kind, as `loopPlugins` is for the examples.
+ *
+ * - a **chat**, a **widget**, a **worker**: its agent (`defineAppPlugin`);
+ *   its page (`app-page`) when it has one, with the Canvas's block plugins
+ *   but those of the UI plugins its organization turned off (`pluginsOff`),
+ *   whose contributions are the blocks it may draw (R-01b); a thumb and a
+ *   comment on each answer when its record keeps feedback (V-18); laid out
+ *   as `interface.layout` says;
+ * - a **decision**: the page its host draws (`page`), as the one view of a
+ *   workspace without a conversation (R-02).
+ *
+ * An application that cannot be drawn is refused with a sentence: a
+ * decision without its host's page, an application run by a team.
+ */
+export declare function appPreset(app: AppSpec, options?: {
+    page?: ComponentType<AppHostPageProps>;
+    pluginsOff?: readonly string[];
+}): AppPreset;
 /**
  * What an application's agent is created with on a Datalayer runtime: under
  * the application's id, over AG-UI, with the application's own document —
@@ -87,5 +164,5 @@ export declare const DATALAYER_BOOTSTRAP_AGENTSPEC = "example-simple";
  * what the page around it set does not reach in.
  */
 export declare function appThemeOverrides(app: AppSpec): ThemeOverrides | undefined;
-export declare function AppRenderer({ app, plugins, instance, onPresence, frame, ...embed }: AppRendererProps): React.JSX.Element;
+export declare function AppRenderer({ app, plugins, instance, onPresence, frame, page, pluginsOff, ...embed }: AppRendererProps): React.JSX.Element;
 export default AppRenderer;

package/lib/loop/apps/AppRenderer.js

@@ -1,4 +1,4 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
 /*
  * Copyright (c) 2025-2026 Datalayer, Inc.
  * Distributed under the terms of the Modified BSD License.
@@ -25,18 +25,26 @@ import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
  * - its **page**, when it has one (`hasAppPage`: a chat, a widget or a worker
  *   with a `page` or `split` layout): its A2UI surface drawn by the
  *   `app-page` plugin, in place of the notebook and the document, fed from
- *   the conversation and answered through it (`APP_KIND_PATHS`). A
- *   decision's page stays the Studio's run page (R-02); its layout keeps the
- *   editors;
+ *   the conversation and answered through it (`APP_KIND_PATHS`), with the
+ *   Canvas's block plugins (`CANVAS_BLOCK_PLUGINS`), whose blocks are what
+ *   the page draws (R-01b);
+ * - a **decision**: a workspace without a conversation whose one view is the
+ *   page its host draws (`page`, R-02) — the Studio's run page, at its
+ *   address and embedded;
  * - its **frame**, when the host asks (`frame`): the `window-frame` plugin's
  *   window, its title the application's face and name.
  *
+ * Which plugins a kind needs, and how its workspace is laid out, is one
+ * function: `appPreset`, the preset per kind, as `loopPlugins` is for the
+ * examples.
+ *
  * @module loop/apps/AppRenderer
  */
 import { useMemo } from 'react';
 import { loopAccentStyles } from '@datalayer/primer-addons';
 import { defineAgentCapacityPlugin } from '../plugins/agent-capacity';
-import { APP_PAGE_SURFACE, defineAppPagePlugin, hasAppPage, } from '../plugins/app-page';
+import { APP_PAGE_SURFACE, defineAppHostPagePlugin, defineAppPagePlugin, hasAppPage, } from '../plugins/app-page';
+import { CANVAS_BLOCK_PLUGINS, canvasBlocksPluginName, } from '../plugins/canvas-blocks';
 import { LoopEmbed } from '../embed/LoopEmbed';
 import { dumpAppspec } from './appspec';
 import { defineAppFeedbackPlugin } from './AppFeedback';
@@ -118,6 +126,51 @@ export function appLayoutOptions(app) {
         pageLayoutTurnPanelFooter: 'actions',
     };
 }
+/**
+ * The plugins an application's kind needs, and how its workspace is laid
+ * out (LOOP R-01): the preset per kind, as `loopPlugins` is for the examples.
+ *
+ * - a **chat**, a **widget**, a **worker**: its agent (`defineAppPlugin`);
+ *   its page (`app-page`) when it has one, with the Canvas's block plugins
+ *   but those of the UI plugins its organization turned off (`pluginsOff`),
+ *   whose contributions are the blocks it may draw (R-01b); a thumb and a
+ *   comment on each answer when its record keeps feedback (V-18); laid out
+ *   as `interface.layout` says;
+ * - a **decision**: the page its host draws (`page`), as the one view of a
+ *   workspace without a conversation (R-02).
+ *
+ * An application that cannot be drawn is refused with a sentence: a
+ * decision without its host's page, an application run by a team.
+ */
+export function appPreset(app, options = {}) {
+    if (app.kind === 'decision') {
+        if (!options.page) {
+            throw new Error(`“${app.name}” is a decision, whose page is drawn by where it runs: none was given here.`);
+        }
+        return {
+            plugins: [defineAppHostPagePlugin(app, options.page)],
+            workspace: {
+                conversation: false,
+                editors: false,
+                showViewSelector: false,
+            },
+        };
+    }
+    const withPage = hasAppPage(app);
+    // The blocks its Canvas offers: those of the UI plugins not turned off.
+    const off = new Set((options.pluginsOff ?? []).map(canvasBlocksPluginName));
+    const blocks = CANVAS_BLOCK_PLUGINS.filter(plugin => !off.has(plugin.name));
+    return {
+        plugins: [
+            defineAppPlugin(app),
+            ...(withPage ? [defineAppPagePlugin(app), ...blocks] : []),
+            // A thumb and a comment on each answer, kept in its record (LOOP
+            // V-18): only for an application whose record keeps feedback.
+            ...(keepsFeedback(app) ? [defineAppFeedbackPlugin(app)] : []),
+        ],
+        workspace: appLayoutOptions(app),
+    };
+}
 /**
  * What an application's agent is created with on a Datalayer runtime: under
  * the application's id, over AG-UI, with the application's own document —
@@ -174,52 +227,50 @@ export function appThemeOverrides(app) {
         }
         : undefined;
 }
-export function AppRenderer({ app, plugins = NO_PLUGINS, instance, onPresence, frame = false, ...embed }) {
+export function AppRenderer({ app, plugins = NO_PLUGINS, instance, onPresence, frame = false, page, pluginsOff, ...embed }) {
     /*
-     * The application plugin, made once per application. `LoopEmbed` rebuilds
-     * its whole reactor when its plugins change, so a new plugin on every
-     * render of the host would restart the running workspace. The key is the
+     * The kind's plugins, made once per application. `LoopEmbed` rebuilds its
+     * whole reactor when its plugins change, so a new plugin on every render
+     * of the host would restart the running workspace. The key is the
      * application as its file holds it: a change to it is a new application.
      */
     const source = JSON.stringify(dumpAppspec(app));
-    const appPlugin = useMemo(() => (app.agent ? defineAppPlugin(app) : null), 
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [source]);
-    const withPage = hasAppPage(app);
-    const pagePlugin = useMemo(() => (withPage ? defineAppPagePlugin(app) : null), 
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [source, withPage]);
-    /*
-     * A thumb and a comment on each answer, kept in its record (LOOP V-18):
-     * only for an application whose record keeps feedback.
-     */
-    const keeps = keepsFeedback(app);
-    const feedbackPlugin = useMemo(() => (keeps ? defineAppFeedbackPlugin(app) : null), 
+    const off = [...(pluginsOff ?? [])].sort().join(',');
+    const preset = useMemo(() => {
+        try {
+            return appPreset(app, { page, pluginsOff });
+        }
+        catch (error) {
+            return {
+                problem: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }, 
     // eslint-disable-next-line react-hooks/exhaustive-deps
-    [source, keeps]);
-    const allPlugins = useMemo(() => appPlugin
-        ? [
-            appPlugin,
-            ...(pagePlugin ? [pagePlugin] : []),
-            ...(feedbackPlugin ? [feedbackPlugin] : []),
-            ...plugins,
-        ]
-        : plugins, [appPlugin, pagePlugin, feedbackPlugin, plugins]);
+    [source, page, off]);
+    const allPlugins = useMemo(() => ('problem' in preset ? plugins : [...preset.plugins, ...plugins]), [preset, plugins]);
     /*
      * On Datalayer, the application runs on a runtime: allocated with a plain
      * agentspec, its agent created there with the application's spec — so that
      * the runtime registers it and decides every tool call by its rules (LOOP
      * R-03, R-05), as `loop apps run --cloud` does.
      */
-    const datalayerCreatePayload = useMemo(() => (app.agent ? appDatalayerCreatePayload(app, instance) : undefined), 
+    const conversation = !('problem' in preset) && preset.workspace.conversation !== false;
+    const datalayerCreatePayload = useMemo(() => (conversation ? appDatalayerCreatePayload(app, instance) : undefined), 
     // eslint-disable-next-line react-hooks/exhaustive-deps
-    [source, instance?.appUid, instance?.deploymentUid, instance?.version]);
+    [
+        source,
+        conversation,
+        instance?.appUid,
+        instance?.deploymentUid,
+        instance?.version,
+    ]);
     const accent = app.interface?.accent;
     const themeOverrides = useMemo(() => appThemeOverrides(app), 
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [accent]);
-    if (!appPlugin) {
-        return (_jsxs("div", { role: "status", style: { padding: 16 }, children: ["\u201C", app.name, "\u201D is run by a team, which the workspace does not run as an application yet."] }));
+    if ('problem' in preset) {
+        return (_jsx("div", { role: "status", style: { padding: 16 }, children: preset.problem }));
     }
     return (_jsx(LoopEmbed
     // The application's own agent: created under its id, so that its
@@ -227,7 +278,7 @@ export function AppRenderer({ app, plugins = NO_PLUGINS, instance, onPresence, f
     , { 
         // The application's own agent: created under its id, so that its
         // spec is applied to an agent of its own, never to the one it extends.
-        agentId: app.id, ...appLayoutOptions(app), ...(frame
+        agentId: app.id, ...preset.workspace, ...(frame
             ? {
                 frameTitle: [app.emoji, app.name].filter(Boolean).join(' '),
             }

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

@@ -227,8 +227,12 @@ export type ViewControls = {
      * rendered surface, whose values the agent should answer. The chat had
      * this control from the start and kept it to itself; a host with a
      * message had no way in.
+     *
+     * `forwardedProps` go with the run as AG-UI's: an application's page says
+     * there what it did besides the message (`loop`, LOOP R-04). Answers why
+     * the message cannot go, when it cannot.
      */
-    send?: (message: string) => void;
+    send?: (message: string, forwardedProps?: Record<string, unknown>) => string | void;
 };
 /** Props every view receives. */
 export type LoopViewProps = {
@@ -955,10 +959,29 @@ export type ChatTurnSnapshot = {
      */
     activity?: string;
 };
+/**
+ * One message of the conversation, as a page shows it (LOOP R-01, C-18): a
+ * person's or the assistant's words, or a tool the assistant called — what
+ * the Chat component draws, bound to a chat application's `/messages`.
+ */
+export type ConversationEntry = {
+    role: 'user' | 'assistant';
+    text: string;
+} | {
+    role: 'tool';
+    name: string;
+    args: Record<string, unknown>;
+    result?: unknown;
+};
 export type ChatTurnContribution = {
     /** Stable id, for the registry and the graph. */
     id: string;
     /** The turn, live. */
     turn: ReadonlySignal<ChatTurnSnapshot>;
+    /**
+     * The whole conversation, live: every message and tool call in order, the
+     * reply as it streams included; empty again when the chat starts over.
+     */
+    conversation: ReadonlySignal<ConversationEntry[]>;
 };
 export declare const LoopChatTurn: import("@datalayer/reactor").ContributionPoint<ChatTurnContribution>;

package/lib/loop/embed/AppEmbed.js

@@ -80,7 +80,8 @@ function useServerAgent(app, serverUrl) {
                 setState({
                     protocol: {
                         type: 'ag-ui',
-                        endpoint: `${base}/api/v1/ag-ui/${app.id}/`,
+                        // Its session API: each thread a session (LOOP R-04).
+                        endpoint: `${base}/api/v1/apps/agents/${encodeURIComponent(app.id)}/ag-ui/`,
                         agentId: app.id,
                     },
                 });
@@ -137,7 +138,8 @@ function useDatalayerAgent(app, instance) {
     return {
         protocol: {
             type: 'ag-ui',
-            endpoint: `${runtime.agentBaseUrl}/api/v1/ag-ui/${app.id}/`,
+            // Its session API: each thread a session (LOOP R-04).
+            endpoint: `${runtime.agentBaseUrl}/api/v1/apps/agents/${encodeURIComponent(app.id)}/ag-ui/`,
             agentId: app.id,
             authToken: token,
         },

package/lib/loop/embed/LoopEmbed.js

@@ -100,6 +100,7 @@ export function LoopEmbed({ agentId = '', showHeader = false, chatHeaderActions,
         preset.floatingPrompt,
         preset.editorSelector,
         preset.editors,
+        preset.conversation,
         preset.graph,
         preset.commandPalette,
         preset.pluginsPanel,

package/lib/loop/index.d.ts

@@ -15,7 +15,7 @@ export { ChatPlugin, CHAT_PLUGIN_NAME, type ChatPluginConfig, } from './plugins/
 export { ChatHeaderPlugin, CHAT_HEADER_PLUGIN_NAME, } from './plugins/chat-header';
 export { InputPromptPlugin, INPUT_PROMPT_PLUGIN_NAME, type InputPromptPluginConfig, } from './plugins/input-prompt';
 export { createChatExtrasPlugin, CHAT_EXTRAS_PLUGIN_NAME, type ChatExtrasHandle, } from './plugins/chat-extras';
-export { LoopChatExtras, LoopChatLayout, LoopChatTurn, LoopOpeningDocument, LoopOpeningNotebook, LoopPromptPanel, type ChatLayoutContribution, type ChatLayoutParts, type ChatTurnContribution, type ChatTurnSnapshot, type ChatTurnStatus, type LoopChatExtrasValue, type OpeningDocumentContribution, type OpeningNotebookContribution, type PromptPanelContribution, } from './core';
+export { LoopChatExtras, LoopChatLayout, LoopChatTurn, LoopOpeningDocument, LoopOpeningNotebook, LoopPromptPanel, type ChatLayoutContribution, type ChatLayoutParts, type ChatTurnContribution, type ConversationEntry, type ChatTurnSnapshot, type ChatTurnStatus, type LoopChatExtrasValue, type OpeningDocumentContribution, type OpeningNotebookContribution, type PromptPanelContribution, } from './core';
 export { LoopPageLayoutPlugin, LOOP_PAGE_LAYOUT_PLUGIN_NAME, openConversationPanel, pageLayoutSheet, pageLayoutPanelOpen, setPageLayoutChatMode, SplitLayout, type LoopPageLayoutConfig, } from './plugins/page-layout';
 export { useOptionalTeamSelection } from './plugins/agents/useTeamSelection';
 export type { TeamMember, TeamSelection } from './plugins/agents/team';

package/lib/loop/plugins/a2ui-surface/InlineSurface.d.ts

@@ -13,13 +13,14 @@
  * an action is handed the surface it came from, so that what a block wrote
  * into its data model can be read when a button is pressed. It draws from
  * Datalayer's catalog: the basic one, any block shown only while its
- * `visible_when` holds.
+ * `visible_when` holds — or, given one, a catalog narrowed to the blocks
+ * the workspace's plugins contribute (`catalogOfBlocks`).
  *
  * @module loop/plugins/a2ui-surface/InlineSurface
  */
 import type { JSX } from 'react';
 import type { ReactComponentImplementation } from '@a2ui/react/v0_9';
-import { type A2uiClientAction, type A2uiMessage, type SurfaceModel } from '@a2ui/web_core/v0_9';
+import { Catalog, type A2uiClientAction, type A2uiMessage, type SurfaceModel } from '@a2ui/web_core/v0_9';
 /** A surface as the renderer holds it: its data model is `dataModel`. */
 export type InlineSurfaceModel = SurfaceModel<ReactComponentImplementation>;
 type Surface = InlineSurfaceModel;
@@ -27,8 +28,10 @@ type Surface = InlineSurfaceModel;
 export declare const SURFACE_CATALOG_ID: string;
 /** Values to publish into a surface, by path. */
 export type InlineSurfaceData = Record<string, unknown>;
-export declare function InlineSurface({ messages, onAction, validationError, data, }: {
+export declare function InlineSurface({ messages, onAction, validationError, data, catalog, }: {
     messages: A2uiMessage[];
+    /** What it draws with, read once: Datalayer's catalog unless given. */
+    catalog?: Catalog<ReactComponentImplementation>;
     /** Told of an action, with the surface it came from. */
     onAction: (action: A2uiClientAction, surface?: Surface) => void;
     validationError?: string | null;

package/lib/loop/plugins/a2ui-surface/InlineSurface.js

@@ -11,12 +11,15 @@ const INHERIT_THEME = {
     ['--a2ui-color-primary']: 'var(--fgColor-accent)',
     ['--a2ui-color-outline']: 'var(--borderColor-default)',
 };
-export function InlineSurface({ messages, onAction, validationError, data, }) {
+export function InlineSurface({ messages, onAction, validationError, data, catalog = datalayerCatalog, }) {
     // Reached through a ref: the processor is built once, and the handler it
     // was built with must not go stale when the host's does not.
     const onActionRef = useRef(onAction);
     onActionRef.current = onAction;
-    const processor = useMemo(() => new MessageProcessor([datalayerCatalog], action => onActionRef.current(action, processorRef.current?.model.getSurface(action.surfaceId))), []);
+    const processor = useMemo(() => new MessageProcessor([catalog], action => onActionRef.current(action, processorRef.current?.model.getSurface(action.surfaceId))), 
+    // Once: a host that changes what it draws with mounts a new surface.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []);
     const processorRef = useRef(undefined);
     processorRef.current = processor;
     const [surfaces, setSurfaces] = useState([]);

package/lib/loop/plugins/app-page/AppPage.d.ts

@@ -1,13 +1,27 @@
 /**
  * An application's page, drawn beside its conversation: its A2UI surface on
  * the workspace's own renderer (`InlineSurface`), fed by the chat's current
- * turn, its buttons answered through the chat's controls.
+ * turn and its conversation, its buttons — and a Chat block's message, a File
+ * upload's files — answered through the chat's controls, what the page did
+ * going with the chat's run to the application's session (LOOP R-04).
+ *
+ * It draws the blocks the workspace's plugins contribute to the Canvas's
+ * palette (`loop.canvas.block`, R-01b) and nothing else, so that what the
+ * Canvas can place and what the page can draw are one list: a page that
+ * uses a block no enabled plugin contributes says so, in place of the page.
  *
  * @module loop/plugins/app-page/AppPage
  */
 import type { JSX } from 'react';
 import type { AppSpec } from '../../../types/agentspecs';
 import { type LoopWorkspaceContext } from '../../core';
+/** The components a page's messages place, each once. */
+export declare function componentsOnPage(messages: readonly unknown[]): string[];
+/**
+ * Why a page is not drawn with the blocks contributed, or null: the blocks it
+ * places that no enabled plugin contributes.
+ */
+export declare function blocksMissing(placed: readonly string[], contributed: readonly string[]): string | null;
 export type AppPageProps = {
     app: AppSpec;
     workspace: LoopWorkspaceContext;

package/lib/loop/plugins/app-page/AppPage.js

@@ -3,16 +3,61 @@ import { useCallback, useMemo, useRef, useState } from 'react';
 import { Box } from '@datalayer/primer-addons';
 import { signal } from '@datalayer/reactor';
 import { useContributions, useSignalValue } from '@datalayer/reactor/react';
-import { LoopChatTurn, } from '../../core';
+import { catalogOfBlocks } from '../../../components/a2ui';
+import { LoopCanvasBlock, LoopChatTurn, } from '../../core';
 import { InlineSurface, SURFACE_CATALOG_ID, } from '../a2ui-surface/InlineSurface';
 import { appPageAction, appPageData, appPageMessages } from './appPageModel';
 /** No chat in the workspace: the page reads a turn that never starts. */
 const NO_TURN = signal({ id: 0, status: 'idle' });
+const NO_CONVERSATION = signal([]);
+/** The components a page's messages place, each once. */
+export function componentsOnPage(messages) {
+    const names = new Set();
+    for (const message of messages) {
+        const update = message.updateComponents;
+        for (const node of update?.components ?? []) {
+            names.add(String(node.component));
+        }
+    }
+    return [...names];
+}
+/**
+ * Why a page is not drawn with the blocks contributed, or null: the blocks it
+ * places that no enabled plugin contributes.
+ */
+export function blocksMissing(placed, contributed) {
+    const have = new Set(contributed);
+    const missing = placed.filter(name => !have.has(name));
+    if (missing.length === 0) {
+        return null;
+    }
+    return `This page places ${missing.join(', ')}, which no enabled plugin contributes: ${missing.length === 1 ? 'it is' : 'they are'} drawn once the plugin that contributes ${missing.length === 1 ? 'it' : 'them'} is on.`;
+}
 export function AppPage({ app, workspace }) {
     const entries = useContributions(LoopChatTurn);
     const turn = useSignalValue(entries[0]?.value.turn ?? NO_TURN);
+    const conversation = useSignalValue(entries[0]?.value.conversation ?? NO_CONVERSATION);
     const messages = useMemo(() => appPageMessages(app, SURFACE_CATALOG_ID), [app]);
-    const data = useMemo(() => appPageData(app, turn), [app, turn]);
+    // The blocks the enabled plugins contribute: what this page may draw.
+    const blocks = useContributions(LoopCanvasBlock);
+    const contributed = [...new Set(blocks.map(entry => entry.value.id))].sort();
+    const drawnWith = contributed.join(',');
+    const drawing = useMemo(() => {
+        const missing = blocksMissing(componentsOnPage(messages), contributed);
+        if (missing) {
+            return { problem: missing };
+        }
+        try {
+            return { catalog: catalogOfBlocks(contributed) };
+        }
+        catch (error) {
+            return {
+                problem: error instanceof Error ? error.message : String(error),
+            };
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [messages, drawnWith]);
+    const data = useMemo(() => appPageData(app, turn, conversation), [app, turn, conversation]);
     const [refusal, setRefusal] = useState(null);
     // The workspace changes as the chat reports itself; the handler reads the latest.
     const workspaceRef = useRef(workspace);
@@ -34,10 +79,20 @@ export function AppPage({ app, workspace }) {
             controls.newChat?.();
         }
         else {
-            // The chat's own send, as a surface in the transcript submits; the
-            // prompt channel when the chat has not reported itself yet.
+            // The chat's own send, with what the page did besides — the block's
+            // action, its files, the settings — for the application's session
+            // (R-04); the prompt channel when the chat has not reported itself
+            // yet, which carries words only.
             if (controls.send) {
-                controls.send(outcome.send);
+                const refused = controls.send(outcome.send, { loop: outcome.loop });
+                if (refused) {
+                    setRefusal(refused);
+                    return;
+                }
+            }
+            else if (outcome.loop.files) {
+                setRefusal('The conversation is not ready for a file yet: try again.');
+                return;
             }
             else {
                 workspaceRef.current.prompts.submit(outcome.send);
@@ -48,6 +103,8 @@ export function AppPage({ app, workspace }) {
             }
         }
     }, [app]);
-    return (_jsx(Box, { "data-testid": "app-page", sx: { height: '100%', minHeight: 0, overflow: 'auto', p: 3 }, children: _jsx(InlineSurface, { messages: messages, data: data, onAction: onAction, validationError: refusal }) }));
+    return (_jsx(Box, { "data-testid": "app-page", sx: { height: '100%', minHeight: 0, overflow: 'auto', p: 3 }, children: 'problem' in drawing ? (_jsx(Box, { role: "status", sx: { color: 'fg.muted', fontSize: 1 }, children: drawing.problem })) : (_jsx(InlineSurface
+        // A new list of blocks is a new surface, drawn with it.
+        , { messages: messages, data: data, onAction: onAction, validationError: refusal, catalog: drawing.catalog }, drawnWith)) }));
 }
 export default AppPage;