@daytonaio/sdk 0.175.0 → 0.178.0

package/esm/Daytona.js

@@ -2,7 +2,7 @@
  * Copyright 2025 Daytona Platforms Inc.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { __decorate, __metadata } from "tslib";
+import { __esDecorate, __runInitializers } from "tslib";
 import { Configuration, SnapshotsApi, ObjectStorageApi, SandboxApi, SandboxState, VolumesApi, ConfigApi, } from '@daytona/api-client';
 import axios, { AxiosError } from 'axios';
 import { DaytonaAuthenticationError, createAxiosDaytonaError, DaytonaError, DaytonaTimeoutError, DaytonaValidationError, } from './errors/DaytonaError.js';
@@ -58,473 +58,460 @@ export var CodeLanguage;
  * });
  * @class
  */
-export class Daytona {
-    clientConfig;
-    sandboxApi;
-    objectStorageApi;
-    configApi;
-    target;
-    apiKey;
-    jwtToken;
-    organizationId;
-    apiUrl;
-    otelSdk;
-    volume;
-    snapshot;
-    /**
-     * Creates a new Daytona client instance.
-     *
-     * @param {DaytonaConfig} [config] - Configuration options
-     * @throws {DaytonaAuthenticationError} When no credentials are provided (neither API key nor JWT token)
-     * @throws {DaytonaAuthenticationError} When JWT token is provided without an organization ID
-     */
-    constructor(config) {
-        let apiUrl;
-        if (config) {
-            this.apiKey = !config?.apiKey && config?.jwtToken ? undefined : config?.apiKey;
-            this.jwtToken = config?.jwtToken;
-            this.organizationId = config?.organizationId;
-            apiUrl = config?.apiUrl || config?.serverUrl;
-            this.target = config?.target;
+let Daytona = (() => {
+    let _instanceExtraInitializers = [];
+    let _create_decorators;
+    let _get_decorators;
+    let _list_decorators;
+    let _start_decorators;
+    let _stop_decorators;
+    let __experimental_fork_decorators;
+    let _delete_decorators;
+    return class Daytona {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _create_decorators = [WithInstrumentation()];
+            _get_decorators = [WithInstrumentation()];
+            _list_decorators = [WithInstrumentation()];
+            _start_decorators = [WithInstrumentation()];
+            _stop_decorators = [WithInstrumentation()];
+            __experimental_fork_decorators = [WithInstrumentation()];
+            _delete_decorators = [WithInstrumentation()];
+            __esDecorate(this, null, _create_decorators, { kind: "method", name: "create", static: false, private: false, access: { has: obj => "create" in obj, get: obj => obj.create }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _get_decorators, { kind: "method", name: "get", static: false, private: false, access: { has: obj => "get" in obj, get: obj => obj.get }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _list_decorators, { kind: "method", name: "list", static: false, private: false, access: { has: obj => "list" in obj, get: obj => obj.list }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _start_decorators, { kind: "method", name: "start", static: false, private: false, access: { has: obj => "start" in obj, get: obj => obj.start }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _stop_decorators, { kind: "method", name: "stop", static: false, private: false, access: { has: obj => "stop" in obj, get: obj => obj.stop }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, __experimental_fork_decorators, { kind: "method", name: "_experimental_fork", static: false, private: false, access: { has: obj => "_experimental_fork" in obj, get: obj => obj._experimental_fork }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _delete_decorators, { kind: "method", name: "delete", static: false, private: false, access: { has: obj => "delete" in obj, get: obj => obj.delete }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
-        let _envReader;
-        const envReader = () => {
-            if (_envReader === undefined) {
-                _envReader = RUNTIME !== Runtime.BROWSER ? new DaytonaEnvReader() : null;
+        clientConfig = __runInitializers(this, _instanceExtraInitializers);
+        sandboxApi;
+        objectStorageApi;
+        configApi;
+        target;
+        apiKey;
+        jwtToken;
+        organizationId;
+        apiUrl;
+        otelSdk;
+        volume;
+        snapshot;
+        /**
+         * Creates a new Daytona client instance.
+         *
+         * @param {DaytonaConfig} [config] - Configuration options
+         * @throws {DaytonaAuthenticationError} When no credentials are provided (neither API key nor JWT token)
+         * @throws {DaytonaAuthenticationError} When JWT token is provided without an organization ID
+         */
+        constructor(config) {
+            let apiUrl;
+            if (config) {
+                this.apiKey = !config?.apiKey && config?.jwtToken ? undefined : config?.apiKey;
+                this.jwtToken = config?.jwtToken;
+                this.organizationId = config?.organizationId;
+                apiUrl = config?.apiUrl || config?.serverUrl;
+                this.target = config?.target;
             }
-            return _envReader;
-        };
-        if (!config ||
-            (!(this.apiKey && apiUrl && this.target) && !(this.jwtToken && this.organizationId && apiUrl && this.target))) {
-            const reader = envReader();
-            if (reader) {
-                this.apiKey = this.apiKey || (this.jwtToken ? undefined : reader.get('DAYTONA_API_KEY'));
-                this.jwtToken = this.jwtToken || reader.get('DAYTONA_JWT_TOKEN');
-                this.organizationId = this.organizationId || reader.get('DAYTONA_ORGANIZATION_ID');
-                apiUrl = apiUrl || reader.get('DAYTONA_API_URL') || reader.get('DAYTONA_SERVER_URL');
-                this.target = this.target || reader.get('DAYTONA_TARGET');
-                if (reader.get('DAYTONA_SERVER_URL') && !reader.get('DAYTONA_API_URL')) {
-                    console.warn('[Deprecation Warning] Environment variable `DAYTONA_SERVER_URL` is deprecated and will be removed in future versions. Use `DAYTONA_API_URL` instead.');
+            let _envReader;
+            const envReader = () => {
+                if (_envReader === undefined) {
+                    _envReader = RUNTIME !== Runtime.BROWSER ? new DaytonaEnvReader() : null;
+                }
+                return _envReader;
+            };
+            if (!config ||
+                (!(this.apiKey && apiUrl && this.target) && !(this.jwtToken && this.organizationId && apiUrl && this.target))) {
+                const reader = envReader();
+                if (reader) {
+                    this.apiKey = this.apiKey || (this.jwtToken ? undefined : reader.get('DAYTONA_API_KEY'));
+                    this.jwtToken = this.jwtToken || reader.get('DAYTONA_JWT_TOKEN');
+                    this.organizationId = this.organizationId || reader.get('DAYTONA_ORGANIZATION_ID');
+                    apiUrl = apiUrl || reader.get('DAYTONA_API_URL') || reader.get('DAYTONA_SERVER_URL');
+                    this.target = this.target || reader.get('DAYTONA_TARGET');
+                    if (reader.get('DAYTONA_SERVER_URL') && !reader.get('DAYTONA_API_URL')) {
+                        console.warn('[Deprecation Warning] Environment variable `DAYTONA_SERVER_URL` is deprecated and will be removed in future versions. Use `DAYTONA_API_URL` instead.');
+                    }
                 }
             }
-        }
-        this.apiUrl = apiUrl || 'https://app.daytona.io/api';
-        if (!this.apiKey && !this.jwtToken) {
-            throw new DaytonaAuthenticationError('Authentication credentials not found. Set DAYTONA_API_KEY, or both DAYTONA_JWT_TOKEN and DAYTONA_ORGANIZATION_ID.' +
-                ' These can also be provided via DaytonaConfig.');
-        }
-        const orgHeader = {};
-        if (!this.apiKey) {
-            if (!this.organizationId) {
-                throw new DaytonaAuthenticationError('DAYTONA_ORGANIZATION_ID is required when authenticating with DAYTONA_JWT_TOKEN.' +
-                    ' It can also be provided via DaytonaConfig.');
+            this.apiUrl = apiUrl || 'https://app.daytona.io/api';
+            if (!this.apiKey && !this.jwtToken) {
+                throw new DaytonaAuthenticationError('Authentication credentials not found. Set DAYTONA_API_KEY, or both DAYTONA_JWT_TOKEN and DAYTONA_ORGANIZATION_ID.' +
+                    ' These can also be provided via DaytonaConfig.');
             }
-            orgHeader['X-Daytona-Organization-ID'] = this.organizationId;
-        }
-        const isLegacyPackage = packageJson.name === '@daytonaio/sdk';
-        const sdkLabel = isLegacyPackage ? 'sdk-typescript-legacy' : 'sdk-typescript';
-        const configuration = new Configuration({
-            basePath: this.apiUrl,
-            baseOptions: {
-                headers: {
-                    Authorization: `Bearer ${this.apiKey || this.jwtToken}`,
-                    'X-Daytona-Source': sdkLabel,
-                    'X-Daytona-SDK-Version': packageJson.version,
-                    'User-Agent': `${sdkLabel}/${packageJson.version}`,
-                    ...orgHeader,
+            const orgHeader = {};
+            if (!this.apiKey) {
+                if (!this.organizationId) {
+                    throw new DaytonaAuthenticationError('DAYTONA_ORGANIZATION_ID is required when authenticating with DAYTONA_JWT_TOKEN.' +
+                        ' It can also be provided via DaytonaConfig.');
+                }
+                orgHeader['X-Daytona-Organization-ID'] = this.organizationId;
+            }
+            const isLegacyPackage = packageJson.name === '@daytonaio/sdk';
+            const sdkLabel = isLegacyPackage ? 'sdk-typescript-legacy' : 'sdk-typescript';
+            const configuration = new Configuration({
+                basePath: this.apiUrl,
+                baseOptions: {
+                    headers: {
+                        Authorization: `Bearer ${this.apiKey || this.jwtToken}`,
+                        'X-Daytona-Source': sdkLabel,
+                        'X-Daytona-SDK-Version': packageJson.version,
+                        'User-Agent': `${sdkLabel}/${packageJson.version}`,
+                        ...orgHeader,
+                    },
                 },
-            },
-        });
-        const axiosInstance = Daytona.createAxiosInstance();
-        this.sandboxApi = new SandboxApi(configuration, '', axiosInstance);
-        this.objectStorageApi = new ObjectStorageApi(configuration, '', axiosInstance);
-        this.configApi = new ConfigApi(configuration, '', axiosInstance);
-        this.volume = new VolumeService(new VolumesApi(configuration, '', axiosInstance));
-        this.snapshot = new SnapshotService(configuration, new SnapshotsApi(configuration, '', axiosInstance), this.objectStorageApi, this.target);
-        this.clientConfig = configuration;
-        const env = envReader();
-        const otelEnabled = config?.otelEnabled ||
-            config?._experimental?.otelEnabled ||
-            env?.get('DAYTONA_OTEL_ENABLED') === 'true' ||
-            env?.get('DAYTONA_EXPERIMENTAL_OTEL_ENABLED') === 'true';
-        if (!otelEnabled) {
-            return;
-        }
-        const errPrefix = 'OpenTelemetry instrumentation is not supported: ';
-        const { diag, DiagConsoleLogger, DiagLogLevel } = dynamicRequire('@opentelemetry/api', errPrefix);
-        const { NodeSDK } = dynamicRequire('@opentelemetry/sdk-node', errPrefix);
-        const { HttpInstrumentation } = dynamicRequire('@opentelemetry/instrumentation-http', errPrefix);
-        const { BatchSpanProcessor } = dynamicRequire('@opentelemetry/sdk-trace-base', errPrefix);
-        const { OTLPTraceExporter } = dynamicRequire('@opentelemetry/exporter-trace-otlp-http', errPrefix);
-        const { CompressionAlgorithm } = dynamicRequire('@opentelemetry/otlp-exporter-base', errPrefix);
-        const { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } = dynamicRequire('@opentelemetry/semantic-conventions', errPrefix);
-        const { resourceFromAttributes } = dynamicRequire('@opentelemetry/resources', errPrefix);
-        diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.INFO);
-        this.otelSdk = new NodeSDK({
-            resource: resourceFromAttributes({
-                [ATTR_SERVICE_VERSION]: packageJson.version,
-                [ATTR_SERVICE_NAME]: 'daytona-typescript-sdk',
-            }),
-            instrumentations: [
-                new HttpInstrumentation({
-                    requireParentforOutgoingSpans: false,
+            });
+            const axiosInstance = Daytona.createAxiosInstance();
+            this.sandboxApi = new SandboxApi(configuration, '', axiosInstance);
+            this.objectStorageApi = new ObjectStorageApi(configuration, '', axiosInstance);
+            this.configApi = new ConfigApi(configuration, '', axiosInstance);
+            this.volume = new VolumeService(new VolumesApi(configuration, '', axiosInstance));
+            this.snapshot = new SnapshotService(configuration, new SnapshotsApi(configuration, '', axiosInstance), this.objectStorageApi, this.target);
+            this.clientConfig = configuration;
+            const env = envReader();
+            const otelEnabled = config?.otelEnabled ||
+                config?._experimental?.otelEnabled ||
+                env?.get('DAYTONA_OTEL_ENABLED') === 'true' ||
+                env?.get('DAYTONA_EXPERIMENTAL_OTEL_ENABLED') === 'true';
+            if (!otelEnabled) {
+                return;
+            }
+            const errPrefix = 'OpenTelemetry instrumentation is not supported: ';
+            const { diag, DiagConsoleLogger, DiagLogLevel } = dynamicRequire('@opentelemetry/api', errPrefix);
+            const { NodeSDK } = dynamicRequire('@opentelemetry/sdk-node', errPrefix);
+            const { HttpInstrumentation } = dynamicRequire('@opentelemetry/instrumentation-http', errPrefix);
+            const { BatchSpanProcessor } = dynamicRequire('@opentelemetry/sdk-trace-base', errPrefix);
+            const { OTLPTraceExporter } = dynamicRequire('@opentelemetry/exporter-trace-otlp-http', errPrefix);
+            const { CompressionAlgorithm } = dynamicRequire('@opentelemetry/otlp-exporter-base', errPrefix);
+            const { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION } = dynamicRequire('@opentelemetry/semantic-conventions', errPrefix);
+            const { resourceFromAttributes } = dynamicRequire('@opentelemetry/resources', errPrefix);
+            diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.INFO);
+            this.otelSdk = new NodeSDK({
+                resource: resourceFromAttributes({
+                    [ATTR_SERVICE_VERSION]: packageJson.version,
+                    [ATTR_SERVICE_NAME]: 'daytona-typescript-sdk',
                 }),
-            ],
-            spanProcessors: [
-                new BatchSpanProcessor(new OTLPTraceExporter({
-                    compression: CompressionAlgorithm.GZIP,
-                })),
-            ],
-        });
-        this.otelSdk.start();
-        // Flush and shutdown OTEL on process exit
-        process.on('SIGTERM', async () => {
-            await this.otelSdk?.shutdown();
-        });
-    }
-    async [Symbol.asyncDispose]() {
-        if (!this.otelSdk) {
-            return;
-        }
-        await this.otelSdk.shutdown();
-    }
-    async create(params, options = { timeout: 60 }) {
-        const startTime = Date.now();
-        options = typeof options === 'number' ? { timeout: options } : { ...options };
-        if (options.timeout == undefined || options.timeout == null) {
-            options.timeout = 60;
-        }
-        if (params == null) {
-            params = { language: 'python' };
-        }
-        if (!params.language) {
-            params.language = 'python';
+                instrumentations: [
+                    new HttpInstrumentation({
+                        requireParentforOutgoingSpans: false,
+                    }),
+                ],
+                spanProcessors: [
+                    new BatchSpanProcessor(new OTLPTraceExporter({
+                        compression: CompressionAlgorithm.GZIP,
+                    })),
+                ],
+            });
+            this.otelSdk.start();
+            // Flush and shutdown OTEL on process exit
+            process.on('SIGTERM', async () => {
+                await this.otelSdk?.shutdown();
+            });
         }
-        const labels = params.labels || {};
-        if (params.language) {
-            const validLanguages = Object.values(CodeLanguage);
-            if (!validLanguages.includes(params.language)) {
-                throw new DaytonaValidationError(`Invalid ${CODE_TOOLBOX_LANGUAGE_LABEL}: ${params.language}. Supported languages: ${validLanguages.join(', ')}`);
+        async [Symbol.asyncDispose]() {
+            if (!this.otelSdk) {
+                return;
             }
-            labels[CODE_TOOLBOX_LANGUAGE_LABEL] = params.language;
-        }
-        if (options.timeout < 0) {
-            throw new DaytonaValidationError('Timeout must be a non-negative number');
+            await this.otelSdk.shutdown();
         }
-        if (params.autoStopInterval !== undefined &&
-            (!Number.isInteger(params.autoStopInterval) || params.autoStopInterval < 0)) {
-            throw new DaytonaValidationError('autoStopInterval must be a non-negative integer');
-        }
-        if (params.ephemeral) {
-            if (params.autoDeleteInterval !== undefined && params.autoDeleteInterval !== 0) {
-                console.warn("'ephemeral' and 'autoDeleteInterval' cannot be used together. If ephemeral is true, autoDeleteInterval will be ignored and set to 0.");
+        async create(params, options = { timeout: 60 }) {
+            const startTime = Date.now();
+            options = typeof options === 'number' ? { timeout: options } : { ...options };
+            if (options.timeout == undefined || options.timeout == null) {
+                options.timeout = 60;
             }
-            params.autoDeleteInterval = 0;
-        }
-        if (params.autoArchiveInterval !== undefined &&
-            (!Number.isInteger(params.autoArchiveInterval) || params.autoArchiveInterval < 0)) {
-            throw new DaytonaValidationError('autoArchiveInterval must be a non-negative integer');
-        }
-        try {
-            let buildInfo;
-            let snapshot;
-            let resources;
-            if ('snapshot' in params) {
-                snapshot = params.snapshot;
+            if (params == null) {
+                params = { language: 'python' };
+            }
+            if (!params.language) {
+                params.language = 'python';
             }
-            if ('image' in params) {
-                if (typeof params.image === 'string') {
-                    buildInfo = {
-                        dockerfileContent: Image.base(params.image).dockerfile,
-                    };
+            const labels = params.labels || {};
+            if (params.language) {
+                const validLanguages = Object.values(CodeLanguage);
+                if (!validLanguages.includes(params.language)) {
+                    throw new DaytonaValidationError(`Invalid ${CODE_TOOLBOX_LANGUAGE_LABEL}: ${params.language}. Supported languages: ${validLanguages.join(', ')}`);
                 }
-                else if (params.image instanceof Image) {
-                    const contextHashes = await SnapshotService.processImageContext(this.objectStorageApi, params.image);
-                    buildInfo = {
-                        contextHashes,
-                        dockerfileContent: params.image.dockerfile,
-                    };
+                labels[CODE_TOOLBOX_LANGUAGE_LABEL] = params.language;
+            }
+            if (options.timeout < 0) {
+                throw new DaytonaValidationError('Timeout must be a non-negative number');
+            }
+            if (params.autoStopInterval !== undefined &&
+                (!Number.isInteger(params.autoStopInterval) || params.autoStopInterval < 0)) {
+                throw new DaytonaValidationError('autoStopInterval must be a non-negative integer');
+            }
+            if (params.ephemeral) {
+                if (params.autoDeleteInterval !== undefined && params.autoDeleteInterval !== 0) {
+                    console.warn("'ephemeral' and 'autoDeleteInterval' cannot be used together. If ephemeral is true, autoDeleteInterval will be ignored and set to 0.");
                 }
+                params.autoDeleteInterval = 0;
             }
-            if ('resources' in params) {
-                resources = params.resources;
+            if (params.autoArchiveInterval !== undefined &&
+                (!Number.isInteger(params.autoArchiveInterval) || params.autoArchiveInterval < 0)) {
+                throw new DaytonaValidationError('autoArchiveInterval must be a non-negative integer');
             }
-            const response = await this.sandboxApi.createSandbox({
-                name: params.name,
-                snapshot: snapshot,
-                buildInfo,
-                user: params.user,
-                env: params.envVars || {},
-                labels: labels,
-                public: params.public,
-                target: this.target,
-                cpu: resources?.cpu,
-                gpu: resources?.gpu,
-                memory: resources?.memory,
-                disk: resources?.disk,
-                autoStopInterval: params.autoStopInterval,
-                autoArchiveInterval: params.autoArchiveInterval,
-                autoDeleteInterval: params.autoDeleteInterval,
-                volumes: params.volumes,
-                networkBlockAll: params.networkBlockAll,
-                networkAllowList: params.networkAllowList,
-            }, undefined, {
-                timeout: options.timeout * 1000,
-            });
-            let sandboxInstance = response.data;
-            if (sandboxInstance.state === SandboxState.PENDING_BUILD && options.onSnapshotCreateLogs) {
-                const terminalStates = [
-                    SandboxState.STARTED,
-                    SandboxState.STARTING,
-                    SandboxState.ERROR,
-                    SandboxState.BUILD_FAILED,
-                ];
-                while (sandboxInstance.state === SandboxState.PENDING_BUILD) {
-                    if (options.timeout) {
-                        const elapsed = (Date.now() - startTime) / 1000;
-                        if (elapsed > options.timeout) {
-                            throw new DaytonaTimeoutError(`Sandbox build has been pending for more than ${options.timeout} seconds. Please check the sandbox state again later.`);
-                        }
+            try {
+                let buildInfo;
+                let snapshot;
+                let resources;
+                if ('snapshot' in params) {
+                    snapshot = params.snapshot;
+                }
+                if ('image' in params) {
+                    if (typeof params.image === 'string') {
+                        buildInfo = {
+                            dockerfileContent: Image.base(params.image).dockerfile,
+                        };
+                    }
+                    else if (params.image instanceof Image) {
+                        const contextHashes = await SnapshotService.processImageContext(this.objectStorageApi, params.image);
+                        buildInfo = {
+                            contextHashes,
+                            dockerfileContent: params.image.dockerfile,
+                        };
                     }
-                    await new Promise((resolve) => setTimeout(resolve, 1000));
-                    sandboxInstance = (await this.sandboxApi.getSandbox(sandboxInstance.id)).data;
                 }
-                const response = await this.sandboxApi.getBuildLogsUrl(sandboxInstance.id);
-                await processStreamingResponse(() => fetch(response.data.url + '?follow=true', {
-                    method: 'GET',
-                    headers: this.clientConfig.baseOptions.headers,
-                }), (chunk) => options.onSnapshotCreateLogs?.(chunk.trimEnd()), async () => {
-                    sandboxInstance = (await this.sandboxApi.getSandbox(sandboxInstance.id)).data;
-                    return sandboxInstance.state !== undefined && terminalStates.includes(sandboxInstance.state);
+                if ('resources' in params) {
+                    resources = params.resources;
+                }
+                const response = await this.sandboxApi.createSandbox({
+                    name: params.name,
+                    snapshot: snapshot,
+                    buildInfo,
+                    user: params.user,
+                    env: params.envVars || {},
+                    labels: labels,
+                    public: params.public,
+                    target: this.target,
+                    cpu: resources?.cpu,
+                    gpu: resources?.gpu,
+                    memory: resources?.memory,
+                    disk: resources?.disk,
+                    autoStopInterval: params.autoStopInterval,
+                    autoArchiveInterval: params.autoArchiveInterval,
+                    autoDeleteInterval: params.autoDeleteInterval,
+                    volumes: params.volumes,
+                    networkBlockAll: params.networkBlockAll,
+                    networkAllowList: params.networkAllowList,
+                }, undefined, {
+                    timeout: options.timeout * 1000,
                 });
+                let sandboxInstance = response.data;
+                if (sandboxInstance.state === SandboxState.PENDING_BUILD && options.onSnapshotCreateLogs) {
+                    const terminalStates = [
+                        SandboxState.STARTED,
+                        SandboxState.STARTING,
+                        SandboxState.ERROR,
+                        SandboxState.BUILD_FAILED,
+                    ];
+                    while (sandboxInstance.state === SandboxState.PENDING_BUILD) {
+                        if (options.timeout) {
+                            const elapsed = (Date.now() - startTime) / 1000;
+                            if (elapsed > options.timeout) {
+                                throw new DaytonaTimeoutError(`Sandbox build has been pending for more than ${options.timeout} seconds. Please check the sandbox state again later.`);
+                            }
+                        }
+                        await new Promise((resolve) => setTimeout(resolve, 1000));
+                        sandboxInstance = (await this.sandboxApi.getSandbox(sandboxInstance.id)).data;
+                    }
+                    const response = await this.sandboxApi.getBuildLogsUrl(sandboxInstance.id);
+                    await processStreamingResponse(() => fetch(response.data.url + '?follow=true', {
+                        method: 'GET',
+                        headers: this.clientConfig.baseOptions.headers,
+                    }), (chunk) => options.onSnapshotCreateLogs?.(chunk.trimEnd()), async () => {
+                        sandboxInstance = (await this.sandboxApi.getSandbox(sandboxInstance.id)).data;
+                        return sandboxInstance.state !== undefined && terminalStates.includes(sandboxInstance.state);
+                    });
+                }
+                const sandbox = new Sandbox(sandboxInstance, new Configuration(structuredClone(this.clientConfig)), Daytona.createAxiosInstance(), this.sandboxApi);
+                if (sandbox.state !== 'started') {
+                    const timeElapsed = Date.now() - startTime;
+                    await sandbox.waitUntilStarted(options.timeout ? Math.max(0.001, options.timeout - timeElapsed / 1000) : options.timeout);
+                }
+                return sandbox;
             }
-            const sandbox = new Sandbox(sandboxInstance, new Configuration(structuredClone(this.clientConfig)), Daytona.createAxiosInstance(), this.sandboxApi);
-            if (sandbox.state !== 'started') {
-                const timeElapsed = Date.now() - startTime;
-                await sandbox.waitUntilStarted(options.timeout ? Math.max(0.001, options.timeout - timeElapsed / 1000) : options.timeout);
+            catch (error) {
+                if (error instanceof DaytonaTimeoutError) {
+                    const errMsg = `Failed to create and start sandbox within ${options.timeout} seconds. Operation timed out.`;
+                    throw new DaytonaTimeoutError(errMsg, error.statusCode, error.headers, error.errorCode);
+                }
+                throw error;
             }
-            return sandbox;
         }
-        catch (error) {
-            if (error instanceof DaytonaTimeoutError) {
-                const errMsg = `Failed to create and start sandbox within ${options.timeout} seconds. Operation timed out.`;
-                throw new DaytonaTimeoutError(errMsg, error.statusCode, error.headers, error.errorCode);
-            }
-            throw error;
+        /**
+         * Gets a Sandbox by its ID or name.
+         *
+         * @param {string} sandboxIdOrName - The ID or name of the Sandbox to retrieve
+         * @returns {Promise<Sandbox>} The Sandbox
+         *
+         * @example
+         * const sandbox = await daytona.get('my-sandbox-id-or-name');
+         * console.log(`Sandbox state: ${sandbox.state}`);
+         */
+        async get(sandboxIdOrName) {
+            const response = await this.sandboxApi.getSandbox(sandboxIdOrName);
+            const sandboxInstance = response.data;
+            return new Sandbox(sandboxInstance, structuredClone(this.clientConfig), Daytona.createAxiosInstance(), this.sandboxApi);
         }
-    }
-    /**
-     * Gets a Sandbox by its ID or name.
-     *
-     * @param {string} sandboxIdOrName - The ID or name of the Sandbox to retrieve
-     * @returns {Promise<Sandbox>} The Sandbox
-     *
-     * @example
-     * const sandbox = await daytona.get('my-sandbox-id-or-name');
-     * console.log(`Sandbox state: ${sandbox.state}`);
-     */
-    async get(sandboxIdOrName) {
-        const response = await this.sandboxApi.getSandbox(sandboxIdOrName);
-        const sandboxInstance = response.data;
-        return new Sandbox(sandboxInstance, structuredClone(this.clientConfig), Daytona.createAxiosInstance(), this.sandboxApi);
-    }
-    /**
-     * Returns paginated list of Sandboxes filtered by labels.
-     *
-     * @param {Record<string, string>} [labels] - Labels to filter Sandboxes
-     * @param {number} [page] - Page number for pagination (starting from 1)
-     * @param {number} [limit] - Maximum number of items per page
-     * @returns {Promise<PaginatedSandboxes>} Paginated list of Sandboxes that match the labels.
-     *
-     * @example
-     * const result = await daytona.list({ 'my-label': 'my-value' }, 2, 10);
-     * for (const sandbox of result.items) {
-     *     console.log(`${sandbox.id}: ${sandbox.state}`);
-     * }
-     */
-    async list(labels, page, limit) {
-        const response = await this.sandboxApi.listSandboxesPaginated(undefined, page, limit, undefined, undefined, labels ? JSON.stringify(labels) : undefined);
-        return {
-            items: response.data.items.map((sandbox) => {
-                return new Sandbox(sandbox, structuredClone(this.clientConfig), Daytona.createAxiosInstance(), this.sandboxApi);
-            }),
-            total: response.data.total,
-            page: response.data.page,
-            totalPages: response.data.totalPages,
-        };
-    }
-    /**
-     * Starts a Sandbox and waits for it to be ready.
-     *
-     * @param {Sandbox} sandbox - The Sandbox to start
-     * @param {number} [timeout] - Optional timeout in seconds (0 means no timeout)
-     * @returns {Promise<void>}
-     *
-     * @example
-     * const sandbox = await daytona.get('my-sandbox-id');
-     * // Wait up to 60 seconds for the sandbox to start
-     * await daytona.start(sandbox, 60);
-     */
-    async start(sandbox, timeout) {
-        await sandbox.start(timeout);
-    }
-    /**
-     * Stops a Sandbox.
-     *
-     * @param {Sandbox} sandbox - The Sandbox to stop
-     * @returns {Promise<void>}
-     *
-     * @example
-     * const sandbox = await daytona.get('my-sandbox-id');
-     * await daytona.stop(sandbox);
-     */
-    async stop(sandbox) {
-        await sandbox.stop();
-    }
-    /**
-     * Forks a Sandbox, creating a new Sandbox with an identical filesystem.
-     *
-     * @param {Sandbox} sandbox - The Sandbox to fork
-     * @param {object} [params] - Fork parameters
-     * @param {string} [params.name] - Optional name for the forked Sandbox
-     * @param {number} [timeout] - Timeout in seconds (0 means no timeout, default is 60)
-     * @returns {Promise<Sandbox>} The forked Sandbox
-     *
-     * @example
-     * const sandbox = await daytona.get('my-sandbox-id');
-     * const forked = await daytona._experimental_fork(sandbox, { name: 'my-fork' });
-     * console.log(`Forked sandbox: ${forked.id}`);
-     */
-    async _experimental_fork(sandbox, params, timeout = 60) {
-        return await sandbox._experimental_fork(params, timeout);
-    }
-    /**
-     * Deletes a Sandbox.
-     *
-     * @param {Sandbox} sandbox - The Sandbox to delete
-     * @param {number} timeout - Timeout in seconds (0 means no timeout, default is 60)
-     * @returns {Promise<void>}
-     *
-     * @example
-     * const sandbox = await daytona.get('my-sandbox-id');
-     * await daytona.delete(sandbox);
-     */
-    async delete(sandbox, timeout = 60) {
-        await sandbox.delete(timeout);
-    }
-    /**
-     * @hidden
-     */
-    static createAxiosInstance() {
-        const axiosInstance = axios.create({
-            timeout: 24 * 60 * 60 * 1000, // 24 hours
-        });
-        // Request interceptor: Inject trace context into headers
-        axiosInstance.interceptors.request.use((requestConfig) => {
-            // Get the current active context (which may contain an active span)
-            const currentContext = context.active();
-            // Inject trace context into HTTP headers using W3C Trace Context propagation
-            // This adds headers like 'traceparent' and 'tracestate'
-            propagation.inject(currentContext, requestConfig.headers);
-            requestConfig.metadata = { startTime: Date.now() };
-            return requestConfig;
-        }, (error) => {
-            return Promise.reject(error);
-        });
-        axiosInstance.interceptors.response.use((response) => {
-            return response;
-        }, (error) => {
-            if (error instanceof AxiosError) {
-                throw createAxiosDaytonaError(error);
-            }
-            throw new DaytonaError(error instanceof Error ? error.message : String(error));
-        });
-        axiosInstance.interceptors.response.use((response) => {
-            const startTime = response.config.metadata?.startTime;
-            if (startTime) {
-                const duration = Date.now() - startTime;
-                // Get the active span to add attributes
-                const activeSpan = trace.getActiveSpan();
-                // Only modify the span if it's still recording (not ended)
-                if (activeSpan && activeSpan.isRecording()) {
-                    // Add response metadata to the span
-                    activeSpan.setAttributes({
-                        'http.response.status_code': response.status,
-                        'http.response.duration_ms': duration,
-                        // 'http.response.size_bytes': JSON.stringify(response.data).length,
-                    });
+        /**
+         * Returns paginated list of Sandboxes filtered by labels.
+         *
+         * @param {Record<string, string>} [labels] - Labels to filter Sandboxes
+         * @param {number} [page] - Page number for pagination (starting from 1)
+         * @param {number} [limit] - Maximum number of items per page
+         * @returns {Promise<PaginatedSandboxes>} Paginated list of Sandboxes that match the labels.
+         *
+         * @example
+         * const result = await daytona.list({ 'my-label': 'my-value' }, 2, 10);
+         * for (const sandbox of result.items) {
+         *     console.log(`${sandbox.id}: ${sandbox.state}`);
+         * }
+         */
+        async list(labels, page, limit) {
+            const response = await this.sandboxApi.listSandboxesPaginated(undefined, page, limit, undefined, undefined, labels ? JSON.stringify(labels) : undefined);
+            return {
+                items: response.data.items.map((sandbox) => {
+                    return new Sandbox(sandbox, structuredClone(this.clientConfig), Daytona.createAxiosInstance(), this.sandboxApi);
+                }),
+                total: response.data.total,
+                page: response.data.page,
+                totalPages: response.data.totalPages,
+            };
+        }
+        /**
+         * Starts a Sandbox and waits for it to be ready.
+         *
+         * @param {Sandbox} sandbox - The Sandbox to start
+         * @param {number} [timeout] - Optional timeout in seconds (0 means no timeout)
+         * @returns {Promise<void>}
+         *
+         * @example
+         * const sandbox = await daytona.get('my-sandbox-id');
+         * // Wait up to 60 seconds for the sandbox to start
+         * await daytona.start(sandbox, 60);
+         */
+        async start(sandbox, timeout) {
+            await sandbox.start(timeout);
+        }
+        /**
+         * Stops a Sandbox.
+         *
+         * @param {Sandbox} sandbox - The Sandbox to stop
+         * @returns {Promise<void>}
+         *
+         * @example
+         * const sandbox = await daytona.get('my-sandbox-id');
+         * await daytona.stop(sandbox);
+         */
+        async stop(sandbox) {
+            await sandbox.stop();
+        }
+        /**
+         * Forks a Sandbox, creating a new Sandbox with an identical filesystem.
+         *
+         * @param {Sandbox} sandbox - The Sandbox to fork
+         * @param {object} [params] - Fork parameters
+         * @param {string} [params.name] - Optional name for the forked Sandbox
+         * @param {number} [timeout] - Timeout in seconds (0 means no timeout, default is 60)
+         * @returns {Promise<Sandbox>} The forked Sandbox
+         *
+         * @example
+         * const sandbox = await daytona.get('my-sandbox-id');
+         * const forked = await daytona._experimental_fork(sandbox, { name: 'my-fork' });
+         * console.log(`Forked sandbox: ${forked.id}`);
+         */
+        async _experimental_fork(sandbox, params, timeout = 60) {
+            return await sandbox._experimental_fork(params, timeout);
+        }
+        /**
+         * Deletes a Sandbox.
+         *
+         * @param {Sandbox} sandbox - The Sandbox to delete
+         * @param {number} timeout - Timeout in seconds (0 means no timeout, default is 60)
+         * @returns {Promise<void>}
+         *
+         * @example
+         * const sandbox = await daytona.get('my-sandbox-id');
+         * await daytona.delete(sandbox);
+         */
+        async delete(sandbox, timeout = 60) {
+            await sandbox.delete(timeout);
+        }
+        /**
+         * @hidden
+         */
+        static createAxiosInstance() {
+            const axiosInstance = axios.create({
+                timeout: 24 * 60 * 60 * 1000, // 24 hours
+            });
+            // Request interceptor: Inject trace context into headers
+            axiosInstance.interceptors.request.use((requestConfig) => {
+                // Get the current active context (which may contain an active span)
+                const currentContext = context.active();
+                // Inject trace context into HTTP headers using W3C Trace Context propagation
+                // This adds headers like 'traceparent' and 'tracestate'
+                propagation.inject(currentContext, requestConfig.headers);
+                requestConfig.metadata = { startTime: Date.now() };
+                return requestConfig;
+            }, (error) => {
+                return Promise.reject(error);
+            });
+            axiosInstance.interceptors.response.use((response) => {
+                return response;
+            }, (error) => {
+                if (error instanceof AxiosError) {
+                    throw createAxiosDaytonaError(error);
                 }
-            }
-            return response;
-        }, (error) => {
-            const startTime = error.config?.metadata?.startTime;
-            if (startTime) {
-                const duration = Date.now() - startTime;
-                // Get the active span to record the error
-                const activeSpan = trace.getActiveSpan();
-                // Only modify the span if it's still recording (not ended)
-                if (activeSpan && activeSpan.isRecording()) {
-                    activeSpan.setStatus({
-                        code: SpanStatusCode.ERROR,
-                        message: error.message,
-                    });
-                    activeSpan.setAttributes({
-                        'http.response.duration_ms': duration,
-                        'error.type': error.name,
-                        'error.message': error.message,
-                    });
-                    if (error.response) {
-                        activeSpan.setAttribute('http.response.status_code', error.response.status);
+                throw new DaytonaError(error instanceof Error ? error.message : String(error));
+            });
+            axiosInstance.interceptors.response.use((response) => {
+                const startTime = response.config.metadata?.startTime;
+                if (startTime) {
+                    const duration = Date.now() - startTime;
+                    // Get the active span to add attributes
+                    const activeSpan = trace.getActiveSpan();
+                    // Only modify the span if it's still recording (not ended)
+                    if (activeSpan && activeSpan.isRecording()) {
+                        // Add response metadata to the span
+                        activeSpan.setAttributes({
+                            'http.response.status_code': response.status,
+                            'http.response.duration_ms': duration,
+                            // 'http.response.size_bytes': JSON.stringify(response.data).length,
+                        });
                     }
-                    // Record the exception on the span
-                    activeSpan.recordException(error);
                 }
-            }
-            return Promise.reject(error);
-        });
-        return axiosInstance;
-    }
-}
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object]),
-    __metadata("design:returntype", Promise)
-], Daytona.prototype, "create", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String]),
-    __metadata("design:returntype", Promise)
-], Daytona.prototype, "get", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Number, Number]),
-    __metadata("design:returntype", Promise)
-], Daytona.prototype, "list", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Sandbox, Number]),
-    __metadata("design:returntype", Promise)
-], Daytona.prototype, "start", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Sandbox]),
-    __metadata("design:returntype", Promise)
-], Daytona.prototype, "stop", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Sandbox, Object, Object]),
-    __metadata("design:returntype", Promise)
-], Daytona.prototype, "_experimental_fork", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Sandbox, Object]),
-    __metadata("design:returntype", Promise)
-], Daytona.prototype, "delete", null);
+                return response;
+            }, (error) => {
+                const startTime = error.config?.metadata?.startTime;
+                if (startTime) {
+                    const duration = Date.now() - startTime;
+                    // Get the active span to record the error
+                    const activeSpan = trace.getActiveSpan();
+                    // Only modify the span if it's still recording (not ended)
+                    if (activeSpan && activeSpan.isRecording()) {
+                        activeSpan.setStatus({
+                            code: SpanStatusCode.ERROR,
+                            message: error.message,
+                        });
+                        activeSpan.setAttributes({
+                            'http.response.duration_ms': duration,
+                            'error.type': error.name,
+                            'error.message': error.message,
+                        });
+                        if (error.response) {
+                            activeSpan.setAttribute('http.response.status_code', error.response.status);
+                        }
+                        // Record the exception on the span
+                        activeSpan.recordException(error);
+                    }
+                }
+                return Promise.reject(error);
+            });
+            return axiosInstance;
+        }
+    };
+})();
+export { Daytona };
 //# sourceMappingURL=Daytona.js.map