@datalayer/core 0.0.24 → 0.0.26

package/lib/client/utils/spacerUtils.d.ts

@@ -12,7 +12,7 @@ import { LexicalDTO } from '../../models/LexicalDTO';
  * to avoid code duplication.
  *
  * @param response - Raw API response containing space items
- * @param sdk - SDK instance to pass to model constructors
+ * @param sdk - Client instance to pass to model constructors
  * @returns Array of Notebook and Lexical model instances
  */
 export declare function convertSpaceItemsToModels(items: GetSpaceItemsResponse['items'], sdk: DatalayerClient): (NotebookDTO | LexicalDTO)[];

package/lib/client/utils/spacerUtils.js

@@ -11,7 +11,7 @@ import { ItemTypes } from '../constants';
  * to avoid code duplication.
  *
  * @param response - Raw API response containing space items
- * @param sdk - SDK instance to pass to model constructors
+ * @param sdk - Client instance to pass to model constructors
  * @returns Array of Notebook and Lexical model instances
  */
 export function convertSpaceItemsToModels(items, sdk) {

package/lib/components/progress/ConsumptionBar.js

@@ -9,6 +9,23 @@ import { Box } from '@datalayer/primer-addons';
 import { useInterval } from 'usehooks-ts';
 const CRITICAL_LEVEL = 90;
 const WARNING_LEVEL = 75;
+/**
+ * Format seconds into a human-friendly string (e.g., "2h 15m", "45m", "30s")
+ */
+function formatTimeRemaining(seconds) {
+    if (seconds < 0)
+        return '0s';
+    const hours = Math.floor(seconds / 3600);
+    const minutes = Math.floor((seconds % 3600) / 60);
+    const secs = Math.floor(seconds % 60);
+    if (hours > 0) {
+        return minutes > 0 ? `${hours}h ${minutes}m` : `${hours}h`;
+    }
+    if (minutes > 0) {
+        return secs > 0 && minutes < 5 ? `${minutes}m ${secs}s` : `${minutes}m`;
+    }
+    return `${secs}s`;
+}
 /**
  * Consumption progress bar
  */
@@ -36,8 +53,9 @@ export function ConsumptionBar(props) {
                 : 'success.emphasis'
         : 'neutral.emphasis';
     const burntCredits = duration * burningRate;
+    const secondsRemaining = (1 - progress / 100) * duration;
     const title = duration
-        ? `${((1 - progress / 100) * duration).toFixed(0)} seconds left - ${((progress / 100) * burntCredits).toFixed(2)} / ${burntCredits.toFixed(2)} credits`
+        ? `${formatTimeRemaining(secondsRemaining)} left - ${((progress / 100) * burntCredits).toFixed(2)} / ${burntCredits.toFixed(2)} credits`
         : `Started at ${new Date(startedAt * 1000).toISOString()} - ${burntCredits.toFixed(2)} credits consumed`;
     return (_jsx(_Fragment, { children: _jsx(Tooltip, { text: title, direction: "w", children: _jsx(Button, { variant: "invisible", children: _jsx(Box, { sx: { width: '70px' }, children: _jsx(ProgressBar, { tabIndex: onClick ? 0 : -1, style: style, animated: expiredAt ? false : true, bg: bg, progress: progress, onClick: onClick, onKeyDown: onClick
                             ? event => {

package/lib/hooks/useCache.d.ts

@@ -36,6 +36,7 @@
  */
 import { UseQueryOptions, UseMutationOptions } from '@tanstack/react-query';
 import { IAnyOrganization, IAnySpace, IAssignment, ICell, IContact, ICourse, IDataset, IDatasource, IDocument, IEnvironment, IExercise, IIAMToken, ILesson, INotebook, IOrganization, IPage, ISchool, ISecret, ITeam, IUser, IUserOnboarding, IUserSettings } from '../models';
+import type { AgentSpaceData, CreateAgentSpaceRequest, UpdateAgentSpaceRequest } from '../api/spacer/agentSpaces';
 export type CacheProps = {
     loginRoute?: string;
 };
@@ -212,6 +213,19 @@ export declare const queryKeys: {
         readonly bySpace: (spaceId: string) => readonly ["items", "space", string];
         readonly search: (opts: ISearchOpts) => readonly ["items", "search", ISearchOpts];
     };
+    readonly agentSpaces: {
+        readonly all: () => readonly ["agentSpaces"];
+        readonly lists: () => readonly ["agentSpaces", "list"];
+        readonly details: () => readonly ["agentSpaces", "detail"];
+        readonly detail: (id: string) => readonly ["agentSpaces", "detail", string];
+        readonly public: () => readonly ["agentSpaces", "public"];
+    };
+    readonly agentRuntimes: {
+        readonly all: () => readonly ["agentRuntimes"];
+        readonly lists: () => readonly ["agentRuntimes", "list"];
+        readonly details: () => readonly ["agentRuntimes", "detail"];
+        readonly detail: (podName: string) => readonly ["agentRuntimes", "detail", string];
+    };
     readonly layout: {
         readonly byAccount: (accountHandle: string, spaceHandle?: string) => readonly ["layout", string, string] | readonly ["layout", string];
     };
@@ -297,7 +311,10 @@ export declare const useCache: ({ loginRoute }?: CacheProps) => {
         token: string;
     }, unknown>;
     useOAuth2AuthorizationURL: () => import("@tanstack/react-query").UseMutationResult<string, Error, Record<string, string>, unknown>;
-    useOAuth2AuthorizationLinkURL: () => import("@tanstack/react-query").UseMutationResult<string, Error, Record<string, string>, unknown>;
+    useOAuth2AuthorizationLinkURL: () => import("@tanstack/react-query").UseMutationResult<{
+        success: boolean;
+        autorization_url: string;
+    }, Error, Record<string, string>, unknown>;
     useGetGitHubProfile: () => import("@tanstack/react-query").UseMutationResult<any, Error, string, unknown>;
     useGetLinkedinProfile: () => import("@tanstack/react-query").UseMutationResult<any, Error, string, unknown>;
     usePostLinkedinShare: () => import("@tanstack/react-query").UseMutationResult<any, Error, {
@@ -469,6 +486,67 @@ export declare const useCache: ({ loginRoute }?: CacheProps) => {
         spaceHandle?: string;
     }, unknown>;
     useExportSpace: () => import("@tanstack/react-query").UseMutationResult<any, Error, string, unknown>;
+    useAgentSpace: (uid: string | undefined) => import("@tanstack/react-query").UseQueryResult<AgentSpaceData, Error>;
+    useAgentSpaces: () => import("@tanstack/react-query").UseQueryResult<AgentSpaceData[], Error>;
+    usePublicAgentSpaces: () => import("@tanstack/react-query").UseQueryResult<AgentSpaceData[], Error>;
+    useCreateAgentSpace: () => import("@tanstack/react-query").UseMutationResult<any, Error, CreateAgentSpaceRequest, unknown>;
+    useUpdateAgentSpace: () => import("@tanstack/react-query").UseMutationResult<any, Error, {
+        uid: string;
+        data: UpdateAgentSpaceRequest;
+    }, unknown>;
+    useDeleteAgentSpace: () => import("@tanstack/react-query").UseMutationResult<any, Error, string, unknown>;
+    useMakeAgentSpacePublic: () => import("@tanstack/react-query").UseMutationResult<any, Error, string, unknown>;
+    useMakeAgentSpacePrivate: () => import("@tanstack/react-query").UseMutationResult<any, Error, string, unknown>;
+    useRefreshAgentSpace: () => (uid: string) => void;
+    useRefreshAgentSpaces: () => () => void;
+    useRefreshPublicAgentSpaces: () => () => void;
+    useAgentRuntime: (podName: string | undefined) => import("@tanstack/react-query").UseQueryResult<{
+        status: "running" | "paused" | "starting" | "terminated" | "archived";
+        name: string;
+        id: string;
+        url: string | undefined;
+        messageCount: number;
+        pod_name: string;
+        environment_name: string;
+        environment_title?: string;
+        given_name: string;
+        phase?: string;
+        type: string;
+        started_at?: string;
+        expired_at?: string;
+        burning_rate?: number;
+        ingress?: string;
+        token?: string;
+        agentSpec?: AgentSpaceData["agentSpec"];
+    }, Error>;
+    useAgentRuntimes: () => import("@tanstack/react-query").UseQueryResult<{
+        status: "running" | "paused" | "starting" | "terminated" | "archived";
+        name: string;
+        id: string;
+        url: string | undefined;
+        messageCount: number;
+        pod_name: string;
+        environment_name: string;
+        environment_title?: string;
+        given_name: string;
+        phase?: string;
+        type: string;
+        started_at?: string;
+        expired_at?: string;
+        burning_rate?: number;
+        ingress?: string;
+        token?: string;
+        agentSpec?: AgentSpaceData["agentSpec"];
+    }[], Error>;
+    useCreateAgentRuntime: () => import("@tanstack/react-query").UseMutationResult<any, Error, {
+        environmentName?: string;
+        givenName?: string;
+        creditsLimit?: number;
+        type?: string;
+        editorVariant?: string;
+    }, unknown>;
+    useDeleteAgentRuntime: () => import("@tanstack/react-query").UseMutationResult<any, Error, string, unknown>;
+    useRefreshAgentRuntimes: () => () => void;
     useCourse: (courseId: string) => import("@tanstack/react-query").UseQueryResult<ICourse | undefined, Error>;
     useUpdateCourse: () => import("@tanstack/react-query").UseMutationResult<any, Error, {
         courseId: string;
@@ -655,7 +733,9 @@ export declare const useCache: ({ loginRoute }?: CacheProps) => {
     useUpdateDatasource: () => import("@tanstack/react-query").UseMutationResult<any, Error, IDatasource, unknown>;
     useSecret: (secretId: string, options?: {
         enabled?: boolean;
-        refetchOnMount?: boolean;
+        refetchOnMount?: boolean | "always";
+        staleTime?: number;
+        gcTime?: number;
     }) => import("@tanstack/react-query").UseQueryResult<ISecret | null | undefined, Error>;
     useSecrets: () => import("@tanstack/react-query").UseQueryResult<any, Error>;
     useCreateSecret: () => import("@tanstack/react-query").UseMutationResult<any, Error, Omit<ISecret, "id">, unknown>;
@@ -946,6 +1026,19 @@ export declare const useCache: ({ loginRoute }?: CacheProps) => {
             readonly bySpace: (spaceId: string) => readonly ["items", "space", string];
             readonly search: (opts: ISearchOpts) => readonly ["items", "search", ISearchOpts];
         };
+        readonly agentSpaces: {
+            readonly all: () => readonly ["agentSpaces"];
+            readonly lists: () => readonly ["agentSpaces", "list"];
+            readonly details: () => readonly ["agentSpaces", "detail"];
+            readonly detail: (id: string) => readonly ["agentSpaces", "detail", string];
+            readonly public: () => readonly ["agentSpaces", "public"];
+        };
+        readonly agentRuntimes: {
+            readonly all: () => readonly ["agentRuntimes"];
+            readonly lists: () => readonly ["agentRuntimes", "list"];
+            readonly details: () => readonly ["agentRuntimes", "detail"];
+            readonly detail: (podName: string) => readonly ["agentRuntimes", "detail", string];
+        };
         readonly layout: {
             readonly byAccount: (accountHandle: string, spaceHandle?: string) => readonly ["layout", string, string] | readonly ["layout", string];
         };

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,386 @@ 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',
+                    },
+                });
+            },
+            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: () => {
+                // Invalidate all agent runtime queries
+                queryClient.invalidateQueries({
+                    queryKey: queryKeys.agentRuntimes.all(),
+                });
+            },
+        });
+    };
+    /**
+     * Refresh agent runtimes list
+     */
+    const useRefreshAgentRuntimes = () => {
+        return () => {
+            queryClient.invalidateQueries({
+                queryKey: queryKeys.agentRuntimes.all(),
+            });
+        };
+    };
+    // ============================================================================
     // Notebook Hooks
     // ============================================================================
     /**
@@ -1834,6 +2229,10 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
     /**
      * Get all secrets
      */
+    // TODO: Previously this hook pre-populated individual secret caches with setQueryData,
+    // but this prevented useSecret from fetching fresh data (e.g., the value field).
+    // Consider re-adding cache pre-population if the list endpoint returns full secret data,
+    // or use a different query key pattern for partial vs full secret data.
     const useSecrets = () => {
         return useQuery({
             queryKey: queryKeys.secrets.all(),
@@ -1844,13 +2243,7 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
                 });
                 if (resp.success && resp.secrets) {
                     const secrets = resp.secrets
-                        .map((s) => {
-                        const secret = toSecret(s);
-                        if (secret) {
-                            queryClient.setQueryData(queryKeys.secrets.detail(secret.id), secret);
-                        }
-                        return secret;
-                    })
+                        .map((s) => toSecret(s))
                         .filter(Boolean);
                     return secrets;
                 }
@@ -2208,6 +2601,8 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
             ...DEFAULT_QUERY_OPTIONS,
             enabled: options?.enabled ?? !!secretId,
             refetchOnMount: options?.refetchOnMount ?? DEFAULT_QUERY_OPTIONS.refetchOnMount,
+            staleTime: options?.staleTime ?? DEFAULT_QUERY_OPTIONS.staleTime,
+            gcTime: options?.gcTime ?? DEFAULT_QUERY_OPTIONS.gcTime,
         });
     };
     /**
@@ -4485,7 +4880,7 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
                 const resp = await requestDatalayer({
                     url: `${configuration.iamRunUrl}/api/iam/v1/oauth2/authz/url/link?${queryString}`,
                 });
-                return resp.autorization_url;
+                return resp;
             },
         });
     };
@@ -4835,7 +5230,7 @@ export const useCache = ({ loginRoute = '/login' } = {}) => {
                     method: 'POST',
                     body: {
                         request_method: 'GET',
-                        request_url: 'https://api.linkedin.com/v2/me',
+                        request_url: 'https://api.linkedin.com/v2/userinfo',
                         request_token: accessToken,
                     },
                 });
@@ -6032,6 +6427,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,