@datalayer/agent-runtimes 1.3.38 → 1.3.40

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 = {

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/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

@@ -2,13 +2,26 @@
  * 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 and its conversation, its buttons — and a Chat block's message, a File
- * upload's files — answered through the chat's controls.
+ * 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,17 +3,60 @@ 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]);
+    // 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.
@@ -36,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);
@@ -50,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;

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

@@ -10,9 +10,11 @@
  * data model at a path the application takes, and what a button does reaches
  * the application through the chat's own channels: a message sent, the
  * answer stopped, the conversation started over. Nothing here is a server
- * API; a setting reaches the application in the words of the message it is
- * sent with, until the session API carries a settings change (R-04), and so
- * does a text file given to a widget, its contents in the message (E-01).
+ * API: what a button did besides its message — the block's action, the files
+ * given, the settings — goes with the chat's own run to the application's
+ * session (LOOP R-04, `forwardedProps.loop`), which puts a file where the
+ * application reads it; a setting also reaches a written application in the
+ * words of its message.
  *
  * A decision is not here: its page is drawn by the Studio's run page, with
  * its own paths (`INTERFACE_PATHS`), until it moves onto the workspace (R-02).
@@ -108,21 +110,50 @@ export declare function appPageInitialData(app: Pick<AppSpec, 'kind' | 'name' |
  */
 export declare function inputsInWords(app: Pick<AppSpec, 'interface'>, inputs: unknown): string;
 /**
- * The most of a file's text a message carries: about thirty thousand
- * tokens. A larger file is refused in a sentence rather than sent for the
- * model to refuse.
+ * The largest file a session takes: what the session API refuses above
+ * (`agent_runtimes.loop.apps.sessions.MAX_FILE_BYTES`), said here before
+ * the file is sent.
  */
-export declare const MAX_FILE_CHARACTERS = 120000;
+export declare const MAX_FILE_BYTES: number;
+/** A file as File upload gives it, and as the session API takes it. */
+export type GivenFile = {
+    name: string;
+    type: string;
+    size: number;
+    data_url: string;
+};
 /**
- * The files given on the page with their contents, for the message a widget
- * is run with — or why one cannot go: it is not a file as File upload gives
- * it, not text, or too long for a message.
+ * The files given on the page, as the session API takes them — or why they
+ * cannot go: what was given is not files as File upload gives them, or one
+ * is larger than a session takes. What becomes of each — put in the
+ * application's sandbox, or its text in the message — is the session's to
+ * decide (LOOP R-04).
  */
-export declare function filesInWords(files: unknown): {
-    words: string;
+export declare function givenFiles(files: unknown): {
+    files: GivenFile[];
 } | {
     refused: string;
 };
+/**
+ * The application's settings as the page holds them, as the session API
+ * takes them: a choice as the option chosen, a number as a number, a toggle
+ * as on or off — each setting the page has a value for.
+ */
+export declare function settingsOf(app: Pick<AppSpec, '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).
+ */
+export type AppPageLoop = {
+    action: {
+        name: string;
+        payload: Record<string, unknown>;
+    };
+    files?: GivenFile[];
+    settings?: Record<string, unknown>;
+};
 /** What a button asked, as the surface hands it over. */
 export type AppPageEvent = {
     name: string;
@@ -132,6 +163,8 @@ export type AppPageEvent = {
 export type AppPageOutcome = {
     /** A message for the application, sent as the person's next turn. */
     send: string;
+    /** What the page did besides, for the session it is sent in. */
+    loop: AppPageLoop;
     /** The inputs in words as sent, to tell a change next time. */
     inputs: string;
     /** Paths to empty once it is sent. */

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

@@ -36,7 +36,7 @@ const MESSAGES = {
 };
 const FILES = {
     path: '/files',
-    meaning: 'The files given on the page, each {name, type, size, data_url}: a text file’s contents go with the next run.',
+    meaning: 'The files given on the page, each {name, type, size, data_url}: they go to the application’s session with the next run, put in its sandbox when it has a shell, a text file in the message when it has none.',
     words: 'The files given',
     list: true,
 };
@@ -96,7 +96,7 @@ export const APP_KIND_PATHS = {
         actions: [
             {
                 name: 'run',
-                meaning: 'Run it on its inputs: every value written under /inputs is sent, and each text file at /files, with the context’s message when there is one.',
+                meaning: 'Run it on its inputs: every value written under /inputs is sent, and each file at /files, with the context’s message when there is one.',
                 words: 'Run it on its inputs',
                 context: ['message'],
                 asks: { message: 'What it says before the inputs' },
@@ -301,81 +301,85 @@ export function inputsInWords(app, inputs) {
     return lines.filter(Boolean).join('\n');
 }
 /**
- * The most of a file's text a message carries: about thirty thousand
- * tokens. A larger file is refused in a sentence rather than sent for the
- * model to refuse.
+ * The largest file a session takes: what the session API refuses above
+ * (`agent_runtimes.loop.apps.sessions.MAX_FILE_BYTES`), said here before
+ * the file is sent.
  */
-export const MAX_FILE_CHARACTERS = 120_000;
-/** The kinds of file read as text, besides `text/*`. */
-const TEXT_TYPES = new Set([
-    'application/json',
-    'application/xml',
-    'application/yaml',
-    'application/x-yaml',
-    'application/csv',
-]);
-/** The extensions read as text whatever type the browser gives. */
-const TEXT_EXTENSIONS = /\.(csv|tsv|txt|md|json|jsonl|xml|ya?ml|log)$/i;
-/** The words of a data URL, decoded as UTF-8. */
-function dataUrlText(dataUrl) {
-    const comma = dataUrl.indexOf(',');
-    if (!dataUrl.startsWith('data:') || comma < 0) {
-        throw new Error('it is not a data URL');
-    }
-    const body = dataUrl.slice(comma + 1);
-    if (!dataUrl.slice(0, comma).endsWith(';base64')) {
-        return decodeURIComponent(body);
-    }
-    const bytes = Uint8Array.from(atob(body), char => char.charCodeAt(0));
-    return new TextDecoder('utf-8').decode(bytes);
-}
+export const MAX_FILE_BYTES = 25 * 1024 * 1024;
 /**
- * The files given on the page with their contents, for the message a widget
- * is run with — or why one cannot go: it is not a file as File upload gives
- * it, not text, or too long for a message.
+ * The files given on the page, as the session API takes them — or why they
+ * cannot go: what was given is not files as File upload gives them, or one
+ * is larger than a session takes. What becomes of each — put in the
+ * application's sandbox, or its text in the message — is the session's to
+ * decide (LOOP R-04).
  */
-export function filesInWords(files) {
+export function givenFiles(files) {
     if (files === undefined || files === null) {
-        return { words: '' };
+        return { files: [] };
     }
     if (!Array.isArray(files)) {
         return { refused: 'What was given as files is not a list of files.' };
     }
-    const parts = [];
+    const given = [];
     for (const [index, file] of files.entries()) {
-        const given = (file ?? {});
-        if (typeof given.name !== 'string' || typeof given.data_url !== 'string') {
+        const item = (file ?? {});
+        if (typeof item.name !== 'string' || typeof item.data_url !== 'string') {
             return {
                 refused: `File ${index + 1} is not a file as File upload gives it ({name, type, size, data_url}).`,
             };
         }
-        const name = given.name;
-        const type = typeof given.type === 'string' ? given.type : '';
-        if (!type.startsWith('text/') &&
-            !TEXT_TYPES.has(type) &&
-            !TEXT_EXTENSIONS.test(name)) {
+        const size = typeof item.size === 'number' ? item.size : 0;
+        if (size > MAX_FILE_BYTES) {
             return {
-                refused: `${name} is not a text file: the page hands its application a file's text, in its message.`,
+                refused: `${item.name} is ${size.toLocaleString('en')} bytes: a session takes files of at most ${MAX_FILE_BYTES.toLocaleString('en')}.`,
             };
         }
-        let text;
-        try {
-            text = dataUrlText(given.data_url);
-        }
-        catch (error) {
-            return {
-                refused: `${name} could not be read: ${error.message}.`,
-            };
+        given.push({
+            name: item.name,
+            type: typeof item.type === 'string' ? item.type : '',
+            size,
+            data_url: item.data_url,
+        });
+    }
+    return { files: given };
+}
+/**
+ * The application's settings as the page holds them, as the session API
+ * takes them: a choice as the option chosen, a number as a number, a toggle
+ * as on or off — each setting the page has a value for.
+ */
+export function settingsOf(app, inputs) {
+    const values = inputs && typeof inputs === 'object'
+        ? inputs
+        : {};
+    const settings = {};
+    for (const setting of app.interface.settings) {
+        const value = values[setting.id];
+        if (value === undefined || value === null) {
+            continue;
         }
-        if (text.length > MAX_FILE_CHARACTERS) {
-            return {
-                refused: `${name} is too long to send in a message: ${text.length.toLocaleString('en')} characters, at most ${MAX_FILE_CHARACTERS.toLocaleString('en')}.`,
-            };
+        switch (setting.type) {
+            case 'select': {
+                const chosen = Array.isArray(value) ? value[0] : value;
+                if (chosen !== undefined && chosen !== '') {
+                    settings[setting.id] = String(chosen);
+                }
+                break;
+            }
+            case 'toggle':
+                settings[setting.id] = Boolean(value);
+                break;
+            case 'slider':
+            case 'number':
+                if (value !== '' && !Number.isNaN(Number(value))) {
+                    settings[setting.id] = Number(value);
+                }
+                break;
+            default:
+                settings[setting.id] = String(value);
         }
-        const fence = text.includes('```') ? '~~~~' : '```';
-        parts.push(`The file ${name} (${type || 'text'}):\n${fence}\n${text.replace(/\n$/, '')}\n${fence}`);
     }
-    return { words: parts.join('\n\n') };
+    return settings;
 }
 /**
  * What a button pressed on the page does.
@@ -397,6 +401,13 @@ export function appPageAction(app, event, read, lastInputs = '') {
     const given = event.context?.message;
     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 } : {}),
+    });
     switch (event.name) {
         case 'stop':
             return { stop: true };
@@ -404,21 +415,21 @@ export function appPageAction(app, event, read, lastInputs = '') {
             return { newChat: true };
         case 'run':
         case 'upload': {
-            const given = event.context?.files;
-            const files = filesInWords(event.name === 'upload' && given !== undefined
-                ? given
+            const context = event.context?.files;
+            const files = givenFiles(event.name === 'upload' && context !== undefined
+                ? context
                 : read(FILES.path));
             if ('refused' in files) {
                 return files;
             }
-            if (event.name === 'upload' && !files.words) {
+            if (event.name === 'upload' && files.files.length === 0) {
                 return { refused: 'No file was given: choose one first.' };
             }
-            const text = [[message, inputs].filter(Boolean).join('\n'), files.words]
-                .filter(Boolean)
-                .join('\n\n');
+            const names = files.files.map(file => file.name).join(', ');
+            const text = [message, inputs].filter(Boolean).join('\n') ||
+                (names ? `Run on ${names}.` : '');
             return text
-                ? { send: text, inputs, clear: [] }
+                ? { send: text, inputs, clear: [], loop: loop(files.files) }
                 : { refused: `${app.name} has no inputs to run on: set one first.` };
         }
         default: {
@@ -432,6 +443,7 @@ export function appPageAction(app, event, read, lastInputs = '') {
                 send: changed ? `${written}\n\n${inputs}` : written,
                 inputs,
                 clear: message ? [] : [DRAFT.path],
+                loop: loop(),
             };
         }
     }

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

@@ -1,8 +1,44 @@
+/**
+ * `@datalayer/loop-plugin-app-page` — an application's page, as a plugin
+ * (LOOP R-01, R-01b).
+ *
+ * A chat, a widget or a worker runs as its conversation; its page — its
+ * A2UI surface, or the default page of its kind when none is composed — is
+ * contributed as the editor beside the chat (`LoopEditorView`), the place a
+ * notebook or a document takes in other workspaces. `AppRenderer` mounts it
+ * for an application that has one (`hasAppPage`) and opens the chat on it.
+ *
+ * What the page shows and takes, by kind, is `APP_KIND_PATHS`.
+ *
+ * A page the workspace does not draw itself — a decision's, whose page is
+ * its host's (the Studio's run page, its hosted address, its embed) — is
+ * contributed by the host through `defineAppHostPagePlugin`, as the
+ * workspace's one view (`LoopViewType`), in a workspace without a
+ * conversation (LOOP R-02).
+ *
+ * @module loop/plugins/app-page
+ */
+import type { ComponentType } from 'react';
 import { type ReactorPlugin } from '@datalayer/reactor';
 import type { AppSpec } from '../../../types/agentspecs';
+import { type LoopWorkspaceContext } from '../../core';
 export declare const APP_PAGE_PLUGIN_NAME = "@datalayer/loop-plugin-app-page";
 /** The plugin that draws an application's page beside its conversation. */
 export declare function defineAppPagePlugin(app: AppSpec): ReactorPlugin<Record<string, never>, unknown, unknown>;
+/** The view an application's page is, when its host draws it. */
+export declare const APP_HOST_PAGE_VIEW = "app-page";
+/** What a host's page is given: the application, and the workspace it is the view of. */
+export type AppHostPageProps = {
+    app: AppSpec;
+    workspace: LoopWorkspaceContext;
+};
+/**
+ * The plugin that makes a host's page the workspace's view (LOOP R-02): the
+ * page a host draws for an application whose kind the workspace has no page
+ * for — a decision's. The workspace opens on it; it is ordered before every
+ * other view.
+ */
+export declare function defineAppHostPagePlugin(app: AppSpec, Page: ComponentType<AppHostPageProps>): ReactorPlugin<Record<string, never>, unknown, unknown>;
 export { AppPage, type AppPageProps } from './AppPage';
 export * from './appPageModel';
 export default defineAppPagePlugin;

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

@@ -1,7 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { BrowserIcon } from '@primer/octicons-react';
 import { contribution, definePlugin, } from '@datalayer/reactor';
-import { LoopEditorView } from '../../core';
+import { LoopEditorView, LoopViewType, } from '../../core';
 import { AppPage } from './AppPage';
 import { APP_PAGE_SURFACE } from './appPageModel';
 export const APP_PAGE_PLUGIN_NAME = '@datalayer/loop-plugin-app-page';
@@ -29,6 +29,37 @@ export function defineAppPagePlugin(app) {
     });
     return plugin;
 }
+/** The view an application's page is, when its host draws it. */
+export const APP_HOST_PAGE_VIEW = 'app-page';
+/**
+ * The plugin that makes a host's page the workspace's view (LOOP R-02): the
+ * page a host draws for an application whose kind the workspace has no page
+ * for — a decision's. The workspace opens on it; it is ordered before every
+ * other view.
+ */
+export function defineAppHostPagePlugin(app, Page) {
+    // One component per plugin: the view host keeps it, and the application with it.
+    function View({ workspace, }) {
+        return _jsx(Page, { app: app, workspace: workspace });
+    }
+    const plugin = definePlugin({
+        name: `${APP_PAGE_PLUGIN_NAME}-${app.id}`,
+        displayName: `${app.name}: its page`,
+        description: `The page of ${app.name}, drawn by its host.`,
+        octicon: 'browser',
+        emoji: app.emoji || undefined,
+        contributes: [
+            contribution(LoopViewType, {
+                viewType: APP_HOST_PAGE_VIEW,
+                title: app.name,
+                icon: BrowserIcon,
+                order: -10,
+                load: async () => ({ default: View }),
+            }, { id: APP_HOST_PAGE_VIEW, order: -10 }),
+        ],
+    });
+    return plugin;
+}
 export { AppPage } from './AppPage';
 export * from './appPageModel';
 export default defineAppPagePlugin;

package/lib/loop/plugins/chat/ChatView.js

@@ -326,21 +326,32 @@ export default function ChatView({ workspace }) {
         feed.assistant(reply);
     }, []);
     const heldForAdapter = useRef([]);
+    /** Whether the agent is turned in this page: read by `sendNow`, set below. */
+    const inPageRef = useRef(false);
     /*
      * Every message that goes to the agent goes through here: the composer's
      * (through the workspace's dispatch and the prompt channel), a host's, and
      * one sent from the application's page (`viewControls.send`) — so each
      * begins its turn, and a page reading the turn sees it asked and answered.
+     *
+     * What the page did besides the message goes with it as AG-UI's
+     * `forwardedProps` (`loop`, LOOP R-04): the application's session takes a
+     * file there. An agent turned in this page has no session, and no file is
+     * handed to it: said, rather than dropped.
      */
-    const sendNow = useCallback((message) => {
+    const sendNow = useCallback((message, forwardedProps) => {
+        const loop = forwardedProps?.loop;
+        if (inPageRef.current && loop?.files && loop.files.length > 0) {
+            return 'A file is given to an application running on a runtime: run it on Datalayer or on your machine to give it one.';
+        }
         // A new turn: whatever the panel showed is gone, this message is it.
         turnFeedRef.current?.begin(message, controlsRef.current?.thread());
         const send = controlsRef.current?.send;
         if (!send) {
-            heldForAdapter.current.push(message);
+            heldForAdapter.current.push([message, forwardedProps]);
             return;
         }
-        send(message);
+        send(message, forwardedProps);
     }, []);
     // One writer, so neither fact can erase the other.
     useEffect(() => {
@@ -374,8 +385,8 @@ export default function ChatView({ workspace }) {
             return;
         }
         const held = heldForAdapter.current.splice(0, heldForAdapter.current.length);
-        for (const message of held) {
-            controlsRef.current?.send(message);
+        for (const [message, forwardedProps] of held) {
+            controlsRef.current?.send(message, forwardedProps);
         }
     }, [sendReady]);
     /*
@@ -629,6 +640,7 @@ export default function ChatView({ workspace }) {
      * for — so the location wins, which is the same rule the examples follow.
      */
     const inPage = targetRunsAgentInPage(workspace.sandbox.target ?? 'local');
+    inPageRef.current = inPage;
     /*
      * Who is being addressed, when this workspace runs a team.
      *
@@ -1088,6 +1100,12 @@ export default function ChatView({ workspace }) {
         // a new identity would resend the last suggestion.
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [suggestion]);
+    /*
+     * An application's session checks who is calling (LOOP R-32, R-04): its
+     * chat says so with the person's token. The embed hands its own.
+     */
+    const runsApp = Boolean(blueprintTurn?.createPayload?.app_spec);
+    const iamToken = useIAMStore(state => state.token);
     const protocol = useMemo(() => inPage
         ? browserProtocolConfig({
             agentId: member?.specId ?? agentId,
@@ -1116,7 +1134,14 @@ export default function ChatView({ workspace }) {
         })
         : {
             type: 'ag-ui',
-            endpoint: `${agentServerUrl}/api/v1/ag-ui/${agentId}/`,
+            // An application's agent is spoken to through its session API
+            // (LOOP R-04): each thread a session, recorded under its uid,
+            // run in the name the application runs in, and taking what the
+            // page did besides the message — the same AG-UI events back.
+            endpoint: runsApp
+                ? `${agentServerUrl}/api/v1/apps/agents/${encodeURIComponent(agentId)}/ag-ui/`
+                : `${agentServerUrl}/api/v1/ag-ui/${agentId}/`,
+            ...(runsApp && iamToken ? { authToken: iamToken } : {}),
             agentId,
             // `/api/v1/configure`, not `/api/v1/configure/config`: the hooks
             // strip one trailing `config`/`configure` segment to find the API
@@ -1134,6 +1159,8 @@ export default function ChatView({ workspace }) {
         blueprintTurn,
         activeModel,
         agentServerUrl,
+        runsApp,
+        iamToken,
     ]);
     /*
      * The model catalogue, and the builtin tools and skills the agent reports.

package/lib/loop/presets.d.ts

@@ -173,6 +173,17 @@ export type LoopPresetOptions = {
      * cells and documents.
      */
     editors?: boolean;
+    /**
+     * Whether the workspace holds a conversation at all.
+     *
+     * True by default. A host whose one view is a page of its own — an
+     * application that answers in its page and has no agent to talk to, a
+     * decision (LOOP R-02) — passes `false`: the chat and its composer, the
+     * agents, the models, the editors and the page layout all stay out, so
+     * that nothing is launched or fetched for a conversation nobody has, and
+     * the workspace opens on the view a host's plugin contributes.
+     */
+    conversation?: boolean;
     /**
      * The editor choice in the workspace header rather than above the chat.
      *

package/lib/loop/presets.js

@@ -52,8 +52,23 @@ import { LoopPageLayoutPlugin } from './plugins/page-layout';
  * be installed or signed into, and the switches a demonstration wants are off.
  */
 export function loopPlugins(options = {}) {
-    const { serverUrl, target = 'browser', defaultEditor: askedEditor, showViewSelector = true, hideChatHeader = false, chatHeaderButtons = false, promptPlacement, autoFocusPrompt = true, suggestionLabels = true, fullScreenTopOffset = 0, showAgentVariants = false, agentSummary = true, teamId, teamPicker = true, pageLayout = false, pageLayoutArrangement = 'page', pageLayoutTurnPanel = 'below', pageLayoutPrompt = 'docked', pageLayoutPromptAnchor = 'top', pageLayoutSize, pageLayoutTurnPanelFooter = 'full', localAgent, localAgentSpec, datalayerAgentSpecId, datalayerCreatePayload, targetFixed, themeVariant, themeOverrides, presence, showTokenUsage, floatingPrompt = false, editorSelector = false, editors = true, graph = false, commandPalette = false, pluginsPanel = false, windowFrame = false, firstPromptHook, } = options;
+    const { serverUrl, target = 'browser', defaultEditor: askedEditor, showViewSelector = true, hideChatHeader = false, chatHeaderButtons = false, promptPlacement, autoFocusPrompt = true, suggestionLabels = true, fullScreenTopOffset = 0, showAgentVariants = false, agentSummary = true, teamId, teamPicker = true, pageLayout = false, pageLayoutArrangement = 'page', pageLayoutTurnPanel = 'below', pageLayoutPrompt = 'docked', pageLayoutPromptAnchor = 'top', pageLayoutSize, pageLayoutTurnPanelFooter = 'full', localAgent, localAgentSpec, datalayerAgentSpecId, datalayerCreatePayload, targetFixed, themeVariant, themeOverrides, presence, showTokenUsage, floatingPrompt = false, editorSelector = false, editors = true, conversation = true, graph = false, commandPalette = false, pluginsPanel = false, windowFrame = false, firstPromptHook, } = options;
     const defaultEditor = askedEditor ?? (editors ? 'notebook' : 'none');
+    // A workspace without a conversation: the theme, the shell's points, and
+    // the host's chrome; its view is a host's plugin's.
+    if (!conversation) {
+        return [
+            ThemePlugin,
+            configurePlugin(ShellPlugin, {
+                defaultEditor: 'none',
+                showSelector: false,
+            }),
+            ...(graph ? [GraphViewPlugin] : []),
+            ...(commandPalette ? [LoopCommandsPlugin] : []),
+            ...(pluginsPanel ? [PluginsPanelPlugin] : []),
+            ...(windowFrame ? [WindowFramePlugin] : []),
+        ];
+    }
     return [
         // The chat owns the editor beside it, so which one opens is its
         // configuration rather than the workspace's.

package/lib/protocols/AGUIAdapter.d.ts

@@ -83,6 +83,8 @@ export declare class AGUIAdapter extends BaseProtocolAdapter {
             provider: string;
             accessToken: string;
         }>;
+        /** What goes with the run besides the conversation (AG-UI's). */
+        forwardedProps?: Record<string, unknown>;
     }): Promise<void>;
     /**
      * Send tool result back through AG-UI and continue the conversation.

package/lib/protocols/AGUIAdapter.js

@@ -191,7 +191,7 @@ export class AGUIAdapter extends BaseProtocolAdapter {
                 skills: options.skills,
             }),
             context: [],
-            forwardedProps: null,
+            forwardedProps: options?.forwardedProps ?? null,
             // Include model for per-request model override
             ...(options?.model && { model: options.model }),
             // Include identities for tool execution with OAuth tokens

package/lib/types/chat.d.ts

@@ -654,7 +654,8 @@ export interface ChatBaseProps {
      * Called again with `null` when the chat can no longer send.
      */
     onSendReady?: (controls: {
-        send: (message: string) => void;
+        /** Send a message; `forwardedProps` go with its run (AG-UI's). */
+        send: (message: string, forwardedProps?: Record<string, unknown>) => void;
         stop: () => void;
         /** Start the conversation over — what the header's + does. */
         newChat: () => void;

package/lib/types/protocol.d.ts

@@ -142,6 +142,8 @@ export interface ProtocolAdapter {
             provider: string;
             accessToken: string;
         }>;
+        /** What goes with the run besides the conversation (AG-UI's `forwardedProps`). */
+        forwardedProps?: Record<string, unknown>;
     }): Promise<void>;
     /**
      * Send tool execution result back

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@datalayer/agent-runtimes",
-    "version": "1.3.38",
+    "version": "1.3.40",
     "type": "module",
     "workspaces": [
         ".",