@datalayer/core 0.0.25 → 0.0.27

package/lib/hooks/useCache.js

@@ -272,6 +272,21 @@ 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'],
+        lists: () => [...queryKeys.agentRuntimes.all(), 'list'],
+        details: () => [...queryKeys.agentRuntimes.all(), 'detail'],
+        detail: (podName) => [...queryKeys.agentRuntimes.details(), podName],
+    },
     // Layout
     layout: {
         byAccount: (accountHandle, spaceHandle) => spaceHandle
@@ -1334,6 +1349,398 @@ 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)
+     */
+    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 = () => {
+        return useMutation({
+            mutationFn: async (data) => {
+                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}`,
+                    method: 'DELETE',
+                });
+            },
+            onSuccess: () => {
+                // Invalidate all agent 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',
+                });
+            },
+            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)
+     */
+    /**
+     * Get all agent runtimes for the current user.
+     *
+     * Note on phase/status mapping:
+     * The backend (operator) RuntimePod model does not include a 'phase' field.
+     * The operator only keeps active/assigned runtimes in its cache (OperatorCache.USER_RUNTIMES),
+     * so any runtime returned by this endpoint is inherently running or starting.
+     * Therefore, if rt.phase is undefined (which it will be), we default to 'running'.
+     * A 'paused' state would require explicit backend support to track paused runtimes.
+     */
+    const useAgentRuntimes = () => {
+        return useQuery({
+            queryKey: queryKeys.agentRuntimes.lists(),
+            queryFn: async () => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.runtimesRunUrl}/api/runtimes/v1/runtimes`,
+                    method: 'GET',
+                });
+                if (resp.success && resp.runtimes) {
+                    // Filter to only include ai-agents-env runtimes
+                    const agentRuntimes = resp.runtimes
+                        .filter((rt) => rt.environment_name === 'ai-agents-env')
+                        .map((rt) => ({
+                        ...rt,
+                        // Phase/status mapping: see hook JSDoc for details.
+                        // Backend returns only active runtimes, so default to 'running'.
+                        status: rt.phase === 'Pending'
+                            ? 'starting'
+                            : rt.phase === 'Terminated'
+                                ? 'terminated'
+                                : rt.phase === 'Paused'
+                                    ? 'paused'
+                                    : rt.phase === 'Archived'
+                                        ? 'archived'
+                                        : 'running',
+                        name: rt.given_name || rt.pod_name,
+                        id: rt.pod_name,
+                        // Map ingress URL to url for UI consistency
+                        url: rt.ingress,
+                        messageCount: 0, // Default for UI compatibility
+                    }));
+                    // Set detail cache for each runtime
+                    agentRuntimes.forEach((runtime) => {
+                        queryClient.setQueryData(queryKeys.agentRuntimes.detail(runtime.pod_name), runtime);
+                    });
+                    return agentRuntimes;
+                }
+                return [];
+            },
+            ...DEFAULT_QUERY_OPTIONS,
+            refetchInterval: 10000, // Refetch every 10 seconds for status updates
+            enabled: !!user,
+        });
+    };
+    /**
+     * Get a single agent runtime by pod name.
+     *
+     * Note on phase/status mapping:
+     * Same as useAgentRuntimes - the backend RuntimePod model has no 'phase' field,
+     * and only active runtimes exist in the operator cache. Default to 'running'.
+     */
+    const useAgentRuntime = (podName) => {
+        return useQuery({
+            queryKey: queryKeys.agentRuntimes.detail(podName ?? ''),
+            queryFn: async () => {
+                const resp = await requestDatalayer({
+                    url: `${configuration.runtimesRunUrl}/api/runtimes/v1/runtimes/${podName}`,
+                    method: 'GET',
+                });
+                if (resp.runtime) {
+                    const rt = resp.runtime;
+                    return {
+                        ...rt,
+                        // Phase/status mapping: see useAgentRuntimes JSDoc for details.
+                        status: rt.phase === 'Pending'
+                            ? 'starting'
+                            : rt.phase === 'Terminated'
+                                ? 'terminated'
+                                : rt.phase === 'Paused'
+                                    ? 'paused'
+                                    : rt.phase === 'Archived'
+                                        ? 'archived'
+                                        : 'running',
+                        name: rt.given_name || rt.pod_name,
+                        id: rt.pod_name,
+                        // Map ingress URL to url for UI consistency
+                        url: rt.ingress,
+                        messageCount: 0,
+                    };
+                }
+                throw new Error('Failed to fetch agent runtime');
+            },
+            ...DEFAULT_QUERY_OPTIONS,
+            refetchInterval: 5000, // Refetch every 5 seconds for status
+            enabled: !!podName,
+        });
+    };
+    const useCreateAgentRuntime = () => {
+        return useMutation({
+            mutationFn: async (data) => {
+                return requestDatalayer({
+                    url: `${configuration.runtimesRunUrl}/api/runtimes/v1/runtimes`,
+                    method: 'POST',
+                    body: {
+                        environment_name: data.environmentName || 'ai-agents-env',
+                        given_name: data.givenName || 'Agent Space',
+                        credits_limit: data.creditsLimit || 10,
+                        type: data.type || 'notebook',
+                        editor_variant: data.editorVariant || 'none',
+                        enable_codemode: data.enableCodemode ?? false,
+                    },
+                });
+            },
+            onSuccess: resp => {
+                if (resp.success && resp.runtime) {
+                    const rt = resp.runtime;
+                    // Phase/status mapping: see useAgentRuntimes JSDoc for details.
+                    queryClient.setQueryData(queryKeys.agentRuntimes.detail(rt.pod_name), {
+                        ...rt,
+                        status: rt.phase === 'Pending'
+                            ? 'starting'
+                            : 'running',
+                        name: rt.given_name || rt.pod_name,
+                        id: rt.pod_name,
+                        // Map ingress URL to url for UI consistency
+                        url: rt.ingress,
+                        messageCount: 0,
+                    });
+                    // Invalidate list
+                    queryClient.invalidateQueries({
+                        queryKey: queryKeys.agentRuntimes.all(),
+                    });
+                }
+            },
+        });
+    };
+    /**
+     * Delete agent runtime
+     */
+    const useDeleteAgentRuntime = () => {
+        return useMutation({
+            mutationFn: async (podName) => {
+                return requestDatalayer({
+                    url: `${configuration.runtimesRunUrl}/api/runtimes/v1/runtimes/${podName}`,
+                    method: 'DELETE',
+                });
+            },
+            onSuccess: (_data, podName) => {
+                // Cancel any in-flight queries for the deleted runtime so they
+                // don't re-fetch a resource that no longer exists.
+                queryClient.cancelQueries({
+                    queryKey: queryKeys.agentRuntimes.detail(podName),
+                });
+                // Remove the detail cache entry immediately — prevents React
+                // Query from triggering a stale re-fetch while the component
+                // unmounts.
+                queryClient.removeQueries({
+                    queryKey: queryKeys.agentRuntimes.detail(podName),
+                });
+                // Invalidate the list so the sidebar refreshes.
+                queryClient.invalidateQueries({
+                    queryKey: queryKeys.agentRuntimes.lists(),
+                });
+            },
+        });
+    };
+    /**
+     * Refresh agent runtimes list
+     */
+    const useRefreshAgentRuntimes = () => {
+        return () => {
+            queryClient.invalidateQueries({
+                queryKey: queryKeys.agentRuntimes.all(),
+            });
+        };
+    };
+    // ============================================================================
     // Notebook Hooks
     // ============================================================================
     /**
@@ -4799,7 +5206,9 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
                 if (!resp.success) {
                     throw new Error(resp.message || 'Failed to search public items');
                 }
-                return resp.items || [];
+                return (resp.items || [])
+                    .map((item) => toItem(item))
+                    .filter(Boolean);
             },
         });
     };
@@ -4824,6 +5233,23 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
             },
         });
     };
+    /**
+     * Get Google profile from access token
+     */
+    const useGetGoogleProfile = () => {
+        return useMutation({
+            mutationFn: async (accessToken) => {
+                const response = await fetch('https://openidconnect.googleapis.com/v1/userinfo', {
+                    method: 'GET',
+                    headers: {
+                        Accept: 'application/json',
+                        Authorization: `Bearer ${accessToken}`,
+                    },
+                });
+                return response.json();
+            },
+        });
+    };
     /**
      * Get LinkedIn profile via proxy
      */
@@ -4880,68 +5306,87 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
     const usePostLinkedinShareWithUpload = () => {
         return useMutation({
             mutationFn: async ({ linkedinUserUrn, postText, uploadObject, accessToken, }) => {
-                // Step 1: Register upload
-                const registerUploadRequest = {
-                    registerUploadRequest: {
-                        recipes: ['urn:li:digitalmediaRecipe:feedshare-image'],
-                        owner: linkedinUserUrn,
-                        serviceRelationships: [
-                            {
-                                relationshipType: 'OWNER',
-                                identifier: 'urn:li:userGeneratedContent',
-                            },
-                        ],
-                    },
-                };
-                const registerResp = await requestDatalayer({
-                    url: `${configuration.iamRunUrl}/api/iam/v1/proxy/request`,
-                    method: 'POST',
-                    body: {
-                        request_method: 'POST',
-                        request_url: 'https://api.linkedin.com/v2/assets?action=registerUpload',
-                        request_token: accessToken,
-                        request_body: registerUploadRequest,
-                    },
-                });
-                const asset = registerResp.response.value.asset;
-                const uploadUrl = registerResp.response.value.uploadMechanism['com.linkedin.digitalmedia.uploading.MediaUploadHttpRequest'].uploadUrl;
-                // Step 2: Upload image
-                await requestDatalayer({
-                    url: `${configuration.iamRunUrl}/api/iam/v1/proxy/request`,
-                    method: 'POST',
-                    body: {
-                        request_method: 'PUT',
-                        request_url: uploadUrl,
-                        request_token: accessToken,
-                        request_body: {
-                            uploadURL: uploadUrl,
-                            content: uploadObject,
-                            userURN: linkedinUserUrn,
-                        },
-                    },
-                });
-                // Step 3: Create share with media
-                const shareRequest = {
-                    author: linkedinUserUrn,
-                    lifecycleState: 'PUBLISHED',
-                    specificContent: {
-                        'com.linkedin.ugc.ShareContent': {
-                            shareCommentary: { text: postText },
-                            shareMediaCategory: 'IMAGE',
-                            media: [
+                let shareRequest;
+                if (uploadObject) {
+                    // Step 1: Register upload
+                    const registerUploadRequest = {
+                        registerUploadRequest: {
+                            recipes: ['urn:li:digitalmediaRecipe:feedshare-image'],
+                            owner: linkedinUserUrn,
+                            serviceRelationships: [
                                 {
-                                    status: 'READY',
-                                    description: { text: 'Datalayer Notebook' },
-                                    media: asset,
-                                    title: { text: 'Datalayer Notebook' },
+                                    relationshipType: 'OWNER',
+                                    identifier: 'urn:li:userGeneratedContent',
                                 },
                             ],
                         },
-                    },
-                    visibility: {
-                        'com.linkedin.ugc.MemberNetworkVisibility': 'PUBLIC',
-                    },
-                };
+                    };
+                    const registerResp = await requestDatalayer({
+                        url: `${configuration.iamRunUrl}/api/iam/v1/proxy/request`,
+                        method: 'POST',
+                        body: {
+                            request_method: 'POST',
+                            request_url: 'https://api.linkedin.com/v2/assets?action=registerUpload',
+                            request_token: accessToken,
+                            request_body: registerUploadRequest,
+                        },
+                    });
+                    const asset = registerResp.response.value.asset;
+                    const uploadUrl = registerResp.response.value.uploadMechanism['com.linkedin.digitalmedia.uploading.MediaUploadHttpRequest'].uploadUrl;
+                    // Step 2: Upload image
+                    await requestDatalayer({
+                        url: `${configuration.iamRunUrl}/api/iam/v1/proxy/request`,
+                        method: 'POST',
+                        body: {
+                            request_method: 'PUT',
+                            request_url: uploadUrl,
+                            request_token: accessToken,
+                            request_body: {
+                                uploadURL: uploadUrl,
+                                content: uploadObject,
+                                userURN: linkedinUserUrn,
+                            },
+                        },
+                    });
+                    // Step 3: Create share with media
+                    shareRequest = {
+                        author: linkedinUserUrn,
+                        lifecycleState: 'PUBLISHED',
+                        specificContent: {
+                            'com.linkedin.ugc.ShareContent': {
+                                shareCommentary: { text: postText },
+                                shareMediaCategory: 'IMAGE',
+                                media: [
+                                    {
+                                        status: 'READY',
+                                        description: { text: 'Datalayer Notebook' },
+                                        media: asset,
+                                        title: { text: 'Datalayer Notebook' },
+                                    },
+                                ],
+                            },
+                        },
+                        visibility: {
+                            'com.linkedin.ugc.MemberNetworkVisibility': 'PUBLIC',
+                        },
+                    };
+                }
+                else {
+                    // Text-only share (no image upload)
+                    shareRequest = {
+                        author: linkedinUserUrn,
+                        lifecycleState: 'PUBLISHED',
+                        specificContent: {
+                            'com.linkedin.ugc.ShareContent': {
+                                shareCommentary: { text: postText },
+                                shareMediaCategory: 'NONE',
+                            },
+                        },
+                        visibility: {
+                            'com.linkedin.ugc.MemberNetworkVisibility': 'PUBLIC',
+                        },
+                    };
+                }
                 return requestDatalayer({
                     url: `${configuration.iamRunUrl}/api/iam/v1/proxy/request`,
                     method: 'POST',
@@ -5958,6 +6403,7 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
         useOAuth2AuthorizationURL,
         useOAuth2AuthorizationLinkURL,
         useGetGitHubProfile,
+        useGetGoogleProfile,
         useGetLinkedinProfile,
         usePostLinkedinShare,
         usePostLinkedinShareWithUpload,
@@ -6032,6 +6478,24 @@ 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,
+        useCreateAgentRuntime,
+        useDeleteAgentRuntime,
+        useRefreshAgentRuntimes,
         // Courses
         useCourse,
         useUpdateCourse,

package/lib/hooks/useCellOutputshot.js

@@ -4,13 +4,13 @@
  */
 import { useState } from 'react';
 import { useCellStore } from '../state';
-import { takeHTMLNodeScreenshot } from '../utils/Screenshot';
+import { takeHTMLNodeScreencapture } from '../utils/Screencapture';
 const useCellOutputshot = () => {
     const [outputshot, setOutputshot] = useState('');
     const [error, setError] = useState();
     const { update } = useCellStore();
     const takeOutputshot = (node) => {
-        takeHTMLNodeScreenshot(node)
+        takeHTMLNodeScreencapture(node)
             .then(outputshotData => {
             setOutputshot(outputshotData);
             update({

package/lib/hooks/useScreencapture.d.ts

@@ -0,0 +1,18 @@
+import { ReactNode } from 'react';
+export type ScreencaptureContextType = {
+    closeScreencapture: () => void;
+    displayScreencapture: (nextScreencapture: any) => void;
+};
+export declare const ScreencaptureContext: import("react").Context<ScreencaptureContextType>;
+export declare function useScreencapture(): ScreencaptureContextType;
+/**
+ * The type for the Screencapture context provider.
+ */
+export declare const ScreencaptureContextProvider: import("react").Provider<ScreencaptureContextType>;
+export type IScreencaptureProviderProps = {
+    children?: ReactNode;
+    zIndex?: number;
+    disableDarken?: boolean;
+    screenshotSurface?: (qfds: any) => JSX.Element;
+};
+export declare function ScreencaptureProvider({ children, zIndex, disableDarken, screenshotSurface, }: IScreencaptureProviderProps): import("react/jsx-runtime").JSX.Element;