@inkeep/agents-run-api 0.39.4 → 0.40.0

package/dist/tools/NativeSandboxExecutor.js

@@ -0,0 +1,432 @@
+import { getLogger } from "../logger.js";
+import { FUNCTION_TOOL_EXECUTION_TIMEOUT_MS_DEFAULT, FUNCTION_TOOL_SANDBOX_CLEANUP_INTERVAL_MS, FUNCTION_TOOL_SANDBOX_MAX_OUTPUT_SIZE_BYTES, FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT, FUNCTION_TOOL_SANDBOX_POOL_TTL_MS, FUNCTION_TOOL_SANDBOX_QUEUE_WAIT_TIMEOUT_MS } from "../constants/execution-limits/index.js";
+import { createExecutionWrapper, parseExecutionResult } from "./sandbox-utils.js";
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+//#region src/tools/NativeSandboxExecutor.ts
+/**
+* NativeSandboxExecutor - Function Tool Execution Engine
+* ========================================================
+*
+* Executes user-defined function tools in isolated sandboxes using native Node.js processes.
+* The main challenge here is that we can't just eval() user code - that's a security nightmare.
+* Instead, we spin up separate Node.js processes with their own dependency trees.
+*
+* The tricky part is making this fast. Installing deps every time would be brutal
+* (2-5s per execution), so we cache sandboxes based on their dependency fingerprint.
+*
+* How it works:
+*
+* 1. User calls a function tool
+* 2. We hash the dependencies (e.g., "axios@1.6.0,lodash@4.17.21")
+* 3. Check if we already have a sandbox with those deps installed
+* 4. If yes: reuse it. If no: create new one, install deps, cache it
+* 5. Write the user's function code to a temp file
+* 6. Execute it in the sandboxed process with resource limits
+* 7. Return the result
+*
+* Sandbox lifecycle:
+* - Created when first needed for a dependency set
+* - Reused up to 50 times or 5 minutes, whichever comes first
+* - Automatically cleaned up when expired
+* - Failed sandboxes are immediately destroyed
+*
+* Security stuff:
+* - Each execution runs in its own process (not just a function call)
+* - Output limited to 1MB to prevent memory bombs
+* - Timeouts with graceful SIGTERM, then SIGKILL if needed
+* - Runs as non-root when possible
+* - Uses OS temp directory so it gets cleaned up automatically
+*
+* Performance:
+* - Cold start: ~100-500ms (vs 2-5s without caching)
+* - Hot path: ~50-100ms (just execution, no install)
+* - Memory bounded by pool size limits
+*
+* Deployment notes:
+* - Uses /tmp on Linux/macOS, %TEMP% on Windows
+* - Works in Docker, Kubernetes, serverless (Vercel, Lambda)
+* - No files left in project directory (no git pollution)
+*
+* The singleton pattern here is important - we need one shared pool
+* across all tool executions, otherwise caching doesn't work.
+*/
+const logger = getLogger("native-sandbox-executor");
+/**
+* Semaphore for limiting concurrent executions based on vCPU allocation
+*/
+var ExecutionSemaphore = class {
+	permits;
+	waitQueue = [];
+	maxWaitTime;
+	constructor(permits, maxWaitTimeMs = FUNCTION_TOOL_SANDBOX_QUEUE_WAIT_TIMEOUT_MS) {
+		this.permits = Math.max(1, permits);
+		this.maxWaitTime = maxWaitTimeMs;
+	}
+	async acquire(fn) {
+		await new Promise((resolve, reject) => {
+			if (this.permits > 0) {
+				this.permits--;
+				resolve();
+				return;
+			}
+			const timeoutId = setTimeout(() => {
+				const index = this.waitQueue.findIndex((item) => item.resolve === resolve);
+				if (index !== -1) {
+					this.waitQueue.splice(index, 1);
+					reject(/* @__PURE__ */ new Error(`Function execution queue timeout after ${this.maxWaitTime}ms. Too many concurrent executions.`));
+				}
+			}, this.maxWaitTime);
+			this.waitQueue.push({
+				resolve: () => {
+					clearTimeout(timeoutId);
+					this.permits--;
+					resolve();
+				},
+				reject
+			});
+		});
+		try {
+			return await fn();
+		} finally {
+			this.permits++;
+			const next = this.waitQueue.shift();
+			if (next) next.resolve();
+		}
+	}
+	getAvailablePermits() {
+		return this.permits;
+	}
+	getQueueLength() {
+		return this.waitQueue.length;
+	}
+};
+var NativeSandboxExecutor = class NativeSandboxExecutor {
+	tempDir;
+	sandboxPool = {};
+	static instance = null;
+	executionSemaphores = /* @__PURE__ */ new Map();
+	constructor() {
+		this.tempDir = join(tmpdir(), "inkeep-sandboxes");
+		this.ensureTempDir();
+		this.startPoolCleanup();
+	}
+	static getInstance() {
+		if (!NativeSandboxExecutor.instance) NativeSandboxExecutor.instance = new NativeSandboxExecutor();
+		return NativeSandboxExecutor.instance;
+	}
+	getSemaphore(vcpus) {
+		const effectiveVcpus = Math.max(1, vcpus || 1);
+		if (!this.executionSemaphores.has(effectiveVcpus)) {
+			logger.debug({ vcpus: effectiveVcpus }, "Creating new execution semaphore");
+			this.executionSemaphores.set(effectiveVcpus, new ExecutionSemaphore(effectiveVcpus));
+		}
+		const semaphore = this.executionSemaphores.get(effectiveVcpus);
+		if (!semaphore) throw new Error(`Failed to create semaphore for ${effectiveVcpus} vCPUs`);
+		return semaphore;
+	}
+	getExecutionStats() {
+		const stats = {};
+		for (const [vcpus, semaphore] of this.executionSemaphores.entries()) stats[`vcpu_${vcpus}`] = {
+			availablePermits: semaphore.getAvailablePermits(),
+			queueLength: semaphore.getQueueLength()
+		};
+		return stats;
+	}
+	ensureTempDir() {
+		try {
+			mkdirSync(this.tempDir, { recursive: true });
+		} catch {}
+	}
+	generateDependencyHash(dependencies) {
+		const sortedDeps = Object.keys(dependencies).sort().map((key) => `${key}@${dependencies[key]}`).join(",");
+		return createHash("sha256").update(sortedDeps).digest("hex").substring(0, 16);
+	}
+	getCachedSandbox(dependencyHash) {
+		const poolKey = dependencyHash;
+		const sandbox = this.sandboxPool[poolKey];
+		if (sandbox && existsSync(sandbox.sandboxDir)) {
+			const now = Date.now();
+			if (now - sandbox.lastUsed < FUNCTION_TOOL_SANDBOX_POOL_TTL_MS && sandbox.useCount < FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT) {
+				sandbox.lastUsed = now;
+				sandbox.useCount++;
+				logger.debug({
+					poolKey,
+					useCount: sandbox.useCount,
+					sandboxDir: sandbox.sandboxDir,
+					lastUsed: new Date(sandbox.lastUsed)
+				}, "Reusing cached sandbox");
+				return sandbox.sandboxDir;
+			}
+			this.cleanupSandbox(sandbox.sandboxDir);
+			delete this.sandboxPool[poolKey];
+		}
+		return null;
+	}
+	addToPool(dependencyHash, sandboxDir, dependencies) {
+		const poolKey = dependencyHash;
+		if (this.sandboxPool[poolKey]) this.cleanupSandbox(this.sandboxPool[poolKey].sandboxDir);
+		this.sandboxPool[poolKey] = {
+			sandboxDir,
+			lastUsed: Date.now(),
+			useCount: 1,
+			dependencies
+		};
+		logger.debug({
+			poolKey,
+			sandboxDir
+		}, "Added sandbox to pool");
+	}
+	cleanupSandbox(sandboxDir) {
+		try {
+			rmSync(sandboxDir, {
+				recursive: true,
+				force: true
+			});
+			logger.debug({ sandboxDir }, "Cleaned up sandbox");
+		} catch (error) {
+			logger.warn({
+				sandboxDir,
+				error
+			}, "Failed to clean up sandbox");
+		}
+	}
+	startPoolCleanup() {
+		setInterval(() => {
+			const now = Date.now();
+			const keysToDelete = [];
+			for (const [key, sandbox] of Object.entries(this.sandboxPool)) if (now - sandbox.lastUsed > FUNCTION_TOOL_SANDBOX_POOL_TTL_MS || sandbox.useCount >= FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT) {
+				this.cleanupSandbox(sandbox.sandboxDir);
+				keysToDelete.push(key);
+			}
+			keysToDelete.forEach((key) => {
+				delete this.sandboxPool[key];
+			});
+			if (keysToDelete.length > 0) logger.debug({ cleanedCount: keysToDelete.length }, "Cleaned up expired sandboxes");
+		}, FUNCTION_TOOL_SANDBOX_CLEANUP_INTERVAL_MS);
+	}
+	detectModuleType(executeCode, configuredRuntime) {
+		const esmPatterns = [
+			/import\s+.*\s+from\s+['"]/g,
+			/import\s*\(/g,
+			/export\s+(default|const|let|var|function|class)/g,
+			/export\s*\{/g
+		];
+		const cjsPatterns = [
+			/require\s*\(/g,
+			/module\.exports/g,
+			/exports\./g
+		];
+		const hasEsmSyntax = esmPatterns.some((pattern) => pattern.test(executeCode));
+		const hasCjsSyntax = cjsPatterns.some((pattern) => pattern.test(executeCode));
+		if (configuredRuntime === "typescript") return hasCjsSyntax ? "cjs" : "esm";
+		if (hasEsmSyntax && hasCjsSyntax) {
+			logger.warn({ executeCode: `${executeCode.substring(0, 100)}...` }, "Both ESM and CommonJS syntax detected, defaulting to ESM");
+			return "esm";
+		}
+		if (hasEsmSyntax) return "esm";
+		if (hasCjsSyntax) return "cjs";
+		return "cjs";
+	}
+	async executeFunctionTool(toolId, args, config) {
+		const vcpus = config.sandboxConfig?.vcpus || 1;
+		const semaphore = this.getSemaphore(vcpus);
+		logger.debug({
+			toolId,
+			vcpus,
+			availablePermits: semaphore.getAvailablePermits(),
+			queueLength: semaphore.getQueueLength(),
+			sandboxConfig: config.sandboxConfig,
+			poolSize: Object.keys(this.sandboxPool).length
+		}, "Acquiring execution slot for function tool");
+		return semaphore.acquire(async () => {
+			return this.executeInSandbox_Internal(toolId, args, config);
+		});
+	}
+	async executeInSandbox_Internal(toolId, args, config) {
+		const dependencies = config.dependencies || {};
+		const dependencyHash = this.generateDependencyHash(dependencies);
+		logger.debug({
+			toolId,
+			dependencies,
+			dependencyHash,
+			sandboxConfig: config.sandboxConfig,
+			poolSize: Object.keys(this.sandboxPool).length
+		}, "Executing function tool");
+		let sandboxDir = this.getCachedSandbox(dependencyHash);
+		let isNewSandbox = false;
+		if (!sandboxDir) {
+			sandboxDir = join(this.tempDir, `sandbox-${dependencyHash}-${Date.now()}`);
+			mkdirSync(sandboxDir, { recursive: true });
+			isNewSandbox = true;
+			logger.debug({
+				toolId,
+				dependencyHash,
+				sandboxDir,
+				dependencies
+			}, "Creating new sandbox");
+			const moduleType = this.detectModuleType(config.executeCode, config.sandboxConfig?.runtime);
+			const packageJson = {
+				name: `function-tool-${toolId}`,
+				version: "1.0.0",
+				...moduleType === "esm" && { type: "module" },
+				dependencies,
+				scripts: { start: moduleType === "esm" ? "node index.mjs" : "node index.js" }
+			};
+			writeFileSync(join(sandboxDir, "package.json"), JSON.stringify(packageJson, null, 2), "utf8");
+			if (Object.keys(dependencies).length > 0) await this.installDependencies(sandboxDir);
+			this.addToPool(dependencyHash, sandboxDir, dependencies);
+		}
+		try {
+			const moduleType = this.detectModuleType(config.executeCode, config.sandboxConfig?.runtime);
+			const executionCode = createExecutionWrapper(config.executeCode, args);
+			writeFileSync(join(sandboxDir, `index.${moduleType === "esm" ? "mjs" : "js"}`), executionCode, "utf8");
+			return await this.executeInSandbox(sandboxDir, config.sandboxConfig?.timeout || FUNCTION_TOOL_EXECUTION_TIMEOUT_MS_DEFAULT, moduleType, config.sandboxConfig);
+		} catch (error) {
+			if (isNewSandbox) {
+				this.cleanupSandbox(sandboxDir);
+				const poolKey = dependencyHash;
+				delete this.sandboxPool[poolKey];
+			}
+			throw error;
+		}
+	}
+	async installDependencies(sandboxDir) {
+		return new Promise((resolve, reject) => {
+			const npm = spawn("npm", [
+				"install",
+				"--no-audit",
+				"--no-fund"
+			], {
+				cwd: sandboxDir,
+				stdio: "pipe",
+				env: {
+					...process.env,
+					npm_config_cache: join(sandboxDir, ".npm-cache"),
+					npm_config_logs_dir: join(sandboxDir, ".npm-logs"),
+					npm_config_tmp: join(sandboxDir, ".npm-tmp"),
+					HOME: sandboxDir,
+					npm_config_update_notifier: "false",
+					npm_config_progress: "false",
+					npm_config_loglevel: "error"
+				}
+			});
+			let stderr = "";
+			npm.stdout?.on("data", () => {});
+			npm.stderr?.on("data", (data) => {
+				stderr += data.toString();
+			});
+			npm.on("close", (code) => {
+				if (code === 0) {
+					logger.debug({ sandboxDir }, "Dependencies installed successfully");
+					resolve();
+				} else {
+					logger.error({
+						sandboxDir,
+						code,
+						stderr
+					}, "Failed to install dependencies");
+					reject(/* @__PURE__ */ new Error(`npm install failed with code ${code}: ${stderr}`));
+				}
+			});
+			npm.on("error", (err) => {
+				logger.error({
+					sandboxDir,
+					error: err
+				}, "Failed to spawn npm install");
+				reject(err);
+			});
+		});
+	}
+	async executeInSandbox(sandboxDir, timeout, moduleType, _sandboxConfig) {
+		return new Promise((resolve, reject) => {
+			const fileExtension = moduleType === "esm" ? "mjs" : "js";
+			const spawnOptions = {
+				cwd: sandboxDir,
+				stdio: "pipe",
+				uid: process.getuid ? process.getuid() : void 0,
+				gid: process.getgid ? process.getgid() : void 0
+			};
+			const node = spawn("node", [`index.${fileExtension}`], spawnOptions);
+			let stdout = "";
+			let stderr = "";
+			let outputSize = 0;
+			node.stdout?.on("data", (data) => {
+				const dataStr = data.toString();
+				outputSize += dataStr.length;
+				if (outputSize > FUNCTION_TOOL_SANDBOX_MAX_OUTPUT_SIZE_BYTES) {
+					node.kill("SIGTERM");
+					reject(/* @__PURE__ */ new Error(`Output size exceeded limit of ${FUNCTION_TOOL_SANDBOX_MAX_OUTPUT_SIZE_BYTES} bytes`));
+					return;
+				}
+				stdout += dataStr;
+			});
+			node.stderr?.on("data", (data) => {
+				const dataStr = data.toString();
+				outputSize += dataStr.length;
+				if (outputSize > FUNCTION_TOOL_SANDBOX_MAX_OUTPUT_SIZE_BYTES) {
+					node.kill("SIGTERM");
+					reject(/* @__PURE__ */ new Error(`Output size exceeded limit of ${FUNCTION_TOOL_SANDBOX_MAX_OUTPUT_SIZE_BYTES} bytes`));
+					return;
+				}
+				stderr += dataStr;
+			});
+			const timeoutId = setTimeout(() => {
+				logger.warn({
+					sandboxDir,
+					timeout
+				}, "Function execution timed out, killing process");
+				node.kill("SIGTERM");
+				const forceKillTimeout = Math.min(Math.max(timeout / 10, 2e3), 5e3);
+				setTimeout(() => {
+					try {
+						node.kill("SIGKILL");
+					} catch {}
+				}, forceKillTimeout);
+				reject(/* @__PURE__ */ new Error(`Function execution timed out after ${timeout}ms`));
+			}, timeout);
+			node.on("close", (code, signal) => {
+				clearTimeout(timeoutId);
+				if (code === 0) try {
+					const result = parseExecutionResult(stdout, "function", logger);
+					if (typeof result === "object" && result !== null && "success" in result) {
+						const parsed = result;
+						if (parsed.success) resolve(parsed.result);
+						else reject(new Error(parsed.error || "Function execution failed"));
+					} else resolve(result);
+				} catch (parseError) {
+					logger.error({
+						stdout,
+						stderr,
+						parseError
+					}, "Failed to parse function result");
+					reject(/* @__PURE__ */ new Error(`Invalid function result: ${stdout}`));
+				}
+				else {
+					const errorMsg = signal ? `Function execution killed by signal ${signal}: ${stderr}` : `Function execution failed with code ${code}: ${stderr}`;
+					logger.error({
+						code,
+						signal,
+						stderr
+					}, "Function execution failed");
+					reject(new Error(errorMsg));
+				}
+			});
+			node.on("error", (error) => {
+				clearTimeout(timeoutId);
+				logger.error({
+					sandboxDir,
+					error
+				}, "Failed to spawn node process");
+				reject(error);
+			});
+		});
+	}
+};
+
+//#endregion
+export { NativeSandboxExecutor };

package/dist/tools/SandboxExecutorFactory.d.ts

@@ -0,0 +1,36 @@
+import { FunctionToolConfig } from "./NativeSandboxExecutor.js";
+
+//#region src/tools/SandboxExecutorFactory.d.ts
+
+/**
+ * Factory for creating and managing sandbox executors
+ * Routes execution to the appropriate sandbox provider (native or Vercel)
+ */
+declare class SandboxExecutorFactory {
+  private static instance;
+  private nativeExecutor;
+  private vercelExecutors;
+  private constructor();
+  /**
+   * Get singleton instance of SandboxExecutorFactory
+   */
+  static getInstance(): SandboxExecutorFactory;
+  /**
+   * Execute a function tool using the appropriate sandbox provider
+   */
+  executeFunctionTool(functionId: string, args: Record<string, unknown>, config: FunctionToolConfig): Promise<unknown>;
+  /**
+   * Execute in native sandbox
+   */
+  private executeInNativeSandbox;
+  /**
+   * Execute in Vercel sandbox
+   */
+  private executeInVercelSandbox;
+  /**
+   * Clean up all sandbox executors
+   */
+  cleanup(): Promise<void>;
+}
+//#endregion
+export { SandboxExecutorFactory };

package/dist/tools/SandboxExecutorFactory.js

@@ -0,0 +1,80 @@
+import { getLogger } from "../logger.js";
+import { NativeSandboxExecutor } from "./NativeSandboxExecutor.js";
+import { VercelSandboxExecutor } from "./VercelSandboxExecutor.js";
+
+//#region src/tools/SandboxExecutorFactory.ts
+const logger = getLogger("SandboxExecutorFactory");
+/**
+* Factory for creating and managing sandbox executors
+* Routes execution to the appropriate sandbox provider (native or Vercel)
+*/
+var SandboxExecutorFactory = class SandboxExecutorFactory {
+	static instance;
+	nativeExecutor = null;
+	vercelExecutors = /* @__PURE__ */ new Map();
+	constructor() {
+		logger.info({}, "SandboxExecutorFactory initialized");
+	}
+	/**
+	* Get singleton instance of SandboxExecutorFactory
+	*/
+	static getInstance() {
+		if (!SandboxExecutorFactory.instance) SandboxExecutorFactory.instance = new SandboxExecutorFactory();
+		return SandboxExecutorFactory.instance;
+	}
+	/**
+	* Execute a function tool using the appropriate sandbox provider
+	*/
+	async executeFunctionTool(functionId, args, config) {
+		const sandboxConfig = config.sandboxConfig;
+		if (!sandboxConfig) throw new Error("Sandbox configuration is required for function tool execution");
+		if (sandboxConfig.provider === "native") return this.executeInNativeSandbox(functionId, args, config);
+		if (sandboxConfig.provider === "vercel") return this.executeInVercelSandbox(functionId, args, config);
+		throw new Error(`Unknown sandbox provider: ${sandboxConfig.provider}`);
+	}
+	/**
+	* Execute in native sandbox
+	*/
+	async executeInNativeSandbox(functionId, args, config) {
+		if (!this.nativeExecutor) {
+			this.nativeExecutor = NativeSandboxExecutor.getInstance();
+			logger.info({}, "Native sandbox executor created");
+		}
+		return this.nativeExecutor.executeFunctionTool(functionId, args, config);
+	}
+	/**
+	* Execute in Vercel sandbox
+	*/
+	async executeInVercelSandbox(functionId, args, config) {
+		const vercelConfig = config.sandboxConfig;
+		const configKey = `${vercelConfig.teamId}:${vercelConfig.projectId}`;
+		if (!this.vercelExecutors.has(configKey)) {
+			const executor$1 = VercelSandboxExecutor.getInstance(vercelConfig);
+			this.vercelExecutors.set(configKey, executor$1);
+			logger.info({
+				teamId: vercelConfig.teamId,
+				projectId: vercelConfig.projectId
+			}, "Vercel sandbox executor created");
+		}
+		const executor = this.vercelExecutors.get(configKey);
+		if (!executor) throw new Error(`Failed to get Vercel executor for config: ${configKey}`);
+		const result = await executor.executeFunctionTool(functionId, args, config);
+		if (!result.success) throw new Error(result.error || "Vercel sandbox execution failed");
+		return result.result;
+	}
+	/**
+	* Clean up all sandbox executors
+	*/
+	async cleanup() {
+		logger.info({}, "Cleaning up sandbox executors");
+		this.nativeExecutor = null;
+		for (const [key, executor] of this.vercelExecutors.entries()) {
+			await executor.cleanup();
+			this.vercelExecutors.delete(key);
+		}
+		logger.info({}, "Sandbox executor cleanup completed");
+	}
+};
+
+//#endregion
+export { SandboxExecutorFactory };

package/dist/tools/VercelSandboxExecutor.d.ts

@@ -0,0 +1,71 @@
+import { VercelSandboxConfig } from "../types/execution-context.js";
+import { FunctionToolConfig } from "./NativeSandboxExecutor.js";
+
+//#region src/tools/VercelSandboxExecutor.d.ts
+interface ExecutionResult {
+  success: boolean;
+  result?: unknown;
+  error?: string;
+  logs?: string[];
+  executionTime?: number;
+}
+/**
+ * Vercel Sandbox Executor with pooling/reuse
+ * Executes function tools in isolated Vercel Sandbox MicroVMs
+ * Caches and reuses sandboxes based on dependencies to improve performance
+ */
+declare class VercelSandboxExecutor {
+  private static instance;
+  private config;
+  private sandboxPool;
+  private cleanupInterval;
+  private constructor();
+  /**
+   * Get singleton instance of VercelSandboxExecutor
+   */
+  static getInstance(config: VercelSandboxConfig): VercelSandboxExecutor;
+  /**
+   * Generate a hash for dependencies to use as cache key
+   */
+  private generateDependencyHash;
+  /**
+   * Get a cached sandbox if available and still valid
+   */
+  private getCachedSandbox;
+  /**
+   * Add sandbox to pool
+   */
+  private addToPool;
+  /**
+   * Increment use count for a sandbox
+   */
+  private incrementUseCount;
+  /**
+   * Remove and clean up a sandbox
+   */
+  private removeSandbox;
+  /**
+   * Start periodic cleanup of expired sandboxes
+   */
+  private startPoolCleanup;
+  /**
+   * Cleanup all sandboxes and stop cleanup interval
+   */
+  cleanup(): Promise<void>;
+  /**
+   * Extract environment variable names from code
+   * Matches patterns like process.env.VAR_NAME or process.env['VAR_NAME']
+   */
+  private extractEnvVars;
+  /**
+   * Create .env file content from environment variables
+   * Note: Currently creates empty placeholders. Values will be populated in the future.
+   */
+  private createEnvFileContent;
+  /**
+   * Execute a function tool in Vercel Sandbox with pooling
+   */
+  executeFunctionTool(functionId: string, args: Record<string, unknown>, toolConfig: FunctionToolConfig): Promise<ExecutionResult>;
+}
+//#endregion
+export { ExecutionResult, VercelSandboxExecutor };