@datalayer/agent-runtimes 1.0.29 → 1.3.11

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

@@ -0,0 +1,41 @@
+/** Whether a tool changes nothing on an editor. */
+export declare function isChatViewTool(name: string): boolean;
+/** The subset of `tools` an agent is handed while no editor is on screen. */
+export declare function toolsForChatView<T extends {
+    name: string;
+}>(tools: T[], 
+/** Names a contribution vouched for (`chatView: true`), kept regardless. */
+keep?: ReadonlySet<string>): T[];
+/**
+ * The order tool contributions are merged in, by their contribution id.
+ *
+ * The notebook and the document used to ship an `executeCode` under one
+ * reference name, and which contribution arrived first decided which won —
+ * a race, and in the chat view the document's would answer "No active kernel
+ * session" to a request the notebook's could serve. The names are specific
+ * now (`executeCodeInNotebook`, `executeCodeInDocument`), so nothing is
+ * shadowed; the order is kept deterministic all the same, because "first
+ * wins" should never again depend on which lazy import landed first.
+ *
+ * The editor on screen goes first; with none on screen, the notebook does.
+ * Everything else keeps its relative order.
+ */
+export declare function orderToolContributions<T extends {
+    value: {
+        id: string;
+    };
+}>(entries: readonly T[], activeSurfaceId: string | undefined): T[];
+/**
+ * Whether a contribution's tools belong to a surface that is not the one on
+ * screen.
+ *
+ * A contribution named `${surfaceId}-tools`, by the notebook and document
+ * plugins' own convention, belongs to that one editor. With no editor active
+ * (`activeSurfaceId` undefined — the chat view), nothing is excluded here:
+ * every surface's tools are still candidates, narrowed instead by
+ * `toolsForChatView`. A contribution whose id doesn't follow the
+ * `-tools` convention, or whose surface isn't one of `surfaceIds` at all
+ * (a host's own tools, say), is never excluded — this only ever withholds
+ * another *editor's* tools, never a tool that was never tied to one.
+ */
+export declare function isInactiveSurfaceContribution(id: string, surfaceIds: ReadonlySet<string>, activeSurfaceId: string | undefined): boolean;

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

@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The tools an agent keeps, depending on what is on screen.
+ *
+ * With an editor open, the agent has that editor's own tools — not every
+ * editor's: the notebook and the document plugins mount together whenever a
+ * workspace offers a choice of either (an `editorSelector`, or a fixed
+ * `defaultEditor` with the other still reachable), and their contributions
+ * used to reach the model together regardless of which one was actually on
+ * screen — asking about a failure while the document was open ran the
+ * notebook's cell tools instead of the document's block ones, because
+ * nothing excluded the surface that was not showing (see
+ * `isInactiveSurfaceContribution`).
+ *
+ * In the chat view — no editor on screen at all — the notebook and the
+ * document are still mounted, out of sight, so every tool would still
+ * *work*, but a cell inserted into a notebook nobody is looking at is a
+ * change the person did not see happen. So there the agent keeps only the
+ * ones that leave the editors as they are — `executeCodeInNotebook` and
+ * `executeCodeInDocument`, whose outputs stream onto the conversation, and
+ * the read and list tools, so it can still answer from what is there.
+ *
+ * Names are matched by their reference form and their raw `datalayer_` form
+ * alike, since the adapter registers whichever the definition carries.
+ *
+ * @module loop/plugins/chat/chatViewTools
+ */
+/** The reference name, with the adapter's prefix and the editor suffix off. */
+function bareName(name) {
+    return name.replace(/^datalayer_/, '').replace(/_lexical$/, '');
+}
+/** Whether a tool changes nothing on an editor. */
+export function isChatViewTool(name) {
+    const bare = bareName(name);
+    return (/^executeCodeIn(Notebook|Document)$/.test(bare) ||
+        /^(read|list)[A-Z]/.test(bare));
+}
+/** The subset of `tools` an agent is handed while no editor is on screen. */
+export function toolsForChatView(tools, 
+/** Names a contribution vouched for (`chatView: true`), kept regardless. */
+keep) {
+    return tools.filter(tool => keep?.has(tool.name) || isChatViewTool(tool.name));
+}
+/**
+ * The order tool contributions are merged in, by their contribution id.
+ *
+ * The notebook and the document used to ship an `executeCode` under one
+ * reference name, and which contribution arrived first decided which won —
+ * a race, and in the chat view the document's would answer "No active kernel
+ * session" to a request the notebook's could serve. The names are specific
+ * now (`executeCodeInNotebook`, `executeCodeInDocument`), so nothing is
+ * shadowed; the order is kept deterministic all the same, because "first
+ * wins" should never again depend on which lazy import landed first.
+ *
+ * The editor on screen goes first; with none on screen, the notebook does.
+ * Everything else keeps its relative order.
+ */
+export function orderToolContributions(entries, activeSurfaceId) {
+    const rank = (entry) => {
+        if (activeSurfaceId && entry.value.id === `${activeSurfaceId}-tools`) {
+            return 0;
+        }
+        return entry.value.id === 'notebook-tools' ? 1 : 2;
+    };
+    return entries
+        .map((entry, index) => ({ entry, index, rank: rank(entry) }))
+        .sort((a, b) => a.rank - b.rank || a.index - b.index)
+        .map(item => item.entry);
+}
+/**
+ * Whether a contribution's tools belong to a surface that is not the one on
+ * screen.
+ *
+ * A contribution named `${surfaceId}-tools`, by the notebook and document
+ * plugins' own convention, belongs to that one editor. With no editor active
+ * (`activeSurfaceId` undefined — the chat view), nothing is excluded here:
+ * every surface's tools are still candidates, narrowed instead by
+ * `toolsForChatView`. A contribution whose id doesn't follow the
+ * `-tools` convention, or whose surface isn't one of `surfaceIds` at all
+ * (a host's own tools, say), is never excluded — this only ever withholds
+ * another *editor's* tools, never a tool that was never tied to one.
+ */
+export function isInactiveSurfaceContribution(id, surfaceIds, activeSurfaceId) {
+    if (!activeSurfaceId || !id.endsWith('-tools')) {
+        return false;
+    }
+    const surfaceId = id.slice(0, -'-tools'.length);
+    return surfaceIds.has(surfaceId) && surfaceId !== activeSurfaceId;
+}

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

@@ -0,0 +1,111 @@
+/** What a host may set on the chat. */
+export type ChatPluginConfig = {
+    /**
+     * What the empty prompt says.
+     *
+     * Configured on the plugin rather than passed to the workspace: the prompt
+     * belongs to the chat, and a shell that has no chat plugin has no prompt to
+     * put a placeholder in. A host that wants different words says so where the
+     * words are.
+     */
+    placeholder: string;
+    /**
+     * Which editor is open beside the chat when the workspace opens.
+     *
+     * `'none'` leaves the chat full width. Any other value is the `surfaceId` of
+     * a contributed chat surface — `'notebook'`, `'document'`, or one a plugin
+     * this host mounts brings of its own; the field is a plain string rather
+     * than a union so a new surface does not have to change this type to be
+     * choosable.
+     *
+     * A surface that is not contributed, or cannot open yet, is simply not
+     * opened: the default is a preference, not a demand, and a host that asks
+     * for the notebook in a workspace with no notebook plugin gets a working
+     * chat rather than an error.
+     */
+    defaultSurface: string;
+    /**
+     * Whether a person may change which editor sits beside the chat.
+     *
+     * True by default. False leaves `defaultSurface` open and removes the
+     * control, for a host that has already decided what the workspace is for —
+     * an embed showing one notebook does not want a strip inviting the reader
+     * to swap it for a document or for nothing at all.
+     */
+    showSurfaceSelector: boolean;
+    /**
+     * Whether the chat draws its own title bar.
+     *
+     * False by default — the header carries the agent's name and the reason a
+     * disabled chat is disabled, and both are worth having.
+     *
+     * True for a host that has already said what this is. On a landing page the
+     * workspace sits under a heading that names it, and a second title bar
+     * directly beneath repeats the point in a smaller font.
+     */
+    hideHeader: boolean;
+    /**
+     * Whether the chat renders a prompt at all.
+     *
+     * False by default: the prompt is most of what a chat is. True is for a
+     * workspace where something else owns the typing — the floating prompt
+     * plugin renders its own input and submits through the same
+     * `workspace.submit`, and a second box under the transcript would be two
+     * composers for one conversation.
+     */
+    hidePrompt: boolean;
+    /**
+     * Where the prompt sits.
+     *
+     * `bottom` (the default) spans the workspace: the notebook and the
+     * conversation share one composer, which is right when what the agent is
+     * doing is the document beside it.
+     *
+     * `bottom-chat` keeps it inside the chat column, under the transcript, where
+     * every other example in this package puts it. The prompt then reads as part
+     * of the conversation rather than as a bar the whole page rests on — better
+     * for a host that embeds the workspace as a chat that happens to have a
+     * notebook attached.
+     *
+     * `floating` takes it out of the layout entirely: the same composer — the
+     * lexical editor, the tools/skills/model footer, all of it — in a draggable
+     * card over the workspace, bottom-centre until somebody moves it. For a
+     * shell that is mostly canvas. `loopPlugins({ floatingPrompt: true })` asks
+     * for it together with the `/prompt` command that focuses it.
+     *
+     * `top` puts it above everything — a horizontal bar across the workspace,
+     * with the openers as a row of chips directly under it. For a host whose
+     * editor is the point: the notebook takes the rest of the height, the
+     * prompt reads as its command line rather than as a chat's tail, and a
+     * reader who has never seen the product knows what to type first.
+     */
+    promptPlacement: 'top' | 'bottom' | 'bottom-chat' | 'floating';
+    /**
+     * Whether the composer takes the caret when the workspace opens.
+     *
+     * True is right nearly everywhere: the workspace exists to be typed into,
+     * and a person who opened it should not have to click first. It is wrong
+     * where the loop is one section of a longer page — focusing an input on
+     * mount scrolls the browser to it, so a visitor who came for the top of the
+     * page is thrown into the middle of it, and a screen reader is moved with
+     * them. Such a host passes `false` and lets the reader arrive at the prompt.
+     */
+    autoFocusPrompt: boolean;
+    /**
+     * Pixels to reserve at the top of the workspace when it goes full screen —
+     * room for a host's own fixed header, drawn outside the workspace
+     * entirely.
+     *
+     * Setting this also keeps full screen on the CSS-overlay door for good,
+     * never the browser's real Fullscreen API: the API promotes the workspace
+     * above *everything* on the page, that header included, and there is no
+     * partial form of it that leaves a sibling element on screen — see
+     * `useWorkspaceFullScreen`'s own `forceOverlay` for why. 0 (the default)
+     * leaves full screen trying the API first, the way most hosts want it, and
+     * filling the entire viewport when it falls back to the overlay.
+     */
+    fullScreenTopOffset: number | string;
+};
+export declare const CHAT_PLUGIN_NAME = "@datalayer/loop-plugin-chat";
+export declare const ChatPlugin: import("@datalayer/reactor").ReactorPlugin<ChatPluginConfig, unknown, unknown>;
+export default ChatPlugin;

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

@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The chat plugin: the first view, and the proof that chat is not special.
+ *
+ * @module loop/plugins/chat
+ */
+import { CommentDiscussionIcon, FoldIcon, SparkleFillIcon, SyncIcon, } from '@primer/octicons-react';
+import { contribution, definePlugin } from '@datalayer/reactor';
+import { LoopAgentGate, LoopChatComposer, LoopChatExtras, LoopChatHeader, LoopChatSuggestion, LoopChatTurn, LoopCommand, LoopFrontendTool, LoopDocumentToolbarItem, LoopNotebookToolbarItem, LoopViewType, } from '../../core';
+import { createTurnFeed, feedWriters } from './turnState';
+/**
+ * An editor toolbar button that asks an agent to do something.
+ *
+ * These live here, on the chat, rather than on the editors — which is where
+ * they were. A button that submits a prompt only works because there is a
+ * conversation to submit it to, so the notebook was reaching into the chat to
+ * draw it. Contributing them from this side inverts that: the editors offer a
+ * toolbar and know nothing about agents, and switching the chat off takes its
+ * buttons off both toolbars with it.
+ *
+ * The specialists are reached the way a person would reach them — by asking.
+ * A button that called a private API would be a second way to invoke an agent,
+ * free to drift from the one people type.
+ */
+function agentAction(context, item) {
+    const { prompt, ...rest } = item;
+    return {
+        ...rest,
+        type: 'button',
+        group: 'agent',
+        onClick: () => context.workspace.prompts.submit(prompt),
+    };
+}
+export const CHAT_PLUGIN_NAME = '@datalayer/loop-plugin-chat';
+export const ChatPlugin = definePlugin({
+    name: CHAT_PLUGIN_NAME,
+    config: {
+        placeholder: 'Ask anything, type / for commands or @ for mention',
+        // The notebook: it is what most of these agents work on, and a workspace
+        // that opens on an empty chat hides the half of itself that does the work.
+        defaultSurface: 'notebook',
+        showSurfaceSelector: true,
+        hideHeader: false,
+        hidePrompt: false,
+        promptPlacement: 'bottom',
+        autoFocusPrompt: true,
+        fullScreenTopOffset: 0,
+    },
+    displayName: 'Chat',
+    description: 'The conversation, the prompt, and the point editors plug into.',
+    octicon: 'comment-discussion',
+    emoji: '\u{1F4AC}',
+    // Declared, not merely used: the registry knows who contributed to a point,
+    // it cannot know who opened it, and a point nobody has filled yet is exactly
+    // when knowing it exists is most useful. `LoopFrontendTool` is the chat's
+    // own opening: the tools its agent is handed, filled by the notebook, the
+    // document, and whoever else owns a capability. The composer and the title
+    // bar are openings too: the chat assembles their props, and the
+    // input-prompt and chat-header plugins render them.
+    contributionPoints: [
+        LoopAgentGate,
+        LoopFrontendTool,
+        LoopChatComposer,
+        LoopChatHeader,
+        LoopChatSuggestion,
+        LoopChatExtras,
+        LoopChatTurn,
+    ],
+    /*
+     * The current turn, contributed at build so it is one per reactor.
+     *
+     * The chat both opens `LoopChatTurn` and fills it: the point is how anyone
+     * else reads the turn (the page layout's panel under the prompt), and the
+     * chat view is what keeps it current. The feed's writers travel with the
+     * contribution so the view can find its own reactor's feed without a
+     * module-level singleton two workspaces on one page would share.
+     */
+    build: ctx => {
+        const feed = createTurnFeed();
+        ctx.contribute(LoopChatTurn, { id: 'chat-turn', turn: feed.turn, ...feedWriters(feed) }, { id: 'chat-turn' });
+        return {};
+    },
+    contributes: [
+        contribution(LoopViewType, {
+            viewType: 'chat',
+            title: 'Chat',
+            icon: CommentDiscussionIcon,
+            order: 0,
+            load: () => import('./ChatView'),
+        }, { id: 'chat', order: 0 }),
+        contribution(LoopCommand, {
+            name: 'chat',
+            description: 'Show the conversation',
+            group: 'Session',
+            keybinding: 'Mod+Alt+K',
+            run: async ({ workspace }) => {
+                workspace.setActiveViewType('chat');
+            },
+        }, { id: 'chat' }),
+        // What the chat puts on the notebook's toolbar. The bar belongs to the
+        // toolbar plugin, which opens this point; the notebook knows about neither.
+        // With the toolbar plugin switched off there is no bar, so these have
+        // nowhere to sit and are not drawn — which is the honest outcome.
+        contribution(LoopNotebookToolbarItem, {
+            items: (context) => [
+                agentAction(context, {
+                    key: 'loop-compact',
+                    ariaLabel: 'Compact this notebook',
+                    title: 'Ask @NotebookCompactor to shorten it without changing results',
+                    icon: FoldIcon,
+                    order: 200,
+                    prompt: '@NotebookCompactor compact this notebook without changing what it computes.',
+                }),
+                agentAction(context, {
+                    key: 'loop-reproduce',
+                    ariaLabel: 'Check reproducibility',
+                    title: 'Ask @NotebookReproducer to run it on a fresh sandbox',
+                    icon: SyncIcon,
+                    order: 201,
+                    prompt: '@NotebookReproducer run this notebook top to bottom on a fresh sandbox and report what does not reproduce.',
+                }),
+            ],
+        }, { id: 'agent-actions', order: 200 }),
+        // And on the document's, which had no agent actions at all before there
+        // was a point to put them on.
+        contribution(LoopDocumentToolbarItem, {
+            items: (context) => [
+                agentAction(context, {
+                    key: 'loop-summarise',
+                    ariaLabel: 'Summarise this document',
+                    title: 'Ask the agent for a summary of what this document says',
+                    icon: SparkleFillIcon,
+                    order: 200,
+                    prompt: 'Summarise this document in a short paragraph.',
+                }),
+            ],
+        }, { id: 'agent-actions', order: 200 }),
+    ],
+});
+export default ChatPlugin;

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

@@ -0,0 +1,41 @@
+/**
+ * The conversation's current turn, kept by the chat and read by anyone.
+ *
+ * One instance per reactor — created by the chat plugin when it builds and
+ * contributed to `LoopChatTurn` — so two workspaces on one page do not share
+ * a turn. The chat view drives it: `begin` on send (which is what clears the
+ * previous turn), `assistant` as the reply arrives, `end` when the agent
+ * stops. Readers hold the signal.
+ *
+ * @module loop/plugins/chat/turnState
+ */
+import { type ReadonlySignal } from '@datalayer/reactor';
+import type { ContextSnapshotData } from '../../../types';
+import type { ChatTurnSnapshot, ChatTurnStatus } from '../../core';
+export type TurnFeed = {
+    /** The turn, for readers. */
+    turn: ReadonlySignal<ChatTurnSnapshot>;
+    /** A new turn: the previous one is gone, this one holds the message. */
+    begin: (user: string) => void;
+    /** The reply so far. Moves the turn to `streaming` on its first text. */
+    assistant: (text: string) => void;
+    /** The agent stopped, one way or another. */
+    end: (status?: Extract<ChatTurnStatus, 'done' | 'error'>) => void;
+    /** The context window, as the agent last reported it. */
+    usage: (snapshot: ContextSnapshotData | undefined) => void;
+    /** What the agent is doing now, or nothing. */
+    activity: (label: string | undefined) => void;
+};
+export declare function createTurnFeed(): TurnFeed;
+/**
+ * The writers, as extra fields on the contribution.
+ *
+ * `ChatTurnContribution` is read-only by type — that is what readers get —
+ * but the chat view has to reach the same feed to drive it, and it finds it
+ * through the contribution like everyone else. So the writers ride along as
+ * fields the public type does not name; {@link turnWritersOf} is how the view
+ * gets them back.
+ */
+export declare const TURN_WRITERS: unique symbol;
+export declare function feedWriters(feed: TurnFeed): Record<symbol, TurnFeed>;
+export declare function turnWritersOf(value: unknown): TurnFeed | undefined;

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

@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The conversation's current turn, kept by the chat and read by anyone.
+ *
+ * One instance per reactor — created by the chat plugin when it builds and
+ * contributed to `LoopChatTurn` — so two workspaces on one page do not share
+ * a turn. The chat view drives it: `begin` on send (which is what clears the
+ * previous turn), `assistant` as the reply arrives, `end` when the agent
+ * stops. Readers hold the signal.
+ *
+ * @module loop/plugins/chat/turnState
+ */
+import { signal } from '@datalayer/reactor';
+const IDLE = { id: 0, status: 'idle' };
+export function createTurnFeed() {
+    const turn = signal(IDLE);
+    return {
+        turn,
+        begin: user => {
+            // The window's fill carries over: it is the conversation's, not the
+            // turn's, and the footer under a fresh turn should not read empty
+            // until the agent reports again.
+            turn.value = {
+                id: turn.value.id + 1,
+                user,
+                status: 'thinking',
+                usage: turn.value.usage,
+            };
+        },
+        assistant: text => {
+            const current = turn.value;
+            // Nothing to attach it to, or nothing new: leave the value alone so
+            // readers do not re-render for an identical snapshot.
+            if (current.status === 'idle' || current.assistant === text) {
+                return;
+            }
+            turn.value = {
+                ...current,
+                assistant: text,
+                status: current.status === 'done' || current.status === 'error'
+                    ? current.status
+                    : text
+                        ? 'streaming'
+                        : current.status,
+            };
+        },
+        usage: snapshot => {
+            const current = turn.value;
+            // Kept even while idle: the agent reports the window once at mount,
+            // before anyone has typed, and the first turn wants those figures.
+            if (current.usage === snapshot) {
+                return;
+            }
+            turn.value = { ...current, usage: snapshot };
+        },
+        activity: label => {
+            const current = turn.value;
+            if (current.status === 'idle' || current.activity === label) {
+                return;
+            }
+            turn.value = { ...current, activity: label };
+        },
+        end: (status = 'done') => {
+            const current = turn.value;
+            if (current.status === 'idle') {
+                return;
+            }
+            turn.value = { ...current, status, activity: undefined };
+        },
+    };
+}
+/**
+ * The writers, as extra fields on the contribution.
+ *
+ * `ChatTurnContribution` is read-only by type — that is what readers get —
+ * but the chat view has to reach the same feed to drive it, and it finds it
+ * through the contribution like everyone else. So the writers ride along as
+ * fields the public type does not name; {@link turnWritersOf} is how the view
+ * gets them back.
+ */
+export const TURN_WRITERS = Symbol.for('loop.chat.turn.writers');
+export function feedWriters(feed) {
+    return { [TURN_WRITERS]: feed };
+}
+export function turnWritersOf(value) {
+    return value?.[TURN_WRITERS];
+}

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

@@ -0,0 +1,14 @@
+import type { ReactorPlugin } from '@datalayer/reactor';
+import { type LoopChatExtrasValue } from '../../core';
+export declare const CHAT_EXTRAS_PLUGIN_NAME = "@datalayer/loop-plugin-chat-extras";
+export type ChatExtrasHandle = {
+    plugin: ReactorPlugin<Record<string, never>, unknown, unknown>;
+    /** Replace the live extras the chat view reads. */
+    setExtras: (value: LoopChatExtrasValue) => void;
+};
+/**
+ * A chat-extras plugin plus its setter. Call once per workspace (memoise it),
+ * then push updates through `setExtras`.
+ */
+export declare function createChatExtrasPlugin(): ChatExtrasHandle;
+export default createChatExtrasPlugin;

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

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * `@datalayer/loop-plugin-chat-extras` — a live channel from a host example
+ * into the loop's conversation.
+ *
+ * An example that wraps a `LoopEmbed` in its own panels still has things to
+ * say to the chat column that change over the life of the page: an error
+ * banner it derives from its own state, the codemode toggle, the MCP and
+ * codemode status the footer shows. {@link createChatExtrasPlugin} returns a
+ * plugin to hand `LoopEmbed` and a `setExtras` the example calls whenever
+ * those change — backed by a signal, so the chat view re-renders without the
+ * plugin being rebuilt.
+ *
+ * ```tsx
+ * const { plugin, setExtras } = useMemo(() => createChatExtrasPlugin(), []);
+ * useEffect(() => setExtras({ errorBanner, codemodeEnabled }), […]);
+ * <LoopEmbed plugins={[capacityPlugin, plugin]} … />
+ * ```
+ *
+ * @module loop/plugins/chat-extras
+ */
+import { contribution, definePlugin, signal } from '@datalayer/reactor';
+import { LoopChatExtras } from '../../core';
+export const CHAT_EXTRAS_PLUGIN_NAME = '@datalayer/loop-plugin-chat-extras';
+let counter = 0;
+/**
+ * A chat-extras plugin plus its setter. Call once per workspace (memoise it),
+ * then push updates through `setExtras`.
+ */
+export function createChatExtrasPlugin() {
+    const id = `chat-extras-${(counter += 1)}`;
+    const extras = signal({});
+    const plugin = definePlugin({
+        name: CHAT_EXTRAS_PLUGIN_NAME,
+        displayName: 'Chat Extras',
+        description: 'A host example’s live banner and footer status.',
+        octicon: 'megaphone',
+        emoji: '\u{1F4E3}',
+        contributes: [contribution(LoopChatExtras, { id, extras }, { id })],
+    });
+    return {
+        plugin,
+        setExtras: value => {
+            extras.value = value;
+        },
+    };
+}
+export default createChatExtrasPlugin;

package/lib/loop/plugins/chat-header/HeaderView.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The standard bar: the assembled props, rendered by `ChatBaseHeader`.
+ *
+ * In its own file for the same reason as the composer's view: the header
+ * pulls the kernel indicator and its friends, and the plugin's module
+ * should stay a manifest.
+ *
+ * @module loop/plugins/chat-header/HeaderView
+ */
+import type { JSX } from 'react';
+import type { LoopChatHeaderProps } from '../../core';
+export declare function HeaderView({ header }: LoopChatHeaderProps): JSX.Element;
+export default HeaderView;

package/lib/loop/plugins/chat-header/HeaderView.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ChatBaseHeader } from '../../../chat/header/ChatHeaderBase';
+export function HeaderView({ header }) {
+    return _jsx(ChatBaseHeader, { ...header });
+}
+export default HeaderView;

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

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

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

@@ -0,0 +1,21 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Suspense, lazy } from 'react';
+import { contribution, definePlugin } from '@datalayer/reactor';
+import { LoopChatHeader } from '../../core';
+export const CHAT_HEADER_PLUGIN_NAME = '@datalayer/loop-plugin-chat-header';
+const LazyHeaderView = lazy(() => import('./HeaderView'));
+/** The lazy boundary, so the point's consumers need no Suspense of theirs. */
+function HeaderView(props) {
+    return (_jsx(Suspense, { fallback: null, children: _jsx(LazyHeaderView, { ...props }) }));
+}
+export const ChatHeaderPlugin = definePlugin({
+    name: CHAT_HEADER_PLUGIN_NAME,
+    displayName: 'Chat Header',
+    description: 'The conversation’s title bar: agent, kernel, actions.',
+    octicon: 'rows',
+    emoji: '\u{1F3F7}\u{FE0F}',
+    contributes: [
+        contribution(LoopChatHeader, { id: 'chat-header', Component: HeaderView }, { id: 'chat-header' }),
+    ],
+});
+export default ChatHeaderPlugin;

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

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