@datalayer/agent-runtimes 1.0.10 → 1.0.17

package/lib/api/index.d.ts

@@ -12,3 +12,15 @@ export * as evals from './evals';
 export * as events from './events';
 export * as notifications from './notifications';
 export * as output from './output';
+export * from '../runtimes';
+import type { ListEnvironmentsResponse } from '../models/EnvironmentDTO';
+import type { CreateCodeSandboxSnapshotRequest, CodeSandboxSnapshotData } from '../models/CodeSandboxSnapshotDTO';
+import { type ICodeSandboxSnapshot } from '../models/CodeSandboxSnapshot';
+export declare function getEnvironments(token?: string, baseUrl?: string): Promise<ListEnvironmentsResponse['environments']>;
+export declare function getSandboxSnapshots(token?: string, baseUrl?: string): Promise<ICodeSandboxSnapshot[]>;
+export declare function createSandboxSnapshot(data: CreateCodeSandboxSnapshotRequest | Record<string, any>, token?: string, baseUrl?: string): Promise<CodeSandboxSnapshotData | Record<string, any>>;
+export declare function deleteCodeSandboxSnapshot(snapshotId: string, token?: string, baseUrl?: string): Promise<void>;
+export declare function exportCodeSandboxSnapshot(..._args: any[]): Promise<never>;
+export declare function updateCodeSandboxSnapshot(..._args: any[]): Promise<never>;
+export declare function uploadCodeSandboxSnapshot(..._args: any[]): Promise<never>;
+export * from '@datalayer/core/lib/api';

package/lib/api/index.js

@@ -20,3 +20,49 @@ export * as evals from './evals';
 export * as events from './events';
 export * as notifications from './notifications';
 export * as output from './output';
+export * from '../runtimes';
+import { iamStore } from '@datalayer/core/lib/state';
+import { listEnvironments } from './runtimes/environments';
+import { listSnapshots, createSnapshot, deleteSnapshot, } from './runtimes/snapshots';
+import { asCodeSandboxSnapshot, } from '../models/CodeSandboxSnapshot';
+function resolveToken(token) {
+    const resolved = token ?? iamStore.getState()?.token;
+    if (!resolved) {
+        throw new Error('Authentication token is required');
+    }
+    return resolved;
+}
+export async function getEnvironments(token, baseUrl) {
+    const response = await listEnvironments(resolveToken(token), baseUrl);
+    return (response.environments ?? []).map(environment => ({
+        ...environment,
+        burningRate: environment.burningRate ?? environment.burning_rate,
+    }));
+}
+export async function getSandboxSnapshots(token, baseUrl) {
+    const response = await listSnapshots(resolveToken(token), baseUrl);
+    return (response.snapshots ?? []).map(snapshot => asCodeSandboxSnapshot(snapshot));
+}
+export async function createSandboxSnapshot(data, token, baseUrl) {
+    // Legacy browser snapshots pass a rich object (connection, metadata, callbacks)
+    // that is handled client-side. Keep compatibility by returning early.
+    if (!('pod_name' in data)) {
+        return data;
+    }
+    const response = await createSnapshot(resolveToken(token), data, baseUrl);
+    return response.snapshot;
+}
+export async function deleteCodeSandboxSnapshot(snapshotId, token, baseUrl) {
+    return deleteSnapshot(resolveToken(token), snapshotId, baseUrl);
+}
+export async function exportCodeSandboxSnapshot(..._args) {
+    throw new Error('exportCodeSandboxSnapshot is not implemented in @datalayer/agent-runtimes/api yet.');
+}
+export async function updateCodeSandboxSnapshot(..._args) {
+    throw new Error('updateCodeSandboxSnapshot is not implemented in @datalayer/agent-runtimes/api yet.');
+}
+export async function uploadCodeSandboxSnapshot(..._args) {
+    throw new Error('uploadCodeSandboxSnapshot is not implemented in @datalayer/agent-runtimes/api yet.');
+}
+// Re-export core API endpoints for IAM/plans/account features.
+export * from '@datalayer/core/lib/api';

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

@@ -0,0 +1,122 @@
+/**
+ * A single runtime checkpoint record.
+ */
+export interface RuntimeCheckpointData {
+    /** Unique identifier (ULID) */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** Checkpoint description */
+    description: string;
+    /** Runtime that was checkpointed */
+    runtime_uid: string;
+    /** Agentspec identifier (e.g. "mocks/monitor-sales-kpis") */
+    agent_spec_id: string;
+    /** Full agentspec payload */
+    agentspec: Record<string, any>;
+    /** Additional metadata */
+    metadata: Record<string, any>;
+    /** Checkpoint mode: criu (full) or light (history-only) */
+    checkpoint_mode?: 'criu' | 'light';
+    /** Lightweight checkpoint message history */
+    messages?: string[];
+    /** Status: requested | created | failed | deleted */
+    status: string;
+    /** Human-readable details about the current status (e.g. error message) */
+    status_message?: string;
+    /** ISO 8601 timestamp */
+    updated_at: string;
+}
+/**
+ * Request payload for creating a checkpoint.
+ */
+export interface CreateRuntimeCheckpointRequest {
+    /** Runtime UID of the runtime that was checkpointed */
+    runtime_uid: string;
+    /** Human-readable name */
+    name?: string;
+    /** Checkpoint description */
+    description?: string;
+    /** Agentspec identifier */
+    agentspec_id?: string;
+    /** Full agentspec payload to persist */
+    agentspec?: Record<string, any>;
+    /** Additional metadata */
+    metadata?: Record<string, any>;
+}
+/**
+ * Response for listing checkpoints.
+ */
+export interface ListRuntimeCheckpointsResponse {
+    success: boolean;
+    message: string;
+    checkpoints: RuntimeCheckpointData[];
+}
+/**
+ * Response for getting a single checkpoint.
+ */
+export interface GetRuntimeCheckpointResponse {
+    success: boolean;
+    message: string;
+    checkpoint: RuntimeCheckpointData;
+}
+/**
+ * Response for creating a checkpoint.
+ */
+export interface CreateRuntimeCheckpointResponse {
+    success: boolean;
+    message: string;
+    checkpoint: RuntimeCheckpointData;
+}
+/**
+ * List runtime checkpoints for a specific runtime.
+ * @param token - Authentication token
+ * @param baseUrl - Base URL for the runtimes API
+ * @param runtimeUid - Runtime UID to list checkpoints for
+ * @returns Promise resolving to list of checkpoints
+ */
+export declare const listCheckpoints: (token: string, baseUrl?: string, runtimeUid?: string) => Promise<ListRuntimeCheckpointsResponse>;
+/**
+ * Get a single runtime checkpoint by ID.
+ * @param token - Authentication token
+ * @param runtimeUid - The runtime UID
+ * @param checkpointId - The checkpoint ID (ULID)
+ * @param baseUrl - Base URL for the runtimes API
+ * @returns Promise resolving to checkpoint details
+ */
+export declare const getCheckpoint: (token: string, runtimeUid: string, checkpointId: string, baseUrl?: string) => Promise<GetRuntimeCheckpointResponse>;
+/**
+ * Create a checkpoint record (after a CRIU checkpoint has been taken).
+ * @param token - Authentication token
+ * @param data - Checkpoint creation payload (runtime_uid, agentspec, etc.)
+ * @param baseUrl - Base URL for the runtimes API
+ * @returns Promise resolving to the created checkpoint
+ */
+export declare const createCheckpoint: (token: string, data: CreateRuntimeCheckpointRequest, baseUrl?: string) => Promise<CreateRuntimeCheckpointResponse>;
+/**
+ * Poll a checkpoint until it reaches one of the target statuses.
+ *
+ * Useful for waiting until an async pause (status "paused")
+ * completes before proceeding.  Checkpoint status stays "paused"
+ * during resume — only the agent runtime status transitions.
+ *
+ * @param token - Authentication token
+ * @param runtimeUid - The runtime UID that owns the checkpoint
+ * @param checkpointId - The checkpoint ID (ULID) to poll
+ * @param targetStatuses - Set of statuses that signal completion (e.g. ["paused", "failed"])
+ * @param baseUrl - Base URL for the runtimes API
+ * @param intervalMs - Polling interval in milliseconds (default: 2000)
+ * @param timeoutMs - Maximum wait time in milliseconds (default: 600000 = 10 min)
+ * @returns Promise resolving to the checkpoint data once a target status is reached
+ * @throws {Error} If polling times out or the request fails
+ */
+export declare const waitForCheckpointStatus: (token: string, runtimeUid: string, checkpointId: string, targetStatuses: string[], baseUrl?: string, intervalMs?: number, timeoutMs?: number) => Promise<RuntimeCheckpointData>;
+/**
+ * Delete a runtime checkpoint.
+ * @param token - Authentication token
+ * @param runtimeUid - The runtime UID that owns the checkpoint
+ * @param checkpointId - The checkpoint ID (ULID) to delete
+ * @param baseUrl - Base URL for the runtimes API
+ * @returns Promise resolving when deletion is complete
+ */
+export declare const deleteCheckpoint: (token: string, runtimeUid: string, checkpointId: string, baseUrl?: string) => Promise<void>;

package/lib/api/runtimes/checkpoints.js

@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Runtime checkpoints API functions for the Datalayer platform.
+ *
+ * Provides functions for managing CRIU full-pod checkpoints.
+ * These are distinct from code sandbox snapshots (Jupyter sandbox snapshots).
+ *
+ * @module api/runtimes/checkpoints
+ */
+import { requestDatalayerAPI } from '@datalayer/core/lib/api/DatalayerApi';
+import { API_BASE_PATHS, DEFAULT_SERVICE_URLS, } from '@datalayer/core/lib/api/constants';
+import { validateToken, validateRequiredString, } from '@datalayer/core/lib/api/utils/validation';
+// ─── API Functions ─────────────────────────────────────────────────────────
+/**
+ * List runtime checkpoints for a specific runtime.
+ * @param token - Authentication token
+ * @param baseUrl - Base URL for the runtimes API
+ * @param runtimeUid - Runtime UID to list checkpoints for
+ * @returns Promise resolving to list of checkpoints
+ */
+export const listCheckpoints = async (token, baseUrl = DEFAULT_SERVICE_URLS.RUNTIMES, runtimeUid) => {
+    validateToken(token);
+    if (!runtimeUid) {
+        throw new Error('runtimeUid is required to list checkpoints');
+    }
+    return requestDatalayerAPI({
+        url: `${baseUrl}${API_BASE_PATHS.RUNTIMES}/runtime-checkpoints/${encodeURIComponent(runtimeUid)}`,
+        method: 'GET',
+        token,
+    });
+};
+/**
+ * Get a single runtime checkpoint by ID.
+ * @param token - Authentication token
+ * @param runtimeUid - The runtime UID
+ * @param checkpointId - The checkpoint ID (ULID)
+ * @param baseUrl - Base URL for the runtimes API
+ * @returns Promise resolving to checkpoint details
+ */
+export const getCheckpoint = async (token, runtimeUid, checkpointId, baseUrl = DEFAULT_SERVICE_URLS.RUNTIMES) => {
+    validateToken(token);
+    validateRequiredString(runtimeUid, 'Runtime UID');
+    validateRequiredString(checkpointId, 'Checkpoint ID');
+    return requestDatalayerAPI({
+        url: `${baseUrl}${API_BASE_PATHS.RUNTIMES}/runtime-checkpoints/${encodeURIComponent(runtimeUid)}/${checkpointId}`,
+        method: 'GET',
+        token,
+    });
+};
+/**
+ * Create a checkpoint record (after a CRIU checkpoint has been taken).
+ * @param token - Authentication token
+ * @param data - Checkpoint creation payload (runtime_uid, agentspec, etc.)
+ * @param baseUrl - Base URL for the runtimes API
+ * @returns Promise resolving to the created checkpoint
+ */
+export const createCheckpoint = async (token, data, baseUrl = DEFAULT_SERVICE_URLS.RUNTIMES) => {
+    validateToken(token);
+    return requestDatalayerAPI({
+        url: `${baseUrl}${API_BASE_PATHS.RUNTIMES}/runtime-checkpoints`,
+        method: 'POST',
+        token,
+        body: data,
+    });
+};
+/**
+ * Poll a checkpoint until it reaches one of the target statuses.
+ *
+ * Useful for waiting until an async pause (status "paused")
+ * completes before proceeding.  Checkpoint status stays "paused"
+ * during resume — only the agent runtime status transitions.
+ *
+ * @param token - Authentication token
+ * @param runtimeUid - The runtime UID that owns the checkpoint
+ * @param checkpointId - The checkpoint ID (ULID) to poll
+ * @param targetStatuses - Set of statuses that signal completion (e.g. ["paused", "failed"])
+ * @param baseUrl - Base URL for the runtimes API
+ * @param intervalMs - Polling interval in milliseconds (default: 2000)
+ * @param timeoutMs - Maximum wait time in milliseconds (default: 600000 = 10 min)
+ * @returns Promise resolving to the checkpoint data once a target status is reached
+ * @throws {Error} If polling times out or the request fails
+ */
+export const waitForCheckpointStatus = async (token, runtimeUid, checkpointId, targetStatuses, baseUrl = DEFAULT_SERVICE_URLS.RUNTIMES, intervalMs = 2000, timeoutMs = 600_000) => {
+    validateToken(token);
+    validateRequiredString(runtimeUid, 'Runtime UID');
+    validateRequiredString(checkpointId, 'Checkpoint ID');
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const resp = await getCheckpoint(token, runtimeUid, checkpointId, baseUrl);
+        if (targetStatuses.includes(resp.checkpoint.status)) {
+            return resp.checkpoint;
+        }
+        // Wait before next poll
+        await new Promise(resolve => setTimeout(resolve, intervalMs));
+    }
+    throw new Error(`Checkpoint ${checkpointId} did not reach status [${targetStatuses.join(', ')}] within ${timeoutMs / 1000}s`);
+};
+/**
+ * Delete a runtime checkpoint.
+ * @param token - Authentication token
+ * @param runtimeUid - The runtime UID that owns the checkpoint
+ * @param checkpointId - The checkpoint ID (ULID) to delete
+ * @param baseUrl - Base URL for the runtimes API
+ * @returns Promise resolving when deletion is complete
+ */
+export const deleteCheckpoint = async (token, runtimeUid, checkpointId, baseUrl = DEFAULT_SERVICE_URLS.RUNTIMES) => {
+    validateToken(token);
+    validateRequiredString(runtimeUid, 'Runtime UID');
+    validateRequiredString(checkpointId, 'Checkpoint ID');
+    return requestDatalayerAPI({
+        url: `${baseUrl}${API_BASE_PATHS.RUNTIMES}/runtime-checkpoints/${encodeURIComponent(runtimeUid)}/${checkpointId}`,
+        method: 'DELETE',
+        token,
+    });
+};

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

@@ -0,0 +1,9 @@
+import { ListEnvironmentsResponse } from '../../models/EnvironmentDTO';
+/**
+ * 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<ListEnvironmentsResponse>;

package/lib/api/runtimes/environments.js

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Computing environments API functions for the Datalayer platform.
+ *
+ * Provides functions for managing computing environment configurations.
+ *
+ * @module api/runtimes/environments
+ */
+import { requestDatalayerAPI } from '@datalayer/core/lib/api/DatalayerApi';
+import { API_BASE_PATHS, DEFAULT_SERVICE_URLS, } from '@datalayer/core/lib/api/constants';
+import { validateToken } from '@datalayer/core/lib/api/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,15 @@
+import type { HealthzPingResponse } from '@datalayer/core/lib/models/Common';
+/**
+ * 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
+ *
+ * @remarks
+ * 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<HealthzPingResponse>;

package/lib/api/runtimes/healthz.js

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Health check API functions for the Datalayer Runtimes service.
+ *
+ * Provides functions for checking the health status of the Runtimes service.
+ *
+ * @module api/runtimes/healthz
+ */
+import { requestDatalayerAPI } from '@datalayer/core/lib/api/DatalayerApi';
+import { API_BASE_PATHS, DEFAULT_SERVICE_URLS, } from '@datalayer/core/lib/api/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
+ *
+ * @remarks
+ * 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

@@ -0,0 +1,12 @@
+/**
+ * Runtimes API exports.
+ *
+ * Provides organized access to runtime management functionality.
+ *
+ * @module api/runtimes
+ */
+export * as environments from './environments';
+export * as healthz from './healthz';
+export * as runtimes from './runtimes';
+export * as snapshots from './snapshots';
+export * as checkpoints from './checkpoints';

package/lib/api/runtimes/index.js

@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) 2025-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Runtimes API exports.
+ *
+ * Provides organized access to runtime management functionality.
+ *
+ * @module api/runtimes
+ */
+export * as environments from './environments';
+export * as healthz from './healthz';
+export * as runtimes from './runtimes';
+export * as snapshots from './snapshots';
+export * as checkpoints from './checkpoints';

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

@@ -0,0 +1,138 @@
+import { RuntimeData, CreateRuntimeRequest, CreateRuntimeResponse, ListRuntimesResponse } from '../../models/RuntimeDTO';
+/**
+ * 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<ListRuntimesResponse>;
+/**
+ * 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<RuntimeData>;
+/**
+ * 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<RuntimeData>;
+/**
+ * Response from the pause/resume runtime endpoints.
+ * The server returns 202 Accepted and provides a checkpoint UID
+ * that can be polled for status updates.
+ */
+export interface PauseResumeResponse {
+    success: boolean;
+    message: string;
+    checkpoint_id: string | null;
+}
+/**
+ * Optional body for the pause endpoint.
+ * Metadata is stored in the checkpoint Solr record created by the backend.
+ */
+export interface PauseRuntimeBody {
+    /** Checkpoint mode: 'criu' (full) or 'light' (history-only) */
+    checkpoint_mode?: 'criu' | 'light';
+    /** Human-readable checkpoint name */
+    name?: string;
+    /** Checkpoint description */
+    description?: string;
+    /** Agentspec identifier */
+    agent_spec_id?: string;
+    /** Full agentspec payload to persist with the checkpoint */
+    agentspec?: Record<string, any>;
+    /** Additional metadata */
+    metadata?: Record<string, any>;
+    /** Lightweight checkpoint message history */
+    messages?: string[];
+}
+/**
+ * Pause a runtime by creating a checkpoint (async, light mode by default).
+ *
+ * Returns immediately with a 202 Accepted response.  The actual checkpoint
+ * process runs in the background.  Use the returned `checkpoint_id` to
+ * poll for status via the runtime-checkpoints API.
+ *
+ * @param token - Authentication token
+ * @param podName - The unique pod name of the runtime to pause
+ * @param baseUrl - Base URL for the API (defaults to production Runtimes URL)
+ * @param body - Optional metadata to store in the checkpoint record
+ * @returns Promise resolving with the checkpoint ID for status tracking
+ * @throws {Error} If authentication token is missing or invalid
+ * @throws {Error} If pod name is missing or invalid
+ */
+export declare const pauseRuntime: (token: string, podName: string, baseUrl?: string, body?: PauseRuntimeBody) => Promise<PauseResumeResponse>;
+/**
+ * Optional body for the resume endpoint.
+ * Contains information needed by the operator to restore from a checkpoint.
+ */
+export interface ResumeRuntimeBody {
+    /** Checkpoint mode to resume from: 'criu' or 'light' */
+    checkpoint_mode?: 'criu' | 'light';
+    /** Explicit checkpoint identifier */
+    checkpoint_id?: string;
+    /** Agentspec identifier (required by the operator for restore) */
+    agent_spec_id?: string;
+    /** Specific checkpoint timestamp to restore from */
+    checkpoint_timestamp?: string;
+    /** Environment name override */
+    environment_name?: string;
+    /** Container image override */
+    container_image?: string;
+    /** Target node name */
+    node_name?: string;
+    /** Additional metadata */
+    metadata?: Record<string, any>;
+}
+/**
+ * Resume a paused runtime by restoring from a checkpoint (async).
+ *
+ * Returns immediately with a 202 Accepted response.  The actual restore
+ * process runs in the background.  Use the returned `checkpoint_id` to
+ * poll for status.
+ *
+ * @param token - Authentication token
+ * @param podName - The unique pod name of the runtime to resume
+ * @param baseUrl - Base URL for the API (defaults to production Runtimes URL)
+ * @param body - Optional body with agent_spec_id and restore options
+ * @returns Promise resolving with the checkpoint ID for status tracking
+ * @throws {Error} If authentication token is missing or invalid
+ * @throws {Error} If pod name is missing or invalid
+ */
+export declare const resumeRuntime: (token: string, podName: string, baseUrl?: string, body?: ResumeRuntimeBody) => Promise<PauseResumeResponse>;