@datalayer/agent-runtimes 1.0.9 → 1.0.17

package/lib/hooks/useProjects.js

@@ -0,0 +1,190 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Hook for fetching and managing projects.
+ *
+ * Projects are backed by the Spacer service as spaces with type_s="project".
+ * Projects persist forever — only agents can terminate.
+ *
+ * Free tier limits: max 3 projects per user.
+ *
+ * @module hooks/useProjects
+ */
+import { useMemo, useCallback } from 'react';
+import { useCache } from '@datalayer/core/lib/hooks/useCache';
+/** The space type value used to identify project spaces in Solr */
+export const PROJECT_SPACE_VARIANT = 'project';
+const normalizeProjectItems = (items) => {
+    if (Array.isArray(items)) {
+        return items;
+    }
+    if (items && typeof items === 'object') {
+        return [items];
+    }
+    return [];
+};
+const isProjectSpace = (space) => {
+    const variant = space?.variant ?? space?.variant_s;
+    if (variant !== PROJECT_SPACE_VARIANT) {
+        return false;
+    }
+    const items = normalizeProjectItems(space?.items);
+    if (items.length === 0) {
+        return true;
+    }
+    const hasNotebook = items.some(item => (item?.type_s ?? item?.type) === 'notebook');
+    const hasDocument = items.some(item => {
+        const type = item?.type_s ?? item?.type;
+        return type === 'document' || type === 'lexical';
+    });
+    return hasNotebook && hasDocument;
+};
+/**
+ * Hook to fetch user's projects (spaces with type "project").
+ *
+ * Uses the spacer service's spaces endpoint filtered by type.
+ */
+export function useProjects() {
+    const { useUserSpaces } = useCache();
+    const { data: allSpaces, ...rest } = useUserSpaces();
+    // Filter to only project-type spaces
+    const projects = useMemo(() => {
+        if (!allSpaces)
+            return [];
+        return allSpaces
+            .filter((space) => isProjectSpace(space))
+            .map((space) => ({
+            uid: space.uid,
+            id: space.id ?? space.uid,
+            handle: space.handle ?? space.handle_s,
+            name: space.name ?? space.name_t,
+            description: space.description ?? space.description_t ?? '',
+            createdAt: space.created_at ? new Date(space.created_at) : new Date(),
+            isPublic: space.public ?? space.public_b ?? false,
+            attachedAgentPodName: space.attached_agent_pod_name_s || undefined,
+            attachedAgentSpecId: space.attached_agent_spec_id_s || undefined,
+        }));
+    }, [allSpaces]);
+    return { data: projects, ...rest };
+}
+/**
+ * Hook to fetch a single project by UID.
+ */
+export function useProject(uid) {
+    const { useSpace } = useCache();
+    // useSpace requires a string – pass empty string when uid is undefined
+    // (the query is disabled when spaceId is falsy inside useCache)
+    const { data: space, ...rest } = useSpace(uid ?? '');
+    const project = useMemo(() => {
+        if (!space)
+            return undefined;
+        const s = space;
+        return {
+            uid: s.uid,
+            id: s.id ?? s.uid,
+            handle: s.handle ?? s.handle_s,
+            name: s.name ?? s.name_t,
+            description: s.description ?? s.description_t ?? '',
+            createdAt: s.created_at ? new Date(s.created_at) : new Date(),
+            isPublic: s.public ?? s.public_b ?? false,
+            attachedAgentPodName: s.attached_agent_pod_name_s || undefined,
+            attachedAgentSpecId: s.attached_agent_spec_id_s || undefined,
+        };
+    }, [space]);
+    return { data: project, ...rest };
+}
+/**
+ * Hook to create a new project.
+ * Creates a space with type "project" via the spacer service.
+ */
+export function useCreateProject() {
+    const { useCreateSpace } = useCache();
+    const createSpaceMutation = useCreateSpace();
+    const createProject = useCallback(async (request) => {
+        const spaceHandle = request.name
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '-')
+            .replace(/^-|-$/g, '');
+        return createSpaceMutation.mutateAsync({
+            space: {
+                name: request.name,
+                description: request.description || '',
+                handle: spaceHandle || `project-${Date.now()}`,
+                variant: PROJECT_SPACE_VARIANT,
+                public: false,
+            },
+        });
+    }, [createSpaceMutation]);
+    return {
+        ...createSpaceMutation,
+        createProject,
+    };
+}
+/**
+ * Hook to update a project (e.g. persist the attached agent pod name).
+ * Uses the spacer PUT endpoint via useUpdateSpace.
+ */
+export function useUpdateProject() {
+    const { useUpdateSpace } = useCache();
+    const updateSpaceMutation = useUpdateSpace();
+    /** Assign an agent runtime to the project */
+    const assignAgent = useCallback(async (project, agentPodName, agentSpecId) => {
+        return updateSpaceMutation.mutateAsync({
+            id: project.id,
+            name: project.name,
+            description: project.description,
+            attached_agent_pod_name_s: agentPodName,
+            attached_agent_spec_id_s: agentSpecId || '',
+        });
+    }, [updateSpaceMutation]);
+    /** Rename a project */
+    const renameProject = useCallback(async (project, newName) => {
+        return updateSpaceMutation.mutateAsync({
+            id: project.id,
+            name: newName,
+            description: project.description,
+        });
+    }, [updateSpaceMutation]);
+    /** Remove the agent assignment from the project */
+    const unassignAgent = useCallback(async (project) => {
+        return updateSpaceMutation.mutateAsync({
+            id: project.id,
+            name: project.name,
+            description: project.description,
+            attached_agent_pod_name_s: '',
+            attached_agent_spec_id_s: '',
+        });
+    }, [updateSpaceMutation]);
+    return {
+        ...updateSpaceMutation,
+        assignAgent,
+        unassignAgent,
+        renameProject,
+    };
+}
+/**
+ * Hook to refresh the projects list.
+ */
+export function useRefreshProjects() {
+    const { useRefreshUserSpaces } = useCache();
+    return useRefreshUserSpaces();
+}
+/**
+ * Hook to delete a project (space) and all its contents.
+ */
+export function useDeleteProject() {
+    const { useDeleteSpace } = useCache();
+    return useDeleteSpace();
+}
+/**
+ * Hook to fetch the default notebook and document UIDs for a project.
+ *
+ * This calls the spacer `GET /spaces/:uid/default-items` endpoint which
+ * returns the UID of the first notebook and first document in the space.
+ */
+export function useProjectDefaultItems(projectUid) {
+    const { useSpaceDefaultItems } = useCache();
+    return useSpaceDefaultItems(projectUid);
+}

package/lib/hooks/useRuntimes.d.ts

@@ -0,0 +1,5 @@
+export declare const useRuntimes: () => {
+    mountLocalFolder: (kernelId: string) => void;
+    unmountLocalFolder: (kernelId: string) => void;
+};
+export default useRuntimes;

package/lib/hooks/useRuntimes.js

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { requestJupyterKernelsExtension } from '../jupyter/kernelsHandler';
+export const useRuntimes = () => {
+    // Folder Mounting ----------------------------------------------------------
+    const mountLocalFolder = (kernelId) => {
+        requestJupyterKernelsExtension(`jump/${kernelId}`)
+            .then(data => {
+            //        console.log('--- Mount Local Folder', data);
+        })
+            .catch(reason => {
+            console.error(`Error while accessing the jupyter server jupyter_kernels extension.\n${reason}`);
+        });
+    };
+    const unmountLocalFolder = (kernelId) => {
+        requestJupyterKernelsExtension(`jump/${kernelId}`, {
+            method: 'DELETE',
+        })
+            .then(data => {
+            //        console.log('--- Unmount Local Folder', data);
+        })
+            .catch(reason => {
+            console.error(`Error while accessing the jupyter server jupyter_kernels extension.\n${reason}`);
+        });
+    };
+    // --------------------------------------------------------------------------
+    return {
+        mountLocalFolder,
+        unmountLocalFolder,
+    };
+};
+export default useRuntimes;

package/lib/hooks/useToolApprovals.d.ts

@@ -18,6 +18,14 @@ export type ApprovalRecord = {
     toolArgs: Record<string, unknown>;
     status: string;
     note?: string | null;
+    requester_uid?: string;
+    requesterUid?: string;
+    requested_by?: string;
+    requestedBy?: string;
+    resolved_by?: string;
+    resolvedBy?: string;
+    resolved_at?: string;
+    resolvedAt?: string;
     created_at: string;
     createdAt: string;
     updated_at?: string;
@@ -39,10 +47,10 @@ interface MutationResult {
         note?: string;
     }) => Promise<void>;
 }
-export declare function useToolApprovalsQuery(filters?: ToolApprovalFilters): import("@tanstack/react-query").UseQueryResult<ApprovalsQueryData, Error>;
-export declare function usePendingApprovalCount(): import("@tanstack/react-query").UseQueryResult<{
+export declare function useToolApprovalsQuery(filters?: ToolApprovalFilters): import("@tanstack/react-query").UseQueryResult<NoInfer<ApprovalsQueryData>, Error>;
+export declare function usePendingApprovalCount(): import("@tanstack/react-query").UseQueryResult<NoInfer<{
     count: number;
-}, Error>;
+}>, Error>;
 export declare function useApproveToolRequest(): MutationResult;
 export declare function useRejectToolRequest(): MutationResult;
 export declare function useMarkToolApprovalRead(): MutationResult;
@@ -56,10 +64,10 @@ export declare function useMarkToolApprovalUnread(): MutationResult;
  */
 export declare function useDeleteToolApproval(): MutationResult;
 export declare function useToolApprovals(filters?: ToolApprovalFilters): {
-    approvalsQuery: import("@tanstack/react-query").UseQueryResult<ApprovalsQueryData, Error>;
-    pendingCountQuery: import("@tanstack/react-query").UseQueryResult<{
+    approvalsQuery: import("@tanstack/react-query").UseQueryResult<NoInfer<ApprovalsQueryData>, Error>;
+    pendingCountQuery: import("@tanstack/react-query").UseQueryResult<NoInfer<{
         count: number;
-    }, Error>;
+    }>, Error>;
     approve: MutationResult;
     reject: MutationResult;
     markRead: MutationResult;

package/lib/hooks/useToolApprovals.js

@@ -42,6 +42,17 @@ function normalizeApproval(raw) {
         {};
     const created = str(rec.created_at ?? rec.createdAt);
     const updated = str(rec.updated_at ?? rec.updatedAt);
+    const resolvedBy = str(rec.resolved_by ?? rec.resolvedBy);
+    const requesterUid = str(rec.requester_uid ?? rec.requesterUid);
+    const requestedBy = str(rec.requested_by ?? rec.requestedBy);
+    const resolvedAtRaw = str(rec.resolved_at ?? rec.resolvedAt);
+    const status = str(rec.status ?? 'pending');
+    // Keep reviewer metadata from WS payloads. If this is dropped during
+    // normalization, downstream pages receive status=approved/rejected but no
+    // reviewer/timestamp context and can incorrectly render "review pending".
+    // Some producers only set updated_at on decision; for non-pending statuses,
+    // fall back to updated_at so UI can still show a decision time.
+    const resolvedAt = resolvedAtRaw || (status !== 'pending' ? updated || undefined : undefined);
     return {
         id,
         agent_id: agent,
@@ -54,12 +65,20 @@ function normalizeApproval(raw) {
         toolCallId: typeof toolCall === 'string' ? toolCall : undefined,
         tool_args: args,
         toolArgs: args,
-        status: str(rec.status ?? 'pending'),
+        status,
         note: typeof rec.note === 'string'
             ? rec.note
             : rec.note === null
                 ? null
                 : undefined,
+        requester_uid: requesterUid || undefined,
+        requesterUid: requesterUid || undefined,
+        requested_by: requestedBy || undefined,
+        requestedBy: requestedBy || undefined,
+        resolved_by: resolvedBy || undefined,
+        resolvedBy: resolvedBy || undefined,
+        resolved_at: resolvedAt,
+        resolvedAt: resolvedAt,
         created_at: created,
         createdAt: created,
         updated_at: updated || undefined,

package/lib/index.d.ts

@@ -1,9 +1,10 @@
 export * from './chat';
 export * from './client';
+export * from './collaboration';
 export * from './components';
 export * from './mcp';
 export * from './stores';
 export * from './identity';
 export * from './config';
 export * from './specs';
-export type { AgentRuntimeData, AgentSpec, BenchmarkSpec, ChatCommonProps, TeamSpec, GuardrailSpec, EvalSpec, TriggerSpec, OutputSpec, NotificationChannelSpec, MCPServer, SkillSpec, SkillInfo, SkillStatus, EnvvarSpec, ToolCallStartContext, ToolCallCompleteContext, } from './types';
+export type { AgentRuntimeData, Agentspec, BenchmarkSpec, ChatCommonProps, TeamSpec, GuardrailSpec, EvalSpec, TriggerSpec, OutputSpec, NotificationChannelSpec, MCPServer, SkillSpec, SkillInfo, SkillStatus, EnvvarSpec, ToolCallStartContext, ToolCallCompleteContext, } from './types';

package/lib/index.js

@@ -4,6 +4,7 @@
  */
 export * from './chat';
 export * from './client';
+export * from './collaboration';
 export * from './components';
 export * from './mcp';
 export * from './stores';

package/lib/jupyter/exec/Python.d.ts

@@ -0,0 +1,5 @@
+export declare function listVariables(): string;
+export declare function saveVariables(variables: string[]): string;
+export declare function loadVariables(variables: string): string;
+export declare function changeCurrentWorkingDirectory(path: string): string;
+export declare function getOutputCandidates(code: string): string[];

package/lib/jupyter/exec/Python.js

@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+export function listVariables() {
+    return `
+def _list_variables():
+    import json
+    from types import BuiltinFunctionType, BuiltinMethodType, FunctionType, MethodType, MethodWrapperType, ModuleType, TracebackType
+
+    _FORBIDDEN_TYPES = [type, BuiltinFunctionType, BuiltinMethodType, FunctionType, MethodType, MethodWrapperType, ModuleType, TracebackType]
+    try:
+        from IPython.core.autocall import ExitAutocall
+        _FORBIDDEN_TYPES.append(ExitAutocall)
+    except ImportError:
+        pass
+    _exclude = tuple(_FORBIDDEN_TYPES)
+
+    _all = frozenset(globals())
+    _vars = {}
+    for _n in _all:
+        _v = globals()[_n]
+        
+        if not (
+            _n.startswith('_') or
+            isinstance(_v, _exclude) or
+            # Special IPython variables
+            (_n == 'In' and isinstance(_v, list)) or
+            (_n == 'Out' and isinstance(_v, dict))
+        ):
+            _vars[_n] = type(_v).__qualname__
+
+    return json.dumps(_vars)
+
+_list_variables()`;
+}
+export function saveVariables(variables) {
+    return `
+def _pickle_variables():
+    from base64 import encodebytes
+    import json
+    import pickle
+    _names = {${variables.map(v => `"${v}"`).join(',')}}
+    _data = {}
+    for _n in _names:
+        try:
+            _v = globals()[_n]
+            dump = pickle.dumps(_v)
+            _data[_n] = encodebytes(dump).decode("ascii")
+        except:
+            ...
+
+    return json.dumps(_data)
+
+_pickle_variables()
+`;
+}
+export function loadVariables(variables) {
+    return `
+def _load_variables():
+    from base64 import decodebytes
+    import json
+    import pickle
+    _data = json.loads(${variables})
+    _loaded = []
+    for _n, _v in _data.items():
+        try:
+            dump = decodebytes(_v.encode("ascii"))
+            globals()[_n] = pickle.loads(dump)
+            _loaded.append(_n)
+        except:
+            ...
+    return json.dumps(_loaded)
+
+_load_variables()
+`;
+}
+export function changeCurrentWorkingDirectory(path) {
+    const formattedPath = path
+        .split('/')
+        .map(seg => `"${seg}"`)
+        .join(' / ');
+    return `
+def _change_current_directory():
+    import os
+    from pathlib import Path
+    _local_content_mount_point = Path(Path.home() / ${formattedPath})
+    _local_content_mount_point.mkdir(parents=True, exist_ok=True)
+    os.chdir(_local_content_mount_point)
+
+    assert Path.cwd() == _local_content_mount_point
+
+_change_current_directory()
+`;
+}
+export function getOutputCandidates(code) {
+    return Array.from(code.matchAll(/^((?<output>[A-z][\w]*)\s*=[^=]|\((?<walrus>[A-z][\w]*)\s*:=[^=)]+\))/gm))
+        .map(match => match.groups?.output ?? match.groups?.walrus ?? '')
+        .filter(n => !!n);
+}

package/lib/jupyter/exec/Snippets.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Runtime snippets.
+ */
+export interface IRuntimeSnippets {
+    /**
+     * Code snippet to change the current working directory.
+     *
+     * @param path New current directory
+     * @returns The code snippet
+     */
+    changeCurrentWorkingDirectory(path: string): string;
+    /**
+     * Code snippet to list the transferable kernel variables.
+     *
+     * @returns The code snippet
+     */
+    listVariables(): string;
+    /**
+     * Code snippet to load kernel variables.
+     *
+     * @param variables Serialized-JSON dictionary (<variable name>, <variable value blob>)
+     * @returns The code snippet
+     */
+    loadVariables(variables: string): string;
+    /**
+     * Code snippet to save kernel variables.
+     *
+     * @param variables Variable names.
+     * @returns The code snippet
+     */
+    saveVariables(variables: string[]): string;
+    /**
+     * Extract output variables candidates by parsing the cell content.
+     *
+     * @param code Cell code source
+     * @returns The output variable candidates
+     */
+    getOutputCandidates(code: string): string[];
+}
+/**
+ * Facade to interact with kernels by requesting code execution.
+ */
+export declare class RuntimeSnippetsFacade {
+    private static $language;
+    /**
+     * Register a facade for a given language
+     *
+     * @param language Kernel language
+     * @param API Kernel API
+     */
+    static register(language: string, API: IRuntimeSnippets): void;
+    /**
+     * Whether there is an API for the given kernel language
+     *
+     * @param language Kernel language
+     */
+    static supports(language: string): boolean;
+    private _language;
+    /**
+     * Create a kernel snippet generator for a given kernel language.
+     *
+     * @param language Kernel language
+     */
+    constructor(language: string);
+    /**
+     * Kernel language
+     */
+    get language(): string;
+    /**
+     * Code snippet to change the current working directory.
+     *
+     * The code snippet has no returned value.
+     *
+     * @param path New current directory
+     * @returns The code snippet
+     */
+    changeCurrentWorkingDirectory(path: string): string;
+    /**
+     * Code snippet to list the transferable kernel variables.
+     *
+     * @returns The code snippet
+     */
+    listVariables(): string;
+    /**
+     * Code snippet to load kernel variables.
+     *
+     * @param variables Serialized-JSON dictionary (<variable name>, <variable value blob>)
+     * @returns The code snippet
+     */
+    loadVariables(variables: string): string;
+    /**
+     * Code snippet to save kernel variables.
+     *
+     * @param variables Variable names.
+     * @returns The code snippet
+     */
+    saveVariables(variables: string[]): string;
+    /**
+     * Extract output variables candidates by parsing the cell content.
+     *
+     * @param code Cell code source
+     * @returns The output variable candidates
+     */
+    getOutputCandidates(code: string): string[];
+}

package/lib/jupyter/exec/Snippets.js

@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import * as Python from './Python';
+/**
+ * Facade to interact with kernels by requesting code execution.
+ */
+export class RuntimeSnippetsFacade {
+    static $language = new Map();
+    /**
+     * Register a facade for a given language
+     *
+     * @param language Kernel language
+     * @param API Kernel API
+     */
+    static register(language, API) {
+        this.$language.set(language, API);
+    }
+    /**
+     * Whether there is an API for the given kernel language
+     *
+     * @param language Kernel language
+     */
+    static supports(language) {
+        return this.$language.has(language);
+    }
+    _language;
+    /**
+     * Create a kernel snippet generator for a given kernel language.
+     *
+     * @param language Kernel language
+     */
+    constructor(language) {
+        if (!RuntimeSnippetsFacade.$language.has(language)) {
+            throw new Error(`${language} is not supported.`);
+        }
+        this._language = language;
+    }
+    /**
+     * Kernel language
+     */
+    get language() {
+        return this._language;
+    }
+    /**
+     * Code snippet to change the current working directory.
+     *
+     * The code snippet has no returned value.
+     *
+     * @param path New current directory
+     * @returns The code snippet
+     */
+    changeCurrentWorkingDirectory(path) {
+        return RuntimeSnippetsFacade.$language
+            .get(this.language)
+            .changeCurrentWorkingDirectory(path);
+    }
+    /**
+     * Code snippet to list the transferable kernel variables.
+     *
+     * @returns The code snippet
+     */
+    listVariables() {
+        return RuntimeSnippetsFacade.$language.get(this.language).listVariables();
+    }
+    /**
+     * Code snippet to load kernel variables.
+     *
+     * @param variables Serialized-JSON dictionary (<variable name>, <variable value blob>)
+     * @returns The code snippet
+     */
+    loadVariables(variables) {
+        return RuntimeSnippetsFacade.$language
+            .get(this.language)
+            .loadVariables(variables);
+    }
+    /**
+     * Code snippet to save kernel variables.
+     *
+     * @param variables Variable names.
+     * @returns The code snippet
+     */
+    saveVariables(variables) {
+        return RuntimeSnippetsFacade.$language
+            .get(this.language)
+            .saveVariables(variables);
+    }
+    /**
+     * Extract output variables candidates by parsing the cell content.
+     *
+     * @param code Cell code source
+     * @returns The output variable candidates
+     */
+    getOutputCandidates(code) {
+        return RuntimeSnippetsFacade.$language
+            .get(this.language)
+            .getOutputCandidates(code);
+    }
+}
+RuntimeSnippetsFacade.register('python', Python);

package/lib/jupyter/exec/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Python';
+export * from './Snippets';

package/lib/jupyter/exec/index.js

@@ -0,0 +1,6 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+export * from './Python';
+export * from './Snippets';

package/lib/jupyter/index.d.ts

@@ -0,0 +1,2 @@
+export * from './exec';
+export * from './kernelsHandler';

package/lib/jupyter/index.js

@@ -0,0 +1,6 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+export * from './exec';
+export * from './kernelsHandler';

package/lib/jupyter/kernelsHandler.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Call the jupyter_kernels extension
+ *
+ * @param endPoint API REST end point for the extension
+ * @param init Initial values for the request
+ * @returns The response body interpreted as JSON
+ */
+export declare function requestJupyterKernelsExtension<T>(endPoint?: string, init?: RequestInit): Promise<T>;