@datalayer/core 0.0.27 → 1.0.2

package/lib/hooks/useCache.js

@@ -272,14 +272,6 @@ export const queryKeys = {
         bySpace: (spaceId) => [...queryKeys.items.all(), 'space', spaceId],
         search: (opts) => [...queryKeys.items.all(), 'search', opts],
     },
-    // Agent Spaces
-    agentSpaces: {
-        all: () => ['agentSpaces'],
-        lists: () => [...queryKeys.agentSpaces.all(), 'list'],
-        details: () => [...queryKeys.agentSpaces.all(), 'detail'],
-        detail: (id) => [...queryKeys.agentSpaces.details(), id],
-        public: () => [...queryKeys.agentSpaces.all(), 'public'],
-    },
     // Agent Runtimes (runtimes with ai-agents environment)
     agentRuntimes: {
         all: () => ['agentRuntimes'],
@@ -1321,17 +1313,20 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
         });
     };
     /**
-     * Update space with optimistic update
+     * Update space with optimistic update.
+     * Any extra fields (e.g. attached_agent_pod_name_s) are forwarded to the backend.
      */
     const useUpdateSpace = () => {
         return useMutation({
             mutationFn: async (space) => {
+                const { id, name, description, ...extraFields } = space;
                 return requestDatalayer({
-                    url: `${configuration.spacerRunUrl}/api/spacer/v1/spaces/${space.id}/users/${user?.id}`,
+                    url: `${configuration.spacerRunUrl}/api/spacer/v1/spaces/${id}/users/${user?.id}`,
                     method: 'PUT',
                     body: {
-                        name: space.name,
-                        description: space.description,
+                        name,
+                        description,
+                        ...extraFields,
                     },
                 });
             },
@@ -1348,219 +1343,25 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
             },
         });
     };
-    // ============================================================================
-    // Agent Spaces Hooks
-    // ============================================================================
-    /**
-     * Get agent space by ID
-     */
-    const useAgentSpace = (uid) => {
-        return useQuery({
-            queryKey: queryKeys.agentSpaces.detail(uid || ''),
-            queryFn: async () => {
-                const resp = await requestDatalayer({
-                    url: `${configuration.spacerRunUrl}/api/spacer/v1/agent-spaces/${uid}`,
-                    method: 'GET',
-                });
-                if (resp.success && resp.agentSpace) {
-                    return resp.agentSpace;
-                }
-                throw new Error(resp.message || 'Failed to fetch agent space');
-            },
-            ...DEFAULT_QUERY_OPTIONS,
-            enabled: !!uid,
-        });
-    };
-    /**
-     * List user's agent spaces
-     */
-    const useAgentSpaces = () => {
-        return useQuery({
-            queryKey: queryKeys.agentSpaces.lists(),
-            queryFn: async () => {
-                const resp = await requestDatalayer({
-                    url: `${configuration.spacerRunUrl}/api/spacer/v1/agent-spaces`,
-                    method: 'GET',
-                });
-                if (resp.success && resp.agentSpaces) {
-                    const agentSpaces = resp.agentSpaces;
-                    // Set detail cache for each agent space
-                    agentSpaces.forEach((agentSpace) => {
-                        queryClient.setQueryData(queryKeys.agentSpaces.detail(agentSpace.id), agentSpace);
-                    });
-                    return agentSpaces;
-                }
-                return [];
-            },
-            ...DEFAULT_QUERY_OPTIONS,
-            enabled: !!user,
-        });
-    };
     /**
-     * List public agent spaces (Library)
+     * Delete a space and all its contents.
      */
-    const usePublicAgentSpaces = () => {
-        return useQuery({
-            queryKey: queryKeys.agentSpaces.public(),
-            queryFn: async () => {
-                const resp = await requestDatalayer({
-                    url: `${configuration.spacerRunUrl}/api/spacer/v1/agent-spaces/public`,
-                    method: 'GET',
-                });
-                if (resp.success && resp.agentSpaces) {
-                    return resp.agentSpaces;
-                }
-                return [];
-            },
-            ...DEFAULT_QUERY_OPTIONS,
-        });
-    };
-    /**
-     * Create agent space
-     */
-    const useCreateAgentSpace = () => {
+    const useDeleteSpace = () => {
         return useMutation({
-            mutationFn: async (data) => {
+            mutationFn: async (spaceUid) => {
                 return requestDatalayer({
-                    url: `${configuration.spacerRunUrl}/api/spacer/v1/agent-spaces`,
-                    method: 'POST',
-                    body: data,
-                });
-            },
-            onSuccess: resp => {
-                if (resp.success && resp.agentSpace) {
-                    const agentSpace = resp.agentSpace;
-                    // Set detail cache
-                    queryClient.setQueryData(queryKeys.agentSpaces.detail(agentSpace.id), agentSpace);
-                    // Invalidate all agent space queries
-                    queryClient.invalidateQueries({
-                        queryKey: queryKeys.agentSpaces.all(),
-                    });
-                }
-            },
-        });
-    };
-    /**
-     * Update agent space
-     */
-    const useUpdateAgentSpace = () => {
-        return useMutation({
-            mutationFn: async ({ uid, data, }) => {
-                return requestDatalayer({
-                    url: `${configuration.spacerRunUrl}/api/spacer/v1/agent-spaces/${uid}`,
-                    method: 'PUT',
-                    body: data,
-                });
-            },
-            onSuccess: (resp, { uid }) => {
-                if (resp.success) {
-                    // Invalidate detail cache
-                    queryClient.invalidateQueries({
-                        queryKey: queryKeys.agentSpaces.detail(uid),
-                    });
-                    // Invalidate all agent space queries
-                    queryClient.invalidateQueries({
-                        queryKey: queryKeys.agentSpaces.all(),
-                    });
-                }
-            },
-        });
-    };
-    /**
-     * Delete agent space
-     */
-    const useDeleteAgentSpace = () => {
-        return useMutation({
-            mutationFn: async (uid) => {
-                return requestDatalayer({
-                    url: `${configuration.spacerRunUrl}/api/spacer/v1/agent-spaces/${uid}`,
+                    url: `${configuration.spacerRunUrl}/api/spacer/v1/spaces/${spaceUid}`,
                     method: 'DELETE',
                 });
             },
             onSuccess: () => {
-                // Invalidate all agent space queries
+                // Invalidate all space queries
                 queryClient.invalidateQueries({
-                    queryKey: queryKeys.agentSpaces.all(),
-                });
-            },
-        });
-    };
-    /**
-     * Make agent space public
-     */
-    const useMakeAgentSpacePublic = () => {
-        return useMutation({
-            mutationFn: async (uid) => {
-                return requestDatalayer({
-                    url: `${configuration.spacerRunUrl}/api/spacer/v1/agent-spaces/${uid}/public`,
-                    method: 'POST',
-                });
-            },
-            onSuccess: (resp, uid) => {
-                if (resp.success) {
-                    queryClient.invalidateQueries({
-                        queryKey: queryKeys.agentSpaces.detail(uid),
-                    });
-                    queryClient.invalidateQueries({
-                        queryKey: queryKeys.agentSpaces.all(),
-                    });
-                }
-            },
-        });
-    };
-    /**
-     * Make agent space private
-     */
-    const useMakeAgentSpacePrivate = () => {
-        return useMutation({
-            mutationFn: async (uid) => {
-                return requestDatalayer({
-                    url: `${configuration.spacerRunUrl}/api/spacer/v1/agent-spaces/${uid}/private`,
-                    method: 'POST',
+                    queryKey: queryKeys.spaces.all(),
                 });
             },
-            onSuccess: (resp, uid) => {
-                if (resp.success) {
-                    queryClient.invalidateQueries({
-                        queryKey: queryKeys.agentSpaces.detail(uid),
-                    });
-                    queryClient.invalidateQueries({
-                        queryKey: queryKeys.agentSpaces.all(),
-                    });
-                }
-            },
         });
     };
-    /**
-     * Refresh agent space data
-     */
-    const useRefreshAgentSpace = () => {
-        return (uid) => {
-            queryClient.invalidateQueries({
-                queryKey: queryKeys.agentSpaces.detail(uid),
-            });
-        };
-    };
-    /**
-     * Refresh agent spaces list
-     */
-    const useRefreshAgentSpaces = () => {
-        return () => {
-            queryClient.invalidateQueries({
-                queryKey: queryKeys.agentSpaces.all(),
-            });
-        };
-    };
-    /**
-     * Refresh public agent spaces list
-     */
-    const useRefreshPublicAgentSpaces = () => {
-        return () => {
-            queryClient.invalidateQueries({
-                queryKey: queryKeys.agentSpaces.public(),
-            });
-        };
-    };
     /**
      * List agent runtimes (runtimes with ai-agents-env environment)
      */
@@ -1604,6 +1405,7 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
                         // Map ingress URL to url for UI consistency
                         url: rt.ingress,
                         messageCount: 0, // Default for UI compatibility
+                        agent_spec_id: rt.agent_spec_id || undefined,
                     }));
                     // Set detail cache for each runtime
                     agentRuntimes.forEach((runtime) => {
@@ -1652,12 +1454,22 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
                         // Map ingress URL to url for UI consistency
                         url: rt.ingress,
                         messageCount: 0,
+                        agent_spec_id: rt.agent_spec_id || undefined,
                     };
                 }
                 throw new Error('Failed to fetch agent runtime');
             },
             ...DEFAULT_QUERY_OPTIONS,
-            refetchInterval: 5000, // Refetch every 5 seconds for status
+            // Poll every 5 seconds while the runtime exists. Stop polling on error
+            // (e.g. 404 — runtime deleted, 500 — broken state) to avoid hammering the server.
+            refetchInterval: query => {
+                if (query.state.error)
+                    return false;
+                return 5000;
+            },
+            // Don't retry failed detail requests. The refetchInterval handles
+            // periodic re-checks, so retrying only generates duplicate failing requests.
+            retry: false,
             enabled: !!podName,
         });
     };
@@ -1669,11 +1481,12 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
                     method: 'POST',
                     body: {
                         environment_name: data.environmentName || 'ai-agents-env',
-                        given_name: data.givenName || 'Agent Space',
+                        given_name: data.givenName || 'Agent',
                         credits_limit: data.creditsLimit || 10,
                         type: data.type || 'notebook',
                         editor_variant: data.editorVariant || 'none',
                         enable_codemode: data.enableCodemode ?? false,
+                        agent_spec_id: data.agentSpecId || undefined,
                     },
                 });
             },
@@ -1691,6 +1504,7 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
                         // Map ingress URL to url for UI consistency
                         url: rt.ingress,
                         messageCount: 0,
+                        agent_spec_id: rt.agent_spec_id || undefined,
                     });
                     // Invalidate list
                     queryClient.invalidateQueries({
@@ -3613,6 +3427,30 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
             ...DEFAULT_QUERY_OPTIONS,
         });
     };
+    /**
+     * Get default items (notebook UID & document UID) for a space / project.
+     * Calls GET /api/spacer/v1/spaces/{spaceId}/default-items
+     */
+    const useSpaceDefaultItems = (spaceId) => {
+        return useQuery({
+            queryKey: ['spaces', spaceId, 'default-items'],
+            queryFn: async () => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.spacerRunUrl}/api/spacer/v1/spaces/${spaceId}/default-items`,
+                    method: 'GET',
+                });
+                if (resp.success) {
+                    return {
+                        defaultNotebookUid: resp.default_notebook_uid,
+                        defaultDocumentUid: resp.default_document_uid,
+                    };
+                }
+                throw new Error(resp.message || 'Failed to fetch default items');
+            },
+            enabled: !!spaceId,
+            ...DEFAULT_QUERY_OPTIONS,
+        });
+    };
     /**
      * Make item public
      */
@@ -6467,6 +6305,7 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
         useUserSpaces,
         useCreateSpace,
         useUpdateSpace,
+        useDeleteSpace,
         useUpdateOrganizationSpace,
         useAddMemberToOrganizationSpace,
         useRemoveMemberFromOrganizationSpace,
@@ -6478,18 +6317,6 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
         useRefreshUserSpace,
         useRefreshLayout,
         useExportSpace,
-        // Agent Spaces
-        useAgentSpace,
-        useAgentSpaces,
-        usePublicAgentSpaces,
-        useCreateAgentSpace,
-        useUpdateAgentSpace,
-        useDeleteAgentSpace,
-        useMakeAgentSpacePublic,
-        useMakeAgentSpacePrivate,
-        useRefreshAgentSpace,
-        useRefreshAgentSpaces,
-        useRefreshPublicAgentSpaces,
         // Agent Runtimes (runtimes with ai-agents environment)
         useAgentRuntime,
         useAgentRuntimes,
@@ -6576,6 +6403,7 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
         // Items (Generic)
         useDeleteItem,
         useSpaceItems,
+        useSpaceDefaultItems,
         useMakeItemPublic,
         useMakeItemPrivate,
         useSearchPublicItems,

package/lib/hooks/useProjectStore.d.ts

@@ -0,0 +1,58 @@
+import type { Session } from '@jupyterlab/services';
+import type { IKernelConnection } from '@jupyterlab/services/lib/kernel/kernel';
+/**
+ * Per-project runtime state tracked in memory.
+ *
+ * This is **not** persisted — it represents live runtime objects
+ * (kernel connections, sessions) that only exist while the project
+ * view is mounted.
+ */
+export type ProjectRuntimeEntry = {
+    /** The Jupyter session connection (notebook ↔ kernel bridge). */
+    sessionConnection?: Session.ISessionConnection;
+    /** The assigned agent pod name (mirrors project.attachedAgentPodName). */
+    agentPodName?: string;
+    /** Display name of the assigned agent. */
+    agentName?: string;
+    /** Agent runtime status (running, starting, terminated, etc.). */
+    agentStatus?: string;
+    /** The agent spec ID used to create the runtime. */
+    agentSpecId?: string;
+};
+export type ProjectStoreState = {
+    /** Map of projectId → runtime entry. */
+    projects: Record<string, ProjectRuntimeEntry>;
+    /** The currently active/viewed project ID (for sidebar highlighting). */
+    currentProjectId: string | undefined;
+    /** Set the currently active project (call on mount, clear on unmount). */
+    setCurrentProjectId: (projectId: string | undefined) => void;
+    /** Set or update the session connection for a project. */
+    setSessionConnection: (projectId: string, sessionConnection: Session.ISessionConnection | undefined) => void;
+    /** Set the assigned agent info for a project. */
+    setAgent: (projectId: string, agentPodName: string | undefined, agentName?: string, agentStatus?: string, agentSpecId?: string) => void;
+    /** Remove all runtime state for a project (e.g. on unmount). */
+    clearProject: (projectId: string) => void;
+    /** Get the kernel connection for a project, or undefined. */
+    getKernel: (projectId: string) => IKernelConnection | null | undefined;
+    /** Get the full entry for a project. */
+    getEntry: (projectId: string) => ProjectRuntimeEntry | undefined;
+};
+/**
+ * Zustand store for per-project runtime state (kernel connections, agents).
+ *
+ * Not persisted — the data is ephemeral and only valid while the project
+ * component is mounted and a kernel/agent is active.
+ *
+ * Usage:
+ * ```ts
+ * import { useProjectStore } from '@datalayer/core/lib/hooks';
+ *
+ * // In Project.tsx — store session when Notebook connects:
+ * const setSessionConnection = useProjectStore(s => s.setSessionConnection);
+ * <Notebook onSessionConnection={sc => setSessionConnection(projectId, sc)} />
+ *
+ * // Anywhere — read the kernel for a project:
+ * const kernel = useProjectStore(s => s.getKernel(projectId));
+ * ```
+ */
+export declare const useProjectStore: import("zustand").UseBoundStore<import("zustand").StoreApi<ProjectStoreState>>;

package/lib/hooks/useProjectStore.js

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { create } from 'zustand';
+/**
+ * Zustand store for per-project runtime state (kernel connections, agents).
+ *
+ * Not persisted — the data is ephemeral and only valid while the project
+ * component is mounted and a kernel/agent is active.
+ *
+ * Usage:
+ * ```ts
+ * import { useProjectStore } from '@datalayer/core/lib/hooks';
+ *
+ * // In Project.tsx — store session when Notebook connects:
+ * const setSessionConnection = useProjectStore(s => s.setSessionConnection);
+ * <Notebook onSessionConnection={sc => setSessionConnection(projectId, sc)} />
+ *
+ * // Anywhere — read the kernel for a project:
+ * const kernel = useProjectStore(s => s.getKernel(projectId));
+ * ```
+ */
+export const useProjectStore = create()((set, get) => ({
+    projects: {},
+    currentProjectId: undefined,
+    setCurrentProjectId: projectId => set({ currentProjectId: projectId }),
+    setSessionConnection: (projectId, sessionConnection) => set(state => ({
+        projects: {
+            ...state.projects,
+            [projectId]: {
+                ...state.projects[projectId],
+                sessionConnection,
+            },
+        },
+    })),
+    setAgent: (projectId, agentPodName, agentName, agentStatus, agentSpecId) => set(state => ({
+        projects: {
+            ...state.projects,
+            [projectId]: {
+                ...state.projects[projectId],
+                agentPodName,
+                agentName,
+                // When removing the agent, also clear the status.
+                // When setting, use provided status or preserve existing.
+                agentStatus: agentPodName !== undefined
+                    ? (agentStatus ?? state.projects[projectId]?.agentStatus)
+                    : undefined,
+                agentSpecId: agentPodName !== undefined
+                    ? (agentSpecId ?? state.projects[projectId]?.agentSpecId)
+                    : undefined,
+            },
+        },
+    })),
+    clearProject: projectId => set(state => {
+        const { [projectId]: _, ...rest } = state.projects;
+        return { projects: rest };
+    }),
+    getKernel: projectId => {
+        const entry = get().projects[projectId];
+        return entry?.sessionConnection?.kernel;
+    },
+    getEntry: projectId => get().projects[projectId],
+}));