@datalayer/agent-runtimes 1.0.19 → 1.0.20

package/lib/examples/utils/useExampleAgentRuntimesUrl.js

@@ -20,7 +20,8 @@ export function resolveExampleAgentRuntimesUrl(target, override) {
     if (override) {
         return normalizeBaseUrl(override) ?? override;
     }
-    const localUrl = normalizeBaseUrl(import.meta.env.VITE_BASE_URL) ?? LOCAL_DEFAULT;
+    const localUrl = normalizeBaseUrl(import.meta.env.VITE_DATALAYER_AGENT_RUNTIMES_URL) ??
+        LOCAL_DEFAULT;
     const cloudUrl = normalizeBaseUrl(import.meta.env.VITE_DATALAYER_AGENT_RUNTIMES_URL) ??
         normalizeBaseUrl(import.meta.env.VITE_DATALAYER_RUNTIMES_URL) ??
         CLOUD_DEFAULT;

package/lib/examples2/NotebookMutationsKernel.js

@@ -7,11 +7,13 @@ import { useState } from 'react';
 import { createRoot } from 'react-dom/client';
 import { Box, SegmentedControl, Label, Text } from '@primer/react';
 import { ServiceManager } from '@jupyterlab/services';
-import { createLiteServiceManager, createServerSettings, setJupyterServerUrl, getJupyterServerUrl, getJupyterServerToken, ServiceManagerLess, loadJupyterConfig, DEFAULT_JUPYTER_SERVER_URL, useNotebookStore, Notebook, SpinnerCentered, JupyterReactTheme, } from '@datalayer/jupyter-react';
+import { createLiteServiceManager, createServerSettings, setJupyterServerUrl, getJupyterServerUrl, getJupyterServerToken, setJupyterServerToken, ServiceManagerLess, loadJupyterConfig, useNotebookStore, Notebook, SpinnerCentered, JupyterReactTheme, } from '@datalayer/jupyter-react';
 import { useCoreStore } from '../state';
 import { createDatalayerServiceManager } from '../services/DatalayerServiceManager';
 import nbformatExample from './notebooks/NotebookExample1.ipynb.json';
 const NOTEBOOK_ID = 'notebook-mutations-id';
+const LOCAL_JUPYTER_SERVER_URL = 'http://0.0.0.0:8888/api/jupyter-server';
+const LOCAL_JUPYTER_SERVER_TOKEN = '60c1661cc408f978c309d04157af55c9588ff9557c9380e4fb50785750703da6';
 loadJupyterConfig();
 const SERVICE_MANAGER_LESS = new ServiceManagerLess();
 const NotebookMutationsKernel = () => {
@@ -36,6 +38,7 @@ const NotebookMutationsKernel = () => {
     };
     const changeIndex = (index) => {
         setIndex(index);
+        setJupyterServerToken(getJupyterServerToken() || LOCAL_JUPYTER_SERVER_TOKEN);
         switch (index) {
             case 0: {
                 setNbformat(getCurrentNotebookContent());
@@ -45,7 +48,7 @@ const NotebookMutationsKernel = () => {
                 break;
             }
             case 1: {
-                setJupyterServerUrl(location.protocol + '//' + location.host);
+                setJupyterServerUrl(LOCAL_JUPYTER_SERVER_URL);
                 createLiteServiceManager().then(liteServiceManager => {
                     setServiceManager(liteServiceManager);
                     setNbformat(getCurrentNotebookContent());
@@ -55,7 +58,7 @@ const NotebookMutationsKernel = () => {
                 break;
             }
             case 2: {
-                setJupyterServerUrl(DEFAULT_JUPYTER_SERVER_URL);
+                setJupyterServerUrl(LOCAL_JUPYTER_SERVER_URL);
                 setNbformat(getCurrentNotebookContent());
                 setReadonly(false);
                 setLite(false);

package/lib/examples2/NotebookMutationsServiceManager.js

@@ -7,11 +7,13 @@ import { useState } from 'react';
 import { createRoot } from 'react-dom/client';
 import { Box, SegmentedControl, Label, Text } from '@primer/react';
 import { ServiceManager } from '@jupyterlab/services';
-import { createLiteServiceManager, createServerSettings, setJupyterServerUrl, getJupyterServerUrl, getJupyterServerToken, ServiceManagerLess, loadJupyterConfig, DEFAULT_JUPYTER_SERVER_URL, useNotebookStore, Notebook, SpinnerCentered, JupyterReactTheme, } from '@datalayer/jupyter-react';
+import { createLiteServiceManager, createServerSettings, setJupyterServerUrl, getJupyterServerUrl, getJupyterServerToken, setJupyterServerToken, ServiceManagerLess, loadJupyterConfig, useNotebookStore, Notebook, SpinnerCentered, JupyterReactTheme, } from '@datalayer/jupyter-react';
 import { useCoreStore } from '../state';
 import { createDatalayerServiceManager } from '../services/DatalayerServiceManager';
 import nbformatExample from './notebooks/NotebookExample1.ipynb.json';
 const NOTEBOOK_ID = 'notebook-mutations-id';
+const LOCAL_JUPYTER_SERVER_URL = 'http://0.0.0.0:8888/api/jupyter-server';
+const LOCAL_JUPYTER_SERVER_TOKEN = '60c1661cc408f978c309d04157af55c9588ff9557c9380e4fb50785750703da6';
 loadJupyterConfig();
 const SERVICE_MANAGER_LESS = new ServiceManagerLess();
 const NotebookMutationsServiceManager = () => {
@@ -36,6 +38,7 @@ const NotebookMutationsServiceManager = () => {
     };
     const changeIndex = (index) => {
         setIndex(index);
+        setJupyterServerToken(getJupyterServerToken() || LOCAL_JUPYTER_SERVER_TOKEN);
         switch (index) {
             case 0: {
                 setNbformat(getCurrentNotebookContent());
@@ -45,7 +48,7 @@ const NotebookMutationsServiceManager = () => {
                 break;
             }
             case 1: {
-                setJupyterServerUrl(location.protocol + '//' + location.host);
+                setJupyterServerUrl(LOCAL_JUPYTER_SERVER_URL);
                 createLiteServiceManager().then(liteServiceManager => {
                     setServiceManager(liteServiceManager);
                     setNbformat(getCurrentNotebookContent());
@@ -55,7 +58,7 @@ const NotebookMutationsServiceManager = () => {
                 break;
             }
             case 2: {
-                setJupyterServerUrl(DEFAULT_JUPYTER_SERVER_URL);
+                setJupyterServerUrl(LOCAL_JUPYTER_SERVER_URL);
                 setNbformat(getCurrentNotebookContent());
                 setReadonly(false);
                 setLite(false);

package/lib/examples2/ReactRouterExample.js

@@ -76,23 +76,23 @@ const Layout = () => {
                     mb: 3,
                 }, children: _jsxs(Box, { sx: { display: 'flex', gap: 3, flexWrap: 'wrap' }, children: [_jsx(NavLink, { to: "/", style: ({ isActive }) => ({
                                 fontWeight: isActive ? 'bold' : 'normal',
-                                color: isActive ? '#0969da' : 'inherit',
+                                color: isActive ? '#16A085' : 'inherit',
                                 textDecoration: 'none',
                             }), children: "Home" }), _jsx(NavLink, { to: "/dashboard", style: ({ isActive }) => ({
                                 fontWeight: isActive ? 'bold' : 'normal',
-                                color: isActive ? '#0969da' : 'inherit',
+                                color: isActive ? '#16A085' : 'inherit',
                                 textDecoration: 'none',
                             }), children: "Dashboard" }), _jsx(NavLink, { to: "/products", style: ({ isActive }) => ({
                                 fontWeight: isActive ? 'bold' : 'normal',
-                                color: isActive ? '#0969da' : 'inherit',
+                                color: isActive ? '#16A085' : 'inherit',
                                 textDecoration: 'none',
                             }), children: "Products" }), _jsx(NavLink, { to: "/users/john-doe", style: ({ isActive }) => ({
                                 fontWeight: isActive ? 'bold' : 'normal',
-                                color: isActive ? '#0969da' : 'inherit',
+                                color: isActive ? '#16A085' : 'inherit',
                                 textDecoration: 'none',
                             }), children: "User Profile" }), _jsx(NavLink, { to: "/settings", style: ({ isActive }) => ({
                                 fontWeight: isActive ? 'bold' : 'normal',
-                                color: isActive ? '#0969da' : 'inherit',
+                                color: isActive ? '#16A085' : 'inherit',
                                 textDecoration: 'none',
                             }), children: "Settings" })] }) }), _jsx(NavigationLogger, {}), _jsx(NavigationControls, {}), _jsx(Box, { sx: {
                     p: 3,

package/lib/examples2/main.js

@@ -15,6 +15,8 @@ import { createDatalayerServiceManager } from '../services/DatalayerServiceManag
 import { BOOTSTRAP_USER_ONBOARDING } from '@datalayer/core/lib/models/UserOnboarding';
 import nbformatExample from './notebooks/NotebookExample1.ipynb.json';
 const DEFAULT_RUNTIMES_URL = 'https://r1.datalayer.run';
+const DEFAULT_LOCAL_JUPYTER_SERVER_URL = 'http://0.0.0.0:8888/api/jupyter-server';
+const DEFAULT_LOCAL_JUPYTER_SERVER_TOKEN = '60c1661cc408f978c309d04157af55c9588ff9557c9380e4fb50785750703da6';
 const resolveRuntimesUrl = (configured) => {
     const envRuntimeUrl = import.meta.env.VITE_DATALAYER_RUNTIMES_URL;
     const envBaseUrl = import.meta.env.VITE_DATALAYER_URL;
@@ -27,6 +29,34 @@ const resolveRuntimesUrl = (configured) => {
     }
     return candidate.replace(/\/$/, '');
 };
+const isProd1JupyterServerUrl = (value) => {
+    if (!value) {
+        return false;
+    }
+    try {
+        return new URL(value).hostname === 'prod1.datalayer.run';
+    }
+    catch {
+        return value.includes('prod1.datalayer.run');
+    }
+};
+const resolveLocalJupyterServerUrl = () => {
+    const envLocalUrl = import.meta.env.VITE_JUPYTER_SERVER_URL?.trim();
+    if (envLocalUrl) {
+        return envLocalUrl.replace(/\/$/, '');
+    }
+    const configured = getJupyterServerUrl();
+    if (configured && !isProd1JupyterServerUrl(configured)) {
+        return configured;
+    }
+    return DEFAULT_LOCAL_JUPYTER_SERVER_URL;
+};
+const ensureLocalJupyterToken = () => {
+    const token = (getJupyterServerToken() || '').trim();
+    if (!token) {
+        setJupyterServerToken(DEFAULT_LOCAL_JUPYTER_SERVER_TOKEN);
+    }
+};
 // Load configurations from DOM
 const loadConfigurations = () => {
     // Load Datalayer configuration
@@ -148,6 +178,8 @@ const NotebookOnlyApp = () => {
                     }
                     catch (error) {
                         console.error('Failed to create DatalayerServiceManager:', error);
+                        setJupyterServerUrl(resolveLocalJupyterServerUrl());
+                        ensureLocalJupyterToken();
                         const serverSettings = createServerSettings(getJupyterServerUrl(), getJupyterServerToken());
                         const manager = new ServiceManager({ serverSettings });
                         await manager.ready;
@@ -155,6 +187,8 @@ const NotebookOnlyApp = () => {
                     }
                 }
                 else {
+                    setJupyterServerUrl(resolveLocalJupyterServerUrl());
+                    ensureLocalJupyterToken();
                     const serverSettings = createServerSettings(getJupyterServerUrl(), getJupyterServerToken());
                     const manager = new ServiceManager({ serverSettings });
                     await manager.ready;
@@ -238,6 +272,8 @@ export const ExampleApp = () => {
                     catch (error) {
                         console.error('Failed to create DatalayerServiceManager:', error);
                         // Fall back to regular ServiceManager
+                        setJupyterServerUrl(resolveLocalJupyterServerUrl());
+                        ensureLocalJupyterToken();
                         const serverSettings = createServerSettings(getJupyterServerUrl(), getJupyterServerToken());
                         const manager = new ServiceManager({ serverSettings });
                         await manager.ready;
@@ -248,6 +284,8 @@ export const ExampleApp = () => {
                 }
                 else {
                     // Use regular ServiceManager (no Datalayer token)
+                    setJupyterServerUrl(resolveLocalJupyterServerUrl());
+                    ensureLocalJupyterToken();
                     const serverSettings = createServerSettings(getJupyterServerUrl(), getJupyterServerToken());
                     const manager = new ServiceManager({ serverSettings });
                     await manager.ready;

package/lib/hooks/useAIAgentsWebSocket.js

@@ -43,6 +43,10 @@ function redactWsUrl(wsUrl) {
 }
 // ─── Hook ────────────────────────────────────────────────────────────
 const RECONNECT_DELAY_MS = 3_000;
+// Buffer outgoing messages sent while the socket is briefly down (e.g. a user
+// approves during an auto-reconnect window) and flush them once reconnected.
+const OUTBOUND_QUEUE_TTL_MS = 30_000;
+const OUTBOUND_QUEUE_MAX = 50;
 const WS_DEFAULT_PATH = `${API_BASE_PATHS.AI_AGENTS}/ws`;
 const isDevTraceEnabled = () => {
     try {
@@ -86,6 +90,7 @@ export function useAIAgentsWebSocket(options) {
     const [reconnectAttempt, setReconnectAttempt] = useState(0);
     const wsRef = useRef(null);
     const reconnectTimer = useRef(null);
+    const outboundQueueRef = useRef([]);
     // Keep a ref of channels so we can re-subscribe on reconnect without
     // tearing down the socket when the array reference changes.
     const channelsRef = useRef(options?.channels ?? []);
@@ -143,6 +148,23 @@ export function useAIAgentsWebSocket(options) {
                 if (channels.length > 0) {
                     ws.send(JSON.stringify({ subscribe: { channels } }));
                 }
+                // Flush messages buffered while the socket was down (dropping any
+                // that have exceeded their TTL) so decisions aren't lost on a blip.
+                const now = Date.now();
+                const queued = outboundQueueRef.current;
+                outboundQueueRef.current = [];
+                for (const item of queued) {
+                    if (item.expiresAt < now)
+                        continue;
+                    try {
+                        ws.send(typeof item.payload === 'string'
+                            ? item.payload
+                            : JSON.stringify(item.payload));
+                    }
+                    catch {
+                        // Drop on serialization/send failure.
+                    }
+                }
             };
             ws.onmessage = ev => {
                 let raw;
@@ -289,6 +311,19 @@ export function useAIAgentsWebSocket(options) {
         send: (payload) => {
             const ws = wsRef.current;
             if (!ws || ws.readyState !== WebSocket.OPEN) {
+                // Not open: buffer for delivery on the next (auto)reconnect so a click
+                // during a transient drop isn't lost. Only when a reconnect is coming.
+                if (enabled && token && autoReconnectRef.current) {
+                    const queue = outboundQueueRef.current;
+                    if (queue.length >= OUTBOUND_QUEUE_MAX) {
+                        queue.shift();
+                    }
+                    queue.push({
+                        payload,
+                        expiresAt: Date.now() + OUTBOUND_QUEUE_TTL_MS,
+                    });
+                    return true;
+                }
                 return false;
             }
             try {

package/lib/hooks/useAgentRuntimes.d.ts

@@ -94,6 +94,28 @@ export declare const agentQueryKeys: {
 export declare function markRuntimePodDeleted(podName: string): void;
 /** Clear a deleted-pod tombstone (pod legitimately exists again). */
 export declare function clearRuntimePodDeleted(podName: string): void;
+export interface AgentSandboxConnectionInfo {
+    baseUrl: string;
+    agentId?: string;
+    agentBaseUrl?: string;
+    runtimeEnvironment?: RuntimeEnvironmentDetails;
+}
+export interface RuntimeEnvironmentDetails {
+    environmentName?: string;
+    environmentTitle?: string;
+    cpu?: string;
+    memory?: string;
+    gpu?: string;
+}
+export declare function getServiceManagerRuntimeEnvironmentDetails(manager: ServiceManager.IManager | null | undefined): RuntimeEnvironmentDetails | undefined;
+/**
+ * Connect a Jupyter ServiceManager to an already-running agent sandbox.
+ *
+ * This is the preferred cloud path when an agent runtime already exists:
+ * resolve sandbox status from the agent API, then bind directly to the
+ * returned Jupyter ingress URL/token instead of creating a new runtime.
+ */
+export declare function createServiceManagerFromAgentSandbox(info: AgentSandboxConnectionInfo, authToken?: string): Promise<ServiceManager.IManager>;
 /**
  * Hook for managing agent runtimes.
  *

package/lib/hooks/useAgentRuntimes.js

@@ -12,6 +12,7 @@
  * @module hooks/useAgentRuntimes
  */
 import { useState, useCallback, useMemo, useEffect, useRef } from 'react';
+import { ServerConnection } from '@jupyterlab/services';
 import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
 import { create } from 'zustand';
 import { persist, createJSONStorage } from 'zustand/middleware';
@@ -21,6 +22,7 @@ import { runtimesStore } from '../state';
 import { agentRuntimeStore, useAgentRuntimeStore, useAgentRuntimeConnection, useAgentRuntimeStatus, useAgentRuntimeError, useAgentRuntimeIsLaunching, } from '../stores/agentRuntimeStore';
 import { parseAgentStreamMessage, } from '../types/stream';
 import { DEFAULT_AGENT_CONFIG } from '../types/config';
+import { ServiceManager } from '@jupyterlab/services/lib/manager';
 import { disposeSandboxServiceManagers } from '../services/sandboxServiceManagers';
 // ═══════════════════════════════════════════════════════════════════════════
 // Constants
@@ -115,6 +117,173 @@ const RUNTIME_STATUS_MAP = {
     archived: 'archived',
     running: 'running',
 };
+const RUNTIME_ENVIRONMENT_META_KEY = '__datalayerRuntimeEnvironmentDetails';
+function resolveSandboxIngress(payload) {
+    const direct = String(payload.jupyter_url || '').trim();
+    if (direct) {
+        return direct;
+    }
+    const nested = String(payload.sandbox?.jupyter_url || '').trim();
+    if (nested) {
+        return nested;
+    }
+    return '';
+}
+function resolveSandboxToken(payload) {
+    const direct = String(payload.jupyter_token || payload.token || '').trim();
+    if (direct) {
+        return direct;
+    }
+    return String(payload.sandbox?.jupyter_token || payload.sandbox?.token || '').trim();
+}
+function toOptionalString(value) {
+    const normalized = String(value || '').trim();
+    return normalized || undefined;
+}
+function resolveGpuLabel(resources) {
+    if (!resources) {
+        return undefined;
+    }
+    const gpuCount = toOptionalString(resources.gpu) ||
+        toOptionalString(resources.gpu_count) ||
+        toOptionalString(resources['nvidia.com/gpu']);
+    const gpuType = toOptionalString(resources.gpu_type);
+    const gpuMemory = toOptionalString(resources.gpu_memory);
+    const parts = [gpuCount, gpuType, gpuMemory].filter(Boolean);
+    return parts.length > 0 ? parts.join(' ') : undefined;
+}
+function resolveRuntimeEnvironmentDetails(payload, seed) {
+    const environment = payload?.environment;
+    const resources = environment?.resources;
+    const environmentName = toOptionalString(seed?.environmentName) ||
+        toOptionalString(environment?.name);
+    const environmentTitle = toOptionalString(seed?.environmentTitle) ||
+        toOptionalString(environment?.title);
+    const cpu = toOptionalString(seed?.cpu) ||
+        toOptionalString(environment?.cpu) ||
+        toOptionalString(resources?.cpu);
+    const memory = toOptionalString(seed?.memory) ||
+        toOptionalString(environment?.memory) ||
+        toOptionalString(resources?.memory);
+    const gpu = toOptionalString(seed?.gpu) ||
+        toOptionalString(environment?.gpu) ||
+        resolveGpuLabel(resources);
+    if (!environmentName && !environmentTitle && !cpu && !memory && !gpu) {
+        return undefined;
+    }
+    return {
+        environmentName,
+        environmentTitle,
+        cpu,
+        memory,
+        gpu,
+    };
+}
+export function getServiceManagerRuntimeEnvironmentDetails(manager) {
+    if (!manager) {
+        return undefined;
+    }
+    const carrier = manager;
+    return carrier[RUNTIME_ENVIRONMENT_META_KEY];
+}
+function isInternalHost(value) {
+    const host = String(value || '')
+        .trim()
+        .toLowerCase();
+    return host === '127.0.0.1' || host === '0.0.0.0' || host === 'localhost';
+}
+/**
+ * Connect a Jupyter ServiceManager to an already-running agent sandbox.
+ *
+ * This is the preferred cloud path when an agent runtime already exists:
+ * resolve sandbox status from the agent API, then bind directly to the
+ * returned Jupyter ingress URL/token instead of creating a new runtime.
+ */
+export async function createServiceManagerFromAgentSandbox(info, authToken) {
+    const fallbackIngress = String(info.baseUrl || '').trim();
+    if (!fallbackIngress) {
+        throw new Error('Cloud agent sandbox base URL is missing.');
+    }
+    let resolvedIngress = fallbackIngress;
+    let tokenFromStatus = '';
+    let payloadFromStatus = null;
+    const agentBaseUrl = String(info.agentBaseUrl || '')
+        .trim()
+        .replace(/\/$/, '');
+    const agentId = String(info.agentId || '').trim();
+    const bearer = String(authToken || '').trim();
+    if (agentBaseUrl && agentId && bearer) {
+        const statusCandidates = [
+            `${agentBaseUrl}/api/v1/runtime/status?agent_id=${encodeURIComponent(agentId)}`,
+        ];
+        for (const statusUrl of statusCandidates) {
+            try {
+                const response = await fetch(statusUrl, {
+                    headers: {
+                        Authorization: `Bearer ${bearer}`,
+                    },
+                });
+                if (!response.ok) {
+                    continue;
+                }
+                const payload = (await response
+                    .json()
+                    .catch(() => null));
+                if (!payload) {
+                    continue;
+                }
+                payloadFromStatus = payload;
+                const ingressFromStatus = resolveSandboxIngress(payload);
+                if (ingressFromStatus) {
+                    try {
+                        const parsed = new URL(ingressFromStatus);
+                        // Cloud sandboxes can report an internal localhost URL in runtime
+                        // status; do not override the known cloud ingress with that host.
+                        if (!isInternalHost(parsed.hostname)) {
+                            resolvedIngress = ingressFromStatus;
+                        }
+                    }
+                    catch {
+                        resolvedIngress = ingressFromStatus;
+                    }
+                }
+                tokenFromStatus = resolveSandboxToken(payload);
+                break;
+            }
+            catch {
+                // Keep fallback ingress/token when status endpoint is unavailable.
+            }
+        }
+    }
+    let ingress = resolvedIngress.replace(/\/$/, '');
+    let tokenFromIngress = '';
+    try {
+        const parsed = new URL(resolvedIngress);
+        tokenFromIngress = String(parsed.searchParams.get('token') ||
+            parsed.searchParams.get('jupyter_token') ||
+            '').trim();
+        parsed.searchParams.delete('token');
+        parsed.searchParams.delete('jupyter_token');
+        ingress = parsed.toString().replace(/\/$/, '');
+    }
+    catch {
+        // Keep raw ingress when URL parsing fails.
+    }
+    const serverSettings = ServerConnection.makeSettings({
+        baseUrl: ingress,
+        wsUrl: ingress.replace(/^http/, 'ws'),
+        token: tokenFromIngress || tokenFromStatus || authToken || '',
+        appendToken: true,
+    });
+    const manager = new ServiceManager({ serverSettings });
+    await manager.ready;
+    const runtimeEnvironment = resolveRuntimeEnvironmentDetails(payloadFromStatus, info.runtimeEnvironment);
+    if (runtimeEnvironment) {
+        const carrier = manager;
+        carrier[RUNTIME_ENVIRONMENT_META_KEY] = runtimeEnvironment;
+    }
+    return manager;
+}
 /**
  * Map a raw backend runtime record to AgentRuntimeData.
  */
@@ -129,8 +298,17 @@ function toAgentRuntimeData(raw) {
     const volume_uids = rawVolumeUids
         .map((uid) => String(uid || '').trim())
         .filter(Boolean);
+    const environment = raw.environment;
     return {
         ...raw,
+        environment: {
+            name: String(environment?.name || '').trim(),
+            title: String(environment?.title || '').trim() || undefined,
+            cpu: String(environment?.cpu || '').trim() || undefined,
+            memory: String(environment?.memory || '').trim() || undefined,
+            gpu: String(environment?.gpu || '').trim() || undefined,
+            resources: environment?.resources,
+        },
         status: normalizedStatus,
         name: raw.given_name || raw.pod_name,
         id: raw.pod_name,
@@ -201,7 +379,6 @@ export function useAgentRuntimes(options = {}) {
         }
         if (runtimeCreationTarget === 'local-agent-runtimes') {
             return (import.meta.env.VITE_DATALAYER_AGENT_RUNTIMES_URL ||
-                import.meta.env.VITE_BASE_URL ||
                 'http://localhost:8765');
         }
         return (configuration?.runtimesUrl ||
@@ -411,7 +588,7 @@ export function useAgentRuntimes(options = {}) {
                 const runtimesResponse = await listRuntimes(token, runtimesUrl);
                 const runtimes = runtimesResponse.runtimes || [];
                 const aiAgentRuntimes = runtimes.filter(rt => {
-                    if (rt.environment_name !== 'ai-agents-env') {
+                    if (rt.environment?.name !== 'ai-agents-env') {
                         return false;
                     }
                     if (!agentSpecId) {
@@ -431,7 +608,7 @@ export function useAgentRuntimes(options = {}) {
                 }
                 storeConnectAgent({
                     podName: latestRuntime.pod_name,
-                    environmentName: latestRuntime.environment_name,
+                    environmentName: latestRuntime.environment.name,
                     jupyterBaseUrl: latestRuntime.ingress,
                 });
                 // Ensure auto-create fires for this reconnected runtime.
@@ -572,7 +749,7 @@ export function useAgentRuntimesQuery(scope, queryOptions) {
             });
             if (resp.success && resp.runtimes) {
                 const agentRuntimes = resp.runtimes
-                    .filter(rt => rt.environment_name === 'ai-agents-env')
+                    .filter(rt => rt.environment?.name === 'ai-agents-env')
                     .map(toAgentRuntimeData)
                     // Drop stale echoes of pods deleted from this client so consumers
                     // never reconnect a ServiceManager to a dead ingress (CORS spam).
@@ -643,7 +820,9 @@ export function useCreateAgentRuntime() {
                 url: `${configuration.runtimesUrl}/api/runtimes/v1/runtimes`,
                 method: 'POST',
                 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',
@@ -954,6 +1133,14 @@ export function useAgentRuntimeWebSocket(options) {
                     state.applySnapshot(parsed.payload);
                     return;
                 }
+                if (parsed.type === 'agent.subagent') {
+                    state.appendSubagentEvent(parsed.payload);
+                    return;
+                }
+                if (parsed.type === 'agent.compaction') {
+                    state.setCompaction(parsed.payload);
+                    return;
+                }
             };
             ws.onclose = () => {
                 agentRuntimeStore.getState().setWs(null, agentId);

package/lib/hooks/useCheckpoints.js

@@ -345,7 +345,7 @@ export function useAgentLifecycle(options) {
                     const runtimesResponse = await listRuntimes(token, runtimesUrl);
                     const runtimes = runtimesResponse.runtimes || [];
                     const aiAgentRuntimes = runtimes.filter(rt => {
-                        if (rt.environment_name !== 'ai-agents-env') {
+                        if (rt.environment.name !== 'ai-agents-env') {
                             return false;
                         }
                         if (!agentSpecId) {
@@ -363,7 +363,7 @@ export function useAgentLifecycle(options) {
                     if (latestRuntime?.pod_name && latestRuntime?.ingress) {
                         connectToRuntime({
                             podName: latestRuntime.pod_name,
-                            environmentName: latestRuntime.environment_name,
+                            environmentName: latestRuntime.environment.name,
                             jupyterBaseUrl: latestRuntime.ingress,
                         });
                     }

package/lib/hooks/useToolApprovals.d.ts

@@ -47,12 +47,17 @@ interface MutationResult {
         note?: string;
     }) => Promise<void>;
 }
+type WSConnectionState = 'connecting' | 'connected' | 'closed';
+interface DecisionMutationResult extends MutationResult {
+    /** Live socket state so callers can tailor offline messaging. */
+    connectionState: WSConnectionState;
+}
 export declare function useToolApprovalsQuery(filters?: ToolApprovalFilters): import("@tanstack/react-query").UseQueryResult<NoInfer<ApprovalsQueryData>, Error>;
 export declare function usePendingApprovalCount(): import("@tanstack/react-query").UseQueryResult<NoInfer<{
     count: number;
 }>, Error>;
-export declare function useApproveToolRequest(): MutationResult;
-export declare function useRejectToolRequest(): MutationResult;
+export declare function useApproveToolRequest(): DecisionMutationResult;
+export declare function useRejectToolRequest(): DecisionMutationResult;
 export declare function useMarkToolApprovalRead(): MutationResult;
 export declare function useMarkToolApprovalUnread(): MutationResult;
 /**
@@ -68,10 +73,11 @@ export declare function useToolApprovals(filters?: ToolApprovalFilters): {
     pendingCountQuery: import("@tanstack/react-query").UseQueryResult<NoInfer<{
         count: number;
     }>, Error>;
-    approve: MutationResult;
-    reject: MutationResult;
+    approve: DecisionMutationResult;
+    reject: DecisionMutationResult;
     markRead: MutationResult;
     markUnread: MutationResult;
     remove: MutationResult;
+    connectionState: WSConnectionState;
 };
 export {};

package/lib/hooks/useToolApprovals.js

@@ -30,7 +30,8 @@ function normalizeApproval(raw) {
     if (!raw || typeof raw !== 'object')
         return null;
     const rec = raw;
-    const id = typeof rec.id === 'string' ? rec.id : undefined;
+    const idSource = rec.id ?? rec.approval_id ?? rec.approvalId;
+    const id = typeof idSource === 'string' ? idSource : undefined;
     if (!id)
         return null;
     const agent = str(rec.agent_id ?? rec.agentId);
@@ -262,7 +263,7 @@ export function usePendingApprovalCount() {
 }
 /** Build a mutation-style object that sends a WS decision. */
 function useDecisionMutation(approved) {
-    const { send } = useApprovalsSocket();
+    const { send, connectionState } = useApprovalsSocket();
     const [isPending, setIsPending] = useState(false);
     const mutateAsync = useCallback(async ({ id, note }) => {
         setIsPending(true);
@@ -282,9 +283,11 @@ function useDecisionMutation(approved) {
         }
     }, [approved, send]);
     const mutate = useCallback((vars) => {
-        void mutateAsync(vars);
+        void mutateAsync(vars).catch(err => {
+            console.warn('[tool-approval] decision was not sent', err);
+        });
     }, [mutateAsync]);
-    return { isPending, mutate, mutateAsync };
+    return { isPending, mutate, mutateAsync, connectionState };
 }
 export function useApproveToolRequest() {
     return useDecisionMutation(true);
@@ -361,7 +364,9 @@ export function useDeleteToolApproval() {
         }
     }, [send]);
     const mutate = useCallback((vars) => {
-        void mutateAsync(vars);
+        void mutateAsync(vars).catch(err => {
+            console.warn('[tool-approval] delete was not sent', err);
+        });
     }, [mutateAsync]);
     return { isPending, mutate, mutateAsync };
 }
@@ -382,6 +387,7 @@ export function useToolApprovals(filters) {
         markRead,
         markUnread,
         remove,
+        connectionState: approve.connectionState,
     }), [
         approvalsQuery,
         pendingQuery,