@datalayer/agent-runtimes 1.0.28 → 1.3.10

package/lib/components/code-sandboxes/CodeSandboxLauncher.js

@@ -1,19 +1,19 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-/*
- * Copyright (c) 2025-2026 Datalayer, Inc.
- * Distributed under the terms of the Modified BSD License.
- */
 import { useCallback, useEffect, useMemo, useState } from 'react';
 import { useIsMounted } from 'usehooks-ts';
-import { Button, FormControl, Select, Spinner, Text, TextInput, ToggleSwitch, } from '@primer/react';
+import { Button, FormControl, Spinner, Text, TextInput, ToggleSwitch, } from '@primer/react';
 import { Dialog } from '@primer/react/experimental';
 import { Box } from '@datalayer/primer-addons';
 import { useJupyterReactStore } from '@datalayer/jupyter-react';
-import { USAGE_ROUTE } from '@datalayer/core/lib/routes';
 import { useNavigate } from '@datalayer/core/lib/hooks';
 import { NO_RUNTIME_AVAILABLE_LABEL } from '@datalayer/core/lib/i18n';
+import { isCodeSandboxProviderAvailable } from './codeSandboxProviders';
+import { CodeSandboxVariant, codeSandboxVariantOf, codeSandboxVariantTitle, } from '../../models/CodeSandboxVariant';
+import { CodeSandboxEnvironmentSelect, } from './CodeSandboxEnvironmentSelect';
+import { codeSandboxEnvironmentOptions, codeSandboxEnvironmentVersion, firstLaunchableCodeSandboxEnvironment, } from './codeSandboxEnvironments';
 import { getCodeSandboxGivenName, listCodeSandboxGivenNames, nextCodeSandboxGivenName, setCodeSandboxGivenName, } from './CodeSandboxNames';
 import { iamStore, runtimesStore, useCoreStore, useIAMStore, } from '../../state/substates';
+import { createRuntime as createRuntimeRecord } from '../../runtimes/actions';
 import { createNotebook, sleep } from '@datalayer/core/lib/utils';
 import { Markdown } from '@datalayer/core/lib/components/display';
 import { Timer } from '@datalayer/core/lib/components/progress';
@@ -42,10 +42,20 @@ const NOT_AVAILABLE_RETRIES = 5;
  * The launcher of a new code sandbox.
  */
 export function CodeSandboxLauncher(props) {
-    const { dialogTitle, kernelSnapshot, manager, onSubmit, markdownParser, sanitizer, upgradeSubscription, submitLabel, startRuntime = true, } = props;
+    const { dialogTitle, kernelSnapshot, manager, onSubmit, markdownParser, sanitizer, upgradeSubscription, usageRoute = '/plans', submitLabel, startRuntime = true, } = props;
     const hasExample = startRuntime === 'with-example';
     const shouldStartRuntime = startRuntime !== 'defer';
     const user = iamStore.getState().user;
+    /*
+     * Where a sandbox may be launched: every provider that can be reached.
+     *
+     * The environments of the platform are offered wherever the account can
+     * reach it — withholding them inside JupyterLab left `ai-agents-env` off
+     * the list and no way to launch a remote sandbox from there. The Jupyter
+     * Server is the provider that depends on where this runs, and it is gated
+     * below.
+     */
+    const jupyterAvailable = isCodeSandboxProviderAvailable('local', runtimesStore.getState().multiServiceManager);
     const environments = manager.environments.get();
     /*
      * The sandboxes of this Jupyter Server, offered beside those of the platform.
@@ -57,6 +67,16 @@ export function CodeSandboxLauncher(props) {
      * prefixed, since a kernelspec and an environment are free to share a name.
      */
     const localSpecs = useMemo(() => {
+        /*
+         * ...and only inside JupyterLab.
+         *
+         * The rule cuts both ways: the web application talks to no Jupyter Server
+         * of its own, so a kernelspec of one is not something it can start — the
+         * entries read as choices that lead nowhere.
+         */
+        if (!jupyterAvailable) {
+            return [];
+        }
         const specs = runtimesStore.getState().multiServiceManager?.local?.kernelspecs.specs
             ?.kernelspecs ?? {};
         return Object.values(specs)
@@ -66,8 +86,33 @@ export function CodeSandboxLauncher(props) {
             title: spec.display_name,
             language: spec.language,
         }));
-    }, []);
+    }, [jupyterAvailable]);
     const LOCAL_PREFIX = 'local:';
+    /** Who is looking, which is what tells your environments from your organizations'. */
+    const viewer = useMemo(() => ({ uid: user?.uid, handle: user?.handle }), [user]);
+    /*
+     * The choices of the dropdown: what the platform and the external
+     * providers offer, then the kernelspecs of this Jupyter Server. Each says
+     * whose machine it is — two entries called "GPU" are told apart by nothing
+     * else.
+     *
+     * The environments come through `codeSandboxEnvironments`, so they read
+     * here exactly as they read in the picker: grouped as yours, your
+     * organizations' and the platform's, with the version and size class each
+     * runs, and disabled where there is nothing built to launch (E1-19).
+     */
+    const environmentOptions = useMemo(() => [
+        ...codeSandboxEnvironmentOptions(environments, viewer, spec => ({
+            providerTitle: codeSandboxVariantTitle(codeSandboxVariantOf(spec?.owner)),
+        })),
+        ...localSpecs.map(spec => ({
+            key: `${LOCAL_PREFIX}${spec.name}`,
+            title: spec.title || spec.name,
+            name: spec.name,
+            providerTitle: codeSandboxVariantTitle(CodeSandboxVariant.JupyterServer),
+            group: 'This Jupyter Server',
+        })),
+    ], [environments, localSpecs, viewer]);
     const localSpecOf = (value) => value.startsWith(LOCAL_PREFIX)
         ? localSpecs.find(spec => spec.name === value.slice(LOCAL_PREFIX.length))
         : undefined;
@@ -84,7 +129,24 @@ export function CodeSandboxLauncher(props) {
     }
     const jupyterReactStore = useJupyterReactStore();
     const jupyterLabAdapter = jupyterReactStore.jupyterLabAdapter;
-    const [selection, setSelection] = useState((kernelSnapshot?.environment || environments[0]?.name) ?? '');
+    const [selection, setSelection] = useState(
+    // Never an environment that cannot be launched — one whose variant was
+    // never built — or the dialog would open on a choice it must refuse.
+    (kernelSnapshot?.environment ||
+        firstLaunchableCodeSandboxEnvironment(environments)?.name) ??
+        '');
+    /*
+     * Something is always selected.
+     *
+     * With the environments of the platform withheld, the first choice of the
+     * list is a sandbox of this server — and nothing was selected at all, so the
+     * launcher opened on an empty dropdown that could not be submitted.
+     */
+    useEffect(() => {
+        if (!selection && localSpecs.length) {
+            setSelection(`${LOCAL_PREFIX}${localSpecs[0].name}`);
+        }
+    }, [localSpecs, selection]);
     const [timeLimit, setTimeLimit] = useState(10);
     /*
      * The name the sandbox is given, and what is offered for it.
@@ -103,10 +165,10 @@ export function CodeSandboxLauncher(props) {
         ...listCodeSandboxGivenNames(),
     ], [manager]);
     const givenNameFor = useCallback((spec) => nextCodeSandboxGivenName(spec?.runtime?.givenNameTemplate || spec?.title || '', takenGivenNames()), [takenGivenNames]);
-    const [runtimeName, setRuntimeName] = useState(() => givenNameFor(environments[0]));
+    const [runtimeName, setRuntimeName] = useState(() => givenNameFor(firstLaunchableCodeSandboxEnvironment(environments)));
     // Whether the runtim name has been changed by the user or not
     const [hasCustomRuntimeName, setHasCustomRuntimeName] = useState(false);
-    const [userStorage, setUserStorage] = useState(false);
+    const [homeFolder, setHomeFolder] = useState(false);
     const [openExample, setOpenExample] = useState(false);
     const [waitingForRuntime, setWaitingForRuntime] = useState(false);
     const [error, setError] = useState();
@@ -125,12 +187,11 @@ export function CodeSandboxLauncher(props) {
     const allowance = useNewCodeSandboxAllowance(burningRate);
     const effectiveMaxMinutes = allowance.effectiveMaxMinutes;
     const outOfCredits = shouldStartRuntime && allowance.outOfCredits;
-    const handleSelectionChange = useCallback((e) => {
-        const selection = e.target.value;
-        setSelection(selection);
+    const handleSelectionChange = useCallback((value) => {
+        setSelection(value);
         if (!hasCustomRuntimeName) {
-            const local = localSpecOf(selection);
-            setRuntimeName(givenNameFor(local ?? environments.find(env => env.name === selection)));
+            const local = localSpecOf(value);
+            setRuntimeName(givenNameFor(local ?? environments.find(env => env.name === value)));
         }
     }, [environments, givenNameFor, setSelection, hasCustomRuntimeName]);
     const handleSubmitRuntime = useCallback(async () => {
@@ -176,6 +237,17 @@ export function CodeSandboxLauncher(props) {
             setError(undefined);
             setWaitingForRuntime(shouldStartRuntime);
             const spec = environments.find(s => s.name === selection);
+            /*
+             * The version the dropdown showed is the version that launches.
+             *
+             * A user environment's entry says "v3", and sending that pins it: a
+             * promotion made while this dialog was open cannot change what the
+             * person accepted. A platform environment has no version, and the
+             * request is then the one it has always been (PLAN_ENV.md, E1-19).
+             */
+            const environmentVersion = spec
+                ? codeSandboxEnvironmentVersion(spec)
+                : undefined;
             const desc = {
                 name: selection,
                 language: spec?.language ?? '',
@@ -187,11 +259,41 @@ export function CodeSandboxLauncher(props) {
             if (startRuntime === 'defer') {
                 desc.params['creditsLimit'] = creditsLimit;
             }
-            if (userStorage) {
-                desc.params['capabilities'] = ['user_storage'];
+            if (homeFolder) {
+                desc.params['capabilities'] = ['home-folder'];
             }
             let success = true;
-            if (shouldStartRuntime) {
+            const provider = codeSandboxVariantOf(spec?.owner);
+            if (shouldStartRuntime && provider !== CodeSandboxVariant.Datalayer) {
+                /*
+                 * An EXTERNAL environment — Kaggle, Modal. The platform RECORDS such
+                 * a sandbox rather than running it: the provider runs it under the
+                 * user's own credentials, and what comes back is a record with no
+                 * pod, no ingress and no kernel. Waiting for one, as the branch
+                 * below does, would time out and then delete the record as broken.
+                 */
+                success = false;
+                try {
+                    await createRuntimeRecord({
+                        environmentName: selection,
+                        environmentVersion,
+                        type: 'notebook',
+                        givenName: runtimeName,
+                        creditsLimit,
+                    });
+                    await manager.runtimesManager.refresh();
+                    success = true;
+                }
+                catch (error) {
+                    console.error('Failed to record the external sandbox.', error);
+                    setFlashLevel('danger');
+                    setError(_jsxs(Text, { children: ["The ", codeSandboxVariantTitle(provider), " sandbox could not be created."] }));
+                }
+                finally {
+                    setWaitingForRuntime(false);
+                }
+            }
+            else if (shouldStartRuntime) {
                 success = false;
                 let availableTrial = 1;
                 let retryDelay = NOT_AVAILABLE_INIT_RETRY;
@@ -200,10 +302,11 @@ export function CodeSandboxLauncher(props) {
                     try {
                         const connection = await manager.runtimesManager.startNew({
                             environmentName: selection,
+                            environmentVersion,
                             type: 'notebook',
                             givenName: runtimeName,
                             creditsLimit: creditsLimit,
-                            capabilities: userStorage ? ['user_storage'] : undefined,
+                            capabilities: homeFolder ? ['home-folder'] : undefined,
                             snapshot: kernelSnapshot?.id,
                         }, {
                             username: user?.handle,
@@ -284,7 +387,7 @@ export function CodeSandboxLauncher(props) {
         startRuntime,
         runtimeName,
         onSubmit,
-        userStorage,
+        homeFolder,
         openExample,
         jupyterLabAdapter,
         timeLimit,
@@ -334,7 +437,7 @@ export function CodeSandboxLauncher(props) {
                     event.preventDefault();
                     handleSubmitRuntime();
                 }
-            }, children: [_jsxs(FormControl, { disabled: !!kernelSnapshot?.environment || environments.length === 0, children: [_jsx(FormControl.Label, { children: "Environment" }), _jsxs(Select, { name: "environment", disabled: !!kernelSnapshot?.environment || environments.length === 0, value: selection, onChange: handleSelectionChange, block: true, children: [environments.map(spec => (_jsxs(Select.Option, { value: spec.name, children: [spec.name, spec.title && (_jsxs(_Fragment, { children: [' - ', spec.title] }))] }, spec.name))), localSpecs.map(spec => (_jsxs(Select.Option, { value: `${LOCAL_PREFIX}${spec.name}`, children: [spec.name, spec.title && _jsx(_Fragment, { children: ` - ${spec.title}` }), ' - Jupyter Server'] }, `${LOCAL_PREFIX}${spec.name}`)))] }), _jsx(FormControl.Caption, { children: _jsx(_Fragment, { children: markdownParser ? (_jsx(Box, { sx: { img: { maxWidth: '100%' } }, children: _jsx(Markdown, { text: description, markdownParser: markdownParser, sanitizer: sanitizer }) })) : sanitizer ? (
+            }, children: [_jsxs(FormControl, { disabled: !!kernelSnapshot?.environment || environments.length === 0, children: [_jsx(FormControl.Label, { children: "Environment" }), _jsx(CodeSandboxEnvironmentSelect, { disabled: !!kernelSnapshot?.environment || environments.length === 0, options: environmentOptions, selectedKey: selection, onSelect: handleSelectionChange }), _jsx(FormControl.Caption, { children: _jsx(_Fragment, { children: markdownParser ? (_jsx(Box, { sx: { img: { maxWidth: '100%' } }, children: _jsx(Markdown, { text: description, markdownParser: markdownParser, sanitizer: sanitizer }) })) : sanitizer ? (
                                 // The description of an environment carries markup. With no
                                 // parser to render it, the sanitizer of the application is
                                 // enough to show it as what it is rather than as its tags.
@@ -349,11 +452,15 @@ export function CodeSandboxLauncher(props) {
                 , { 
                     // A sandbox of this server costs nothing and starts at once: it has
                     // no time to reserve and no storage of the platform to mount.
-                    withReservation: !!startRuntime && !isLocalSelection, withUserStorage: !isLocalSelection, burningRate: burningRate, timeLimit: timeLimit, onTimeChange: setTimeLimit, max: effectiveMaxMinutes, disabled: outOfCredits, error: outOfCredits ? 'You must add credits to your account.' : undefined, addCredits: navigate
+                    withReservation: !!startRuntime && !isLocalSelection, withHomeFolder: !isLocalSelection, burningRate: burningRate, timeLimit: timeLimit, onTimeChange: setTimeLimit, max: effectiveMaxMinutes, 
+                    // Nothing to reserve or store until an environment is chosen.
+                    disabled: outOfCredits || !selection, storageDisabled: !selection, error: outOfCredits ? 'You must add credits to your account.' : undefined, addCredits: navigate
                         ? () => {
-                            navigate(USAGE_ROUTE);
+                            navigate(usageRoute);
                         }
-                        : undefined, userStorage: userStorage, onUserStorageToggle: () => setUserStorage(current => !current) }), _jsxs(FormControl, { sx: { paddingTop: '10px' }, children: [_jsx(FormControl.Label, { children: "Given Name" }), _jsx(TextInput, { name: "name", value: runtimeName, onChange: handleKernelNameChange, block: true })] }), hasExample &&
+                        : undefined, homeFolder: homeFolder, onHomeFolderToggle: () => setHomeFolder(current => !current) }), _jsxs(FormControl, { sx: { paddingTop: '10px' }, children: [_jsx(FormControl.Label, { children: "Given Name" }), _jsx(TextInput, { name: "name", value: runtimeName, onChange: handleKernelNameChange, 
+                            // A sandbox is named only once there is one to name.
+                            disabled: !selection, block: true })] }), hasExample &&
                     jupyterLabAdapter?.jupyterLab &&
                     !configuration.whiteLabel && (_jsxs(FormControl, { sx: { paddingTop: '10px' }, children: [_jsx(FormControl.Label, { id: "open-example-label", children: "Open example notebook" }), _jsx(ToggleSwitch, { disabled: !environments.find(spec => spec.name === selection)?.example, checked: openExample, size: "small", onClick: handleSwitchClick, "aria-labelledby": "open-example-label" })] })), error && (_jsx(FlashClosable, { variant: flashLevel, actions: navigate && upgradeSubscription && flashLevel === 'warning' ? (_jsx(Button, { onClick: handleUpgrade, title: 'Upgrade your subscription.', children: "Upgrade" })) : undefined, children: error }))] }) }));
 }

package/lib/components/code-sandboxes/CodeSandboxNames.js

@@ -2,10 +2,6 @@
  * Copyright (c) 2025-2026 Datalayer, Inc.
  * Distributed under the terms of the Modified BSD License.
  */
-/*
- * Copyright (c) 2023-2025 Datalayer, Inc.
- * Distributed under the terms of the Modified BSD License.
- */
 /**
  * The given name of a code sandbox of a Jupyter Server or of the browser.
  *
@@ -32,25 +28,56 @@
  */
 /** Where the names are kept, and under which key. */
 const STORAGE_KEY = 'datalayer:code-sandbox-names';
-/** The names, by kernel identifier, as they were last written. */
-let names;
-function load() {
-    if (names) {
-        return names;
-    }
+/** When each name was written, so pruning can spare what is brand new. */
+const STAMP_KEY = 'datalayer:code-sandbox-names:at';
+/**
+ * How long a fresh name is safe from pruning.
+ *
+ * Pruning compares the names against a list of running kernels, and that list
+ * is a POLL: a sweep that was in flight while a sandbox was created and named
+ * finishes with a list from before it existed, and deleted the name the user
+ * had just typed — every surface then agreed on the renumbered default. A
+ * kernel identifier is never reused, so sparing a young name costs nothing:
+ * a truly dead one is collected on the sweeps after the grace.
+ */
+const PRUNE_GRACE_MS = 10 * 60 * 1000;
+/** The fallback for a browser that refuses its storage: this page only. */
+let memory = {};
+let memoryStamps = {};
+function read(key) {
     try {
-        const raw = globalThis.localStorage?.getItem(STORAGE_KEY);
-        names = raw ? JSON.parse(raw) : {};
+        const raw = globalThis.localStorage?.getItem(key);
+        return raw ? JSON.parse(raw) : {};
     }
     catch {
-        // A browser that refuses its storage keeps the names for this page only.
-        names = {};
+        return undefined;
     }
-    return names;
 }
-function save() {
+/*
+ * Read on every call, never cached in the module.
+ *
+ * A cached copy is a second truth: another instance of this module — another
+ * tab, another bundle holding its own copy — writes the storage, the cache
+ * here goes stale, and the next save writes the stale cache back over what
+ * the other instance stored. The maps are a handful of entries; reading them
+ * each time is nothing.
+ */
+function load() {
+    const stored = read(STORAGE_KEY);
+    return stored === undefined ? memory : stored;
+}
+function loadStamps() {
+    const stored = read(STAMP_KEY);
+    return stored === undefined
+        ? memoryStamps
+        : stored;
+}
+function save(names, stamps) {
+    memory = names;
+    memoryStamps = stamps;
     try {
-        globalThis.localStorage?.setItem(STORAGE_KEY, JSON.stringify(load()));
+        globalThis.localStorage?.setItem(STORAGE_KEY, JSON.stringify(names));
+        globalThis.localStorage?.setItem(STAMP_KEY, JSON.stringify(stamps));
     }
     catch {
         /* the names stay in memory */
@@ -71,14 +98,17 @@ export function getCodeSandboxGivenName(kernelId) {
  * @param givenName What to call it; empty forgets the name
  */
 export function setCodeSandboxGivenName(kernelId, givenName) {
-    const stored = load();
+    const names = load();
+    const stamps = loadStamps();
     if (givenName) {
-        stored[kernelId] = asGivenName(givenName);
+        names[kernelId] = asGivenName(givenName);
+        stamps[kernelId] = Date.now();
     }
     else {
-        delete stored[kernelId];
+        delete names[kernelId];
+        delete stamps[kernelId];
     }
-    save();
+    save(names, stamps);
 }
 /**
  * Drop the names of the sandboxes that are no longer running.
@@ -87,16 +117,27 @@ export function setCodeSandboxGivenName(kernelId, givenName) {
  */
 export function pruneCodeSandboxGivenNames(runningKernelIds) {
     const alive = new Set(runningKernelIds);
-    const stored = load();
+    const names = load();
+    const stamps = loadStamps();
+    const now = Date.now();
     let dropped = false;
-    Object.keys(stored).forEach(kernelId => {
-        if (!alive.has(kernelId)) {
-            delete stored[kernelId];
-            dropped = true;
+    Object.keys(names).forEach(kernelId => {
+        if (alive.has(kernelId)) {
+            return;
+        }
+        // Not in the list is not proof of death: the list is a poll, and a
+        // sandbox named a moment ago may not be in it yet. The young are spared;
+        // see PRUNE_GRACE_MS.
+        const namedAt = stamps[kernelId];
+        if (typeof namedAt === 'number' && now - namedAt < PRUNE_GRACE_MS) {
+            return;
         }
+        delete names[kernelId];
+        delete stamps[kernelId];
+        dropped = true;
     });
     if (dropped) {
-        save();
+        save(names, stamps);
     }
 }
 /**
@@ -110,8 +151,13 @@ export function pruneCodeSandboxGivenNames(runningKernelIds) {
  */
 function asGivenName(base) {
     const stripped = (base ?? '')
-        // Pictographs, their skin tones, their joiners and their selectors.
-        .replace(/[\u{1F000}-\u{1FAFF}\u{2190}-\u{2BFF}\u{FE00}-\u{FE0F}\u{200D}]/gu, ' ')
+        /*
+         * Pictographs, their skin tones, their joiners and their selectors.
+         * Split into three alternatives rather than one class: a class whose next
+         * range starts on a combining mark (the variation selectors) reads to
+         * `no-misleading-character-class` as a base character followed by a mark.
+         */
+        .replace(/[\u{1F000}-\u{1FAFF}\u{2190}-\u{2BFF}]|[\u{FE00}-\u{FE0F}]|\u{200D}/gu, ' ')
         .replace(/\s+/g, ' ')
         .trim();
     return stripped || 'Code Sandbox';

package/lib/components/code-sandboxes/CodeSandboxPicker.d.ts

@@ -4,7 +4,7 @@ import { ITranslator } from '@jupyterlab/translation';
 import { IRuntimeDesc } from '../../models';
 import { type IMultiServiceManager } from '../../runtimes';
 import type { CodeSandboxTransfer } from './CodeSandboxTransfer';
-type IDisplayMode = 'menu' | 'radio';
+type IDisplayMode = 'menu' | 'radio' | 'dropdown';
 /**
  * {@link CodeSandboxPicker} properties
  */
@@ -13,6 +13,19 @@ export interface ICodeSandboxPickerProps {
      * The display mode.
      */
     display: IDisplayMode;
+    /**
+     * Where the sandboxes that ALREADY RUN are offered, in the `dropdown`
+     * display.
+     *
+     * `separated`, the default: as radio buttons of their own, above a
+     * dropdown that then offers only the environments — so the dropdown reads
+     * as "start a new one" and the running sandboxes are all in sight, which
+     * is what picking one of them is usually about.
+     *
+     * `combined`: everything in the one dropdown, running sandboxes and
+     * environments alike, under their headings.
+     */
+    sandboxLayout?: 'separated' | 'combined';
     /**
      * Additional actions items to be placed at the top of the picker
      */