@datalayer/agent-runtimes 1.0.29 → 1.3.11

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

@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Decks in a Loop: a deck beside the chat.
+ *
+ * The plugin pulls `@datalayer/decks`'s own reactor plugin in as a dependency,
+ * pointed at the Loop's slots — the list of decks in the sidebar, the "new
+ * deck" dialog at the root — and adds what only a Loop can know:
+ *
+ * - a **Deck** editor surface, one entry in the shell's editor selector, that
+ *   shows the open deck in the column beside the conversation;
+ * - a **menu in the composer** with the decks to open and the plugin's
+ *   commands, and a `deck` slash command with a keystroke;
+ * - the deck **following the decks**: whatever asks to see one — a row in the
+ *   list, the palette, an agent's tool — brings the surface beside the chat.
+ *
+ * It declares no tools. The decks plugin does: its `AgentTools` bundle names
+ * every command an agent may call — reading and writing decks as much as
+ * opening and presenting one — and the chat reads the bundle from the reactor
+ * (`useAgentCommandTools`) and runs each as the command it is, on this page,
+ * saved to the decks server when the plugin was given one. Nothing here
+ * duplicates, and nothing here can drift from, what the plugin declared.
+ *
+ * `DeckViewPlugin` is the footer icon that switches to the deck, like the
+ * notebook's and the document's.
+ *
+ * @module loop/plugins/decks
+ */
+import { ProjectIcon } from '@primer/octicons-react';
+import { configurePlugin, contribution, definePlugin, } from '@datalayer/reactor';
+import { DecksPlugin, getDecksState, subscribeDecksState, } from '@datalayer/decks/plugin';
+import { LoopCommand, LoopEditorView, LoopSlots, requestSurface, } from '../../core';
+import { InputPromptPlugin } from '../input-prompt';
+import { chooseEditor } from '../shell/editorChoice';
+import { defineViewPlugin } from '../view-switch';
+import DecksMenu from './DecksMenu';
+import { DECK_SURFACE_ID } from './surface';
+export { DECK_SURFACE_ID } from './surface';
+export const DECKS_PLUGIN_NAME = '@datalayer/loop-plugin-decks';
+/**
+ * A slot nobody renders: the decks plugin's main view is shown through the
+ * Deck surface instead, so the plugin's own `slot` output must land nowhere.
+ */
+export const DECKS_UNUSED_SLOT = 'loop.decks.unused';
+export const LoopDecksPlugin = definePlugin({
+    name: DECKS_PLUGIN_NAME,
+    // `Deck editor`, like `Notebook editor`: the decks plugin it depends on is
+    // the one called `Decks`, and the two sit side by side in the plugins panel.
+    displayName: 'Deck editor',
+    description: 'A deck beside the chat, and the tools an agent writes a presentation with.',
+    octicon: 'project',
+    emoji: '\u{1F4CA}',
+    dependencies: [
+        configurePlugin(DecksPlugin, {
+            listSlot: LoopSlots.sidebar,
+            // Above the plugins panel, which puts itself last.
+            listOrder: 10,
+            slot: DECKS_UNUSED_SLOT,
+            dialogSlot: LoopSlots.root,
+            shellView: false,
+        }),
+        // The menu sits in the composer's action row; without the composer there
+        // is nowhere for it to be.
+        InputPromptPlugin,
+    ],
+    contributes: [
+        contribution(LoopEditorView, {
+            surfaceId: DECK_SURFACE_ID,
+            title: 'Deck',
+            icon: ProjectIcon,
+            order: 30,
+            load: () => import('./DeckSurface'),
+        }, { id: DECK_SURFACE_ID, order: 30 }),
+        contribution(LoopCommand, {
+            name: 'deck',
+            description: 'Open the deck beside the chat',
+            group: 'Open',
+            keybinding: 'Mod+Alt+D',
+            run: async ({ workspace }) => {
+                workspace.setActiveViewType('chat');
+                if (!requestSurface(DECK_SURFACE_ID)) {
+                    throw new Error('No chat is on screen to open the deck beside.');
+                }
+            },
+        }, { id: 'deck' }),
+    ],
+    register: () => {
+        /*
+         * The deck surface follows the decks. Whatever asks to see a deck or the
+         * list — the sidebar row, the palette's "Show the decks", an agent's
+         * `decks_open` — bumps the store's `revealed`, and this brings the Deck
+         * editor beside the chat so the ask has a visible answer. Without it,
+         * "Show the decks" with the notebook on screen changed the store and
+         * nothing else.
+         */
+        let seen = getDecksState().revealed;
+        return subscribeDecksState(() => {
+            const { revealed } = getDecksState();
+            if (revealed === seen) {
+                return;
+            }
+            seen = revealed;
+            if (!chooseEditor(DECK_SURFACE_ID)) {
+                console.warn('[loop] No chat is on screen to show the deck beside.');
+            }
+        });
+    },
+    build: () => ({
+        components: [
+            {
+                id: 'decks-menu',
+                slot: LoopSlots.promptAction,
+                order: 40,
+                Component: DecksMenu,
+            },
+        ],
+    }),
+});
+/** The footer icon that shows the deck, beside the notebook's and the document's. */
+export const DeckViewPlugin = defineViewPlugin({
+    key: 'deck',
+    viewId: DECK_SURFACE_ID,
+    displayName: 'Deck view',
+    description: 'The deck beside the chat, from the composer footer.',
+    icon: ProjectIcon,
+    tooltip: 'Show the deck',
+    octicon: 'project',
+    emoji: '\u{1F4CA}',
+    order: 12,
+});
+export default LoopDecksPlugin;

package/lib/loop/plugins/decks/surface.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The editor surface the deck is shown on: what the selector, the footer
+ * icon, the composer menu and the store's "reveal" all point at.
+ *
+ * @module loop/plugins/decks/surface
+ */
+export declare const DECK_SURFACE_ID = "deck";

package/lib/loop/plugins/decks/surface.js

@@ -0,0 +1,11 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The editor surface the deck is shown on: what the selector, the footer
+ * icon, the composer menu and the store's "reveal" all point at.
+ *
+ * @module loop/plugins/decks/surface
+ */
+export const DECK_SURFACE_ID = 'deck';

package/lib/loop/plugins/document/DocumentView.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The document view: the ephemeral Lexical document, bound to the sandbox.
+ *
+ * This module is only ever reached through the view's `load()` thunk, which is
+ * what keeps `@datalayer/jupyter-lexical` — and the Lumino nodes it initialises
+ * on import — out of the shell's bundle until someone opens a document.
+ *
+ * @module loop/plugins/document/DocumentView
+ */
+import type { JSX } from 'react';
+import { type ChatSurfaceProps } from '../../core';
+export default function DocumentView({ workspace, }: ChatSurfaceProps): JSX.Element;

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

@@ -0,0 +1,68 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from 'react';
+import { useContributions, useSignalValue } from '@datalayer/reactor/react';
+import { Box, Text } from '@primer/react';
+import { EphemeralDocument } from '../../../chat/document/EphemeralDocument';
+import { LoopDocumentToolbar, LoopDocumentToolbarItem, LoopOpeningDocument, } from '../../core';
+import { useEditorToolbar } from '../../core/toolbar';
+import { useSandboxService } from '../agents';
+import { openingDocument } from './openingDocument';
+export default function DocumentView({ workspace, }) {
+    const service = useSandboxService();
+    const snapshot = useSignalValue(service.snapshot);
+    const documentId = workspace.surfaceId;
+    // Read before the early return, not after: the hook count must not depend on
+    // whether a sandbox happens to be running. As with the notebook, the bar
+    // itself belongs to a plugin — switch that off and the document has no
+    // toolbar rather than an empty one.
+    const toolbar = useEditorToolbar(LoopDocumentToolbar, LoopDocumentToolbarItem, {
+        workspace,
+        editorId: documentId,
+    });
+    /*
+     * What the editor opens on. A host's own opening document wins over the
+     * plugin's; either is built fresh here and handed over as the serialised
+     * state `EphemeralDocument` loads exactly once, when it mounts — which is
+     * below the early return, so the state is ready before the editor is.
+     */
+    const openingEntries = useContributions(LoopOpeningDocument);
+    const contributedOpening = openingEntries[0]?.value;
+    const opening = useMemo(() => JSON.stringify((contributedOpening?.document ?? openingDocument)()), [contributedOpening]);
+    const autoFocus = contributedOpening?.autoFocus ?? true;
+    if (snapshot.state !== 'running') {
+        return (_jsx(Box, { sx: {
+                height: '100%',
+                display: 'flex',
+                alignItems: 'center',
+                justifyContent: 'center',
+                color: 'fg.muted',
+                fontSize: 1,
+                px: 4,
+                textAlign: 'center',
+            }, children: _jsx(Text, { children: "The document needs a running sandbox for its code blocks. Open the Sandbox view to see what it is doing." }) }));
+    }
+    // A browser sandbox already owns its kernel; binding to that manager is what
+    // puts the agent's code blocks and the reader's in the same one. A server
+    // sandbox is reached by URL, as before, and returns null here. The notebook
+    // view does exactly this — the document simply never did, which is why it
+    // came up blank on Pyodide.
+    const browserManager = service.getServiceManager() ??
+        undefined;
+    return (_jsx(Box, { sx: { height: '100%', minHeight: 0 }, children: _jsx(EphemeralDocument
+        // The entry point owns the theme; a second provider here would fight
+        // it over BaseStyles and font tokens (§3.5, §3.6).
+        , { 
+            // The entry point owns the theme; a second provider here would fight
+            // it over BaseStyles and font tokens (§3.5, §3.6).
+            inheritTheme: true, documentId: documentId, content: opening, autoFocus: autoFocus, serviceManager: browserManager, showToolbar: toolbar.present, toolbarExtraItems: toolbar.items, 
+            // Join the sandbox's kernel rather than starting a rival one.
+            kernelId: browserManager ? snapshot.kernelId : undefined, runtimeOverride: !browserManager && snapshot.jupyterUrl
+                ? {
+                    baseUrl: snapshot.jupyterUrl,
+                    // Without the token the server refuses every request and the
+                    // cell runs into silence — no kernel, no output, no error the
+                    // reader can act on.
+                    token: snapshot.jupyterToken,
+                }
+                : undefined }) }));
+}

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

@@ -0,0 +1,3 @@
+export declare const DOCUMENT_PLUGIN_NAME = "@datalayer/loop-plugin-document";
+export declare const DocumentPlugin: import("@datalayer/reactor").ReactorPlugin<Record<string, never>, unknown, unknown>;
+export default DocumentPlugin;

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

@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * `@datalayer/loop-plugin-document` — a rich-text editor, beside the chat.
+ *
+ * The same shape as the notebook plugin, contributed to the same point: an
+ * editor the conversation is about, not an alternative to it.
+ *
+ * @module loop/plugins/document
+ */
+import { FileIcon } from '@primer/octicons-react';
+import { contribution, definePlugin } from '@datalayer/reactor';
+import { LoopCommand, LoopEditorView, LoopFrontendTool, requestSurface, LoopDocumentToolbar, LoopOpeningDocument, } from '../../core';
+import { AgentsPlugin } from '../agents';
+export const DOCUMENT_PLUGIN_NAME = '@datalayer/loop-plugin-document';
+export const DocumentPlugin = definePlugin({
+    name: DOCUMENT_PLUGIN_NAME,
+    displayName: 'Document editor',
+    description: 'A rich-text document beside the chat, driven by the agent.',
+    octicon: 'file',
+    emoji: '\u{1F4C4}',
+    // The sandbox is a hard dependency; the shell and the chat are extended
+    // through their points instead — see the notebook plugin for why.
+    dependencies: [AgentsPlugin],
+    // Declared, not merely used: the registry knows who contributed to a
+    // point, it cannot know who opened it. Declaring it is also what makes
+    // the document toolbar visible on the plugin graph before anything has
+    // filled it — which is exactly when knowing it exists is most useful.
+    // And the opening document: what the editor holds before anyone types,
+    // for a host with a story of its own to open on.
+    contributionPoints: [LoopDocumentToolbar, LoopOpeningDocument],
+    contributes: [
+        // The editor: one entry in the shell's segmented control, one view in
+        // the editor column.
+        contribution(LoopEditorView, {
+            surfaceId: 'document',
+            title: 'Document',
+            icon: FileIcon,
+            order: 20,
+            canOpen: workspace => workspace.sandbox.state === 'running',
+            unavailableReason: () => 'Needs a running sandbox',
+            // Lazy, and it matters more here than anywhere: this module pulls
+            // `@datalayer/jupyter-lexical`, which initialises Lumino-backed nodes
+            // at import time.
+            load: () => import('./DocumentView'),
+        }, { id: 'document', order: 20 }),
+        contribution(LoopCommand, {
+            name: 'document',
+            description: 'Open the document beside the chat',
+            group: 'Open',
+            keybinding: 'Mod+Alt+O',
+            run: async ({ workspace }) => {
+                // The chat first, because the surface lives beside it; then the
+                // surface itself. Switching the view alone leaves whichever surface
+                // was already open, so on the chat view — where a reader usually is
+                // — this used to do nothing at all.
+                workspace.setActiveViewType('chat');
+                if (!requestSurface('document')) {
+                    throw new Error('No chat is on screen to open the document beside.');
+                }
+            },
+        }, { id: 'document' }),
+    ],
+    build: ctx => {
+        /*
+         * The document's tools, contributed when their module arrives.
+         *
+         * `lexicalHooks` imports `@datalayer/jupyter-lexical` at module load —
+         * the exact import this plugin keeps out of its own entry so a workspace
+         * only pays for lexical when a document exists. A static contribution
+         * would smuggle it back in. The reactor takes contributions at any time
+         * and bumps its revision, so the chat re-reads its tools point the
+         * moment these land.
+         */
+        void import('../../../tools/adapters/agent-runtimes/lexicalHooks').then(({ createLexicalTools }) => {
+            ctx.contribute(LoopFrontendTool, {
+                id: 'document-tools',
+                tools: workspace => createLexicalTools(workspace.surfaceId),
+            }, { id: 'document-tools' });
+        });
+        return {};
+    },
+});
+export default DocumentPlugin;

package/lib/loop/plugins/document/openingDocument.d.ts

@@ -0,0 +1,28 @@
+/**
+ * What the document editor holds before anyone types.
+ *
+ * A heading, a paragraph and a Jupyter cell that has already run — the same
+ * small analysis the opening notebook shows, so the two editors open on one
+ * story. It exists for the same reason the notebook's opening cell does: an
+ * empty editor shows what the editor is, and a short document shows what it is
+ * *for* — prose and live code on one page, the output already there.
+ *
+ * Serialised Lexical state, as `EphemeralDocument` loads it. The cell is the
+ * pair the slash menu's "Jupyter Cell" inserts — a `jupyter-input` holding the
+ * code and a `jupyter-output` holding what it printed, tied by one uuid. The
+ * code is stored already tokenised, the way the editor's own highlighter
+ * stores it after a keystroke: a loaded state runs no transforms, so code
+ * handed over as plain text would sit unhighlighted until somebody typed in
+ * it. The same Prism grammar the highlighter uses does the tokenising here.
+ * The output is what this code prints, from a real run: a fabricated output
+ * on a page asking to be trusted is a lie told at the worst possible moment.
+ *
+ * @module loop/plugins/document/openingDocument
+ */
+import type { SerializedEditorState } from 'lexical';
+import 'prismjs/components/prism-python';
+export declare const OPENING_DOCUMENT_TITLE = "Quarterly revenue by region";
+export declare const OPENING_DOCUMENT_PARAGRAPH: string;
+/** The opening document, built fresh: the editor keeps what it is handed. */
+export declare function openingDocument(): SerializedEditorState;
+export default openingDocument;

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

@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import Prism from 'prismjs';
+import 'prismjs/components/prism-python';
+import { OPENING_FRAME_REPR, OPENING_SOURCE, } from '../notebook/openingNotebook';
+export const OPENING_DOCUMENT_TITLE = 'Quarterly revenue by region';
+export const OPENING_DOCUMENT_PARAGRAPH = 'Six rows of revenue, two quarters, three regions. The cell below loads them and ' +
+    'shows the frame; run it, change it, or ask an agent to take it further — the ' +
+    'code and its output live in this document, beside the words about them.';
+const INPUT_UUID = 'opening-document-input';
+const OUTPUT_UUID = 'opening-document-output';
+const text = (content) => ({
+    detail: 0,
+    format: 0,
+    mode: 'normal',
+    style: '',
+    text: content,
+    type: 'text',
+    version: 1,
+});
+const block = (type, children, extra = {}) => ({
+    children,
+    direction: 'ltr',
+    format: '',
+    indent: 0,
+    type,
+    version: 1,
+    ...extra,
+});
+const LINE_BREAK = { type: 'linebreak', version: 1 };
+/** One run of code as the highlighter stores it: text, and the token type it is. */
+const highlight = (content, highlightType) => ({
+    detail: 0,
+    format: 0,
+    mode: 'normal',
+    style: '',
+    text: content,
+    type: 'jupyter-input-highlight',
+    version: 1,
+    highlightType,
+});
+/**
+ * Prism's tokens as highlight nodes — the same walk `@datalayer/jupyter-lexical`
+ * makes when it tokenises a code block, so what is stored here is what the
+ * editor would have stored itself.
+ */
+const tokenNodes = (tokens) => tokens.flatMap(token => {
+    if (typeof token === 'string') {
+        return token
+            .split('\n')
+            .flatMap((part, index) => [
+            ...(index > 0 ? [LINE_BREAK] : []),
+            ...(part.length > 0 ? [highlight(part)] : []),
+        ]);
+    }
+    const { content, type } = token;
+    if (typeof content === 'string') {
+        return [highlight(content, type)];
+    }
+    if (Array.isArray(content)) {
+        return content.length === 1 && typeof content[0] === 'string'
+            ? [highlight(content[0], type)]
+            : tokenNodes(content);
+    }
+    return [];
+});
+/** The code, tokenised; plain lines only if the grammar is somehow missing. */
+const codeNodes = (source) => {
+    const grammar = Prism.languages.python;
+    if (grammar) {
+        return tokenNodes(Prism.tokenize(source, grammar));
+    }
+    return source
+        .split('\n')
+        .flatMap((line, index) => [
+        ...(index > 0 ? [LINE_BREAK] : []),
+        ...(line.length > 0 ? [highlight(line)] : []),
+    ]);
+};
+/** The opening document, built fresh: the editor keeps what it is handed. */
+export function openingDocument() {
+    const source = OPENING_SOURCE.join('');
+    return {
+        root: {
+            children: [
+                block('heading', [text(OPENING_DOCUMENT_TITLE)], { tag: 'h1' }),
+                block('paragraph', [text(OPENING_DOCUMENT_PARAGRAPH)], {
+                    textFormat: 0,
+                    textStyle: '',
+                }),
+                block('jupyter-input', codeNodes(source), {
+                    language: 'python',
+                    jupyterInputNodeUuid: INPUT_UUID,
+                }),
+                {
+                    type: 'jupyter-output',
+                    version: 1,
+                    format: '',
+                    source,
+                    outputs: [
+                        {
+                            output_type: 'execute_result',
+                            execution_count: 1,
+                            data: { 'text/plain': OPENING_FRAME_REPR },
+                            metadata: {},
+                        },
+                    ],
+                    jupyterInputNodeUuid: INPUT_UUID,
+                    jupyterOutputNodeUuid: OUTPUT_UUID,
+                },
+            ],
+            direction: 'ltr',
+            format: '',
+            indent: 0,
+            type: 'root',
+            version: 1,
+        },
+    };
+}
+export default openingDocument;

package/lib/loop/plugins/document-toolbar/SandboxStatusItem.d.ts

@@ -0,0 +1,16 @@
+/**
+ * What the document's code blocks run on, on the document's toolbar.
+ *
+ * The prose equivalent of the notebook's kernel light. A document with a
+ * Jupyter cell in it is running code, and someone whose cell does nothing
+ * should be able to see whether there is anything to run it on without leaving
+ * the document.
+ *
+ * Read through the sandbox service's signal rather than the workspace snapshot
+ * so it tracks the sandbox itself, including while it is starting.
+ *
+ * @module loop/plugins/document-toolbar/SandboxStatusItem
+ */
+import type { JSX } from 'react';
+export declare function SandboxStatusItem(): JSX.Element | null;
+export default SandboxStatusItem;

package/lib/loop/plugins/document-toolbar/SandboxStatusItem.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useSignalValue } from '@datalayer/reactor/react';
+import { Box, Text } from '@primer/react';
+import { useOptionalSandboxService } from '../agents';
+import { IDLE_SANDBOX_SNAPSHOT_SIGNAL } from '../../core';
+/** How each state reads, and what colour it reads in. */
+const APPEARANCE = {
+    idle: { label: 'No sandbox', color: 'fg.muted' },
+    starting: { label: 'Sandbox starting', color: 'attention.fg' },
+    running: { label: 'Sandbox ready', color: 'success.fg' },
+    stopping: { label: 'Sandbox stopping', color: 'attention.fg' },
+    error: { label: 'Sandbox failed', color: 'danger.fg' },
+};
+export function SandboxStatusItem() {
+    // Optional: the document is usable without the sandbox plugin, and a status
+    // item is the last thing that should insist on it.
+    const service = useOptionalSandboxService();
+    const snapshot = useSignalValue(service?.snapshot ?? IDLE_SANDBOX_SNAPSHOT_SIGNAL);
+    if (!service) {
+        return null;
+    }
+    const appearance = APPEARANCE[snapshot.state] ?? APPEARANCE.idle;
+    return (_jsxs(Box, { sx: { display: 'flex', alignItems: 'center', gap: 1, px: 2 }, children: [_jsx(Box, { sx: {
+                    width: 8,
+                    height: 8,
+                    borderRadius: '50%',
+                    bg: appearance.color,
+                    flexShrink: 0,
+                } }), _jsx(Text, { sx: { fontSize: 0, color: 'fg.muted' }, children: appearance.label })] }));
+}
+export default SandboxStatusItem;

package/lib/loop/plugins/document-toolbar/index.d.ts

@@ -0,0 +1,4 @@
+import { DOCUMENT_TOOLBAR_PLUGIN_NAME } from './names';
+export { DOCUMENT_TOOLBAR_PLUGIN_NAME };
+export declare const DocumentToolbarPlugin: import("@datalayer/reactor").LazyPluginRef;
+export default DocumentToolbarPlugin;

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

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * `@datalayer/loop-plugin-document-toolbar` — the document's own toolbar items.
+ *
+ * The prose counterpart of the notebook toolbar plugin, and the same
+ * arrangement: the document editor offers a point, this plugin provides the
+ * bar and puts what belongs to the document on it, and opens a second point
+ * where the chat's agent actions arrive. Switch it off and the document has no
+ * toolbar at all — no formatting controls, no buttons — and goes on being
+ * editable.
+ *
+ * Lazy, waiting on the document toolbar point — a workspace where nobody opens
+ * a document never fetches it.
+ *
+ * @module loop/plugins/document-toolbar
+ */
+import { defineLazyPlugin, onContributionPoint } from '@datalayer/reactor';
+import { LoopDocumentToolbar, LoopDocumentToolbarItem } from '../../core';
+import { DOCUMENT_TOOLBAR_PLUGIN_NAME } from './names';
+export { DOCUMENT_TOOLBAR_PLUGIN_NAME };
+export const DocumentToolbarPlugin = defineLazyPlugin({
+    name: DOCUMENT_TOOLBAR_PLUGIN_NAME,
+    displayName: 'Document toolbar',
+    description: 'Shows what the document’s code blocks run on.',
+    octicon: 'circle',
+    emoji: '\u{1F535}',
+    activationEvents: [onContributionPoint(LoopDocumentToolbar)],
+    /** The bar accepts the buttons, so the bar's owner opens the point. */
+    contributionPoints: [LoopDocumentToolbarItem],
+    load: () => import('./plugin'),
+});
+export default DocumentToolbarPlugin;

package/lib/loop/plugins/document-toolbar/names.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The plugin's name, on its own — see the notebook toolbar's `names` module.
+ *
+ * @module loop/plugins/document-toolbar/names
+ */
+export declare const DOCUMENT_TOOLBAR_PLUGIN_NAME = "@datalayer/loop-plugin-document-toolbar";

package/lib/loop/plugins/document-toolbar/names.js

@@ -0,0 +1,10 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The plugin's name, on its own — see the notebook toolbar's `names` module.
+ *
+ * @module loop/plugins/document-toolbar/names
+ */
+export const DOCUMENT_TOOLBAR_PLUGIN_NAME = '@datalayer/loop-plugin-document-toolbar';

package/lib/loop/plugins/document-toolbar/plugin.d.ts

@@ -0,0 +1,2 @@
+export declare const DocumentToolbarPlugin: import("@datalayer/reactor").ReactorPlugin<Record<string, never>, unknown, unknown>;
+export default DocumentToolbarPlugin;

package/lib/loop/plugins/document-toolbar/plugin.js

@@ -0,0 +1,38 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The document toolbar plugin's module.
+ *
+ * @module loop/plugins/document-toolbar/plugin
+ */
+import { contribution, definePlugin } from '@datalayer/reactor';
+import { LoopDocumentToolbar } from '../../core';
+import { SandboxStatusItem } from './SandboxStatusItem';
+import { DOCUMENT_TOOLBAR_PLUGIN_NAME } from './names';
+/** Trailing edge, past whatever the Lexical toolbar puts there itself. */
+const STATUS_ORDER = 1000;
+export const DocumentToolbarPlugin = definePlugin({
+    name: DOCUMENT_TOOLBAR_PLUGIN_NAME,
+    contributes: [
+        contribution(LoopDocumentToolbar, {
+            items: () => [
+                {
+                    key: 'loop-document-status-spacer',
+                    type: 'spacer',
+                    order: STATUS_ORDER - 1,
+                },
+                {
+                    key: 'loop-document-sandbox-status',
+                    type: 'custom',
+                    order: STATUS_ORDER,
+                    group: 'sandbox',
+                    render: () => _jsx(SandboxStatusItem, {}),
+                },
+            ],
+        }, { id: 'toolbar', order: 100 }),
+    ],
+});
+export default DocumentToolbarPlugin;

package/lib/loop/plugins/document-view/index.d.ts

@@ -0,0 +1,10 @@
+export declare const DOCUMENT_VIEW_PLUGIN_NAME = "@datalayer/loop-plugin-document-view";
+export declare const DocumentViewPlugin: import("@datalayer/reactor").ReactorPlugin<Record<string, never>, unknown, {
+    components: {
+        id: string;
+        slot: "loop.promptAction";
+        order: number;
+        Component: () => import("react").JSX.Element | null;
+    }[];
+}>;
+export default DocumentViewPlugin;