@daytonaio/sdk 0.12.2-alpha.1 → 0.13.1

package/README.md

@@ -30,7 +30,7 @@ const daytona = new Daytona()
 const sandbox = await daytona.create()
 
 // Run code in the sandbox
-const response = await sandbox.process.codeRun('typescript', 'console.log("Hello World!")')
+const response = await sandbox.process.codeRun('console.log("Hello World!")')
 console.log(response.result)
 
 // Clean up when done
@@ -86,14 +86,11 @@ const response = await sandbox.process.executeCommand('echo "Hello, World!"')
 console.log(response.result)
 
 // Run TypeScript code
-const response = await sandbox.process.codeRun(
-  'typescript',
-  `
-  const x = 10
-  const y = 20
-  console.log(\`Sum: \${x + y}\`)
-  `
-)
+const response = await sandbox.process.codeRun(`
+const x = 10
+const y = 20
+console.log(\`Sum: \${x + y}\`)
+`)
 console.log(response.result)
 ```
 

package/dist/Daytona.d.ts

@@ -1,5 +1,5 @@
-import { Sandbox, Sandbox as Workspace } from './Sandbox';
 import { CreateWorkspaceTargetEnum as SandboxTargetRegion } from '@daytonaio/api-client';
+import { Sandbox, Sandbox as Workspace } from './Sandbox';
 /**
  * Configuration options for initializing the Daytona client.
  *
@@ -38,6 +38,14 @@ export interface DaytonaConfig {
     /** Target environment for sandboxes */
     target?: SandboxTargetRegion;
 }
+/**
+ * Supported programming languages for code execution
+ */
+export declare enum CodeLanguage {
+    PYTHON = "python",
+    TYPESCRIPT = "typescript",
+    JAVASCRIPT = "javascript"
+}
 /**
  * Resource allocation for a Sandbox.
  *
@@ -71,6 +79,7 @@ export interface SandboxResources {
  * @property {string} [id] - Optional Sandbox ID. If not provided, a random ID will be generated
  * @property {string} [image] - Optional Docker image to use for the Sandbox
  * @property {string} [user] - Optional os user to use for the Sandbox
+ * @property {CodeLanguage | string} [language] - Programming language for direct code execution
  * @property {Record<string, string>} [envVars] - Optional environment variables to set in the Sandbox
  * @property {Record<string, string>} [labels] - Sandbox labels
  * @property {boolean} [public] - Is the Sandbox port preview public
@@ -82,6 +91,7 @@ export interface SandboxResources {
  *
  * @example
  * const params: CreateSandboxParams = {
+ *     language: 'typescript',
  *     envVars: { NODE_ENV: 'development' },
  *     resources: {
  *         cpu: 2,
@@ -98,6 +108,8 @@ export type CreateSandboxParams = {
     image?: string;
     /** Optional os user to use for the Sandbox */
     user?: string;
+    /** Programming language for direct code execution */
+    language?: CodeLanguage | string;
     /** Optional environment variables to set in the sandbox */
     envVars?: Record<string, string>;
     /** Sandbox labels */
@@ -159,7 +171,7 @@ export declare class Daytona {
     constructor(config?: DaytonaConfig);
     /**
      * Creates Sandboxes with default or custom configurations. You can specify various parameters,
-     * including image, resources, environment variables, and volumes for the Sandbox.
+     * including language, image, resources, environment variables, and volumes for the Sandbox.
      *
      * @param {CreateSandboxParams} [params] - Parameters for Sandbox creation
      * @param {number} [timeout] - Timeout in seconds (0 means no timeout, default is 60)
@@ -172,6 +184,7 @@ export declare class Daytona {
      * @example
      * // Create a custom sandbox
      * const params: CreateSandboxParams = {
+     *     language: 'typescript',
      *     image: 'node:18',
      *     envVars: {
      *         NODE_ENV: 'development',
@@ -265,4 +278,13 @@ export declare class Daytona {
      * console.log(`Current sandbox state: ${sandbox.instance.state}`);
      */
     getCurrentSandbox(sandboxId: string): Promise<Sandbox>;
+    /**
+     * Gets the appropriate code toolbox based on language.
+     *
+     * @private
+     * @param {CodeLanguage} [language] - Programming language for the toolbox
+     * @returns {SandboxCodeToolbox} The appropriate code toolbox instance
+     * @throws {DaytonaError} - `DaytonaError` - When an unsupported language is specified
+     */
+    private getCodeToolbox;
 }

package/dist/Daytona.js

@@ -36,12 +36,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Daytona = void 0;
-const Sandbox_1 = require("./Sandbox");
+exports.Daytona = exports.CodeLanguage = void 0;
 const api_client_1 = require("@daytonaio/api-client");
 const axios_1 = __importStar(require("axios"));
-const DaytonaError_1 = require("./errors/DaytonaError");
 const dotenv_1 = __importDefault(require("dotenv"));
+const SandboxPythonCodeToolbox_1 = require("./code-toolbox/SandboxPythonCodeToolbox");
+const SandboxTsCodeToolbox_1 = require("./code-toolbox/SandboxTsCodeToolbox");
+const DaytonaError_1 = require("./errors/DaytonaError");
+const Sandbox_1 = require("./Sandbox");
+/**
+ * Supported programming languages for code execution
+ */
+var CodeLanguage;
+(function (CodeLanguage) {
+    CodeLanguage["PYTHON"] = "python";
+    CodeLanguage["TYPESCRIPT"] = "typescript";
+    CodeLanguage["JAVASCRIPT"] = "javascript";
+})(CodeLanguage || (exports.CodeLanguage = CodeLanguage = {}));
 /**
  * Main class for interacting with the Daytona API.
  *
@@ -77,7 +88,7 @@ class Daytona {
         var _a, _b, _c, _d, _e, _f, _g, _h;
         dotenv_1.default.config();
         dotenv_1.default.config({ path: '.env.local', override: true });
-        const apiKey = (config === null || config === void 0 ? void 0 : config.apiKey) || ((_a = process === null || process === void 0 ? void 0 : process.env) === null || _a === void 0 ? void 0 : _a.DAYTONA_API_KEY);
+        const apiKey = !(config === null || config === void 0 ? void 0 : config.apiKey) && (config === null || config === void 0 ? void 0 : config.jwtToken) ? undefined : (config === null || config === void 0 ? void 0 : config.apiKey) || ((_a = process === null || process === void 0 ? void 0 : process.env) === null || _a === void 0 ? void 0 : _a.DAYTONA_API_KEY);
         const jwtToken = (config === null || config === void 0 ? void 0 : config.jwtToken) || ((_b = process === null || process === void 0 ? void 0 : process.env) === null || _b === void 0 ? void 0 : _b.DAYTONA_JWT_TOKEN);
         const organizationId = (config === null || config === void 0 ? void 0 : config.organizationId) || ((_c = process === null || process === void 0 ? void 0 : process.env) === null || _c === void 0 ? void 0 : _c.DAYTONA_ORGANIZATION_ID);
         if (!apiKey && !jwtToken) {
@@ -127,6 +138,12 @@ class Daytona {
             else {
                 errorMessage = ((_b = (_a = error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.message) || ((_c = error.response) === null || _c === void 0 ? void 0 : _c.data) || error.message || String(error);
             }
+            try {
+                errorMessage = JSON.stringify(errorMessage);
+            }
+            catch (_d) {
+                errorMessage = String(errorMessage);
+            }
             throw new DaytonaError_1.DaytonaError(errorMessage);
         });
         this.sandboxApi = new api_client_1.WorkspaceApi(configuration, '', axiosInstance);
@@ -134,7 +151,7 @@ class Daytona {
     }
     /**
      * Creates Sandboxes with default or custom configurations. You can specify various parameters,
-     * including image, resources, environment variables, and volumes for the Sandbox.
+     * including language, image, resources, environment variables, and volumes for the Sandbox.
      *
      * @param {CreateSandboxParams} [params] - Parameters for Sandbox creation
      * @param {number} [timeout] - Timeout in seconds (0 means no timeout, default is 60)
@@ -147,6 +164,7 @@ class Daytona {
      * @example
      * // Create a custom sandbox
      * const params: CreateSandboxParams = {
+     *     language: 'typescript',
      *     image: 'node:18',
      *     envVars: {
      *         NODE_ENV: 'development',
@@ -164,7 +182,11 @@ class Daytona {
         // const startTime = Date.now();
         var _a, _b, _c, _d;
         if (params == null) {
-            params = {};
+            params = { language: 'python' };
+        }
+        const labels = params.labels || {};
+        if (params.language) {
+            labels['code-toolbox-language'] = params.language;
         }
         // remove this when params.timeout is removed
         const effectiveTimeout = params.timeout || timeout;
@@ -175,6 +197,7 @@ class Daytona {
             (!Number.isInteger(params.autoStopInterval) || params.autoStopInterval < 0)) {
             throw new DaytonaError_1.DaytonaError('autoStopInterval must be a non-negative integer');
         }
+        const codeToolbox = this.getCodeToolbox(params.language);
         try {
             const response = await this.sandboxApi.createWorkspace({
                 id: params.id,
@@ -196,7 +219,7 @@ class Daytona {
             const sandboxInstance = response.data;
             const sandboxInfo = Sandbox_1.Sandbox.toSandboxInfo(sandboxInstance);
             sandboxInstance.info = sandboxInfo;
-            const sandbox = new Sandbox_1.Sandbox(sandboxInstance.id, sandboxInstance, this.sandboxApi, this.toolboxApi);
+            const sandbox = new Sandbox_1.Sandbox(sandboxInstance.id, sandboxInstance, this.sandboxApi, this.toolboxApi, codeToolbox);
             // if (!params.async) {
             //   const timeElapsed = Date.now() - startTime;
             //   await sandbox.waitUntilStarted(effectiveTimeout ? effectiveTimeout - (timeElapsed / 1000) : 0);
@@ -224,9 +247,11 @@ class Daytona {
     async get(sandboxId) {
         const response = await this.sandboxApi.getWorkspace(sandboxId);
         const sandboxInstance = response.data;
+        const language = sandboxInstance.labels && sandboxInstance.labels['code-toolbox-language'];
+        const codeToolbox = this.getCodeToolbox(language);
         const sandboxInfo = Sandbox_1.Sandbox.toSandboxInfo(sandboxInstance);
         sandboxInstance.info = sandboxInfo;
-        return new Sandbox_1.Sandbox(sandboxId, sandboxInstance, this.sandboxApi, this.toolboxApi);
+        return new Sandbox_1.Sandbox(sandboxId, sandboxInstance, this.sandboxApi, this.toolboxApi, codeToolbox);
     }
     /**
      * Lists all Sandboxes.
@@ -242,9 +267,11 @@ class Daytona {
     async list() {
         const response = await this.sandboxApi.listWorkspaces();
         return response.data.map((sandbox) => {
+            var _a;
+            const language = (_a = sandbox.labels) === null || _a === void 0 ? void 0 : _a['code-toolbox-language'];
             const sandboxInfo = Sandbox_1.Sandbox.toSandboxInfo(sandbox);
             sandbox.info = sandboxInfo;
-            return new Sandbox_1.Sandbox(sandbox.id, sandbox, this.sandboxApi, this.toolboxApi);
+            return new Sandbox_1.Sandbox(sandbox.id, sandbox, this.sandboxApi, this.toolboxApi, this.getCodeToolbox(language));
         });
     }
     /**
@@ -313,5 +340,25 @@ class Daytona {
     async getCurrentSandbox(sandboxId) {
         return await this.get(sandboxId);
     }
+    /**
+     * Gets the appropriate code toolbox based on language.
+     *
+     * @private
+     * @param {CodeLanguage} [language] - Programming language for the toolbox
+     * @returns {SandboxCodeToolbox} The appropriate code toolbox instance
+     * @throws {DaytonaError} - `DaytonaError` - When an unsupported language is specified
+     */
+    getCodeToolbox(language) {
+        switch (language) {
+            case CodeLanguage.JAVASCRIPT:
+            case CodeLanguage.TYPESCRIPT:
+                return new SandboxTsCodeToolbox_1.SandboxTsCodeToolbox();
+            case CodeLanguage.PYTHON:
+            case undefined:
+                return new SandboxPythonCodeToolbox_1.SandboxPythonCodeToolbox();
+            default:
+                throw new DaytonaError_1.DaytonaError(`Unsupported language: ${language}, supported languages: ${Object.values(CodeLanguage).join(', ')}`);
+        }
+    }
 }
 exports.Daytona = Daytona;

package/dist/FileSystem.d.ts

@@ -23,6 +23,19 @@ export type FilePermissionsParams = {
     /** User owner of the file */
     owner?: string;
 };
+/**
+ * Represents a file to be uploaded to the Sandbox.
+ *
+ * @interface
+ * @property {string} path - Absolute destination path in the Sandbox
+ * @property {File} content - File to upload
+ */
+export interface FileUpload {
+    /** Absolute destination path in the Sandbox */
+    path: string;
+    /** File to upload */
+    content: File;
+}
 /**
  * Provides file system operations within a Sandbox.
  *
@@ -179,4 +192,30 @@ export declare class FileSystem {
      * await fs.uploadFile('/app/config.json', configFile);
      */
     uploadFile(path: string, file: File): Promise<void>;
+    /**
+     * Uploads multiple files to the Sandbox. The parent directories must exist.
+     * If files already exist at the destination paths, they will be overwritten.
+     *
+     * @param {FileUpload[]} files - Array of files to upload
+     * @returns {Promise<void>}
+     *
+     * @example
+     * // Upload multiple text files
+     * const files = [
+     *   {
+     *     path: '/app/data/file1.txt',
+     *     content: new File(['Content of file 1'], 'file1.txt')
+     *   },
+     *   {
+     *     path: '/app/data/file2.txt',
+     *     content: new File(['Content of file 2'], 'file2.txt')
+     *   },
+     *   {
+     *     path: '/app/config/settings.json',
+     *     content: new File(['{"key": "value"}'], 'settings.json')
+     *   }
+     * ];
+     * await fs.uploadFiles(files);
+     */
+    uploadFiles(files: FileUpload[]): Promise<void>;
 }

package/dist/FileSystem.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FileSystem = void 0;
+const DaytonaError_1 = require("./errors/DaytonaError");
 /**
  * Provides file system operations within a Sandbox.
  *
@@ -196,5 +197,43 @@ class FileSystem {
         const response = await this.toolboxApi.uploadFile(this.instance.id, path, undefined, file);
         return response.data;
     }
+    /**
+     * Uploads multiple files to the Sandbox. The parent directories must exist.
+     * If files already exist at the destination paths, they will be overwritten.
+     *
+     * @param {FileUpload[]} files - Array of files to upload
+     * @returns {Promise<void>}
+     *
+     * @example
+     * // Upload multiple text files
+     * const files = [
+     *   {
+     *     path: '/app/data/file1.txt',
+     *     content: new File(['Content of file 1'], 'file1.txt')
+     *   },
+     *   {
+     *     path: '/app/data/file2.txt',
+     *     content: new File(['Content of file 2'], 'file2.txt')
+     *   },
+     *   {
+     *     path: '/app/config/settings.json',
+     *     content: new File(['{"key": "value"}'], 'settings.json')
+     *   }
+     * ];
+     * await fs.uploadFiles(files);
+     */
+    async uploadFiles(files) {
+        const results = await Promise.allSettled(files.map((file) => this.uploadFile(file.path, file.content)));
+        const failedUploads = results
+            .map((result, index) => ({
+            path: files[index].path,
+            error: result.status === 'rejected' ? result.reason : undefined,
+        }))
+            .filter(({ error }) => error !== undefined);
+        if (failedUploads.length > 0) {
+            const errorMessage = failedUploads.map(({ path, error }) => `\nFailed to upload '${path}': ${error}`).join('');
+            throw new DaytonaError_1.DaytonaError(errorMessage);
+        }
+    }
 }
 exports.FileSystem = FileSystem;

package/dist/Process.d.ts

@@ -1,5 +1,5 @@
 import { Command, Session, SessionExecuteRequest, SessionExecuteResponse, ToolboxApi } from '@daytonaio/api-client';
-import { SandboxInstance } from './Sandbox';
+import { SandboxCodeToolbox, SandboxInstance } from './Sandbox';
 import { ExecuteResponse } from './types/ExecuteResponse';
 /**
  * Parameters for code execution.
@@ -14,28 +14,22 @@ export declare class CodeRunParams {
      */
     env?: Record<string, string>;
 }
-/**
- * Supported programming languages for code execution
- */
-export declare enum CodeLanguage {
-    PYTHON = "python",
-    TYPESCRIPT = "typescript",
-    JAVASCRIPT = "javascript"
-}
 /**
  * Handles process and code execution within a Sandbox.
  *
  * @class
  */
 export declare class Process {
+    private readonly codeToolbox;
     private readonly toolboxApi;
     private readonly instance;
-    constructor(toolboxApi: ToolboxApi, instance: SandboxInstance);
+    constructor(codeToolbox: SandboxCodeToolbox, toolboxApi: ToolboxApi, instance: SandboxInstance);
     /**
      * Executes a shell command in the Sandbox.
      *
      * @param {string} command - Shell command to execute
      * @param {string} [cwd] - Working directory for command execution. If not specified, uses the Sandbox root directory
+     * @param {Record<string, string>} [env] - Environment variables to set for the command
      * @param {number} [timeout] - Maximum time in seconds to wait for the command to complete. 0 means wait indefinitely.
      * @returns {Promise<ExecuteResponse>} Command execution results containing:
      *                                    - exitCode: The command's exit status
@@ -55,11 +49,10 @@ export declare class Process {
      * // Command with timeout
      * const result = await process.executeCommand('sleep 10', undefined, 5);
      */
-    executeCommand(command: string, cwd?: string, timeout?: number): Promise<ExecuteResponse>;
+    executeCommand(command: string, cwd?: string, env?: Record<string, string>, timeout?: number): Promise<ExecuteResponse>;
     /**
      * Executes code in the Sandbox using the appropriate language runtime.
      *
-     * @param {"python" | "typescript" | "javascript"} language - Programming language for the code.
      * @param {string} code - Code to execute
      * @param {CodeRunParams} params - Parameters for code execution
      * @param {number} [timeout] - Maximum time in seconds to wait for execution to complete
@@ -70,21 +63,16 @@ export declare class Process {
      *
      * @example
      * // Run TypeScript code
-     * const response = await sandbox.process.codeRun(
-     *   'typescript',
-     *   `
-     *     const x = 10;
-     *     const y = 20;
-     *     console.log(\`Sum: \${x + y}\`);
-     *   `
-     *  );
+     * const response = await process.codeRun(`
+     *   const x = 10;
+     *   const y = 20;
+     *   console.log(\`Sum: \${x + y}\`);
+     * `);
      * console.log(response.artifacts.stdout);  // Prints: Sum: 30
      *
      * @example
      * // Run Python code with matplotlib
-     * const response = await sandbox.process.codeRun(
-     *   'python',
-     *   `
+     * const response = await process.codeRun(`
      * import matplotlib.pyplot as plt
      * import numpy as np
      *
@@ -98,8 +86,7 @@ export declare class Process {
      * plt.ylabel('Y-axis (amplitude)')
      * plt.grid(True)
      * plt.show()
-     * `
-     * );
+     * `);
      *
      * if (response.artifacts?.charts) {
      *   const chart = response.artifacts.charts[0];
@@ -121,7 +108,7 @@ export declare class Process {
      *   }
      * }
      */
-    codeRun(language: 'python' | 'typescript' | 'javascript', code: string, params?: CodeRunParams, timeout?: number): Promise<ExecuteResponse>;
+    codeRun(code: string, params?: CodeRunParams, timeout?: number): Promise<ExecuteResponse>;
     /**
      * Creates a new long-running background session in the Sandbox.
      *
@@ -254,15 +241,4 @@ export declare class Process {
      * await process.deleteSession('my-session');
      */
     deleteSession(sessionId: string): Promise<void>;
-    /**
-     * Gets the appropriate code toolbox based on language.
-     *
-     * @private
-     * @param {CodeLanguage} [language] - Programming language for the toolbox
-     * @param {string} code - Code to execute
-     * @param {CodeRunParams} [params] - Parameters for code execution
-     * @returns {string} The appropriate code run command
-     * @throws {DaytonaError} - `DaytonaError` - When an unsupported language is specified
-     */
-    private getCodeRunCommand;
 }

package/dist/Process.js

@@ -1,32 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Process = exports.CodeLanguage = exports.CodeRunParams = void 0;
+exports.Process = exports.CodeRunParams = void 0;
 const ArtifactParser_1 = require("./utils/ArtifactParser");
-const SandboxPythonCodeToolbox_1 = require("./code-toolbox/SandboxPythonCodeToolbox");
-const DaytonaError_1 = require("./errors/DaytonaError");
-const SandboxTsCodeToolbox_1 = require("./code-toolbox/SandboxTsCodeToolbox");
 /**
  * Parameters for code execution.
  */
 class CodeRunParams {
 }
 exports.CodeRunParams = CodeRunParams;
-/**
- * Supported programming languages for code execution
- */
-var CodeLanguage;
-(function (CodeLanguage) {
-    CodeLanguage["PYTHON"] = "python";
-    CodeLanguage["TYPESCRIPT"] = "typescript";
-    CodeLanguage["JAVASCRIPT"] = "javascript";
-})(CodeLanguage || (exports.CodeLanguage = CodeLanguage = {}));
 /**
  * Handles process and code execution within a Sandbox.
  *
  * @class
  */
 class Process {
-    constructor(toolboxApi, instance) {
+    constructor(codeToolbox, toolboxApi, instance) {
+        this.codeToolbox = codeToolbox;
         this.toolboxApi = toolboxApi;
         this.instance = instance;
     }
@@ -35,6 +24,7 @@ class Process {
      *
      * @param {string} command - Shell command to execute
      * @param {string} [cwd] - Working directory for command execution. If not specified, uses the Sandbox root directory
+     * @param {Record<string, string>} [env] - Environment variables to set for the command
      * @param {number} [timeout] - Maximum time in seconds to wait for the command to complete. 0 means wait indefinitely.
      * @returns {Promise<ExecuteResponse>} Command execution results containing:
      *                                    - exitCode: The command's exit status
@@ -54,7 +44,16 @@ class Process {
      * // Command with timeout
      * const result = await process.executeCommand('sleep 10', undefined, 5);
      */
-    async executeCommand(command, cwd, timeout) {
+    async executeCommand(command, cwd, env, timeout) {
+        const envVars = env
+            ? Object.entries(env)
+                .map(([key, value]) => `${key}=${value}`)
+                .join(' ')
+            : undefined;
+        if (envVars) {
+            const base64Cmd = Buffer.from(command).toString('base64');
+            command = `sh -c '${envVars} sh -c "echo '${base64Cmd}' | base64 -d | sh"'`;
+        }
         const response = await this.toolboxApi.executeCommand(this.instance.id, {
             command,
             timeout,
@@ -73,7 +72,6 @@ class Process {
     /**
      * Executes code in the Sandbox using the appropriate language runtime.
      *
-     * @param {"python" | "typescript" | "javascript"} language - Programming language for the code.
      * @param {string} code - Code to execute
      * @param {CodeRunParams} params - Parameters for code execution
      * @param {number} [timeout] - Maximum time in seconds to wait for execution to complete
@@ -84,21 +82,16 @@ class Process {
      *
      * @example
      * // Run TypeScript code
-     * const response = await sandbox.process.codeRun(
-     *   'typescript',
-     *   `
-     *     const x = 10;
-     *     const y = 20;
-     *     console.log(\`Sum: \${x + y}\`);
-     *   `
-     *  );
+     * const response = await process.codeRun(`
+     *   const x = 10;
+     *   const y = 20;
+     *   console.log(\`Sum: \${x + y}\`);
+     * `);
      * console.log(response.artifacts.stdout);  // Prints: Sum: 30
      *
      * @example
      * // Run Python code with matplotlib
-     * const response = await sandbox.process.codeRun(
-     *   'python',
-     *   `
+     * const response = await process.codeRun(`
      * import matplotlib.pyplot as plt
      * import numpy as np
      *
@@ -112,8 +105,7 @@ class Process {
      * plt.ylabel('Y-axis (amplitude)')
      * plt.grid(True)
      * plt.show()
-     * `
-     * );
+     * `);
      *
      * if (response.artifacts?.charts) {
      *   const chart = response.artifacts.charts[0];
@@ -135,9 +127,9 @@ class Process {
      *   }
      * }
      */
-    async codeRun(language, code, params, timeout) {
-        const runCommand = this.getCodeRunCommand(language, code, params);
-        return this.executeCommand(runCommand, undefined, timeout);
+    async codeRun(code, params, timeout) {
+        const runCommand = this.codeToolbox.getRunCommand(code, params);
+        return this.executeCommand(runCommand, undefined, undefined, timeout);
     }
     /**
      * Creates a new long-running background session in the Sandbox.
@@ -296,26 +288,5 @@ class Process {
     async deleteSession(sessionId) {
         await this.toolboxApi.deleteSession(this.instance.id, sessionId);
     }
-    /**
-     * Gets the appropriate code toolbox based on language.
-     *
-     * @private
-     * @param {CodeLanguage} [language] - Programming language for the toolbox
-     * @param {string} code - Code to execute
-     * @param {CodeRunParams} [params] - Parameters for code execution
-     * @returns {string} The appropriate code run command
-     * @throws {DaytonaError} - `DaytonaError` - When an unsupported language is specified
-     */
-    getCodeRunCommand(language, code, params) {
-        switch (language) {
-            case CodeLanguage.JAVASCRIPT:
-            case CodeLanguage.TYPESCRIPT:
-                return SandboxTsCodeToolbox_1.SandboxTsCodeToolbox.getRunCommand(code, params);
-            case CodeLanguage.PYTHON:
-                return SandboxPythonCodeToolbox_1.SandboxPythonCodeToolbox.getRunCommand(code, params);
-            default:
-                throw new DaytonaError_1.DaytonaError(`Unsupported language: ${language}, supported languages: ${Object.values(CodeLanguage).join(', ')}`);
-        }
-    }
 }
 exports.Process = Process;

package/dist/Sandbox.d.ts

@@ -1,7 +1,7 @@
 import { ToolboxApi, WorkspaceState as SandboxState, WorkspaceApi as SandboxApi, Workspace as ApiSandbox, WorkspaceInfo as ApiSandboxInfo, CreateNodeClassEnum as SandboxClass, CreateNodeRegionEnum as SandboxTargetRegion, Workspace as ApiWorkspace } from '@daytonaio/api-client';
 import { FileSystem } from './FileSystem';
 import { Git } from './Git';
-import { Process } from './Process';
+import { CodeRunParams, Process } from './Process';
 import { LspLanguageId, LspServer } from './LspServer';
 /** @deprecated Use SandboxInfo instead. This type will be removed in a future version. */
 type WorkspaceInfo = SandboxInfo;
@@ -112,6 +112,14 @@ export interface SandboxInfo extends ApiSandboxInfo {
      */
     providerMetadata?: string;
 }
+/**
+ * Interface defining methods that a code toolbox must implement
+ * @interface
+ */
+export interface SandboxCodeToolbox {
+    /** Generates a command to run the provided code */
+    getRunCommand(code: string, params?: CodeRunParams): string;
+}
 /**
  * Represents a Daytona Sandbox.
  *
@@ -119,6 +127,7 @@ export interface SandboxInfo extends ApiSandboxInfo {
  * @property {SandboxInstance} instance - The underlying Sandbox instance
  * @property {SandboxApi} sandboxApi - API client for Sandbox operations
  * @property {ToolboxApi} toolboxApi - API client for toolbox operations
+ * @property {SandboxCodeToolbox} codeToolbox - Language-specific toolbox implementation
  * @property {FileSystem} fs - File system operations interface
  * @property {Git} git - Git operations interface
  * @property {Process} process - Process execution interface
@@ -130,6 +139,7 @@ export declare class Sandbox {
     readonly instance: SandboxInstance;
     readonly sandboxApi: SandboxApi;
     readonly toolboxApi: ToolboxApi;
+    private readonly codeToolbox;
     /** File system operations for the Sandbox */
     readonly fs: FileSystem;
     /** Git operations for the Sandbox */
@@ -143,8 +153,9 @@ export declare class Sandbox {
      * @param {SandboxInstance} instance - The underlying Sandbox instance
      * @param {SandboxApi} sandboxApi - API client for Sandbox operations
      * @param {ToolboxApi} toolboxApi - API client for toolbox operations
+     * @param {SandboxCodeToolbox} codeToolbox - Language-specific toolbox implementation
      */
-    constructor(id: string, instance: SandboxInstance, sandboxApi: SandboxApi, toolboxApi: ToolboxApi);
+    constructor(id: string, instance: SandboxInstance, sandboxApi: SandboxApi, toolboxApi: ToolboxApi, codeToolbox: SandboxCodeToolbox);
     /**
      * Gets the root directory path for the logged in user inside the Sandbox.
      *

package/dist/Sandbox.js

@@ -14,6 +14,7 @@ const DaytonaError_1 = require("./errors/DaytonaError");
  * @property {SandboxInstance} instance - The underlying Sandbox instance
  * @property {SandboxApi} sandboxApi - API client for Sandbox operations
  * @property {ToolboxApi} toolboxApi - API client for toolbox operations
+ * @property {SandboxCodeToolbox} codeToolbox - Language-specific toolbox implementation
  * @property {FileSystem} fs - File system operations interface
  * @property {Git} git - Git operations interface
  * @property {Process} process - Process execution interface
@@ -28,15 +29,17 @@ class Sandbox {
      * @param {SandboxInstance} instance - The underlying Sandbox instance
      * @param {SandboxApi} sandboxApi - API client for Sandbox operations
      * @param {ToolboxApi} toolboxApi - API client for toolbox operations
+     * @param {SandboxCodeToolbox} codeToolbox - Language-specific toolbox implementation
      */
-    constructor(id, instance, sandboxApi, toolboxApi) {
+    constructor(id, instance, sandboxApi, toolboxApi, codeToolbox) {
         this.id = id;
         this.instance = instance;
         this.sandboxApi = sandboxApi;
         this.toolboxApi = toolboxApi;
+        this.codeToolbox = codeToolbox;
         this.fs = new FileSystem_1.FileSystem(instance, this.toolboxApi);
         this.git = new Git_1.Git(this, this.toolboxApi, instance);
-        this.process = new Process_1.Process(this.toolboxApi, instance);
+        this.process = new Process_1.Process(this.codeToolbox, this.toolboxApi, instance);
     }
     /**
      * Gets the root directory path for the logged in user inside the Sandbox.

package/dist/code-toolbox/SandboxPythonCodeToolbox.d.ts

@@ -1,6 +1,8 @@
+import { SandboxCodeToolbox } from '../Sandbox';
 import { CodeRunParams } from '../Process';
-export declare class SandboxPythonCodeToolbox {
-    static getRunCommand(code: string, params?: CodeRunParams): string;
+export declare class SandboxPythonCodeToolbox implements SandboxCodeToolbox {
+    getDefaultImage(): string;
+    getRunCommand(code: string, params?: CodeRunParams): string;
     /**
      * Checks if matplotlib is imported in the given Python code string.
      * @param codeString Python code as a string

package/dist/code-toolbox/SandboxPythonCodeToolbox.js

@@ -2,7 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SandboxPythonCodeToolbox = void 0;
 class SandboxPythonCodeToolbox {
-    static getRunCommand(code, params) {
+    getDefaultImage() {
+        return 'daytonaio/sdk-python:v0.49.0-2';
+    }
+    getRunCommand(code, params) {
         // Encode the provided code in base64
         let base64Code = Buffer.from(code).toString('base64');
         // Override plt.show() method if matplotlib is imported

package/dist/code-toolbox/SandboxTsCodeToolbox.d.ts

@@ -1,4 +1,6 @@
+import { SandboxCodeToolbox } from '../Sandbox';
 import { CodeRunParams } from '../Process';
-export declare class SandboxTsCodeToolbox {
-    static getRunCommand(code: string, params?: CodeRunParams): string;
+export declare class SandboxTsCodeToolbox implements SandboxCodeToolbox {
+    getDefaultImage(): string;
+    getRunCommand(code: string, params?: CodeRunParams): string;
 }

package/dist/code-toolbox/SandboxTsCodeToolbox.js

@@ -2,7 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SandboxTsCodeToolbox = void 0;
 class SandboxTsCodeToolbox {
-    static getRunCommand(code, params) {
+    getDefaultImage() {
+        return 'daytonaio/sdk-typescript:v0.49.0-3';
+    }
+    getRunCommand(code, params) {
         const base64Code = Buffer.from(code).toString('base64');
         const envVars = (params === null || params === void 0 ? void 0 : params.env)
             ? Object.entries(params.env)

package/dist/index.d.ts

@@ -1,17 +1,19 @@
-export { Daytona } from './Daytona';
+export { CodeLanguage, Daytona } from './Daytona';
 export type { CreateSandboxParams, DaytonaConfig, SandboxResources } from './Daytona';
 export { FileSystem } from './FileSystem';
 export { Git } from './Git';
 export { LspLanguageId } from './LspServer';
-export { Process, CodeLanguage } from './Process';
+export { Process } from './Process';
 export { DaytonaError } from './errors/DaytonaError';
 export { Sandbox } from './Sandbox';
+export type { SandboxCodeToolbox } from './Sandbox';
 export { ChartType } from './types/Charts';
 export type { BarChart, BoxAndWhiskerChart, Chart, CompositeChart, LineChart, PieChart, ScatterChart, } from './types/Charts';
 export { WorkspaceState as SandboxState, CreateWorkspaceTargetEnum as SandboxTargetRegion } from '@daytonaio/api-client';
 export type { FileInfo, GitStatus, ListBranchResponse, Match, ReplaceResult, SearchFilesResponse, } from '@daytonaio/api-client';
 import { CreateWorkspaceTargetEnum, WorkspaceState as WS } from '@daytonaio/api-client';
 import type { CreateSandboxParams, SandboxResources } from './Daytona';
+import type { SandboxCodeToolbox } from './Sandbox';
 import { Sandbox } from './Sandbox';
 /** @deprecated `CreateWorkspaceParams` is deprecated. Please use `CreateSandboxParams` instead. This will be removed in a future version. */
 export type CreateWorkspaceParams = CreateSandboxParams;
@@ -19,6 +21,8 @@ export type CreateWorkspaceParams = CreateSandboxParams;
 export declare const Workspace: typeof Sandbox;
 /** @deprecated `Workspace` is deprecated. Please use `Sandbox` instead. This will be removed in a future version. */
 export type Workspace = Sandbox;
+/** @deprecated `WorkspaceCodeToolbox` is deprecated. Please use `SandboxCodeToolbox` instead. This will be removed in a future version. */
+export type WorkspaceCodeToolbox = SandboxCodeToolbox;
 /** @deprecated `WorkspaceResources` is deprecated. Please use `SandboxResources` instead. This will be removed in a future version. */
 export type WorkspaceResources = SandboxResources;
 /** @deprecated `WorkspaceState` is deprecated. Please use `SandboxState` instead. This will be removed in a future version. */

package/dist/index.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkspaceTargetRegion = exports.WorkspaceState = exports.Workspace = exports.SandboxTargetRegion = exports.SandboxState = exports.ChartType = exports.Sandbox = exports.DaytonaError = exports.CodeLanguage = exports.Process = exports.LspLanguageId = exports.Git = exports.FileSystem = exports.Daytona = void 0;
+exports.WorkspaceTargetRegion = exports.WorkspaceState = exports.Workspace = exports.SandboxTargetRegion = exports.SandboxState = exports.ChartType = exports.Sandbox = exports.DaytonaError = exports.Process = exports.LspLanguageId = exports.Git = exports.FileSystem = exports.Daytona = exports.CodeLanguage = void 0;
 var Daytona_1 = require("./Daytona");
+Object.defineProperty(exports, "CodeLanguage", { enumerable: true, get: function () { return Daytona_1.CodeLanguage; } });
 Object.defineProperty(exports, "Daytona", { enumerable: true, get: function () { return Daytona_1.Daytona; } });
 var FileSystem_1 = require("./FileSystem");
 Object.defineProperty(exports, "FileSystem", { enumerable: true, get: function () { return FileSystem_1.FileSystem; } });
@@ -11,7 +12,6 @@ var LspServer_1 = require("./LspServer");
 Object.defineProperty(exports, "LspLanguageId", { enumerable: true, get: function () { return LspServer_1.LspLanguageId; } });
 var Process_1 = require("./Process");
 Object.defineProperty(exports, "Process", { enumerable: true, get: function () { return Process_1.Process; } });
-Object.defineProperty(exports, "CodeLanguage", { enumerable: true, get: function () { return Process_1.CodeLanguage; } });
 // export { LspServer } from './LspServer'
 // export type { LspLanguageId, Position } from './LspServer'
 var DaytonaError_1 = require("./errors/DaytonaError");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daytonaio/sdk",
-  "version": "0.12.2-alpha.1",
+  "version": "0.13.1",
   "description": "Daytona client library for AI Agents",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",