@datalayer/agent-runtimes 1.0.18 → 1.0.20

package/lib/chat/notebook/EphemeralNotebook.js

@@ -21,7 +21,8 @@ import { jsx as _jsx } from "react/jsx-runtime";
  */
 import { useEffect, useMemo, useRef, useState } from 'react';
 import { ServerConnection, ServiceManager } from '@jupyterlab/services';
-import { Box, DatalayerThemeProvider, getThemeConfig, useSystemColorMode, useThemeStore, } from '@datalayer/primer-addons';
+import { DatalayerThemeProvider, getThemeConfig, useSystemColorMode, useThemeStore, } from '@datalayer/primer-addons';
+import { Box } from '@primer/react';
 import { Notebook, NotebookToolbar, CellSidebarExtension, CellSidebarButton, JupyterReactTheme, notebookStore, disposeServiceManager, } from '@datalayer/jupyter-react';
 import { useAgentsRuntimes } from '../../hooks/useAgentRuntimes';
 import { registerSandboxServiceManager } from '../../services/sandboxServiceManagers';
@@ -54,7 +55,7 @@ const EPHEMERAL_NOTEBOOK_CONTENT = {
 /**
  * Renders an in-memory notebook backed by a sandbox kernel.
  */
-export function EphemeralNotebook({ notebookId, runtimePodName, cellSidebarMargin = 120, nbformat, onNbformatChange, toolbarComponent, }) {
+export function EphemeralNotebook({ notebookId, runtimePodName, runtimeOverride, cellSidebarMargin = 120, nbformat, onNbformatChange, toolbarComponent, themeVariant, colorMode, collaborationProvider, }) {
     // The `nbformat` passed to the `Notebook` component MUST stay a stable
     // reference for the lifetime of a given `notebookId`: the underlying
     // `useNotebookModel` hook rebuilds the notebook model (and its context /
@@ -77,18 +78,36 @@ export function EphemeralNotebook({ notebookId, runtimePodName, cellSidebarMargi
     // notebook must bind to exactly the runtime assigned to this agent, or to
     // none at all (straight path).
     const { runtimes, refetchRuntimes } = useAgentsRuntimes();
-    const selectedRuntime = useMemo(() => {
+    const podResolvedRuntime = useMemo(() => {
         const preferredPod = String(runtimePodName || '').trim();
         if (!preferredPod) {
             return undefined;
         }
         return runtimes.find(rt => String(rt?.pod_name || '') === preferredPod);
     }, [runtimePodName, runtimes]);
+    // An explicit endpoint override wins over the pod lookup: it lets a SaaS
+    // browser bind the kernel through the runtimes tunnel proxy (the node's
+    // Jupyter server is not directly reachable, so no pod exists in the list).
+    const selectedRuntime = useMemo(() => {
+        const overrideBaseUrl = String(runtimeOverride?.baseUrl || '').trim();
+        if (overrideBaseUrl) {
+            return {
+                url: overrideBaseUrl,
+                wsUrl: String(runtimeOverride?.wsUrl || '').trim() || undefined,
+                token: String(runtimeOverride?.token || '').trim(),
+                pod_name: String(runtimeOverride?.podName || '').trim() || 'agent-node-proxy',
+            };
+        }
+        return podResolvedRuntime;
+    }, [runtimeOverride, podResolvedRuntime]);
     // While the assigned pod has not yet appeared in the runtimes list, poll the
     // list quickly instead of waiting for the default (10s) refresh interval.
     // This is what makes the "Starting notebook…" state clear promptly once the
-    // agent runtime is ready, rather than lingering for several seconds.
-    const needsRuntimeLookup = Boolean(String(runtimePodName || '').trim() && !selectedRuntime);
+    // agent runtime is ready, rather than lingering for several seconds. The
+    // override path binds immediately, so no polling is needed there.
+    const needsRuntimeLookup = Boolean(!runtimeOverride?.baseUrl &&
+        String(runtimePodName || '').trim() &&
+        !selectedRuntime);
     useEffect(() => {
         if (!needsRuntimeLookup) {
             return;
@@ -120,9 +139,11 @@ export function EphemeralNotebook({ notebookId, runtimePodName, cellSidebarMargi
             }
             try {
                 const token = String(selectedRuntime?.token || '').trim();
+                const wsUrl = String(selectedRuntime?.wsUrl || '').trim() ||
+                    baseUrl.replace(/^http/, 'ws');
                 const serverSettings = ServerConnection.makeSettings({
                     baseUrl,
-                    wsUrl: baseUrl.replace(/^http/, 'ws'),
+                    wsUrl,
                     token,
                     appendToken: true,
                 });
@@ -155,7 +176,12 @@ export function EphemeralNotebook({ notebookId, runtimePodName, cellSidebarMargi
                 disposeServiceManager(manager);
             }
         };
-    }, [selectedRuntime?.pod_name, selectedRuntime?.url, selectedRuntime?.token]);
+    }, [
+        selectedRuntime?.pod_name,
+        selectedRuntime?.url,
+        selectedRuntime?.token,
+        selectedRuntime?.wsUrl,
+    ]);
     // Bind strictly to the agent runtime sandbox; there is NO local fallback
     // kernel. The notebook executes on the agent's runtime or shows a waiting
     // state until the runtime is ready.
@@ -163,9 +189,17 @@ export function EphemeralNotebook({ notebookId, runtimePodName, cellSidebarMargi
     const activeKernelId = runtimeKernelId;
     const activeStartDefaultKernel = runtimeStartDefaultKernel;
     const ToolbarComponent = toolbarComponent || NotebookToolbar;
-    const isRuntimeStarting = Boolean(String(runtimePodName || '').trim() && !activeServiceManager);
+    const isRuntimeStarting = Boolean((String(runtimePodName || '').trim() ||
+        String(runtimeOverride?.baseUrl || '').trim()) &&
+        !activeServiceManager);
     useProgressTask(`ephemeral-notebook-start-${notebookId}`, isRuntimeStarting);
     useEffect(() => {
+        // When a collaboration provider is active the shared ydoc is the single
+        // source of truth and is synced remotely; the local in-memory persistence
+        // poll would fight it, so it is disabled in that mode.
+        if (collaborationProvider) {
+            return;
+        }
         // Read the CURRENT live notebook model straight from the notebook store.
         // The `NotebookAdapter` exposes `notebook` (the widget, whose `.model` is
         // the `INotebookModel`) and `panel` (`panel.content.model`). There is NO
@@ -203,10 +237,12 @@ export function EphemeralNotebook({ notebookId, runtimePodName, cellSidebarMargi
     // Resolve the active theme/color-mode exactly like the notebook editor
     // (NotebookEditorPanel) so the notebook honours dark / branded themes
     // instead of always rendering light.
-    const { colorMode, theme: themeVariant } = useThemeStore();
+    const { colorMode: storeColorMode, theme: storeThemeVariant } = useThemeStore();
+    const effectiveColorMode = colorMode ?? storeColorMode;
+    const effectiveThemeVariant = themeVariant ?? storeThemeVariant;
     const systemMode = useSystemColorMode();
-    const themeConfig = getThemeConfig(themeVariant);
-    const resolvedMode = colorMode === 'auto' ? systemMode : colorMode;
+    const themeConfig = getThemeConfig(effectiveThemeVariant);
+    const resolvedMode = effectiveColorMode === 'auto' ? systemMode : effectiveColorMode;
     const modeStyles = resolvedMode === 'dark'
         ? themeConfig.themeStyles.dark
         : themeConfig.themeStyles.light;
@@ -219,7 +255,7 @@ export function EphemeralNotebook({ notebookId, runtimePodName, cellSidebarMargi
             position: 'relative',
             overflow: 'hidden',
             bg: 'canvas.default',
-        }, children: activeServiceManager ? (_jsx(DatalayerThemeProvider, { colorMode: colorMode, theme: themeConfig.primerTheme, themeStyles: themeConfig.themeStyles, children: _jsx(JupyterReactTheme, { colormode: resolvedMode, backgroundColor: themeBackground, children: _jsx(Box, { sx: {
+        }, children: activeServiceManager ? (_jsx(DatalayerThemeProvider, { colorMode: effectiveColorMode, theme: themeConfig.primerTheme, themeStyles: themeConfig.themeStyles, children: _jsx(JupyterReactTheme, { colormode: resolvedMode, backgroundColor: themeBackground, children: _jsx(Box, { sx: {
                         position: 'absolute',
                         inset: 0,
                         display: 'flex',
@@ -247,6 +283,6 @@ export function EphemeralNotebook({ notebookId, runtimePodName, cellSidebarMargi
                             flex: '1 1 auto',
                             minHeight: 0,
                         },
-                    }, children: _jsx(Notebook, { nbformat: initialNbformat, id: notebookId, serviceManager: activeServiceManager, startDefaultKernel: activeStartDefaultKernel, kernelId: activeKernelId, height: "100%", cellSidebarMargin: cellSidebarMargin, extensions: extensions, Toolbar: ToolbarComponent }) }) }) })) : null }));
+                    }, children: _jsx(Notebook, { nbformat: initialNbformat, id: notebookId, serviceManager: activeServiceManager, startDefaultKernel: activeStartDefaultKernel, kernelId: activeKernelId, height: "100%", cellSidebarMargin: cellSidebarMargin, extensions: extensions, Toolbar: ToolbarComponent, collaborationProvider: collaborationProvider }) }) }) })) : null }));
 }
 export default EphemeralNotebook;

package/lib/chat/prompt/InputPrompt.js

@@ -76,7 +76,7 @@ export function InputPrompt({ variant = 'text', placeholder = 'Ask anything…',
                     transition: 'border-color 0.2s ease',
                     '&:focus-within': {
                         borderColor: 'accent.fg',
-                        boxShadow: (t) => `0 0 0 1px ${t?.colors?.accent?.fg ?? '#0969da'}`,
+                        boxShadow: (t) => `0 0 0 1px ${t?.colors?.accent?.fg ?? '#16A085'}`,
                     },
                 }, children: [_jsx(InputPromptHeader, { children: headerContent }), variant === 'lexical' ? (_jsx(InputPromptLexical, { value: input, onChange: setInput, placeholder: placeholder, disabled: isLoading || disabled, readOnly: readOnly, onSubmit: handleSend, autoFocus: autoFocus })) : (_jsx(InputPromptText, { value: input, onChange: setInput, placeholder: placeholder, disabled: isLoading || disabled, readOnly: readOnly, onSubmit: handleSend, inputRef: inputRef })), _jsx(InputPromptFooter, { isLoading: isLoading, isKernelBusy: isKernelBusy, sendDisabled: !input.trim() || disabled || readOnly, onSend: handleSend, onStop: handleStop, rightContent: footerRightContent, children: footerContent })] }) }) }));
 }

package/lib/chat/tools/SubagentActivity.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Live subagent activity panel.
+ *
+ * Renders the streamed interaction timeline for a `delegate_task` tool call:
+ * text/thinking deltas, nested tool calls and results, and the final output.
+ * Events are sourced from the agent runtime store, keyed by the parent
+ * delegation tool call id.
+ *
+ * @module chat/tools/SubagentActivity
+ */
+import React from 'react';
+export interface SubagentActivityProps {
+    /** Parent `delegate_task` tool call id used to look up streamed events. */
+    toolCallId: string;
+}
+/**
+ * Displays the live activity timeline for a delegated subagent run.
+ * Renders nothing until the first event for `toolCallId` arrives.
+ */
+export declare function SubagentActivity({ toolCallId, }: SubagentActivityProps): React.ReactElement | null;

package/lib/chat/tools/SubagentActivity.js

@@ -0,0 +1,154 @@
+import { 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.
+ */
+/**
+ * Live subagent activity panel.
+ *
+ * Renders the streamed interaction timeline for a `delegate_task` tool call:
+ * text/thinking deltas, nested tool calls and results, and the final output.
+ * Events are sourced from the agent runtime store, keyed by the parent
+ * delegation tool call id.
+ *
+ * @module chat/tools/SubagentActivity
+ */
+import { useMemo, useState } from 'react';
+import { Text } from '@primer/react';
+import { Box } from '@datalayer/primer-addons';
+import { ChevronDownIcon, ChevronRightIcon, DependabotIcon, ToolsIcon, CheckCircleIcon, AlertIcon, LightBulbIcon, } from '@primer/octicons-react';
+import { useAgentRuntimeSubagentActivity } from '../../stores/agentRuntimeStore';
+/**
+ * Collapse the ordered event stream into render segments, merging consecutive
+ * text/thinking deltas into single blocks.
+ */
+function buildSegments(events) {
+    const segments = [];
+    for (const event of events) {
+        const phase = event.phase;
+        if (phase === 'text' || phase === 'thinking') {
+            const kind = phase;
+            const last = segments[segments.length - 1];
+            if (last && last.kind === kind) {
+                last.text = (last.text ?? '') + (event.text ?? '');
+            }
+            else {
+                segments.push({ kind, text: event.text ?? '' });
+            }
+        }
+        else if (phase === 'tool_call') {
+            segments.push({
+                kind: 'tool_call',
+                toolName: event.toolName,
+                toolArgs: event.toolArgs,
+            });
+        }
+        else if (phase === 'tool_result') {
+            segments.push({
+                kind: 'tool_result',
+                toolName: event.toolName,
+                result: event.result,
+            });
+        }
+        else if (phase === 'error') {
+            segments.push({ kind: 'error', error: event.error });
+        }
+        // `start` and `end` phases are represented by header/status, not segments.
+    }
+    return segments;
+}
+/**
+ * Displays the live activity timeline for a delegated subagent run.
+ * Renders nothing until the first event for `toolCallId` arrives.
+ */
+export function SubagentActivity({ toolCallId, }) {
+    const events = useAgentRuntimeSubagentActivity(toolCallId);
+    const [expanded, setExpanded] = useState(true);
+    const subagentName = useMemo(() => {
+        for (const event of events) {
+            if (event.subagentName)
+                return event.subagentName;
+        }
+        return 'subagent';
+    }, [events]);
+    const isDone = useMemo(() => events.some(e => e.phase === 'end' || e.phase === 'error'), [events]);
+    const hasError = useMemo(() => events.some(e => e.phase === 'error'), [events]);
+    const segments = useMemo(() => buildSegments(events), [events]);
+    if (events.length === 0) {
+        return null;
+    }
+    const StatusIcon = hasError
+        ? AlertIcon
+        : isDone
+            ? CheckCircleIcon
+            : DependabotIcon;
+    const statusColor = hasError
+        ? 'danger.fg'
+        : isDone
+            ? 'success.fg'
+            : 'accent.fg';
+    return (_jsxs(Box, { sx: {
+            mt: 1,
+            ml: 2,
+            borderLeft: '2px solid',
+            borderColor: 'border.muted',
+            pl: 2,
+        }, children: [_jsxs(Box, { as: "button", onClick: () => setExpanded(prev => !prev), sx: {
+                    display: 'flex',
+                    alignItems: 'center',
+                    gap: 1,
+                    width: '100%',
+                    border: 'none',
+                    background: 'transparent',
+                    cursor: 'pointer',
+                    p: 0,
+                    color: 'fg.muted',
+                    textAlign: 'left',
+                }, children: [expanded ? (_jsx(ChevronDownIcon, { size: 12 })) : (_jsx(ChevronRightIcon, { size: 12 })), _jsx(Box, { sx: { color: statusColor, display: 'flex' }, children: _jsx(StatusIcon, { size: 14 }) }), _jsx(Text, { sx: { fontSize: 0, fontWeight: 'bold', color: 'fg.default' }, children: subagentName }), _jsx(Text, { sx: { fontSize: 0, color: 'fg.muted' }, children: hasError ? 'failed' : isDone ? 'done' : 'working…' })] }), expanded && (_jsx(Box, { sx: { mt: 1, display: 'flex', flexDirection: 'column', gap: 1 }, children: segments.map((segment, index) => (_jsx(SubagentSegmentView, { segment: segment }, index))) }))] }));
+}
+function SubagentSegmentView({ segment, }) {
+    switch (segment.kind) {
+        case 'text':
+            if (!segment.text)
+                return null;
+            return (_jsx(Text, { sx: {
+                    fontSize: 0,
+                    color: 'fg.default',
+                    whiteSpace: 'pre-wrap',
+                    wordBreak: 'break-word',
+                }, children: segment.text }));
+        case 'thinking':
+            if (!segment.text)
+                return null;
+            return (_jsxs(Box, { sx: { display: 'flex', gap: 1, color: 'fg.muted' }, children: [_jsx(Box, { sx: { mt: '2px', flexShrink: 0 }, children: _jsx(LightBulbIcon, { size: 12 }) }), _jsx(Text, { sx: {
+                            fontSize: 0,
+                            fontStyle: 'italic',
+                            whiteSpace: 'pre-wrap',
+                            wordBreak: 'break-word',
+                        }, children: segment.text })] }));
+        case 'tool_call':
+            return (_jsxs(Box, { sx: { display: 'flex', gap: 1, color: 'fg.muted' }, children: [_jsx(Box, { sx: { mt: '2px', flexShrink: 0 }, children: _jsx(ToolsIcon, { size: 12 }) }), _jsxs(Box, { sx: { minWidth: 0 }, children: [_jsx(Text, { sx: { fontSize: 0, fontWeight: 'bold' }, children: segment.toolName ?? 'tool' }), segment.toolArgs && Object.keys(segment.toolArgs).length > 0 && (_jsx(Text, { as: "pre", sx: {
+                                    fontSize: 0,
+                                    fontFamily: 'mono',
+                                    m: 0,
+                                    mt: '2px',
+                                    whiteSpace: 'pre-wrap',
+                                    wordBreak: 'break-word',
+                                    color: 'fg.muted',
+                                }, children: JSON.stringify(segment.toolArgs) }))] })] }));
+        case 'tool_result':
+            if (!segment.result)
+                return null;
+            return (_jsxs(Box, { sx: { display: 'flex', gap: 1, color: 'fg.muted' }, children: [_jsx(Box, { sx: { mt: '2px', flexShrink: 0, color: 'success.fg' }, children: _jsx(CheckCircleIcon, { size: 12 }) }), _jsx(Text, { as: "pre", sx: {
+                            fontSize: 0,
+                            fontFamily: 'mono',
+                            m: 0,
+                            whiteSpace: 'pre-wrap',
+                            wordBreak: 'break-word',
+                        }, children: segment.result })] }));
+        case 'error':
+            return (_jsxs(Box, { sx: { display: 'flex', gap: 1, color: 'danger.fg' }, children: [_jsx(Box, { sx: { mt: '2px', flexShrink: 0 }, children: _jsx(AlertIcon, { size: 12 }) }), _jsx(Text, { sx: { fontSize: 0 }, children: segment.error ?? 'Subagent failed' })] }));
+        default:
+            return null;
+    }
+}

package/lib/chat/tools/index.d.ts

@@ -4,5 +4,6 @@
  * @module chat/tools
  */
 export { ToolCallDisplay, type ToolCallDisplayProps, type ErrorType, } from './ToolCallDisplay';
+export { SubagentActivity, type SubagentActivityProps, } from './SubagentActivity';
 export { ToolApprovalBanner, type ToolApprovalBannerProps, type PendingApproval, } from './ToolApprovalBanner';
 export { ToolApprovalDialog, useToolApprovalDialog, type ToolApprovalDialogProps, } from './ToolApprovalDialog';

package/lib/chat/tools/index.js

@@ -8,5 +8,6 @@
  * @module chat/tools
  */
 export { ToolCallDisplay, } from './ToolCallDisplay';
+export { SubagentActivity, } from './SubagentActivity';
 export { ToolApprovalBanner, } from './ToolApprovalBanner';
 export { ToolApprovalDialog, useToolApprovalDialog, } from './ToolApprovalDialog';

package/lib/chat/usage/TokenUsageBar.js

@@ -53,7 +53,7 @@ export function TokenUsageBar({ agentUsage, padding }) {
         const colorMap = {
             'System Prompts': '#8250df',
             'Tool Definitions': '#bf8700',
-            'User Messages': '#0969da',
+            'User Messages': '#16A085',
             'Assistant Messages': '#1a7f37',
             'Tool Usage': '#cf222e',
         };
@@ -86,7 +86,7 @@ export function TokenUsageBar({ agentUsage, padding }) {
             categories.push({
                 name: 'Messages',
                 value: messageTokens,
-                color: '#0969da',
+                color: '#16A085',
             });
         }
         const toolResultTokens = (agentUsage.toolCallTokens || 0) + (agentUsage.toolReturnTokens || 0);
@@ -99,7 +99,7 @@ export function TokenUsageBar({ agentUsage, padding }) {
         }
     }
     // Tiny filled pie chart options
-    const pieColor = pct > 90 ? '#cf222e' : pct > 70 ? '#bf8700' : '#0969da';
+    const pieColor = pct > 90 ? '#cf222e' : pct > 70 ? '#bf8700' : '#16A085';
     const freeSliceColor = 'var(--bgColor-muted, #f6f8fa)';
     const freeSliceOverlayColor = 'var(--borderColor-default, #d1d9e0)';
     const miniPieOption = {

package/lib/client/AgentRuntimesClient.d.ts

@@ -13,6 +13,7 @@ import type { SpaceDTO, UpdateSpaceRequest } from '../models/SpaceDTO';
 import type { NotebookDTO } from '../models/NotebookDTO';
 import type { LexicalDTO } from '../models/LexicalDTO';
 import type { ProjectDTO, ProjectDefaultItems } from '../models/ProjectDTO';
+import type { RuntimeMemory, ListRuntimeMemoriesOptions } from '../api/runtimes/runtimes';
 declare const AgentRuntimesClientWithMixins: {
     new (...args: any[]): {
         getMySpaces(): Promise<SpaceDTO[]>;
@@ -54,6 +55,8 @@ declare const AgentRuntimesClientWithMixins: {
         listRuntimes(): Promise<RuntimeDTO[]>;
         getRuntime(podName: string): Promise<RuntimeDTO>;
         deleteRuntime(podName: string): Promise<void>;
+        listRuntimeMemories(options?: ListRuntimeMemoriesOptions): Promise<RuntimeMemory[]>;
+        getRuntimeMemory(memoryId: string): Promise<RuntimeMemory>;
         terminateAllRuntimes(): Promise<PromiseSettledResult<void>[]>;
         createSnapshot(podName: string, name: string, description: string, stop?: boolean): Promise<CodeSandboxSnapshotDTO>;
         listSnapshots(): Promise<CodeSandboxSnapshotDTO[]>;
@@ -86,6 +89,8 @@ export interface AgentRuntimesClient extends DatalayerCoreClient {
     ensureRuntime(environmentName?: string, creditsLimit?: number, waitForReady?: boolean, maxWaitTime?: number, reuseExisting?: boolean, snapshotId?: string): Promise<RuntimeDTO>;
     createRuntime(environmentName: string, type: 'notebook' | 'terminal' | 'job', givenName: string, minutesLimit: number, fromSnapshotId?: string): Promise<RuntimeDTO>;
     listRuntimes(): Promise<RuntimeDTO[]>;
+    listRuntimeMemories(options?: ListRuntimeMemoriesOptions): Promise<RuntimeMemory[]>;
+    getRuntimeMemory(memoryId: string): Promise<RuntimeMemory>;
     getRuntime(podName: string): Promise<RuntimeDTO>;
     deleteRuntime(podName: string): Promise<void>;
     terminateAllRuntimes(): Promise<PromiseSettledResult<void>[]>;

package/lib/client/AgentsMixin.js

@@ -339,7 +339,9 @@ export function AgentsMixin(Base) {
                 method: 'POST',
                 token,
                 body: {
-                    environment_name: data.environmentName || 'ai-agents-env',
+                    environment: {
+                        name: data.environmentName || 'ai-agents-env',
+                    },
                     given_name: data.givenName || 'Agent',
                     credits_limit: data.creditsLimit || 10,
                     type: data.type || 'notebook',

package/lib/client/mixins/RuntimesMixin.d.ts

@@ -1,3 +1,4 @@
+import type { RuntimeMemory, ListRuntimeMemoriesOptions } from '../../api/runtimes/runtimes';
 import type { Constructor } from '@datalayer/core/lib/client/utils/mixins';
 import { EnvironmentDTO } from '../../models/EnvironmentDTO';
 import { RuntimeDTO } from '../../models/RuntimeDTO';
@@ -53,6 +54,17 @@ export declare function RuntimesMixin<TBase extends Constructor>(Base: TBase): {
          * @param podName - Runtime pod name
          */
         deleteRuntime(podName: string): Promise<void>;
+        /**
+         * List persisted memories for the authenticated caller.
+         *
+         * Backend scoping rules apply: non-admin callers are limited to their own
+         * personal account.
+         */
+        listRuntimeMemories(options?: ListRuntimeMemoriesOptions): Promise<RuntimeMemory[]>;
+        /**
+         * Fetch one persisted memory by id.
+         */
+        getRuntimeMemory(memoryId: string): Promise<RuntimeMemory>;
         /**
          * Terminate all runtimes.
          * Lists all runtimes and deletes them in parallel.

package/lib/client/mixins/RuntimesMixin.js

@@ -69,7 +69,9 @@ export function RuntimesMixin(Base) {
                     const runtimesUrl = this.getRuntimesUrl();
                     const creditsLimit = this.calculateCreditsFromMinutes(minutesLimit, env.burningRate);
                     const data = {
-                        environment_name: environmentName,
+                        environment: {
+                            name: environmentName,
+                        },
                         type,
                         given_name: givenName,
                         credits_limit: creditsLimit,
@@ -113,6 +115,27 @@ export function RuntimesMixin(Base) {
             const runtimesUrl = this.getRuntimesUrl();
             await runtimes.deleteRuntime(token, podName, runtimesUrl);
         }
+        /**
+         * List persisted memories for the authenticated caller.
+         *
+         * Backend scoping rules apply: non-admin callers are limited to their own
+         * personal account.
+         */
+        async listRuntimeMemories(options = {}) {
+            const token = this.getToken();
+            const runtimesUrl = this.getRuntimesUrl();
+            const response = await runtimes.listRuntimeMemories(token, options, runtimesUrl);
+            return response.memories;
+        }
+        /**
+         * Fetch one persisted memory by id.
+         */
+        async getRuntimeMemory(memoryId) {
+            const token = this.getToken();
+            const runtimesUrl = this.getRuntimesUrl();
+            const response = await runtimes.getRuntimeMemory(token, memoryId, runtimesUrl);
+            return response.memory;
+        }
         /**
          * Terminate all runtimes.
          * Lists all runtimes and deletes them in parallel.

package/lib/components/AgentSummary.d.ts

@@ -5,6 +5,7 @@ export interface AgentSummaryData {
     specId?: string;
     status?: string;
     baseUrl?: string;
+    sandboxBaseUrl?: string;
     agentId?: string;
     isReady?: boolean;
     error?: string;

package/lib/components/AgentSummary.js

@@ -3,9 +3,10 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
  * Copyright (c) 2025-2026 Datalayer, Inc.
  * Distributed under the terms of the Modified BSD License.
  */
-import { useState } from 'react';
+import { useEffect, useRef, useState } from 'react';
 import { Spinner } from '@primer/react';
 import { Box } from '@datalayer/primer-addons';
+import { strip } from '@datalayer/core/lib/utils';
 /**
  * Statuses that represent an agent actively being created/started. The spinner
  * only shows for these; app-navigation states ("selected", "switching") and
@@ -19,20 +20,61 @@ const CREATING_STATUSES = new Set([
     'pending',
     'resuming',
 ]);
+const MAX_AGENT_NAME_LENGTH = 32;
+const toSandboxStatusUrl = (value) => {
+    const raw = String(value || '').trim();
+    if (!raw) {
+        return undefined;
+    }
+    try {
+        const parsed = new URL(raw);
+        parsed.pathname = `${parsed.pathname.replace(/\/$/, '')}/api`;
+        return parsed.toString();
+    }
+    catch {
+        const normalized = raw.replace(/\/$/, '');
+        return normalized.endsWith('/api') ? normalized : `${normalized}/api`;
+    }
+};
 /**
  * Compact agent summary badge with a hover overlay for details.
  */
 export const AgentSummary = ({ summary, title = 'Active Agent', }) => {
     const [isHovering, setIsHovering] = useState(false);
-    const runtimeStatusUrl = summary?.baseUrl
+    const closeTimerRef = useRef(null);
+    const clearCloseTimer = () => {
+        if (closeTimerRef.current !== null) {
+            window.clearTimeout(closeTimerRef.current);
+            closeTimerRef.current = null;
+        }
+    };
+    const handleMouseEnter = () => {
+        clearCloseTimer();
+        setIsHovering(true);
+    };
+    const handleMouseLeave = () => {
+        clearCloseTimer();
+        closeTimerRef.current = window.setTimeout(() => {
+            setIsHovering(false);
+            closeTimerRef.current = null;
+        }, 300);
+    };
+    useEffect(() => {
+        return () => {
+            clearCloseTimer();
+        };
+    }, []);
+    // Agent status is served by the agent-runtimes API server.
+    const apiBase = summary?.baseUrl
         ? (() => {
             const normalized = summary.baseUrl.replace(/\/$/, '');
-            if (normalized.endsWith('/api/v1')) {
-                return `${normalized}/runtime/status`;
-            }
-            return `${normalized}/api/v1/runtime/status`;
+            return normalized.endsWith('/api/v1')
+                ? normalized
+                : `${normalized}/api/v1`;
         })()
         : undefined;
+    const agentStatusUrl = apiBase ? `${apiBase}/runtime/status` : undefined;
+    const sandboxStatusUrl = toSandboxStatusUrl(summary?.sandboxBaseUrl);
     if (!summary) {
         return null;
     }
@@ -43,9 +85,17 @@ export const AgentSummary = ({ summary, title = 'Active Agent', }) => {
         !summary.agentId &&
         CREATING_STATUSES.has(normalizedStatus);
     const hasError = Boolean(summary.error);
-    return (_jsxs(Box, { sx: { position: 'relative' }, onMouseEnter: () => setIsHovering(true), onMouseLeave: () => setIsHovering(false), children: [_jsxs(Box, { as: "button", type: "button", sx: {
+    // The agent is optional: some examples run only a code sandbox. Show the
+    // agent status when there is an agent (or one is being created).
+    const hasAgent = Boolean(summary.agentId) || isCreating;
+    const shortAgentName = strip(summary.agentName, MAX_AGENT_NAME_LENGTH);
+    const badgeLabel = `${summary.agentName} · ${summary.location}`;
+    const badgeLabelShort = `${shortAgentName} · ${summary.location}`;
+    return (_jsxs(Box, { sx: { position: 'relative' }, onMouseEnter: handleMouseEnter, onMouseLeave: handleMouseLeave, children: [_jsxs(Box, { as: "button", type: "button", title: badgeLabel, sx: {
                     px: 2,
                     py: '6px',
+                    maxWidth: 280,
+                    minWidth: 0,
                     border: '1px solid',
                     borderColor: hasError ? 'danger.emphasis' : 'border.default',
                     borderRadius: 2,
@@ -56,7 +106,13 @@ export const AgentSummary = ({ summary, title = 'Active Agent', }) => {
                     display: 'flex',
                     alignItems: 'center',
                     gap: 1,
-                }, children: [isCreating && _jsx(Spinner, { size: "small", sx: { width: 12, height: 12 } }), hasError && _jsx("span", { "aria-hidden": true, children: "\u26A0" }), summary.agentName, " \u00B7 ", summary.location] }), isHovering && (_jsxs(Box, { sx: {
+                }, children: [isCreating && _jsx(Spinner, { size: "small", sx: { width: 12, height: 12 } }), hasError && _jsx("span", { "aria-hidden": true, children: "\u26A0" }), _jsx(Box, { as: "span", sx: {
+                            display: 'block',
+                            minWidth: 0,
+                            overflow: 'hidden',
+                            textOverflow: 'ellipsis',
+                            whiteSpace: 'nowrap',
+                        }, children: badgeLabelShort })] }), isHovering && (_jsxs(Box, { sx: {
                     position: 'absolute',
                     top: 'calc(100% + 8px)',
                     right: 0,
@@ -70,13 +126,13 @@ export const AgentSummary = ({ summary, title = 'Active Agent', }) => {
                     zIndex: 120,
                     fontSize: 0,
                     color: 'fg.default',
-                }, children: [_jsx(Box, { sx: { mb: 1, fontWeight: 600 }, children: title }), _jsxs(Box, { sx: { color: 'fg.muted' }, children: ["Name: ", summary.agentName] }), _jsxs(Box, { sx: { color: 'fg.muted' }, children: ["Location: ", summary.location] }), _jsxs(Box, { sx: { color: 'fg.muted' }, children: ["Spec: ", summary.specId || '—'] }), _jsxs(Box, { sx: { color: 'fg.muted' }, children: ["Status: ", isCreating ? 'creating' : summary.status || '—'] }), _jsxs(Box, { sx: { color: 'fg.muted', wordBreak: 'break-all' }, children: ["Base URL: ", summary.baseUrl || '—'] }), _jsxs(Box, { sx: {
+                }, children: [_jsx(Box, { sx: { mb: 1, fontWeight: 600 }, children: title }), _jsxs(Box, { sx: { color: 'fg.muted' }, children: ["Name: ", summary.agentName] }), _jsxs(Box, { sx: { color: 'fg.muted' }, children: ["Location: ", summary.location] }), _jsxs(Box, { sx: { color: 'fg.muted' }, children: ["Spec: ", summary.specId || '—'] }), _jsxs(Box, { sx: { color: 'fg.muted' }, children: ["Status: ", isCreating ? 'creating' : summary.status || '—'] }), _jsxs(Box, { sx: { color: 'fg.muted', wordBreak: 'break-all' }, children: ["Agent base URL: ", summary.baseUrl || '—'] }), _jsxs(Box, { sx: { color: 'fg.muted', wordBreak: 'break-all' }, children: ["Code sandbox base URL:", ' ', summary.sandboxBaseUrl ? (_jsx(Box, { as: "a", href: summary.sandboxBaseUrl, target: "_blank", rel: "noopener noreferrer", sx: { color: 'accent.fg', textDecoration: 'underline' }, children: summary.sandboxBaseUrl })) : ('—')] }), _jsxs(Box, { sx: {
                             color: 'fg.muted',
                             wordBreak: 'break-all',
                             display: 'flex',
                             alignItems: 'center',
                             gap: 1,
-                        }, children: ["Agent ID:", ' ', summary.agentId ? (summary.agentId) : isCreating ? (_jsxs(_Fragment, { children: [_jsx(Spinner, { size: "small", sx: { width: 12, height: 12 } }), "Creating\u2026"] })) : ('—')] }), _jsxs(Box, { sx: { color: 'fg.muted', wordBreak: 'break-all' }, children: ["Runtime status:", ' ', runtimeStatusUrl ? (_jsx(Box, { as: "a", href: runtimeStatusUrl, target: "_blank", rel: "noopener noreferrer", sx: { color: 'accent.fg', textDecoration: 'underline' }, children: runtimeStatusUrl })) : ('n/a')] }), hasError && (_jsxs(Box, { sx: {
+                        }, children: ["Agent ID:", ' ', summary.agentId ? (summary.agentId) : isCreating ? (_jsxs(_Fragment, { children: [_jsx(Spinner, { size: "small", sx: { width: 12, height: 12 } }), "Creating\u2026"] })) : ('—')] }), _jsxs(Box, { sx: { color: 'fg.muted', wordBreak: 'break-all' }, children: ["Agent status:", ' ', hasAgent && agentStatusUrl ? (_jsx(Box, { as: "a", href: agentStatusUrl, target: "_blank", rel: "noopener noreferrer", sx: { color: 'accent.fg', textDecoration: 'underline' }, children: agentStatusUrl })) : ('n/a')] }), _jsxs(Box, { sx: { color: 'fg.muted', wordBreak: 'break-all' }, children: ["Code sandbox status:", ' ', sandboxStatusUrl ? (_jsx(Box, { as: "a", href: sandboxStatusUrl, target: "_blank", rel: "noopener noreferrer", sx: { color: 'accent.fg', textDecoration: 'underline' }, children: sandboxStatusUrl })) : ('n/a')] }), hasError && (_jsxs(Box, { sx: {
                             mt: 1,
                             p: 1,
                             border: '1px solid',