@datalayer/agent-runtimes 1.0.28 → 1.3.10

package/lib/loop/plugins/a2ui/A2uiView.js

@@ -0,0 +1,97 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { Box, Text } from '@primer/react';
+import { basicCatalog, } from '@a2ui/react/v0_9';
+import { MessageProcessor, } from '@a2ui/web_core/v0_9';
+import { useSignalValue } from '@datalayer/reactor/react';
+import { A2uiSurfaceComposed } from '../../../components/a2ui';
+import { useSandboxService } from '../agents';
+/**
+ * A2UI's basic catalog draws from inherited `--a2ui-*` custom properties, so a
+ * surface follows the workspace's theme by inheriting rather than by being
+ * told — which is what keeps a generated surface from being the one light card
+ * in a dark workspace (§3.6).
+ */
+const INHERIT_THEME = {
+    ['--a2ui-color-surface']: 'var(--bgColor-muted)',
+    ['--a2ui-color-on-surface']: 'var(--fgColor-default)',
+    ['--a2ui-color-primary']: 'var(--fgColor-accent)',
+    ['--a2ui-color-outline']: 'var(--borderColor-default)',
+};
+export default function A2uiView({ workspace }) {
+    const service = useSandboxService();
+    const lastExecution = useSignalValue(service.lastExecution);
+    const [surfaces, setSurfaces] = useState([]);
+    const [error, setError] = useState(null);
+    // The code that produced what is on screen, so an action can re-run *it*
+    // rather than whatever the sandbox happened to execute last.
+    const sourceRef = useRef('');
+    const renderRef = useRef(null);
+    const processor = useMemo(() => new MessageProcessor([basicCatalog], action => {
+        // The round-trip: what the reader did goes back to the code that drew
+        // the surface, and the surface it returns replaces this one. Without
+        // this a surface is a screenshot with buttons on it.
+        void renderRef.current?.(sourceRef.current, action);
+    }), []);
+    useEffect(() => {
+        const created = processor.onSurfaceCreated(surface => setSurfaces(previous => [...previous, surface]));
+        const deleted = processor.onSurfaceDeleted(id => setSurfaces(previous => previous.filter(surface => surface.id !== id)));
+        return () => {
+            created.unsubscribe();
+            deleted.unsubscribe();
+        };
+    }, [processor]);
+    const render = useCallback(async (code, action) => {
+        setError(null);
+        sourceRef.current = code;
+        try {
+            const response = await fetch(`${workspace.serverUrl}/api/v1/sandbox/execute/a2ui`, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({ code, action: action ?? null }),
+            });
+            if (!response.ok) {
+                setError(`The server could not render that execution (${response.status}).`);
+                return;
+            }
+            const payload = await response.json();
+            // Replace rather than stack: a filtered view is the same surface with
+            // different data, not a second one below the first.
+            setSurfaces([]);
+            processor.processMessages((payload.messages ?? []));
+        }
+        catch (failure) {
+            setError(failure instanceof Error ? failure.message : String(failure));
+        }
+    }, [processor, workspace.serverUrl]);
+    // Published for the processor's action callback, which is built once and
+    // cannot close over a `render` that changes with the server URL.
+    useEffect(() => {
+        renderRef.current = render;
+    }, [render]);
+    // Re-render whenever the sandbox runs something new.
+    useEffect(() => {
+        if (lastExecution?.code) {
+            void render(lastExecution.code);
+        }
+    }, [lastExecution, render]);
+    if (error) {
+        return (_jsx(Centered, { children: _jsx(Text, { sx: { color: 'danger.fg' }, children: error }) }));
+    }
+    if (surfaces.length === 0) {
+        return (_jsx(Centered, { children: _jsx(Text, { children: "Nothing has run yet. Ask for something that executes code and the result appears here as a surface rather than as output." }) }));
+    }
+    return (_jsx(Box, { sx: { height: '100%', overflowY: 'auto', px: 4, py: 3 }, style: INHERIT_THEME, children: surfaces.map(surface => (_jsx(A2uiSurfaceComposed, { surface: surface }, surface.id))) }));
+}
+function Centered({ children }) {
+    return (_jsx(Box, { sx: {
+            height: '100%',
+            display: 'flex',
+            alignItems: 'center',
+            justifyContent: 'center',
+            color: 'fg.muted',
+            fontSize: 1,
+            px: 4,
+            textAlign: 'center',
+        }, children: children }));
+}

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

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

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

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * `@datalayer/loop-plugin-a2ui` — a prompt runs code, and the result is a UI.
+ *
+ * @module loop/plugins/a2ui
+ */
+import { BrowserIcon } from '@primer/octicons-react';
+import { contribution, definePlugin } from '@datalayer/reactor';
+import { LoopCommand, LoopViewType } from '../../core';
+import { AgentsPlugin } from '../agents';
+export const A2UI_PLUGIN_NAME = '@datalayer/loop-plugin-a2ui';
+export const A2uiPlugin = definePlugin({
+    name: A2UI_PLUGIN_NAME,
+    displayName: 'A2UI surfaces',
+    description: 'The last execution, rendered as a surface rather than dumped.',
+    octicon: 'browser',
+    emoji: '\u{1F5BC}',
+    dependencies: [AgentsPlugin],
+    contributes: [
+        contribution(LoopViewType, {
+            viewType: 'a2ui',
+            title: 'Surface',
+            icon: BrowserIcon,
+            order: 30,
+            canOpen: workspace => workspace.sandbox.state === 'running' &&
+                // The converter that turns an execution into a surface lives on the
+                // server (D20), so a browser sandbox has nothing to render with.
+                // Saying so is better than an empty panel.
+                workspace.sandbox.variant !== 'pyodide',
+            unavailableReason: workspace => workspace.sandbox.variant === 'pyodide'
+                ? 'Surfaces are rendered by the server; this sandbox runs in the browser'
+                : 'Needs a running sandbox',
+            load: () => import('./A2uiView'),
+        }, { id: 'a2ui', order: 30 }),
+        contribution(LoopCommand, {
+            name: 'a2ui',
+            aliases: ['surface'],
+            description: 'Show the last execution as a rendered surface',
+            group: 'Open',
+            keybinding: 'Mod+Alt+U',
+            run: async ({ workspace }) => {
+                workspace.setActiveViewType('a2ui');
+            },
+        }, { id: 'a2ui' }),
+    ],
+});
+export default A2uiPlugin;

package/lib/loop/plugins/a2ui-scene/index.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The mould the A2UI scene plugins are cast from.
+ *
+ * A scene — the contact card, the restaurant menu, the components gallery —
+ * is a canned set of A2UI protocol messages rendered as a surface, no agent
+ * behind it. The capacity, factored once here, is *showing such a scene as
+ * a workspace view*: the plugin contributes one `LoopViewType` entry whose
+ * component loads lazily, ordered ahead of the chat so the workspace opens
+ * on the scene with the conversation one tab away.
+ *
+ * The scene component itself stays with whoever owns the scene (the
+ * examples own theirs); this module owns only the casting.
+ *
+ * @module loop/plugins/a2ui-scene
+ */
+import type { ComponentType } from 'react';
+import { type ReactorPlugin } from '@datalayer/reactor';
+import { type LoopViewProps } from '../../core';
+export type A2uiSceneOptions = {
+    /** Short slug: `contact-card`, … names the plugin `…-a2ui-scene-<key>`. */
+    key: string;
+    title: string;
+    description: string;
+    /** Registry icon name. */
+    octicon?: string;
+    emoji?: string;
+    icon?: ComponentType<{
+        size?: number;
+    }>;
+    /** The scene view, loaded when first shown. */
+    load: () => Promise<{
+        default: ComponentType<LoopViewProps>;
+    }>;
+};
+export declare function defineA2uiScenePlugin(options: A2uiSceneOptions): ReactorPlugin<Record<string, never>, unknown, unknown>;
+export default defineA2uiScenePlugin;

package/lib/loop/plugins/a2ui-scene/index.js

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { contribution, definePlugin, } from '@datalayer/reactor';
+import { LoopViewType } from '../../core';
+export function defineA2uiScenePlugin(options) {
+    const { key, title, description, icon, load } = options;
+    return definePlugin({
+        name: `@datalayer/loop-plugin-a2ui-scene-${key}`,
+        displayName: title,
+        description,
+        octicon: options.octicon ?? 'browser',
+        emoji: options.emoji,
+        contributes: [
+            contribution(LoopViewType, {
+                viewType: `a2ui-scene-${key}`,
+                title,
+                icon,
+                // Ahead of the chat (order 0): the scene is what this workspace
+                // exists to show, and the conversation stands one tab away.
+                order: -10,
+                load,
+            }, { id: `a2ui-scene-${key}`, order: -10 }),
+        ],
+    });
+}
+export default defineA2uiScenePlugin;

package/lib/loop/plugins/agent-a2a/index.d.ts

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

package/lib/loop/plugins/agent-a2a/index.js

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * `@datalayer/loop-plugin-agent-a2a` — the capacity, as a plugin.
+ *
+ * Mounts the `example-a2a` agent: an orchestrator whose researcher and writer
+ * are separate agents reached over the A2A protocol, launched beside it on
+ * the local server or on Datalayer runtimes when it runs in the cloud. Cast
+ * from the shared capacity mould; see `loop/plugins/agent-capacity`. The
+ * openers are the spec's own: one list, kept where the agent is described.
+ *
+ * @module loop/plugins/agent-a2a
+ */
+import { defineAgentCapacityPlugin } from '../agent-capacity';
+export const AGENT_A2A_PLUGIN_NAME = '@datalayer/loop-plugin-agent-a2a';
+export const AgentA2APlugin = defineAgentCapacityPlugin({
+    key: 'a2a',
+    displayName: 'Agent A2A',
+    description: 'Delegation to separate agents over the A2A protocol',
+    specId: 'example-a2a',
+    octicon: 'broadcast',
+    emoji: '📡',
+});
+export default AgentA2APlugin;

package/lib/loop/plugins/agent-a2ui/index.d.ts

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

package/lib/loop/plugins/agent-a2ui/index.js

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * `@datalayer/loop-plugin-agent-a2ui` — generated surfaces, as a capacity.
+ *
+ * Mounts the `example-a2ui-agent` agent: ask for a form or a configurator
+ * and the answer arrives as an interactive A2UI surface, rendered in the
+ * workspace's a2ui view. Cast from the shared capacity mould.
+ *
+ * @module loop/plugins/agent-a2ui
+ */
+import { defineAgentCapacityPlugin } from '../agent-capacity';
+export const AGENT_A2UI_PLUGIN_NAME = '@datalayer/loop-plugin-agent-a2ui';
+export const AgentA2uiPlugin = defineAgentCapacityPlugin({
+    key: 'a2ui',
+    displayName: 'Agent A2UI',
+    description: 'Generate interactive A2UI surfaces from plain requests.',
+    specId: 'example-a2ui-agent',
+    octicon: 'browser',
+    emoji: '🪟',
+    suggestions: [
+        {
+            text: 'Support ticket intake',
+            message: 'Build a support ticket intake form with category, priority and a description.',
+        },
+        {
+            text: 'Trip booking',
+            message: 'Create a trip booking form with destination, dates, travelers and budget.',
+        },
+        {
+            text: 'Feedback survey',
+            message: 'Generate a customer feedback survey with a rating slider and comments.',
+        },
+        {
+            text: 'Product configurator',
+            message: 'Make a product configurator for a laptop with CPU, RAM and add-ons.',
+        },
+    ],
+});
+export default AgentA2uiPlugin;

package/lib/loop/plugins/agent-a2ui-jupyter-output/index.d.ts

@@ -0,0 +1,3 @@
+export declare const AGENT_A2UI_JUPYTER_OUTPUT_PLUGIN_NAME = "@datalayer/loop-plugin-agent-a2ui-jupyter-output";
+export declare const AgentA2uiJupyterOutputPlugin: import("@datalayer/reactor").ReactorPlugin<Record<string, never>, unknown, unknown>;
+export default AgentA2uiJupyterOutputPlugin;

package/lib/loop/plugins/agent-a2ui-jupyter-output/index.js

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * `@datalayer/loop-plugin-agent-a2ui-jupyter-output` — Jupyter outputs on
+ * A2UI surfaces, as a capacity.
+ *
+ * Mounts the `example-a2ui-jupyter-output` agent: each demonstration runs
+ * real code in the sandbox and lands its kernel outputs — streams, figures,
+ * tables, tracebacks, widgets — on the conversation. On the browser target
+ * the loop turns in the page and the blueprint is inert; on Local the same
+ * plugin creates the agent server-side.
+ *
+ * @module loop/plugins/agent-a2ui-jupyter-output
+ */
+import { defineAgentCapacityPlugin } from '../agent-capacity';
+export const AGENT_A2UI_JUPYTER_OUTPUT_PLUGIN_NAME = '@datalayer/loop-plugin-agent-a2ui-jupyter-output';
+export const AgentA2uiJupyterOutputPlugin = defineAgentCapacityPlugin({
+    key: 'a2ui-jupyter-output',
+    displayName: 'Agent A2UI Jupyter Output',
+    description: 'Kernel outputs — streams, figures, tables, errors, widgets — rendered as surfaces.',
+    specId: 'example-a2ui-jupyter-output',
+    octicon: 'log',
+    emoji: '📓',
+    suggestions: [
+        {
+            text: 'Stream output',
+            message: 'Run something in the code sandbox that prints as it goes.',
+        },
+        {
+            text: 'Figure output',
+            message: 'Plot a chart in the code sandbox and show me the image.',
+        },
+        {
+            text: 'Table output',
+            message: 'Build a small DataFrame in the code sandbox and show it as a table.',
+        },
+        {
+            text: 'Error output',
+            message: 'Run something in the code sandbox that fails, so I can see the traceback.',
+        },
+        {
+            text: 'IPyWidgets output',
+            message: 'Show me an interactive slider from the code sandbox.',
+        },
+        {
+            text: 'Interactive output',
+            message: 'Give me a surface with buttons I can press.',
+        },
+    ],
+});
+export default AgentA2uiJupyterOutputPlugin;

package/lib/loop/plugins/agent-capacity/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The mould the agent-capacity plugins are cast from.
+ *
+ * A capacity — codemode, hooks, guardrails, memory — is, from the
+ * workspace's side, always the same two statements: *which agent* answers
+ * (an agentspec id and the create-payload details its server needs) and
+ * *what it is worth asking* (the openers on the empty chat). This factory
+ * turns those statements into a reactor plugin: an `LoopAgentBlueprint`
+ * contribution the agents plugin reads when its Local target creates the
+ * agent, and an optional `LoopChatSuggestion` contribution the chat shows
+ * ahead of the spec's own.
+ *
+ * One folder per capacity under `loop/plugins/agent-*`, each a few lines of
+ * facts handed to this mould — the way every example used to carry the same
+ * facts as props into its own private `<Chat>`.
+ *
+ * @module loop/plugins/agent-capacity
+ */
+import { type ReactorPlugin } from '@datalayer/reactor';
+import { type ChatSuggestionItem } from '../../core';
+export type AgentCapacityOptions = {
+    /** Short slug: `hooks`, `codemode`, … names the plugin `…-agent-<key>`. */
+    key: string;
+    displayName: string;
+    description: string;
+    /** The agentspec the Local agent is created from. */
+    specId: string;
+    /** Registry icon; a sensible default is used when absent. */
+    octicon?: string;
+    emoji?: string;
+    /** Whether the agent runs its tools through codemode. */
+    codemode?: boolean;
+    /** Extra fields merged into the server's create-agent payload. */
+    createPayload?: Record<string, unknown>;
+    /** The openers the empty chat offers for this capacity. */
+    suggestions?: ChatSuggestionItem[];
+};
+export declare function defineAgentCapacityPlugin(options: AgentCapacityOptions): ReactorPlugin<Record<string, never>, unknown, unknown>;
+export default defineAgentCapacityPlugin;

package/lib/loop/plugins/agent-capacity/index.js

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The mould the agent-capacity plugins are cast from.
+ *
+ * A capacity — codemode, hooks, guardrails, memory — is, from the
+ * workspace's side, always the same two statements: *which agent* answers
+ * (an agentspec id and the create-payload details its server needs) and
+ * *what it is worth asking* (the openers on the empty chat). This factory
+ * turns those statements into a reactor plugin: an `LoopAgentBlueprint`
+ * contribution the agents plugin reads when its Local target creates the
+ * agent, and an optional `LoopChatSuggestion` contribution the chat shows
+ * ahead of the spec's own.
+ *
+ * One folder per capacity under `loop/plugins/agent-*`, each a few lines of
+ * facts handed to this mould — the way every example used to carry the same
+ * facts as props into its own private `<Chat>`.
+ *
+ * @module loop/plugins/agent-capacity
+ */
+import { contribution, definePlugin, } from '@datalayer/reactor';
+import { LoopAgentBlueprint, LoopChatSuggestion, } from '../../core';
+export function defineAgentCapacityPlugin(options) {
+    const { key, displayName, description, specId, octicon, emoji, codemode, createPayload, suggestions, } = options;
+    return definePlugin({
+        name: `@datalayer/loop-plugin-agent-${key}`,
+        displayName,
+        description,
+        octicon: octicon ?? 'dependabot',
+        emoji,
+        contributes: [
+            contribution(LoopAgentBlueprint, {
+                id: key,
+                specId,
+                createPayload: {
+                    description,
+                    agent_library: 'pydantic-ai',
+                    enable_codemode: codemode ?? false,
+                    ...createPayload,
+                },
+            }, { id: key }),
+            ...(suggestions && suggestions.length > 0
+                ? [
+                    contribution(LoopChatSuggestion, { id: key, suggestions }, { id: key }),
+                ]
+                : []),
+        ],
+    });
+}
+export default defineAgentCapacityPlugin;

package/lib/loop/plugins/agent-checkpoints/index.d.ts

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

package/lib/loop/plugins/agent-checkpoints/index.js

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * `@datalayer/loop-plugin-agent-checkpoints` — checkpointing, as a capacity.
+ *
+ * Mounts the `example-checkpoints` agent: its conversation is snapshotted
+ * after every turn, and it can save, list and rewind to checkpoints on
+ * request. Cast from the shared capacity mould; the openers are the spec's
+ * own. Pair it with the checkpoints sidebar to see and use the checkpoints
+ * from outside the chat.
+ *
+ * @module loop/plugins/agent-checkpoints
+ */
+import { defineAgentCapacityPlugin } from '../agent-capacity';
+export const AGENT_CHECKPOINTS_PLUGIN_NAME = '@datalayer/loop-plugin-agent-checkpoints';
+export const AgentCheckpointsPlugin = defineAgentCapacityPlugin({
+    key: 'checkpoints',
+    displayName: 'Agent Checkpoints',
+    description: 'Conversation checkpoints: taken every turn, saved on request, rewound to.',
+    specId: 'example-checkpoints',
+    octicon: 'versions',
+    emoji: '💾',
+});
+export default AgentCheckpointsPlugin;

package/lib/loop/plugins/agent-code-sandbox/index.d.ts

@@ -0,0 +1,3 @@
+export declare const AGENT_CODE_SANDBOX_PLUGIN_NAME = "@datalayer/loop-plugin-agent-code-sandbox";
+export declare const AgentCodeSandboxPlugin: import("@datalayer/reactor").ReactorPlugin<Record<string, never>, unknown, unknown>;
+export default AgentCodeSandboxPlugin;

package/lib/loop/plugins/agent-code-sandbox/index.js

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * `@datalayer/loop-plugin-agent-code-sandbox` — the code sandbox, as a capacity.
+ *
+ * Mounts the `example-code-sandbox` agent: Python run through `execute_code`
+ * in a sandbox the server manages, whose variant can be switched live. Cast
+ * from the shared capacity mould; the openers are the spec's own.
+ *
+ * @module loop/plugins/agent-code-sandbox
+ */
+import { defineAgentCapacityPlugin } from '../agent-capacity';
+export const AGENT_CODE_SANDBOX_PLUGIN_NAME = '@datalayer/loop-plugin-agent-code-sandbox';
+export const AgentCodeSandboxPlugin = defineAgentCapacityPlugin({
+    key: 'code-sandbox',
+    displayName: 'Agent Code Sandbox',
+    description: 'Python run in a server-managed sandbox: eval or a Jupyter kernel.',
+    specId: 'example-code-sandbox',
+    octicon: 'codespaces',
+    emoji: '📦',
+});
+export default AgentCodeSandboxPlugin;

package/lib/loop/plugins/agent-code-sandboxes/index.d.ts

@@ -0,0 +1,13 @@
+type SandboxCapacity = {
+    key: string;
+    variant: string;
+    specId: string;
+    displayName: string;
+    description: string;
+};
+export declare const SANDBOX_CAPACITIES: SandboxCapacity[];
+/** The plugins, keyed by capacity key — one per sandbox variant. */
+export declare const SandboxCapacityPlugins: {
+    [k: string]: import("@datalayer/reactor").ReactorPlugin<Record<string, never>, unknown, unknown>;
+};
+export default SandboxCapacityPlugins;

package/lib/loop/plugins/agent-code-sandboxes/index.js

@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * `@datalayer/loop-plugin-agent-sandbox-*` — where the code runs, as
+ * capacities.
+ *
+ * One plugin per sandbox variant, each cast from the shared capacity mould:
+ * the blueprint names the variant's agentspec *and* pins `sandbox_variant`
+ * in the create payload, which the Local target respects. The code-sandboxes
+ * example offers the whole family behind a chooser; a host that wants
+ * exactly one mounts exactly one.
+ *
+ * The openers are each spec's own: the same three on every variant, the
+ * first of which asks the code where it ran.
+ *
+ * @module loop/plugins/agent-code-sandboxes
+ */
+import { defineAgentCapacityPlugin } from '../agent-capacity';
+export const SANDBOX_CAPACITIES = [
+    {
+        key: 'sandbox-eval',
+        variant: 'eval',
+        specId: 'example-sandbox-eval',
+        displayName: 'Eval Sandbox',
+        description: 'In-process Python execution for quick local iteration.',
+    },
+    {
+        key: 'sandbox-jupyter',
+        variant: 'jupyter-server',
+        specId: 'example-sandbox-jupyter',
+        displayName: 'Jupyter Sandbox',
+        description: 'Kernel-backed execution with notebook-compatible behavior.',
+    },
+    {
+        key: 'sandbox-docker',
+        variant: 'docker',
+        specId: 'example-sandbox-docker',
+        displayName: 'Docker Sandbox',
+        description: 'Containerized execution for stronger process isolation.',
+    },
+    {
+        key: 'sandbox-datalayer',
+        variant: 'datalayer',
+        specId: 'example-sandbox-datalayer',
+        displayName: 'Datalayer Sandbox',
+        description: 'Cloud sandbox runtime powered by Datalayer environments.',
+    },
+    {
+        key: 'sandbox-colab',
+        variant: 'google-colab',
+        specId: 'example-sandbox-colab',
+        displayName: 'Colab Sandbox',
+        description: 'Google Colab runtime connector (reuse an already-running kernel).',
+    },
+    {
+        key: 'sandbox-kaggle',
+        variant: 'kaggle',
+        specId: 'example-sandbox-kaggle',
+        displayName: 'Kaggle Sandbox',
+        description: 'Kaggle runtime connector (create kernel with API token or attach existing).',
+    },
+    {
+        key: 'sandbox-monty',
+        variant: 'monty',
+        specId: 'example-sandbox-monty',
+        displayName: 'Monty Sandbox',
+        description: 'Secure in-process interpreter focused on safe snippets.',
+    },
+];
+/** The plugins, keyed by capacity key — one per sandbox variant. */
+export const SandboxCapacityPlugins = Object.fromEntries(SANDBOX_CAPACITIES.map(capacity => [
+    capacity.key,
+    defineAgentCapacityPlugin({
+        key: capacity.key,
+        displayName: capacity.displayName,
+        description: capacity.description,
+        specId: capacity.specId,
+        octicon: 'codespaces',
+        emoji: '📦',
+        createPayload: { sandbox_variant: capacity.variant },
+    }),
+]));
+export default SandboxCapacityPlugins;

package/lib/loop/plugins/agent-codemode/index.d.ts

@@ -0,0 +1,5 @@
+export declare const AGENT_CODEMODE_PLUGIN_NAME = "@datalayer/loop-plugin-agent-codemode";
+export declare const AGENT_NO_CODEMODE_PLUGIN_NAME = "@datalayer/loop-plugin-agent-no-codemode";
+export declare const AgentCodemodePlugin: import("@datalayer/reactor").ReactorPlugin<Record<string, never>, unknown, unknown>;
+export declare const AgentNoCodemodePlugin: import("@datalayer/reactor").ReactorPlugin<Record<string, never>, unknown, unknown>;
+export default AgentCodemodePlugin;

package/lib/loop/plugins/agent-codemode/index.js

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * `@datalayer/loop-plugin-agent-codemode` — codemode, as a capacity.
+ *
+ * Two plugins from one mould, because codemode is best understood as a
+ * comparison: {@link AgentCodemodePlugin} mounts the `example-codemode`
+ * agent, whose MCP tools are converted into programmatic tools the model
+ * composes in code; {@link AgentNoCodemodePlugin} mounts
+ * `example-no-codemode`, the same tools raw. The codemode example mounts
+ * both side by side and hands each pane the same task.
+ *
+ * The openers are the specs' own — the same first task on both sides, so
+ * the example's two panes compare like with like.
+ *
+ * @module loop/plugins/agent-codemode
+ */
+import { defineAgentCapacityPlugin } from '../agent-capacity';
+export const AGENT_CODEMODE_PLUGIN_NAME = '@datalayer/loop-plugin-agent-codemode';
+export const AGENT_NO_CODEMODE_PLUGIN_NAME = '@datalayer/loop-plugin-agent-no-codemode';
+export const AgentCodemodePlugin = defineAgentCapacityPlugin({
+    key: 'codemode',
+    displayName: 'Agent Codemode',
+    description: 'MCP tools converted into programmatic tools.',
+    specId: 'example-codemode',
+    octicon: 'code-square',
+    emoji: '🧑‍💻',
+    codemode: true,
+});
+export const AgentNoCodemodePlugin = defineAgentCapacityPlugin({
+    key: 'no-codemode',
+    displayName: 'Agent MCP Tools (No Codemode)',
+    description: 'Raw MCP tools without codemode conversion.',
+    specId: 'example-no-codemode',
+    octicon: 'tools',
+    emoji: '🔧',
+    codemode: false,
+});
+export default AgentCodemodePlugin;