@datalayer/agent-runtimes 1.0.29 → 1.3.10

package/lib/loop/plugins/plugins-panel/index.js

@@ -0,0 +1,74 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * `@datalayer/loop-plugin-plugins-panel` — the plugin list, as a plugin.
+ *
+ * It fills the sidebar slot like any other contribution, which is the joke and
+ * also the proof: the thing that switches plugins on and off is itself one, and
+ * can be left out of a host that does not want it.
+ *
+ * The list itself is no longer written here. `@datalayer/reactor-manager` is
+ * the same surface, generic — a filter, a row per plugin, a switch each — and
+ * the workspace had grown its own copy that answered the same questions
+ * slightly differently. This plugin is now the loop's placement of it: which
+ * slot it goes in, and which plugin may not be switched off.
+ *
+ * What went with the rewrite is the graph button. The panel used to draw it,
+ * which meant asking by name whether a graph view was mounted; the graph
+ * plugin contributes it to the manager's action slot now, so it appears and
+ * disappears with the thing it opens.
+ *
+ * @module loop/plugins/plugins-panel
+ */
+import { definePlugin } from '@datalayer/reactor';
+import { GraphPlugin } from '@datalayer/reactor-graph';
+import { PluginsManagerView } from '@datalayer/reactor-manager';
+import { LoopSlots } from '../../core';
+export const PLUGINS_PANEL_PLUGIN_NAME = '@datalayer/loop-plugin-plugins-panel';
+/**
+ * How wide the panel is, and the aside around it.
+ *
+ * Declared here rather than in the shell so the two cannot disagree: the panel
+ * truncates its descriptions to the width it was given, and truncating to a
+ * width the container does not actually have is how text ends up cut short in
+ * the middle of empty space.
+ */
+export const SIDEBAR_WIDTH = 420;
+/** The generic graph plugin, which the loop's own adapter wraps. */
+const REACTOR_GRAPH_PLUGIN_NAME = GraphPlugin.name;
+export const PluginsPanelPlugin = definePlugin({
+    name: PLUGINS_PANEL_PLUGIN_NAME,
+    displayName: 'Plugins panel',
+    description: 'Switch plugins on and off while the workspace runs.',
+    octicon: 'plug',
+    emoji: '\u{1F50C}',
+    build: () => ({
+        components: [
+            {
+                id: 'plugins-panel',
+                slot: LoopSlots.sidebar,
+                // Last in the sidebar: it is about the workspace rather than part of
+                // the work, so a plugin's own panel — the decks list, say — sits
+                // above it whatever order the plugins were listed in.
+                order: 900,
+                // Itself protected: switching the panel off would remove the only way
+                // to switch anything back on.
+                //
+                // The workspace is forwarded rather than used here — the manager
+                // passes whatever it is given to the plugins contributing actions, and
+                // the graph button is the one that needs it.
+                Component: ({ workspace }) => (_jsx(PluginsManagerView, { protectedPlugins: [PLUGINS_PANEL_PLUGIN_NAME], 
+                    // `@datalayer/loop-plugin-graph` is the switch that matters: it
+                    // places the graph in this workspace and pulls the generic plugin
+                    // in as a dependency. Listing both put two switches in front of
+                    // one feature, with no way to tell which to use.
+                    hiddenPlugins: [REACTOR_GRAPH_PLUGIN_NAME], width: SIDEBAR_WIDTH, workspace: workspace })),
+            },
+        ],
+    }),
+});
+export { PluginsManagerView as PluginsPanel } from '@datalayer/reactor-manager';
+export default PluginsPanelPlugin;

package/lib/loop/plugins/prompt/NewChatAction.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The + in the prompt's footer: start the conversation over.
+ *
+ * The chat header carries the same control, and a workspace that hides that
+ * header — the Loop Shell does — used to lose the only way to reset. This one
+ * lives with the composer, which is on screen in every placement.
+ *
+ * It presses the `/new` command rather than reaching into the chat, so the
+ * button and the slash command cannot drift: one intent, one path, and the
+ * command's own error shows when no conversation is on screen.
+ *
+ * @module loop/plugins/prompt/NewChatAction
+ */
+import type { JSX } from 'react';
+import type { LoopWorkspaceContext } from '../../core';
+export declare function NewChatAction({ workspace, }: {
+    workspace?: LoopWorkspaceContext;
+}): JSX.Element | null;
+export default NewChatAction;

package/lib/loop/plugins/prompt/NewChatAction.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { IconButton } from '@primer/react';
+import { PlusIcon } from '@primer/octicons-react';
+export function NewChatAction({ workspace, }) {
+    if (!workspace) {
+        return null;
+    }
+    return (_jsx(IconButton, { icon: PlusIcon, "aria-label": "New conversation", title: "New conversation", variant: "invisible", size: "small", onClick: () => void workspace.submit('/new') }));
+}
+export default NewChatAction;

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

@@ -0,0 +1,11 @@
+import { NewChatAction } from './NewChatAction';
+export declare const PROMPT_PLUGIN_NAME = "@datalayer/loop-plugin-prompt";
+export declare const PromptPlugin: import("@datalayer/reactor").ReactorPlugin<Record<string, never>, unknown, {
+    components: {
+        id: string;
+        slot: "loop.promptAction";
+        Component: typeof NewChatAction;
+    }[];
+}>;
+export { focusPrompt, onPromptFocusRequest } from '../../core';
+export default PromptPlugin;

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

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * `@datalayer/loop-plugin-prompt` — the prompt as a first-class subject.
+ *
+ * The composer itself is the chat's, whatever the placement: docked under the
+ * workspace, in the chat column, or floating in a draggable card
+ * (`promptPlacement: 'floating'` on the chat, which is the real
+ * `InputPrompt` — lexical editor, slash commands, the tools/skills/model
+ * footer — wrapped in `FloatingCard`). This plugin deliberately ships no
+ * second input box: two composers for one conversation is one too many, and a
+ * reimplementation would be a composer that drifts.
+ *
+ * What it adds is around the composer: `/prompt` (Mod+Alt+P) puts the caret
+ * in it from anywhere, through the same ask-and-answer channel the editor
+ * commands use; `/new` (Mod+Alt+R) starts the conversation over, and the +
+ * this plugin puts in the prompt's footer bar presses exactly that command.
+ * `loopPlugins({ floatingPrompt: true })` mounts this plugin and asks the
+ * chat for the floating placement together.
+ *
+ * @module loop/plugins/prompt
+ */
+import { contribution, definePlugin } from '@datalayer/reactor';
+import { LoopCommand, LoopSlots, focusPrompt } from '../../core';
+import { NewChatAction } from './NewChatAction';
+export const PROMPT_PLUGIN_NAME = '@datalayer/loop-plugin-prompt';
+export const PromptPlugin = definePlugin({
+    name: PROMPT_PLUGIN_NAME,
+    displayName: 'Prompt',
+    description: 'Prompt commands: focus the composer, start over, and the +.',
+    octicon: 'paper-airplane',
+    emoji: '\u{1FAB6}',
+    contributes: [
+        contribution(LoopCommand, {
+            name: 'prompt',
+            description: 'Focus the prompt',
+            group: 'Session',
+            keybinding: 'Mod+Alt+P',
+            run: async () => {
+                if (!focusPrompt()) {
+                    throw new Error('No prompt is on screen to focus.');
+                }
+            },
+        }, { id: 'prompt' }),
+        contribution(LoopCommand, {
+            name: 'new',
+            aliases: ['reset'],
+            description: 'Start the conversation over',
+            group: 'Session',
+            keybinding: 'Mod+Alt+R',
+            run: async ({ workspace }) => {
+                const reset = workspace.viewControls.newChat;
+                if (!reset) {
+                    throw new Error('No conversation is on screen to start over.');
+                }
+                reset();
+            },
+        }, { id: 'new' }),
+    ],
+    build: () => ({
+        components: [
+            {
+                id: 'new-chat',
+                slot: LoopSlots.promptAction,
+                Component: NewChatAction,
+            },
+        ],
+    }),
+});
+export { focusPrompt, onPromptFocusRequest } from '../../core';
+export default PromptPlugin;

package/lib/loop/plugins/shell/editorChoice.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The editor choice, in the loop's vocabulary.
+ *
+ * The store itself lives in `@datalayer/reactor-shell` now — the loop's
+ * editor selector grew into the generic shell plugin, and this module is the
+ * thin dictionary between the two: `editor` here is `view` there. Kept so
+ * everything written against the loop's names (the `/editor` command, the
+ * tests, the barrel) reads unchanged.
+ *
+ * The one behavioural difference from the old local store is deliberate:
+ * `chooseEditor` no longer calls the chat's surface channel itself — the
+ * generic store announces every choice through the announcer the loop's
+ * shell plugin installs, which is wired to `requestSurface`. One path,
+ * whether the choice came from the selector, `/editor`, or the generic
+ * cycle command.
+ *
+ * @module loop/plugins/shell/editorChoice
+ */
+import { chooseView, nextView, seedViewChoice, setViewOptions, subscribeViewChoice } from '@datalayer/reactor-shell';
+/** The choice that means "just the conversation". */
+export declare const NONE_EDITOR = "none";
+/** The current request and options, in loop names. */
+export declare function getEditorChoice(): {
+    editorId: string;
+    options: readonly string[];
+};
+export declare const subscribeEditorChoice: typeof subscribeViewChoice;
+export declare const setEditorOptions: typeof setViewOptions;
+export declare const chooseEditor: typeof chooseView;
+export declare const seedEditorChoice: typeof seedViewChoice;
+export declare const nextEditor: typeof nextView;

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

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The editor choice, in the loop's vocabulary.
+ *
+ * The store itself lives in `@datalayer/reactor-shell` now — the loop's
+ * editor selector grew into the generic shell plugin, and this module is the
+ * thin dictionary between the two: `editor` here is `view` there. Kept so
+ * everything written against the loop's names (the `/editor` command, the
+ * tests, the barrel) reads unchanged.
+ *
+ * The one behavioural difference from the old local store is deliberate:
+ * `chooseEditor` no longer calls the chat's surface channel itself — the
+ * generic store announces every choice through the announcer the loop's
+ * shell plugin installs, which is wired to `requestSurface`. One path,
+ * whether the choice came from the selector, `/editor`, or the generic
+ * cycle command.
+ *
+ * @module loop/plugins/shell/editorChoice
+ */
+import { NONE_VIEW, chooseView, getViewChoice, nextView, seedViewChoice, setViewAnnouncer, setViewOptions, subscribeViewChoice, } from '@datalayer/reactor-shell';
+import { requestSurface } from '../../core/surfaceRequests';
+/*
+ * Wired at import, not only at plugin start: the `/editor` command is a
+ * plain contribution that can be run without a reactor around it — the tests
+ * do, and so does anything driving commands headlessly — and a choice that
+ * silently announced to nobody would look exactly like the bug the surface
+ * channel exists to prevent. The loop shell plugin installs the same
+ * announcer again when it registers, which is idempotent by construction.
+ */
+setViewAnnouncer(requestSurface);
+/** The choice that means "just the conversation". */
+export const NONE_EDITOR = NONE_VIEW;
+/*
+ * Cached per underlying state: `useSyncExternalStore` re-renders whenever
+ * the snapshot's identity changes, so a getter that builds a fresh object on
+ * every call is an infinite render loop waiting for its first subscriber —
+ * the view-switch icons found it. The store replaces its state object only
+ * on actual change, which makes it the perfect cache key.
+ */
+let mappedFor = null;
+let mapped = null;
+/** The current request and options, in loop names. */
+export function getEditorChoice() {
+    const state = getViewChoice();
+    if (state !== mappedFor || !mapped) {
+        mappedFor = state;
+        mapped = { editorId: state.viewId, options: state.options };
+    }
+    return mapped;
+}
+export const subscribeEditorChoice = subscribeViewChoice;
+export const setEditorOptions = setViewOptions;
+export const chooseEditor = chooseView;
+export const seedEditorChoice = seedViewChoice;
+export const nextEditor = nextView;

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

@@ -0,0 +1,47 @@
+/**
+ * `@datalayer/loop-plugin-shell` — the loop's face of the generic shell.
+ *
+ * The machinery lives in `@datalayer/reactor-shell` now: the view choice
+ * store, the segmented selector that shows nothing until plugins contribute,
+ * the cycle command. This plugin is what makes it *the loop's*:
+ *
+ * - it points the generic plugin at {@link LoopEditorView} — the editor
+ *   point the notebook and document fill — and declares the loop's points;
+ * - it teaches the selector to read a {@link ChatSurfaceContribution},
+ *   gating against the live workspace the header slot passes;
+ * - it wires the announcer to `requestSurface`, so a choice reaches the chat
+ *   through the same channel `/notebook` and `/document` use;
+ * - it keeps the `/editor` slash command, in the loop's own registry.
+ *
+ * @module loop/plugins/shell
+ */
+import type { JSX } from 'react';
+export declare const SHELL_PLUGIN_NAME = "@datalayer/loop-plugin-shell";
+export type ShellPluginConfig = {
+    /**
+     * The editor the selector starts on.
+     *
+     * A preference, not a demand, exactly like the chat's `defaultSurface` — a
+     * named editor whose plugin is not mounted leaves the selector on `'none'`.
+     * The two configs should agree; `loopPlugins` sets both from one option.
+     */
+    defaultEditor: string;
+    /**
+     * Whether the header carries the segmented control at all.
+     *
+     * The points are declared either way — extending the shell must not
+     * depend on whether its selector happens to be drawn.
+     */
+    showSelector: boolean;
+};
+/** The generic selector, dressed for the loop's header. */
+declare function EditorSelectorComponent(slotProps: Record<string, unknown>): JSX.Element | null;
+export declare const ShellPlugin: import("@datalayer/reactor").ReactorPlugin<ShellPluginConfig, unknown, unknown>;
+export { NONE_EDITOR, chooseEditor, getEditorChoice, nextEditor, seedEditorChoice, setEditorOptions, subscribeEditorChoice, } from './editorChoice';
+/** The loop's selector, for a host that renders it somewhere of its own. */
+export { EditorSelectorComponent as EditorSelector };
+/** @deprecated The editors plugin grew into the shell plugin; same object. */
+export declare const EditorsPlugin: import("@datalayer/reactor").ReactorPlugin<ShellPluginConfig, unknown, unknown>;
+/** @deprecated See {@link SHELL_PLUGIN_NAME}. */
+export declare const EDITORS_PLUGIN_NAME = "@datalayer/loop-plugin-shell";
+export default ShellPlugin;

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

@@ -0,0 +1,142 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { configurePlugin, contribution, definePlugin, } from '@datalayer/reactor';
+import { ShellPlugin as ReactorShellPlugin, ViewSelector, } from '@datalayer/reactor-shell';
+import { LoopCommand, LoopEditorView, LoopSlots, LoopViewType, canOpenView, requestSurface, } from '../../core';
+import { NONE_EDITOR, chooseEditor, getEditorChoice, nextEditor, seedEditorChoice, } from './editorChoice';
+import { useEditorPreviews } from './useEditorPreviews';
+export const SHELL_PLUGIN_NAME = '@datalayer/loop-plugin-shell';
+/** How a loop editor contribution reads as the generic selector's view. */
+function describeEditor(value, context) {
+    const surface = value;
+    const workspace = context
+        ?.workspace;
+    const openable = workspace ? canOpenView(surface, workspace) : true;
+    return {
+        id: surface.surfaceId,
+        title: surface.title,
+        icon: surface.icon,
+        order: surface.order,
+        disabled: !openable,
+        disabledReason: openable
+            ? undefined
+            : (workspace && surface.unavailableReason?.(workspace)) ||
+                'Not available right now',
+    };
+}
+/** The generic selector, dressed for the loop's header. */
+function EditorSelectorComponent(slotProps) {
+    const workspace = slotProps
+        .workspace;
+    /*
+     * Live figures for the labels — "Notebook (4)" — and the hover cards
+     * behind them. The editors are connected whether or not they are shown;
+     * the selector is where that stops being invisible.
+     */
+    const previews = useEditorPreviews(workspace?.surfaceId ?? '');
+    const describe = (value, context) => {
+        const base = describeEditor(value, context);
+        const preview = previews[base.id];
+        return preview
+            ? { ...base, badge: preview.badge, details: preview.details }
+            : base;
+    };
+    return (_jsx(ViewSelector, { point: LoopEditorView, describe: describe, context: slotProps, 
+        // "Chat", not "None": with no editor beside it the conversation IS the
+        // view, and a control that names the common case after what it lacks
+        // reads as an error state.
+        noneLabel: "Chat", ariaLabel: "Editor" }));
+}
+export const ShellPlugin = definePlugin({
+    name: SHELL_PLUGIN_NAME,
+    // Named apart from the reactor's own `Shell` plugin, which sits beside it
+    // in the plugins panel: this is the Loop workspace's.
+    displayName: 'Loop shell',
+    description: 'The Loop workspace’s extension points, and the editor choice.',
+    octicon: 'columns',
+    emoji: '\u{1F4D1}',
+    config: {
+        defaultEditor: NONE_EDITOR,
+        showSelector: true,
+    },
+    /*
+     * The generic shell, configured for the loop. The selector is rendered by
+     * *this* plugin (below) rather than the generic one, because which slot it
+     * sits in and whether it shows are loop configuration; the generic
+     * keybinding is stood down so the loop's `/editor` keeps `Mod+Alt+E`
+     * without two commands fighting over one chord.
+     */
+    dependencies: [
+        configurePlugin(ReactorShellPlugin, {
+            point: LoopEditorView,
+            describe: describeEditor,
+            showSelector: false,
+            announce: (viewId) => requestSurface(viewId),
+            commandId: 'loop.shell.cycleEditor',
+            // Named for what it cycles here: the palette said "Switch the view" and
+            // a person looking for the notebook did not recognise it.
+            commandName: 'Switch the editor',
+            commandDescription: 'Cycle through the editors beside the conversation, and none',
+            keybinding: '',
+        }),
+    ],
+    // Declared, not merely used: the registry knows who contributed to a
+    // point, it cannot know who opened it — and these two are what makes this
+    // the plugin the others extend.
+    contributionPoints: [LoopViewType, LoopEditorView],
+    contributes: [
+        contribution(LoopCommand, {
+            name: 'editor',
+            aliases: ['editors'],
+            description: 'Switch the editor beside the conversation',
+            group: 'Open',
+            keybinding: 'Mod+Alt+E',
+            args: [
+                {
+                    name: 'editor',
+                    description: 'Which editor: none, or a surface id. Omit to cycle.',
+                    required: false,
+                    choices: () => [NONE_EDITOR, ...getEditorChoice().options],
+                },
+            ],
+            run: async ({ argv }) => {
+                const asked = argv.trim();
+                const wanted = asked === '' ? nextEditor() : asked;
+                const known = [NONE_EDITOR, ...getEditorChoice().options];
+                if (!known.includes(wanted)) {
+                    throw new Error(`No editor called '${wanted}'. There is: ${known.join(', ')}.`);
+                }
+                if (!chooseEditor(wanted)) {
+                    throw new Error('No chat is on screen to host the editor.');
+                }
+            },
+        }, { id: 'editor' }),
+    ],
+    build: ({ config }) => {
+        // The selector starts where the chat starts. Seeded, not requested: the
+        // chat's own `defaultSurface` is what actually opens the editor, and at
+        // build time there is no chat listening yet. The chat writes "no editor"
+        // as `''` or `'none'`; the selector's word for it is `'none'`.
+        seedEditorChoice(config.defaultEditor || NONE_EDITOR);
+        return {
+            components: config.showSelector
+                ? [
+                    {
+                        id: 'editor-selector',
+                        slot: LoopSlots.header,
+                        // The component holds itself to the trailing edge of the header
+                        // row with `marginLeft: 'auto'`, wherever the slot renders it.
+                        Component: EditorSelectorComponent,
+                    },
+                ]
+                : [],
+        };
+    },
+});
+export { NONE_EDITOR, chooseEditor, getEditorChoice, nextEditor, seedEditorChoice, setEditorOptions, subscribeEditorChoice, } from './editorChoice';
+/** The loop's selector, for a host that renders it somewhere of its own. */
+export { EditorSelectorComponent as EditorSelector };
+/** @deprecated The editors plugin grew into the shell plugin; same object. */
+export const EditorsPlugin = ShellPlugin;
+/** @deprecated See {@link SHELL_PLUGIN_NAME}. */
+export const EDITORS_PLUGIN_NAME = SHELL_PLUGIN_NAME;
+export default ShellPlugin;

package/lib/loop/plugins/shell/useEditorPreviews.d.ts

@@ -0,0 +1,32 @@
+/**
+ * What the hidden editors hold, for the selector to show.
+ *
+ * The notebook and the document are mounted and connected whether or not
+ * they are on screen — the agent works in them from the `none` view. The
+ * selector is where that stops being invisible: each label carries a live
+ * count ("Notebook (4)"), and hovering opens a card listing the cells or
+ * blocks, one truncated source line each. A person watching the agent work
+ * sees the notebook filling up without ever leaving the conversation.
+ *
+ * The notebook is read synchronously from the live model and followed
+ * through its own signals; the document is read through the lexical store's
+ * async block reader, refreshed when the store reports change. The lexical
+ * module is imported lazily and only once the workspace actually offers a
+ * document — this file must not be the import that drags lexical into every
+ * bundle.
+ *
+ * @module loop/plugins/shell/useEditorPreviews
+ */
+import type { ReactNode } from 'react';
+export type EditorPreview = {
+    badge: string;
+    details: ReactNode;
+};
+/**
+ * Live previews for the editor selector, keyed by surface id.
+ *
+ * Only the editors actually on offer are read — the store subscriptions and
+ * the lexical import cost nothing in a workspace without them.
+ */
+export declare function useEditorPreviews(surfaceId: string): Record<string, EditorPreview | undefined>;
+export default useEditorPreviews;