@datalayer/agent-runtimes 1.0.26 → 1.0.29

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

@@ -2,11 +2,13 @@
  * Copyright (c) 2025-2026 Datalayer, Inc.
  * Distributed under the terms of the Modified BSD License.
  */
-import { PathExt } from '@jupyterlab/coreutils';
 import { nullTranslator } from '@jupyterlab/translation';
-const ASSIGN_NEW_RUNTIME_LABEL = 'Assign a new Runtime';
-const ASSIGN_EXISTING_REMOTE_RUNTIME_LABEL = 'Assign an existing Remote Runtime';
-const ASSIGN_EXISTING_RUNTIME_LABEL = 'Assign an existing Runtime';
+const ASSIGN_NEW_RUNTIME_LABEL = 'Assign a new Code Sandbox';
+import { ensureCodeSandboxGivenName } from './CodeSandboxNames';
+import { isCodeSandboxProviderAvailable } from './codeSandboxProviders';
+import { CodeSandboxVariant, codeSandboxVariantOf, } from '../../models/CodeSandboxVariant';
+const ASSIGN_EXISTING_REMOTE_RUNTIME_LABEL = 'Assign an existing Remote Code Sandbox';
+const ASSIGN_EXISTING_RUNTIME_LABEL = 'Assign an existing Code Sandbox';
 /**
  * Create the grouped runtime descriptions.
  */
@@ -18,18 +20,31 @@ export function getGroupedCodeSandboxDescs(multiServiceManager, kernelId, transl
     // identifier, the specification only names it. Only the environments to
     // start a new runtime in come from the specifications, and they wait.
     const specs = multiServiceManager.local.kernelspecs.specs;
-    const sessions = multiServiceManager.local.sessions.running();
+    /*
+     * The kernels of a Jupyter Server belong to the page that talks to one —
+     * inside JupyterLab. The web application's "local" manager points at
+     * whatever server its configuration names, and offering those kernels
+     * there lists sandboxes the user never started and cannot reason about.
+     * One rule for the whole file: the provider registry answers it, for the
+     * existing sandboxes here exactly as for the new-sandbox group below.
+     */
+    const jupyterProviderAvailable = isCodeSandboxProviderAvailable('local', multiServiceManager);
+    const sessions = jupyterProviderAvailable
+        ? multiServiceManager.local.sessions.running()
+        : [];
     const kernels = {};
     // Add the sessions.
     const runningSessions = Array.from(sessions)
         .filter(session => session.kernel && session.kernel.id !== kernelId)
-        .map(session => {
+        // Annotated for the same reason as the chain below: what is pushed into
+        // this list includes sandboxes that carry a pod rather than a kernel.
+        .map((session) => {
         const spec = specs?.kernelspecs[session.kernel.name];
         return {
             kernelId: session.kernel.id,
             name: spec?.name ?? session.kernel.name,
             language: spec?.language ?? '',
-            displayName: session.name || PathExt.basename(session.path),
+            displayName: ensureCodeSandboxGivenName(session.kernel.id, spec?.display_name ?? session.kernel.name),
             location: 'local',
         };
     })
@@ -43,36 +58,56 @@ export function getGroupedCodeSandboxDescs(multiServiceManager, kernelId, transl
             kernelId: session.kernel.id,
             name: spec?.name ?? session.kernel.name,
             language: spec?.language ?? '',
-            displayName: session.name || PathExt.basename(session.path),
+            displayName: ensureCodeSandboxGivenName(session.kernel.id, spec?.display_name ?? session.kernel.name),
             location: 'browser',
         };
     }))
         .filter(filterKernels);
     // Add the running runtimes.
     const listedAsSession = runningSessions.map(s => s.kernelId);
-    const runningKernels = Array.from(multiServiceManager.local.kernels.running())
+    const runningKernels = Array.from(jupyterProviderAvailable ? multiServiceManager.local.kernels.running() : [])
         .filter(k => !listedAsSession.includes(k.id))
-        .map(k => {
+        // Annotated, because the element type of the chain below is taken from
+        // this first link: a sandbox with no kernel joins it further down.
+        .map((k) => {
         const spec = specs?.kernelspecs[k.name];
         return {
             kernelId: k.id,
             name: spec?.name ?? k.name,
             language: spec?.language ?? '',
-            displayName: spec?.display_name ?? k.name,
+            displayName: ensureCodeSandboxGivenName(k.id, spec?.display_name ?? k.name),
             location: 'local',
         };
     })
         .concat((multiServiceManager.remote?.runtimesManager.get() ?? [])
-        .filter(k => k.id && !listedAsSession.includes(k.id))
+        /*
+         * A sandbox with no KERNEL is still a sandbox that runs.
+         *
+         * The ones of an external provider — Kaggle, Modal — run at their
+         * provider and carry no kernel of this platform, so their `id` is
+         * empty. Asking for a truthy one dropped every one of them: they
+         * appeared in the table of the Code Sandboxes and nowhere in the
+         * picker, which is the one place a notebook can be pointed at them.
+         * What they always have is the pod that stands for them.
+         */
+        .filter(k => (k.id || k.pod_name) && !listedAsSession.includes(k.id))
         .map(runtime => {
         const environment = multiServiceManager
             .remote.environments.get()
             .find(env => env.name === runtime.environment.name);
         return {
-            kernelId: runtime.id,
+            // Empty for an external sandbox: it has none, and saying so is
+            // what keeps the picker from trying to connect to one.
+            kernelId: runtime.id || undefined,
             name: environment.name,
             language: environment.language,
-            displayName: environment.title || runtime.given_name || environment.name,
+            provider: codeSandboxVariantOf(environment?.owner ?? runtime.environment?.owner),
+            displayName: 
+            // The name it was GIVEN first: the title of the environment is
+            // what it runs, and every sandbox of that environment answers
+            // it — the launcher asks for a name precisely so two of them
+            // can be told apart here.
+            runtime.given_name || environment.title || environment.name,
             location: 'remote',
             podName: runtime.pod_name,
             gpu: environment.resources?.['nvidia.com/gpu'],
@@ -86,7 +121,7 @@ export function getGroupedCodeSandboxDescs(multiServiceManager, kernelId, transl
             kernelId: k.id,
             name: spec?.name ?? k.name,
             language: spec?.language ?? '',
-            displayName: spec?.display_name ?? k.name,
+            displayName: ensureCodeSandboxGivenName(k.id, spec?.display_name ?? k.name),
             location: 'browser',
         };
     }))
@@ -96,7 +131,9 @@ export function getGroupedCodeSandboxDescs(multiServiceManager, kernelId, transl
     // another — and a runtime listed twice would be picked twice.
     const seen = new Set();
     const distinctRunning = runningSessions.filter(desc => {
-        const key = `${desc.location}:${desc.kernelId ?? desc.name}`;
+        // A kernel-less sandbox is named by its pod; without it every external
+        // sandbox of one environment collapsed into a single entry.
+        const key = `${desc.location}:${desc.kernelId ?? desc.podName ?? desc.name}`;
         if (seen.has(key)) {
             return false;
         }
@@ -112,7 +149,14 @@ export function getGroupedCodeSandboxDescs(multiServiceManager, kernelId, transl
         kernels[key] = runningSessions;
     }
     // Environments.
-    const environments = Object.values(specs?.kernelspecs ?? {})
+    /*
+     * The sandboxes of a Jupyter Server, which is a provider like the others.
+     *
+     * It is the one provider that only exists where the page is talking to such
+     * a server: inside JupyterLab. Elsewhere its kernels are somebody else's,
+     * and offering them promises what cannot be reached.
+     */
+    const environments = Object.values(jupyterProviderAvailable ? (specs?.kernelspecs ?? {}) : {})
         .filter(spec => !!spec)
         .map(spec => ({
         name: spec.name,
@@ -120,10 +164,21 @@ export function getGroupedCodeSandboxDescs(multiServiceManager, kernelId, transl
         displayName: spec.display_name,
         gpu: spec.resources?.['nvidia.com/gpu'],
         location: 'local',
+        provider: CodeSandboxVariant.JupyterServer,
     }))
         .filter(filterKernels);
-    environments.push(...(multiServiceManager.remote?.environments
-        .get()
+    /*
+     * Every provider that can be used from here, and only those.
+     *
+     * A provider is a place a sandbox runs — the platform, this Jupyter Server,
+     * the browser — and each is offered when it is REACHABLE, not according to
+     * which application is asking. Withholding the platform inside JupyterLab
+     * took `ai-agents-env` off the list and left no way to launch a remote
+     * sandbox from there at all; the rule that was wanted is the other one, and
+     * it is stated where the Jupyter Server is read below.
+     */
+    const remoteEnvironments = multiServiceManager.remote?.environments.get() ?? [];
+    environments.push(...remoteEnvironments
         .map(spec => ({
         name: spec.name,
         language: spec.language,
@@ -131,8 +186,9 @@ export function getGroupedCodeSandboxDescs(multiServiceManager, kernelId, transl
         location: 'remote',
         gpu: spec.resources?.['nvidia.com/gpu'],
         burningRate: spec.burning_rate,
+        provider: codeSandboxVariantOf(spec?.owner),
     }))
-        .filter(filterKernels) ?? []));
+        .filter(filterKernels));
     environments.push(...Object.values(multiServiceManager.browser?.kernelspecs.specs?.kernelspecs ?? {})
         .filter(spec => !!spec)
         .map(spec => ({

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

@@ -34,6 +34,23 @@ export interface INewCodeSandboxControlsProps {
     userStorage: boolean;
     onUserStorageToggle: () => void;
     storageDisabled?: boolean;
+    /**
+     * The name the sandbox is given, when the caller asks for that question.
+     *
+     * A sandbox of the platform is named through `given_name`; one of a server
+     * or of the browser has the name held for it by `CodeSandboxNames`. The
+     * question is the same either way, so it is asked in one place.
+     */
+    givenName?: string;
+    onGivenNameChange?: (givenName: string) => void;
+    /**
+     * Whether the storage of the user is offered.
+     *
+     * A sandbox of this Jupyter Server runs on this machine, with the files of
+     * this machine: it reserves no time and mounts no storage of the platform,
+     * so neither question applies to it.
+     */
+    withUserStorage?: boolean;
 }
 /**
  * The two questions of a new sandbox: the time reservation, and the storage.

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

@@ -15,7 +15,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
  *
  * @module components/code-sandboxes/NewCodeSandboxControls
  */
-import { FormControl, ToggleSwitch, Tooltip, IconButton } from '@primer/react';
+import { FormControl, IconButton, TextInput, ToggleSwitch, Tooltip, } from '@primer/react';
 import { AlertIcon } from '@primer/octicons-react';
 import { useCoreStore, useIAMStore } from '../../state/substates';
 import { CodeSandboxReservationControl, MAXIMAL_CODE_SANDBOX_TIME_RESERVATION_MINUTES, } from './CodeSandboxReservationControl';
@@ -67,10 +67,10 @@ export function creditsLimitFor(timeLimitMinutes, burningRate) {
  * The storage is withheld on white-label deployments, as it always was.
  */
 export function NewCodeSandboxControls(props) {
-    const { addCredits, burningRate, withReservation = true, disabled, error, max, onTimeChange, onUserStorageToggle, storageDisabled, timeLimit, userStorage, } = props;
+    const { addCredits, burningRate, withReservation = true, disabled, error, givenName, max, onGivenNameChange, onTimeChange, onUserStorageToggle, storageDisabled, timeLimit, userStorage, withUserStorage = true, } = props;
     const { configuration } = useCoreStore();
-    return (_jsxs(_Fragment, { children: [withReservation && (_jsx(CodeSandboxReservationControl, { addCredits: addCredits, disabled: disabled, label: 'Time reservation', max: max, time: timeLimit, burningRate: burningRate, onTimeChange: onTimeChange, error: error })), !configuration.whiteLabel && (_jsxs(FormControl, { disabled: storageDisabled, layout: "horizontal", children: [_jsxs(FormControl.Label, { id: "new-sandbox-user-storage-label", children: ["User storage", _jsx(Tooltip, { text: "The runtime will be slower to start.", direction: "e", style: { marginLeft: 3 }, children: _jsx(IconButton, { icon: AlertIcon, "aria-label": "", variant: "invisible" }) })] }), _jsx(ToggleSwitch, { disabled: storageDisabled, checked: userStorage, size: "small", onClick: event => {
+    return (_jsxs(_Fragment, { children: [withReservation && (_jsx(CodeSandboxReservationControl, { addCredits: addCredits, disabled: disabled, label: 'Time reservation', max: max, time: timeLimit, burningRate: burningRate, onTimeChange: onTimeChange, error: error })), withUserStorage && !configuration.whiteLabel && (_jsxs(FormControl, { disabled: storageDisabled, layout: "horizontal", children: [_jsxs(FormControl.Label, { id: "new-sandbox-user-storage-label", children: ["User storage", _jsx(Tooltip, { text: "The runtime will be slower to start.", direction: "e", style: { marginLeft: 3 }, children: _jsx(IconButton, { icon: AlertIcon, "aria-label": "", variant: "invisible" }) })] }), _jsx(ToggleSwitch, { disabled: storageDisabled, checked: userStorage, size: "small", onClick: event => {
                             event.preventDefault();
                             onUserStorageToggle();
-                        }, "aria-labelledby": "new-sandbox-user-storage-label" })] }))] }));
+                        }, "aria-labelledby": "new-sandbox-user-storage-label" })] })), onGivenNameChange && (_jsxs(FormControl, { disabled: disabled, children: [_jsx(FormControl.Label, { children: "Given Name" }), _jsx(TextInput, { block: true, name: "given-name", value: givenName ?? '', onChange: event => onGivenNameChange(event.target.value) }), _jsx(FormControl.Caption, { children: "What this sandbox is called, wherever it is listed." })] }))] }));
 }

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

@@ -0,0 +1,29 @@
+import type { IMultiServiceManager } from '../../api';
+import type { IRuntimeLocation } from '../../models';
+/** A place sandboxes run, as this page knows it. */
+export type ICodeSandboxProvider = {
+    /** Identifier of the provider, which is where its sandboxes run. */
+    name: IRuntimeLocation;
+    /** What it is called, for a person. */
+    title: string;
+    /** Whether this page can reach it at all. */
+    available: boolean;
+    /** Why not, when it cannot. */
+    unavailableReason?: string;
+};
+/**
+ * Every provider this page knows, and whether it can be used.
+ *
+ * @param multiServiceManager The services of the page, which say what is
+ *   reachable: the platform when the account has it, the Jupyter Server when
+ *   the page is one, the browser when kernels run in it
+ */
+export declare function codeSandboxProviders(multiServiceManager: IMultiServiceManager | undefined): ICodeSandboxProvider[];
+/**
+ * Whether one provider can be used from this page.
+ *
+ * @param location Where the sandboxes of that provider run
+ * @param multiServiceManager The services of the page
+ */
+export declare function isCodeSandboxProviderAvailable(location: IRuntimeLocation, multiServiceManager: IMultiServiceManager | undefined): boolean;
+export default codeSandboxProviders;

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

@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The places a code sandbox can run, and which of them this page can use.
+ *
+ * A sandbox is not one kind of thing: it is a runtime of the platform, a
+ * kernel of a Jupyter Server, a kernel of the browser — and, on the Python
+ * side, a Kaggle session or a Modal container as well. Each of those is a
+ * PROVIDER, each ships the environments it offers (the platform ships
+ * `ai-agents-env`, Kaggle a CPU and a GPU session), and each is usable only
+ * where what it needs is at hand.
+ *
+ * That last rule was written three times over — in the picker, in the
+ * launcher, in the table of the sandboxes — and drifted every time it was
+ * touched: withholding the platform inside JupyterLab took `ai-agents-env`
+ * off the list and left no way to launch a remote sandbox there at all. It is
+ * stated once here, and the three read it.
+ *
+ * The same concept lives in `code_sandboxes.providers` on the Python side,
+ * where availability is decided by secrets rather than by services. Both
+ * answer the same question — which providers can be used from here — so the
+ * CLI, the web application and JupyterLab offer the same thing.
+ *
+ * @module components/code-sandboxes/codeSandboxProviders
+ */
+import { loadJupyterConfig } from '@datalayer/jupyter-react';
+/**
+ * Every provider this page knows, and whether it can be used.
+ *
+ * @param multiServiceManager The services of the page, which say what is
+ *   reachable: the platform when the account has it, the Jupyter Server when
+ *   the page is one, the browser when kernels run in it
+ */
+export function codeSandboxProviders(multiServiceManager) {
+    /*
+     * The Jupyter Server is the provider bound to WHERE the page runs.
+     *
+     * Its kernels belong to the server the page is talking to. Outside
+     * JupyterLab there is no such server — what a manager reports as "local" is
+     * somebody else's — so offering them promises what cannot be reached.
+     */
+    const insideJupyterLab = loadJupyterConfig().insideJupyterLab;
+    return [
+        {
+            name: 'remote',
+            title: 'Datalayer',
+            available: Boolean(multiServiceManager?.remote),
+            unavailableReason: multiServiceManager?.remote
+                ? undefined
+                : 'Sign in to Datalayer to launch a sandbox on the platform.'
+        },
+        {
+            name: 'local',
+            title: 'Jupyter Server',
+            available: insideJupyterLab && Boolean(multiServiceManager?.local),
+            unavailableReason: insideJupyterLab
+                ? undefined
+                : 'The kernels of a Jupyter Server are offered inside JupyterLab.'
+        },
+        {
+            name: 'browser',
+            title: 'Browser',
+            available: Boolean(multiServiceManager?.browser),
+            unavailableReason: multiServiceManager?.browser
+                ? undefined
+                : 'No kernel runs in this browser.'
+        }
+    ];
+}
+/**
+ * Whether one provider can be used from this page.
+ *
+ * @param location Where the sandboxes of that provider run
+ * @param multiServiceManager The services of the page
+ */
+export function isCodeSandboxProviderAvailable(location, multiServiceManager) {
+    return Boolean(codeSandboxProviders(multiServiceManager).find(provider => provider.name === location)?.available);
+}
+export default codeSandboxProviders;

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

@@ -11,11 +11,14 @@
  */
 export * from './CodeSandboxCellVariables';
 export * from './CodeSandboxCellVariablesDialog';
+export * from './CodeSandboxEnvironmentSelect';
 export * from './CodeSandboxLauncher';
 export * from './CodeSandboxPicker';
 export * from './CodeSandboxPickerCell';
 export * from './CodeSandboxReservationControl';
 export * from './CodeSandboxTransfer';
+export * from './CodeSandboxNames';
+export * from './codeSandboxProviders';
 export * from './CodeSandboxUtils';
 export * from './CodeSandboxVariables';
 export * from './NewCodeSandboxControls';

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

@@ -15,11 +15,14 @@
  */
 export * from './CodeSandboxCellVariables';
 export * from './CodeSandboxCellVariablesDialog';
+export * from './CodeSandboxEnvironmentSelect';
 export * from './CodeSandboxLauncher';
 export * from './CodeSandboxPicker';
 export * from './CodeSandboxPickerCell';
 export * from './CodeSandboxReservationControl';
 export * from './CodeSandboxTransfer';
+export * from './CodeSandboxNames';
+export * from './codeSandboxProviders';
 export * from './CodeSandboxUtils';
 export * from './CodeSandboxVariables';
 export * from './NewCodeSandboxControls';

package/lib/examples/AgentspecsExample.js

@@ -84,7 +84,7 @@ const GITHUB_CLIENT_ID = import.meta.env.VITE_GITHUB_CLIENT_ID || 'example-clien
 // Kaggle API token - set via environment variable
 // Get your token at: https://www.kaggle.com/settings/account (API section)
 // Download kaggle.json and use the "key" value
-const KAGGLE_TOKEN = import.meta.env.VITE_KAGGLE_TOKEN || '';
+const KAGGLE_API_TOKEN = import.meta.env.VITE_KAGGLE_API_TOKEN || '';
 const isPlainObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
 const yamlScalar = (value) => {
     if (value === null || value === undefined) {
@@ -252,11 +252,11 @@ const DEFAULT_IDENTITY_PROVIDERS = {
             },
         }
         : {}),
-    ...(KAGGLE_TOKEN
+    ...(KAGGLE_API_TOKEN
         ? {
             kaggle: {
                 type: 'token',
-                token: KAGGLE_TOKEN,
+                token: KAGGLE_API_TOKEN,
                 displayName: 'Kaggle',
                 iconUrl: 'https://www.kaggle.com/static/images/favicon.ico',
             },

package/lib/identity/index.d.ts

@@ -37,7 +37,7 @@
  * ```
  */
 export type { OAuthProvider, OAuthToken, Identity, ProviderUserInfo, OAuthProviderConfig, AuthorizationRequest, AuthorizationCallback, IdentityState, IdentityActions, IdentityStore, AuthType, TokenProviderConfig, OAuthIdentityProviderConfig, TokenIdentityProviderConfig, IdentityProviderConfig, IdentityProvidersConfig, } from './types';
-export { GITHUB_PROVIDER, GOOGLE_PROVIDER, KAGGLE_PROVIDER, KAGGLE_TOKEN_PROVIDER, } from './types';
+export { GITHUB_PROVIDER, GOOGLE_PROVIDER, KAGGLE_PROVIDER, KAGGLE_API_TOKEN_PROVIDER, } from './types';
 export { generateCodeVerifier, generateCodeChallenge, generateState, generatePKCEPair, } from './pkce';
 export { discoverAuthorizationServer, supportsDCR, registerClient, updateClientRegistration, deleteClientRegistration, getOrCreateDynamicClient, loadDynamicClient, saveDynamicClient, removeDynamicClient, getAllDynamicClients, clearAllDynamicClients, dynamicClientToProviderConfig, type AuthorizationServerMetadata, type ClientRegistrationRequest, type ClientRegistrationResponse, type ClientRegistrationError, type DynamicClient, } from './dcr';
 export { useIdentityStore, useConnectedIdentities, useConnectedProviders, useIdentity as useIdentitySelector, useIsProviderConnected, usePendingAuthorization, useIdentityLoading, useIdentityError, configureBuiltinProviders, } from './identityStore';

package/lib/identity/index.js

@@ -2,7 +2,7 @@
  * Copyright (c) 2025-2026 Datalayer, Inc.
  * Distributed under the terms of the Modified BSD License.
  */
-export { GITHUB_PROVIDER, GOOGLE_PROVIDER, KAGGLE_PROVIDER, KAGGLE_TOKEN_PROVIDER, } from './types';
+export { GITHUB_PROVIDER, GOOGLE_PROVIDER, KAGGLE_PROVIDER, KAGGLE_API_TOKEN_PROVIDER, } from './types';
 // PKCE utilities
 export { generateCodeVerifier, generateCodeChallenge, generateState, generatePKCEPair, } from './pkce';
 // Dynamic Client Registration (DCR)

package/lib/identity/types.d.ts

@@ -237,7 +237,7 @@ export interface TokenProviderConfig {
  * Kaggle token-based provider configuration.
  * Generate token at: https://www.kaggle.com/settings/account (API section)
  */
-export declare const KAGGLE_TOKEN_PROVIDER: TokenProviderConfig;
+export declare const KAGGLE_API_TOKEN_PROVIDER: TokenProviderConfig;
 /**
  * OAuth provider configuration for identity providers.
  */

package/lib/identity/types.js

@@ -63,7 +63,7 @@ export const KAGGLE_PROVIDER = {
  * Kaggle token-based provider configuration.
  * Generate token at: https://www.kaggle.com/settings/account (API section)
  */
-export const KAGGLE_TOKEN_PROVIDER = {
+export const KAGGLE_API_TOKEN_PROVIDER = {
     provider: 'kaggle',
     displayName: 'Kaggle',
     iconUrl: 'https://www.kaggle.com/static/images/favicon.ico',

package/lib/models/CodeSandboxVariant.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 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"
+}
+/** 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` — 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,65 @@
+/*
+ * 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";
+})(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'
+};
+/**
+ * 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` — 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/index.d.ts

@@ -22,6 +22,7 @@ export * from './NotebookDTO';
 export * from './Page';
 export * from './PageTag';
 export * from './ProjectDTO';
+export * from './CodeSandboxVariant';
 export * from './Runtime';
 export * from './RuntimeDTO';
 export * from './Space';

package/lib/models/index.js

@@ -27,6 +27,7 @@ export * from './NotebookDTO';
 export * from './Page';
 export * from './PageTag';
 export * from './ProjectDTO';
+export * from './CodeSandboxVariant';
 export * from './Runtime';
 export * from './RuntimeDTO';
 export * from './Space';

package/lib/runtimes/actions.js

@@ -30,11 +30,23 @@ export async function getEnvironments() {
  */
 export async function createRuntime(options) {
     const { externalToken, token } = iamStore.getState();
+    /*
+     * A limit is required; ZERO is one of the answers.
+     *
+     * The environments of an external provider — Kaggle, Modal — burn no
+     * credits of the platform: their sandbox runs on the account of the user,
+     * at their provider, and the platform only records it. Their burning rate
+     * is `0`, so the limit computed for them is `0` too, and refusing that
+     * threw here — before any request was made, which is why the failure
+     * showed as a sandbox that could not be created with nothing in the
+     * network log to explain it. What is still refused is a limit that is not
+     * a number at all, or one below zero.
+     */
     if (typeof options.creditsLimit !== 'number' ||
         !Number.isFinite(options.creditsLimit) ||
-        options.creditsLimit <= 0) {
+        options.creditsLimit < 0) {
         throw new Error(`Invalid runtime creditsLimit for environment ${options.environmentName}. ` +
-            'A positive number is required.');
+            'A number of zero or more is required.');
     }
     const body = {
         environment: {

package/lib/specs/envvars.d.ts

@@ -12,7 +12,7 @@ export declare const GITHUB_TOKEN_SPEC_0_0_1: EnvvarSpec;
 export declare const GOOGLE_OAUTH_CLIENT_ID_SPEC_0_0_1: EnvvarSpec;
 export declare const GOOGLE_OAUTH_CLIENT_SECRET_SPEC_0_0_1: EnvvarSpec;
 export declare const HF_TOKEN_SPEC_0_0_1: EnvvarSpec;
-export declare const KAGGLE_TOKEN_SPEC_0_0_1: EnvvarSpec;
+export declare const KAGGLE_API_TOKEN_SPEC_0_0_1: EnvvarSpec;
 export declare const SLACK_BOT_TOKEN_SPEC_0_0_1: EnvvarSpec;
 export declare const SLACK_CHANNEL_IDS_SPEC_0_0_1: EnvvarSpec;
 export declare const SLACK_TEAM_ID_SPEC_0_0_1: EnvvarSpec;

package/lib/specs/envvars.js

@@ -62,8 +62,8 @@ export const HF_TOKEN_SPEC_0_0_1 = {
     icon: 'key',
     emoji: '🔑',
 };
-export const KAGGLE_TOKEN_SPEC_0_0_1 = {
-    id: 'KAGGLE_TOKEN',
+export const KAGGLE_API_TOKEN_SPEC_0_0_1 = {
+    id: 'KAGGLE_API_TOKEN',
     version: '0.0.1',
     name: 'Kaggle API Token',
     description: 'API token for accessing Kaggle datasets, competitions, notebooks, and models. Required for Kaggle MCP server authentication.',
@@ -120,7 +120,7 @@ export const ENVVAR_CATALOG = {
     GOOGLE_OAUTH_CLIENT_ID: GOOGLE_OAUTH_CLIENT_ID_SPEC_0_0_1,
     GOOGLE_OAUTH_CLIENT_SECRET: GOOGLE_OAUTH_CLIENT_SECRET_SPEC_0_0_1,
     HF_TOKEN: HF_TOKEN_SPEC_0_0_1,
-    KAGGLE_TOKEN: KAGGLE_TOKEN_SPEC_0_0_1,
+    KAGGLE_API_TOKEN: KAGGLE_API_TOKEN_SPEC_0_0_1,
     SLACK_BOT_TOKEN: SLACK_BOT_TOKEN_SPEC_0_0_1,
     SLACK_CHANNEL_IDS: SLACK_CHANNEL_IDS_SPEC_0_0_1,
     SLACK_TEAM_ID: SLACK_TEAM_ID_SPEC_0_0_1,