@datalayer/agent-runtimes 1.3.10 → 1.3.13

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

@@ -3,9 +3,12 @@ import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { Box, IconButton, SegmentedControl, Text, Truncate, } from '@primer/react';
 import { useColorPalette } from '@datalayer/primer-addons';
 import { ScreenFullIcon, ScreenNormalIcon } from '@primer/octicons-react';
-import { signal } from '@datalayer/reactor';
+import { computed, signal } from '@datalayer/reactor';
+/* A signal to read when the layout publishes no live stance: the hook needs one. */
+const NO_STANCE = signal(undefined);
 import { useContributions, useSignalValue, useGate, useReactorPlatform, ReactorLazy, ReactorSlot, useSlotComponents, } from '@datalayer/reactor/react';
 import { ChatBase } from '../../../chat/base/ChatBase';
+import { readServerCatalogue } from '../../../chat/base/modelChoice';
 import { SUGGESTION_CHIP_WIDTH } from '../../../chat/display/EmptyState';
 import { AnonymousKeyExpired } from '@datalayer/core/lib/components/anonymous/AnonymousKeyExpired';
 import { useAnonymousSessionStore } from '../../../runtimes/browser/anonymousToken';
@@ -123,6 +126,11 @@ export default function ChatView({ workspace }) {
        its own way; first contribution wins. */
     const layoutEntries = useContributions(LoopChatLayout);
     const layout = layoutEntries[0]?.value;
+    // The composer's stance: live when the layout publishes one (the page
+    // layout, moving the composer as the display mode changes), its starting
+    // stance otherwise.
+    const liveStance = useSignalValue(layout?.promptStance ?? NO_STANCE);
+    const promptStance = liveStance ?? layout?.prompt;
     /* The current turn, kept for whoever shows the conversation without the
        transcript. The chat plugin contributed the feed at build; this view is
        its writer — begin on send, the reply as it arrives, end when it stops. */
@@ -136,7 +144,16 @@ export default function ChatView({ workspace }) {
        handler memoised with empty deps. Set once the spec is resolved below. */
     const agentNameRef = useRef('');
     const extrasEntries = useContributions(LoopChatExtras);
-    const chatExtras = useSignalValue(extrasEntries[0]?.value.extras ?? EMPTY_CHAT_EXTRAS);
+    /*
+     * Every contribution, merged, a later one winning a key both set.
+     *
+     * Only the first used to be read, which made the extras the property of
+     * whichever plugin registered first: the loop's own surface plugin
+     * contributes a tool-result renderer, and a host example contributing a
+     * banner beside it would have silenced one or the other.
+     */
+    const mergedExtras = useMemo(() => computed(() => extrasEntries.reduce((merged, entry) => ({ ...merged, ...entry.value.extras.value }), {})), [extrasEntries]);
+    const chatExtras = useSignalValue(extrasEntries.length > 0 ? mergedExtras : EMPTY_CHAT_EXTRAS);
     /* Which editors have ever been mounted; they are never unmounted after —
        see the render below. A ref, not state: adding to it during render is
        idempotent and must not schedule another one. */
@@ -301,18 +318,43 @@ export default function ChatView({ workspace }) {
                 busy,
                 stop: controlsRef.current?.stop,
                 newChat: controlsRef.current?.newChat,
+                send: controlsRef.current?.send,
             }
             : null);
     }, [busy, sendReady, setViewControls]);
     // Stop reporting when the view goes away, or the shell would keep a stop
     // button for something that is no longer there.
     useEffect(() => () => setViewControls(null), [setViewControls]);
+    /*
+     * Said before the adapter could take it.
+     *
+     * The composer is live while the chat is still starting — the shell shows
+     * it as soon as the view mounts — and a message sent in that moment used
+     * to be dropped, on the grounds that sending it late and out of context
+     * would be worse. It was worse: the message stood in the conversation with
+     * no reply and no reason, and the only way to find out was to send it
+     * again. Held instead, and sent the moment the adapter is ready, which is
+     * the next second or two rather than minutes.
+     */
+    const heldForAdapter = useRef([]);
     useEffect(() => workspace.prompts.subscribe(message => {
-        // A prompt typed before the adapter is ready is dropped rather than
-        // queued: silently sending it minutes later, out of context, is worse
-        // than saying nothing happened.
-        controlsRef.current?.send(message);
+        const send = controlsRef.current?.send;
+        if (!send) {
+            heldForAdapter.current.push(message);
+            return;
+        }
+        send(message);
     }), [workspace.prompts]);
+    // The adapter arrived: whatever was said while it was starting goes now.
+    useEffect(() => {
+        if (!sendReady || heldForAdapter.current.length === 0) {
+            return;
+        }
+        const held = heldForAdapter.current.splice(0, heldForAdapter.current.length);
+        for (const message of held) {
+            controlsRef.current?.send(message);
+        }
+    }, [sendReady]);
     /*
      * Fired once, on the first real send, for the life of this mounted chat —
      * a ref rather than a signal, because nothing here needs to re-render when
@@ -627,7 +669,11 @@ export default function ChatView({ workspace }) {
      */
     const suggestionEntries = useContributions(LoopChatSuggestion);
     const hiddenOpeners = chatExtras.hiddenOpeners;
+    const hideOpeners = chatExtras.hideOpeners;
     const suggestions = useMemo(() => {
+        if (hideOpeners) {
+            return [];
+        }
         // What the host took off this page, by the chip's words — the same key
         // the two-group merge below uses to tell openers apart.
         const hidden = new Set(hiddenOpeners ?? []);
@@ -652,7 +698,15 @@ export default function ChatView({ workspace }) {
                 .filter(item => !listed.has(item.text))
                 .map(item => ({ ...item, group: memberName })),
         ];
-    }, [suggestionEntries, team, spec, member, agentId, hiddenOpeners]);
+    }, [
+        suggestionEntries,
+        team,
+        spec,
+        member,
+        agentId,
+        hiddenOpeners,
+        hideOpeners,
+    ]);
     /*
      * The same openers in the shape the chat's empty state asks for.
      *
@@ -736,13 +790,18 @@ export default function ChatView({ workspace }) {
         }
         // A host example's own frontend tools, folded in last (first name wins),
         // so a bespoke client tool like A2UI's run_jupyter_output_demo joins the
-        // agent's toolset without a plugin of its own.
+        // agent's toolset without a plugin of its own. Vouched for in the chat
+        // view as well: the filter below keeps the tools that leave the editors
+        // alone, and a host's tool touches no editor — the Jupyter Output
+        // example's chat had lost its one tool to that filter and answered
+        // "use the demo button" instead of running the demonstration.
         for (const tool of chatExtras.frontendTools ?? []) {
             if (owners.has(tool.name)) {
                 continue;
             }
             owners.set(tool.name, 'chat-extras');
             merged.push(tool);
+            keep.add(tool.name);
         }
         /*
          * The view decides the toolset. With an editor on screen the agent has
@@ -1070,7 +1129,10 @@ export default function ChatView({ workspace }) {
             .then(response => (response.ok ? response.json() : { models: [] }))
             .then(payload => {
             if (!cancelled) {
-                setCatalogModels(payload.models ?? []);
+                // In the chat's shape: the route says `available`, the menu and
+                // the opening pick read `isAvailable`, and an unmapped row passes
+                // for usable. See `readServerCatalogue`.
+                setCatalogModels(readServerCatalogue(payload));
             }
         })
             // No catalogue is not an error worth a banner: the menu simply has
@@ -1183,13 +1245,14 @@ export default function ChatView({ workspace }) {
         // In a draggable card over the workspace when the host asked for the
         // floating placement; the dragging is the prompt's own feature.
         placement: floatingPrompt ||
-            layout?.prompt === 'floating' ||
-            layout?.prompt === 'floating-top'
+            promptStance === 'floating' ||
+            promptStance === 'floating-top' ||
+            promptStance === 'floating-bottom'
             ? 'floating'
             : 'docked',
         // Where a floating card starts: the page layout wants it over the top
         // of the sheet, like a document's title bar; everyone else, bottom.
-        floatingAnchor: layout?.prompt === 'floating-top' ? 'top' : 'bottom',
+        floatingAnchor: promptStance === 'floating-top' ? 'top' : 'bottom',
         // The agent is working: `isLoading` disables the editor and turns the
         // send button into a stop — the person keeps a way out.
         isLoading: busy,
@@ -1206,8 +1269,9 @@ export default function ChatView({ workspace }) {
         // Both of the page layout's placements are that bar — one floating over
         // the page, one docked above it — so both take the tighter padding.
         padding: topPrompt ||
-            layout?.prompt === 'floating-top' ||
-            layout?.prompt === 'docked-top'
+            promptStance === 'floating-top' ||
+            promptStance === 'floating-bottom' ||
+            promptStance === 'docked-top'
             ? 2
             : 3,
         promptVariant: 'lexical',
@@ -1340,6 +1404,16 @@ export default function ChatView({ workspace }) {
                         // placeholder does: a dead control with no explanation is worse
                         // than an absent one.
                         disabled: chatDisabled, disableReason: disabledReason, protocol: protocol, 
+                        /*
+                            The model this view is on, as the chat's opening pick.
+            
+                            `ChatBase` keeps the model it sends with, and opened on the
+                            first row of whatever catalogue it had before the server
+                            answered — Alibaba — while the footer, drawn from
+                            `activeModel`, said Claude. Told the same model, both agree
+                            from the first message.
+                        */
+                        initialModel: activeModel || undefined, 
                         /*
                             Who is answering, in the words its spec uses.
             
@@ -1408,7 +1482,13 @@ export default function ChatView({ workspace }) {
                             props through `renderHeader`. No contribution — or a host
                             that set `hideHeader` — means no bar.
                           */
-                        showHeader: !config?.hideHeader && !!HeaderComponent, renderHeader: HeaderComponent
+                        showHeader: !config?.hideHeader && !!HeaderComponent, 
+                        // The `+` and the bin in the title bar, when the host asked for
+                        // them; the header draws whatever `ChatBase` assembles here.
+                        headerButtons: {
+                            showNewChat: config?.headerButtons?.newChat ?? false,
+                            showClear: config?.headerButtons?.clear ?? false,
+                        }, renderHeader: HeaderComponent
                             ? headerProps => (_jsx(HeaderComponent, { workspace: workspace, header: headerProps }))
                             : undefined, 
                         /*

package/lib/loop/plugins/chat/index.d.ts

@@ -44,6 +44,20 @@ export type ChatPluginConfig = {
      * directly beneath repeats the point in a smaller font.
      */
     hideHeader: boolean;
+    /**
+     * Whether the title bar offers a way to start over.
+     *
+     * `newChat` is the `+`: a fresh thread, the transcript emptied. `clear`
+     * is the bin: the same emptying, behind a confirmation, and drawn only
+     * while there is something to empty. Both off by default — a workspace
+     * embedded in a page is usually one conversation — and on for an example
+     * whose reader will ask for one surface after another and want the last
+     * one gone.
+     */
+    headerButtons: {
+        newChat: boolean;
+        clear: boolean;
+    };
     /**
      * Whether the chat renders a prompt at all.
      *

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

@@ -44,6 +44,7 @@ export const ChatPlugin = definePlugin({
         defaultSurface: 'notebook',
         showSurfaceSelector: true,
         hideHeader: false,
+        headerButtons: { newChat: false, clear: false },
         hidePrompt: false,
         promptPlacement: 'bottom',
         autoFocusPrompt: true,

package/lib/loop/plugins/document/index.js

@@ -79,6 +79,10 @@ export const DocumentPlugin = definePlugin({
                 id: 'document-tools',
                 tools: workspace => createLexicalTools(workspace.surfaceId),
             }, { id: 'document-tools' });
+        }, error => {
+            // The chunk did not load, or the page went away while it did: the
+            // chat simply has no document tools.
+            console.warn('The document tools could not be loaded', error);
         });
         return {};
     },

package/lib/loop/plugins/notebook/index.js

@@ -84,6 +84,10 @@ export const NotebookPlugin = definePlugin({
                 id: 'notebook-tools',
                 tools: workspace => createNotebookTools(workspace.surfaceId),
             }, { id: 'notebook-tools' });
+        }, error => {
+            // The chunk did not load, or the page went away while it did: the
+            // chat simply has no notebook tools.
+            console.warn('The notebook tools could not be loaded', error);
         });
         return {};
     },

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

@@ -1,6 +1,9 @@
+import { type PageSize } from '@datalayer/primer-addons/lib/reactor';
+import type { ChatViewMode } from '../../../types/chat';
 import { type TurnPanelFooter } from './TurnPanel';
 export { pageLayoutPanelOpen, pageLayoutSheet, openPagePanel as openConversationPanel, } from '@datalayer/primer-addons/lib/reactor';
 export type { TurnPanelFooter } from './TurnPanel';
+export type { PageSize, PageSizeFormat, } from '@datalayer/primer-addons/lib/reactor';
 export declare const LOOP_PAGE_LAYOUT_PLUGIN_NAME = "@datalayer/loop-plugin-page-layout";
 /** What a host may set on the page layout. */
 export type LoopPageLayoutConfig = {
@@ -22,6 +25,20 @@ export type LoopPageLayoutConfig = {
      * kept clear for it — the document application's title bar, movable.
      */
     prompt: 'docked' | 'floating';
+    /**
+     * Which edge of the page a floating composer starts at: `top` (the
+     * default), where a document's title bar would be, or `bottom`, where a
+     * chat's composer waits. Either way it is dragged from there. Only read
+     * with a `floating` prompt.
+     */
+    promptAnchor?: 'top' | 'bottom';
+    /**
+     * The sheet's size: free (the default) at the layout's reading width, or
+     * a paper — `{ format: 'letter' }`, `{ format: 'a4' }` — whose width the
+     * sheet takes and whose height it is at least, with a free `width` or
+     * `height` over either. Omitted: free.
+     */
+    pageSize?: PageSize;
     /**
      * What the turn panel draws under the reply.
      *
@@ -31,5 +48,24 @@ export type LoopPageLayoutConfig = {
      */
     turnPanelFooter: TurnPanelFooter;
 };
+/**
+ * How the page layout shows the chat, when the composer is the floating
+ * card: the card itself over the page (`floating-draggable`, where it
+ * starts), or the conversation panel with the composer standing in it —
+ * beside the page (`sidebar`), over its right edge at full height
+ * (`floating`), or as a window in its corner (`floating-small`). The four
+ * modes of the chat header's toggle, which the card carries in its own
+ * footer. One signal for the workspace, as `pageLayoutPanelOpen` is: the
+ * mode is the person's, not a build's.
+ */
+export declare const pageLayoutChatMode: import("@datalayer/reactor").Signal<ChatViewMode>;
+/** Where a mode puts the composer (the band) and the conversation (the panel). */
+export type PageLayoutChatPlacement = {
+    bandMode: 'floating' | 'panel';
+    panelMode: 'docked' | 'overlay' | 'popup';
+};
+export declare function pageLayoutForChatMode(mode: ChatViewMode): PageLayoutChatPlacement;
+/** Picks a mode: the layout follows, and so does the composer's stance. */
+export declare function setPageLayoutChatMode(mode: ChatViewMode): void;
 export declare const LoopPageLayoutPlugin: import("@datalayer/reactor").ReactorPlugin<LoopPageLayoutConfig, unknown, unknown>;
 export default LoopPageLayoutPlugin;

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

@@ -2,7 +2,8 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { CommentDiscussionIcon } from '@primer/octicons-react';
 import { definePlugin, signal } from '@datalayer/reactor';
 import { useContributions, useSignalValue } from '@datalayer/reactor/react';
-import { PageLayout, PagePanelToggle, } from '@datalayer/primer-addons/lib/reactor';
+import { PageLayout, PagePanelToggle, openPagePanel, } from '@datalayer/primer-addons/lib/reactor';
+import { ChatViewModeToggle } from '../../../chat/header/ChatViewModeToggle';
 import { LoopChatLayout, LoopChatTurn, LoopPromptPanel, LoopSlots, } from '../../core';
 import { TurnPanel } from './TurnPanel';
 /*
@@ -14,6 +15,53 @@ export { pageLayoutPanelOpen, pageLayoutSheet, openPagePanel as openConversation
 export const LOOP_PAGE_LAYOUT_PLUGIN_NAME = '@datalayer/loop-plugin-page-layout';
 /* A signal to read when no chat contributed a turn: the hook needs one. */
 const NO_TURN = signal({ id: 0, status: 'idle' });
+/**
+ * How the page layout shows the chat, when the composer is the floating
+ * card: the card itself over the page (`floating-draggable`, where it
+ * starts), or the conversation panel with the composer standing in it —
+ * beside the page (`sidebar`), over its right edge at full height
+ * (`floating`), or as a window in its corner (`floating-small`). The four
+ * modes of the chat header's toggle, which the card carries in its own
+ * footer. One signal for the workspace, as `pageLayoutPanelOpen` is: the
+ * mode is the person's, not a build's.
+ */
+export const pageLayoutChatMode = signal('floating-draggable');
+/** The composer's stance for the chat view, following the mode above. */
+const promptStance = signal('floating-top');
+/*
+ * Which edge the card returns to when the mode puts it back over the page:
+ * the build's own `promptAnchor`, kept here because the mode is picked
+ * through a module-level function, as `pageLayoutChatMode` itself is. One
+ * page layout to a page, the assumption that signal already makes.
+ */
+let floatingStance = 'floating-top';
+export function pageLayoutForChatMode(mode) {
+    switch (mode) {
+        case 'sidebar':
+            return { bandMode: 'panel', panelMode: 'docked' };
+        case 'floating':
+            return { bandMode: 'panel', panelMode: 'overlay' };
+        case 'floating-small':
+            return { bandMode: 'panel', panelMode: 'popup' };
+        default:
+            return { bandMode: 'floating', panelMode: 'docked' };
+    }
+}
+/** Picks a mode: the layout follows, and so does the composer's stance. */
+export function setPageLayoutChatMode(mode) {
+    pageLayoutChatMode.value = mode;
+    const { bandMode } = pageLayoutForChatMode(mode);
+    promptStance.value = bandMode === 'floating' ? floatingStance : 'docked-top';
+    // The composer went into the panel: the panel opens to show it.
+    if (bandMode === 'panel') {
+        openPagePanel();
+    }
+}
+/** The toggle in the floating composer's footer. */
+function ChatModeAction() {
+    const mode = useSignalValue(pageLayoutChatMode);
+    return _jsx(ChatViewModeToggle, { value: mode, onChange: setPageLayoutChatMode });
+}
 /**
  * The chat view's parts on the page layout.
  *
@@ -21,10 +69,16 @@ const NO_TURN = signal({ id: 0, status: 'idle' });
  * what the agent is doing — the turn's `activity` — is the line at the top
  * of the sheet, so the change is seen where it happens.
  */
-function LoopPageLayout({ parts, promptMode, }) {
+function LoopPageLayout({ parts, promptMode, pageSize, }) {
     const turnEntries = useContributions(LoopChatTurn);
     const turn = useSignalValue(turnEntries[0]?.value.turn ?? NO_TURN);
-    return (_jsx(PageLayout, { page: parts.editors, hasPage: parts.hasEditor, panel: parts.transcript, band: parts.prompt, chips: parts.chips, picker: parts.picker, transient: parts.transient, activity: turn.activity, bandMode: promptMode }));
+    const chatMode = useSignalValue(pageLayoutChatMode);
+    // The display modes are the floating card's own; a docked composer stays
+    // docked above the page, whatever mode was picked elsewhere.
+    const placement = promptMode === 'floating'
+        ? pageLayoutForChatMode(chatMode)
+        : { bandMode: 'docked', panelMode: 'docked' };
+    return (_jsx(PageLayout, { page: parts.editors, hasPage: parts.hasEditor, panel: parts.transcript, band: parts.prompt, chips: parts.chips, picker: parts.picker, transient: parts.transient, activity: turn.activity, bandMode: placement.bandMode, panelMode: placement.panelMode, pageSize: pageSize }));
 }
 /** The header button that opens and closes the conversation panel. */
 function ConversationToggle() {
@@ -32,7 +86,13 @@ function ConversationToggle() {
 }
 export const LoopPageLayoutPlugin = definePlugin({
     name: LOOP_PAGE_LAYOUT_PLUGIN_NAME,
-    config: { turnPanel: 'below', turnPanelFooter: 'full', prompt: 'docked' },
+    config: {
+        turnPanel: 'below',
+        turnPanelFooter: 'full',
+        prompt: 'docked',
+        promptAnchor: 'top',
+        pageSize: undefined,
+    },
     displayName: 'Page layout',
     description: 'The editor — or, in the chat view, the conversation — on a centred sheet, the prompt docked above it at the same width or floating over it as a draggable card, the current turn under the prompt, the conversation in a side panel.',
     octicon: 'file',
@@ -42,15 +102,24 @@ export const LoopPageLayoutPlugin = definePlugin({
           The layout, contributed per build because the composer's stance is
           configuration: `docked-top` means the layout owns the composer's width
           — `PageLayout` gives it a mount point the width of the sheet, so the
-          prompt and the page read as one column; `floating-top` is the draggable
+          prompt and the page read as one column; `floating-top` and
+          `floating-bottom` are the draggable
           card, sized by itself, over a strip of canvas kept clear for it. The
           component closes over the choice once, per build.
         */
         const promptMode = config.prompt;
-        const ConfiguredLayout = (parts) => (_jsx(LoopPageLayout, { parts: parts, promptMode: promptMode }));
+        const pageSize = config.pageSize;
+        floatingStance =
+            config.promptAnchor === 'bottom' ? 'floating-bottom' : 'floating-top';
+        if (promptMode === 'floating') {
+            promptStance.value = floatingStance;
+        }
+        const ConfiguredLayout = (parts) => (_jsx(LoopPageLayout, { parts: parts, promptMode: promptMode, pageSize: pageSize }));
         ctx.contribute(LoopChatLayout, {
             id: 'page-layout',
-            prompt: promptMode === 'floating' ? 'floating-top' : 'docked-top',
+            prompt: promptMode === 'floating' ? floatingStance : 'docked-top',
+            // Live only for the card: its display modes move the composer.
+            promptStance: promptMode === 'floating' ? promptStance : undefined,
             Component: ConfiguredLayout,
         }, { id: 'page-layout' });
         // The turn panel is configuration-dependent, so it is contributed here
@@ -73,6 +142,17 @@ export const LoopPageLayoutPlugin = definePlugin({
                     slot: LoopSlots.header,
                     Component: ConversationToggle,
                 },
+                // The display modes, in the floating card's footer — and only
+                // there: a docked composer has none to pick.
+                ...(promptMode === 'floating'
+                    ? [
+                        {
+                            id: 'page-layout-chat-mode',
+                            slot: LoopSlots.promptAction,
+                            Component: ChatModeAction,
+                        },
+                    ]
+                    : []),
             ],
         };
     },

package/lib/loop/plugins/shell/useEditorPreviews.js

@@ -179,6 +179,13 @@ function useDocumentRows(surfaceId, enabled) {
             };
             refresh();
             unsubscribe = lexicalStore.subscribe(refresh);
+        })
+            .catch(() => {
+            // Lexical could not load (or the page went away while it did): the
+            // document offers no preview, which is all this hook was for.
+            if (!cancelled) {
+                setRows(null);
+            }
         });
         return () => {
             cancelled = true;

package/lib/loop/presets.d.ts

@@ -22,6 +22,7 @@
 import { type PluginRef } from '@datalayer/reactor';
 import { type AgentsConfig, type SandboxTarget } from './plugins/agents';
 import { type ChatPluginConfig } from './plugins/chat';
+import { type PageSize } from './plugins/page-layout';
 export type LoopPresetOptions = {
     /** Where the agent runtimes service is. */
     serverUrl?: string;
@@ -39,6 +40,11 @@ export type LoopPresetOptions = {
     showViewSelector?: boolean;
     /** Whether the chat draws its own header. */
     hideChatHeader?: boolean;
+    /**
+     * Whether the chat's header offers `+` (a new chat) and the bin (clear).
+     * Off by default; see `ChatPluginConfig.headerButtons`.
+     */
+    chatHeaderButtons?: boolean;
     /** Where the prompt sits. Passed through to the chat plugin. */
     promptPlacement?: ChatPluginConfig['promptPlacement'];
     /**
@@ -81,6 +87,19 @@ export type LoopPresetOptions = {
      * as a draggable card over the top of the canvas.
      */
     pageLayoutPrompt?: 'docked' | 'floating';
+    /**
+     * Which edge a floating composer starts at: `top` (the default) or
+     * `bottom`. It is dragged from there either way. Only read with
+     * `pageLayoutPrompt: 'floating'`.
+     */
+    pageLayoutPromptAnchor?: 'top' | 'bottom';
+    /**
+     * The page layout's sheet: free (the default) at its reading width, or a
+     * paper — `{ format: 'letter' }`, `{ format: 'a4' }` — whose width it
+     * takes and whose height it is at least; a free `width` or `height` over
+     * either. Only read with `pageLayout`.
+     */
+    pageLayoutSize?: PageSize;
     /**
      * What the turn panel draws under the reply: the full turn footer
      * (counters, copy, dismiss — the default), `actions` only, or `none`.

package/lib/loop/presets.js

@@ -33,6 +33,7 @@ import { AgentspecsPlugin } from './plugins/agentspecs';
 import { AgentsPlugin, } from './plugins/agents';
 import { ChatPlugin } from './plugins/chat';
 import { ChatHeaderPlugin } from './plugins/chat-header';
+import { A2uiSurfacePlugin } from './plugins/a2ui-surface';
 import { ChatViewPlugin } from './plugins/chat-view';
 import { DocumentViewPlugin } from './plugins/document-view';
 import { InputPromptPlugin } from './plugins/input-prompt';
@@ -51,7 +52,7 @@ 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 = 'notebook', showViewSelector = true, hideChatHeader = false, promptPlacement, autoFocusPrompt = true, fullScreenTopOffset = 0, showAgentVariants = false, agentSummary = true, teamId, teamPicker = true, pageLayout = false, pageLayoutTurnPanel = 'below', pageLayoutPrompt = 'docked', pageLayoutTurnPanelFooter = 'full', localAgent, localAgentSpec, floatingPrompt = false, editorSelector = false, editors = true, graph = false, commandPalette = false, pluginsPanel = false, windowFrame = false, firstPromptHook, } = options;
+    const { serverUrl, target = 'browser', defaultEditor = 'notebook', showViewSelector = true, hideChatHeader = false, chatHeaderButtons = false, promptPlacement, autoFocusPrompt = true, fullScreenTopOffset = 0, showAgentVariants = false, agentSummary = true, teamId, teamPicker = true, pageLayout = false, pageLayoutTurnPanel = 'below', pageLayoutPrompt = 'docked', pageLayoutPromptAnchor = 'top', pageLayoutSize, pageLayoutTurnPanelFooter = 'full', localAgent, localAgentSpec, floatingPrompt = false, editorSelector = false, editors = true, graph = false, commandPalette = false, pluginsPanel = false, windowFrame = false, firstPromptHook, } = options;
     return [
         // The chat owns the editor beside it, so which one opens is its
         // configuration rather than the workspace's.
@@ -62,6 +63,7 @@ export function loopPlugins(options = {}) {
             // to choose.
             showSurfaceSelector: editors && showViewSelector && !editorSelector,
             hideHeader: hideChatHeader,
+            headerButtons: { newChat: chatHeaderButtons, clear: chatHeaderButtons },
             promptPlacement: floatingPrompt ? 'floating' : promptPlacement,
             autoFocusPrompt,
             fullScreenTopOffset,
@@ -72,6 +74,10 @@ export function loopPlugins(options = {}) {
         // still switched individually in the plugins panel.
         configurePlugin(InputPromptPlugin, { firstPromptHook }),
         ChatHeaderPlugin,
+        // An agent whose spec binds a tool to the `a2ui-surface` renderer gets
+        // its surfaces drawn and submitted without a line of host code. Idle
+        // for every other agent: it answers only for tools some spec bound.
+        A2uiSurfacePlugin,
         // One footer icon per view, in the composer where the writing hand
         // already is. Each editor's icon withdraws while its editor is not
         // contributed, so mounting these unconditionally costs an absent editor
@@ -127,6 +133,8 @@ export function loopPlugins(options = {}) {
                     turnPanel: pageLayoutTurnPanel,
                     turnPanelFooter: pageLayoutTurnPanelFooter,
                     prompt: pageLayoutPrompt,
+                    promptAnchor: pageLayoutPromptAnchor,
+                    pageSize: pageLayoutSize,
                 }),
             ]
             : []),

package/lib/models/Deck.d.ts

@@ -0,0 +1,14 @@
+import { IItem } from './Item';
+/**
+ * A deck: a presentation described as data, on the `@datalayer/decks`
+ * engine. `spec` is the deck specification the engine renders — the
+ * item's content, the way `nbformat` is a notebook's — present when the
+ * item was read on its own and absent in a listing.
+ */
+export type IBaseDeck = IItem & {
+    spec?: any;
+};
+export type IDeck = IBaseDeck & {
+    type: 'deck';
+};
+export default IDeck;

package/lib/models/Deck.js

@@ -0,0 +1,5 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+export {};