@datalayer/core 0.0.12 → 0.0.14

package/lib/components/runtimes/RuntimeUtils.d.ts

@@ -1,6 +1,6 @@
 import { SessionContext } from '@jupyterlab/apputils';
 import { ITranslator } from '@jupyterlab/translation';
-import { IMultiServiceManager } from '../../sdk/stateful/runtimes';
+import { IMultiServiceManager } from '../../stateful/runtimes';
 import { IRuntimeDesc } from '../../models';
 export type IDatalayerRuntimeDesc = IRuntimeDesc & {
     gpu?: string;

package/lib/components/snapshots/RuntimeSnapshotMenu.d.ts

@@ -1,6 +1,6 @@
 import { type PropsWithChildren } from 'react';
 import { Kernel } from '@jupyterlab/services';
-import { IMultiServiceManager } from '../../sdk/stateful/runtimes';
+import { IMultiServiceManager } from '../../stateful/runtimes';
 /**
  * Runtime snapshot menu component properties
  */

package/lib/components/snapshots/RuntimeSnapshotMenu.js

@@ -5,10 +5,11 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
  */
 import { useCallback, useEffect, useState, } from 'react';
 import { CameraIcon } from '@datalayer/icons-react';
-import { ActionList, ActionMenu, Box, Flash, FormControl, Select, Spinner, } from '@primer/react';
+import { ActionList, ActionMenu, Flash, FormControl, Select, Spinner, } from '@primer/react';
 import { Dialog } from '@primer/react/experimental';
+import { Box } from '@datalayer/primer-addons';
 import { useToast } from '../../hooks';
-import { createRuntimeSnapshot, getRuntimeSnapshots, loadBrowserRuntimeSnapshot, loadRuntimeSnapshot, } from '../../sdk/stateful/runtimes';
+import { createRuntimeSnapshot, getRuntimeSnapshots, loadBrowserRuntimeSnapshot, loadRuntimeSnapshot, } from '../../stateful/runtimes';
 import { useRuntimesStore } from '../../state';
 import { createRuntimeSnapshotName } from '../../utils';
 /**
@@ -17,10 +18,10 @@ import { createRuntimeSnapshotName } from '../../utils';
 export function RuntimeSnapshotMenu(props) {
     const { children, connection, podName, multiServiceManager, disabled } = props;
     const { addRuntimeSnapshot, runtimesRunUrl, runtimeSnapshots, setRuntimeSnapshots, } = useRuntimesStore();
-    const { trackAsyncTask } = useToast();
+    const { enqueueToast, trackAsyncTask } = useToast();
     const [openLoadDialog, setOpenLoadDialog] = useState(false);
-    const [loadingKernelSnapshot, setLoadingKernelSnapshot] = useState(false);
-    const [takingKernelSnapshot, setTakingSnapshot] = useState(false);
+    const [loadingRuntimeSnapshot, setLoadingRuntimeSnapshot] = useState(false);
+    const [takingRuntimeSnapshot, setTakingRuntimeSnapshot] = useState(false);
     const [selection, setSelection] = useState(runtimeSnapshots[0]?.id ?? '');
     const [error, setError] = useState();
     useEffect(() => {
@@ -35,31 +36,37 @@ export function RuntimeSnapshotMenu(props) {
             console.error(`Failed to fetch remote kernel snapshots; ${reason}`);
         });
     }, [runtimesRunUrl]);
-    const onLoadKernelSnapshot = useCallback(() => {
+    const onLoadRuntimeSnapshot = useCallback(() => {
         setError(undefined);
         setOpenLoadDialog(true);
     }, []);
-    const onKerenelSnapshotChanged = useCallback(event => {
+    const onRuntimeSnapshotChanged = useCallback(event => {
         setSelection(event.target.value);
     }, []);
-    const onLoadKernelSnapshotSubmit = useCallback(async ({ id, connection, podName, }) => {
+    const onLoadRuntimeSnapshotSubmit = useCallback(async ({ id, connection, podName, }) => {
         if (podName) {
             await loadRuntimeSnapshot({ id: podName, from: id });
+            enqueueToast(`Runtime snapshot ${podName} is loaded.`, {
+                variant: 'success',
+            });
         }
         else if (connection) {
             await loadBrowserRuntimeSnapshot({ connection, id });
+            enqueueToast(`Runtime snapshot ${id} is loaded.`, {
+                variant: 'success',
+            });
         }
     }, []);
-    const onTakeKernelSnapshot = useCallback(async () => {
+    const onTakeRuntimeSnapshot = useCallback(async () => {
         try {
-            setTakingSnapshot(true);
+            setTakingRuntimeSnapshot(true);
             let snapshot;
             let task;
             let ref = '';
             let snapshotName = '';
             if (podName && multiServiceManager?.remote) {
                 snapshotName = createRuntimeSnapshotName('cloud');
-                task = multiServiceManager.remote.runtimesManager.snapshot({
+                task = multiServiceManager.remote.runtimesManager.snapshotRuntime({
                     podName,
                     name: snapshotName,
                     description: snapshotName,
@@ -97,7 +104,7 @@ export function RuntimeSnapshotMenu(props) {
                         message: (reason, data) => {
                             const msg = reason === 'Empty snapshot'
                                 ? `Runtime ${ref} will not be snapshotted as it does not contain any serializable state.`
-                                : `Failed to pause runtime ${ref} - ${reason}`;
+                                : `Failed to snapshot runtime ${ref} - ${reason}`;
                             return msg;
                         },
                     },
@@ -113,10 +120,10 @@ export function RuntimeSnapshotMenu(props) {
             }
         }
         finally {
-            setTakingSnapshot(false);
+            setTakingRuntimeSnapshot(false);
         }
     }, [connection, podName, multiServiceManager]);
-    return (_jsxs(_Fragment, { children: [_jsxs(ActionMenu, { children: [_jsx(ActionMenu.Button, { leadingVisual: CameraIcon, variant: "invisible", size: "small", disabled: loadingKernelSnapshot || takingKernelSnapshot || disabled, children: children }), _jsx(ActionMenu.Overlay, { children: _jsxs(ActionList, { children: [_jsx(ActionList.Item, { onSelect: onLoadKernelSnapshot, disabled: loadingKernelSnapshot || runtimeSnapshots.length === 0, children: "Load a runtime snapshot\u2026" }), _jsx(ActionList.Item, { onSelect: onTakeKernelSnapshot, disabled: takingKernelSnapshot, children: "Take a runtime snapshot" })] }) })] }), openLoadDialog && (_jsx(Dialog, { title: _jsx("span", { style: { color: 'var(--fgColor-default)' }, children: "Choose a runtime snapshot to load" }), onClose: () => {
+    return (_jsxs(_Fragment, { children: [_jsxs(ActionMenu, { children: [_jsx(ActionMenu.Button, { leadingVisual: CameraIcon, variant: "invisible", size: "small", disabled: loadingRuntimeSnapshot || takingRuntimeSnapshot || disabled, children: children }), _jsx(ActionMenu.Overlay, { children: _jsxs(ActionList, { children: [_jsx(ActionList.Item, { onSelect: onLoadRuntimeSnapshot, disabled: loadingRuntimeSnapshot || runtimeSnapshots.length === 0, children: "Load a runtime snapshot\u2026" }), _jsx(ActionList.Item, { onSelect: onTakeRuntimeSnapshot, disabled: takingRuntimeSnapshot, children: "Take a runtime snapshot" })] }) })] }), openLoadDialog && (_jsx(Dialog, { title: _jsx("span", { style: { color: 'var(--fgColor-default)' }, children: "Choose a runtime snapshot to load" }), onClose: () => {
                     setOpenLoadDialog(false);
                 }, footerButtons: [
                     {
@@ -131,17 +138,17 @@ export function RuntimeSnapshotMenu(props) {
                     },
                     {
                         buttonType: 'primary',
-                        content: loadingKernelSnapshot ? (_jsx(Spinner, { size: "small" })) : ('Load'),
-                        disabled: loadingKernelSnapshot,
+                        content: loadingRuntimeSnapshot ? (_jsx(Spinner, { size: "small" })) : ('Load'),
+                        disabled: loadingRuntimeSnapshot,
                         onClick: async (event) => {
                             if (!event.defaultPrevented) {
                                 event.preventDefault();
-                                setLoadingKernelSnapshot(true);
+                                setLoadingRuntimeSnapshot(true);
                                 try {
                                     setError(undefined);
                                     const snapshot = runtimeSnapshots.find(s => s.id === selection);
                                     if (snapshot && (connection || podName)) {
-                                        await onLoadKernelSnapshotSubmit({
+                                        await onLoadRuntimeSnapshotSubmit({
                                             connection,
                                             id: snapshot.id,
                                             podName,
@@ -152,14 +159,14 @@ export function RuntimeSnapshotMenu(props) {
                                     }
                                 }
                                 finally {
-                                    setLoadingKernelSnapshot(false);
+                                    setLoadingRuntimeSnapshot(false);
                                     setOpenLoadDialog(false);
                                 }
                             }
                         },
                         autoFocus: true,
                     },
-                ], children: _jsxs(Box, { as: "form", children: [_jsxs(FormControl, { children: [_jsx(FormControl.Label, { children: "Snapshot" }), _jsx(Select, { name: "snapshot", value: selection, onChange: onKerenelSnapshotChanged, block: true, children: runtimeSnapshots.map(s => (_jsx(Select.Option, { value: s.id, children: s.name ? `${s.name} (${s.id})` : s.id }, s.id))) })] }), error && _jsx(Flash, { variant: "danger", children: error })] }) }))] }));
+                ], children: _jsxs(Box, { as: "form", children: [_jsxs(FormControl, { children: [_jsx(FormControl.Label, { children: "Snapshot" }), _jsx(Select, { name: "snapshot", value: selection, onChange: onRuntimeSnapshotChanged, block: true, children: runtimeSnapshots.map(s => (_jsx(Select.Option, { value: s.id, children: s.name ? `${s.name} (${s.id})` : s.id }, s.id))) })] }), error && _jsx(Flash, { variant: "danger", children: error })] }) }))] }));
 }
 RuntimeSnapshotMenu.defaultProps = {
     disabled: false,

package/lib/config/Configuration.d.ts

@@ -63,6 +63,14 @@ export type IDatalayerCoreConfig = {
      * AI Agents API URL.
      */
     aiagentsRunUrl: string;
+    /**
+     * AI Inference API URL.
+     */
+    aiinferenceRunUrl: string;
+    /**
+     * MCP Servers API URL.
+     */
+    mcpserversRunUrl: string;
     /**
      * Growth API URL.
      */

package/lib/hooks/useDatalayer.js

@@ -36,7 +36,7 @@ export function useDatalayer(props = {}) {
             if (error.name === 'RunResponseError') {
                 const responseError = error;
                 if (responseError.response.status === 401) {
-                    console.log('Datalayer RUN sent a 401 return code.');
+                    console.log('Datalayer sent a 401 return code.');
                     if (location.pathname !== loginRoute_) {
                         iamStore.logout();
                         navigate(loginRoute_);

package/lib/hooks/useRuntimes.js

@@ -2,7 +2,7 @@
  * Copyright (c) 2023-2025 Datalayer, Inc.
  * Distributed under the terms of the Modified BSD License.
  */
-import { requestJupyterKernelsExtension } from '../sdk/stateful/jupyter/kernelsHandler';
+import { requestJupyterKernelsExtension } from '../stateful/jupyter/kernelsHandler';
 export const useRuntimes = () => {
     // Folder Mounting ----------------------------------------------------------
     const mountLocalFolder = (kernelId) => {

package/lib/hooks/useToast.js

@@ -41,7 +41,7 @@ function createContent(message, closeHandler, actions) {
                     })] }))] }));
 }
 export const useToast = () => {
-    // This CANNOT use React hooks as it is used outside React context.
+    // This CANNOT use Jupyter React hooks as it may be used outside Jupyter React context.
     const insideJupyterLab = isInsideJupyterLab();
     const enqueueToast = (message, options = { variant: 'info' }) => {
         const { actions, autoClose } = options;

package/lib/index.d.ts

@@ -7,9 +7,8 @@ export * from './hooks';
 export { requestDatalayerAPI, RunResponseError, NetworkError, } from './api/DatalayerApi';
 export type { IRequestDatalayerAPIOptions } from './api/DatalayerApi';
 export { API_BASE_PATHS } from './api/constants';
-export * from './api/types';
 export * as runtimesApi from './api/runtimes';
 export * as iamApi from './api/iam';
 export * as spacerApi from './api/spacer';
-export { DatalayerSDK, type DatalayerSDKConfig } from './sdk/client';
-export { getEnvironments, createRuntime, getRuntimes, deleteRuntime, snapshotRuntime, getRuntimeSnapshots, loadRuntimeSnapshot, } from './sdk/stateful/runtimes/actions';
+export { DatalayerClient, type DatalayerClientConfig, type SDKHandlers, User, Runtime, Environment, Snapshot, Space, Notebook, LexicalDTO, Credits, Item, type RuntimeJSON, type EnvironmentJSON, type UserJSON, } from './client';
+export { getEnvironments, createRuntime, getRuntimes, deleteRuntime, snapshotRuntime, getRuntimeSnapshots, loadRuntimeSnapshot, } from './stateful/runtimes/actions';

package/lib/index.js

@@ -12,10 +12,11 @@ export * from './hooks';
 // Export API and SDK layers
 export { requestDatalayerAPI, RunResponseError, NetworkError, } from './api/DatalayerApi';
 export { API_BASE_PATHS } from './api/constants';
-export * from './api/types';
 export * as runtimesApi from './api/runtimes';
 export * as iamApi from './api/iam';
 export * as spacerApi from './api/spacer';
-export { DatalayerSDK } from './sdk/client';
+export { DatalayerClient, 
+// Export SDK models
+User, Runtime, Environment, Snapshot, Space, Notebook, LexicalDTO, Credits, Item, } from './client';
 // Export commonly used SDK functions directly for convenience
-export { getEnvironments, createRuntime, getRuntimes, deleteRuntime, snapshotRuntime, getRuntimeSnapshots, loadRuntimeSnapshot, } from './sdk/stateful/runtimes/actions';
+export { getEnvironments, createRuntime, getRuntimes, deleteRuntime, snapshotRuntime, getRuntimeSnapshots, loadRuntimeSnapshot, } from './stateful/runtimes/actions';

package/lib/models/Common.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Common types shared across all Datalayer API services.
+ *
+ * @module api/types/common
+ */
+/**
+ * Standard health check response used by all services.
+ * @interface HealthzPingResponse
+ */
+export interface HealthzPingResponse {
+    /** Whether the request was successful */
+    success: boolean;
+    /** Response message from the server */
+    message: string;
+    /** Service status information */
+    status?: {
+        /** Status indicator (e.g., "OK") */
+        status: string;
+    };
+    /** API version */
+    version?: string;
+}
+/**
+ * Standard error response structure.
+ * @interface ErrorResponse
+ */
+export interface ErrorResponse {
+    /** Whether the request was successful (always false for errors) */
+    success: false;
+    /** Error message */
+    message: string;
+    /** Optional error code */
+    code?: string;
+    /** Optional additional error details */
+    details?: any;
+}
+/**
+ * Standard pagination parameters.
+ * @interface PaginationParams
+ */
+export interface PaginationParams {
+    /** Page number (1-based) */
+    page?: number;
+    /** Items per page */
+    limit?: number;
+    /** Sort field */
+    sort?: string;
+    /** Sort order */
+    order?: 'asc' | 'desc';
+}
+/**
+ * Standard pagination response metadata.
+ * @interface PaginationMeta
+ */
+export interface PaginationMeta {
+    /** Current page */
+    page: number;
+    /** Items per page */
+    limit: number;
+    /** Total number of items */
+    total: number;
+    /** Total number of pages */
+    totalPages: number;
+}

package/lib/models/CreditsDTO.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Credit information for a user.
+ */
+export interface CreditsInfo {
+    /** Available credits */
+    credits: number;
+    /** Credit quota (null if unlimited) */
+    quota: number | null;
+    /** Last update timestamp */
+    last_update: string;
+}
+/**
+ * Credit reservation information.
+ */
+export interface CreditReservation {
+    /** Reservation ID */
+    id: string;
+    /** Reserved credits */
+    credits: number;
+    /** Resource ID (e.g., runtime ID) */
+    resource: string;
+    /** Last update timestamp */
+    last_update: string;
+    /** Burning rate (credits per hour) for this reservation */
+    burning_rate: number;
+    /** Start date of the reservation */
+    start_date: string;
+}
+/**
+ * Response from the credits endpoint.
+ */
+export interface CreditsResponse {
+    /** Operation success status */
+    success: boolean;
+    /** Credit information */
+    credits: CreditsInfo;
+    /** Active credit reservations */
+    reservations: CreditReservation[];
+}
+/**
+ * Credits model representing user's available credits and usage.
+ *
+ * @example
+ * ```typescript
+ * const credits = await sdk.getCredits();
+ * console.log(`Available: ${credits.available}`);
+ * console.log(`Quota: ${credits.quota || 'unlimited'}`);
+ *
+ * // Calculate maximum runtime for an environment
+ * const maxMinutes = credits.calculateMaxRuntimeMinutes(environment.burningRate);
+ * ```
+ */
+export declare class CreditsDTO {
+    /** @internal */
+    _data: CreditsInfo;
+    private _reservations;
+    constructor(data: CreditsInfo, reservations?: CreditReservation[]);
+    /**
+     * Available credits for the user.
+     */
+    get available(): number;
+    /**
+     * Credit quota for the user.
+     * Returns null if unlimited.
+     */
+    get quota(): number | null;
+    /**
+     * Last update timestamp.
+     */
+    get lastUpdate(): string;
+    /**
+     * Active credit reservations.
+     */
+    get reservations(): CreditReservation[];
+    /**
+     * Total reserved credits across all reservations.
+     */
+    get totalReserved(): number;
+    /**
+     * Net available credits (available minus reserved).
+     */
+    get netAvailable(): number;
+    /**
+     * Get runtime reservations (reservations that start with 'runtime-').
+     */
+    get runtimeReservations(): CreditReservation[];
+    /**
+     * Check if there are any active runtime reservations.
+     */
+    get hasActiveRuntimes(): boolean;
+    /**
+     * Calculate maximum runtime in minutes based on environment burning rate.
+     *
+     * @param burningRate - Credits consumed per hour
+     * @returns Maximum runtime in minutes
+     */
+    calculateMaxRuntimeMinutes(burningRate: number): number;
+    /**
+     * Calculate credits needed for runtime duration.
+     *
+     * @param minutes - Runtime duration in minutes
+     * @param burningRate - Credits consumed per hour
+     * @returns Credits needed
+     */
+    calculateCreditsFromMinutes(minutes: number, burningRate: number): number;
+    /**
+     * Check if user has enough credits for runtime.
+     *
+     * @param minutes - Runtime duration in minutes
+     * @param burningRate - Credits consumed per hour
+     * @returns True if user has enough credits
+     */
+    hasEnoughCreditsForRuntime(minutes: number, burningRate: number): boolean;
+    /**
+     * Convert to JSON representation.
+     */
+    toJSON(): CreditsInfo & {
+        reservations: CreditReservation[];
+    };
+    /**
+     * String representation of credits.
+     */
+    toString(): string;
+}

package/lib/models/CreditsDTO.js

@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Credits model for the Datalayer SDK.
+ *
+ * @module models/CreditsDTO
+ */
+import { validateJSON } from '../api/utils/validation';
+/**
+ * Credits model representing user's available credits and usage.
+ *
+ * @example
+ * ```typescript
+ * const credits = await sdk.getCredits();
+ * console.log(`Available: ${credits.available}`);
+ * console.log(`Quota: ${credits.quota || 'unlimited'}`);
+ *
+ * // Calculate maximum runtime for an environment
+ * const maxMinutes = credits.calculateMaxRuntimeMinutes(environment.burningRate);
+ * ```
+ */
+export class CreditsDTO {
+    /** @internal */
+    _data;
+    _reservations;
+    constructor(data, reservations = []) {
+        this._data = data;
+        this._reservations = reservations;
+    }
+    /**
+     * Available credits for the user.
+     */
+    get available() {
+        return this._data.credits;
+    }
+    /**
+     * Credit quota for the user.
+     * Returns null if unlimited.
+     */
+    get quota() {
+        return this._data.quota;
+    }
+    /**
+     * Last update timestamp.
+     */
+    get lastUpdate() {
+        return this._data.last_update;
+    }
+    /**
+     * Active credit reservations.
+     */
+    get reservations() {
+        return [...this._reservations];
+    }
+    /**
+     * Total reserved credits across all reservations.
+     */
+    get totalReserved() {
+        return this._reservations.reduce((sum, r) => sum + r.credits, 0);
+    }
+    /**
+     * Net available credits (available minus reserved).
+     */
+    get netAvailable() {
+        return Math.max(0, this.available - this.totalReserved);
+    }
+    /**
+     * Get runtime reservations (reservations that start with 'runtime-').
+     */
+    get runtimeReservations() {
+        return this._reservations.filter(r => r.id.startsWith('runtime-'));
+    }
+    /**
+     * Check if there are any active runtime reservations.
+     */
+    get hasActiveRuntimes() {
+        return this.runtimeReservations.length > 0;
+    }
+    /**
+     * Calculate maximum runtime in minutes based on environment burning rate.
+     *
+     * @param burningRate - Credits consumed per hour
+     * @returns Maximum runtime in minutes
+     */
+    calculateMaxRuntimeMinutes(burningRate) {
+        if (burningRate <= 0)
+            return 0;
+        const burningRatePerMinute = burningRate * 60;
+        return Math.floor(this.netAvailable / burningRatePerMinute);
+    }
+    /**
+     * Calculate credits needed for runtime duration.
+     *
+     * @param minutes - Runtime duration in minutes
+     * @param burningRate - Credits consumed per hour
+     * @returns Credits needed
+     */
+    calculateCreditsFromMinutes(minutes, burningRate) {
+        const burningRatePerMinute = burningRate * 60;
+        return minutes * burningRatePerMinute;
+    }
+    /**
+     * Check if user has enough credits for runtime.
+     *
+     * @param minutes - Runtime duration in minutes
+     * @param burningRate - Credits consumed per hour
+     * @returns True if user has enough credits
+     */
+    hasEnoughCreditsForRuntime(minutes, burningRate) {
+        const creditsNeeded = this.calculateCreditsFromMinutes(minutes, burningRate);
+        return this.netAvailable >= creditsNeeded;
+    }
+    /**
+     * Convert to JSON representation.
+     */
+    toJSON() {
+        // FIXME
+        const obj = {
+            ...this._data,
+            reservations: this._reservations,
+        };
+        validateJSON(obj, 'Credits');
+        return obj;
+    }
+    /**
+     * String representation of credits.
+     */
+    toString() {
+        const quotaStr = this.quota !== null ? ` of ${this.quota}` : '';
+        const reservedStr = this.totalReserved > 0 ? ` (${this.totalReserved} reserved)` : '';
+        return `Credits: ${this.available}${quotaStr}${reservedStr}`;
+    }
+}

package/lib/models/Environment.d.ts

@@ -60,7 +60,7 @@ export interface IDatalayerEnvironment {
     /**
      * Associate kernel attributes
      */
-    kernel?: {
+    runtime?: {
         /**
          * Proposed display name
          */