@datalayer/core 1.0.25 → 1.1.43

package/README.md

@@ -2,7 +2,7 @@
 
 [![Become a Sponsor](https://img.shields.io/static/v1?label=Become%20a%20Sponsor&message=%E2%9D%A4&logo=GitHub&style=flat&color=1ABC9C)](https://github.com/sponsors/datalayer)
 
-# ☰ 🌀 Datalayer Core
+# ☰ Datalayer Core
 
 <p align="center">
   <strong>Python and Typescript libraries for Datalayer</strong>
@@ -25,12 +25,10 @@ This package serves as the base foundation used by many other Datalayer packages
 ## Key Features
 
 - **🔐 Simple Authentication**: Easy token-based authentication with environment variable support
-- **⚡ Runtime Management**: Create and manage scalable compute runtimes (CPU/GPU) for code execution
-- **📸 Snapshot Management**: Create and manage compute snapshots of your runtimes for reproducible environments
 - **🔒 Secrets Management**: Securely handle sensitive data and credentials in your workflows
 - **🐍 Python Client**: Programmatic access to Datalayer platform with context managers and clean resource management
 - **🌐 TypeScript/React Client**: React components and services for building Jupyter-based applications
-- **💻 Command Line Interface**: CLI tools for managing runtimes, snapshots, and platform resources
+- **💻 Command Line Interface**: CLI tools for account and platform operations
 - **🔧 Base Classes**: Core application classes and configuration inherited by other Datalayer projects
 - **📓 Jupyter Integration**: ServiceManager and collaboration providers for notebook experiences
 - **🧭 Universal Navigation**: Smart navigation hooks that auto-detect and work with React Router, Next.js, or native browser
@@ -85,148 +83,27 @@ from datalayer_core import DatalayerClient
 client = DatalayerClient()
 
 # Or pass token directly
-client = DatalayerClient(token="your-token-here")
+client = DatalayerClient(api_key="your-api-key-here")
 
 if client.authenticate():
     print("Successfully authenticated!")
 ```
 
-### 2. Execute Code in a Runtime
+### 2. Runtime, Snapshots, and Evals
 
-Use context managers to create runtimes and ensure proper resource cleanup:
+Runtime execution, snapshot workflows, and evals CLI are now documented and maintained in:
 
-```python
-from datalayer_core import DatalayerClient
-
-client = DatalayerClient()
-
-# Execute code in a managed runtime
-with client.create_runtime() as runtime:
-    response = runtime.execute("print('Hello from Datalayer!')")
-    print(response.stdout)
-```
-
-### 3. Using the CLI
-
-The CLI provides command-line access to Datalayer platform features:
-
-```bash
-# List available runtimes
-datalayer runtime list
-
-# Create a new runtime
-datalayer runtime create ai-env --given-name my-runtime-123
-
-# Execute a script in a runtime
-datalayer runtime exec my-script.py --agent <agent-id>
-
-# Create a snapshot from a runtime but do not terminate the runtime
-datalayer snapshots create <pod-name> my-snapshot 'AI work!' False
-```
-
-### 4. Subscription and Credits CLI
-
-Use these commands to inspect billing and manage credits distribution.
-
-```bash
-# End-user billing view
-datalayer subscriptions show
-datalayer subscriptions available
-datalayer subscriptions move
-datalayer subscriptions topups
-datalayer subscriptions dry-run
-
-# Organization and team credits visibility
-datalayer usage org-overview --organization-uid <org_uid>
-datalayer usage team-overview --team-uid <team_uid>
-
-# Monitoring-driven credit management
-datalayer usage org-monitor --organization-uid <org_uid> --window-hours 24
-datalayer usage team-monitor --team-uid <team_uid> --window-hours 24
-
-# Credits transfer operations (owners/admins)
-datalayer usage org-allocate-team --organization-uid <org_uid> --team-uid <team_uid> --amount 50
-datalayer usage org-revoke-team --organization-uid <org_uid> --team-uid <team_uid> --amount 20
-datalayer usage team-allocate-member --team-uid <team_uid> --member-uid <member_uid> --amount 15
-datalayer usage team-revoke-member --team-uid <team_uid> --member-uid <member_uid> --amount 5
-```
-
-### 5. Evals CLI (Multi-Agentspec)
-
-Use comma-separated agentspec ids to create one experiment per agentspec variant:
-
-```bash
-# Creates one experiment per agentspec in the list
-datalayer evals experiments create my-exp \
-  --evalset-id <evalset_id> \
-  --agent-spec-ids example-evals,example-evals-nocodemode,example-custom
-```
+- [agent-runtimes README](https://github.com/datalayer/agent-runtimes/blob/main/README.md)
+- [agent-runtimes CLI docs](https://agent-runtimes.datalayer.tech/cli)
 
-Generate a comparison report:
-
-```bash
-datalayer evals report <evalset_id> --run-limit 50 --export
-```
-
-How to interpret grouped comparisons in the report:
-
-- `Within-Agentspec Pairwise Latest-Pass Deltas`: compares experiments using the same agentspec id.
-- `Cross-Agentspec Pairwise Latest-Pass Deltas`: compares experiments using different agentspec ids.
-- Pairwise sections compute all combinations for the selected experiments, not just two agentspecs.
+Use `agent-runtimes` for runtime workloads (`RuntimeClient`, `@datalayer`, snapshots, and evals), and use `datalayer-core` for account/platform operations (authentication, secrets, API keys, usage, profile).
 
 ## Examples
 
-### Python Examples
-
-For comprehensive Python usage examples, see the [`examples/`](https://github.com/datalayer/core/tree/main/examples) directory which includes:
-
-- **FastAPI + scikit-learn**: Web application with ML models
-- **Streamlit + scikit-learn**: Interactive data science apps
-- **PyTorch GPU workloads**: High-performance computing examples
-- **Decorator patterns**: Remote function execution with `@datalayer`
-- **And more**: Complete examples with documentation and setup instructions
-
-### TypeScript/React Examples
-
-Run the interactive examples locally:
-
-```bash
-# Install dependencies
-npm install
-
-# Set your Datalayer API token in .env
-echo "VITE_DATALAYER_API_KEY=your-token-here" > .env
-
-# Start the examples server
-npm run examples
-```
-
-Available at http://localhost:3000/:
-
-- **DatalayerNotebookExample**: Full integration with Datalayer services and collaboration
-- **NotebookExample**: Basic Jupyter notebook in React
-- **CellExample**: Individual code cell execution
-- **ReactRouterAdvancedExample**: Comprehensive navigation demo with React Router integration
-- **ReactRouterNavigationExample**: Basic navigation with route parameters
-- **NativeNavigationExample**: Browser-native navigation fallback
-
-### Next.js Application Example
-
-A complete Next.js application demonstrating platform integration:
-
-```bash
-cd examples/nextjj
-npm install
-npm run dev
-```
-
-Features:
+Examples have moved to Agent Runtimes:
 
-- Token authentication with Datalayer IAM
-- Browse and create notebooks from your workspace
-- Select compute environments for execution
-- Interactive notebook viewer with real-time outputs
-- Clean, responsive UI with GitHub Primer components
+- [Agent Runtimes examples README](https://github.com/datalayer/agent-runtimes/blob/main/examples/README.md)
+- [Agent Runtimes examples directory](https://github.com/datalayer/agent-runtimes/tree/main/examples)
 
 ## Platform Integration
 

package/lib/api/index.d.ts

@@ -10,13 +10,4 @@ export { requestDatalayerAPI, RunResponseError, NetworkError, } from './Datalaye
 export type { IRequestDatalayerAPIOptions } from './DatalayerApi';
 export * as iam from './iam';
 export * as otel from './otel';
-export * as runtimes from './runtimes';
-export * as scheduler from './scheduler';
-export * as spacer from './spacer';
-/**
- * @deprecated Please import directly from '@datalayer/core/stateful' instead.
- * This module provides backward compatibility for the moved apiv1 modules.
- */
-export * from '../stateful/jupyter';
-export * from '../stateful/runtimes';
 export * from '../api/DatalayerApi';

package/lib/api/index.js

@@ -15,13 +15,4 @@ export { requestDatalayerAPI, RunResponseError, NetworkError, } from './Datalaye
 // Domain-organized API exports
 export * as iam from './iam/index.js';
 export * as otel from './otel/index.js';
-export * as runtimes from './runtimes/index.js';
-export * as scheduler from './scheduler/index.js';
-export * as spacer from './spacer/index.js';
-/**
- * @deprecated Please import directly from '@datalayer/core/stateful' instead.
- * This module provides backward compatibility for the moved apiv1 modules.
- */
-export * from '../stateful/jupyter/index.js';
-export * from '../stateful/runtimes/index.js';
 export * from '../api/DatalayerApi.js';

package/lib/cli-login.js

@@ -0,0 +1,167 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { useCallback, useEffect, useState } from 'react';
+import { createRoot } from 'react-dom/client';
+import { Box, Button, Spinner, Text } from '@primer/react';
+import { ShieldLockIcon } from '@primer/octicons-react';
+import { DatalayerThemeProvider, themeConfigs, createThemeStore, } from '@datalayer/primer-addons';
+import { SvgLinesLogo, SvgUsecasesHero } from '@datalayer/design';
+import { AppearanceControlsWithStore } from '@datalayer/primer-addons/lib/components/appearance';
+import { ConfettiSuccess } from './components/confetti/index.js';
+import { formatFriendlyHandle } from './utils/Handles.js';
+import { SignInSimple } from './views/iam/SignInSimple.js';
+const DATALAYER_IAM_USER_KEY = '@datalayer/iam:user';
+const DATALAYER_IAM_TOKEN_KEY = '@datalayer/iam:token';
+const useCliThemeStore = createThemeStore('datalayer-core-cli-theme-v2', {
+    colorMode: 'dark',
+    theme: 'matrix',
+});
+const readStoredAuth = () => {
+    const token = window.localStorage.getItem(DATALAYER_IAM_TOKEN_KEY) || '';
+    const rawUser = window.localStorage.getItem(DATALAYER_IAM_USER_KEY) || '';
+    if (!token || !rawUser) {
+        return null;
+    }
+    try {
+        const user = JSON.parse(rawUser);
+        const userHandle = String(user?.handle || user?.handle_s || '').trim();
+        if (!userHandle) {
+            return null;
+        }
+        return { token, userHandle };
+    }
+    catch {
+        return null;
+    }
+};
+function SignInCLIApp() {
+    const [state, setState] = useState('checking');
+    const [message, setMessage] = useState('');
+    const [closeHelp, setCloseHelp] = useState('');
+    const { colorMode, theme: themeVariant } = useCliThemeStore();
+    const cfg = themeConfigs[themeVariant];
+    const handleCloseWindow = useCallback(() => {
+        setCloseHelp('');
+        // Browsers allow window.close() only for windows/tabs opened by script.
+        window.close();
+        setTimeout(() => {
+            if (!document.hidden) {
+                try {
+                    // Some browsers require a same-tab self-target before closing.
+                    window.open('', '_self');
+                    window.close();
+                }
+                catch {
+                    // Ignore and show manual-close help below.
+                }
+            }
+            if (!document.hidden) {
+                setCloseHelp('Authentication is complete. Your browser blocked auto-close for this tab, so you can safely close it manually.');
+            }
+        }, 150);
+    }, []);
+    const finalizeCliAuthentication = useCallback(async () => {
+        const auth = readStoredAuth();
+        if (!auth) {
+            setState('signin');
+            return;
+        }
+        const response = await fetch('/', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                user_handle: auth.userHandle,
+                token: auth.token,
+            }),
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(text || 'Failed to finalize CLI authentication.');
+        }
+        setMessage(`Successfully logged in as ${formatFriendlyHandle(auth.userHandle)}.`);
+        setState('success');
+    }, []);
+    useEffect(() => {
+        finalizeCliAuthentication().catch((error) => {
+            setMessage(error instanceof Error ? error.message : 'Authentication failed.');
+            setState('signin');
+        });
+    }, [finalizeCliAuthentication]);
+    const renderLayout = (content) => (_jsx(DatalayerThemeProvider, { colorMode: colorMode, theme: cfg.primerTheme, themeStyles: cfg.themeStyles, children: _jsxs(Box, { sx: {
+                minHeight: '100vh',
+                bg: 'canvas.default',
+                color: 'fg.default',
+                position: 'relative',
+            }, children: [_jsx(Box, { sx: {
+                        position: 'fixed',
+                        top: 0,
+                        right: 0,
+                        zIndex: 20,
+                        p: 3,
+                        display: 'flex',
+                        justifyContent: 'flex-end',
+                    }, children: _jsx(AppearanceControlsWithStore, { useStore: useCliThemeStore }) }), content] }) }));
+    if (state === 'checking') {
+        return renderLayout(_jsx(Box, { sx: {
+                display: 'flex',
+                alignItems: 'center',
+                justifyContent: 'center',
+                minHeight: '100vh',
+            }, children: _jsx(Spinner, {}) }));
+    }
+    if (state === 'success') {
+        return renderLayout(_jsxs(Box, { sx: {
+                minHeight: '100vh',
+                display: 'flex',
+                alignItems: 'center',
+                justifyContent: 'center',
+                px: 3,
+                position: 'relative',
+                overflow: 'hidden',
+            }, children: [_jsx(Box, { sx: {
+                        position: 'absolute',
+                        inset: 0,
+                        opacity: 0.45,
+                        pointerEvents: 'none',
+                    }, children: _jsx(SvgUsecasesHero, {}) }), _jsx(Box, { sx: {
+                        position: 'absolute',
+                        inset: 0,
+                        pointerEvents: 'none',
+                        zIndex: 2,
+                    }, children: _jsx(ConfettiSuccess, {}) }), _jsxs(Box, { sx: {
+                        position: 'relative',
+                        zIndex: 3,
+                        textAlign: 'center',
+                        maxWidth: 560,
+                        p: 4,
+                        borderRadius: 2,
+                        border: '1px solid',
+                        borderColor: 'border.default',
+                        bg: 'canvas.default',
+                    }, children: [_jsx(Box, { sx: { display: 'flex', justifyContent: 'center', mb: 3 }, children: _jsx(Box, { sx: { width: 210 }, children: _jsx(SvgLinesLogo, { height: 32 }) }) }), _jsx(Text, { as: "h2", sx: { display: 'block', fontSize: 3, fontWeight: 600, mb: 2 }, children: message || 'Successfully logged in.' }), _jsx(Text, { as: "p", sx: { color: 'fg.muted', mb: 3 }, children: "You can close this window." }), closeHelp && (_jsx(Text, { as: "p", sx: { color: 'fg.accent', mb: 3 }, children: closeHelp })), _jsx(Box, { sx: { display: 'flex', justifyContent: 'center' }, children: _jsx(Button, { onClick: handleCloseWindow, children: "Close this window" }) })] })] }));
+    }
+    return renderLayout(_jsx(SignInSimple, { name: "Datalayer CLI", description: "Sign in to continue in your CLI session.", icon: _jsx(ShieldLockIcon, { size: 24 }), github: true, google: true, linkedin: true, signUp: true, apiKey: false, socialSignInNavigationTarget: null, onSignIn: async (token, handle) => {
+            window.localStorage.setItem(DATALAYER_IAM_TOKEN_KEY, token);
+            window.localStorage.setItem(DATALAYER_IAM_USER_KEY, JSON.stringify({
+                handle,
+                displayName: handle,
+                uid: '',
+                firstName: '',
+                lastName: '',
+                email: '',
+            }));
+            try {
+                await finalizeCliAuthentication();
+            }
+            catch (error) {
+                setMessage(error instanceof Error ? error.message : 'Authentication failed.');
+            }
+        } }));
+}
+const rootElement = document.getElementById('root');
+if (rootElement) {
+    createRoot(rootElement).render(_jsx(SignInCLIApp, {}));
+}

package/lib/client/auth/AuthenticationManager.d.ts

@@ -10,15 +10,15 @@ import { UserDTO } from '../../models/UserDTO';
 export declare class AuthenticationManager {
     private strategies;
     private storage;
-    private iamRunUrl;
+    private iamUrl;
     private currentUser?;
     private currentToken?;
     /**
      * Create an AuthenticationManager instance
-     * @param iamRunUrl - IAM service URL (e.g., "https://prod1.datalayer.run")
+     * @param iamUrl - IAM service URL (e.g., "https://prod1.datalayer.run")
      * @param storage - Token storage backend (optional, defaults to auto-detected)
      */
-    constructor(iamRunUrl: string, storage?: TokenStorage);
+    constructor(iamUrl: string, storage?: TokenStorage);
     /**
      * Login using various authentication methods
      * Automatically selects the appropriate strategy based on options

package/lib/client/auth/AuthenticationManager.js

@@ -15,25 +15,25 @@ import { NodeStorage, BrowserStorage } from './storage.js';
 export class AuthenticationManager {
     strategies;
     storage;
-    iamRunUrl;
+    iamUrl;
     currentUser;
     currentToken;
     /**
      * Create an AuthenticationManager instance
-     * @param iamRunUrl - IAM service URL (e.g., "https://prod1.datalayer.run")
+     * @param iamUrl - IAM service URL (e.g., "https://prod1.datalayer.run")
      * @param storage - Token storage backend (optional, defaults to auto-detected)
      */
-    constructor(iamRunUrl, storage) {
-        this.iamRunUrl = iamRunUrl;
-        // Extract run_url (remove /api/iam/v1 if present)
-        const runUrl = iamRunUrl.replace('/api/iam/v1', '');
-        // CRITICAL: Pass runUrl to storage for keyring compatibility
+    constructor(iamUrl, storage) {
+        this.iamUrl = iamUrl;
+        // Extract datalayer_url (remove /api/iam/v1 if present)
+        const datalayerUrl = iamUrl.replace('/api/iam/v1', '');
+        // CRITICAL: Pass datalayerUrl to storage for keyring compatibility
         if (!storage) {
             if (typeof window !== 'undefined') {
                 this.storage = new BrowserStorage();
             }
             else {
-                this.storage = new NodeStorage(runUrl); // Pass runUrl as serviceUrl
+                this.storage = new NodeStorage(datalayerUrl); // Pass datalayerUrl as serviceUrl
             }
         }
         else {
@@ -41,10 +41,10 @@ export class AuthenticationManager {
         }
         // Initialize strategies
         this.strategies = [
-            new TokenAuthStrategy(this.iamRunUrl, this.storage),
-            new CredentialsAuthStrategy(this.iamRunUrl, this.storage),
-            new StorageAuthStrategy(this.iamRunUrl, this.storage),
-            new BrowserOAuthStrategy(this.iamRunUrl, this.storage),
+            new TokenAuthStrategy(this.iamUrl, this.storage),
+            new CredentialsAuthStrategy(this.iamUrl, this.storage),
+            new StorageAuthStrategy(this.iamUrl, this.storage),
+            new BrowserOAuthStrategy(this.iamUrl, this.storage),
         ];
     }
     /**
@@ -98,7 +98,7 @@ export class AuthenticationManager {
     async logout() {
         if (this.currentToken) {
             try {
-                await authentication.logout(this.currentToken, this.iamRunUrl);
+                await authentication.logout(this.currentToken, this.iamUrl);
             }
             catch (error) {
                 console.error('Error during logout API call:', error);

package/lib/client/auth/strategies.d.ts

@@ -4,9 +4,9 @@ import { UserDTO } from '../../models/UserDTO';
  * Base authentication strategy with common functionality
  */
 declare abstract class BaseAuthStrategy implements AuthStrategy {
-    protected iamRunUrl: string;
+    protected iamUrl: string;
     protected storage?: TokenStorage | undefined;
-    constructor(iamRunUrl: string, storage?: TokenStorage | undefined);
+    constructor(iamUrl: string, storage?: TokenStorage | undefined);
     abstract authenticate(options: AuthOptions): Promise<AuthResult>;
     abstract canHandle(options: AuthOptions): boolean;
     /**

package/lib/client/auth/strategies.js

@@ -17,17 +17,17 @@ import { UserDTO } from '../../models/UserDTO.js';
  * Base authentication strategy with common functionality
  */
 class BaseAuthStrategy {
-    iamRunUrl;
+    iamUrl;
     storage;
-    constructor(iamRunUrl, storage) {
-        this.iamRunUrl = iamRunUrl;
+    constructor(iamUrl, storage) {
+        this.iamUrl = iamUrl;
         this.storage = storage;
     }
     /**
      * Validate a token by calling whoami
      */
     async validateToken(token) {
-        const response = await profile.whoami(token, this.iamRunUrl);
+        const response = await profile.whoami(token, this.iamUrl);
         if (!response || !response.profile) {
             throw new Error('Invalid response from profile API');
         }
@@ -82,7 +82,7 @@ export class CredentialsAuthStrategy extends BaseAuthStrategy {
             throw new Error('Handle and password are required for credentials authentication');
         }
         // Call the login API
-        const response = await authentication.login({ handle: options.handle, password: options.password }, this.iamRunUrl);
+        const response = await authentication.login({ handle: options.handle, password: options.password }, this.iamUrl);
         if (!response || !response.success || !response.token) {
             throw new Error(response?.message || 'Login failed');
         }
@@ -158,7 +158,7 @@ export class BrowserOAuthStrategy extends BaseAuthStrategy {
         const callbackUri = options.callbackUri || `${window.location.origin}/auth/callback`;
         try {
             // Step 1: Get OAuth authorization URL
-            const authzResponse = await getOAuth2AuthzUrl(provider, callbackUri, this.iamRunUrl, options.nonce);
+            const authzResponse = await getOAuth2AuthzUrl(provider, callbackUri, this.iamUrl, options.nonce);
             // Step 2: Open OAuth URL in popup or redirect
             if (options.usePopup !== false) {
                 // Use popup window

package/lib/client/base.d.ts

@@ -1,4 +1,3 @@
-import { EnvironmentDTO } from '../models/EnvironmentDTO';
 import { AuthenticationManager } from './auth';
 import type { TokenStorage } from './auth/types';
 /** Handlers for Client method lifecycle events. */
@@ -15,11 +14,11 @@ export interface DatalayerClientConfig {
     /** Authentication token for API requests */
     token?: string;
     /** URL for the IAM service */
-    iamRunUrl?: string;
+    iamUrl?: string;
     /** URL for the Runtimes service */
-    runtimesRunUrl?: string;
+    runtimesUrl?: string;
     /** URL for the Spacer service */
-    spacerRunUrl?: string;
+    spacerUrl?: string;
     /** Custom token storage backend (optional, defaults to auto-detected) */
     storage?: TokenStorage;
     /** Handlers for intercepting Client method calls */
@@ -28,15 +27,13 @@ export interface DatalayerClientConfig {
 /** Base Client class providing core configuration and token management. */
 export declare class DatalayerClientBase {
     /** URL for IAM service */
-    readonly iamRunUrl: string;
+    readonly iamUrl: string;
     /** URL for Runtimes service */
-    readonly runtimesRunUrl: string;
+    readonly runtimesUrl: string;
     /** URL for Spacer service */
-    readonly spacerRunUrl: string;
+    readonly spacerUrl: string;
     /** Authentication token */
     token?: string;
-    /** Environments */
-    readonly environments: EnvironmentDTO[];
     /** Method lifecycle handlers */
     readonly handlers?: ClientHandlers;
     /** Authentication manager */
@@ -52,11 +49,11 @@ export declare class DatalayerClientBase {
      */
     getConfig(): DatalayerClientConfig;
     /** Get the IAM service URL. */
-    getIamRunUrl(): string;
+    getIamUrl(): string;
     /** Get the Runtimes service URL. */
-    getRuntimesRunUrl(): string;
+    getRuntimesUrl(): string;
     /** Get the Spacer service URL. */
-    getSpacerRunUrl(): string;
+    getSpacerUrl(): string;
     /** Get the current authentication token. */
     getToken(): string | undefined;
     /**

package/lib/client/base.js

@@ -11,15 +11,13 @@ import { AuthenticationManager } from './auth/index.js';
 /** Base Client class providing core configuration and token management. */
 export class DatalayerClientBase {
     /** URL for IAM service */
-    iamRunUrl;
+    iamUrl;
     /** URL for Runtimes service */
-    runtimesRunUrl;
+    runtimesUrl;
     /** URL for Spacer service */
-    spacerRunUrl;
+    spacerUrl;
     /** Authentication token */
     token;
-    /** Environments */
-    environments = [];
     /** Method lifecycle handlers */
     handlers;
     /** Authentication manager */
@@ -29,14 +27,14 @@ export class DatalayerClientBase {
      * @param config - Client configuration options
      */
     constructor(config) {
-        this.iamRunUrl = config.iamRunUrl || DEFAULT_SERVICE_URLS.IAM;
-        this.runtimesRunUrl =
-            config.runtimesRunUrl || DEFAULT_SERVICE_URLS.RUNTIMES;
-        this.spacerRunUrl = config.spacerRunUrl || DEFAULT_SERVICE_URLS.SPACER;
+        this.iamUrl = config.iamUrl || DEFAULT_SERVICE_URLS.IAM;
+        this.runtimesUrl =
+            config.runtimesUrl || DEFAULT_SERVICE_URLS.RUNTIMES;
+        this.spacerUrl = config.spacerUrl || DEFAULT_SERVICE_URLS.SPACER;
         this.token = config.token;
         this.handlers = config.handlers;
         // Initialize authentication manager with custom storage if provided
-        this.auth = new AuthenticationManager(this.iamRunUrl, config.storage);
+        this.auth = new AuthenticationManager(this.iamUrl, config.storage);
         // If a token was provided, store it in the auth manager
         if (this.token) {
             this.auth.storeToken(this.token);
@@ -48,23 +46,23 @@ export class DatalayerClientBase {
      */
     getConfig() {
         return {
-            iamRunUrl: this.iamRunUrl,
-            runtimesRunUrl: this.runtimesRunUrl,
-            spacerRunUrl: this.spacerRunUrl,
+            iamUrl: this.iamUrl,
+            runtimesUrl: this.runtimesUrl,
+            spacerUrl: this.spacerUrl,
             token: this.token,
         };
     }
     /** Get the IAM service URL. */
-    getIamRunUrl() {
-        return this.iamRunUrl;
+    getIamUrl() {
+        return this.iamUrl;
     }
     /** Get the Runtimes service URL. */
-    getRuntimesRunUrl() {
-        return this.runtimesRunUrl;
+    getRuntimesUrl() {
+        return this.runtimesUrl;
     }
     /** Get the Spacer service URL. */
-    getSpacerRunUrl() {
-        return this.spacerRunUrl;
+    getSpacerUrl() {
+        return this.spacerUrl;
     }
     /** Get the current authentication token. */
     getToken() {