@datalayer/core 0.0.9 → 0.0.11

package/lib/api/runtimes/__tests__/runtimes.unit.test.js

@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { describe, it, expect } from 'vitest';
+import { runtimes } from '..';
+import { MOCK_JWT_TOKEN } from '../../../__tests__/shared/test-constants';
+describe('Runtimes Unit Tests', () => {
+    describe('create parameter validation', () => {
+        const mockBaseUrl = 'https://example.com';
+        const mockData = {
+            environment_name: 'python-cpu-env',
+            type: 'notebook',
+            given_name: 'test-runtime',
+            credits_limit: 100,
+        };
+        it('should fail when token is missing', async () => {
+            console.log('Testing create with missing token...');
+            await expect(
+            // @ts-expect-error Testing undefined token
+            runtimes.createRuntime(undefined, mockData, mockBaseUrl)).rejects.toThrow('Authentication token is required');
+            console.log('Correctly rejected create with missing token');
+        });
+        it('should fail when token is empty', async () => {
+            console.log('Testing create with empty token...');
+            await expect(runtimes.createRuntime('', mockData, mockBaseUrl)).rejects.toThrow('Authentication token is required');
+            console.log('Correctly rejected create with empty token');
+        });
+        it('should fail when token is only whitespace', async () => {
+            console.log('Testing create with whitespace token...');
+            await expect(runtimes.createRuntime('   ', mockData, mockBaseUrl)).rejects.toThrow('Authentication token is required');
+            console.log('Correctly rejected create with whitespace token');
+        });
+    });
+    describe('list parameter validation', () => {
+        const mockBaseUrl = 'https://example.com';
+        it('should fail when token is missing', async () => {
+            console.log('Testing list with missing token...');
+            await expect(
+            // @ts-expect-error Testing undefined token
+            runtimes.listRuntimes(undefined, mockBaseUrl)).rejects.toThrow('Authentication token is required');
+            console.log('Correctly rejected list with missing token');
+        });
+        it('should fail when token is null', async () => {
+            console.log('Testing list with null token...');
+            await expect(
+            // @ts-expect-error Testing null token
+            runtimes.listRuntimes(null, mockBaseUrl)).rejects.toThrow('Authentication token is required');
+            console.log('Correctly rejected list with null token');
+        });
+        it('should fail when token is empty', async () => {
+            console.log('Testing list with empty token...');
+            await expect(runtimes.listRuntimes('', mockBaseUrl)).rejects.toThrow('Authentication token is required');
+            console.log('Correctly rejected list with empty token');
+        });
+        it('should fail when token is only whitespace', async () => {
+            console.log('Testing list with whitespace token...');
+            await expect(runtimes.listRuntimes('   ', mockBaseUrl)).rejects.toThrow('Authentication token is required');
+            console.log('Correctly rejected list with whitespace token');
+        });
+    });
+    describe('get parameter validation', () => {
+        const mockBaseUrl = 'https://example.com';
+        it('should fail when token is missing', async () => {
+            console.log('Testing get with missing token...');
+            await expect(
+            // @ts-expect-error Testing undefined token
+            runtimes.getRuntime(undefined, 'pod-123', mockBaseUrl)).rejects.toThrow('Authentication token is required');
+            console.log('Correctly rejected get with missing token');
+        });
+        it('should fail when pod name is missing', async () => {
+            console.log('Testing get with missing pod name...');
+            await expect(
+            // @ts-expect-error Testing undefined pod name
+            runtimes.getRuntime(MOCK_JWT_TOKEN, undefined, mockBaseUrl)).rejects.toThrow('Pod name is required');
+            console.log('Correctly rejected get with missing pod name');
+        });
+        it('should fail when pod name is empty', async () => {
+            console.log('Testing get with empty pod name...');
+            await expect(runtimes.getRuntime(MOCK_JWT_TOKEN, '', mockBaseUrl)).rejects.toThrow('Pod name is required');
+            console.log('Correctly rejected get with empty pod name');
+        });
+        it('should fail when pod name is only whitespace', async () => {
+            console.log('Testing get with whitespace pod name...');
+            await expect(runtimes.getRuntime(MOCK_JWT_TOKEN, '   ', mockBaseUrl)).rejects.toThrow('Pod name is required');
+            console.log('Correctly rejected get with whitespace pod name');
+        });
+    });
+    describe('remove parameter validation', () => {
+        const mockBaseUrl = 'https://example.com';
+        it('should fail when token is missing', async () => {
+            console.log('Testing remove with missing token...');
+            await expect(
+            // @ts-expect-error Testing undefined token
+            runtimes.deleteRuntime(undefined, 'pod-123', mockBaseUrl)).rejects.toThrow('Authentication token is required');
+            console.log('Correctly rejected remove with missing token');
+        });
+        it('should fail when pod name is missing', async () => {
+            console.log('Testing remove with missing pod name...');
+            await expect(
+            // @ts-expect-error Testing undefined pod name
+            runtimes.deleteRuntime(MOCK_JWT_TOKEN, undefined, mockBaseUrl)).rejects.toThrow('Pod name is required');
+            console.log('Correctly rejected remove with missing pod name');
+        });
+        it('should fail when pod name is empty', async () => {
+            console.log('Testing remove with empty pod name...');
+            await expect(runtimes.deleteRuntime(MOCK_JWT_TOKEN, '', mockBaseUrl)).rejects.toThrow('Pod name is required');
+            console.log('Correctly rejected remove with empty pod name');
+        });
+        it('should fail when pod name is only whitespace', async () => {
+            console.log('Testing remove with whitespace pod name...');
+            await expect(runtimes.deleteRuntime(MOCK_JWT_TOKEN, '   ', mockBaseUrl)).rejects.toThrow('Pod name is required');
+            console.log('Correctly rejected remove with whitespace pod name');
+        });
+    });
+    describe('put parameter validation', () => {
+        const mockBaseUrl = 'https://example.com';
+        it('should fail when token is missing', async () => {
+            console.log('Testing put with missing token...');
+            await expect(runtimes.updateRuntime(undefined, 'pod-123', 'snapshot-123', mockBaseUrl)).rejects.toThrow('Authentication token is required');
+            console.log('Correctly rejected put with missing token');
+        });
+        it('should fail when pod name is missing', async () => {
+            console.log('Testing put with missing pod name...');
+            await expect(runtimes.updateRuntime(MOCK_JWT_TOKEN, undefined, 'snapshot-123', mockBaseUrl)).rejects.toThrow('Pod name is required');
+            console.log('Correctly rejected put with missing pod name');
+        });
+        it('should fail when pod name is empty', async () => {
+            console.log('Testing put with empty pod name...');
+            await expect(runtimes.updateRuntime(MOCK_JWT_TOKEN, '', 'snapshot-123', mockBaseUrl)).rejects.toThrow('Pod name is required');
+            console.log('Correctly rejected put with empty pod name');
+        });
+        it('should fail when pod name is only whitespace', async () => {
+            console.log('Testing put with whitespace pod name...');
+            await expect(runtimes.updateRuntime(MOCK_JWT_TOKEN, '   ', 'snapshot-123', mockBaseUrl)).rejects.toThrow('Pod name is required');
+            console.log('Correctly rejected put with whitespace pod name');
+        });
+    });
+});

package/lib/api/runtimes/__tests__/snapshots.unit.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/api/runtimes/__tests__/snapshots.unit.test.js

@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+import { describe, it, expect } from 'vitest';
+import { snapshots } from '..';
+import { MOCK_JWT_TOKEN } from '../../../__tests__/shared/test-constants';
+describe('Runtimes Snapshots Unit Tests', () => {
+    describe('create parameter validation', () => {
+        const mockBaseUrl = 'https://example.com';
+        const mockData = {
+            pod_name: 'pod-123',
+            name: 'my-snapshot',
+            description: 'Test snapshot',
+            stop: true,
+        };
+        it('should fail when token is missing', async () => {
+            console.log('Testing create with missing token...');
+            await expect(
+            // @ts-expect-error Testing undefined token
+            snapshots.createSnapshot(undefined, mockData, mockBaseUrl)).rejects.toThrow('Authentication token is required');
+            console.log('Correctly rejected create with missing token');
+        });
+        it('should fail when token is empty', async () => {
+            console.log('Testing create with empty token...');
+            await expect(snapshots.createSnapshot('', mockData, mockBaseUrl)).rejects.toThrow('Authentication token is required');
+            console.log('Correctly rejected create with empty token');
+        });
+        it('should fail when token is only whitespace', async () => {
+            console.log('Testing create with whitespace token...');
+            await expect(snapshots.createSnapshot('   ', mockData, mockBaseUrl)).rejects.toThrow('Authentication token is required');
+            console.log('Correctly rejected create with whitespace token');
+        });
+    });
+    describe('list parameter validation', () => {
+        const mockBaseUrl = 'https://example.com';
+        it('should fail when token is missing', async () => {
+            console.log('Testing list with missing token...');
+            await expect(
+            // @ts-expect-error Testing undefined token
+            snapshots.listSnapshots(undefined, mockBaseUrl)).rejects.toThrow('Authentication token is required');
+            console.log('Correctly rejected list with missing token');
+        });
+        it('should fail when token is null', async () => {
+            console.log('Testing list with null token...');
+            await expect(
+            // @ts-expect-error Testing null token
+            snapshots.listSnapshots(null, mockBaseUrl)).rejects.toThrow('Authentication token is required');
+            console.log('Correctly rejected list with null token');
+        });
+    });
+    describe('get parameter validation', () => {
+        const mockBaseUrl = 'https://example.com';
+        it('should fail when token is missing', async () => {
+            console.log('Testing get with missing token...');
+            await expect(
+            // @ts-expect-error Testing undefined token
+            snapshots.getSnapshot(undefined, 'snapshot-123', mockBaseUrl)).rejects.toThrow('Authentication token is required');
+            console.log('Correctly rejected get with missing token');
+        });
+        it('should fail when snapshot ID is missing', async () => {
+            console.log('Testing get with missing snapshot ID...');
+            await expect(
+            // @ts-expect-error Testing undefined snapshot ID
+            snapshots.getSnapshot(MOCK_JWT_TOKEN, undefined, mockBaseUrl)).rejects.toThrow('Snapshot ID is required');
+            console.log('Correctly rejected get with missing snapshot ID');
+        });
+        it('should fail when snapshot ID is empty', async () => {
+            console.log('Testing get with empty snapshot ID...');
+            await expect(snapshots.getSnapshot(MOCK_JWT_TOKEN, '', mockBaseUrl)).rejects.toThrow('Snapshot ID is required');
+            console.log('Correctly rejected get with empty snapshot ID');
+        });
+        it('should fail when snapshot ID is only whitespace', async () => {
+            console.log('Testing get with whitespace snapshot ID...');
+            await expect(snapshots.getSnapshot(MOCK_JWT_TOKEN, '   ', mockBaseUrl)).rejects.toThrow('Snapshot ID is required');
+            console.log('Correctly rejected get with whitespace snapshot ID');
+        });
+    });
+    describe('remove parameter validation', () => {
+        const mockBaseUrl = 'https://example.com';
+        it('should fail when token is missing', async () => {
+            console.log('Testing remove with missing token...');
+            await expect(
+            // @ts-expect-error Testing undefined token
+            snapshots.deleteSnapshot(undefined, 'snapshot-123', mockBaseUrl)).rejects.toThrow('Authentication token is required');
+            console.log('Correctly rejected remove with missing token');
+        });
+        it('should fail when snapshot ID is missing', async () => {
+            console.log('Testing remove with missing snapshot ID...');
+            await expect(
+            // @ts-expect-error Testing undefined snapshot ID
+            snapshots.deleteSnapshot(MOCK_JWT_TOKEN, undefined, mockBaseUrl)).rejects.toThrow('Snapshot ID is required');
+            console.log('Correctly rejected remove with missing snapshot ID');
+        });
+    });
+});

package/lib/api/runtimes/environments.d.ts

@@ -0,0 +1,9 @@
+import { EnvironmentsListResponse } from '../types/runtimes';
+/**
+ * List all available computing environments.
+ * @param token - Authentication token
+ * @param baseUrl - Base URL for the API (defaults to production Runtimes URL)
+ * @returns Promise resolving to list of available environments
+ * @throws {Error} If authentication token is missing or invalid
+ */
+export declare const listEnvironments: (token: string, baseUrl?: string) => Promise<EnvironmentsListResponse>;

package/lib/api/runtimes/environments.js

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * @module api/runtimes/environments
+ * @description Computing environments API functions for the Datalayer platform.
+ *
+ * Provides functions for managing computing environment configurations.
+ */
+import { requestDatalayerAPI } from '../DatalayerApi';
+import { API_BASE_PATHS, DEFAULT_SERVICE_URLS } from '../constants';
+import { validateToken } from '../utils/validation';
+/**
+ * List all available computing environments.
+ * @param token - Authentication token
+ * @param baseUrl - Base URL for the API (defaults to production Runtimes URL)
+ * @returns Promise resolving to list of available environments
+ * @throws {Error} If authentication token is missing or invalid
+ */
+export const listEnvironments = async (token, baseUrl = DEFAULT_SERVICE_URLS.RUNTIMES) => {
+    validateToken(token);
+    return requestDatalayerAPI({
+        url: `${baseUrl}${API_BASE_PATHS.RUNTIMES}/environments`,
+        method: 'GET',
+        token,
+    });
+};

package/lib/api/runtimes/healthz.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Health check response from the Runtimes service
+ */
+export interface RuntimesHealthzPingResponse {
+    success: boolean;
+    message: string;
+    status?: {
+        status: string;
+    };
+    version?: string;
+}
+/**
+ * Health check ping endpoint for Runtimes service
+ * @param baseUrl - Base URL for the API (defaults to production Runtimes URL)
+ * @returns Health check response
+ * @throws {Error} If the health check fails
+ *
+ * @description
+ * This endpoint provides a basic health check for the Runtimes service.
+ * It returns the current status of the service.
+ *
+ * Expected status codes:
+ * - 200: Service is healthy
+ */
+export declare const ping: (baseUrl?: string) => Promise<RuntimesHealthzPingResponse>;

package/lib/api/runtimes/healthz.js

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * @module api/runtimes/healthz
+ * @description Health check API functions for the Datalayer Runtimes service.
+ *
+ * Provides functions for checking the health status of the Runtimes service.
+ */
+import { requestDatalayerAPI } from '../DatalayerApi';
+import { API_BASE_PATHS, DEFAULT_SERVICE_URLS } from '../constants';
+/**
+ * Health check ping endpoint for Runtimes service
+ * @param baseUrl - Base URL for the API (defaults to production Runtimes URL)
+ * @returns Health check response
+ * @throws {Error} If the health check fails
+ *
+ * @description
+ * This endpoint provides a basic health check for the Runtimes service.
+ * It returns the current status of the service.
+ *
+ * Expected status codes:
+ * - 200: Service is healthy
+ */
+export const ping = async (baseUrl = DEFAULT_SERVICE_URLS.RUNTIMES) => {
+    try {
+        const response = await requestDatalayerAPI({
+            url: `${baseUrl}${API_BASE_PATHS.RUNTIMES}/ping`,
+            method: 'GET',
+        });
+        return response;
+    }
+    catch (error) {
+        // Check if it's a response error with status code information
+        if (error.response) {
+            const status = error.response.status;
+            throw new Error(`Health check failed: Service unhealthy (status ${status}) - ${error.message}`);
+        }
+        // Re-throw other errors (network errors, etc.)
+        throw new Error(`Health check failed: ${error.message}`);
+    }
+};

package/lib/api/runtimes/index.d.ts

@@ -1,5 +1,10 @@
-export * from './actions';
-export * from './apis';
-export * from './settings';
-export * from './snapshots';
-export * from './utils';
+/**
+ * @module api/runtimes
+ * @description Runtimes API exports.
+ *
+ * Provides organized access to runtime management functionality.
+ */
+export * as environments from './environments';
+export * as healthz from './healthz';
+export * as runtimes from './runtimes';
+export * as snapshots from './snapshots';

package/lib/api/runtimes/index.js

@@ -2,8 +2,13 @@
  * Copyright (c) 2023-2025 Datalayer, Inc.
  * Distributed under the terms of the Modified BSD License.
  */
-export * from './actions';
-export * from './apis';
-export * from './settings';
-export * from './snapshots';
-export * from './utils';
+/**
+ * @module api/runtimes
+ * @description Runtimes API exports.
+ *
+ * Provides organized access to runtime management functionality.
+ */
+export * as environments from './environments';
+export * as healthz from './healthz';
+export * as runtimes from './runtimes';
+export * as snapshots from './snapshots';

package/lib/api/runtimes/runtimes.d.ts

@@ -0,0 +1,54 @@
+import { Runtime, CreateRuntimeRequest, CreateRuntimeResponse, RuntimesListResponse } from '../types/runtimes';
+/**
+ * Create a new runtime instance.
+ * @param token - Authentication token
+ * @param data - Runtime creation configuration
+ * @param baseUrl - Base URL for the API (defaults to production Runtimes URL)
+ * @returns Promise resolving to the created runtime details
+ * @throws {Error} If authentication token is missing or invalid
+ * @throws {Error} With status 404 if the environment is not found
+ * @throws {Error} With status 503 if no runtime is available
+ */
+export declare const createRuntime: (token: string, data: CreateRuntimeRequest, baseUrl?: string) => Promise<CreateRuntimeResponse>;
+/**
+ * List all runtime instances.
+ * @param token - Authentication token
+ * @param baseUrl - Base URL for the API (defaults to production Runtimes URL)
+ * @returns Promise resolving to list of runtime instances
+ * @throws {Error} If authentication token is missing or invalid
+ */
+export declare const listRuntimes: (token: string, baseUrl?: string) => Promise<RuntimesListResponse>;
+/**
+ * Get details for a specific runtime instance.
+ * @param token - Authentication token
+ * @param podName - The unique pod name of the runtime
+ * @param baseUrl - Base URL for the API (defaults to production Runtimes URL)
+ * @returns Promise resolving to runtime details
+ * @throws {Error} If authentication token is missing or invalid
+ * @throws {Error} If pod name is missing or invalid
+ * @throws {Error} With status 404 if the runtime is not found
+ */
+export declare const getRuntime: (token: string, podName: string, baseUrl?: string) => Promise<Runtime>;
+/**
+ * Delete a runtime instance.
+ * @param token - Authentication token
+ * @param podName - The unique pod name of the runtime to delete
+ * @param baseUrl - Base URL for the API (defaults to production Runtimes URL)
+ * @returns Promise resolving when deletion is complete
+ * @throws {Error} If authentication token is missing or invalid
+ * @throws {Error} If pod name is missing or invalid
+ * @throws {Error} With status 404 if the runtime is not found
+ */
+export declare const deleteRuntime: (token: string, podName: string, baseUrl?: string) => Promise<void>;
+/**
+ * Update a runtime instance.
+ * @param token - Authentication token
+ * @param podName - The unique pod name of the runtime
+ * @param from - The source to update from
+ * @param baseUrl - Base URL for the API (defaults to production Runtimes URL)
+ * @returns Promise resolving to updated runtime details
+ * @throws {Error} If authentication token is missing or invalid
+ * @throws {Error} If pod name is missing or invalid
+ * @throws {Error} With status 404 if the runtime is not found
+ */
+export declare const updateRuntime: (token: string, podName: string, from: string, baseUrl?: string) => Promise<Runtime>;

package/lib/api/runtimes/runtimes.js

@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * @module api/runtimes/runtimes
+ * @description Runtime instances API functions for the Datalayer platform.
+ *
+ * Provides functions for managing runtime instances (active compute containers).
+ */
+import { requestDatalayerAPI } from '../DatalayerApi';
+import { API_BASE_PATHS, DEFAULT_SERVICE_URLS } from '../constants';
+import { validateToken, validateRequiredString } from '../utils/validation';
+/**
+ * Create a new runtime instance.
+ * @param token - Authentication token
+ * @param data - Runtime creation configuration
+ * @param baseUrl - Base URL for the API (defaults to production Runtimes URL)
+ * @returns Promise resolving to the created runtime details
+ * @throws {Error} If authentication token is missing or invalid
+ * @throws {Error} With status 404 if the environment is not found
+ * @throws {Error} With status 503 if no runtime is available
+ */
+export const createRuntime = async (token, data, baseUrl = DEFAULT_SERVICE_URLS.RUNTIMES) => {
+    validateToken(token);
+    try {
+        return await requestDatalayerAPI({
+            url: `${baseUrl}${API_BASE_PATHS.RUNTIMES}/runtimes`,
+            method: 'POST',
+            body: data,
+            token,
+        });
+    }
+    catch (error) {
+        // Handle specific error cases
+        if (error.response) {
+            const status = error.response.status;
+            const responseData = error.response.data || {};
+            if (status === 404) {
+                // Environment not found
+                throw new Error(`Environment '${data.environment_name}' not found. ${responseData.message || 'Please check the environment name and try again.'}`);
+            }
+            else if (status === 503) {
+                // No runtime available
+                throw new Error(`No runtime available. ${responseData.message || 'The service is temporarily unavailable or at capacity. Please try again later.'}`);
+            }
+        }
+        // Re-throw the original error for other cases
+        throw error;
+    }
+};
+/**
+ * List all runtime instances.
+ * @param token - Authentication token
+ * @param baseUrl - Base URL for the API (defaults to production Runtimes URL)
+ * @returns Promise resolving to list of runtime instances
+ * @throws {Error} If authentication token is missing or invalid
+ */
+export const listRuntimes = async (token, baseUrl = DEFAULT_SERVICE_URLS.RUNTIMES) => {
+    validateToken(token);
+    return requestDatalayerAPI({
+        url: `${baseUrl}${API_BASE_PATHS.RUNTIMES}/runtimes`,
+        method: 'GET',
+        token,
+    });
+};
+/**
+ * Get details for a specific runtime instance.
+ * @param token - Authentication token
+ * @param podName - The unique pod name of the runtime
+ * @param baseUrl - Base URL for the API (defaults to production Runtimes URL)
+ * @returns Promise resolving to runtime details
+ * @throws {Error} If authentication token is missing or invalid
+ * @throws {Error} If pod name is missing or invalid
+ * @throws {Error} With status 404 if the runtime is not found
+ */
+export const getRuntime = async (token, podName, baseUrl = DEFAULT_SERVICE_URLS.RUNTIMES) => {
+    validateToken(token);
+    validateRequiredString(podName, 'Pod name');
+    try {
+        const response = await requestDatalayerAPI({
+            url: `${baseUrl}${API_BASE_PATHS.RUNTIMES}/runtimes/${podName}`,
+            method: 'GET',
+            token,
+        });
+        // The API returns { success: true, message: string, kernel: Runtime }
+        // We need to return just the runtime data
+        if (response.kernel) {
+            // Map kernel fields to Runtime fields
+            return {
+                ...response.kernel,
+                pod_name: response.kernel.pod_name || podName,
+            };
+        }
+        // Fallback if response structure is different
+        return response;
+    }
+    catch (error) {
+        // Handle specific error cases
+        if (error.response && error.response.status === 404) {
+            // Runtime not found
+            throw new Error(`Runtime with pod name '${podName}' not found. Please check the pod name and try again.`);
+        }
+        // Re-throw the original error for other cases
+        throw error;
+    }
+};
+/**
+ * Delete a runtime instance.
+ * @param token - Authentication token
+ * @param podName - The unique pod name of the runtime to delete
+ * @param baseUrl - Base URL for the API (defaults to production Runtimes URL)
+ * @returns Promise resolving when deletion is complete
+ * @throws {Error} If authentication token is missing or invalid
+ * @throws {Error} If pod name is missing or invalid
+ * @throws {Error} With status 404 if the runtime is not found
+ */
+export const deleteRuntime = async (token, podName, baseUrl = DEFAULT_SERVICE_URLS.RUNTIMES) => {
+    validateToken(token);
+    validateRequiredString(podName, 'Pod name');
+    try {
+        return await requestDatalayerAPI({
+            url: `${baseUrl}${API_BASE_PATHS.RUNTIMES}/runtimes/${podName}`,
+            method: 'DELETE',
+            token,
+        });
+    }
+    catch (error) {
+        // Handle specific error cases
+        if (error.response && error.response.status === 404) {
+            // Runtime not found
+            throw new Error(`Runtime with pod name '${podName}' not found. Cannot delete a non-existent runtime.`);
+        }
+        // Re-throw the original error for other cases
+        throw error;
+    }
+};
+/**
+ * Update a runtime instance.
+ * @param token - Authentication token
+ * @param podName - The unique pod name of the runtime
+ * @param from - The source to update from
+ * @param baseUrl - Base URL for the API (defaults to production Runtimes URL)
+ * @returns Promise resolving to updated runtime details
+ * @throws {Error} If authentication token is missing or invalid
+ * @throws {Error} If pod name is missing or invalid
+ * @throws {Error} With status 404 if the runtime is not found
+ */
+export const updateRuntime = async (token, podName, from, baseUrl = DEFAULT_SERVICE_URLS.RUNTIMES) => {
+    validateToken(token);
+    validateRequiredString(podName, 'Pod name');
+    try {
+        return await requestDatalayerAPI({
+            url: `${baseUrl}${API_BASE_PATHS.RUNTIMES}/runtimes/${podName}`,
+            method: 'PUT',
+            token,
+            body: { from },
+        });
+    }
+    catch (error) {
+        // Handle specific error cases
+        if (error.response && error.response.status === 404) {
+            // Runtime not found
+            throw new Error(`Runtime with pod name '${podName}' not found. Cannot update a non-existent runtime.`);
+        }
+        // Re-throw the original error for other cases
+        throw error;
+    }
+};