rl-rock 1.2.4 → 1.2.6

package/dist/index.js

@@ -1,22 +1,24 @@
 'use strict';
 
+var fs = require('fs');
+var path = require('path');
 var zod = require('zod');
-var axios3 = require('axios');
+var axios = require('axios');
 var https = require('https');
 var tsCaseConvert = require('ts-case-convert');
-require('os');
-var path = require('path');
 var winston = require('winston');
-var fs = require('fs');
+var os = require('os');
 var crypto = require('crypto');
-var child_process = require('child_process');
+var promises = require('fs/promises');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var axios3__default = /*#__PURE__*/_interopDefault(axios3);
+var axios__default = /*#__PURE__*/_interopDefault(axios);
 var https__default = /*#__PURE__*/_interopDefault(https);
 var winston__default = /*#__PURE__*/_interopDefault(winston);
 
+// src/index.ts
+
 // src/types/codes.ts
 var Codes = /* @__PURE__ */ ((Codes2) => {
   Codes2[Codes2["OK"] = 2e3] = "OK";
@@ -177,14 +179,6 @@ var RunMode = {
   NORMAL: "normal",
   NOHUP: "nohup"
 };
-var Constants = class {
-  static BASE_URL_PRODUCT = "";
-  static BASE_URL_ALIYUN = "";
-  static BASE_URL_INNER = "";
-  static BASE_URL_PRE = "";
-  static BASE_URL_LOCAL = "";
-  static REQUEST_TIMEOUT_SECONDS = 180;
-};
 var PID_PREFIX = "__ROCK_PID_START__";
 var PID_SUFFIX = "__ROCK_PID_END__";
 
@@ -262,6 +256,10 @@ var objectToCamel = tsCaseConvert.objectToCamel;
 var objectToSnake = tsCaseConvert.objectToSnake;
 
 // src/utils/http.ts
+var sharedHttpsAgent = new https__default.default.Agent({
+  rejectUnauthorized: true,
+  keepAlive: true
+});
 var HttpUtils = class {
   static defaultTimeout = 3e5;
   // 5 minutes
@@ -270,15 +268,13 @@ var HttpUtils = class {
    * Create axios instance with default config
    */
   static createClient(config) {
-    return axios3__default.default.create({
+    return axios__default.default.create({
       timeout: config?.timeout ?? this.defaultTimeout,
       headers: {
         "Content-Type": "application/json",
         ...config?.headers
       },
-      httpsAgent: new https__default.default.Agent({
-        rejectUnauthorized: true
-      })
+      httpsAgent: sharedHttpsAgent
     });
   }
   /**
@@ -307,7 +303,7 @@ var HttpUtils = class {
       }
       return httpResponse;
     } catch (error) {
-      if (error instanceof axios3.AxiosError) {
+      if (error instanceof axios.AxiosError) {
         throw new Error(`Failed to POST ${url}: ${error.message}`);
       }
       throw error;
@@ -334,7 +330,7 @@ var HttpUtils = class {
       }
       return httpResponse;
     } catch (error) {
-      if (error instanceof axios3.AxiosError) {
+      if (error instanceof axios.AxiosError) {
         throw new Error(`Failed to GET ${url}: ${error.message}`);
       }
       throw error;
@@ -394,12 +390,15 @@ var HttpUtils = class {
     }
     const client = this.createClient({
       headers: {
-        ...headers,
-        "Content-Type": "multipart/form-data"
+        ...headers
       }
     });
     try {
-      const response = await client.post(url, formData);
+      const response = await client.post(url, formData, {
+        headers: {
+          "Content-Type": null
+        }
+      });
       const camelData = objectToCamel(response.data);
       const httpResponse = {
         status: camelData.status ?? "Success",
@@ -413,7 +412,7 @@ var HttpUtils = class {
       }
       return httpResponse;
     } catch (error) {
-      if (error instanceof axios3.AxiosError) {
+      if (error instanceof axios.AxiosError) {
         throw new Error(`Failed to POST multipart ${url}: ${error.message}`);
       }
       throw error;
@@ -444,13 +443,21 @@ var HttpUtils = class {
     return mimeTypes[ext ?? ""] ?? "application/octet-stream";
   }
 };
+function extractNohupPid(output) {
+  const pattern = new RegExp(`${PID_PREFIX}(\\d+)${PID_SUFFIX}`);
+  const match = output.match(pattern);
+  if (match?.[1]) {
+    return parseInt(match[1], 10);
+  }
+  return null;
+}
 
 // src/utils/retry.ts
 function retryAsync(fn, options = {}) {
   const {
     maxAttempts = 3,
     delaySeconds = 1,
-    backoff = 1,
+    backoff = 2,
     jitter = false
   } = options;
   return retryAsyncImpl(fn, {
@@ -491,43 +498,12 @@ function withRetry(fn, options = {}) {
   });
 }
 
-// src/utils/deprecated.ts
-function deprecated(reason = "") {
-  return function(target, propertyKey, descriptor) {
-    const originalMethod = descriptor.value;
-    descriptor.value = function(...args) {
-      console.warn(
-        `${String(propertyKey)} is deprecated. ${reason}`
-      );
-      return originalMethod.apply(this, args);
-    };
-    return descriptor;
-  };
-}
-function deprecatedClass(reason = "") {
-  return function(constructor) {
-    return class extends constructor {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      constructor(...args) {
-        console.warn(`${constructor.name} is deprecated. ${reason}`);
-        super(...args);
-      }
-    };
-  };
-}
-
 // src/utils/system.ts
 function isNode() {
   return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
 }
-function isBrowser() {
-  return typeof globalThis !== "undefined" && "window" in globalThis && typeof globalThis.window !== "undefined";
-}
 function getEnv(key, defaultValue) {
-  if (isNode()) {
-    return process.env[key] ?? defaultValue;
-  }
-  return defaultValue;
+  return process.env[key] ?? defaultValue;
 }
 function getRequiredEnv(key) {
   const value = getEnv(key);
@@ -537,10 +513,7 @@ function getRequiredEnv(key) {
   return value;
 }
 function isEnvSet(key) {
-  if (isNode()) {
-    return key in process.env;
-  }
-  return false;
+  return key in process.env;
 }
 var envVars = {
   // Logging
@@ -553,23 +526,306 @@ var envVars = {
   get ROCK_LOGGING_LEVEL() {
     return getEnv("ROCK_LOGGING_LEVEL", "INFO");
   },
+  // Service
+  get ROCK_SERVICE_STATUS_DIR() {
+    return getEnv("ROCK_SERVICE_STATUS_DIR", "/data/service_status");
+  },
+  get ROCK_SCHEDULER_STATUS_DIR() {
+    return getEnv("ROCK_SCHEDULER_STATUS_DIR", "/data/scheduler_status");
+  },
+  // Config
+  get ROCK_CONFIG() {
+    return getEnv("ROCK_CONFIG");
+  },
+  get ROCK_CONFIG_DIR_NAME() {
+    return getEnv("ROCK_CONFIG_DIR_NAME", "rock-conf");
+  },
   // Base URLs
   get ROCK_BASE_URL() {
     return getEnv("ROCK_BASE_URL", "http://localhost:8080");
   },
+  get ROCK_WORKER_ROCKLET_PORT() {
+    const val = getEnv("ROCK_WORKER_ROCKLET_PORT");
+    return val ? parseInt(val, 10) : void 0;
+  },
   get ROCK_SANDBOX_STARTUP_TIMEOUT_SECONDS() {
     return parseInt(getEnv("ROCK_SANDBOX_STARTUP_TIMEOUT_SECONDS", "180"), 10);
   },
+  get ROCK_CODE_SANDBOX_BASE_URL() {
+    return getEnv("ROCK_CODE_SANDBOX_BASE_URL", "");
+  },
   // EnvHub
   get ROCK_ENVHUB_BASE_URL() {
     return getEnv("ROCK_ENVHUB_BASE_URL", "http://localhost:8081");
   },
+  get ROCK_ENVHUB_DEFAULT_DOCKER_IMAGE() {
+    return getEnv("ROCK_ENVHUB_DEFAULT_DOCKER_IMAGE", "python:3.11");
+  },
+  get ROCK_ENVHUB_DB_URL() {
+    return getEnv(
+      "ROCK_ENVHUB_DB_URL",
+      `sqlite:///${path.join(os.homedir(), ".rock", "rock_envs.db")}`
+    );
+  },
+  // Auto clear
+  get ROCK_DEFAULT_AUTO_CLEAR_TIME_MINUTES() {
+    return parseInt(getEnv("ROCK_DEFAULT_AUTO_CLEAR_TIME_MINUTES", "360"), 10);
+  },
+  // Ray
+  get ROCK_RAY_NAMESPACE() {
+    return getEnv("ROCK_RAY_NAMESPACE", "xrl-sandbox");
+  },
+  get ROCK_SANDBOX_EXPIRE_TIME_KEY() {
+    return getEnv("ROCK_SANDBOX_EXPIRE_TIME_KEY", "expire_time");
+  },
+  get ROCK_SANDBOX_AUTO_CLEAR_TIME_KEY() {
+    return getEnv("ROCK_SANDBOX_AUTO_CLEAR_TIME_KEY", "auto_clear_time");
+  },
+  // Timezone
+  get ROCK_TIME_ZONE() {
+    return getEnv("ROCK_TIME_ZONE", "Asia/Shanghai");
+  },
+  // OSS
+  get ROCK_OSS_ENABLE() {
+    return getEnv("ROCK_OSS_ENABLE", "false")?.toLowerCase() === "true";
+  },
+  get ROCK_OSS_BUCKET_ENDPOINT() {
+    return getEnv("ROCK_OSS_BUCKET_ENDPOINT");
+  },
+  get ROCK_OSS_BUCKET_NAME() {
+    return getEnv("ROCK_OSS_BUCKET_NAME");
+  },
+  get ROCK_OSS_BUCKET_REGION() {
+    return getEnv("ROCK_OSS_BUCKET_REGION");
+  },
+  // Pip
+  get ROCK_PIP_INDEX_URL() {
+    return getEnv("ROCK_PIP_INDEX_URL", "https://pypi.org/simple/");
+  },
+  // Monitor
+  get ROCK_MONITOR_ENABLE() {
+    return getEnv("ROCK_MONITOR_ENABLE", "false")?.toLowerCase() === "true";
+  },
+  // Project
+  get ROCK_PROJECT_ROOT() {
+    return getEnv("ROCK_PROJECT_ROOT", process.cwd());
+  },
+  get ROCK_WORKER_ENV_TYPE() {
+    return getEnv("ROCK_WORKER_ENV_TYPE", "local");
+  },
+  get ROCK_PYTHON_ENV_PATH() {
+    return getEnv("ROCK_PYTHON_ENV_PATH", process.cwd());
+  },
+  // Admin
+  get ROCK_ADMIN_ENV() {
+    return getEnv("ROCK_ADMIN_ENV", "dev");
+  },
+  get ROCK_ADMIN_ROLE() {
+    return getEnv("ROCK_ADMIN_ROLE", "write");
+  },
+  // CLI
+  get ROCK_CLI_LOAD_PATHS() {
+    return getEnv("ROCK_CLI_LOAD_PATHS", "");
+  },
+  get ROCK_CLI_DEFAULT_CONFIG_PATH() {
+    return getEnv("ROCK_CLI_DEFAULT_CONFIG_PATH", path.join(os.homedir(), ".rock", "config.ini"));
+  },
   // Model Service
   get ROCK_MODEL_SERVICE_DATA_DIR() {
     return getEnv("ROCK_MODEL_SERVICE_DATA_DIR", "/data/logs");
-  }};
+  },
+  get ROCK_MODEL_SERVICE_TRAJ_APPEND_MODE() {
+    return getEnv("ROCK_MODEL_SERVICE_TRAJ_APPEND_MODE", "false")?.toLowerCase() === "true";
+  },
+  // RuntimeEnv
+  get ROCK_RTENV_PYTHON_V31114_INSTALL_CMD() {
+    return getEnv(
+      "ROCK_RTENV_PYTHON_V31114_INSTALL_CMD",
+      "[ -f cpython31114.tar.gz ] && rm cpython31114.tar.gz; [ -d python ] && rm -rf python; wget -q -O cpython31114.tar.gz https://github.com/astral-sh/python-build-standalone/releases/download/20251120/cpython-3.11.14+20251120-x86_64-unknown-linux-gnu-install_only.tar.gz && tar -xzf cpython31114.tar.gz && mv python runtime-env"
+    );
+  },
+  get ROCK_RTENV_PYTHON_V31212_INSTALL_CMD() {
+    return getEnv(
+      "ROCK_RTENV_PYTHON_V31212_INSTALL_CMD",
+      "[ -f cpython-3.12.12.tar.gz ] && rm cpython-3.12.12.tar.gz; [ -d python ] && rm -rf python; wget -q -O cpython-3.12.12.tar.gz https://github.com/astral-sh/python-build-standalone/releases/download/20251217/cpython-3.12.12+20251217-x86_64-unknown-linux-gnu-install_only.tar.gz && tar -xzf cpython-3.12.12.tar.gz && mv python runtime-env"
+    );
+  },
+  get ROCK_RTENV_NODE_V22180_INSTALL_CMD() {
+    return getEnv(
+      "ROCK_RTENV_NODE_V22180_INSTALL_CMD",
+      "[ -f node.tar.xz ] && rm node.tar.xz; [ -d node ] && rm -rf node; wget -q -O node.tar.xz --tries=10 --waitretry=2 https://nodejs.org/dist/v22.18.0/node-v22.18.0-linux-x64.tar.xz && tar -xf node.tar.xz && mv node-v22.18.0-linux-x64 runtime-env"
+    );
+  },
+  // Agent
+  get ROCK_AGENT_PRE_INIT_BASH_CMD_LIST() {
+    const val = getEnv("ROCK_AGENT_PRE_INIT_BASH_CMD_LIST", "[]");
+    try {
+      return JSON.parse(val);
+    } catch {
+      return [];
+    }
+  },
+  get ROCK_AGENT_IFLOW_CLI_INSTALL_CMD() {
+    return getEnv("ROCK_AGENT_IFLOW_CLI_INSTALL_CMD", "npm i -g @iflow-ai/iflow-cli@latest");
+  },
+  get ROCK_MODEL_SERVICE_INSTALL_CMD() {
+    return getEnv("ROCK_MODEL_SERVICE_INSTALL_CMD", "pip install rl_rock[model-service]");
+  },
+  // Doccuum
+  get ROCK_DOCUUM_INSTALL_URL() {
+    return getEnv(
+      "ROCK_DOCUUM_INSTALL_URL",
+      "https://raw.githubusercontent.com/stepchowfun/docuum/main/install.sh"
+    );
+  },
+  // ========== Sandbox Defaults ==========
+  // Sandbox configuration defaults - allow users to override via environment variables
+  get ROCK_DEFAULT_IMAGE() {
+    return getEnv("ROCK_DEFAULT_IMAGE", "python:3.11");
+  },
+  get ROCK_DEFAULT_MEMORY() {
+    return getEnv("ROCK_DEFAULT_MEMORY", "8g");
+  },
+  get ROCK_DEFAULT_CPUS() {
+    return parseFloat(getEnv("ROCK_DEFAULT_CPUS", "2"));
+  },
+  get ROCK_DEFAULT_CLUSTER() {
+    return getEnv("ROCK_DEFAULT_CLUSTER", "zb");
+  },
+  get ROCK_DEFAULT_AUTO_CLEAR_SECONDS() {
+    return parseInt(getEnv("ROCK_DEFAULT_AUTO_CLEAR_SECONDS", "300"), 10);
+  },
+  // ========== SandboxGroup Defaults ==========
+  get ROCK_DEFAULT_GROUP_SIZE() {
+    return parseInt(getEnv("ROCK_DEFAULT_GROUP_SIZE", "2"), 10);
+  },
+  get ROCK_DEFAULT_START_CONCURRENCY() {
+    return parseInt(getEnv("ROCK_DEFAULT_START_CONCURRENCY", "2"), 10);
+  },
+  get ROCK_DEFAULT_START_RETRY_TIMES() {
+    return parseInt(getEnv("ROCK_DEFAULT_START_RETRY_TIMES", "3"), 10);
+  },
+  // ========== Client Timeouts (in seconds) ==========
+  get ROCK_DEFAULT_ARUN_TIMEOUT() {
+    return parseInt(getEnv("ROCK_DEFAULT_ARUN_TIMEOUT", "300"), 10);
+  },
+  get ROCK_DEFAULT_NOHUP_WAIT_TIMEOUT() {
+    return parseInt(getEnv("ROCK_DEFAULT_NOHUP_WAIT_TIMEOUT", "300"), 10);
+  },
+  get ROCK_DEFAULT_NOHUP_WAIT_INTERVAL() {
+    return parseInt(getEnv("ROCK_DEFAULT_NOHUP_WAIT_INTERVAL", "10"), 10);
+  },
+  get ROCK_DEFAULT_STATUS_CHECK_INTERVAL() {
+    return parseInt(getEnv("ROCK_DEFAULT_STATUS_CHECK_INTERVAL", "3"), 10);
+  }
+};
+var levels = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  http: 3,
+  debug: 4
+};
+var colors = {
+  error: "red",
+  warn: "yellow",
+  info: "green",
+  http: "magenta",
+  debug: "cyan"
+};
+winston__default.default.addColors(colors);
+var consoleFormat = winston__default.default.format.combine(
+  winston__default.default.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss.SSS" }),
+  winston__default.default.format.colorize({ all: true }),
+  winston__default.default.format.printf((info) => {
+    const { timestamp, level, message, ...meta } = info;
+    const metaStr = Object.keys(meta).length ? JSON.stringify(meta) : "";
+    return `${timestamp} ${level}: ${message} ${metaStr}`;
+  })
+);
+var fileFormat = winston__default.default.format.combine(
+  winston__default.default.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss.SSS" }),
+  winston__default.default.format.json()
+);
+function getLogLevel() {
+  const level = envVars.ROCK_LOGGING_LEVEL.toLowerCase();
+  if (level in levels) {
+    return level;
+  }
+  return "info";
+}
+var loggerContainer = new winston__default.default.Container();
+function initLogger(name = "rock", fileName) {
+  if (loggerContainer.has(name)) {
+    return loggerContainer.get(name);
+  }
+  const transports = [];
+  const logLevel = getLogLevel();
+  const logPath = envVars.ROCK_LOGGING_PATH;
+  const logFileName = envVars.ROCK_LOGGING_FILE_NAME;
+  if (logPath) {
+    if (!fs.existsSync(logPath)) {
+      fs.mkdirSync(logPath, { recursive: true });
+    }
+    transports.push(
+      new winston__default.default.transports.File({
+        filename: path.join(logPath, logFileName),
+        format: fileFormat,
+        level: logLevel
+      })
+    );
+  } else {
+    transports.push(
+      new winston__default.default.transports.Console({
+        format: consoleFormat,
+        level: logLevel
+      })
+    );
+  }
+  const logger13 = loggerContainer.add(name, {
+    levels,
+    defaultMeta: { service: name },
+    transports
+  });
+  return logger13;
+}
+initLogger("rock");
 
-// src/envhub/schema.ts
+// src/utils/deprecated.ts
+var warnedKeys = /* @__PURE__ */ new Set();
+function getLogger() {
+  return initLogger("rock.deprecated");
+}
+function warnOnce(key, message) {
+  if (warnedKeys.has(key)) {
+    return;
+  }
+  getLogger().warn(message);
+  warnedKeys.add(key);
+}
+function deprecated(reason = "") {
+  return function(target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    const key = String(propertyKey);
+    descriptor.value = function(...args) {
+      warnOnce(key, `${key} is deprecated. ${reason}`);
+      return originalMethod.apply(this, args);
+    };
+    return descriptor;
+  };
+}
+function deprecatedClass(reason = "") {
+  return function(constructor) {
+    const key = constructor.name;
+    return class extends constructor {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      constructor(...args) {
+        warnOnce(key, `${key} is deprecated. ${reason}`);
+        super(...args);
+      }
+    };
+  };
+}
 var EnvHubClientConfigSchema = zod.z.object({
   baseUrl: zod.z.string().default(envVars.ROCK_ENVHUB_BASE_URL)
 });
@@ -698,104 +954,51 @@ var EnvHubClient = class {
     }
   }
 };
-var levels = {
-  error: 0,
-  warn: 1,
-  info: 2,
-  http: 3,
-  debug: 4
-};
-var colors = {
-  error: "red",
-  warn: "yellow",
-  info: "green",
-  http: "magenta",
-  debug: "cyan"
-};
-winston__default.default.addColors(colors);
-var consoleFormat = winston__default.default.format.combine(
-  winston__default.default.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss.SSS" }),
-  winston__default.default.format.colorize({ all: true }),
-  winston__default.default.format.printf((info) => {
-    const { timestamp, level, message, ...meta } = info;
-    const metaStr = Object.keys(meta).length ? JSON.stringify(meta) : "";
-    return `${timestamp} ${level}: ${message} ${metaStr}`;
-  })
-);
-var fileFormat = winston__default.default.format.combine(
-  winston__default.default.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss.SSS" }),
-  winston__default.default.format.json()
-);
-function getLogLevel() {
-  const level = envVars.ROCK_LOGGING_LEVEL.toLowerCase();
-  if (level in levels) {
-    return level;
-  }
-  return "info";
-}
-var loggerCache = /* @__PURE__ */ new Map();
-function initLogger(name = "rock", fileName) {
-  if (loggerCache.has(name)) {
-    return loggerCache.get(name);
-  }
-  const transports = [];
-  const logLevel = getLogLevel();
-  const logPath = envVars.ROCK_LOGGING_PATH;
-  const logFileName = envVars.ROCK_LOGGING_FILE_NAME;
-  if (logPath) {
-    if (!fs.existsSync(logPath)) {
-      fs.mkdirSync(logPath, { recursive: true });
-    }
-    transports.push(
-      new winston__default.default.transports.File({
-        filename: path.join(logPath, logFileName),
-        format: fileFormat,
-        level: logLevel
-      })
-    );
-  } else {
-    transports.push(
-      new winston__default.default.transports.Console({
-        format: consoleFormat,
-        level: logLevel
-      })
-    );
-  }
-  const logger10 = winston__default.default.createLogger({
-    levels,
-    defaultMeta: { service: name },
-    transports
-  });
-  loggerCache.set(name, logger10);
-  return logger10;
-}
-initLogger("rock");
 
 // src/envs/rock_env.ts
 var logger = initLogger("rock.envs");
-var RockEnv = class {
+var RockEnv = class _RockEnv {
   envId;
   sandboxId = null;
   isClosed = false;
-  client;
   constructor(config) {
     this.envId = config.envId;
-    this.client = axios3__default.default.create({
-      baseURL: envVars.ROCK_BASE_URL,
-      timeout: 3e5,
-      headers: { "Content-Type": "application/json" }
-    });
+  }
+  /**
+   * Create and initialize a RockEnv instance
+   *
+   * @param config - Environment configuration
+   * @returns Initialized RockEnv instance
+   */
+  static async create(config) {
+    const env = new _RockEnv(config);
     try {
-      this.initializeEnvironment();
+      await env.initializeEnvironment();
     } catch (e) {
       throw new Error(`Failed to initialize environment: ${e}`);
     }
+    return env;
+  }
+  /**
+   * Get the sandbox ID
+   */
+  getSandboxId() {
+    return this.sandboxId;
   }
   /**
    * Initialize environment instance
    */
-  initializeEnvironment() {
+  async initializeEnvironment() {
     logger.debug(`Initializing environment: ${this.envId}`);
+    const response = await HttpUtils.post(
+      `${envVars.ROCK_BASE_URL}/apis/v1/envs/gem/make`,
+      { "Content-Type": "application/json" },
+      { envId: this.envId }
+    );
+    this.sandboxId = response.result?.sandboxId ?? null;
+    if (!this.sandboxId) {
+      throw new Error("Failed to get environment instance ID");
+    }
   }
   /**
    * Execute an action step
@@ -805,19 +1008,12 @@ var RockEnv = class {
    */
   async step(action) {
     this.ensureNotClosed();
-    const params = {
-      sandbox_id: this.sandboxId,
-      action
-    };
-    try {
-      const response = await this.client.post(
-        "/apis/v1/envs/gem/step",
-        params
-      );
-      return this.parseStepResult(response.data);
-    } catch (e) {
-      throw new Error(`Failed to execute step with action ${action}: ${e}`);
-    }
+    const response = await HttpUtils.post(
+      `${envVars.ROCK_BASE_URL}/apis/v1/envs/gem/step`,
+      { "Content-Type": "application/json" },
+      { sandboxId: this.sandboxId, action }
+    );
+    return this.parseStepResult(response.result);
   }
   /**
    * Reset environment to initial state
@@ -827,19 +1023,16 @@ var RockEnv = class {
    */
   async reset(seed) {
     this.ensureNotClosed();
-    const params = { sandbox_id: this.sandboxId };
+    const params = { sandboxId: this.sandboxId };
     if (seed !== void 0) {
       params.seed = seed;
     }
-    try {
-      const response = await this.client.post(
-        "/apis/v1/envs/gem/reset",
-        params
-      );
-      return this.parseResetResult(response.data);
-    } catch (e) {
-      throw new Error(`Failed to reset environment: ${e}`);
-    }
+    const response = await HttpUtils.post(
+      `${envVars.ROCK_BASE_URL}/apis/v1/envs/gem/reset`,
+      { "Content-Type": "application/json" },
+      params
+    );
+    return this.parseResetResult(response.result);
   }
   /**
    * Close environment and clean up resources
@@ -849,9 +1042,11 @@ var RockEnv = class {
       return;
     }
     try {
-      await this.client.post("/apis/v1/envs/gem/close", {
-        sandbox_id: this.sandboxId
-      });
+      await HttpUtils.post(
+        `${envVars.ROCK_BASE_URL}/apis/v1/envs/gem/close`,
+        { "Content-Type": "application/json" },
+        { sandboxId: this.sandboxId }
+      );
     } catch (e) {
       throw new Error(`Failed to close environment: ${e}`);
     } finally {
@@ -863,6 +1058,9 @@ var RockEnv = class {
    * Parse step result from API response
    */
   parseStepResult(data) {
+    if (!data) {
+      throw new Error("Invalid step result: no data");
+    }
     return [
       data.observation,
       data.reward,
@@ -875,6 +1073,9 @@ var RockEnv = class {
    * Parse reset result from API response
    */
   parseResetResult(data) {
+    if (!data) {
+      throw new Error("Invalid reset result: no data");
+    }
     return [data.observation, data.info];
   }
   /**
@@ -888,30 +1089,30 @@ var RockEnv = class {
 };
 
 // src/envs/registration.ts
-function make(envId, options) {
-  return new RockEnv({ envId, ...options });
+async function make(envId, options) {
+  return RockEnv.create({ envId, ...options });
 }
 var BaseConfigSchema = zod.z.object({
-  baseUrl: zod.z.string().default(envVars.ROCK_BASE_URL),
+  baseUrl: zod.z.string().default(() => envVars.ROCK_BASE_URL),
   xrlAuthorization: zod.z.string().optional(),
   extraHeaders: zod.z.record(zod.z.string()).default({})
 });
 var SandboxConfigSchema = BaseConfigSchema.extend({
-  image: zod.z.string().default("python:3.11"),
-  autoClearSeconds: zod.z.number().default(300),
+  image: zod.z.string().default(() => envVars.ROCK_DEFAULT_IMAGE),
+  autoClearSeconds: zod.z.number().default(() => envVars.ROCK_DEFAULT_AUTO_CLEAR_SECONDS),
   routeKey: zod.z.string().optional(),
-  startupTimeout: zod.z.number().default(envVars.ROCK_SANDBOX_STARTUP_TIMEOUT_SECONDS),
-  memory: zod.z.string().default("8g"),
-  cpus: zod.z.number().default(2),
+  startupTimeout: zod.z.number().default(() => envVars.ROCK_SANDBOX_STARTUP_TIMEOUT_SECONDS),
+  memory: zod.z.string().default(() => envVars.ROCK_DEFAULT_MEMORY),
+  cpus: zod.z.number().default(() => envVars.ROCK_DEFAULT_CPUS),
   userId: zod.z.string().optional(),
   experimentId: zod.z.string().optional(),
-  cluster: zod.z.string().default("zb"),
+  cluster: zod.z.string().default(() => envVars.ROCK_DEFAULT_CLUSTER),
   namespace: zod.z.string().optional()
 });
 var SandboxGroupConfigSchema = SandboxConfigSchema.extend({
-  size: zod.z.number().default(2),
-  startConcurrency: zod.z.number().default(2),
-  startRetryTimes: zod.z.number().default(3)
+  size: zod.z.number().default(() => envVars.ROCK_DEFAULT_GROUP_SIZE),
+  startConcurrency: zod.z.number().default(() => envVars.ROCK_DEFAULT_START_CONCURRENCY),
+  startRetryTimes: zod.z.number().default(() => envVars.ROCK_DEFAULT_START_RETRY_TIMES)
 });
 function createSandboxConfig(config) {
   return SandboxConfigSchema.parse(config ?? {});
@@ -984,8 +1185,100 @@ var Deploy = class {
   }
 };
 
+// src/utils/shell.ts
+function shellQuote(str) {
+  if (str === "") {
+    return "''";
+  }
+  return `'${str.replace(/'/g, "'\\''")}'`;
+}
+function validateUrl(url, allowedProtocols = ["http:", "https:"]) {
+  try {
+    const parsed = new URL(url);
+    if (!allowedProtocols.includes(parsed.protocol)) {
+      throw new Error(
+        `Protocol ${parsed.protocol} is not allowed. Allowed: ${allowedProtocols.join(", ")}`
+      );
+    }
+    return url.replace(/\/$/, "");
+  } catch (e) {
+    if (e instanceof Error && e.message.includes("Protocol")) {
+      throw e;
+    }
+    throw new Error(`Invalid URL: ${url}. ${e instanceof Error ? e.message : String(e)}`);
+  }
+}
+function validateIpAddress(ip) {
+  const pattern = /^(\d{1,3}\.){3}\d{1,3}$/;
+  if (!pattern.test(ip)) {
+    throw new Error(`Invalid IP address format: ${ip}. Expected format: x.x.x.x`);
+  }
+  const octets = ip.split(".");
+  for (const octet of octets) {
+    const value = parseInt(octet, 10);
+    if (value < 0 || value > 255) {
+      throw new Error(`Invalid IP address: ${ip}. Each octet must be 0-255.`);
+    }
+  }
+  return ip;
+}
+function validatePath(path) {
+  if (!path.startsWith("/")) {
+    throw new Error(`Path must be absolute: ${path}`);
+  }
+  if (path.includes("..")) {
+    throw new Error(`Path cannot contain ..: ${path}`);
+  }
+  if (/[`$(){};|&<>()]/.test(path)) {
+    throw new Error(`Path contains forbidden characters: ${path}`);
+  }
+}
+function validateUsername(username) {
+  if (username.length === 0) {
+    throw new Error("Username cannot be empty");
+  }
+  if (username.startsWith("-")) {
+    throw new Error(`Username starting with dash is not allowed: ${username}`);
+  }
+  if (!/^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(username)) {
+    throw new Error(`Invalid username format: ${username}. Only alphanumeric, underscore, and hyphen allowed.`);
+  }
+}
+function validateChmodMode(mode) {
+  if (mode.length === 0) {
+    throw new Error("Mode cannot be empty");
+  }
+  if (/^[0-7]{3,4}$/.test(mode)) {
+    return;
+  }
+  if (/^[ugoa]*[+-=][rwxXstugo]*([,][ugoa]*[+-=][rwxXstugo]*)*$/.test(mode)) {
+    return;
+  }
+  throw new Error(`Invalid chmod mode: ${mode}. Expected octal (e.g., 755) or symbolic (e.g., u+x)`);
+}
+
 // src/sandbox/file_system.ts
 var logger3 = initLogger("rock.sandbox.fs");
+async function createTarGz(sourceDir, outputPath) {
+  const { spawn } = await import('child_process');
+  return new Promise((resolve3, reject) => {
+    const tar = spawn("tar", ["-czf", outputPath, "-C", sourceDir, "."]);
+    let stderr = "";
+    tar.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    tar.on("close", (code) => {
+      if (code === 0) {
+        resolve3();
+      } else {
+        reject(new Error(`tar command failed with code ${code}: ${stderr}`));
+      }
+    });
+    tar.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
 var FileSystem = class {
   sandbox;
   constructor(sandbox) {
@@ -1001,6 +1294,10 @@ var LinuxFileSystem = class extends FileSystem {
     if (!paths || paths.length === 0) {
       throw new Error("paths is empty");
     }
+    validateUsername(remoteUser);
+    for (const p of paths) {
+      validatePath(p);
+    }
     const command = ["chown"];
     if (recursive) {
       command.push("-R");
@@ -1018,6 +1315,10 @@ var LinuxFileSystem = class extends FileSystem {
     if (!paths || paths.length === 0) {
       throw new Error("paths is empty");
     }
+    validateChmodMode(mode);
+    for (const p of paths) {
+      validatePath(p);
+    }
     const command = ["chmod"];
     if (recursive) {
       command.push("-R");
@@ -1030,27 +1331,128 @@ var LinuxFileSystem = class extends FileSystem {
     }
     return { success: true, message: JSON.stringify(response) };
   }
-  async uploadDir(sourceDir, targetDir, _extractTimeout = 600) {
-    logger3.info(`uploadDir: ${sourceDir} -> ${targetDir}`);
-    return {
-      output: `uploaded ${sourceDir} -> ${targetDir}`,
-      exitCode: 0,
-      failureReason: "",
-      expectString: ""
-    };
+  async uploadDir(sourceDir, targetDir, extractTimeout = 600) {
+    let localTarPath = null;
+    let remoteTarPath = null;
+    let session = null;
+    try {
+      const src = path.resolve(sourceDir);
+      if (!fs.existsSync(src)) {
+        return {
+          output: "",
+          exitCode: 1,
+          failureReason: `source_dir not found: ${src}`,
+          expectString: ""
+        };
+      }
+      const stats = fs.statSync(src);
+      if (!stats.isDirectory()) {
+        return {
+          output: "",
+          exitCode: 1,
+          failureReason: `source_dir must be a directory: ${src}`,
+          expectString: ""
+        };
+      }
+      try {
+        validatePath(targetDir);
+      } catch (e) {
+        return {
+          output: "",
+          exitCode: 1,
+          failureReason: e instanceof Error ? e.message : "Invalid target directory",
+          expectString: ""
+        };
+      }
+      const ts = Date.now().toString();
+      const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "rock-upload-"));
+      localTarPath = path.join(tmpDir, `rock_upload_${ts}.tar.gz`);
+      remoteTarPath = `/tmp/rock_upload_${ts}.tar.gz`;
+      session = `bash-${ts}`;
+      logger3.info(`uploadDir: ${src} -> ${targetDir}`);
+      await this.sandbox.createSession({ session, startupSource: [], envEnable: false });
+      const checkResult = await this.sandbox.arun("command -v tar >/dev/null 2>&1", {
+        session,
+        mode: RunMode.NORMAL
+      });
+      if (checkResult.exitCode !== 0) {
+        return {
+          output: "",
+          exitCode: 1,
+          failureReason: "sandbox has no tar command; cannot extract tarball",
+          expectString: ""
+        };
+      }
+      try {
+        await createTarGz(src, localTarPath);
+      } catch (e) {
+        throw new Error(`tar pack failed: ${e}`);
+      }
+      const uploadResponse = await this.sandbox.upload({
+        sourcePath: localTarPath,
+        targetPath: remoteTarPath
+      });
+      if (!uploadResponse.success) {
+        return {
+          output: "",
+          exitCode: 1,
+          failureReason: `tar upload failed: ${uploadResponse.message}`,
+          expectString: ""
+        };
+      }
+      const escapedTargetDir = shellQuote(targetDir);
+      const escapedRemoteTar = shellQuote(remoteTarPath);
+      const extractCmd = `rm -rf ${escapedTargetDir} && mkdir -p ${escapedTargetDir} && tar -xzf ${escapedRemoteTar} -C ${escapedTargetDir}`;
+      const extractResult = await this.sandbox.arun(`bash -c ${shellQuote(extractCmd)}`, {
+        session,
+        mode: RunMode.NOHUP,
+        waitTimeout: extractTimeout
+      });
+      if (extractResult.exitCode !== 0) {
+        return {
+          output: "",
+          exitCode: 1,
+          failureReason: `tar extract failed: ${extractResult.output}`,
+          expectString: ""
+        };
+      }
+      try {
+        await this.sandbox.execute({ command: ["rm", "-f", remoteTarPath], timeout: 30 });
+      } catch {
+      }
+      return {
+        output: `uploaded ${src} -> ${targetDir} via tar`,
+        exitCode: 0,
+        failureReason: "",
+        expectString: ""
+      };
+    } catch (e) {
+      return {
+        output: "",
+        exitCode: 1,
+        failureReason: `upload_dir unexpected error: ${e}`,
+        expectString: ""
+      };
+    } finally {
+      try {
+        if (localTarPath) {
+          const tmpDir = path.basename(localTarPath).replace(/\.tar\.gz$/, "");
+          fs.rmSync(path.join(os.tmpdir(), `rock-upload-${tmpDir.split("_").pop()}`), { recursive: true, force: true });
+        }
+      } catch {
+      }
+    }
   }
 };
 
-// src/sandbox/types.ts
+// src/sandbox/network.ts
+var logger4 = initLogger("rock.sandbox.network");
 var SpeedupType = /* @__PURE__ */ ((SpeedupType2) => {
   SpeedupType2["APT"] = "apt";
   SpeedupType2["PIP"] = "pip";
   SpeedupType2["GITHUB"] = "github";
   return SpeedupType2;
 })(SpeedupType || {});
-
-// src/sandbox/network.ts
-var logger4 = initLogger("rock.sandbox.network");
 var Network = class {
   sandbox;
   constructor(sandbox) {
@@ -1069,45 +1471,179 @@ var Network = class {
     logger4.info(
       `[${sandboxId}] Configuring ${speedupType} speedup: ${speedupValue}`
     );
-    let command;
+    let validatedValue;
     switch (speedupType) {
       case "apt" /* APT */:
-        command = this.buildAptSpeedupCommand(speedupValue);
-        break;
       case "pip" /* PIP */:
-        command = this.buildPipSpeedupCommand(speedupValue);
+        validatedValue = validateUrl(speedupValue);
         break;
       case "github" /* GITHUB */:
-        command = this.buildGithubSpeedupCommand(speedupValue);
+        validatedValue = validateIpAddress(speedupValue);
         break;
       default:
         throw new Error(`Unsupported speedup type: ${speedupType}`);
     }
-    const result = await this.sandbox.arun(command, {
-      mode: "nohup",
+    const scriptContent = this.generateSpeedupScript(speedupType, validatedValue);
+    const result = await this.sandbox.getProcess().executeScript({
+      scriptContent,
       waitTimeout: timeout
     });
     return result;
   }
-  buildAptSpeedupCommand(mirrorUrl) {
-    return `cat > /etc/apt/sources.list << 'EOF'
-deb ${mirrorUrl} $(lsb_release -cs) main restricted universe multiverse
-deb ${mirrorUrl} $(lsb_release -cs)-updates main restricted universe multiverse
-deb ${mirrorUrl} $(lsb_release -cs)-backports main restricted universe multiverse
-deb ${mirrorUrl} $(lsb_release -cs)-security main restricted universe multiverse
+  /**
+   * Generate speedup script content based on type
+   */
+  generateSpeedupScript(speedupType, value) {
+    switch (speedupType) {
+      case "apt" /* APT */:
+        return this.buildAptSpeedupScript(value);
+      case "pip" /* PIP */:
+        return this.buildPipSpeedupScript(value);
+      case "github" /* GITHUB */:
+        return this.buildGithubSpeedupScript(value);
+      default:
+        throw new Error(`Unsupported speedup type: ${speedupType}`);
+    }
+  }
+  /**
+   * Build APT speedup script
+   * Uses script file approach for safety
+   */
+  buildAptSpeedupScript(mirrorUrl) {
+    return `#!/bin/bash
+detect_system_and_version() {
+    if [ -f /etc/debian_version ]; then
+        . /etc/os-release
+        if [ "$ID" = "ubuntu" ]; then
+            echo "ubuntu:$VERSION_CODENAME"
+        elif [ "$ID" = "debian" ]; then
+            echo "debian:$VERSION_CODENAME"
+        else
+            echo "unknown:"
+        fi
+    else
+        echo "unknown:"
+    fi
+}
+
+SYSTEM_INFO=$(detect_system_and_version)
+SYSTEM=$(echo "$SYSTEM_INFO" | cut -d: -f1)
+CODENAME=$(echo "$SYSTEM_INFO" | cut -d: -f2)
+echo "System type: $SYSTEM, Version codename: $CODENAME"
+
+# Backup original sources file
+if [ ! -f /etc/apt/sources.list.backup ]; then
+    cp /etc/apt/sources.list /etc/apt/sources.list.backup
+fi
+
+if [ "$SYSTEM" = "debian" ]; then
+    if [ -z "$CODENAME" ]; then
+        CODENAME="bookworm"
+    fi
+    cat > /etc/apt/sources.list <<EOF
+deb ${mirrorUrl}/debian/ \${CODENAME} main non-free non-free-firmware contrib
+deb ${mirrorUrl}/debian-security/ \${CODENAME}-security main
+deb ${mirrorUrl}/debian/ \${CODENAME}-updates main non-free non-free-firmware contrib
 EOF
-apt-get update`;
+elif [ "$SYSTEM" = "ubuntu" ]; then
+    if [ -z "$CODENAME" ]; then
+        if [ -f /etc/os-release ]; then
+            VERSION_ID=$(grep VERSION_ID /etc/os-release | cut -d'"' -f2)
+            case "$VERSION_ID" in
+                "24.04") CODENAME="noble" ;;
+                "22.04") CODENAME="jammy" ;;
+                "20.04") CODENAME="focal" ;;
+                *) CODENAME="noble" ;;
+            esac
+        else
+            CODENAME="noble"
+        fi
+    fi
+    cat > /etc/apt/sources.list <<EOF
+deb ${mirrorUrl}/ubuntu/ $CODENAME main restricted universe multiverse
+deb ${mirrorUrl}/ubuntu/ $CODENAME-security main restricted universe multiverse
+deb ${mirrorUrl}/ubuntu/ $CODENAME-updates main restricted universe multiverse
+deb ${mirrorUrl}/ubuntu/ $CODENAME-backports main restricted universe multiverse
+EOF
+fi
+
+# Clean up other source files
+rm -rf /etc/apt/sources.list.d
+
+# Clean APT cache and update
+apt-get clean
+rm -rf /var/lib/apt/lists/*
+echo ">>> APT source configuration completed"
+`;
   }
-  buildPipSpeedupCommand(mirrorUrl) {
-    const safeUrl = mirrorUrl.replace(/'/g, "'\\''");
-    return `mkdir -p ~/.pip && cat > ~/.pip/pip.conf << 'EOF'
+  /**
+   * Build PIP speedup script
+   * Uses script file approach for safety
+   */
+  buildPipSpeedupScript(mirrorUrl) {
+    const parsed = new URL(mirrorUrl);
+    const trustedHost = parsed.host;
+    const indexUrl = `${mirrorUrl}/pypi/simple/`;
+    return `#!/bin/bash
+echo ">>> Configuring pip source..."
+
+# Configure for root user
+mkdir -p /root/.pip
+cat > /root/.pip/pip.conf <<EOF
 [global]
-index-url = ${safeUrl}
-trusted-host = $(echo ${safeUrl} | sed 's|https\\?://||' | cut -d'/' -f1)
-EOF`;
+index-url = ${indexUrl}
+trusted-host = ${trustedHost}
+timeout = 120
+
+[install]
+trusted-host = ${trustedHost}
+EOF
+
+# Configure for other existing users
+for home_dir in /home/*; do
+    if [ -d "$home_dir" ]; then
+        username=$(basename "$home_dir")
+        mkdir -p "$home_dir/.pip"
+        cat > "$home_dir/.pip/pip.conf" <<EOF
+[global]
+index-url = ${indexUrl}
+trusted-host = ${trustedHost}
+timeout = 120
+
+[install]
+trusted-host = ${trustedHost}
+EOF
+        chown -R "$username:$username" "$home_dir/.pip" 2>/dev/null || true
+    fi
+done
+
+echo ">>> pip source configuration completed"
+`;
   }
-  buildGithubSpeedupCommand(ipAddress) {
-    return `echo "${ipAddress} github.com" >> /etc/hosts`;
+  /**
+   * Build GitHub speedup script
+   * Uses script file approach for safety
+   */
+  buildGithubSpeedupScript(ipAddress) {
+    return `#!/bin/bash
+echo ">>> Configuring GitHub hosts for github.com acceleration..."
+
+# Backup original hosts file if not already backed up
+if [ ! -f /etc/hosts.backup ]; then
+    cp /etc/hosts /etc/hosts.backup
+    echo "Hosts file backed up to /etc/hosts.backup"
+fi
+
+# Remove existing github.com entry if any
+sed -i '/github.com$/d' /etc/hosts
+
+# Add new github.com hosts entry
+echo "${ipAddress} github.com" | tee -a /etc/hosts
+
+echo ">>> GitHub hosts configuration completed"
+echo "Current github.com entry in /etc/hosts:"
+grep 'github.com$' /etc/hosts || echo "No github.com entry found"
+`;
   }
 };
 
@@ -1299,16 +1835,6 @@ async function arunWithRetry(sandbox, cmd, session, mode, options = {}) {
   }
   throw lastError ?? new Error(`${errorMsg}: all attempts failed`);
 }
-function extractNohupPid(output) {
-  const PID_PREFIX2 = "__ROCK_PID_START__";
-  const PID_SUFFIX2 = "__ROCK_PID_END__";
-  const pattern = new RegExp(`${PID_PREFIX2}(\\d+)${PID_SUFFIX2}`);
-  const match = output.match(pattern);
-  if (match?.[1]) {
-    return parseInt(match[1], 10);
-  }
-  return null;
-}
 
 // src/sandbox/client.ts
 var logger8 = initLogger("rock.sandbox");
@@ -1415,45 +1941,45 @@ var Sandbox = class extends AbstractSandbox {
     };
     logger8.debug(`Calling start_async API: ${url}`);
     logger8.debug(`Request data: ${JSON.stringify(data)}`);
-    try {
-      const response = await HttpUtils.post(
-        url,
-        headers,
-        data
-      );
-      logger8.debug(`Start sandbox response: ${JSON.stringify(response)}`);
-      if (response.status !== "Success") {
-        throw new Error(`Failed to start sandbox: ${JSON.stringify(response)}`);
-      }
-      this.sandboxId = response.result?.sandboxId ?? null;
-      this.hostName = response.result?.hostName ?? null;
-      this.hostIp = response.result?.hostIp ?? null;
-      logger8.info(`Sandbox ID: ${this.sandboxId}`);
-      await sleep(2e3);
-      const startTime = Date.now();
-      const checkTimeout = 1e4;
-      const checkInterval = 3e3;
-      while (Date.now() - startTime < this.config.startupTimeout * 1e3) {
-        try {
-          logger8.info(`Checking status... (elapsed: ${Math.round((Date.now() - startTime) / 1e3)}s)`);
-          const statusPromise = this.getStatus();
-          const timeoutPromise = new Promise(
-            (_, reject) => setTimeout(() => reject(new Error("Status check timeout")), checkTimeout)
-          );
-          const status = await Promise.race([statusPromise, timeoutPromise]);
-          if (status && status.isAlive) {
-            logger8.info("Sandbox is alive");
-            return;
-          }
-        } catch (e) {
-          logger8.debug(`Status check failed (will retry): ${e}`);
+    const response = await HttpUtils.post(
+      url,
+      headers,
+      data
+    );
+    logger8.debug(`Start sandbox response: ${JSON.stringify(response)}`);
+    if (response.status !== "Success") {
+      const code = response.result?.code;
+      raiseForCode(code, `Failed to start sandbox: ${JSON.stringify(response)}`);
+      throw new Error(`Failed to start sandbox: ${JSON.stringify(response)}`);
+    }
+    this.sandboxId = response.result?.sandboxId ?? null;
+    this.hostName = response.result?.hostName ?? null;
+    this.hostIp = response.result?.hostIp ?? null;
+    logger8.info(`Sandbox ID: ${this.sandboxId}`);
+    await sleep(2e3);
+    const startTime = Date.now();
+    const checkTimeout = 1e4;
+    const checkInterval = 3e3;
+    while (Date.now() - startTime < this.config.startupTimeout * 1e3) {
+      try {
+        logger8.info(`Checking status... (elapsed: ${Math.round((Date.now() - startTime) / 1e3)}s)`);
+        const statusPromise = this.getStatus();
+        const timeoutPromise = new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("Status check timeout")), checkTimeout)
+        );
+        const status = await Promise.race([statusPromise, timeoutPromise]);
+        if (status && status.isAlive) {
+          logger8.info("Sandbox is alive");
+          return;
         }
-        await sleep(checkInterval);
+      } catch (e) {
+        logger8.debug(`Status check failed (will retry): ${e}`);
       }
-      throw new Error(`Failed to start sandbox within ${this.config.startupTimeout}s`);
-    } catch (e) {
-      throw new Error(`Failed to start sandbox: ${e}`);
+      await sleep(checkInterval);
     }
+    throw new InternalServerRockError(
+      `Failed to start sandbox within ${this.config.startupTimeout}s, sandbox: ${this.toString()}`
+    );
   }
   async stop() {
     if (!this.sandboxId) return;
@@ -1468,10 +1994,10 @@ var Sandbox = class extends AbstractSandbox {
   async isAlive() {
     try {
       const status = await this.getStatus();
-      return {
+      return IsAliveResponseSchema.parse({
         isAlive: status.isAlive,
         message: status.hostName ?? ""
-      };
+      });
     } catch (e) {
       throw new Error(`Failed to get is alive: ${e}`);
     }
@@ -1482,9 +2008,11 @@ var Sandbox = class extends AbstractSandbox {
     const response = await HttpUtils.get(url, headers);
     if (response.status !== "Success") {
       const errorDetail = response.error ? `, error=${response.error}` : "";
+      const code = response.result?.code;
+      raiseForCode(code, `Failed to get status: status=${response.status}${errorDetail}, result=${JSON.stringify(response.result)}`);
       throw new Error(`Failed to get status: status=${response.status}${errorDetail}, result=${JSON.stringify(response.result)}`);
     }
-    const result = response.result;
+    const result = SandboxStatusResponseSchema.parse(response.result);
     result.cluster = response.headers["x-rock-gateway-target-cluster"] || this.config.cluster || "N/A";
     result.requestId = response.headers["x-request-id"] || response.headers["request-id"] || "N/A";
     result.eagleeyeTraceid = response.headers["eagleeye-traceid"] || "N/A";
@@ -1501,20 +2029,18 @@ var Sandbox = class extends AbstractSandbox {
       cwd: command.cwd,
       env: command.env
     };
-    try {
-      const response = await HttpUtils.post(
-        url,
-        headers,
-        data
-      );
-      if (response.status !== "Success") {
-        const errorDetail = response.error ? `, error=${response.error}` : "";
-        throw new Error(`Failed to execute command: status=${response.status}${errorDetail}, result=${JSON.stringify(response.result)}`);
-      }
-      return response.result;
-    } catch (e) {
-      throw new Error(`Failed to execute command: ${e}`);
+    const response = await HttpUtils.post(
+      url,
+      headers,
+      data
+    );
+    if (response.status !== "Success") {
+      const errorDetail = response.error ? `, error=${response.error}` : "";
+      const code = response.result?.code;
+      raiseForCode(code, `Failed to execute command: status=${response.status}${errorDetail}, result=${JSON.stringify(response.result)}`);
+      throw new Error(`Failed to execute command: status=${response.status}${errorDetail}, result=${JSON.stringify(response.result)}`);
     }
+    return CommandResponseSchema.parse(response.result);
   }
   // Session management
   async createSession(request) {
@@ -1524,20 +2050,18 @@ var Sandbox = class extends AbstractSandbox {
       sandboxId: this.sandboxId,
       ...request
     };
-    try {
-      const response = await HttpUtils.post(
-        url,
-        headers,
-        data
-      );
-      if (response.status !== "Success") {
-        const errorDetail = response.error ? `, error=${response.error}` : "";
-        throw new Error(`Failed to create session: status=${response.status}${errorDetail}, result=${JSON.stringify(response.result)}`);
-      }
-      return response.result;
-    } catch (e) {
-      throw new Error(`Failed to create session: ${e}`);
+    const response = await HttpUtils.post(
+      url,
+      headers,
+      data
+    );
+    if (response.status !== "Success") {
+      const errorDetail = response.error ? `, error=${response.error}` : "";
+      const code = response.result?.code;
+      raiseForCode(code, `Failed to create session: status=${response.status}${errorDetail}, result=${JSON.stringify(response.result)}`);
+      throw new Error(`Failed to create session: status=${response.status}${errorDetail}, result=${JSON.stringify(response.result)}`);
     }
+    return CreateSessionResponseSchema.parse(response.result);
   }
   async closeSession(request) {
     const url = `${this.url}/close_session`;
@@ -1546,20 +2070,18 @@ var Sandbox = class extends AbstractSandbox {
       sandboxId: this.sandboxId,
       ...request
     };
-    try {
-      const response = await HttpUtils.post(
-        url,
-        headers,
-        data
-      );
-      if (response.status !== "Success") {
-        const errorDetail = response.error ? `, error=${response.error}` : "";
-        throw new Error(`Failed to close session: status=${response.status}${errorDetail}, result=${JSON.stringify(response.result)}`);
-      }
-      return response.result ?? { sessionType: "bash" };
-    } catch (e) {
-      throw new Error(`Failed to close session: ${e}`);
+    const response = await HttpUtils.post(
+      url,
+      headers,
+      data
+    );
+    if (response.status !== "Success") {
+      const errorDetail = response.error ? `, error=${response.error}` : "";
+      const code = response.result?.code;
+      raiseForCode(code, `Failed to close session: status=${response.status}${errorDetail}, result=${JSON.stringify(response.result)}`);
+      throw new Error(`Failed to close session: status=${response.status}${errorDetail}, result=${JSON.stringify(response.result)}`);
     }
+    return CloseSessionResponseSchema.parse(response.result ?? {});
   }
   // Run command in session
   async arun(cmd, options = {}) {
@@ -1570,13 +2092,6 @@ var Sandbox = class extends AbstractSandbox {
     } = options;
     const sessionName = session ?? "default";
     if (mode === "normal") {
-      try {
-        await this.createSession({ session: sessionName, startupSource: [], envEnable: false });
-      } catch (e) {
-        if (String(e).includes("already exists")) ; else {
-          throw e;
-        }
-      }
       return this.runInSession({ command: cmd, session: sessionName, timeout });
     }
     return this.arunWithNohup(cmd, options);
@@ -1591,22 +2106,20 @@ var Sandbox = class extends AbstractSandbox {
       sandboxId: this.sandboxId,
       timeout: action.timeout
     };
-    try {
-      const timeoutMs = action.timeout ? action.timeout * 1e3 : void 0;
-      const response = await HttpUtils.post(
-        url,
-        headers,
-        data,
-        timeoutMs
-      );
-      if (response.status !== "Success") {
-        const errorDetail = response.error ? `, error=${response.error}` : "";
-        throw new Error(`Failed to run in session: status=${response.status}${errorDetail}, result=${JSON.stringify(response.result)}`);
-      }
-      return response.result;
-    } catch (e) {
-      throw new Error(`Failed to run in session: ${e}`);
+    const timeoutMs = action.timeout ? action.timeout * 1e3 : void 0;
+    const response = await HttpUtils.post(
+      url,
+      headers,
+      data,
+      timeoutMs
+    );
+    if (response.status !== "Success") {
+      const errorDetail = response.error ? `, error=${response.error}` : "";
+      const code = response.result?.code;
+      raiseForCode(code, `Failed to run in session: status=${response.status}${errorDetail}, result=${JSON.stringify(response.result)}`);
+      throw new Error(`Failed to run in session: status=${response.status}${errorDetail}, result=${JSON.stringify(response.result)}`);
     }
+    return ObservationSchema.parse(response.result);
   }
   async arunWithNohup(cmd, options) {
     const {
@@ -1618,13 +2131,12 @@ var Sandbox = class extends AbstractSandbox {
       outputFile
     } = options;
     const timestamp = Date.now();
-    const tmpSession = session ?? `bash-${timestamp}`;
-    try {
+    let tmpSession;
+    if (session === void 0 || session === null) {
+      tmpSession = `bash-${timestamp}`;
       await this.createSession({ session: tmpSession, startupSource: [], envEnable: false });
-    } catch (e) {
-      if (!String(e).includes("already exists")) {
-        throw e;
-      }
+    } else {
+      tmpSession = session;
     }
     const tmpFile = outputFile ?? `/tmp/tmp_${timestamp}.out`;
     const nohupCommand = `nohup ${cmd} < /dev/null > ${tmpFile} 2>&1 & echo __ROCK_PID_START__$!__ROCK_PID_END__;disown`;
@@ -1717,7 +2229,7 @@ var Sandbox = class extends AbstractSandbox {
       headers,
       data
     );
-    return { content: response.result?.content ?? "" };
+    return ReadFileResponseSchema.parse(response.result ?? {});
   }
   // Upload
   async upload(request) {
@@ -1727,11 +2239,13 @@ var Sandbox = class extends AbstractSandbox {
     const url = `${this.url}/upload`;
     const headers = this.buildHeaders();
     try {
-      const fs = await import('fs');
-      if (!fs.existsSync(sourcePath)) {
+      const fs = await import('fs/promises');
+      try {
+        await fs.access(sourcePath);
+      } catch {
         return { success: false, message: `File not found: ${sourcePath}` };
       }
-      const fileBuffer = fs.readFileSync(sourcePath);
+      const fileBuffer = await fs.readFile(sourcePath);
       const fileName = sourcePath.split("/").pop() ?? "file";
       const response = await HttpUtils.postMultipart(
         url,
@@ -1801,6 +2315,7 @@ var SandboxGroup = class {
   }
 };
 var logger9 = initLogger("rock.model.client");
+var DEFAULT_POLL_TIMEOUT = 60;
 var REQUEST_START_MARKER = "__REQUEST_START__";
 var REQUEST_END_MARKER = "__REQUEST_END__";
 var RESPONSE_START_MARKER = "__RESPONSE_START__";
@@ -1838,7 +2353,7 @@ var ModelClient = class {
     const content = this.constructResponse(lastResponse, index);
     const lastResponseLine = await this.readLastResponseLine();
     if (lastResponseLine === null) {
-      this.appendResponse(content);
+      await this.appendResponse(content);
       return;
     }
     const { meta } = this.parseResponseLine(lastResponseLine);
@@ -1850,42 +2365,77 @@ var ModelClient = class {
       logger9.debug(`response index ${index} already exists, skip`);
       return;
     }
-    this.appendResponse(content);
+    await this.appendResponse(content);
   }
   /**
    * Pop request from log file
+   *
+   * @param index - The index of the request to pop
+   * @param options - Optional configuration for timeout and cancellation
+   * @returns The request JSON string or SESSION_END_MARKER
+   * @throws Error if timeout expires or operation is aborted
    */
-  // eslint-disable-next-line no-constant-condition
-  async popRequest(index) {
+  async popRequest(index, options) {
+    const timeout = options?.timeout ?? DEFAULT_POLL_TIMEOUT;
+    const startTime = Date.now();
     while (true) {
-      const lastRequestLine = await this.readLastRequestLine();
-      const { requestJson, meta } = this.parseRequestLine(lastRequestLine);
-      if (requestJson === SESSION_END_MARKER) {
-        return SESSION_END_MARKER;
+      if (options?.signal?.aborted) {
+        throw new Error(`popRequest(index=${index}) aborted`);
       }
-      if (meta.index === index) {
-        return requestJson;
+      if ((Date.now() - startTime) / 1e3 > timeout) {
+        throw new Error(`popRequest timed out after ${timeout} seconds`);
+      }
+      try {
+        const lastRequestLine = await this.readLastRequestLine();
+        const { requestJson, meta } = this.parseRequestLine(lastRequestLine);
+        if (requestJson === SESSION_END_MARKER) {
+          return SESSION_END_MARKER;
+        }
+        if (meta.index === index) {
+          return requestJson;
+        }
+        logger9.debug(`Last request is not the index ${index} we want, waiting...`);
+        await sleep(1e3);
+      } catch (e) {
+        if (e instanceof Error) {
+          if (e.message.includes("aborted")) {
+            throw e;
+          }
+          if (e.message.includes("Invalid request line format")) {
+            throw e;
+          }
+        }
+        logger9.debug(`Error reading request: ${e}, waiting...`);
+        await sleep(1e3);
       }
-      logger9.debug(`Last request is not the index ${index} we want, waiting...`);
-      await this.sleep(1e3);
     }
   }
   /**
    * Wait for first request
+   *
+   * @param options - Optional configuration for timeout and cancellation
+   * @throws Error if timeout expires or operation is aborted
    */
-  // eslint-disable-next-line no-constant-condition
-  async waitForFirstRequest() {
+  async waitForFirstRequest(options) {
+    const timeout = options?.timeout ?? DEFAULT_POLL_TIMEOUT;
+    const startTime = Date.now();
     while (true) {
+      if (options?.signal?.aborted) {
+        throw new Error("waitForFirstRequest aborted");
+      }
+      if ((Date.now() - startTime) / 1e3 > timeout) {
+        throw new Error(`waitForFirstRequest timed out after ${timeout} seconds`);
+      }
       if (!fs.existsSync(this.logFile)) {
         logger9.debug(`Log file ${this.logFile} not found, waiting...`);
-        await this.sleep(1e3);
+        await sleep(1e3);
         continue;
       }
-      const content = fs.readFileSync(this.logFile, "utf-8");
+      const content = await promises.readFile(this.logFile, "utf-8");
       const lines = content.split("\n").filter((l) => l.trim());
       if (lines.length === 0) {
         logger9.debug(`Log file ${this.logFile} is empty, waiting for the first request...`);
-        await this.sleep(1e3);
+        await sleep(1e3);
         continue;
       }
       return;
@@ -1895,21 +2445,31 @@ var ModelClient = class {
     if (lineContent.includes(SESSION_END_MARKER)) {
       return { requestJson: SESSION_END_MARKER, meta: {} };
     }
-    const parts = lineContent.split(REQUEST_END_MARKER);
-    const metaJson = parts[1] ?? "";
-    const requestJson = parts[0]?.split(REQUEST_START_MARKER)[1] ?? "";
-    const meta = JSON.parse(metaJson);
-    return { requestJson, meta };
+    try {
+      const parts = lineContent.split(REQUEST_END_MARKER);
+      const metaJson = parts[1] ?? "";
+      const requestJson = parts[0]?.split(REQUEST_START_MARKER)[1] ?? "";
+      const meta = JSON.parse(metaJson);
+      return { requestJson, meta };
+    } catch (e) {
+      logger9.error(`Failed to parse request line: ${lineContent}, error: ${e}`);
+      throw new Error(`Invalid request line format: ${e}`);
+    }
   }
   parseResponseLine(lineContent) {
-    const parts = lineContent.split(RESPONSE_END_MARKER);
-    const metaJson = parts[1] ?? "";
-    const responseJson = parts[0]?.split(RESPONSE_START_MARKER)[1] ?? "";
-    const meta = JSON.parse(metaJson);
-    return { responseJson, meta };
+    try {
+      const parts = lineContent.split(RESPONSE_END_MARKER);
+      const metaJson = parts[1] ?? "";
+      const responseJson = parts[0]?.split(RESPONSE_START_MARKER)[1] ?? "";
+      const meta = JSON.parse(metaJson);
+      return { responseJson, meta };
+    } catch (e) {
+      logger9.error(`Failed to parse response line: ${lineContent}, error: ${e}`);
+      throw new Error(`Invalid response line format: ${e}`);
+    }
   }
   async readLastRequestLine() {
-    const content = fs.readFileSync(this.logFile, "utf-8");
+    const content = await promises.readFile(this.logFile, "utf-8");
     const lines = content.split("\n").filter((l) => l.trim());
     for (let i = lines.length - 1; i >= 0; i--) {
       const line = lines[i];
@@ -1920,7 +2480,7 @@ var ModelClient = class {
     throw new Error(`No request found in log file ${this.logFile}`);
   }
   async readLastResponseLine() {
-    const content = fs.readFileSync(this.logFile, "utf-8");
+    const content = await promises.readFile(this.logFile, "utf-8");
     const lines = content.split("\n").filter((l) => l.trim());
     for (let i = lines.length - 1; i >= 0; i--) {
       const line = lines[i];
@@ -1930,8 +2490,8 @@ var ModelClient = class {
     }
     return null;
   }
-  appendResponse(content) {
-    fs.appendFileSync(this.logFile, content);
+  async appendResponse(content) {
+    await promises.appendFile(this.logFile, content);
   }
   constructResponse(lastResponse, index) {
     const meta = {
@@ -1942,114 +2502,711 @@ var ModelClient = class {
     return `${RESPONSE_START_MARKER}${lastResponse}${RESPONSE_END_MARKER}${metaJson}
 `;
   }
-  sleep(ms) {
-    return new Promise((resolve3) => setTimeout(resolve3, ms));
-  }
 };
-var ModelService = class {
-  process = null;
+var RuntimeEnvConfigSchema = zod.z.object({
+  /** Runtime type discriminator. */
+  type: zod.z.string(),
+  /** Runtime version. Use 'default' for the default version of each runtime. */
+  version: zod.z.string().default("default"),
+  /** Environment variables for the runtime session. */
+  env: zod.z.record(zod.z.string()).default({}),
+  /** Timeout in seconds for installation commands. */
+  installTimeout: zod.z.number().int().positive().default(600),
+  /** Custom install command to run after init. */
+  customInstallCmd: zod.z.string().nullable().default(null),
+  /** Directory to create symlinks of executables. If null, no symlinks are created. */
+  extraSymlinkDir: zod.z.string().nullable().default(null),
+  /** List of executable names to symlink. Empty list means no symlinks. */
+  extraSymlinkExecutables: zod.z.array(zod.z.string()).default([])
+});
+var logger10 = initLogger("rock.sandbox.runtime_env");
+function createRuntimeEnvId() {
+  return crypto.randomUUID().slice(0, 8);
+}
+var RUNTIME_ENV_REGISTRY = {};
+var RuntimeEnv = class {
+  /** Registry for subclasses */
+  static registry = RUNTIME_ENV_REGISTRY;
+  /** Sandbox instance */
+  _sandbox;
+  /** Configuration */
+  _config;
+  /** Version */
+  _version;
+  /** Environment variables */
+  _env;
+  /** Install timeout in seconds */
+  _installTimeout;
+  /** Custom install command */
+  _customInstallCmd;
+  /** Extra symlink directory */
+  _extraSymlinkDir;
+  /** Extra symlink executables */
+  _extraSymlinkExecutables;
+  /** Unique ID for this runtime env instance */
+  _runtimeEnvId;
+  /** Working directory */
+  _workdir;
+  /** Session name */
+  _session;
+  /** Whether the runtime has been initialized */
+  _initialized = false;
+  /** Whether the session is ready */
+  _sessionReady = false;
+  constructor(sandbox, config) {
+    this._sandbox = sandbox;
+    this._config = config;
+    this._version = config.version;
+    this._env = config.env;
+    this._installTimeout = config.installTimeout;
+    this._customInstallCmd = config.customInstallCmd;
+    this._extraSymlinkDir = config.extraSymlinkDir;
+    this._extraSymlinkExecutables = config.extraSymlinkExecutables;
+    this._runtimeEnvId = createRuntimeEnvId();
+    const versionStr = this._version || "default";
+    this._workdir = `/tmp/rock-runtime-envs/${config.type}/${versionStr}/${this._runtimeEnvId}`;
+    this._session = `runtime-env-${config.type}-${versionStr}-${this._runtimeEnvId}`;
+  }
+  /** Whether the runtime has been initialized */
+  get initialized() {
+    return this._initialized;
+  }
+  /** Unique ID for this runtime env instance */
+  get runtimeEnvId() {
+    return this._runtimeEnvId;
+  }
+  /** Working directory for this runtime env instance */
+  get workdir() {
+    return this._workdir;
+  }
+  /** Binary directory for this runtime env instance */
+  get binDir() {
+    return `${this._workdir}/runtime-env/bin`;
+  }
   /**
-   * Start sandbox service
+   * Initialize the runtime environment.
+   * This method performs installation and validation.
+   * It is idempotent: calling multiple times only initializes once.
    */
-  startSandboxService(config = {}) {
-    const {
-      modelServiceType = "local",
-      configFile,
-      host,
-      port,
-      proxyBaseUrl,
-      retryableStatusCodes,
-      requestTimeout
-    } = config;
-    const cmd = ["node", "main.js", "--type", modelServiceType];
-    if (configFile) {
-      cmd.push("--config-file", configFile);
-    }
-    if (host) {
-      cmd.push("--host", host);
-    }
-    if (port) {
-      cmd.push("--port", String(port));
-    }
-    if (proxyBaseUrl) {
-      cmd.push("--proxy-base-url", proxyBaseUrl);
-    }
-    if (retryableStatusCodes) {
-      cmd.push("--retryable-status-codes", retryableStatusCodes);
-    }
-    if (requestTimeout) {
-      cmd.push("--request-timeout", String(requestTimeout));
-    }
-    const command = cmd[0] ?? "node";
-    this.process = child_process.spawn(command, cmd.slice(1), {
-      cwd: path.resolve(__dirname, "server"),
-      stdio: "inherit"
+  async init() {
+    if (this._initialized) {
+      return;
+    }
+    await this._ensureSession();
+    await this._ensureWorkdir();
+    await this._installRuntime();
+    await this._postInit();
+    if (this._customInstallCmd) {
+      await this._doCustomInstall();
+    }
+    await this._createSysPathLinks();
+    this._initialized = true;
+  }
+  /**
+   * Run a command under this runtime
+   */
+  async run(cmd, options = {}) {
+    const { mode = "nohup", waitTimeout = 600, errorMsg = "runtime env command failed" } = options;
+    await this._ensureSession();
+    const wrapped = this.wrappedCmd(cmd, true);
+    logger10.debug(`[${this._sandbox.sandboxId}] RuntimeEnv run cmd: ${wrapped}`);
+    const result = await this._sandbox.arun(wrapped, {
+      session: this._session,
+      mode,
+      waitTimeout
     });
-    if (!this.process) {
-      throw new Error("Failed to spawn model service process");
+    if (result.exitCode !== void 0 && result.exitCode !== 0) {
+      throw new Error(`${errorMsg} with exit code: ${result.exitCode}, output: ${result.output}`);
     }
-    return this.process;
+    return result;
   }
   /**
-   * Start and wait for service to be available
+   * Wrap command with PATH export.
+   * Always wrap with bash -c to ensure it only affects current cmd.
+   * Default prepend=true to give current runtime_env highest priority.
    */
-  async start(config = {}) {
-    const { timeoutSeconds = 30, ...serviceConfig } = config;
-    const process2 = this.startSandboxService(serviceConfig);
-    const pid = process2.pid?.toString();
-    if (!pid) {
-      throw new Error("Failed to start model service");
+  wrappedCmd(cmd, prepend = true) {
+    const binDir = this.binDir;
+    let wrapped;
+    if (prepend) {
+      wrapped = `export PATH='${binDir}':$PATH && ${cmd}`;
+    } else {
+      wrapped = `export PATH=$PATH:'${binDir}' && ${cmd}`;
+    }
+    return `bash -c '${wrapped.replace(/'/g, `'"'"'`)}'`;
+  }
+  /**
+   * Ensure runtime env session exists. Safe to call multiple times.
+   */
+  async _ensureSession() {
+    if (this._sessionReady) {
+      return;
+    }
+    await this._sandbox.createSession({
+      session: this._session,
+      envEnable: true,
+      env: this._env
+    });
+    this._sessionReady = true;
+  }
+  /**
+   * Create workdir for runtime environment.
+   */
+  async _ensureWorkdir() {
+    const result = await this._sandbox.arun(`mkdir -p ${this._workdir}`, {
+      session: this._session
+    });
+    if (result.exitCode !== void 0 && result.exitCode !== 0) {
+      throw new Error(`Failed to create workdir: ${this._workdir}, exit_code: ${result.exitCode}`);
     }
-    const success = await this.waitServiceAvailable(
-      timeoutSeconds,
-      serviceConfig.host ?? "127.0.0.1",
-      serviceConfig.port ?? 8080
+  }
+  /**
+   * Install the runtime environment.
+   */
+  async _installRuntime() {
+    const installCmd = `cd '${this._workdir}' && ${this._getInstallCmd()}`;
+    const wrappedCmd = `bash -c '${installCmd.replace(/'/g, `'"'"'`)}'`;
+    const result = await this._sandbox.arun(wrappedCmd, {
+      session: this._session,
+      mode: "nohup",
+      waitTimeout: this._installTimeout
+    });
+    if (result.exitCode !== void 0 && result.exitCode !== 0) {
+      throw new Error(
+        `${this.runtimeEnvType} runtime installation failed with exit code: ${result.exitCode}, output: ${result.output}`
+      );
+    }
+  }
+  /**
+   * Additional initialization after runtime installation.
+   * Override in subclasses.
+   */
+  async _postInit() {
+  }
+  /**
+   * Execute custom install command after _postInit.
+   */
+  async _doCustomInstall() {
+    if (!this._customInstallCmd) {
+      return;
+    }
+    await this.run(this._customInstallCmd, {
+      waitTimeout: this._installTimeout,
+      errorMsg: "custom_install_cmd failed"
+    });
+  }
+  /**
+   * Create symlinks in target directory for executables.
+   */
+  async _createSysPathLinks() {
+    if (this._extraSymlinkDir === null) {
+      return;
+    }
+    if (this._extraSymlinkExecutables.length === 0) {
+      return;
+    }
+    const links = this._extraSymlinkExecutables.map((exe) => `ln -sf '${this.binDir}/${exe}' '${this._extraSymlinkDir}/${exe}'`).join(" && ");
+    await this.run(links);
+  }
+};
+
+// src/sandbox/runtime_env/python_runtime_env.ts
+var PythonRuntimeEnvConfigSchema = RuntimeEnvConfigSchema.extend({
+  /** Runtime type discriminator. Must be 'python'. */
+  type: zod.z.literal("python").default("python"),
+  /** Python version. Use "default" for 3.11. */
+  version: zod.z.enum(["3.11", "3.12", "default"]).default("default"),
+  /**
+   * Pip packages to install.
+   * Can be:
+   * - string[]: List of package names to install
+   * - string: Path to requirements.txt file
+   * - null: No packages to install
+   */
+  pip: zod.z.union([zod.z.array(zod.z.string()), zod.z.string()]).nullable().default(null),
+  /** Pip index URL for package installation. If set, will use this mirror. */
+  pipIndexUrl: zod.z.string().nullable().default(null),
+  /** List of Python executables to symlink. */
+  extraSymlinkExecutables: zod.z.array(zod.z.string()).default(["python", "python3", "pip", "pip3"])
+});
+function getDefaultPipIndexUrl() {
+  return envVars.ROCK_PIP_INDEX_URL;
+}
+var PythonRuntimeEnv = class extends RuntimeEnv {
+  runtimeEnvType = "python";
+  _pip;
+  _pipIndexUrl;
+  constructor(sandbox, config) {
+    if (config.version !== "3.11" && config.version !== "3.12" && config.version !== "default") {
+      throw new Error(
+        `Unsupported Python version: ${config.version}. Supported versions: 3.11, 3.12, default`
+      );
+    }
+    super(sandbox, config);
+    this._pip = config.pip;
+    this._pipIndexUrl = config.pipIndexUrl;
+  }
+  _getInstallCmd() {
+    const version = this._version;
+    if (version === "3.11" || version === "default") {
+      return envVars.ROCK_RTENV_PYTHON_V31114_INSTALL_CMD;
+    }
+    return envVars.ROCK_RTENV_PYTHON_V31212_INSTALL_CMD;
+  }
+  async _postInit() {
+    await this._validatePython();
+    if (this._pipIndexUrl) {
+      await this._configurePip();
+    }
+    if (this._pip) {
+      await this._installPip();
+    }
+  }
+  async _validatePython() {
+    await this.run("test -x python");
+  }
+  async _configurePip() {
+    const escapedUrl = this._pipIndexUrl.replace(/'/g, "'\\''");
+    await this.run(`pip config set global.index-url '${escapedUrl}'`);
+  }
+  async _installPip() {
+    if (!this._pip) {
+      return;
+    }
+    if (typeof this._pip === "string") {
+      await this.run(`pip install -r '${this._pip.replace(/'/g, "'\\''")}'`);
+    } else {
+      const packages = this._pip.map((pkg) => `'${pkg.replace(/'/g, "'\\''")}'`).join(" ");
+      await this.run(`pip install ${packages}`);
+    }
+  }
+};
+var NODE_DEFAULT_VERSION = "22.18.0";
+var NodeRuntimeEnvConfigSchema = RuntimeEnvConfigSchema.extend({
+  /** Runtime type discriminator. Must be 'node'. */
+  type: zod.z.literal("node").default("node"),
+  /** Node.js version. Use "default" for 22.18.0. */
+  version: zod.z.enum(["22.18.0", "default"]).default("default"),
+  /** NPM registry URL. If set, will run 'npm config set registry <url>' during init. */
+  npmRegistry: zod.z.string().nullable().default(null),
+  /** List of Node.js executables to symlink. */
+  extraSymlinkExecutables: zod.z.array(zod.z.string()).default(["node", "npm", "npx"])
+});
+var NodeRuntimeEnv = class extends RuntimeEnv {
+  runtimeEnvType = "node";
+  _npmRegistry;
+  constructor(sandbox, config) {
+    if (config.version !== "default" && config.version !== NODE_DEFAULT_VERSION) {
+      throw new Error(
+        `Unsupported Node version: ${config.version}. Only ${NODE_DEFAULT_VERSION} is supported right now.`
+      );
+    }
+    super(sandbox, config);
+    this._npmRegistry = config.npmRegistry;
+  }
+  _getInstallCmd() {
+    return envVars.ROCK_RTENV_NODE_V22180_INSTALL_CMD;
+  }
+  async _postInit() {
+    await this._validateNode();
+    if (this._npmRegistry) {
+      await this._configureNpmRegistry();
+    }
+  }
+  async _validateNode() {
+    await this.run("test -x node");
+  }
+  async _configureNpmRegistry() {
+    const escapedRegistry = this._npmRegistry.replace(/'/g, "'\\''");
+    await this.run(`npm config set registry '${escapedRegistry}'`);
+  }
+};
+var logger11 = initLogger("rock.model_service");
+var ModelServiceConfigSchema = zod.z.object({
+  /** Whether to enable model service */
+  enabled: zod.z.boolean().default(false),
+  /** Type of model service to start */
+  type: zod.z.string().default("local"),
+  /** Command to install model service package */
+  installCmd: zod.z.string().default(envVars.ROCK_MODEL_SERVICE_INSTALL_CMD),
+  /** Timeout for model service installation in seconds */
+  installTimeout: zod.z.number().positive().default(300),
+  /** Runtime environment configuration for the model service */
+  runtimeEnvConfig: PythonRuntimeEnvConfigSchema.default({ type: "python", version: "default" }),
+  /** Command to start model service with type placeholder */
+  startCmd: zod.z.string().default("rock model-service start --type ${type}"),
+  /** Command to stop model service */
+  stopCmd: zod.z.string().default("rock model-service stop"),
+  /** Command to create Rock config file */
+  configIniCmd: zod.z.string().default("mkdir -p ~/.rock && touch ~/.rock/config.ini"),
+  /** Command to watch agent with pid placeholder */
+  watchAgentCmd: zod.z.string().default("rock model-service watch-agent --pid ${pid}"),
+  /** Command to anti-call LLM with index and response_payload placeholders */
+  antiCallLlmCmd: zod.z.string().default(
+    "rock model-service anti-call-llm --index ${index} --response ${response_payload}"
+  ),
+  /** Command to anti-call LLM with only index placeholder */
+  antiCallLlmCmdNoResponse: zod.z.string().default("rock model-service anti-call-llm --index ${index}"),
+  /** Path for logging directory */
+  loggingPath: zod.z.string().default("/data/logs"),
+  /** Name of the log file */
+  loggingFileName: zod.z.string().default("model_service.log")
+});
+var ModelService = class {
+  _sandbox;
+  _config;
+  _runtimeEnv = null;
+  _isInstalled = false;
+  _isStarted = false;
+  constructor(sandbox, config) {
+    this._sandbox = sandbox;
+    this._config = config;
+  }
+  /** Whether the model service has been installed */
+  get isInstalled() {
+    return this._isInstalled;
+  }
+  /** Whether the model service has been started */
+  get isStarted() {
+    return this._isStarted;
+  }
+  /**
+   * Install model service in the sandbox.
+   *
+   * Performs the following installation steps:
+   * 1. Create and initialize Python runtime environment (via RuntimeEnv).
+   * 2. Install model service package.
+   */
+  async install() {
+    if (this._config.runtimeEnvConfig.type !== "python") {
+      throw new Error("ModelService requires a Python runtime environment");
+    }
+    const runtimeConfigResult = PythonRuntimeEnvConfigSchema.safeParse(this._config.runtimeEnvConfig);
+    if (!runtimeConfigResult.success) {
+      throw new Error(`Invalid runtime config: ${runtimeConfigResult.error.message}`);
+    }
+    this._runtimeEnv = new PythonRuntimeEnv(
+      this._sandbox,
+      runtimeConfigResult.data
     );
-    if (!success) {
-      await this.stop(pid);
-      throw new Error("Model service start failed");
+    await this._runtimeEnv.init();
+    await this._createRockConfig();
+    await this._installModelService();
+    this._isInstalled = true;
+  }
+  async _createRockConfig() {
+    if (!this._runtimeEnv) {
+      throw new Error("Runtime environment not initialized");
+    }
+    await this._runtimeEnv.run(this._config.configIniCmd);
+  }
+  async _installModelService() {
+    if (!this._runtimeEnv) {
+      throw new Error("Runtime environment not initialized");
     }
-    return pid;
+    const installCmd = `cd ${this._runtimeEnv.workdir} && ${this._config.installCmd}`;
+    await this._runtimeEnv.run(installCmd, {
+      waitTimeout: this._config.installTimeout,
+      errorMsg: "Model service installation failed"
+    });
   }
   /**
-   * Start watching agent
+   * Start the model service in the sandbox.
+   *
+   * Starts the service with configured logging settings.
    */
-  async startWatchAgent(agentPid, host = "127.0.0.1", port = 8080) {
-    await axios3__default.default.post(`http://${host}:${port}/v1/agent/watch`, { pid: agentPid });
+  async start() {
+    if (!this._isInstalled) {
+      throw new Error(
+        `[${this._sandbox.sandboxId}] Cannot start model service: ModelService has not been installed yet. Please call install() first.`
+      );
+    }
+    if (!this._runtimeEnv) {
+      throw new Error("Runtime environment not initialized");
+    }
+    const startCmd = this._config.startCmd.replace(/\$\{type\}/g, this._config.type);
+    const bashStartCmd = `export ROCK_LOGGING_PATH=${this._config.loggingPath} && export ROCK_LOGGING_FILE_NAME=${this._config.loggingFileName} && ${this._config.stopCmd} && ` + startCmd;
+    logger11.debug(`[${this._sandbox.sandboxId}] Model service Start command: ${bashStartCmd}`);
+    await this._runtimeEnv.run(bashStartCmd);
+    this._isStarted = true;
   }
   /**
-   * Stop service
+   * Stop the model service.
    */
-  async stop(pid) {
-    const { execSync } = await import('child_process');
-    try {
-      execSync(`kill -9 ${pid}`);
-    } catch {
+  async stop() {
+    if (!this._isStarted) {
+      logger11.warn(
+        `[${this._sandbox.sandboxId}] Model service is not running, skipping stop operation. is_started=${this._isStarted}`
+      );
+      return;
     }
+    if (!this._runtimeEnv) {
+      throw new Error("Runtime environment not initialized");
+    }
+    await this._runtimeEnv.run(this._config.stopCmd);
+    this._isStarted = false;
   }
   /**
-   * Wait for service to be available
+   * Watch agent process with the specified PID.
    */
-  async waitServiceAvailable(timeoutSeconds, host, port) {
-    const startTime = Date.now();
-    while ((Date.now() - startTime) / 1e3 < timeoutSeconds) {
-      try {
-        await axios3__default.default.get(`http://${host}:${port}/health`);
-        return true;
-      } catch {
-        await this.sleep(1e3);
+  async watchAgent(pid) {
+    if (!this._isStarted) {
+      throw new Error(
+        `[${this._sandbox.sandboxId}] Cannot watch agent: ModelService is not started. Please call start() first.`
+      );
+    }
+    if (!this._runtimeEnv) {
+      throw new Error("Runtime environment not initialized");
+    }
+    const watchCmd = this._config.watchAgentCmd.replace(/\$\{pid\}/g, pid);
+    logger11.debug(
+      `[${this._sandbox.sandboxId}] Model service watch agent with pid=${pid}, cmd: ${watchCmd}`
+    );
+    await this._runtimeEnv.run(watchCmd);
+  }
+  /**
+   * Execute anti-call LLM command.
+   */
+  async antiCallLlm(index, responsePayload, callTimeout = 600) {
+    if (!this._isStarted) {
+      throw new Error(
+        `[${this._sandbox.sandboxId}] Cannot execute anti-call LLM: ModelService is not started. Please call start() first.`
+      );
+    }
+    if (!this._runtimeEnv) {
+      throw new Error("Runtime environment not initialized");
+    }
+    logger11.info(
+      `[${this._sandbox.sandboxId}] Executing anti-call LLM: index=${index}, has_response=${responsePayload !== void 0}, timeout=${callTimeout}s`
+    );
+    let cmd;
+    if (responsePayload !== void 0) {
+      const escapedPayload = `'${responsePayload.replace(/'/g, "'\\''")}'`;
+      cmd = this._config.antiCallLlmCmd.replace(/\$\{index\}/g, String(index)).replace(/\$\{response_payload\}/g, escapedPayload);
+    } else {
+      cmd = this._config.antiCallLlmCmdNoResponse.replace(/\$\{index\}/g, String(index));
+    }
+    const bashCmd = this._runtimeEnv.wrappedCmd(cmd);
+    logger11.debug(`[${this._sandbox.sandboxId}] Executing command: ${bashCmd}`);
+    const result = await this._sandbox.arun(bashCmd, {
+      mode: "nohup",
+      waitTimeout: callTimeout,
+      waitInterval: 3
+    });
+    if (result.exitCode !== 0) {
+      throw new Error(`Anti-call LLM command failed: ${result.output}`);
+    }
+    return result.output;
+  }
+};
+
+// src/sandbox/agent/base.ts
+var logger12 = initLogger("rock.agent");
+var Agent = class {
+  _sandbox;
+  _modelService = null;
+  constructor(sandbox) {
+    this._sandbox = sandbox;
+  }
+  get sandbox() {
+    return this._sandbox;
+  }
+  get modelService() {
+    return this._modelService;
+  }
+};
+var DefaultAgent = class extends Agent {
+  _config = null;
+  _agentSession = null;
+  get config() {
+    return this._config;
+  }
+  get agentSession() {
+    return this._agentSession;
+  }
+  get modelService() {
+    return this._modelService;
+  }
+  async install(config) {
+    this._config = config;
+    this._agentSession = config.agentSession;
+    const sandboxId = this._sandbox.sandboxId;
+    logger12.info(`[${sandboxId}] Starting agent initialization`);
+    try {
+      await this._setupSession();
+      await this._executeInitCommands(config.preInitCmds, "pre-init");
+      await this._executeInitCommands(config.postInitCmds, "post-init");
+      logger12.info(`[${sandboxId}] Agent initialization completed`);
+    } catch (e) {
+      const error = e;
+      logger12.error(`[${sandboxId}] Agent initialization failed: ${error.message}`);
+      throw error;
+    }
+  }
+  async run(prompt) {
+    if (!this._config) {
+      throw new Error("Agent is not installed. Please call install() first.");
+    }
+    if (!this._config.runCmd) {
+      throw new Error("runCmd is not configured");
+    }
+    const cmd = await this._createAgentRunCmd(prompt);
+    return this._agentRun(cmd);
+  }
+  async _setupSession() {
+    if (!this._config) return;
+    const sandboxId = this._sandbox.sandboxId;
+    logger12.info(`[${sandboxId}] Creating bash session: ${this._agentSession}`);
+    await this._sandbox.createSession({
+      session: this._agentSession,
+      envEnable: true,
+      env: this._config.env
+    });
+    logger12.info(`[${sandboxId}] Bash session '${this._agentSession}' created successfully`);
+  }
+  async _executeInitCommands(cmdList, stepName) {
+    if (!cmdList || cmdList.length === 0) return;
+    const sandboxId = this._sandbox.sandboxId;
+    logger12.info(`[${sandboxId}] ${stepName} started: Executing ${cmdList.length} commands`);
+    for (let idx = 0; idx < cmdList.length; idx++) {
+      const cmdConfig = cmdList[idx];
+      if (!cmdConfig) continue;
+      const command = cmdConfig.command;
+      const timeout = cmdConfig.timeoutSeconds;
+      logger12.debug(
+        `[${sandboxId}] Executing ${stepName} command ${idx + 1}/${cmdList.length}: ${command.substring(0, 100)}...`
+      );
+      const result = await this._sandbox.arun(`bash -c ${JSON.stringify(command)}`, {
+        waitTimeout: timeout,
+        mode: "NOHUP"
+      });
+      if (result.exitCode !== 0) {
+        throw new Error(
+          `[${sandboxId}] ${stepName} command ${idx + 1} failed with exit code ${result.exitCode}: ${result.output.substring(0, 200)}`
+        );
       }
+      logger12.debug(`[${sandboxId}] ${stepName} command ${idx + 1} completed successfully`);
     }
-    return false;
+    logger12.info(`[${sandboxId}] ${stepName} completed: Completed ${cmdList.length} commands`);
   }
-  sleep(ms) {
-    return new Promise((resolve3) => setTimeout(resolve3, ms));
+  async _createAgentRunCmd(prompt) {
+    if (!this._config || !this._config.runCmd) {
+      throw new Error("runCmd is not configured");
+    }
+    let runCmd = this._config.runCmd.replace(/{prompt}/g, JSON.stringify(prompt));
+    if (this._config.skipWrapRunCmd) {
+      return `bash -c ${JSON.stringify(runCmd)}`;
+    }
+    return `bash -c ${JSON.stringify(runCmd)}`;
+  }
+  async _agentRun(cmd) {
+    const sandboxId = this._sandbox.sandboxId;
+    try {
+      const timestamp = Date.now().toString();
+      const tmpFile = `/tmp/tmp_${timestamp}.out`;
+      if (!this._sandbox.startNohupProcess) {
+        const msg = "startNohupProcess method is not available on sandbox";
+        return { output: msg, exitCode: 1, failureReason: msg, expectString: "" };
+      }
+      const { pid, errorResponse } = await this._sandbox.startNohupProcess(cmd, tmpFile, this._agentSession);
+      if (errorResponse) {
+        return errorResponse;
+      }
+      if (!pid) {
+        const msg = "Failed to submit command, nohup failed to extract PID";
+        return { output: msg, exitCode: 1, failureReason: msg, expectString: "" };
+      }
+      logger12.info(`[${sandboxId}] Agent process started with PID: ${pid}`);
+      if (!this._sandbox.waitForProcessCompletion) {
+        const msg = "waitForProcessCompletion method is not available on sandbox";
+        return { output: msg, exitCode: 1, failureReason: msg, expectString: "" };
+      }
+      const { success, message } = await this._sandbox.waitForProcessCompletion(
+        pid,
+        this._agentSession,
+        this._config.agentRunTimeout,
+        this._config.agentRunCheckInterval
+      );
+      if (!this._sandbox.handleNohupOutput) {
+        const msg = "handleNohupOutput method is not available on sandbox";
+        return { output: msg, exitCode: 1, failureReason: msg, expectString: "" };
+      }
+      const result = await this._sandbox.handleNohupOutput(tmpFile, this._agentSession, success, message, false, null);
+      return result;
+    } catch (e) {
+      const error = e;
+      const errorMsg = `Failed to execute nohup command: ${error.message}`;
+      logger12.error(`[${sandboxId}] ${errorMsg}`);
+      return { output: errorMsg, exitCode: 1, failureReason: errorMsg, expectString: "" };
+    }
   }
 };
+var AgentConfigSchema = zod.z.object({
+  agentType: zod.z.string(),
+  version: zod.z.string().default("default")
+});
+var AgentBashCommandSchema = zod.z.object({
+  command: zod.z.string(),
+  timeoutSeconds: zod.z.number().int().positive().default(300)
+});
+var DefaultAgentConfigSchema = zod.z.object({
+  agentType: zod.z.string(),
+  version: zod.z.string().default("default"),
+  // Session management
+  agentSession: zod.z.string().default("default-agent-session"),
+  // Startup/shutdown commands
+  preInitBashCmdList: zod.z.array(AgentBashCommandSchema).default(
+    envVars.ROCK_AGENT_PRE_INIT_BASH_CMD_LIST.map((cmd) => ({
+      command: cmd.command,
+      timeoutSeconds: cmd.timeoutSeconds || 300
+    }))
+  ),
+  postInitBashCmdList: zod.z.array(AgentBashCommandSchema).default([]),
+  // Environment variables for the session
+  sessionEnvs: zod.z.record(zod.z.string()).default({}),
+  // Optional ModelService configuration
+  modelServiceConfig: zod.z.custom().nullable().default(null)
+});
+var RockAgentConfigSchema = zod.z.object({
+  agentType: zod.z.string().default("default"),
+  agentName: zod.z.string().default(() => crypto.randomUUID().replace(/-/g, "")),
+  version: zod.z.string().default("default"),
+  agentInstalledDir: zod.z.string().default("/tmp/installed_agent"),
+  instanceId: zod.z.string().default(() => `instance-id-${crypto.randomUUID().replace(/-/g, "")}`),
+  projectPath: zod.z.string().nullable().default(null),
+  useDeployWorkingDirAsFallback: zod.z.boolean().default(true),
+  agentSession: zod.z.string().default(() => `agent-session-${crypto.randomUUID().replace(/-/g, "")}`),
+  env: zod.z.record(zod.z.string()).default({}),
+  preInitCmds: zod.z.array(AgentBashCommandSchema).default(
+    envVars.ROCK_AGENT_PRE_INIT_BASH_CMD_LIST.map((cmd) => ({
+      command: cmd.command,
+      timeoutSeconds: cmd.timeoutSeconds || 300
+    }))
+  ),
+  postInitCmds: zod.z.array(AgentBashCommandSchema).default([]),
+  agentInstallTimeout: zod.z.number().int().positive().default(600),
+  agentRunTimeout: zod.z.number().int().positive().default(1800),
+  agentRunCheckInterval: zod.z.number().int().positive().default(30),
+  workingDir: zod.z.string().nullable().default(null),
+  runCmd: zod.z.string().nullable().default(null),
+  skipWrapRunCmd: zod.z.boolean().default(false),
+  runtimeEnvConfig: zod.z.any().nullable().default(null),
+  modelServiceConfig: zod.z.custom().nullable().default(null)
+}).refine((data) => data.agentRunCheckInterval < data.agentRunTimeout, {
+  message: "agentRunCheckInterval must be less than agentRunTimeout"
+});
 
 // src/index.ts
-var VERSION = "1.2.1";
+function getVersion() {
+  const packageJsonPath = path.join(__dirname, "..", "package.json");
+  const content = fs.readFileSync(packageJsonPath, "utf-8");
+  return JSON.parse(content).version;
+}
+var VERSION = getVersion();
 
+exports.Agent = Agent;
+exports.AgentBashCommandSchema = AgentBashCommandSchema;
+exports.AgentConfigSchema = AgentConfigSchema;
 exports.BadRequestRockError = BadRequestRockError;
 exports.BashActionSchema = BashActionSchema;
 exports.ChmodRequestSchema = ChmodRequestSchema;
@@ -2063,9 +3220,10 @@ exports.Codes = Codes;
 exports.CommandResponseSchema = CommandResponseSchema;
 exports.CommandRockError = CommandRockError;
 exports.CommandSchema = CommandSchema;
-exports.Constants = Constants;
 exports.CreateBashSessionRequestSchema = CreateBashSessionRequestSchema;
 exports.CreateSessionResponseSchema = CreateSessionResponseSchema;
+exports.DefaultAgent = DefaultAgent;
+exports.DefaultAgentConfigSchema = DefaultAgentConfigSchema;
 exports.Deploy = Deploy;
 exports.EnvHubClient = EnvHubClient;
 exports.EnvHubClientConfigSchema = EnvHubClientConfigSchema;
@@ -2079,19 +3237,28 @@ exports.LinuxFileSystem = LinuxFileSystem;
 exports.LinuxRemoteUser = LinuxRemoteUser;
 exports.ModelClient = ModelClient;
 exports.ModelService = ModelService;
+exports.ModelServiceConfigSchema = ModelServiceConfigSchema;
+exports.NODE_DEFAULT_VERSION = NODE_DEFAULT_VERSION;
 exports.Network = Network;
+exports.NodeRuntimeEnv = NodeRuntimeEnv;
+exports.NodeRuntimeEnvConfigSchema = NodeRuntimeEnvConfigSchema;
 exports.ObservationSchema = ObservationSchema;
 exports.OssSetupResponseSchema = OssSetupResponseSchema;
 exports.PID_PREFIX = PID_PREFIX;
 exports.PID_SUFFIX = PID_SUFFIX;
 exports.Process = Process;
+exports.PythonRuntimeEnv = PythonRuntimeEnv;
+exports.PythonRuntimeEnvConfigSchema = PythonRuntimeEnvConfigSchema;
 exports.ReadFileRequestSchema = ReadFileRequestSchema;
 exports.ReadFileResponseSchema = ReadFileResponseSchema;
 exports.ReasonPhrases = ReasonPhrases;
+exports.RockAgentConfigSchema = RockAgentConfigSchema;
 exports.RockEnv = RockEnv;
 exports.RockEnvInfoSchema = RockEnvInfoSchema;
 exports.RockException = RockException;
 exports.RunMode = RunMode;
+exports.RuntimeEnv = RuntimeEnv;
+exports.RuntimeEnvConfigSchema = RuntimeEnvConfigSchema;
 exports.Sandbox = Sandbox;
 exports.SandboxConfigSchema = SandboxConfigSchema;
 exports.SandboxGroup = SandboxGroup;
@@ -2106,16 +3273,17 @@ exports.WriteFileRequestSchema = WriteFileRequestSchema;
 exports.WriteFileResponseSchema = WriteFileResponseSchema;
 exports.arunWithRetry = arunWithRetry;
 exports.createRockEnvInfo = createRockEnvInfo;
+exports.createRuntimeEnvId = createRuntimeEnvId;
 exports.createSandboxConfig = createSandboxConfig;
 exports.createSandboxGroupConfig = createSandboxGroupConfig;
 exports.deprecated = deprecated;
 exports.deprecatedClass = deprecatedClass;
 exports.extractNohupPidFromSandbox = extractNohupPid;
 exports.fromRockException = fromRockException;
+exports.getDefaultPipIndexUrl = getDefaultPipIndexUrl;
 exports.getEnv = getEnv;
 exports.getReasonPhrase = getReasonPhrase;
 exports.getRequiredEnv = getRequiredEnv;
-exports.isBrowser = isBrowser;
 exports.isClientError = isClientError;
 exports.isCommandError = isCommandError;
 exports.isEnvSet = isEnvSet;