@datalayer/agent-runtimes 1.0.29 → 1.3.11

package/lib/loop/plugins/window-frame/index.js

@@ -0,0 +1,79 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * `@datalayer/loop-plugin-window-frame` — Loop in a window.
+ *
+ * The frame a page puts around an embedded Loop, and the two slots that make
+ * its title bar extensible. The plugin itself contributes only the window
+ * controls; everything else in the bar is somebody's contribution.
+ *
+ * Why a plugin and not just a component: the point of the frame is the slots,
+ * and a slot is only useful if something can be contributed to it without the
+ * host forwarding it. A page adds a button by mounting a plugin, exactly as it
+ * would add anything else to the workspace — and a plugin that ships a control
+ * takes the control with it when it is switched off.
+ *
+ * The frame is composed rather than injected: a plugin cannot wrap the shell,
+ * so the host renders `<WindowFrame>` around whatever it is framing. That is
+ * the one thing the host still does, and it is the one thing only the host
+ * knows — how much of its page to give away.
+ *
+ * ```tsx
+ * const reactor = buildLoopReactor([...loopPlugins(), WindowFramePlugin]);
+ *
+ * <WindowFrame title="Loop" height="60vh">
+ *   <LoopWorkspace reactor={reactor} … />
+ * </WindowFrame>
+ * ```
+ *
+ * @module loop/plugins/window-frame
+ */
+import { definePlugin } from '@datalayer/reactor';
+import { Box } from '@datalayer/primer-addons';
+import { LoopSlots } from '../../core';
+import { WorkspaceFullScreenAction } from '../../shell/WorkspaceFullScreenAction';
+import { WINDOW_CONTROLS_SLOT } from './slots';
+export { WindowFrame } from './WindowFrame';
+export { WINDOW_ACTIONS_SLOT, WINDOW_CONTROLS_SLOT } from './slots';
+export const WINDOW_FRAME_PLUGIN_NAME = '@datalayer/loop-plugin-window-frame';
+/**
+ * The three dots.
+ *
+ * They say "this is an application" without imitating a particular one, which
+ * is why they are dots and not a close button that closes nothing. Contributed
+ * rather than drawn into the frame so a host with its own idea of window
+ * controls can switch this plugin off and fill the slot itself.
+ */
+function WindowControls() {
+    return (_jsx(_Fragment, { children: ['danger.emphasis', 'attention.emphasis', 'success.emphasis'].map(token => (_jsx(Box, { sx: { width: 10, height: 10, borderRadius: '50%', bg: token } }, token))) }));
+}
+export const WindowFramePlugin = definePlugin({
+    name: WINDOW_FRAME_PLUGIN_NAME,
+    displayName: 'Window frame',
+    description: 'Draws Loop as a window, and opens its title bar to controls and actions.',
+    octicon: 'browser',
+    emoji: '\u{1FA9F}',
+    build: () => ({
+        components: [
+            {
+                id: 'window-controls',
+                slot: WINDOW_CONTROLS_SLOT,
+                Component: WindowControls,
+            },
+            // Full screen is window chrome, so the window plugin is where it comes
+            // from: the workspace header gains the same control the chat header
+            // carries, which is what keeps it reachable for a shell that hides the
+            // chat's chrome. Registered after the editor selector, so it sits on
+            // the far trailing edge of the row.
+            {
+                id: 'full-screen',
+                slot: LoopSlots.header,
+                Component: WorkspaceFullScreenAction,
+            },
+        ],
+    }),
+});
+export default WindowFramePlugin;

package/lib/loop/plugins/window-frame/slots.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The window frame's slots, by name.
+ *
+ * In their own module so the frame component, the plugin and a host that fills
+ * them can each import the names without importing each other — the same
+ * reason the graph plugin keeps its view type apart.
+ *
+ * @module loop/plugins/window-frame/slots
+ */
+/**
+ * The leading edge of the title bar.
+ *
+ * The three dots are contributed here by the plugin itself, so a host that
+ * wants a different set of window controls can switch the plugin off and
+ * contribute its own rather than fight the ones it was given.
+ */
+export declare const WINDOW_CONTROLS_SLOT = "loop.window.controls";
+/**
+ * The trailing edge of the title bar.
+ *
+ * Empty unless a host fills it. What belongs here is what the *page* offers
+ * about the workspace — a link to the section that explains it, a sign-in
+ * prompt — as opposed to what the workspace offers about the conversation,
+ * which is the chat's own header.
+ */
+export declare const WINDOW_ACTIONS_SLOT = "loop.window.actions";

package/lib/loop/plugins/window-frame/slots.js

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The window frame's slots, by name.
+ *
+ * In their own module so the frame component, the plugin and a host that fills
+ * them can each import the names without importing each other — the same
+ * reason the graph plugin keeps its view type apart.
+ *
+ * @module loop/plugins/window-frame/slots
+ */
+/**
+ * The leading edge of the title bar.
+ *
+ * The three dots are contributed here by the plugin itself, so a host that
+ * wants a different set of window controls can switch the plugin off and
+ * contribute its own rather than fight the ones it was given.
+ */
+export const WINDOW_CONTROLS_SLOT = 'loop.window.controls';
+/**
+ * The trailing edge of the title bar.
+ *
+ * Empty unless a host fills it. What belongs here is what the *page* offers
+ * about the workspace — a link to the section that explains it, a sign-in
+ * prompt — as opposed to what the workspace offers about the conversation,
+ * which is the chat's own header.
+ */
+export const WINDOW_ACTIONS_SLOT = 'loop.window.actions';

package/lib/loop/presets.d.ts

@@ -0,0 +1,181 @@
+/**
+ * The plugins a Loop workspace normally has.
+ *
+ * A host builds a workspace by choosing plugins, which is the point of the
+ * architecture and also a lot to get right before seeing anything. This is the
+ * set the examples app runs, as a function, so a third party can start from a
+ * working Loop and take things out rather than assemble one from nothing.
+ *
+ * It exists because the landing page was importing the *example* to get it.
+ * An example is written to be read: its props are demonstration switches, its
+ * wiring is whatever made the demo clearest, and nothing about it is a promise.
+ * A page that embeds Loop needs the plugins, not the demonstration — and the
+ * two drifting apart should not be able to break somebody's home page.
+ *
+ * ```tsx
+ * const reactor = buildLoopReactor(loopPlugins({ serverUrl, target: 'browser' }));
+ * <LoopWorkspace reactor={reactor} serverUrl={serverUrl} agentId={agentId} />
+ * ```
+ *
+ * @module loop/presets
+ */
+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;
+    /** Where code runs: in the page, on a local server, or on Datalayer. */
+    target?: SandboxTarget;
+    /**
+     * Which surface opens beside the chat.
+     *
+     * A surface id rather than a fixed union, because the surfaces are
+     * contributed: an editor plugin the preset has never heard of is still a
+     * valid answer, and `'none'` is how a host asks for the chat alone.
+     */
+    defaultEditor?: ChatPluginConfig['defaultSurface'];
+    /** Whether the chat offers its surface switcher. */
+    showViewSelector?: boolean;
+    /** Whether the chat draws its own header. */
+    hideChatHeader?: boolean;
+    /** Where the prompt sits. Passed through to the chat plugin. */
+    promptPlacement?: ChatPluginConfig['promptPlacement'];
+    /**
+     * Whether the composer takes the caret when the workspace opens. True by
+     * default — the workspace is there to be typed into. A host that embeds the
+     * loop as one section of a longer page passes `false`, so that mounting it
+     * does not scroll the reader into the middle of the page.
+     */
+    autoFocusPrompt?: boolean;
+    /**
+     * Pixels to reserve at the top of the workspace when it goes full screen,
+     * for a host's own fixed header. Passed through to the chat plugin — see
+     * `ChatPluginConfig.fullScreenTopOffset` for what it changes and why
+     * setting it also keeps full screen off the browser's real API.
+     */
+    fullScreenTopOffset?: number | string;
+    /** Whether a person may choose between agent variants. */
+    showAgentVariants?: boolean;
+    /**
+     * Whether the header offers the team's member picker. True by default; a
+     * host that renders the choice itself passes `false`.
+     */
+    teamPicker?: boolean;
+    /**
+     * The page layout: the editor on a centred sheet, like a document, with
+     * the composer docked above it at the sheet's own width and the
+     * conversation in a panel beside it. Mounts `LoopPageLayoutPlugin`, which
+     * hands the chat view's parts to primer-addons' page layout through the
+     * `LoopChatLayout` point.
+     */
+    pageLayout?: boolean;
+    /**
+     * Where the page layout hangs the current turn on the composer: `below`
+     * (the default), `above`, or `none`. Only read with `pageLayout`.
+     */
+    pageLayoutTurnPanel?: 'below' | 'above' | 'none';
+    /**
+     * How the page layout stands the composer over the page: `docked` (the
+     * default) in a band above the canvas at the sheet's width, or `floating`
+     * 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`.
+     */
+    pageLayoutTurnPanelFooter?: 'full' | 'actions' | 'none';
+    /**
+     * The agent summary badge in the workspace header. On by default; a host
+     * whose page already introduces the agent switches it off.
+     */
+    agentSummary?: boolean;
+    /** The team whose agents are offered. */
+    teamId?: string;
+    /** What a local agent is created from, when one is. */
+    localAgent?: AgentsConfig['localAgent'];
+    /**
+     * The agentspec the local agent is created from, by id.
+     *
+     * Shorthand for the `localAgent` payload every host was writing out by
+     * hand; `localAgent`, when both are given, wins — it is the longhand.
+     */
+    localAgentSpec?: string;
+    /**
+     * The chat's composer in a floating, draggable card.
+     *
+     * Sets the chat's `promptPlacement` to `'floating'` — it is the same
+     * composer, card included — and mounts `PromptPlugin` for the `/prompt`
+     * command that focuses it: the two halves of one decision, taken together.
+     * Wins over `promptPlacement` when both are given.
+     */
+    floatingPrompt?: boolean;
+    /**
+     * Whether the notebook and document editors are mounted beside the chat.
+     *
+     * True by default. A host that wants the chat alone passes `false`: the
+     * two editor plugins, their toolbars and the surface strip all stay out,
+     * and the chat opens on no surface — rather than mounting editors and
+     * hiding the way to them, which leaves a workspace that still speaks of
+     * cells and documents.
+     */
+    editors?: boolean;
+    /**
+     * The editor choice in the workspace header rather than above the chat.
+     *
+     * Mounts `EditorsPlugin` and switches the chat's own surface strip off —
+     * again both halves of one decision: two controls offering the same choice
+     * would eventually disagree about what is open.
+     */
+    editorSelector?: boolean;
+    /**
+     * The plugin graph, reachable from the sidebar.
+     *
+     * Left out rather than mounted-and-hidden: it pulls the generic
+     * `@datalayer/reactor-graph` in as a dependency, and mounting both to show
+     * neither would put two plugins in the sidebar that do nothing.
+     */
+    graph?: boolean;
+    /** Ctrl-K over whatever the mounted plugins contribute. */
+    commandPalette?: boolean;
+    /** The sidebar that switches plugins on and off. */
+    pluginsPanel?: boolean;
+    /**
+     * The window chrome's slots.
+     *
+     * The frame itself is composed by the host — see `WindowFrame` — but the
+     * plugin is what opens its title bar to contributions, so a host that frames
+     * Loop wants this on.
+     */
+    windowFrame?: boolean;
+    /**
+     * Called once, the first time a person sends a message through the
+     * composer. Passed straight through to `InputPromptPlugin`'s own config —
+     * see `InputPromptPluginConfig.firstPromptHook` for what it is for and
+     * when it fires.
+     */
+    firstPromptHook?: () => void;
+};
+/**
+ * The standard set, with the options a host usually varies.
+ *
+ * Defaults are the embeddable ones: code runs in the page, so nothing has to
+ * be installed or signed into, and the switches a demonstration wants are off.
+ */
+export declare function loopPlugins(options?: LoopPresetOptions): PluginRef[];
+export default loopPlugins;

package/lib/loop/presets.js

@@ -0,0 +1,141 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The plugins a Loop workspace normally has.
+ *
+ * A host builds a workspace by choosing plugins, which is the point of the
+ * architecture and also a lot to get right before seeing anything. This is the
+ * set the examples app runs, as a function, so a third party can start from a
+ * working Loop and take things out rather than assemble one from nothing.
+ *
+ * It exists because the landing page was importing the *example* to get it.
+ * An example is written to be read: its props are demonstration switches, its
+ * wiring is whatever made the demo clearest, and nothing about it is a promise.
+ * A page that embeds Loop needs the plugins, not the demonstration — and the
+ * two drifting apart should not be able to break somebody's home page.
+ *
+ * ```tsx
+ * const reactor = buildLoopReactor(loopPlugins({ serverUrl, target: 'browser' }));
+ * <LoopWorkspace reactor={reactor} serverUrl={serverUrl} agentId={agentId} />
+ * ```
+ *
+ * @module loop/presets
+ */
+import { configurePlugin } from '@datalayer/reactor';
+import { ThemePlugin } from '@datalayer/primer-addons/lib/reactor';
+import { SubagentActivityPlugin } from './plugins/subagent-activity';
+import { A2uiPlugin } from './plugins/a2ui';
+import { ShellPlugin } from './plugins/shell';
+import { PromptPlugin } from './plugins/prompt';
+import { AgentspecsPlugin } from './plugins/agentspecs';
+import { AgentsPlugin, } from './plugins/agents';
+import { ChatPlugin } from './plugins/chat';
+import { ChatHeaderPlugin } from './plugins/chat-header';
+import { ChatViewPlugin } from './plugins/chat-view';
+import { DocumentViewPlugin } from './plugins/document-view';
+import { InputPromptPlugin } from './plugins/input-prompt';
+import { NotebookViewPlugin } from './plugins/notebook-view';
+import { LoopCommandsPlugin } from './plugins/commands';
+import { GraphViewPlugin } from './plugins/graph';
+import { ModelsPlugin } from './plugins/models';
+import { PluginsPanelPlugin } from './plugins/plugins-panel';
+import { WindowFramePlugin } from './plugins/window-frame';
+import { DocumentExtension, NotebookExtension } from './extensions';
+import { LoopPageLayoutPlugin } from './plugins/page-layout';
+/**
+ * The standard set, with the options a host usually varies.
+ *
+ * Defaults are the embeddable ones: code runs in the page, so nothing has to
+ * 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', 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.
+        configurePlugin(ChatPlugin, {
+            defaultSurface: editors ? defaultEditor : 'none',
+            // The chat's strip stands down when the header selector offers the
+            // same choice; see `editorSelector` — and when there is no editor
+            // to choose.
+            showSurfaceSelector: editors && showViewSelector && !editorSelector,
+            hideHeader: hideChatHeader,
+            promptPlacement: floatingPrompt ? 'floating' : promptPlacement,
+            autoFocusPrompt,
+            fullScreenTopOffset,
+        }),
+        // The composer and the title bar are plugins of their own: the chat
+        // assembles their props, these render them. In the preset by default —
+        // a chat without a composer is a demonstration, not a chat — and each is
+        // still switched individually in the plugins panel.
+        configurePlugin(InputPromptPlugin, { firstPromptHook }),
+        ChatHeaderPlugin,
+        // 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
+        // nothing.
+        ChatViewPlugin,
+        ...(editors ? [NotebookViewPlugin, DocumentViewPlugin] : []),
+        configurePlugin(AgentsPlugin, {
+            serverUrl,
+            target,
+            showAgentVariants,
+            showAgentSummary: agentSummary,
+            teamId,
+            showTeamPicker: teamPicker,
+            localAgent: localAgent ??
+                (localAgentSpec
+                    ? {
+                        createPayload: {
+                            description: `Local agent from the ${localAgentSpec} spec`,
+                            agent_library: 'pydantic-ai',
+                            agent_spec_id: localAgentSpec,
+                            enable_codemode: false,
+                        },
+                    }
+                    : undefined),
+        }),
+        // Two extensions rather than four plugins: each delivers an editor and the
+        // toolbar that reports on it. Every member is still switched individually.
+        ...(editors ? [NotebookExtension, DocumentExtension] : []),
+        A2uiPlugin,
+        AgentspecsPlugin,
+        ModelsPlugin,
+        // The Primer portal root, kept in the application's color mode, and the
+        // command that toggles it. Unconditional: every workspace portals
+        // something, and the palette's dependency alone would tie the theme to
+        // whether Ctrl-K happens to be mounted.
+        ThemePlugin,
+        // A delegation, visible: the subagent's icon pulses in the prompt's
+        // header while it works. Unconditional, because a parent that has handed
+        // work off is otherwise indistinguishable from one that has stopped.
+        SubagentActivityPlugin,
+        // The shell plugin is unconditional: it declares the points the others
+        // extend, and a workspace where extending works only if a selector
+        // happens to be on is a workspace with a trap in it. The selector itself
+        // stays behind the old switch.
+        configurePlugin(ShellPlugin, {
+            defaultEditor: editors ? defaultEditor : 'none',
+            showSelector: editors && editorSelector,
+        }),
+        ...(floatingPrompt ? [PromptPlugin] : []),
+        ...(pageLayout
+            ? [
+                configurePlugin(LoopPageLayoutPlugin, {
+                    turnPanel: pageLayoutTurnPanel,
+                    turnPanelFooter: pageLayoutTurnPanelFooter,
+                    prompt: pageLayoutPrompt,
+                    promptAnchor: pageLayoutPromptAnchor,
+                    pageSize: pageLayoutSize,
+                }),
+            ]
+            : []),
+        ...(graph ? [GraphViewPlugin] : []),
+        ...(commandPalette ? [LoopCommandsPlugin] : []),
+        ...(pluginsPanel ? [PluginsPanelPlugin] : []),
+        ...(windowFrame ? [WindowFramePlugin] : []),
+    ];
+}
+export default loopPlugins;

package/lib/loop/shell/LoopWorkspace.d.ts

@@ -0,0 +1,109 @@
+/**
+ * The workspace: one view, and slots for whatever a plugin wants beside it.
+ *
+ * The base is blank. It renders no prompt, no chat, no editor — those are all
+ * plugins, and a workspace mounted with none of them shows an empty frame,
+ * which is the honest picture of what the shell actually is. Even the prompt
+ * belongs to the chat plugin: it is the chat's input, and putting it in the
+ * shell made a workspace without a chat carry an input box wired to nothing.
+ *
+ * What the shell keeps is what only it can do: hold the view host, render the
+ * slots, and dispatch a typed message against every command every plugin
+ * contributed. That last one stays here — as `workspace.submit` — because no
+ * single plugin can see the others' commands.
+ *
+ * It mounts no providers of its own (no theme, no router, no query client): the
+ * entry point owns those and the workspace inherits them, which is what lets
+ * the same component run as a page, inside the Datalayer app, and later inside
+ * a JupyterLab panel.
+ *
+ * @module loop/shell/LoopWorkspace
+ */
+import type { JSX } from 'react';
+import type { ReactNode } from 'react';
+import { type PluginRef, type ReactorPlatform } from '@datalayer/reactor';
+import { type LoopWorkspaceContext, type SandboxSnapshot } from '../core';
+export type LoopWorkspaceProps = {
+    /** Server backing this session. */
+    serverUrl: string;
+    /** Agent bound to the session. */
+    agentId: string;
+    conversationId?: string;
+    model?: string;
+    sandbox?: SandboxSnapshot;
+    /** Plugins to mount. Ignored when `reactor` is given. */
+    extensions?: PluginRef[];
+    /** A prebuilt platform, for hosts that assemble their own. */
+    reactor?: ReactorPlatform;
+    /**
+     * Whether the workspace registers and starts the platform.
+     *
+     * A host that renders its own reactor-aware UI *around* the workspace — a
+     * plugin checkbox list, say — has to register the platform before that UI
+     * renders, and therefore owns the lifecycle. Passing `false` stops the
+     * workspace from starting it a second time.
+     */
+    manageReactor?: boolean;
+    /** View to open on. Defaults to the first that can be opened. */
+    initialViewType?: string;
+    /**
+     * Where a prompt goes when no view answers it.
+     *
+     * A host embedding the workspace in something that already has a
+     * conversation — the Datalayer app — takes the message itself.
+     */
+    onSend?: (message: string, workspace: LoopWorkspaceContext) => void;
+    /**
+     * How much room there is.
+     *
+     * `page` is the default: the shell owns the viewport. `panel` is a
+     * JupyterLab side panel — a column, not a page — where the switcher shows
+     * icons rather than labels and the header wraps instead of overflowing. The
+     * views are the same views; only the chrome around them gives way.
+     */
+    layout?: 'page' | 'panel';
+    /**
+     * Whether the header offers a choice of view.
+     *
+     * True by default. False when the host has already decided what the
+     * workspace is for — an embed that exists to show one notebook does not
+     * want a tab strip inviting the reader somewhere else — and the workspace
+     * opens on `initialViewType` and stays there.
+     */
+    showViewSelector?: boolean;
+    /**
+     * Whether the workspace draws its header row.
+     *
+     * True by default. False removes the row entirely — the view switcher and
+     * every control a plugin contributed to it — for a host whose own page
+     * already frames the workspace and does not want a second bar of chrome
+     * inside it.
+     *
+     * The plugins stay switched on: this hides where their controls are
+     * rendered, not what they do. A plugin that contributes a header button and
+     * a service keeps the service, and the button is simply never mounted.
+     */
+    showHeader?: boolean;
+    /**
+     * Extra controls for the chat's own title bar.
+     *
+     * For a host with something to add beside the agent's name — a link back to
+     * its page, a close button — without writing a plugin to add it. Anything
+     * that belongs to a capability rather than to this embed should contribute
+     * to `LoopSlots.chatHeader` instead, and both end up in the same row.
+     */
+    chatHeaderActions?: ReactNode;
+    /**
+     * The host's own controls for the workspace header row.
+     *
+     * The same bargain as `chatHeaderActions`, for the other header: a page
+     * embedding the workspace should not have to write a plugin to put its two
+     * menus in the row. Rendered before the plugins' contributions, so the
+     * host's additions read as part of the page; plugins reach the same row
+     * through `LoopSlots.header`.
+     */
+    headerActions?: ReactNode;
+};
+/** Build the platform for a set of plugins. */
+export declare function buildLoopReactor(extensions: PluginRef[]): ReactorPlatform;
+export declare function LoopWorkspace(props: LoopWorkspaceProps): JSX.Element;