@datalayer/agent-runtimes 1.0.9 → 1.0.17

package/lib/hooks/useAgentRuntimes.js

@@ -17,9 +17,11 @@ import { create } from 'zustand';
 import { persist, createJSONStorage } from 'zustand/middleware';
 import { useCoreStore, useDatalayer } from '@datalayer/core';
 import { useIAMStore } from '@datalayer/core/lib/state';
+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 { disposeSandboxServiceManagers } from '../services/sandboxServiceManagers';
 // ═══════════════════════════════════════════════════════════════════════════
 // Constants
 // ═══════════════════════════════════════════════════════════════════════════
@@ -46,6 +48,60 @@ export const agentQueryKeys = {
 // ═══════════════════════════════════════════════════════════════════════════
 // Helpers
 // ═══════════════════════════════════════════════════════════════════════════
+/**
+ * Session tombstones for runtime pods deleted from this client.
+ *
+ * After a DELETE succeeds, the control plane can keep returning the pod
+ * (status \"running\") for a few seconds. Without a tombstone, the immediate
+ * list refetch re-adds the dead pod to the query cache (and re-seeds the
+ * per-pod detail cache), so consumers rebuild Jupyter `ServiceManager`s
+ * against the dead ingress — producing endless CORS `/api/kernels` errors.
+ *
+ * Entries expire after a TTL so a pod that legitimately reappears later
+ * (e.g. resumed from a checkpoint under the same pod name) is not hidden
+ * forever; resume/create mutations also clear the tombstone eagerly.
+ */
+const DELETED_POD_TOMBSTONE_TTL_MS = 5 * 60 * 1000;
+const deletedRuntimePodTombstones = new Map();
+/** Mark a runtime pod as deleted by this client (tombstone). */
+export function markRuntimePodDeleted(podName) {
+    const normalized = String(podName || '').trim();
+    if (normalized) {
+        deletedRuntimePodTombstones.set(normalized, Date.now());
+        // Centralized teardown: dispose every ServiceManager any surface opened
+        // against this pod's sandbox so their kernelspecs/sessions/users pollers
+        // stop immediately instead of waiting for query-cache propagation.
+        disposeSandboxServiceManagers(normalized);
+    }
+}
+/** Clear a deleted-pod tombstone (pod legitimately exists again). */
+export function clearRuntimePodDeleted(podName) {
+    deletedRuntimePodTombstones.delete(String(podName || '').trim());
+}
+/** Statuses that imply a live pod the client would connect to. */
+const LIVE_RUNTIME_STATUSES = new Set([
+    'running',
+    'resumed',
+    'starting',
+    'resuming',
+]);
+/**
+ * True when a runtime record is a stale control-plane echo of a pod this
+ * client already deleted: tombstoned, within TTL, and claiming a live status.
+ * Checkpoint-synthesised `paused` records pass through (no live pod to poll).
+ */
+function isStaleDeletedRuntime(runtime) {
+    const podName = String(runtime?.pod_name || '').trim();
+    const deletedAt = deletedRuntimePodTombstones.get(podName);
+    if (deletedAt === undefined) {
+        return false;
+    }
+    if (Date.now() - deletedAt > DELETED_POD_TOMBSTONE_TTL_MS) {
+        deletedRuntimePodTombstones.delete(podName);
+        return false;
+    }
+    return LIVE_RUNTIME_STATUSES.has(runtime.status);
+}
 const RUNTIME_STATUS_MAP = {
     resume: 'resumed',
     resumed: 'resumed',
@@ -148,11 +204,11 @@ export function useAgentRuntimes(options = {}) {
                 import.meta.env.VITE_BASE_URL ||
                 'http://localhost:8765');
         }
-        return (configuration?.runtimesRunUrl ||
+        return (configuration?.runtimesUrl ||
             import.meta.env.VITE_DATALAYER_AGENT_RUNTIMES_URL ||
             'https://r1.datalayer.run');
     }, [
-        configuration?.runtimesRunUrl,
+        configuration?.runtimesUrl,
         runtimeCreationBaseUrl,
         runtimeCreationTarget,
     ]);
@@ -162,12 +218,12 @@ export function useAgentRuntimes(options = {}) {
             const { iamStore, coreStore } = await import('@datalayer/core/lib/state');
             const token = iamStore.getState().token || '';
             const config = coreStore.getState().configuration;
-            const runUrl = config?.aiagentsRunUrl || '';
-            const runtimesRunUrl = resolvedRuntimeCreationBaseUrl;
-            return { token, runUrl, runtimesRunUrl };
+            const datalayerUrl = config?.aiAgentsUrl || '';
+            const runtimesUrl = resolvedRuntimeCreationBaseUrl;
+            return { token, datalayerUrl, runtimesUrl };
         }
         catch {
-            return { token: '', runUrl: '', runtimesRunUrl: '' };
+            return { token: '', datalayerUrl: '', runtimesUrl: '' };
         }
     }, [resolvedRuntimeCreationBaseUrl]);
     // ─── Launch Runtime ─────────────────────────────────────────────────
@@ -188,13 +244,13 @@ export function useAgentRuntimes(options = {}) {
                 const conn = await storeLaunchAgent(runtimeOptions
                     ? {
                         ...runtimeOptions,
-                        runtimesRunUrl: resolvedRuntimeCreationBaseUrl,
+                        runtimesUrl: resolvedRuntimeCreationBaseUrl,
                     }
                     : {
                         environmentName: 'ai-agents-env',
                         creditsLimit: 10,
                         givenName: safeName,
-                        runtimesRunUrl: resolvedRuntimeCreationBaseUrl,
+                        runtimesUrl: resolvedRuntimeCreationBaseUrl,
                     });
                 setLifecycleStatus('ready');
                 return conn;
@@ -212,7 +268,7 @@ export function useAgentRuntimes(options = {}) {
             }
             return storeLaunchAgent({
                 ...runtimeOptions,
-                runtimesRunUrl: resolvedRuntimeCreationBaseUrl,
+                runtimesUrl: resolvedRuntimeCreationBaseUrl,
             });
         }
     }, [
@@ -271,6 +327,29 @@ export function useAgentRuntimes(options = {}) {
             setIsCreating(false);
         }
     }, [agentSpecId, agentConfig, agentSpec, hasSpec, runtime, storeCreateAgent]);
+    // ─── Teardown ───────────────────────────────────────────────────────
+    const teardown = useCallback(async () => {
+        const agentId = runtime?.agentId;
+        const agentBaseUrl = runtime?.agentBaseUrl;
+        if (agentId && agentBaseUrl) {
+            try {
+                const { token } = await getAuthHeaders();
+                await fetch(`${agentBaseUrl}/api/v1/agents/${encodeURIComponent(agentId)}`, {
+                    method: 'DELETE',
+                    headers: token ? { Authorization: `Bearer ${token}` } : {},
+                });
+            }
+            catch {
+                // Best-effort teardown: ignore network / 404 errors.
+            }
+        }
+        // Reset in-process runtime state so a fresh agent can be launched.
+        hasCreatedAgentRef.current = false;
+        hasAutoStarted.current = false;
+        setLifecycleStatus('idle');
+        setLifecycleError(null);
+        agentRuntimeStore.getState().reset();
+    }, [runtime?.agentId, runtime?.agentBaseUrl, getAuthHeaders]);
     // ─── Auto-create agent when runtime is ready (connect mode) ───────
     useEffect(() => {
         if (!hasSpec &&
@@ -324,12 +403,12 @@ export function useAgentRuntimes(options = {}) {
         let cancelled = false;
         const bootstrap = async () => {
             try {
-                const { token, runtimesRunUrl } = await getAuthHeaders();
+                const { token, runtimesUrl } = await getAuthHeaders();
                 if (!token) {
                     return;
                 }
-                const { listRuntimes } = await import('@datalayer/core/lib/api/runtimes/runtimes');
-                const runtimesResponse = await listRuntimes(token, runtimesRunUrl);
+                const { listRuntimes } = await import('../api/runtimes/runtimes');
+                const runtimesResponse = await listRuntimes(token, runtimesUrl);
                 const runtimes = runtimesResponse.runtimes || [];
                 const aiAgentRuntimes = runtimes.filter(rt => {
                     if (rt.environment_name !== 'ai-agents-env') {
@@ -338,9 +417,9 @@ export function useAgentRuntimes(options = {}) {
                     if (!agentSpecId) {
                         return true;
                     }
-                    const runtimeAgentSpecId = rt
+                    const runtimeAgentspecId = rt
                         .agent_spec_id;
-                    return runtimeAgentSpecId === agentSpecId;
+                    return runtimeAgentspecId === agentSpecId;
                 });
                 const latestRuntime = aiAgentRuntimes.slice().sort((a, b) => {
                     const aTs = Number(a.started_at || 0);
@@ -441,6 +520,7 @@ export function useAgentRuntimes(options = {}) {
         endpoint,
         serviceManager,
         createAgent,
+        teardown,
         isCreating,
         // Status
         isReady,
@@ -487,13 +567,16 @@ export function useAgentRuntimesQuery(scope, queryOptions) {
             }
             const query = params.toString();
             const resp = await requestDatalayer({
-                url: `${configuration.runtimesRunUrl}/api/runtimes/v1/runtimes${query ? `?${query}` : ''}`,
+                url: `${configuration.runtimesUrl}/api/runtimes/v1/runtimes${query ? `?${query}` : ''}`,
                 method: 'GET',
             });
             if (resp.success && resp.runtimes) {
                 const agentRuntimes = resp.runtimes
                     .filter(rt => rt.environment_name === 'ai-agents-env')
-                    .map(toAgentRuntimeData);
+                    .map(toAgentRuntimeData)
+                    // Drop stale echoes of pods deleted from this client so consumers
+                    // never reconnect a ServiceManager to a dead ingress (CORS spam).
+                    .filter(runtime => !isStaleDeletedRuntime(runtime));
                 agentRuntimes.forEach((runtime) => {
                     queryClient.setQueryData(agentQueryKeys.agentRuntimes.detail(runtime.pod_name), runtime);
                 });
@@ -518,11 +601,17 @@ export function useAgentRuntimeByPodName(podName) {
         queryKey: agentQueryKeys.agentRuntimes.detail(podName ?? ''),
         queryFn: async () => {
             const resp = await requestDatalayer({
-                url: `${configuration.runtimesRunUrl}/api/runtimes/v1/runtimes/${podName}`,
+                url: `${configuration.runtimesUrl}/api/runtimes/v1/runtimes/${podName}`,
                 method: 'GET',
             });
             if (resp.runtime) {
-                return toAgentRuntimeData(resp.runtime);
+                const runtime = toAgentRuntimeData(resp.runtime);
+                if (isStaleDeletedRuntime(runtime)) {
+                    // Stale echo of a pod deleted from this client — surface as an
+                    // error so the poll stops and consumers tear the connection down.
+                    throw new Error('Agent runtime deleted');
+                }
+                return runtime;
             }
             throw new Error('Failed to fetch agent runtime');
         },
@@ -551,7 +640,7 @@ export function useCreateAgentRuntime() {
                     ? [String(data.volumeUid).trim()]
                     : [];
             return requestDatalayer({
-                url: `${configuration.runtimesRunUrl}/api/runtimes/v1/runtimes`,
+                url: `${configuration.runtimesUrl}/api/runtimes/v1/runtimes`,
                 method: 'POST',
                 body: {
                     environment_name: data.environmentName || 'ai-agents-env',
@@ -563,11 +652,11 @@ export function useCreateAgentRuntime() {
                     agent_spec_id: data.agentSpecId || undefined,
                     agent_spec: data.agentSpec || undefined,
                     user_account_handle: data.userAccountHandle || undefined,
-                    billable_account_uid: data.billableAccountUid || undefined,
-                    billable_account_type: data.billableAccountType || undefined,
-                    billable_account_handle: data.billableAccountHandle || undefined,
-                    billable_source_organization_uid: data.billableSourceOrganizationUid || undefined,
-                    billable_source_organization_handle: data.billableSourceOrganizationHandle || undefined,
+                    billing_entity_uid: data.billingEntityUid || undefined,
+                    billing_entity_type: data.billingEntityType || undefined,
+                    billing_entity_handle: data.billingEntityHandle || undefined,
+                    billing_source_organization_uid: data.billingSourceOrganizationUid || undefined,
+                    billing_source_organization_handle: data.billingSourceOrganizationHandle || undefined,
                     mount_home_folder: data.mountHomeFolder ?? false,
                     volume_uids: normalizedVolumeUids.length > 0 ? normalizedVolumeUids : undefined,
                     volume_uid: normalizedVolumeUids[0] || data.volumeUid || undefined,
@@ -577,6 +666,8 @@ export function useCreateAgentRuntime() {
         onSuccess: resp => {
             if (resp.success && resp.runtime) {
                 const mapped = toAgentRuntimeData(resp.runtime);
+                // A fresh runtime legitimately exists — drop any stale tombstone.
+                clearRuntimePodDeleted(mapped.pod_name);
                 queryClient.setQueryData(agentQueryKeys.agentRuntimes.detail(mapped.pod_name), mapped);
                 queryClient.invalidateQueries({
                     queryKey: agentQueryKeys.agentRuntimes.all(),
@@ -592,14 +683,70 @@ export function useDeleteAgentRuntime() {
     const { configuration } = useCoreStore();
     const { requestDatalayer } = useDatalayer({ notifyOnError: false });
     const queryClient = useQueryClient();
+    const getErrorStatus = (error) => {
+        if (!error || typeof error !== 'object') {
+            return undefined;
+        }
+        const response = error.response;
+        return typeof response?.status === 'number' ? response.status : undefined;
+    };
+    const getErrorText = (error) => {
+        if (!error || typeof error !== 'object') {
+            return '';
+        }
+        const responseData = error.response?.data;
+        return String(responseData?.detail ||
+            responseData?.message ||
+            error.message ||
+            '').toLowerCase();
+    };
     return useMutation({
         mutationFn: async (podName) => {
-            return requestDatalayer({
-                url: `${configuration.runtimesRunUrl}/api/runtimes/v1/runtimes/${podName}`,
-                method: 'DELETE',
-            });
+            try {
+                return await requestDatalayer({
+                    url: `${configuration.runtimesUrl}/api/runtimes/v1/runtimes/${podName}`,
+                    method: 'DELETE',
+                });
+            }
+            catch (error) {
+                const status = getErrorStatus(error);
+                const message = getErrorText(error);
+                const maybeAlreadyDeleted = status === 404 ||
+                    message.includes('no reservation') ||
+                    message.includes('unknown reservation') ||
+                    message.includes('not found');
+                if (!maybeAlreadyDeleted) {
+                    throw error;
+                }
+                // The backend can return an IAM reservation error even after the pod
+                // has already been deleted successfully. Confirm state by checking if
+                // the runtime detail endpoint still exists.
+                try {
+                    await requestDatalayer({
+                        url: `${configuration.runtimesUrl}/api/runtimes/v1/runtimes/${podName}`,
+                        method: 'GET',
+                    });
+                    // Runtime still exists: propagate original DELETE failure.
+                    throw error;
+                }
+                catch (checkError) {
+                    const checkStatus = getErrorStatus(checkError);
+                    if (checkStatus === 404) {
+                        return { success: true, recovered: true };
+                    }
+                    throw error;
+                }
+            }
         },
         onSuccess: (_data, podName) => {
+            // Tombstone the pod so refetches that still echo it from the control
+            // plane (deletion lag) do not re-add it to the caches below.
+            markRuntimePodDeleted(podName);
+            // Prune the pod from the runtimes store immediately so the remote service
+            // managers dispose right away and stop polling the now-dead pod ingress
+            // (otherwise `/api/kernels` requests keep firing until the next
+            // `refreshRuntimePods()` poll tick, producing CORS errors).
+            runtimesStore.getState().removeRuntimePod(podName);
             queryClient.setQueriesData({ queryKey: agentQueryKeys.agentRuntimes.lists() }, (current) => {
                 if (!Array.isArray(current)) {
                     return current;
@@ -707,6 +854,16 @@ export function useAgentsRuntimes(scope, queryOptions) {
     const createRuntimeMutation = useCreateAgentRuntime();
     const deleteRuntimeMutation = useDeleteAgentRuntime();
     const refreshRuntimes = useRefreshAgentRuntimes();
+    const terminateRuntimeByPod = useCallback(async (podName, options) => {
+        const normalizedPodName = String(podName || '').trim();
+        if (!normalizedPodName) {
+            return;
+        }
+        if (options?.beforeTerminate) {
+            await options.beforeTerminate();
+        }
+        return deleteRuntimeMutation.mutateAsync(normalizedPodName);
+    }, [deleteRuntimeMutation]);
     return useMemo(() => ({
         runtimes: runtimesQuery.data ?? EMPTY_RUNTIMES,
         isRuntimesLoading: runtimesQuery.isLoading,
@@ -714,7 +871,8 @@ export function useAgentsRuntimes(scope, queryOptions) {
         runtimesError: runtimesQuery.error,
         refetchRuntimes: () => runtimesQuery.refetch(),
         refreshRuntimes,
-        deleteRuntimeByPod: async (podName) => deleteRuntimeMutation.mutateAsync(podName),
+        terminateRuntimeByPod,
+        deleteRuntimeByPod: async (podName) => terminateRuntimeByPod(podName),
         createRuntime: async (data) => createRuntimeMutation.mutateAsync(data),
     }), [
         runtimesQuery.data,
@@ -723,6 +881,7 @@ export function useAgentsRuntimes(scope, queryOptions) {
         runtimesQuery.error,
         runtimesQuery.refetch,
         refreshRuntimes,
+        terminateRuntimeByPod,
         createRuntimeMutation,
         deleteRuntimeMutation,
     ]);

package/lib/hooks/useAgentsCatalog.d.ts

@@ -1,10 +1,10 @@
-import type { AgentRuntimeData, AgentSpec } from '../types';
+import type { AgentRuntimeData, Agentspec } from '../types';
 /**
  * Centralised Zustand store for agents.
  *
  * Two collections are maintained:
  *
- * 1. **agentSpecs** – the static catalogue of available agent blueprints
+ * 1. **agentspecs** – the static catalogue of available agent blueprints
  *    (from `@datalayer/agent-runtimes/lib/specs`).
  *    Populated once at import time; call `refreshSpecs()` to re-read.
  *
@@ -14,7 +14,7 @@ import type { AgentRuntimeData, AgentSpec } from '../types';
  */
 export type AgentCatalogStoreState = {
     /** Static catalogue of agent blueprints. */
-    agentSpecs: AgentSpec[];
+    agentspecs: Agentspec[];
     /** Live agent runtimes (running / starting). */
     runningAgents: AgentRuntimeData[];
     /** Re-read agent specs from the config. */

package/lib/hooks/useAgentsCatalog.js

@@ -10,18 +10,18 @@
  * @module hooks/useAgentsCatalog
  */
 import { create } from 'zustand';
-import { listAgentSpecs } from '../specs';
+import { listAgentspecs } from '../specs';
 export const useAgentCatalogStore = create()(set => ({
-    agentSpecs: listAgentSpecs(),
+    agentspecs: listAgentspecs(),
     runningAgents: [],
-    refreshSpecs: () => set({ agentSpecs: listAgentSpecs() }),
+    refreshSpecs: () => set({ agentspecs: listAgentspecs() }),
     setRunningAgents: agents => set(state => ({
         runningAgents: agents.map(agent => {
             if (agent.agentSpec)
                 return agent;
             if (!agent.agent_spec_id)
                 return agent;
-            const spec = state.agentSpecs.find(s => s.id === agent.agent_spec_id);
+            const spec = state.agentspecs.find(s => s.id === agent.agent_spec_id);
             return spec ? { ...agent, agentSpec: spec } : agent;
         }),
     })),

package/lib/hooks/useAgentsService.js

@@ -23,7 +23,7 @@ export const useAgentsService = (baseUrlOverride = 'api/ai-agents/v1') => {
     const { requestDatalayer } = useDatalayer({ notifyOnError: false });
     const createAgent = (documentId, documentType, ingress, token, kernelId, { signal, baseUrl = baseUrlOverride } = {}) => {
         return requestDatalayer({
-            url: URLExt.join(configuration.aiagentsRunUrl, baseUrl, 'agents'),
+            url: URLExt.join(configuration.aiAgentsUrl, baseUrl, 'agents'),
             method: 'POST',
             body: {
                 document_id: documentId,
@@ -39,28 +39,28 @@ export const useAgentsService = (baseUrlOverride = 'api/ai-agents/v1') => {
     };
     const getAgents = ({ signal, baseUrl = baseUrlOverride, } = {}) => {
         return requestDatalayer({
-            url: URLExt.join(configuration.aiagentsRunUrl, baseUrl, 'agents'),
+            url: URLExt.join(configuration.aiAgentsUrl, baseUrl, 'agents'),
             method: 'GET',
             signal,
         });
     };
     const deleteAgent = (documentId, { signal, baseUrl = baseUrlOverride } = {}) => {
         return requestDatalayer({
-            url: URLExt.join(configuration.aiagentsRunUrl, baseUrl, 'agents', documentId),
+            url: URLExt.join(configuration.aiAgentsUrl, baseUrl, 'agents', documentId),
             method: 'DELETE',
             signal,
         });
     };
     const getAgent = (documentId, { signal, baseUrl = baseUrlOverride } = {}) => {
         return requestDatalayer({
-            url: URLExt.join(configuration.aiagentsRunUrl, baseUrl, 'agents', documentId),
+            url: URLExt.join(configuration.aiAgentsUrl, baseUrl, 'agents', documentId),
             method: 'GET',
             signal,
         });
     };
     const patchAgent = (documentId, ingress, token, kernelId, { signal, baseUrl = baseUrlOverride } = {}) => {
         return requestDatalayer({
-            url: URLExt.join(configuration.aiagentsRunUrl, baseUrl, 'agents', documentId),
+            url: URLExt.join(configuration.aiAgentsUrl, baseUrl, 'agents', documentId),
             method: 'PATCH',
             body: {
                 runtime: ingress && token && kernelId

package/lib/hooks/useCellOutputshot.d.ts

@@ -0,0 +1,4 @@
+declare const useCellOutputshot: () => (string | ((node: HTMLDivElement) => void) | {
+    error: undefined;
+})[];
+export default useCellOutputshot;

package/lib/hooks/useCellOutputshot.js

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { useState } from 'react';
+import { useCellStore } from '../state/substates';
+import { takeHTMLNodeScreencapture } from '@datalayer/core/lib/utils/Screencapture';
+const useCellOutputshot = () => {
+    const [outputshot, setOutputshot] = useState('');
+    const [error, setError] = useState();
+    const { update } = useCellStore();
+    const takeOutputshot = (node) => {
+        takeHTMLNodeScreencapture(node)
+            .then(outputshotData => {
+            setOutputshot(outputshotData);
+            update({
+                outputshotData,
+            });
+            return outputshotData;
+        })
+            .catch(reason => setError(reason));
+    };
+    return [outputshot, takeOutputshot, { error }];
+};
+export default useCellOutputshot;

package/lib/hooks/useCheckpoints.d.ts

@@ -48,7 +48,7 @@ export type TerminateAgentParams = {
  * Calls ``GET /api/runtimes/v1/runtime-checkpoints`` and returns
  * the list of checkpoint records in visible states.
  */
-export declare function useCheckpointsQuery(): import("@tanstack/react-query").UseQueryResult<CheckpointData[], Error>;
+export declare function useCheckpointsQuery(): import("@tanstack/react-query").UseQueryResult<NoInfer<CheckpointData[]>, Error>;
 /**
  * Hook to refresh the checkpoints list.
  */
@@ -73,14 +73,14 @@ export declare function useResumePausedAgentRuntime(): import("@tanstack/react-q
  * until the checkpoint reaches ``paused`` or ``failed``.
  * On success, both runtimes and checkpoints queries are invalidated.
  */
-export declare function usePauseAgent(): import("@tanstack/react-query").UseMutationResult<import("@datalayer/core/lib/api/runtimes/runtimes").PauseResumeResponse, Error, PauseAgentParams, unknown>;
+export declare function usePauseAgent(): import("@tanstack/react-query").UseMutationResult<import("../api/runtimes/runtimes").PauseResumeResponse, Error, PauseAgentParams, unknown>;
 /**
  * Hook to resume a paused agent runtime from a checkpoint.
  *
  * Calls ``POST .../resume`` then invalidates both runtimes and
  * checkpoints queries so the UI reflects the new state.
  */
-export declare function useResumeAgent(): import("@tanstack/react-query").UseMutationResult<import("@datalayer/core/lib/api/runtimes/runtimes").PauseResumeResponse, Error, ResumeAgentParams, unknown>;
+export declare function useResumeAgent(): import("@tanstack/react-query").UseMutationResult<import("../api/runtimes/runtimes").PauseResumeResponse, Error, ResumeAgentParams, unknown>;
 /**
  * Hook to create a named checkpoint (pause → wait → stay paused).
  *
@@ -88,7 +88,7 @@ export declare function useResumeAgent(): import("@tanstack/react-query").UseMut
  * this hook creates a named checkpoint record for later restore.
  */
 export declare function useCheckpointAgent(): import("@tanstack/react-query").UseMutationResult<{
-    checkpoint: import("@datalayer/core/lib/api/runtimes/checkpoints").RuntimeCheckpointData;
+    checkpoint: import("../api/runtimes/checkpoints").RuntimeCheckpointData;
     success: boolean;
     message: string;
     checkpoint_id: string | null;
@@ -163,12 +163,12 @@ export declare function useAgentLifecycle(options: AgentLifecycleOptions): Agent
  * for pause, resume, and checkpoint lifecycle.
  */
 export declare function useCheckpoints(): {
-    checkpointsQuery: import("@tanstack/react-query").UseQueryResult<CheckpointData[], Error>;
+    checkpointsQuery: import("@tanstack/react-query").UseQueryResult<NoInfer<CheckpointData[]>, Error>;
     refresh: () => void;
-    pauseAgent: import("@tanstack/react-query").UseMutationResult<import("@datalayer/core/lib/api/runtimes/runtimes").PauseResumeResponse, Error, PauseAgentParams, unknown>;
-    resumeAgent: import("@tanstack/react-query").UseMutationResult<import("@datalayer/core/lib/api/runtimes/runtimes").PauseResumeResponse, Error, ResumeAgentParams, unknown>;
+    pauseAgent: import("@tanstack/react-query").UseMutationResult<import("../api/runtimes/runtimes").PauseResumeResponse, Error, PauseAgentParams, unknown>;
+    resumeAgent: import("@tanstack/react-query").UseMutationResult<import("../api/runtimes/runtimes").PauseResumeResponse, Error, ResumeAgentParams, unknown>;
     checkpointAgent: import("@tanstack/react-query").UseMutationResult<{
-        checkpoint: import("@datalayer/core/lib/api/runtimes/checkpoints").RuntimeCheckpointData;
+        checkpoint: import("../api/runtimes/checkpoints").RuntimeCheckpointData;
         success: boolean;
         message: string;
         checkpoint_id: string | null;