@datalayer/agent-runtimes 1.0.28 → 1.3.10

package/lib/loop/shell/useWorkspaceFullScreen.js

@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { useCallback, useEffect, useRef, useState } from 'react';
+/**
+ * A top offset as pixels: a number as given, or the bottom edge of the
+ * element a CSS selector names — a host's fixed header, whose height depends
+ * on the width it wraps at and is never a number worth hard-coding. A
+ * selector that matches nothing, or no document, is 0.
+ */
+export function resolveTopOffset(offset) {
+    if (typeof offset === 'number') {
+        return offset;
+    }
+    if (!offset || typeof document === 'undefined') {
+        return 0;
+    }
+    const element = document.querySelector(offset);
+    return element
+        ? Math.max(0, Math.round(element.getBoundingClientRect().bottom))
+        : 0;
+}
+/**
+ * Full-screen state and the toggle, anchored by any element inside the
+ * workspace.
+ *
+ * The element promoted is the whole workspace — the nearest
+ * `[data-loop-workspace]` above the anchor — so the header's controls come
+ * along instead of being left on the page underneath. With no workspace
+ * around it, the anchor's own element is promoted, which is what a view
+ * mounted without a shell would want.
+ */
+export function useWorkspaceFullScreen(anchorRef, options = {}) {
+    const { forceOverlay = false, paintOverlay = false, topOffset = 0 } = options;
+    const [fullScreen, setFullScreen] = useState(false);
+    /* Which of the two doors is in play, so leaving uses the one it came in
+       by. */
+    const usingApi = useRef(false);
+    useEffect(() => {
+        /* The browser can leave without asking us — Escape does exactly that — so
+           the flag follows the document rather than the click. */
+        const sync = () => {
+            if (!usingApi.current) {
+                return;
+            }
+            // Whatever was promoted — the workspace, or the anchor's element where
+            // there is no workspace around it — as long as it still contains us.
+            const active = !!document.fullscreenElement &&
+                !!anchorRef.current &&
+                document.fullscreenElement.contains(anchorRef.current);
+            setFullScreen(active);
+            if (!active) {
+                usingApi.current = false;
+            }
+        };
+        document.addEventListener('fullscreenchange', sync);
+        return () => document.removeEventListener('fullscreenchange', sync);
+    }, [anchorRef]);
+    const toggle = useCallback(() => {
+        /*
+         * The whole workspace, not the view the control happens to be in.
+         *
+         * Promoting a single view would leave the workspace's header on the page
+         * underneath — the agent picker and the control saying where the code
+         * runs — so at full screen a reader would lose the two controls most
+         * worth having room for.
+         */
+        const node = anchorRef.current?.closest('[data-loop-workspace]') ?? anchorRef.current;
+        if (fullScreen) {
+            if (usingApi.current && document.fullscreenElement) {
+                void document.exitFullscreen();
+            }
+            else {
+                setFullScreen(false);
+            }
+            return;
+        }
+        if (forceOverlay || paintOverlay || !node?.requestFullscreen) {
+            setFullScreen(true);
+            return;
+        }
+        usingApi.current = true;
+        node.requestFullscreen().then(() => setFullScreen(true), () => {
+            // Refused. Cover what can be covered instead.
+            usingApi.current = false;
+            setFullScreen(true);
+        });
+    }, [anchorRef, fullScreen, forceOverlay, paintOverlay]);
+    /*
+     * The offset, measured while the overlay is up: on entry, and again when
+     * the window resizes and the header may wrap to a different height.
+     */
+    const [topOffsetPx, setTopOffsetPx] = useState(0);
+    useEffect(() => {
+        if (!fullScreen || usingApi.current) {
+            setTopOffsetPx(0);
+            return undefined;
+        }
+        const measure = () => setTopOffsetPx(resolveTopOffset(topOffset));
+        measure();
+        window.addEventListener('resize', measure);
+        return () => window.removeEventListener('resize', measure);
+    }, [fullScreen, topOffset]);
+    /*
+     * The overlay itself, for a caller that asked the hook to paint one.
+     *
+     * Direct inline styles rather than a class: this hook has no stylesheet of
+     * its own to add one to, and the node being styled is found by DOM query
+     * in the first place — see `toggle` above, which the same lookup is
+     * copied from rather than shared, since memoising it would need `anchorRef`
+     * itself to change identity to notice a different anchor mounting, which
+     * it never does.
+     */
+    useEffect(() => {
+        if (!paintOverlay || !fullScreen || usingApi.current) {
+            return undefined;
+        }
+        const node = anchorRef.current?.closest('[data-loop-workspace]') ?? anchorRef.current;
+        if (!node) {
+            return undefined;
+        }
+        const previous = node.getAttribute('style');
+        node.style.position = 'fixed';
+        node.style.top = `${topOffsetPx}px`;
+        node.style.right = '0';
+        node.style.bottom = '0';
+        node.style.left = '0';
+        // The workspace root sizes itself `height: 100%`; left in place, that
+        // height wins over `top`/`bottom` and the overlay runs `topOffset` pixels
+        // past the bottom of the window.
+        node.style.height = 'auto';
+        node.style.zIndex = '1000';
+        return () => {
+            if (previous === null) {
+                node.removeAttribute('style');
+            }
+            else {
+                node.setAttribute('style', previous);
+            }
+        };
+    }, [paintOverlay, fullScreen, anchorRef, topOffsetPx]);
+    /*
+     * Escape leaves the fallback overlay, as it does from anything covering the
+     * window. Not bound for the real thing: the browser handles Escape itself
+     * there, and a second listener would only race it.
+     *
+     * `defaultPrevented` is the guard that matters: a menu open inside the
+     * workspace closes on Escape too, and says so by consuming the event.
+     * Without the check, dismissing a menu would drop the reader out of full
+     * screen as well.
+     */
+    useEffect(() => {
+        if (!fullScreen || usingApi.current) {
+            return undefined;
+        }
+        const leave = (event) => {
+            if (event.key === 'Escape' && !event.defaultPrevented) {
+                setFullScreen(false);
+            }
+        };
+        window.addEventListener('keydown', leave);
+        return () => window.removeEventListener('keydown', leave);
+    }, [fullScreen]);
+    return { fullScreen, usingApi, toggle, topOffsetPx };
+}
+export default useWorkspaceFullScreen;

package/lib/loop-example-main.d.ts

@@ -0,0 +1 @@
+import '../style/primer-primitives.css';

package/lib/loop-example-main.js

@@ -0,0 +1,42 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Entry point for the workspace example.
+ *
+ * Owns the providers, as every entry point does — the workspace mounts none of
+ * its own (§3.5).
+ *
+ * @module loop-example-main
+ */
+// `@jupyter-widgets` assigns to a bare `__webpack_public_path__` at module
+// scope, which Vite's `define` cannot rewrite because it rewrites reads and not
+// assignment targets. Declaring it before anything else runs is what keeps a
+// lazily-loaded chunk from throwing a ReferenceError.
+const globals = globalThis;
+if (globals['__webpack_public_path__'] === undefined) {
+    globals['__webpack_public_path__'] = '';
+}
+import { StrictMode, useEffect } from 'react';
+import { createRoot } from 'react-dom/client';
+import { QueryClientProvider } from '@tanstack/react-query';
+import { DatalayerThemeProvider, setupPrimerPortals, themeConfigs, useSystemColorMode, useThemeStore, } from '@datalayer/primer-addons';
+import { LoopWorkspaceExample } from './examples/LoopWorkspaceExample';
+import { internalQueryClient } from './utils';
+import '../style/primer-primitives.css';
+function Page() {
+    const { colorMode, theme } = useThemeStore();
+    const systemColorMode = useSystemColorMode();
+    const resolvedMode = colorMode === 'auto' ? systemColorMode : colorMode;
+    const themeConfig = themeConfigs[theme];
+    useEffect(() => {
+        setupPrimerPortals();
+    }, []);
+    return (_jsx(DatalayerThemeProvider, { colorMode: resolvedMode, theme: themeConfig.primerTheme, themeStyles: themeConfig.themeStyles, children: _jsx(QueryClientProvider, { client: internalQueryClient, children: _jsx(LoopWorkspaceExample, {}) }) }));
+}
+const container = document.getElementById('root');
+if (container) {
+    createRoot(container).render(_jsx(StrictMode, { children: _jsx(Page, {}) }));
+}

package/lib/loop-main.d.ts

@@ -0,0 +1 @@
+import '../style/primer-primitives.css';

package/lib/loop-main.js

@@ -0,0 +1,138 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The standalone LOOP workspace page.
+ *
+ * This is the entry point, and it owns the providers — theme, query client —
+ * because the workspace itself mounts none. The same component runs unchanged
+ * inside the Datalayer app and, later, inside a JupyterLab panel, each bringing
+ * providers of its own.
+ *
+ * @module loop-main
+ */
+// `@jupyter-widgets` assigns to a bare `__webpack_public_path__` at module
+// scope — a webpack-ism that survives into the bundle, because Vite's `define`
+// rewrites reads of an identifier and not assignments to one. In an ES module
+// that assignment is a ReferenceError unless the binding exists as a global.
+//
+// The other entry points get away with it by accident of chunking: the module
+// that declares the name happens to land in the same chunk. This entry loads
+// its views lazily, so it does not, and the chat view failed to load with
+// `__webpack_public_path__ is not defined`. Declaring it here, before anything
+// else runs, does not depend on that luck. Written through `globalThis` with a
+// string key so `define` leaves it alone.
+const globals = globalThis;
+if (globals['__webpack_public_path__'] === undefined) {
+    globals['__webpack_public_path__'] = '';
+}
+import { StrictMode, useEffect, useState } from 'react';
+import { createRoot } from 'react-dom/client';
+import { QueryClientProvider } from '@tanstack/react-query';
+import { Box } from '@primer/react';
+import { DatalayerThemeProvider, setupPrimerPortals, themeConfigs, useSystemColorMode, useThemeStore, } from '@datalayer/primer-addons';
+import { configurePlugin } from '@datalayer/reactor';
+import { LoopWorkspace } from './loop/shell/LoopWorkspace';
+import { ChatPlugin } from './loop/plugins/chat';
+import { A2uiPlugin } from './loop/plugins/a2ui';
+import { AgentspecsPlugin } from './loop/plugins/agentspecs';
+import { AgentsPlugin } from './loop/plugins/agents';
+import { ModelsPlugin } from './loop/plugins/models';
+import { DocumentPlugin } from './loop/plugins/document';
+import { NotebookPlugin } from './loop/plugins/notebook';
+import { internalQueryClient } from './utils';
+// `src/index.css` is the Vite starter template's stylesheet: it sets
+// `body { display: flex; place-items: center }`, which shrink-wraps #root to
+// its content — the workspace filled 407px of a 1280px window. The agent page
+// uses the primitives stylesheet instead; so does this one.
+import '../style/primer-primitives.css';
+/**
+ * Redeem a handoff code for the session the terminal was holding.
+ *
+ * The code is single-use and short-lived, so it is exchanged once on load and
+ * then removed from the address bar — a URL that still carries it would be
+ * pasted, bookmarked, and screenshotted.
+ */
+async function resolveSession(serverUrl) {
+    const params = new URLSearchParams(window.location.search);
+    const handoff = params.get('handoff');
+    const view = params.get('view') ?? undefined;
+    const fallback = {
+        serverUrl,
+        agentId: params.get('agentId') ?? '',
+        view,
+        sandbox: { state: 'idle' },
+    };
+    if (!handoff) {
+        return fallback;
+    }
+    try {
+        const response = await fetch(`${serverUrl}/api/v1/loop/handoff/exchange?code=${encodeURIComponent(handoff)}`, { method: 'POST' });
+        if (!response.ok) {
+            return fallback;
+        }
+        const session = await response.json();
+        params.delete('handoff');
+        const query = params.toString();
+        window.history.replaceState({}, '', `${window.location.pathname}${query ? `?${query}` : ''}`);
+        return {
+            serverUrl,
+            agentId: session.agent_id ?? fallback.agentId,
+            conversationId: session.conversation_id ?? undefined,
+            model: session.model ?? undefined,
+            view: session.view ?? view,
+            sandbox: {
+                state: session.sandbox?.sandbox_running ? 'running' : 'idle',
+                variant: session.sandbox?.variant,
+                kernelId: session.sandbox?.kernel_id,
+                jupyterUrl: session.sandbox?.jupyter_url,
+            },
+        };
+    }
+    catch {
+        // A handoff that cannot be redeemed is not a reason to show nothing: the
+        // page still opens, just without the terminal's conversation.
+        return fallback;
+    }
+}
+function LoopPage() {
+    const [session, setSession] = useState(null);
+    const { colorMode, theme } = useThemeStore();
+    const systemColorMode = useSystemColorMode();
+    const resolvedMode = colorMode === 'auto' ? systemColorMode : colorMode;
+    const themeConfig = themeConfigs[theme];
+    useEffect(() => {
+        // Overlays — the view switcher's tooltips, dialogs, the mention typeahead —
+        // render outside this subtree, so the portal root has to exist and be
+        // themed before anything opens one.
+        setupPrimerPortals();
+    }, []);
+    useEffect(() => {
+        const serverUrl = window.location.origin;
+        void resolveSession(serverUrl).then(setSession);
+    }, []);
+    return (_jsx(DatalayerThemeProvider, { colorMode: resolvedMode, theme: themeConfig.primerTheme, themeStyles: themeConfig.themeStyles, children: _jsx(QueryClientProvider, { client: internalQueryClient, children: _jsx(Box, { sx: { height: '100vh', overflow: 'hidden' }, children: session ? (_jsx(LoopWorkspace, { serverUrl: session.serverUrl, agentId: session.agentId, conversationId: session.conversationId, model: session.model, sandbox: session.sandbox, initialViewType: session.view, 
+                    // The notebook and document plugins depend on the sandbox, so
+                    // the reactor pulls it in; it is named here only to be told which
+                    // server it talks to.
+                    extensions: [
+                        ChatPlugin,
+                        configurePlugin(AgentsPlugin, {
+                            serverUrl: session.serverUrl,
+                            // A session handed over from the terminal is server-backed;
+                            // the header control can move it from there.
+                            target: 'local',
+                        }),
+                        NotebookPlugin,
+                        DocumentPlugin,
+                        A2uiPlugin,
+                        AgentspecsPlugin,
+                        ModelsPlugin,
+                    ] })) : null }) }) }));
+}
+const container = document.getElementById('root');
+if (container) {
+    createRoot(container).render(_jsx(StrictMode, { children: _jsx(LoopPage, {}) }));
+}

package/lib/mcp/McpServerManager.d.ts

@@ -25,5 +25,5 @@ export interface McpServerManagerProps {
  * - View MCP Config servers from mcp.json (read-only, auto-started)
  * - Trigger codemode tool regeneration on changes
  */
-export declare function McpServerManager({ baseUrl, agentId, enableCodemode, selectedServers, onSelectedServersChange, onServersChange, disabled, }: McpServerManagerProps): import("react/jsx-runtime").JSX.Element;
+export declare function McpServerManager({ baseUrl, agentId, enableCodemode, selectedServers, onSelectedServersChange, onServersChange, disabled, }: McpServerManagerProps): import("react").JSX.Element;
 export default McpServerManager;

package/lib/models/CodeSandboxSnapshotDTO.d.ts

@@ -60,7 +60,7 @@ export interface CodeSandboxSnapshotJSON {
  */
 export interface CreateCodeSandboxSnapshotRequest {
     /** Pod name of the runtime to snapshot */
-    pod_name: string;
+    runtime_name: string;
     /** Name for the snapshot */
     name: string;
     /** Description of the snapshot */

package/lib/models/CodeSandboxVariant.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The kinds of code sandbox, as the Python `code_sandboxes` package names them.
+ *
+ * A sandbox is a place code runs, and the VARIANT names the kind of place:
+ * the Datalayer platform, a Jupyter Server, Kaggle, Modal, and so on. The
+ * values mirror `code_sandboxes.models.SandboxVariant` verbatim — one naming
+ * for the CLI, the services and the applications, so an environment tagged
+ * `kaggle` by the operator reads as `kaggle` here and nowhere becomes a
+ * synonym.
+ *
+ * @module models/CodeSandboxVariant
+ */
+/** The kinds of code sandbox, by the value the platform tags them with. */
+export declare enum CodeSandboxVariant {
+    /** In-process evaluation: tests and examples, isolates nothing. */
+    Eval = "eval",
+    /** A container on the Docker daemon of a machine. */
+    Docker = "docker",
+    /** A kernel of a Jupyter Server. */
+    JupyterServer = "jupyter-server",
+    /** A runtime of the Datalayer platform. */
+    Datalayer = "datalayer",
+    /** A Google Colab runtime. */
+    GoogleColab = "google-colab",
+    /** A Kaggle notebook session. */
+    Kaggle = "kaggle",
+    /** The Monty in-browser interpreter. */
+    Monty = "monty",
+    /** A container on Modal. */
+    Modal = "modal",
+    /** A sandbox on Daytona, with an optional GPU. */
+    Daytona = "daytona",
+    /** A container on Cloudflare's edge, behind a bridge Worker. */
+    Cloudflare = "cloudflare",
+    /** A container on CoreWeave, with an optional GPU. */
+    CoreWeave = "coreweave",
+    /** A Firecracker microVM on E2B. */
+    E2B = "e2b"
+}
+/** What each variant is called where a person reads it. */
+export declare const CODE_SANDBOX_VARIANT_TITLES: Record<CodeSandboxVariant, string>;
+/**
+ * The variant an environment belongs to, read off its `owner` tag.
+ *
+ * The operator tags an external environment with its provider through the
+ * environment's `owner` — `kaggle`, `modal`, `e2b` — while the platform's own
+ * carry `datalayer`. An owner nothing here recognises reads as Datalayer,
+ * which is what every environment was before providers existed.
+ */
+export declare function codeSandboxVariantOf(owner?: string | null): CodeSandboxVariant;
+/** A short label for the chip beside an environment's name. */
+export declare function codeSandboxVariantTitle(variant: CodeSandboxVariant): string;
+export default CodeSandboxVariant;

package/lib/models/CodeSandboxVariant.js

@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The kinds of code sandbox, as the Python `code_sandboxes` package names them.
+ *
+ * A sandbox is a place code runs, and the VARIANT names the kind of place:
+ * the Datalayer platform, a Jupyter Server, Kaggle, Modal, and so on. The
+ * values mirror `code_sandboxes.models.SandboxVariant` verbatim — one naming
+ * for the CLI, the services and the applications, so an environment tagged
+ * `kaggle` by the operator reads as `kaggle` here and nowhere becomes a
+ * synonym.
+ *
+ * @module models/CodeSandboxVariant
+ */
+/** The kinds of code sandbox, by the value the platform tags them with. */
+export var CodeSandboxVariant;
+(function (CodeSandboxVariant) {
+    /** In-process evaluation: tests and examples, isolates nothing. */
+    CodeSandboxVariant["Eval"] = "eval";
+    /** A container on the Docker daemon of a machine. */
+    CodeSandboxVariant["Docker"] = "docker";
+    /** A kernel of a Jupyter Server. */
+    CodeSandboxVariant["JupyterServer"] = "jupyter-server";
+    /** A runtime of the Datalayer platform. */
+    CodeSandboxVariant["Datalayer"] = "datalayer";
+    /** A Google Colab runtime. */
+    CodeSandboxVariant["GoogleColab"] = "google-colab";
+    /** A Kaggle notebook session. */
+    CodeSandboxVariant["Kaggle"] = "kaggle";
+    /** The Monty in-browser interpreter. */
+    CodeSandboxVariant["Monty"] = "monty";
+    /** A container on Modal. */
+    CodeSandboxVariant["Modal"] = "modal";
+    /** A sandbox on Daytona, with an optional GPU. */
+    CodeSandboxVariant["Daytona"] = "daytona";
+    /** A container on Cloudflare's edge, behind a bridge Worker. */
+    CodeSandboxVariant["Cloudflare"] = "cloudflare";
+    /** A container on CoreWeave, with an optional GPU. */
+    CodeSandboxVariant["CoreWeave"] = "coreweave";
+    /** A Firecracker microVM on E2B. */
+    CodeSandboxVariant["E2B"] = "e2b";
+})(CodeSandboxVariant || (CodeSandboxVariant = {}));
+/** What each variant is called where a person reads it. */
+export const CODE_SANDBOX_VARIANT_TITLES = {
+    [CodeSandboxVariant.Eval]: 'Eval',
+    [CodeSandboxVariant.Docker]: 'Docker',
+    [CodeSandboxVariant.JupyterServer]: 'Jupyter Server',
+    [CodeSandboxVariant.Datalayer]: 'Datalayer',
+    [CodeSandboxVariant.GoogleColab]: 'Google Colab',
+    [CodeSandboxVariant.Kaggle]: 'Kaggle',
+    [CodeSandboxVariant.Monty]: 'Monty',
+    [CodeSandboxVariant.Modal]: 'Modal',
+    [CodeSandboxVariant.Daytona]: 'Daytona',
+    [CodeSandboxVariant.Cloudflare]: 'Cloudflare',
+    [CodeSandboxVariant.CoreWeave]: 'CoreWeave',
+    [CodeSandboxVariant.E2B]: 'E2B',
+};
+/**
+ * The variant an environment belongs to, read off its `owner` tag.
+ *
+ * The operator tags an external environment with its provider through the
+ * environment's `owner` — `kaggle`, `modal`, `e2b` — while the platform's own
+ * carry `datalayer`. An owner nothing here recognises reads as Datalayer,
+ * which is what every environment was before providers existed.
+ */
+export function codeSandboxVariantOf(owner) {
+    const normalized = (owner ?? '').replace('_', '-').toLowerCase();
+    const match = Object.values(CodeSandboxVariant).find(value => value.replace('_', '-') === normalized);
+    return match ?? CodeSandboxVariant.Datalayer;
+}
+/** A short label for the chip beside an environment's name. */
+export function codeSandboxVariantTitle(variant) {
+    return CODE_SANDBOX_VARIANT_TITLES[variant] ?? variant;
+}
+export default CodeSandboxVariant;

package/lib/models/Content.d.ts

@@ -1,5 +1,31 @@
+/**
+ * How a sandbox may use a content: read it, or read and write it.
+ */
+export type IContentPermissions = 'ro' | 'rw';
+/**
+ * A content an Environment selects.
+ *
+ * This is the selection as the Runtimes service lists it on an Environment —
+ * which `RuntimeContent` (by `uid`), where it is mounted and how it may be
+ * used. The name is for reading; the `uid` is what identifies the content,
+ * and what a selection persists.
+ */
 export interface IContent {
+    /**
+     * The RuntimeContent identifier.
+     */
+    uid: string;
+    /**
+     * The RuntimeContent name.
+     */
     name: string;
+    /**
+     * Where the content is mounted in the sandbox.
+     */
     mount: string;
+    /**
+     * How the sandbox may use the content.
+     */
+    permissions: IContentPermissions;
 }
 export default IContent;