@agentrun/sdk 0.0.3 → 0.0.4

package/dist/sandbox/index.js

@@ -0,0 +1,3532 @@
+import * as dotenv from 'dotenv';
+import * as $AgentRun4 from '@alicloud/agentrun20250910';
+import * as $OpenApi from '@alicloud/openapi-client';
+import * as $Util from '@alicloud/tea-util';
+import * as fs2 from 'fs';
+import * as path from 'path';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/log.ts
+var LOG_LEVELS, COLORS, Logger, logger;
+var init_log = __esm({
+  "src/utils/log.ts"() {
+    LOG_LEVELS = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3
+    };
+    COLORS = {
+      reset: "\x1B[0m",
+      bright: "\x1B[1m",
+      dim: "\x1B[2m",
+      italic: "\x1B[3m",
+      blue: "\x1B[34m",
+      cyan: "\x1B[36m",
+      yellow: "\x1B[33m",
+      red: "\x1B[31m"
+    };
+    Logger = class {
+      level = "info";
+      // match Python logger name
+      prefix = "agentrun-logger";
+      setLevel(level) {
+        this.level = level;
+      }
+      shouldLog(level) {
+        return LOG_LEVELS[level] >= LOG_LEVELS[this.level];
+      }
+      getColor(level) {
+        switch (level) {
+          case "debug":
+            return COLORS.cyan;
+          case "info":
+            return COLORS.blue;
+          case "warn":
+            return COLORS.yellow;
+          case "error":
+            return COLORS.red;
+          default:
+            return COLORS.reset;
+        }
+      }
+      // format timestamp like Python: YYYY-MM-DD HH:mm:ss,SSS
+      formatTimestamp(d = /* @__PURE__ */ new Date()) {
+        const pad = (n, sz = 2) => n.toString().padStart(sz, "0");
+        const year = d.getFullYear();
+        const month = pad(d.getMonth() + 1);
+        const day = pad(d.getDate());
+        const hour = pad(d.getHours());
+        const minute = pad(d.getMinutes());
+        const second = pad(d.getSeconds());
+        const ms = pad(d.getMilliseconds(), 3);
+        return `${year}-${month}-${day} ${hour}:${minute}:${second},${ms}`;
+      }
+      // attempt to infer caller file and line by parsing Error.stack
+      // helper: parse a single stack frame into {filepath, line, functionName}
+      parseFrame(frame) {
+        const m = frame.match(/^(?:at\s+)?(?:(.+?)\s+\()?(.*?):(\d+):(\d+)\)?$/);
+        if (!m) return null;
+        return {
+          functionName: m[1] ? m[1].trim() : void 0,
+          filepath: m[2],
+          line: parseInt(m[3], 10)
+        };
+      }
+      // get caller by fixed stack offset (used in public log methods)
+      getCallerByOffset() {
+        const err = new Error();
+        const stack = err.stack;
+        if (!stack) return {};
+        const lines = stack.split("\n").map((l) => l.trim());
+        for (let i = 3; i < lines.length; i++) {
+          let parsed = this.parseFrame(lines[i]);
+          if (!parsed) {
+            const m = lines[i].match(/(\/[^:\s]+:\d+:\d+)/);
+            if (m) {
+              const parts = m[1].split(":");
+              parts.pop();
+              const ln = Number(parts.pop());
+              const fp2 = parts.join(":");
+              parsed = { filepath: fp2, line: ln, functionName: void 0 };
+            }
+          }
+          if (!parsed) continue;
+          const fp = parsed.filepath;
+          if (fp.includes("node_modules") || fp.includes("internal") || fp.includes("<anonymous>") || fp.includes("native"))
+            continue;
+          return { filepath: parsed.filepath, line: parsed.line };
+        }
+        const cwd = process.cwd();
+        for (let i = 0; i < lines.length; i++) {
+          let parsed = this.parseFrame(lines[i]);
+          if (!parsed) {
+            const m = lines[i].match(/(\/[^:\s]+:\d+:\d+)/);
+            if (m) {
+              const parts = m[1].split(":");
+              parts.pop();
+              const ln = Number(parts.pop());
+              const fp2 = parts.join(":");
+              parsed = { filepath: fp2, line: ln, functionName: void 0 };
+            }
+          }
+          if (!parsed) continue;
+          const fp = parsed.filepath;
+          if (fp.includes("node_modules") || fp.includes("internal") || fp.includes("<anonymous>") || fp.includes("native"))
+            continue;
+          if (fp.includes("/src/utils/log.ts")) continue;
+          if (fp.startsWith(cwd)) return { filepath: parsed.filepath, line: parsed.line };
+        }
+        for (let i = 0; i < lines.length; i++) {
+          let parsed = this.parseFrame(lines[i]);
+          if (!parsed) {
+            const m = lines[i].match(/(\/[^:\s]+:\d+:\d+)/);
+            if (m) {
+              const parts = m[1].split(":");
+              parts.pop();
+              const ln = Number(parts.pop());
+              const fp2 = parts.join(":");
+              parsed = { filepath: fp2, line: ln, functionName: void 0 };
+            }
+          }
+          if (!parsed) continue;
+          const fp = parsed.filepath;
+          if (fp.includes("node_modules") || fp.includes("internal") || fp.includes("<anonymous>") || fp.includes("native"))
+            continue;
+          if (fp.includes("/src/utils/log.ts")) continue;
+          return { filepath: parsed.filepath, line: parsed.line };
+        }
+        return {};
+      }
+      formatMessage(level, message, filepath, line) {
+        const timestamp = this.formatTimestamp();
+        const color = this.getColor(level);
+        const reset = COLORS.reset;
+        const levelName = level === "warn" ? "WARNING" : level.toUpperCase();
+        const levelStr = `${COLORS.bright}${color}${levelName}${reset}`;
+        const nameStr = `${color}[${this.prefix}]${reset}`;
+        const tsStr = `${color} ${timestamp}${reset}`;
+        const pathInfo = filepath && line !== void 0 ? ` ${COLORS.dim}${COLORS.italic}${filepath}:${line}${reset}` : "";
+        const msg = level === "debug" ? `${COLORS.dim}${message}${reset}` : message;
+        return `
+${levelStr} ${nameStr}${tsStr}${pathInfo}
+${msg}
+`;
+      }
+      debug(message, ...args) {
+        if (this.shouldLog("debug")) {
+          const caller = this.getCallerByOffset();
+          console.debug(this.formatMessage("debug", message, caller.filepath, caller.line), ...args);
+        }
+      }
+      info(message, ...args) {
+        if (this.shouldLog("info")) {
+          const caller = this.getCallerByOffset();
+          console.info(this.formatMessage("info", message, caller.filepath, caller.line), ...args);
+        }
+      }
+      warn(message, ...args) {
+        if (this.shouldLog("warn")) {
+          const caller = this.getCallerByOffset();
+          console.warn(this.formatMessage("warn", message, caller.filepath, caller.line), ...args);
+        }
+      }
+      error(message, ...args) {
+        if (this.shouldLog("error")) {
+          const caller = this.getCallerByOffset();
+          console.error(this.formatMessage("error", message, caller.filepath, caller.line), ...args);
+        }
+      }
+    };
+    logger = new Logger();
+    if (![void 0, null, "", "False", "FALSE", "false", "0"].includes(process.env["AGENTRUN_SDK_DEBUG"])) {
+      logger.setLevel("debug");
+      if (!globalThis._AGENTRUN_DEBUG_LOGGED) {
+        logger.warn("\u542F\u7528 AgentRun SDK \u8C03\u8BD5\u65E5\u5FD7\uFF0C \u79FB\u9664 AGENTRUN_SDK_DEBUG \u73AF\u5883\u53D8\u91CF\u4EE5\u5173\u95ED");
+        globalThis._AGENTRUN_DEBUG_LOGGED = true;
+      }
+    } else {
+      logger.setLevel("info");
+    }
+  }
+});
+
+// src/utils/version-check.ts
+var VERSION;
+var init_version_check = __esm({
+  "src/utils/version-check.ts"() {
+    init_log();
+    VERSION = "0.0.4" ;
+    if (!process.env.DISABLE_BREAKING_CHANGES_WARNING && !globalThis._AGENTRUN_VERSION_WARNING_SHOWN) {
+      globalThis._AGENTRUN_VERSION_WARNING_SHOWN = true;
+      logger.warn(
+        `\u5F53\u524D\u60A8\u6B63\u5728\u4F7F\u7528 AgentRun Python SDK \u7248\u672C ${VERSION}\u3002\u65E9\u671F\u7248\u672C\u901A\u5E38\u5305\u542B\u8BB8\u591A\u65B0\u529F\u80FD\uFF0C\u8FD9\u4E9B\u529F\u80FD\x1B[1;33m \u53EF\u80FD\u5F15\u5165\u4E0D\u517C\u5BB9\u7684\u53D8\u66F4 \x1B[0m\u3002\u4E3A\u907F\u514D\u6F5C\u5728\u95EE\u9898\uFF0C\u6211\u4EEC\u5F3A\u70C8\u5EFA\u8BAE\x1B[1;32m \u5C06\u4F9D\u8D56\u9501\u5B9A\u4E3A\u6B64\u7248\u672C \x1B[0m\u3002
+You are currently using AgentRun Python SDK version ${VERSION}. Early versions often include many new features, which\x1B[1;33m may introduce breaking changes\x1B[0m. To avoid potential issues, we strongly recommend \x1B[1;32mpinning the dependency to this version\x1B[0m.
+\x1B[2;3m  pip install 'agentrun-sdk==${VERSION}' \x1B[0m
+
+\u589E\u52A0\x1B[2;3m DISABLE_BREAKING_CHANGES_WARNING=1 \x1B[0m\u5230\u60A8\u7684\u73AF\u5883\u53D8\u91CF\u4EE5\u5173\u95ED\u6B64\u8B66\u544A\u3002
+Add\x1B[2;3m DISABLE_BREAKING_CHANGES_WARNING=1 \x1B[0mto your environment variables to disable this warning.
+     
+Releases:\x1B[2;3m https://github.com/Serverless-Devs/agentrun-sdk-python/releases\x1B[0m`
+      );
+    }
+  }
+});
+function getEnvWithDefault(defaultValue, ...keys) {
+  for (const key of keys) {
+    const value = process.env[key];
+    if (value !== void 0 && value !== "") {
+      return value;
+    }
+  }
+  return defaultValue;
+}
+var Config;
+var init_config = __esm({
+  "src/utils/config.ts"() {
+    dotenv.config();
+    Config = class _Config {
+      _accessKeyId;
+      _accessKeySecret;
+      _securityToken;
+      _accountId;
+      _token;
+      _regionId;
+      _timeout;
+      _readTimeout;
+      _controlEndpoint;
+      _dataEndpoint;
+      _devsEndpoint;
+      _headers;
+      constructor(options = {}) {
+        this._accessKeyId = options.accessKeyId ?? getEnvWithDefault("", "AGENTRUN_ACCESS_KEY_ID", "ALIBABA_CLOUD_ACCESS_KEY_ID");
+        this._accessKeySecret = options.accessKeySecret ?? getEnvWithDefault("", "AGENTRUN_ACCESS_KEY_SECRET", "ALIBABA_CLOUD_ACCESS_KEY_SECRET");
+        this._securityToken = options.securityToken ?? getEnvWithDefault("", "AGENTRUN_SECURITY_TOKEN", "ALIBABA_CLOUD_SECURITY_TOKEN");
+        this._accountId = options.accountId ?? getEnvWithDefault("", "AGENTRUN_ACCOUNT_ID", "FC_ACCOUNT_ID");
+        this._token = options.token;
+        this._regionId = options.regionId ?? getEnvWithDefault("cn-hangzhou", "AGENTRUN_REGION", "FC_REGION");
+        this._timeout = options.timeout ?? 6e5;
+        this._readTimeout = options.readTimeout ?? 1e8;
+        this._controlEndpoint = options.controlEndpoint ?? getEnvWithDefault("", "AGENTRUN_CONTROL_ENDPOINT");
+        this._dataEndpoint = options.dataEndpoint ?? getEnvWithDefault("", "AGENTRUN_DATA_ENDPOINT");
+        this._devsEndpoint = options.devsEndpoint ?? getEnvWithDefault("", "DEVS_ENDPOINT");
+        this._headers = options.headers ?? {};
+      }
+      /**
+       * Create a new Config by merging multiple configs.
+       * Later configs take precedence.
+       */
+      static withConfigs(...configs) {
+        return new _Config().update(...configs);
+      }
+      /**
+       * Update this config with values from other configs.
+       * Non-undefined values from later configs take precedence.
+       */
+      update(...configs) {
+        for (const config2 of configs) {
+          if (!config2) continue;
+          if (config2._accessKeyId) this._accessKeyId = config2._accessKeyId;
+          if (config2._accessKeySecret) this._accessKeySecret = config2._accessKeySecret;
+          if (config2._securityToken) this._securityToken = config2._securityToken;
+          if (config2._accountId) this._accountId = config2._accountId;
+          if (config2._token) this._token = config2._token;
+          if (config2._regionId) this._regionId = config2._regionId;
+          if (config2._timeout) this._timeout = config2._timeout;
+          if (config2._readTimeout) this._readTimeout = config2._readTimeout;
+          if (config2._controlEndpoint) this._controlEndpoint = config2._controlEndpoint;
+          if (config2._dataEndpoint) this._dataEndpoint = config2._dataEndpoint;
+          if (config2._devsEndpoint) this._devsEndpoint = config2._devsEndpoint;
+          if (config2._headers && Object.keys(config2._headers).length > 0) {
+            this._headers = { ...this._headers, ...config2._headers };
+          }
+        }
+        return this;
+      }
+      get accessKeyId() {
+        return this._accessKeyId;
+      }
+      get accessKeySecret() {
+        return this._accessKeySecret;
+      }
+      get securityToken() {
+        return this._securityToken;
+      }
+      get accountId() {
+        if (!this._accountId) {
+          throw new Error(
+            "Account ID is not set. Please add AGENTRUN_ACCOUNT_ID environment variable or set it in code."
+          );
+        }
+        return this._accountId;
+      }
+      get token() {
+        return this._token;
+      }
+      get regionId() {
+        return this._regionId || "cn-hangzhou";
+      }
+      get timeout() {
+        return this._timeout || 6e5;
+      }
+      get readTimeout() {
+        return this._readTimeout || 1e8;
+      }
+      get controlEndpoint() {
+        if (this._controlEndpoint) {
+          return this._controlEndpoint;
+        }
+        return `https://agentrun.${this.regionId}.aliyuncs.com`;
+      }
+      get dataEndpoint() {
+        if (this._dataEndpoint) {
+          return this._dataEndpoint;
+        }
+        return `https://${this.accountId}.agentrun-data.${this.regionId}.aliyuncs.com`;
+      }
+      get devsEndpoint() {
+        if (this._devsEndpoint) {
+          return this._devsEndpoint;
+        }
+        return `https://devs.${this.regionId}.aliyuncs.com`;
+      }
+      get headers() {
+        return this._headers;
+      }
+    };
+  }
+});
+
+// src/utils/exception.ts
+var AgentRunError, HTTPError, ClientError, ServerError, ResourceNotExistError, ResourceAlreadyExistError;
+var init_exception = __esm({
+  "src/utils/exception.ts"() {
+    AgentRunError = class _AgentRunError extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "AgentRunError";
+        Object.setPrototypeOf(this, _AgentRunError.prototype);
+      }
+    };
+    HTTPError = class _HTTPError extends AgentRunError {
+      statusCode;
+      requestId;
+      errorCode;
+      constructor(statusCode, message, options) {
+        super(message);
+        this.name = "HTTPError";
+        this.statusCode = statusCode;
+        this.requestId = options?.requestId;
+        this.errorCode = options?.errorCode;
+        Object.setPrototypeOf(this, _HTTPError.prototype);
+      }
+      /**
+       * Convert HTTP error to resource-specific error based on status code
+       */
+      toResourceError(resourceType, resourceId) {
+        if (this.statusCode == 404) return new ResourceNotExistError(resourceType, resourceId);
+        else if (this.statusCode == 409) return new ResourceAlreadyExistError(resourceType, resourceId);
+        else if ((this.statusCode == 400 || this.statusCode == 500) && this.message.includes("already exists"))
+          return new ResourceAlreadyExistError(resourceType, resourceId);
+        else return this;
+      }
+    };
+    ClientError = class _ClientError extends HTTPError {
+      constructor(statusCode, message, options) {
+        super(statusCode, message, options);
+        this.name = "ClientError";
+        Object.setPrototypeOf(this, _ClientError.prototype);
+      }
+    };
+    ServerError = class _ServerError extends HTTPError {
+      constructor(statusCode, message, options) {
+        super(statusCode, message, options);
+        this.name = "ServerError";
+        Object.setPrototypeOf(this, _ServerError.prototype);
+      }
+    };
+    ResourceNotExistError = class _ResourceNotExistError extends ClientError {
+      resourceType;
+      resourceId;
+      constructor(resourceType, resourceId, options) {
+        const message = resourceId ? `${resourceType} '${resourceId}' does not exist` : `${resourceType} does not exist`;
+        super(404, message, options);
+        this.name = "ResourceNotExistError";
+        this.resourceType = resourceType;
+        this.resourceId = resourceId;
+        Object.setPrototypeOf(this, _ResourceNotExistError.prototype);
+      }
+    };
+    ResourceAlreadyExistError = class _ResourceAlreadyExistError extends ClientError {
+      resourceType;
+      resourceId;
+      constructor(resourceType, resourceId, options) {
+        const message = resourceId ? `${resourceType} '${resourceId}' already exists` : `${resourceType} already exists`;
+        super(409, message, options);
+        this.name = "ResourceAlreadyExistError";
+        this.resourceType = resourceType;
+        this.resourceId = resourceId;
+        Object.setPrototypeOf(this, _ResourceAlreadyExistError.prototype);
+      }
+    };
+  }
+});
+var $AgentRunClient, ControlAPI;
+var init_control_api = __esm({
+  "src/utils/control-api.ts"() {
+    init_config();
+    $AgentRunClient = // @ts-expect-error - ESM interop: default.default exists when imported as ESM namespace
+    $AgentRun4.default?.default ?? $AgentRun4.default ?? $AgentRun4;
+    ControlAPI = class {
+      config;
+      constructor(config2) {
+        this.config = config2;
+      }
+      /**
+       * Get the underlying AgentRun client instance
+       */
+      getClient(config2) {
+        const cfg = Config.withConfigs(this.config, config2);
+        let endpoint = cfg.controlEndpoint;
+        if (endpoint.startsWith("http://") || endpoint.startsWith("https://")) {
+          endpoint = endpoint.split("://")[1];
+        }
+        const openApiConfig = new $OpenApi.Config({
+          accessKeyId: cfg.accessKeyId,
+          accessKeySecret: cfg.accessKeySecret,
+          securityToken: cfg.securityToken || void 0,
+          regionId: cfg.regionId,
+          endpoint,
+          connectTimeout: cfg.timeout,
+          readTimeout: cfg.readTimeout
+        });
+        return new $AgentRunClient(openApiConfig);
+      }
+    };
+  }
+});
+var SandboxControlAPI;
+var init_control = __esm({
+  "src/sandbox/api/control.ts"() {
+    init_control_api();
+    init_exception();
+    init_log();
+    SandboxControlAPI = class extends ControlAPI {
+      constructor(config2) {
+        super(config2);
+      }
+      /**
+       * Create Sandbox Template
+       *
+       * @param params - Method parameters
+       * @param params.input - Template configuration
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns Created Template object
+       */
+      createTemplate = async (params) => {
+        const { input, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util.RuntimeOptions({});
+          const response = await client.createTemplateWithOptions(
+            new $AgentRun4.CreateTemplateRequest({ body: input }),
+            headers ?? {},
+            runtime
+          );
+          logger.debug(
+            `request api createTemplate, request Request ID: ${response.body?.requestId}
+  request: ${JSON.stringify([input])}
+  response: ${JSON.stringify(response.body?.data)}`
+          );
+          return response.body?.data;
+        } catch (error) {
+          if (error && typeof error === "object" && "statusCode" in error) {
+            const e = error;
+            const statusCode = e.statusCode;
+            const message = e.message || "Unknown error";
+            const requestId = e.data?.requestId;
+            if (statusCode >= 400 && statusCode < 500) {
+              throw new ClientError(statusCode, message, { requestId });
+            } else if (statusCode >= 500) {
+              throw new ServerError(statusCode, message, { requestId });
+            }
+          }
+          throw error;
+        }
+      };
+      /**
+       * Delete Sandbox Template
+       *
+       * @param params - Method parameters
+       * @param params.templateName - Template name
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns Deleted Template object
+       */
+      deleteTemplate = async (params) => {
+        const { templateName, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util.RuntimeOptions({});
+          const response = await client.deleteTemplateWithOptions(templateName, headers ?? {}, runtime);
+          logger.debug(
+            `request api deleteTemplate, request Request ID: ${response.body?.requestId}
+  request: ${JSON.stringify([templateName])}
+  response: ${JSON.stringify(response.body?.data)}`
+          );
+          return response.body?.data;
+        } catch (error) {
+          if (error && typeof error === "object" && "statusCode" in error) {
+            const e = error;
+            const statusCode = e.statusCode;
+            const message = e.message || "Unknown error";
+            const requestId = e.data?.requestId;
+            if (statusCode >= 400 && statusCode < 500) {
+              throw new ClientError(statusCode, message, { requestId });
+            } else if (statusCode >= 500) {
+              throw new ServerError(statusCode, message, { requestId });
+            }
+          }
+          throw error;
+        }
+      };
+      /**
+       * Update Sandbox Template
+       *
+       * @param params - Method parameters
+       * @param params.templateName - Template name
+       * @param params.input - Template configuration
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns Updated Template object
+       */
+      updateTemplate = async (params) => {
+        const { templateName, input, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util.RuntimeOptions({});
+          const response = await client.updateTemplateWithOptions(
+            templateName,
+            new $AgentRun4.UpdateTemplateRequest({ body: input }),
+            headers ?? {},
+            runtime
+          );
+          logger.debug(
+            `request api updateTemplate, request Request ID: ${response.body?.requestId}
+  request: ${JSON.stringify([templateName, input])}
+  response: ${JSON.stringify(response.body?.data)}`
+          );
+          return response.body?.data;
+        } catch (error) {
+          if (error && typeof error === "object" && "statusCode" in error) {
+            const e = error;
+            const statusCode = e.statusCode;
+            const message = e.message || "Unknown error";
+            const requestId = e.data?.requestId;
+            if (statusCode >= 400 && statusCode < 500) {
+              throw new ClientError(statusCode, message, { requestId });
+            } else if (statusCode >= 500) {
+              throw new ServerError(statusCode, message, { requestId });
+            }
+          }
+          throw error;
+        }
+      };
+      /**
+       * Get Sandbox Template
+       *
+       * @param params - Method parameters
+       * @param params.templateName - Template name
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns Template object
+       */
+      getTemplate = async (params) => {
+        const { templateName, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util.RuntimeOptions({});
+          const response = await client.getTemplateWithOptions(templateName, headers ?? {}, runtime);
+          logger.debug(
+            `request api getTemplate, request Request ID: ${response.body?.requestId}
+  request: ${JSON.stringify([templateName])}
+  response: ${JSON.stringify(response.body?.data)}`
+          );
+          return response.body?.data;
+        } catch (error) {
+          if (error && typeof error === "object" && "statusCode" in error) {
+            const e = error;
+            const statusCode = e.statusCode;
+            const message = e.message || "Unknown error";
+            const requestId = e.data?.requestId;
+            if (statusCode >= 400 && statusCode < 500) {
+              throw new ClientError(statusCode, message, { requestId });
+            } else if (statusCode >= 500) {
+              throw new ServerError(statusCode, message, { requestId });
+            }
+          }
+          throw error;
+        }
+      };
+      /**
+       * List Sandbox Templates
+       *
+       * @param params - Method parameters
+       * @param params.input - List options
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns List of Template objects
+       */
+      listTemplates = async (params) => {
+        const { input, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util.RuntimeOptions({});
+          const response = await client.listTemplatesWithOptions(input, headers ?? {}, runtime);
+          logger.debug(
+            `request api listTemplates, request Request ID: ${response.body?.requestId}
+  request: ${JSON.stringify([input])}
+  response: ${JSON.stringify(response.body?.data)}`
+          );
+          return response.body?.data;
+        } catch (error) {
+          if (error && typeof error === "object" && "statusCode" in error) {
+            const e = error;
+            const statusCode = e.statusCode;
+            const message = e.message || "Unknown error";
+            const requestId = e.data?.requestId;
+            if (statusCode >= 400 && statusCode < 500) {
+              throw new ClientError(statusCode, message, { requestId });
+            } else if (statusCode >= 500) {
+              throw new ServerError(statusCode, message, { requestId });
+            }
+          }
+          throw error;
+        }
+      };
+      /**
+       * Create Sandbox
+       *
+       * @param params - Method parameters
+       * @param params.input - Sandbox configuration
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns Created Sandbox object
+       */
+      createSandbox = async (params) => {
+        const { input, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util.RuntimeOptions({
+            readTimeout: 3e4
+          });
+          const response = await client.createSandboxWithOptions(
+            new $AgentRun4.CreateSandboxRequest({ body: input }),
+            headers ?? {},
+            runtime
+          );
+          logger.debug(
+            `request api createSandbox, request Request ID: ${response.body?.requestId}
+  request: ${JSON.stringify([input])}
+  response: ${JSON.stringify(response.body?.data)}`
+          );
+          return response.body?.data;
+        } catch (error) {
+          if (error && typeof error === "object" && "statusCode" in error) {
+            const e = error;
+            const statusCode = e.statusCode;
+            const message = e.message || "Unknown error";
+            const requestId = e.data?.requestId;
+            if (statusCode >= 400 && statusCode < 500) {
+              throw new ClientError(statusCode, message, { requestId });
+            } else if (statusCode >= 500) {
+              throw new ServerError(statusCode, message, { requestId });
+            }
+          }
+          throw error;
+        }
+      };
+      /**
+       * Delete Sandbox
+       *
+       * @param params - Method parameters
+       * @param params.sandboxId - Sandbox ID
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns Deleted Sandbox object
+       */
+      deleteSandbox = async (params) => {
+        const { sandboxId, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util.RuntimeOptions({});
+          const response = await client.deleteSandboxWithOptions(sandboxId, headers ?? {}, runtime);
+          logger.debug(
+            `request api deleteSandbox, request Request ID: ${response.body?.requestId}
+  request: ${JSON.stringify([sandboxId])}
+  response: ${JSON.stringify(response.body?.data)}`
+          );
+          return response.body?.data;
+        } catch (error) {
+          if (error && typeof error === "object" && "statusCode" in error) {
+            const e = error;
+            const statusCode = e.statusCode;
+            const message = e.message || "Unknown error";
+            const requestId = e.data?.requestId;
+            if (statusCode >= 400 && statusCode < 500) {
+              throw new ClientError(statusCode, message, { requestId });
+            } else if (statusCode >= 500) {
+              throw new ServerError(statusCode, message, { requestId });
+            }
+          }
+          throw error;
+        }
+      };
+      /**
+       * Stop Sandbox
+       *
+       * @param params - Method parameters
+       * @param params.sandboxId - Sandbox ID
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns Stopped Sandbox object
+       */
+      stopSandbox = async (params) => {
+        const { sandboxId, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util.RuntimeOptions({});
+          const response = await client.stopSandboxWithOptions(sandboxId, headers ?? {}, runtime);
+          logger.debug(
+            `request api stopSandbox, request Request ID: ${response.body?.requestId}
+  request: ${JSON.stringify([sandboxId])}
+  response: ${JSON.stringify(response.body?.data)}`
+          );
+          return response.body?.data;
+        } catch (error) {
+          if (error && typeof error === "object" && "statusCode" in error) {
+            const e = error;
+            const statusCode = e.statusCode;
+            const message = e.message || "Unknown error";
+            const requestId = e.data?.requestId;
+            if (statusCode >= 400 && statusCode < 500) {
+              throw new ClientError(statusCode, message, { requestId });
+            } else if (statusCode >= 500) {
+              throw new ServerError(statusCode, message, { requestId });
+            }
+          }
+          throw error;
+        }
+      };
+      /**
+       * Get Sandbox
+       *
+       * @param params - Method parameters
+       * @param params.sandboxId - Sandbox ID
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns Sandbox object
+       */
+      getSandbox = async (params) => {
+        const { sandboxId, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util.RuntimeOptions({});
+          const response = await client.getSandboxWithOptions(sandboxId, headers ?? {}, runtime);
+          logger.debug(
+            `request api getSandbox, request Request ID: ${response.body?.requestId}
+  request: ${JSON.stringify([sandboxId])}
+  response: ${JSON.stringify(response.body?.data)}`
+          );
+          return response.body?.data;
+        } catch (error) {
+          if (error && typeof error === "object" && "statusCode" in error) {
+            const e = error;
+            const statusCode = e.statusCode;
+            const message = e.message || "Unknown error";
+            const requestId = e.data?.requestId;
+            if (statusCode >= 400 && statusCode < 500) {
+              throw new ClientError(statusCode, message, { requestId });
+            } else if (statusCode >= 500) {
+              throw new ServerError(statusCode, message, { requestId });
+            }
+          }
+          throw error;
+        }
+      };
+      /**
+       * List Sandboxes
+       *
+       * @param params - Method parameters
+       * @param params.input - List options
+       * @param params.headers - Custom request headers
+       * @param params.config - Optional config override
+       * @returns List of Sandbox objects
+       */
+      listSandboxes = async (params) => {
+        const { input, headers, config: config2 } = params;
+        try {
+          const client = this.getClient(config2);
+          const runtime = new $Util.RuntimeOptions({});
+          const response = await client.listSandboxesWithOptions(input, headers ?? {}, runtime);
+          logger.debug(
+            `request api listSandboxes, request Request ID: ${response.body?.requestId}
+  request: ${JSON.stringify([input])}
+  response: ${JSON.stringify(response.body?.data)}`
+          );
+          return response.body?.data;
+        } catch (error) {
+          if (error && typeof error === "object" && "statusCode" in error) {
+            const e = error;
+            const statusCode = e.statusCode;
+            const message = e.message || "Unknown error";
+            const requestId = e.data?.requestId;
+            if (statusCode >= 400 && statusCode < 500) {
+              throw new ClientError(statusCode, message, { requestId });
+            } else if (statusCode >= 500) {
+              throw new ServerError(statusCode, message, { requestId });
+            }
+          }
+          throw error;
+        }
+      };
+    };
+  }
+});
+var SandboxDataAPI;
+var init_sandbox_data = __esm({
+  "src/sandbox/api/sandbox-data.ts"() {
+    init_config();
+    init_control_api();
+    init_exception();
+    init_log();
+    SandboxDataAPI = class {
+      resourceName;
+      resourceType;
+      namespace;
+      config;
+      accessToken;
+      accessTokenMap = /* @__PURE__ */ new Map();
+      constructor(params) {
+        const { config: config2, namespace = "sandboxes" } = params;
+        this.resourceName = "";
+        this.resourceType = "template" /* Template */;
+        this.namespace = namespace;
+        this.config = config2 || new Config();
+      }
+      /**
+       * Refresh access token for the resource
+       */
+      async refreshAccessToken(params) {
+        const { sandboxId, templateName, config: config2 } = params;
+        const cfg = Config.withConfigs(config2, this.config);
+        const cacheKey = sandboxId || templateName;
+        const cachedToken = this.accessTokenMap.get(cacheKey);
+        if (sandboxId) {
+          this.resourceName = sandboxId;
+          this.resourceType = "sandbox" /* Sandbox */;
+          this.namespace = `sandboxes/${sandboxId}`;
+        } else if (templateName) {
+          this.resourceName = templateName;
+          this.resourceType = "template" /* Template */;
+          this.namespace = "sandboxes";
+        }
+        if (cachedToken) {
+          this.accessToken = cachedToken;
+          return;
+        }
+        this.accessToken = void 0;
+        await this.auth({ config: cfg });
+        if (this.accessToken) {
+          this.accessTokenMap.set(cacheKey, this.accessToken);
+        }
+      }
+      /**
+       * Get base URL for data API
+       */
+      getBaseUrl() {
+        return this.config.dataEndpoint;
+      }
+      /**
+       * Construct full URL with path and query parameters
+       */
+      withPath(path2, query) {
+        path2 = path2.replace(/^\//, "");
+        const parts = [this.getBaseUrl(), this.namespace, path2].filter((p) => p && p.length > 0);
+        let url = parts.join("/").replace(/\/+/g, "/").replace(/:\//g, "://");
+        if (query && Object.keys(query).length > 0) {
+          const urlObj = new URL(url);
+          Object.entries(query).forEach(([key, value]) => {
+            if (Array.isArray(value)) {
+              value.forEach((v) => urlObj.searchParams.append(key, String(v)));
+            } else if (value !== void 0 && value !== null) {
+              urlObj.searchParams.append(key, String(value));
+            }
+          });
+          url = urlObj.toString();
+        }
+        return url;
+      }
+      /**
+       * Authentication hook - gets access token for the resource
+       */
+      async auth(params) {
+        const cfg = Config.withConfigs(this.config, params.config);
+        if (cfg.token) {
+          logger.debug(`Using provided access token from config: ${this.maskToken(cfg.token)}`);
+          this.accessToken = cfg.token;
+          return;
+        }
+        if (!this.accessToken && this.resourceName && this.resourceType && !cfg.token) {
+          try {
+            const controlApi = new ControlAPI(cfg);
+            const client = controlApi.getClient(cfg);
+            const request = this.resourceType === "sandbox" /* Sandbox */ ? new $AgentRun4.GetAccessTokenRequest({
+              resourceId: this.resourceName,
+              resourceType: this.resourceType
+            }) : new $AgentRun4.GetAccessTokenRequest({
+              resourceName: this.resourceName,
+              resourceType: this.resourceType
+            });
+            const runtime = new $Util.RuntimeOptions({});
+            const response = await client.getAccessTokenWithOptions(request, {}, runtime);
+            this.accessToken = response.body?.data?.accessToken;
+            logger.debug(
+              `Fetched access token for resource ${this.resourceName} of type ${this.resourceType}: ${this.maskToken(this.accessToken || "")}`
+            );
+          } catch (error) {
+            logger.warn(
+              `Failed to get access token for ${this.resourceType}(${this.resourceName}): ${error}`
+            );
+          }
+        }
+      }
+      /**
+       * Mask token for logging
+       */
+      maskToken(token) {
+        if (!token || token.length <= 8) {
+          return "***";
+        }
+        return `${token.substring(0, 4)}...${token.substring(token.length - 4)}`;
+      }
+      /**
+       * Prepare request headers
+       */
+      prepareHeaders(params) {
+        const cfg = Config.withConfigs(this.config, params.config);
+        const reqHeaders = {
+          "Content-Type": "application/json",
+          "User-Agent": "AgentRunDataClient-Node/1.0",
+          "Agentrun-Access-Token": cfg.token || this.accessToken || "",
+          ...cfg.headers,
+          ...params.headers || {}
+        };
+        return reqHeaders;
+      }
+      /**
+       * Make an HTTP request
+       */
+      async makeRequest(params) {
+        const { method, url, data, headers, query, config: config2 } = params;
+        const reqHeaders = this.prepareHeaders({ headers, config: config2 });
+        let finalUrl = url;
+        if (query && Object.keys(query).length > 0) {
+          const urlObj = new URL(url);
+          Object.entries(query).forEach(([key, value]) => {
+            if (value !== void 0 && value !== null) {
+              if (Array.isArray(value)) {
+                value.forEach((v) => urlObj.searchParams.append(key, String(v)));
+              } else {
+                urlObj.searchParams.append(key, String(value));
+              }
+            }
+          });
+          finalUrl = urlObj.toString();
+        }
+        logger.debug(
+          `${method} ${finalUrl} headers=${JSON.stringify(reqHeaders)} data=${JSON.stringify(data)}`
+        );
+        try {
+          const cfg = Config.withConfigs(this.config, config2);
+          const response = await fetch(finalUrl, {
+            method,
+            headers: reqHeaders,
+            body: data ? JSON.stringify(data) : void 0,
+            signal: AbortSignal.timeout(cfg.timeout)
+          });
+          const responseText = await response.text();
+          logger.debug(`Response: ${responseText}`);
+          if (responseText) {
+            try {
+              return JSON.parse(responseText);
+            } catch (error) {
+              const errorMsg = `Failed to parse JSON response: ${error}`;
+              logger.error(errorMsg);
+              if (response.status === 502 && responseText.includes("502 Bad Gateway")) {
+                throw new ClientError(response.status, "502 Bad Gateway");
+              }
+              throw new ClientError(response.status, errorMsg);
+            }
+          }
+          return {};
+        } catch (error) {
+          if (error instanceof ClientError) {
+            throw error;
+          }
+          const errorMsg = `Request error: ${error}`;
+          throw new ClientError(0, errorMsg);
+        }
+      }
+      /**
+       * GET request
+       */
+      async get(params) {
+        const url = this.withPath(params.path, params.query);
+        return this.makeRequest({
+          method: "GET",
+          url,
+          headers: params.headers,
+          config: params.config
+        });
+      }
+      /**
+       * POST request
+       */
+      async post(params) {
+        const url = this.withPath(params.path, params.query);
+        return this.makeRequest({
+          method: "POST",
+          url,
+          data: params.data,
+          headers: params.headers,
+          config: params.config
+        });
+      }
+      /**
+       * PUT request
+       */
+      async put(params) {
+        const url = this.withPath(params.path, params.query);
+        return this.makeRequest({
+          method: "PUT",
+          url,
+          data: params.data,
+          headers: params.headers,
+          config: params.config
+        });
+      }
+      /**
+       * PATCH request
+       */
+      async patch(params) {
+        const url = this.withPath(params.path, params.query);
+        return this.makeRequest({
+          method: "PATCH",
+          url,
+          data: params.data,
+          headers: params.headers,
+          config: params.config
+        });
+      }
+      /**
+       * DELETE request
+       */
+      async delete(params) {
+        const url = this.withPath(params.path, params.query);
+        return this.makeRequest({
+          method: "DELETE",
+          url,
+          headers: params.headers,
+          config: params.config
+        });
+      }
+      /**
+       * Check sandbox health
+       */
+      checkHealth = async (params) => {
+        await this.refreshAccessToken({
+          sandboxId: params.sandboxId,
+          config: params.config
+        });
+        return this.get({ path: "/health", config: params.config });
+      };
+      /**
+       * Create sandbox from template
+       * 从模板创建沙箱 / Create Sandbox from Template
+       */
+      createSandbox = async (params) => {
+        await this.refreshAccessToken({
+          templateName: params.templateName,
+          config: params.config
+        });
+        const data = {
+          templateName: params.templateName,
+          sandboxIdleTimeoutSeconds: params.sandboxIdleTimeoutSeconds || 600
+        };
+        if (params.nasConfig !== void 0) {
+          data.nasConfig = params.nasConfig;
+        }
+        if (params.ossMountConfig !== void 0) {
+          data.ossMountConfig = params.ossMountConfig;
+        }
+        if (params.polarFsConfig !== void 0) {
+          data.polarFsConfig = params.polarFsConfig;
+        }
+        return this.post({
+          path: "/",
+          data
+        });
+      };
+      /**
+       * Delete sandbox
+       */
+      deleteSandbox = async (params) => {
+        await this.refreshAccessToken({
+          sandboxId: params.sandboxId,
+          config: params.config
+        });
+        return this.delete({ path: "/" });
+      };
+      /**
+       * Stop sandbox
+       */
+      stopSandbox = async (params) => {
+        await this.refreshAccessToken({
+          sandboxId: params.sandboxId,
+          config: params.config
+        });
+        return this.post({ path: "/stop" });
+      };
+      /**
+       * Get sandbox info
+       */
+      getSandbox = async (params) => {
+        await this.refreshAccessToken({
+          sandboxId: params.sandboxId,
+          config: params.config
+        });
+        return this.get({ path: "/" });
+      };
+    };
+  }
+});
+var BrowserDataAPI;
+var init_browser_data = __esm({
+  "src/sandbox/api/browser-data.ts"() {
+    init_config();
+    init_exception();
+    init_log();
+    init_sandbox_data();
+    BrowserDataAPI = class extends SandboxDataAPI {
+      sandboxId;
+      constructor(params) {
+        super({
+          sandboxId: params.sandboxId,
+          config: params.config,
+          // Set namespace to include sandboxId for CDP/VNC URL generation
+          namespace: `sandboxes/${params.sandboxId}`
+        });
+        this.sandboxId = params.sandboxId;
+      }
+      /**
+       * Generate the WebSocket URL for Chrome DevTools Protocol (CDP) connection
+       */
+      getCdpUrl(record) {
+        const cdpUrl = this.withPath("/ws/automation").replace("http", "ws");
+        const url = new URL(cdpUrl);
+        url.searchParams.set("tenantId", this.config.accountId);
+        if (record) {
+          url.searchParams.set("recording", "true");
+        }
+        return url.toString();
+      }
+      /**
+       * Generate the WebSocket URL for VNC (Virtual Network Computing) live view connection
+       */
+      getVncUrl(record) {
+        const vncUrl = this.withPath("/ws/liveview").replace("http", "ws");
+        const url = new URL(vncUrl);
+        url.searchParams.set("tenantId", this.config.accountId);
+        if (record) {
+          url.searchParams.set("recording", "true");
+        }
+        return url.toString();
+      }
+      /**
+       * List all recordings
+       */
+      listRecordings = async (params) => {
+        return this.get({ path: "/recordings", config: params?.config });
+      };
+      /**
+       * Delete a recording
+       */
+      deleteRecording = async (params) => {
+        return this.delete({ path: `/recordings/${params.filename}`, config: params.config });
+      };
+      /**
+       * Download a recording video file
+       */
+      downloadRecording = async (params) => {
+        return this.getVideo({
+          path: `/recordings/${params.filename}`,
+          savePath: params.savePath
+        });
+      };
+      /**
+       * Helper method to download video file
+       */
+      async getVideo(params) {
+        const url = this.withPath(params.path, params.query);
+        const cfg = Config.withConfigs(this.config, params.config);
+        const reqHeaders = this.prepareHeaders({ headers: params.headers, config: cfg });
+        try {
+          const response = await fetch(url, {
+            method: "GET",
+            headers: reqHeaders,
+            signal: AbortSignal.timeout(cfg.timeout)
+          });
+          if (!response.ok) {
+            const errorText = await response.text();
+            throw new ClientError(response.status, errorText);
+          }
+          const arrayBuffer = await response.arrayBuffer();
+          const buffer = Buffer.from(arrayBuffer);
+          await fs2.promises.writeFile(params.savePath, buffer);
+          return {
+            savedPath: params.savePath,
+            size: buffer.length
+          };
+        } catch (error) {
+          if (error instanceof ClientError) {
+            throw error;
+          }
+          logger.error(`Download video error: ${error}`);
+          throw new ClientError(0, `Download video error: ${error}`);
+        }
+      }
+    };
+  }
+});
+
+// src/utils/model.ts
+function isFinalStatus(status) {
+  return [
+    void 0,
+    null,
+    "",
+    ...["READY", "CREATE_FAILED", "UPDATE_FAILED", "DELETE_FAILED"]
+  ].includes(status);
+}
+var Status;
+var init_model = __esm({
+  "src/utils/model.ts"() {
+    Status = {
+      CREATING: "CREATING",
+      CREATE_FAILED: "CREATE_FAILED",
+      READY: "READY",
+      UPDATING: "UPDATING",
+      UPDATE_FAILED: "UPDATE_FAILED",
+      DELETING: "DELETING",
+      DELETE_FAILED: "DELETE_FAILED"
+    };
+  }
+});
+
+// src/sandbox/model.ts
+var TemplateType, SandboxState, TemplateNetworkMode, TemplateOSSPermission, CodeLanguage;
+var init_model2 = __esm({
+  "src/sandbox/model.ts"() {
+    init_model();
+    TemplateType = /* @__PURE__ */ ((TemplateType2) => {
+      TemplateType2["CODE_INTERPRETER"] = "CodeInterpreter";
+      TemplateType2["BROWSER"] = "Browser";
+      TemplateType2["AIO"] = "AllInOne";
+      TemplateType2["CUSTOM"] = "CustomImage";
+      return TemplateType2;
+    })(TemplateType || {});
+    SandboxState = /* @__PURE__ */ ((SandboxState3) => {
+      SandboxState3["CREATING"] = "Creating";
+      SandboxState3["RUNNING"] = "Running";
+      SandboxState3["READY"] = "READY";
+      SandboxState3["STOPPED"] = "Stopped";
+      SandboxState3["FAILED"] = "Failed";
+      SandboxState3["DELETING"] = "Deleting";
+      return SandboxState3;
+    })(SandboxState || {});
+    TemplateNetworkMode = /* @__PURE__ */ ((TemplateNetworkMode2) => {
+      TemplateNetworkMode2["PUBLIC"] = "PUBLIC";
+      TemplateNetworkMode2["PRIVATE"] = "PRIVATE";
+      TemplateNetworkMode2["PUBLIC_AND_PRIVATE"] = "PUBLIC_AND_PRIVATE";
+      return TemplateNetworkMode2;
+    })(TemplateNetworkMode || {});
+    TemplateOSSPermission = /* @__PURE__ */ ((TemplateOSSPermission2) => {
+      TemplateOSSPermission2["READ_WRITE"] = "READ_WRITE";
+      TemplateOSSPermission2["READ_ONLY"] = "READ_ONLY";
+      return TemplateOSSPermission2;
+    })(TemplateOSSPermission || {});
+    CodeLanguage = /* @__PURE__ */ ((CodeLanguage2) => {
+      CodeLanguage2["PYTHON"] = "python";
+      CodeLanguage2["JAVASCRIPT"] = "javascript";
+      return CodeLanguage2;
+    })(CodeLanguage || {});
+  }
+});
+var CodeInterpreterDataAPI;
+var init_code_interpreter_data = __esm({
+  "src/sandbox/api/code-interpreter-data.ts"() {
+    init_config();
+    init_exception();
+    init_log();
+    init_model2();
+    init_sandbox_data();
+    CodeInterpreterDataAPI = class extends SandboxDataAPI {
+      constructor(params) {
+        super({
+          sandboxId: params.sandboxId,
+          config: params.config,
+          // Set namespace to include sandboxId for correct API path generation
+          namespace: `sandboxes/${params.sandboxId}`
+        });
+      }
+      /**
+       * List directory contents
+       */
+      async listDirectory(params) {
+        const query = {};
+        if (params?.path !== void 0) {
+          query.path = params.path;
+        }
+        if (params?.depth !== void 0) {
+          query.depth = params.depth;
+        }
+        return this.get({ path: "/filesystem", query, config: params?.config });
+      }
+      /**
+       * Get file/directory stats
+       */
+      async stat(params) {
+        const query = {
+          path: params.path
+        };
+        return this.get({ path: "/filesystem/stat", query, config: params.config });
+      }
+      /**
+       * Create directory
+       */
+      async mkdir(params) {
+        const data = {
+          path: params.path,
+          parents: params.parents !== void 0 ? params.parents : true,
+          mode: params.mode || "0755"
+        };
+        return this.post({ path: "/filesystem/mkdir", data, config: params.config });
+      }
+      /**
+       * Move file or directory
+       */
+      async moveFile(params) {
+        const data = {
+          source: params.source,
+          destination: params.destination
+        };
+        return this.post({ path: "/filesystem/move", data, config: params.config });
+      }
+      /**
+       * Remove file or directory
+       */
+      async removeFile(params) {
+        const data = {
+          path: params.path
+        };
+        return this.post({ path: "/filesystem/remove", data, config: params.config });
+      }
+      /**
+       * List code execution contexts
+       */
+      async listContexts(params) {
+        return this.get({ path: "/contexts", config: params?.config });
+      }
+      /**
+       * Create a new code execution context
+       */
+      async createContext(params) {
+        const language = params?.language || "python" /* PYTHON */;
+        const cwd = params?.cwd || "/home/user";
+        if (language !== "python" && language !== "javascript") {
+          throw new Error(`language must be 'python' or 'javascript', got: ${language}`);
+        }
+        const data = {
+          cwd,
+          language
+        };
+        return this.post({ path: "/contexts", data, config: params?.config });
+      }
+      /**
+       * Get context details
+       */
+      async getContext(params) {
+        return this.get({ path: `/contexts/${params.contextId}`, config: params.config });
+      }
+      /**
+       * Execute code in a context
+       */
+      async executeCode(params) {
+        const { code, contextId, language, timeout = 30, config: config2 } = params;
+        if (language && language !== "python" && language !== "javascript") {
+          throw new Error(`language must be 'python' or 'javascript', got: ${language}`);
+        }
+        const data = {
+          code
+        };
+        if (timeout !== void 0) {
+          data.timeout = timeout;
+        }
+        if (language !== void 0) {
+          data.language = language;
+        }
+        if (contextId !== void 0) {
+          data.contextId = contextId;
+        }
+        return this.post({ path: "/contexts/execute", data, config: config2 });
+      }
+      /**
+       * Delete a context
+       */
+      async deleteContext(params) {
+        return this.delete({ path: `/contexts/${params.contextId}`, config: params.config });
+      }
+      /**
+       * Read file contents
+       */
+      async readFile(params) {
+        const query = {
+          path: params.path
+        };
+        return this.get({ path: "/files", query, config: params.config });
+      }
+      /**
+       * Write file contents
+       */
+      async writeFile(params) {
+        const data = {
+          path: params.path,
+          content: params.content,
+          mode: params.mode || "644",
+          encoding: params.encoding || "utf-8",
+          createDir: params.createDir !== void 0 ? params.createDir : true
+        };
+        return this.post({ path: "/files", data, config: params.config });
+      }
+      /**
+       * Upload file to sandbox
+       */
+      async uploadFile(params) {
+        return this.postFile({
+          path: "/filesystem/upload",
+          localFilePath: params.localFilePath,
+          targetFilePath: params.targetFilePath,
+          config: params.config
+        });
+      }
+      /**
+       * Download file from sandbox
+       */
+      async downloadFile(params) {
+        const query = { path: params.path };
+        return this.getFile({
+          path: "/filesystem/download",
+          savePath: params.savePath,
+          query,
+          config: params.config
+        });
+      }
+      /**
+       * Execute shell command
+       */
+      async cmd(params) {
+        const data = {
+          command: params.command,
+          cwd: params.cwd
+        };
+        if (params.timeout !== void 0) {
+          data.timeout = params.timeout;
+        }
+        return this.post({ path: "/processes/cmd", data, config: params.config });
+      }
+      /**
+       * List running processes
+       */
+      async listProcesses(params) {
+        return this.get({ path: "/processes", config: params?.config });
+      }
+      /**
+       * Get process details
+       */
+      async getProcess(params) {
+        return this.get({ path: `/processes/${params.pid}`, config: params.config });
+      }
+      /**
+       * Kill a process
+       */
+      async killProcess(params) {
+        return this.delete({ path: `/processes/${params.pid}`, config: params.config });
+      }
+      /**
+       * Helper method to upload file using multipart/form-data
+       */
+      async postFile(params) {
+        const filename = path.basename(params.localFilePath);
+        const url = this.withPath(params.path, params.query);
+        const reqHeaders = this.prepareHeaders({ headers: params.headers, config: params.config });
+        delete reqHeaders["Content-Type"];
+        try {
+          const fileContent = await fs2.promises.readFile(params.localFilePath);
+          const formData = new FormData();
+          formData.append("file", new Blob([fileContent]), filename);
+          const data = params.formData || {};
+          data.path = params.targetFilePath;
+          Object.entries(data).forEach(([key, value]) => {
+            formData.append(key, String(value));
+          });
+          const cfg = Config.withConfigs(this.config, params.config);
+          const response = await fetch(url, {
+            method: "POST",
+            headers: reqHeaders,
+            body: formData,
+            signal: AbortSignal.timeout(cfg.timeout)
+          });
+          if (!response.ok) {
+            const errorText = await response.text();
+            throw new ClientError(response.status, errorText);
+          }
+          return response.json();
+        } catch (error) {
+          if (error instanceof ClientError) {
+            throw error;
+          }
+          logger.error(`Upload file error: ${error}`);
+          throw new ClientError(0, `Upload file error: ${error}`);
+        }
+      }
+      /**
+       * Helper method to download file
+       */
+      async getFile(params) {
+        const url = this.withPath(params.path, params.query);
+        const reqHeaders = this.prepareHeaders({ headers: params.headers, config: params.config });
+        try {
+          const cfg = Config.withConfigs(this.config, params.config);
+          const response = await fetch(url, {
+            method: "GET",
+            headers: reqHeaders,
+            signal: AbortSignal.timeout(cfg.timeout)
+          });
+          if (!response.ok) {
+            const errorText = await response.text();
+            throw new ClientError(response.status, errorText);
+          }
+          const arrayBuffer = await response.arrayBuffer();
+          const buffer = Buffer.from(arrayBuffer);
+          await fs2.promises.writeFile(params.savePath, buffer);
+          return {
+            savedPath: params.savePath,
+            size: buffer.length
+          };
+        } catch (error) {
+          if (error instanceof ClientError) {
+            throw error;
+          }
+          logger.error(`Download file error: ${error}`);
+          throw new ClientError(0, `Download file error: ${error}`);
+        }
+      }
+    };
+  }
+});
+
+// src/sandbox/api/aio-data.ts
+var AioDataAPI;
+var init_aio_data = __esm({
+  "src/sandbox/api/aio-data.ts"() {
+    init_browser_data();
+    init_code_interpreter_data();
+    AioDataAPI = class extends CodeInterpreterDataAPI {
+      browserAPI;
+      constructor(params) {
+        super({
+          sandboxId: params.sandboxId,
+          config: params.config
+        });
+        this.browserAPI = new BrowserDataAPI({
+          sandboxId: params.sandboxId,
+          config: params.config
+        });
+      }
+      // Browser API methods - delegate to browserAPI
+      /**
+       * Get CDP WebSocket URL for browser automation
+       */
+      getCdpUrl(record) {
+        return this.browserAPI.getCdpUrl(record);
+      }
+      /**
+       * Get VNC WebSocket URL for live view
+       */
+      getVncUrl(record) {
+        return this.browserAPI.getVncUrl(record);
+      }
+      /**
+       * List browser recordings
+       */
+      listRecordings = async (params) => {
+        return this.browserAPI.listRecordings(params);
+      };
+      /**
+       * Delete a recording
+       */
+      deleteRecording = async (params) => {
+        return this.browserAPI.deleteRecording(params);
+      };
+      /**
+       * Download a recording
+       */
+      downloadRecording = async (params) => {
+        return this.browserAPI.downloadRecording(params);
+      };
+    };
+  }
+});
+
+// src/utils/data-api.ts
+var init_data_api = __esm({
+  "src/utils/data-api.ts"() {
+    init_config();
+    init_exception();
+    init_log();
+  }
+});
+
+// src/utils/index.ts
+var init_utils = __esm({
+  "src/utils/index.ts"() {
+    init_version_check();
+    init_config();
+    init_data_api();
+    init_exception();
+    init_log();
+    init_model();
+  }
+});
+
+// src/utils/resource.ts
+function updateObjectProperties(target, source) {
+  for (const key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key) && typeof source[key] !== "function" && !key.startsWith("_")) {
+      target[key] = source[key];
+    }
+  }
+}
+function listAllResourcesFunction(list) {
+  return async (params) => {
+    const { config: config2, ...restParams } = params ?? {};
+    const allResults = [];
+    let page = 1;
+    const pageSize = 50;
+    while (true) {
+      const pageResults = await list({
+        input: {
+          ...restParams,
+          pageNumber: page,
+          pageSize
+        },
+        config: config2
+      });
+      page += 1;
+      allResults.push(...pageResults);
+      if (pageResults.length < pageSize) break;
+    }
+    const resultSet = /* @__PURE__ */ new Set();
+    const results = [];
+    for (const item of allResults) {
+      const uniqId = item.uniqIdCallback() || "";
+      if (!resultSet.has(uniqId) && uniqId) {
+        resultSet.add(uniqId);
+        results.push(item);
+      }
+    }
+    return results;
+  };
+}
+var ResourceBase;
+var init_resource = __esm({
+  "src/utils/resource.ts"() {
+    init_exception();
+    init_log();
+    init_model();
+    ResourceBase = class {
+      status;
+      _config;
+      // static async list(params?: {
+      //   input?: PageableInput;
+      //   config?: Config;
+      // }): Promise<WithUniqIdCallback[]> {
+      //   return [];
+      // }
+      waitUntil = async (params) => {
+        const { checkFinishedCallback, intervalSeconds = 5, timeoutSeconds = 300 } = params;
+        const startTime = Date.now();
+        while (true) {
+          if (await checkFinishedCallback(this)) return this;
+          if (Date.now() - startTime >= timeoutSeconds * 1e3) {
+            throw new Error("Timeout waiting for resource to reach desired state");
+          }
+          await new Promise((resolve) => setTimeout(resolve, intervalSeconds * 1e3));
+        }
+      };
+      waitUntilReadyOrFailed = async (params) => {
+        const { callback, intervalSeconds = 5, timeoutSeconds = 300 } = params ?? {};
+        async function checkFinishedCallback(resource) {
+          await resource.refresh();
+          if (callback) await callback(resource);
+          logger.debug(`Resource status: ${resource.status}`);
+          return isFinalStatus(resource.status);
+        }
+        return await this.waitUntil({
+          checkFinishedCallback,
+          intervalSeconds,
+          timeoutSeconds
+        });
+      };
+      deleteAndWaitUntilFinished = async (params) => {
+        const { callback, intervalSeconds = 5, timeoutSeconds = 300 } = params ?? {};
+        try {
+          await this.delete();
+        } catch (error) {
+          if (error instanceof ResourceNotExistError) return;
+        }
+        async function checkFinishedCallback(resource) {
+          try {
+            await resource.refresh();
+            if (callback) await callback(resource);
+          } catch (error) {
+            if (error instanceof ResourceNotExistError) return true;
+            if (resource.status === Status.DELETING) return false;
+            throw Error(`Resource status is ${resource.status}`);
+          }
+          return false;
+        }
+        return await this.waitUntil({
+          checkFinishedCallback,
+          intervalSeconds,
+          timeoutSeconds
+        });
+      };
+      refresh = async (params) => await this.get(params);
+      /**
+       * 更新实例自身的属性 / Update instance properties
+       *
+       * @param source - 源对象 / Source object
+       */
+      updateSelf(source) {
+        updateObjectProperties(this, source);
+      }
+      setConfig = (config2) => {
+        this._config = config2;
+        return this;
+      };
+    };
+  }
+});
+
+// src/sandbox/code-interpreter-sandbox.ts
+var code_interpreter_sandbox_exports = {};
+__export(code_interpreter_sandbox_exports, {
+  CodeInterpreterSandbox: () => CodeInterpreterSandbox,
+  ContextOperations: () => ContextOperations,
+  FileOperations: () => FileOperations,
+  FileSystemOperations: () => FileSystemOperations,
+  ProcessOperations: () => ProcessOperations
+});
+var FileOperations, FileSystemOperations, ProcessOperations, ContextOperations, CodeInterpreterSandbox;
+var init_code_interpreter_sandbox = __esm({
+  "src/sandbox/code-interpreter-sandbox.ts"() {
+    init_log();
+    init_exception();
+    init_code_interpreter_data();
+    init_model2();
+    init_sandbox();
+    FileOperations = class {
+      sandbox;
+      constructor(sandbox) {
+        this.sandbox = sandbox;
+      }
+      /**
+       * Read a file from the code interpreter
+       */
+      read = async (params) => {
+        return this.sandbox.dataApi.readFile(params);
+      };
+      /**
+       * Write a file to the code interpreter
+       */
+      write = async (params) => {
+        return this.sandbox.dataApi.writeFile(params);
+      };
+    };
+    FileSystemOperations = class {
+      sandbox;
+      constructor(sandbox) {
+        this.sandbox = sandbox;
+      }
+      /**
+       * List directory contents
+       */
+      list = async (params) => {
+        return this.sandbox.dataApi.listDirectory(params);
+      };
+      /**
+       * Move a file or directory
+       */
+      move = async (params) => {
+        return this.sandbox.dataApi.moveFile(params);
+      };
+      /**
+       * Remove a file or directory
+       */
+      remove = async (params) => {
+        return this.sandbox.dataApi.removeFile(params);
+      };
+      /**
+       * Get file or directory statistics
+       */
+      stat = async (params) => {
+        return this.sandbox.dataApi.stat(params);
+      };
+      /**
+       * Create a directory
+       */
+      mkdir = async (params) => {
+        return this.sandbox.dataApi.mkdir(params);
+      };
+      /**
+       * Upload a file to the code interpreter
+       */
+      upload = async (params) => {
+        return this.sandbox.dataApi.uploadFile(params);
+      };
+      /**
+       * Download a file from the code interpreter
+       */
+      download = async (params) => {
+        return this.sandbox.dataApi.downloadFile(params);
+      };
+    };
+    ProcessOperations = class {
+      sandbox;
+      constructor(sandbox) {
+        this.sandbox = sandbox;
+      }
+      /**
+       * Execute a command in the code interpreter
+       */
+      cmd = async (params) => {
+        return this.sandbox.dataApi.cmd(params);
+      };
+      /**
+       * List all processes
+       */
+      list = async (params) => {
+        return this.sandbox.dataApi.listProcesses(params);
+      };
+      /**
+       * Get a specific process by PID
+       */
+      get = async (params) => {
+        return this.sandbox.dataApi.getProcess(params);
+      };
+      /**
+       * Kill a specific process by PID
+       */
+      kill = async (params) => {
+        return this.sandbox.dataApi.killProcess(params);
+      };
+    };
+    ContextOperations = class {
+      sandbox;
+      _contextId;
+      _language;
+      _cwd;
+      constructor(sandbox) {
+        this.sandbox = sandbox;
+      }
+      /**
+       * Get the current context ID
+       */
+      get contextId() {
+        return this._contextId;
+      }
+      /**
+       * List all contexts
+       */
+      list = async (params) => {
+        return this.sandbox.dataApi.listContexts(params);
+      };
+      /**
+       * Create a new context and save its ID
+       */
+      create = async (params) => {
+        const language = params?.language || "python" /* PYTHON */;
+        const cwd = params?.cwd || "/home/user";
+        const result = await this.sandbox.dataApi.createContext({
+          language,
+          cwd
+        });
+        if (result?.id && result?.cwd && result?.language) {
+          this._contextId = result.id;
+          this._language = result.language;
+          this._cwd = result.cwd;
+          return this;
+        }
+        throw new ServerError(500, "Failed to create context");
+      };
+      /**
+       * Get a specific context by ID
+       */
+      get = async (params) => {
+        const id = params?.contextId || this._contextId;
+        if (!id) {
+          logger.error("context id is not set");
+          throw new Error("context id is not set");
+        }
+        const result = await this.sandbox.dataApi.getContext({ contextId: id });
+        if (result?.id && result?.cwd && result?.language) {
+          this._contextId = result.id;
+          this._language = result.language;
+          this._cwd = result.cwd;
+          return this;
+        }
+        throw new ServerError(500, "Failed to get context");
+      };
+      /**
+       * Execute code in a context
+       */
+      execute = async (params) => {
+        const { code, timeout = 30 } = params;
+        let { contextId, language } = params;
+        if (!contextId) {
+          contextId = this._contextId;
+        }
+        if (!contextId && !language) {
+          logger.debug("context id is not set, use default language: python");
+          language = "python" /* PYTHON */;
+        }
+        return this.sandbox.dataApi.executeCode({
+          code,
+          contextId,
+          language,
+          timeout
+        });
+      };
+      /**
+       * Delete a context
+       */
+      delete = async (params) => {
+        const id = params?.contextId || this._contextId;
+        if (!id) {
+          throw new Error(
+            "context_id is required. Either pass it as parameter or create a context first."
+          );
+        }
+        const result = await this.sandbox.dataApi.deleteContext({ contextId: id });
+        this._contextId = void 0;
+        return result;
+      };
+    };
+    CodeInterpreterSandbox = class extends Sandbox {
+      static templateType = "CodeInterpreter" /* CODE_INTERPRETER */;
+      /**
+       * Create a Code Interpreter Sandbox from template
+       * 从模板创建代码解释器沙箱 / Create Code Interpreter Sandbox from Template
+       */
+      static async createFromTemplate(templateName, options, config2) {
+        const sandbox = await Sandbox.create({
+          input: {
+            templateName,
+            sandboxIdleTimeoutSeconds: options?.sandboxIdleTimeoutSeconds,
+            nasConfig: options?.nasConfig,
+            ossMountConfig: options?.ossMountConfig,
+            polarFsConfig: options?.polarFsConfig
+          },
+          templateType: "CodeInterpreter" /* CODE_INTERPRETER */,
+          config: config2
+        });
+        return sandbox;
+      }
+      constructor(sandbox, config2) {
+        super(sandbox, config2);
+      }
+      _dataApi;
+      _file;
+      _fileSystem;
+      _context;
+      _process;
+      /**
+       * Get data API client
+       */
+      get dataApi() {
+        if (!this._dataApi) {
+          this._dataApi = new CodeInterpreterDataAPI({
+            sandboxId: this.sandboxId || "",
+            config: this._config
+          });
+        }
+        return this._dataApi;
+      }
+      /**
+       * Access file upload/download operations
+       */
+      get file() {
+        if (!this._file) {
+          this._file = new FileOperations(this);
+        }
+        return this._file;
+      }
+      /**
+       * Access file system operations
+       */
+      get fileSystem() {
+        if (!this._fileSystem) {
+          this._fileSystem = new FileSystemOperations(this);
+        }
+        return this._fileSystem;
+      }
+      /**
+       * Access context management operations
+       */
+      get context() {
+        if (!this._context) {
+          this._context = new ContextOperations(this);
+        }
+        return this._context;
+      }
+      /**
+       * Access process management operations
+       */
+      get process() {
+        if (!this._process) {
+          this._process = new ProcessOperations(this);
+        }
+        return this._process;
+      }
+      /**
+       * Check sandbox health
+       */
+      checkHealth = async (params) => {
+        return this.dataApi.checkHealth({
+          sandboxId: this.sandboxId,
+          config: params?.config
+        });
+      };
+      /**
+       * Execute code (convenience method delegating to context.execute)
+       */
+      execute = async (params) => {
+        return this.context.execute(params);
+      };
+    };
+  }
+});
+
+// src/sandbox/browser-sandbox.ts
+var browser_sandbox_exports = {};
+__export(browser_sandbox_exports, {
+  BrowserSandbox: () => BrowserSandbox
+});
+var BrowserSandbox;
+var init_browser_sandbox = __esm({
+  "src/sandbox/browser-sandbox.ts"() {
+    init_browser_data();
+    init_model2();
+    init_sandbox();
+    BrowserSandbox = class extends Sandbox {
+      static templateType = "Browser" /* BROWSER */;
+      /**
+       * Create a Browser Sandbox from template
+       * 从模板创建浏览器沙箱 / Create Browser Sandbox from Template
+       */
+      static async createFromTemplate(templateName, options, config2) {
+        const sandbox = await Sandbox.create({
+          input: {
+            templateName,
+            sandboxIdleTimeoutSeconds: options?.sandboxIdleTimeoutSeconds,
+            nasConfig: options?.nasConfig,
+            ossMountConfig: options?.ossMountConfig,
+            polarFsConfig: options?.polarFsConfig
+          },
+          templateType: "Browser" /* BROWSER */,
+          config: config2
+        });
+        return sandbox;
+      }
+      constructor(sandbox, config2) {
+        super(sandbox, config2);
+      }
+      _dataApi;
+      /**
+       * Get data API client
+       */
+      get dataApi() {
+        if (!this._dataApi) {
+          if (!this.sandboxId) {
+            throw new Error("Sandbox ID is not set");
+          }
+          this._dataApi = new BrowserDataAPI({
+            sandboxId: this.sandboxId,
+            config: this._config
+          });
+        }
+        return this._dataApi;
+      }
+      /**
+       * Check sandbox health
+       */
+      checkHealth = async (params) => {
+        return this.dataApi.checkHealth({
+          sandboxId: this.sandboxId,
+          config: params?.config
+        });
+      };
+      /**
+       * Get CDP WebSocket URL for browser automation
+       */
+      getCdpUrl(record) {
+        return this.dataApi.getCdpUrl(record);
+      }
+      /**
+       * Get VNC WebSocket URL for live view
+       */
+      getVncUrl(record) {
+        return this.dataApi.getVncUrl(record);
+      }
+      /**
+       * List all recordings
+       */
+      listRecordings = async (params) => {
+        return this.dataApi.listRecordings(params);
+      };
+      /**
+       * Download a recording video file
+       */
+      downloadRecording = async (params) => {
+        return this.dataApi.downloadRecording(params);
+      };
+      /**
+       * Delete a recording
+       */
+      deleteRecording = async (params) => {
+        return this.dataApi.deleteRecording(params);
+      };
+    };
+  }
+});
+
+// src/sandbox/custom-sandbox.ts
+var custom_sandbox_exports = {};
+__export(custom_sandbox_exports, {
+  CustomSandbox: () => CustomSandbox
+});
+var CustomSandbox;
+var init_custom_sandbox = __esm({
+  "src/sandbox/custom-sandbox.ts"() {
+    init_config();
+    init_model2();
+    init_sandbox();
+    init_sandbox_data();
+    CustomSandbox = class extends Sandbox {
+      static templateType = "CustomImage" /* CUSTOM */;
+      /**
+       * Create a Custom Sandbox from template
+       * 从模板创建自定义沙箱 / Create Custom Sandbox from Template
+       */
+      static async createFromTemplate(templateName, options, config2) {
+        return await Sandbox.create({
+          input: {
+            templateName,
+            sandboxIdleTimeoutSeconds: options?.sandboxIdleTimeoutSeconds,
+            nasConfig: options?.nasConfig,
+            ossMountConfig: options?.ossMountConfig,
+            polarFsConfig: options?.polarFsConfig
+          },
+          templateType: "CustomImage" /* CUSTOM */,
+          config: config2
+        });
+      }
+      constructor(sandbox, config2) {
+        super(sandbox, config2);
+      }
+      _dataApi;
+      /**
+       * Get data API client
+       */
+      get dataApi() {
+        if (!this._dataApi) {
+          this._dataApi = new SandboxDataAPI({
+            sandboxId: this.sandboxId || "",
+            config: this._config
+          });
+        }
+        return this._dataApi;
+      }
+      /**
+       * Get base URL for the sandbox
+       * 获取沙箱的基础 URL / Get base URL for the sandbox
+       *
+       * @returns 基础 URL / Base URL
+       */
+      getBaseUrl() {
+        const cfg = Config.withConfigs(this._config);
+        return `${cfg.dataEndpoint}/sandboxes/${this.sandboxId}`;
+      }
+    };
+  }
+});
+
+// src/sandbox/sandbox.ts
+var Sandbox;
+var init_sandbox = __esm({
+  "src/sandbox/sandbox.ts"() {
+    init_utils();
+    init_log();
+    init_config();
+    init_resource();
+    init_model2();
+    init_sandbox_data();
+    Sandbox = class _Sandbox extends ResourceBase {
+      templateType;
+      /**
+       * 沙箱 ID / Sandbox ID
+       */
+      sandboxId;
+      /**
+       * 沙箱名称 / Sandbox Name
+       */
+      sandboxName;
+      /**
+       * 模板 ID / Template ID
+       */
+      templateId;
+      /**
+       * 模板名称 / Template Name
+       */
+      templateName;
+      /**
+       * 沙箱状态 / Sandbox State
+       */
+      state;
+      /**
+       * 状态原因 / State Reason
+       */
+      stateReason;
+      /**
+       * 沙箱创建时间 / Sandbox Creation Time
+       */
+      createdAt;
+      /**
+       * 最后更新时间 / Last Updated Time
+       */
+      lastUpdatedAt;
+      /**
+       * 沙箱空闲超时时间（秒） / Sandbox Idle Timeout (seconds)
+       */
+      sandboxIdleTimeoutSeconds;
+      /**
+       * 沙箱结束时间 / Sandbox End Time
+       */
+      endedAt;
+      /**
+       * 元数据 / Metadata
+       */
+      metadata;
+      /**
+       * 沙箱全局唯一资源名称 / Sandbox ARN
+       */
+      sandboxArn;
+      /**
+       * 沙箱空闲 TTL（秒） / Sandbox Idle TTL (seconds)
+       */
+      sandboxIdleTTLInSeconds;
+      _config;
+      constructor(data, config2) {
+        super();
+        if (data) {
+          updateObjectProperties(this, data);
+        }
+        this._config = config2;
+      }
+      /**
+       * Create sandbox from SDK response object
+       * 从 SDK 响应对象创建沙箱 / Create Sandbox from SDK Response Object
+       */
+      static fromInnerObject(obj, config2) {
+        return new _Sandbox(
+          {
+            sandboxId: obj.sandboxId,
+            sandboxName: obj.sandboxName,
+            templateId: obj.templateId,
+            templateName: obj.templateName,
+            // API returns "status" field, map it to "state"
+            state: obj.status || obj.state,
+            stateReason: obj.stateReason,
+            createdAt: obj.createdAt,
+            lastUpdatedAt: obj.lastUpdatedAt,
+            sandboxIdleTimeoutSeconds: obj.sandboxIdleTimeoutSeconds,
+            // New fields / 新增字段
+            endedAt: obj.endedAt,
+            metadata: obj.metadata,
+            sandboxArn: obj.sandboxArn,
+            sandboxIdleTTLInSeconds: obj.sandboxIdleTTLInSeconds
+          },
+          config2
+        );
+      }
+      static getClient() {
+        const { SandboxClient: SandboxClient2 } = (init_client(), __toCommonJS(client_exports));
+        return new SandboxClient2();
+      }
+      static async create(arg1, arg2) {
+        if (typeof arg1 === "object" && arg1 !== null && "input" in arg1) {
+          return await _Sandbox.getClient().createSandbox(arg1);
+        }
+        logger.warn(
+          "Deprecated: Sandbox.create(input, config) is deprecated. Use Sandbox.create({ input, config }) instead."
+        );
+        return await _Sandbox.getClient().createSandbox(arg1, arg2);
+      }
+      static async delete(arg1, arg2) {
+        if (typeof arg1 === "string") {
+          logger.warn(
+            "Sandbox.delete(id, config) is deprecated. Use Sandbox.delete({ id, config }) instead."
+          );
+          return await _Sandbox.getClient().deleteSandbox(arg1, arg2);
+        }
+        return await _Sandbox.getClient().deleteSandbox(arg1);
+      }
+      static async stop(arg1, arg2) {
+        if (typeof arg1 === "string") {
+          logger.warn(
+            "Sandbox.stop(id, config) is deprecated. Use Sandbox.stop({ id, config }) instead."
+          );
+          return await _Sandbox.getClient().stopSandbox(arg1, arg2);
+        }
+        return await _Sandbox.getClient().stopSandbox(arg1);
+      }
+      static async get(arg1, arg2, arg3) {
+        let id;
+        let templateType;
+        let config2;
+        if (typeof arg1 === "string") {
+          logger.warn(
+            "Deprecated: Sandbox.get(id, templateType?, config?) is deprecated. Use Sandbox.get({ id, templateType, config }) instead."
+          );
+          id = arg1;
+          if (arg2 && typeof arg2 === "string") {
+            templateType = arg2;
+            config2 = arg3;
+          } else {
+            config2 = arg2;
+          }
+        } else {
+          id = arg1.id;
+          templateType = arg1.templateType;
+          config2 = arg1.config;
+        }
+        try {
+          const cfg = Config.withConfigs(config2);
+          const dataApi = new SandboxDataAPI({
+            sandboxId: id,
+            config: cfg
+          });
+          const result = await dataApi.getSandbox({
+            sandboxId: id,
+            config: cfg
+          });
+          if (result.code !== "SUCCESS") {
+            throw new ClientError(0, `Failed to get sandbox: ${result.message || "Unknown error"}`);
+          }
+          const data = result.data || {};
+          const baseSandbox = _Sandbox.fromInnerObject(data, config2);
+          if (templateType) {
+            switch (templateType) {
+              case "CodeInterpreter" /* CODE_INTERPRETER */: {
+                const { CodeInterpreterSandbox: CodeInterpreterSandbox2 } = await Promise.resolve().then(() => (init_code_interpreter_sandbox(), code_interpreter_sandbox_exports));
+                const sandbox = new CodeInterpreterSandbox2(baseSandbox, config2);
+                return sandbox;
+              }
+              case "Browser" /* BROWSER */: {
+                const { BrowserSandbox: BrowserSandbox2 } = await Promise.resolve().then(() => (init_browser_sandbox(), browser_sandbox_exports));
+                const sandbox = new BrowserSandbox2(baseSandbox, config2);
+                return sandbox;
+              }
+              case "AllInOne" /* AIO */: {
+                const { AioSandbox: AioSandbox2 } = await Promise.resolve().then(() => (init_aio_sandbox(), aio_sandbox_exports));
+                const sandbox = new AioSandbox2(baseSandbox, config2);
+                return sandbox;
+              }
+              case "CustomImage" /* CUSTOM */: {
+                const { CustomSandbox: CustomSandbox2 } = await Promise.resolve().then(() => (init_custom_sandbox(), custom_sandbox_exports));
+                const sandbox = new CustomSandbox2(baseSandbox, config2);
+                return sandbox;
+              }
+            }
+          }
+          return baseSandbox;
+        } catch (error) {
+          if (error instanceof HTTPError) {
+            throw error.toResourceError("Sandbox", id);
+          }
+          throw error;
+        }
+      }
+      static async list(arg1, arg2) {
+        if (arg2 !== void 0 || arg1 && ("maxResults" in arg1 || "nextToken" in arg1 || "status" in arg1 || "templateName" in arg1 || "templateType" in arg1)) {
+          logger.warn(
+            "Deprecated: Sandbox.list(input, config) is deprecated. Use Sandbox.list({ input, config }) instead."
+          );
+          return await _Sandbox.getClient().listSandboxes(arg1, arg2);
+        }
+        return await _Sandbox.getClient().listSandboxes(
+          arg1
+        );
+      }
+      get = async (params) => {
+        const { config: config2 } = params ?? {};
+        return await _Sandbox.get({
+          id: this.sandboxId,
+          templateType: this.templateType,
+          config: Config.withConfigs(this._config, config2)
+        });
+      };
+      /**
+       * Delete this sandbox
+       */
+      delete = async (params) => {
+        const config2 = params?.config;
+        if (!this.sandboxId) {
+          throw new Error("sandboxId is required to delete a Sandbox");
+        }
+        const result = await _Sandbox.delete({
+          id: this.sandboxId,
+          config: config2 ?? this._config
+        });
+        updateObjectProperties(this, result);
+        return this;
+      };
+      /**
+       * Stop this sandbox
+       */
+      stop = async (params) => {
+        const config2 = params?.config;
+        if (!this.sandboxId) {
+          throw new Error("sandboxId is required to stop a Sandbox");
+        }
+        const result = await _Sandbox.stop({
+          id: this.sandboxId,
+          config: config2 ?? this._config
+        });
+        updateObjectProperties(this, result);
+        return this;
+      };
+      /**
+       * Refresh this sandbox's data
+       */
+      refresh = async (params) => {
+        const config2 = params?.config;
+        if (!this.sandboxId) {
+          throw new Error("sandboxId is required to refresh a Sandbox");
+        }
+        const result = await _Sandbox.get({
+          id: this.sandboxId,
+          config: config2 ?? this._config
+        });
+        updateObjectProperties(this, result);
+        return this;
+      };
+      /**
+       * Wait until the sandbox is running
+       */
+      waitUntilRunning = async (options, config2) => {
+        const timeout = (options?.timeoutSeconds ?? 300) * 1e3;
+        const interval = (options?.intervalSeconds ?? 5) * 1e3;
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeout) {
+          await this.refresh({ config: config2 });
+          if (options?.beforeCheck) {
+            options.beforeCheck(this);
+          }
+          if (this.state === "Running" /* RUNNING */ || this.state === "READY" /* READY */) {
+            return this;
+          }
+          if (this.state === "Failed" /* FAILED */) {
+            throw new Error(`Sandbox failed: ${this.stateReason}`);
+          }
+          await new Promise((resolve) => setTimeout(resolve, interval));
+        }
+        throw new Error(
+          `Timeout waiting for Sandbox to be running after ${options?.timeoutSeconds ?? 300} seconds`
+        );
+      };
+    };
+  }
+});
+
+// src/sandbox/aio-sandbox.ts
+var aio_sandbox_exports = {};
+__export(aio_sandbox_exports, {
+  AioContextOperations: () => AioContextOperations,
+  AioFileOperations: () => AioFileOperations,
+  AioFileSystemOperations: () => AioFileSystemOperations,
+  AioProcessOperations: () => AioProcessOperations,
+  AioSandbox: () => AioSandbox
+});
+var AioFileOperations, AioFileSystemOperations, AioProcessOperations, AioContextOperations, AioSandbox;
+var init_aio_sandbox = __esm({
+  "src/sandbox/aio-sandbox.ts"() {
+    init_log();
+    init_exception();
+    init_aio_data();
+    init_model2();
+    init_sandbox();
+    AioFileOperations = class {
+      sandbox;
+      constructor(sandbox) {
+        this.sandbox = sandbox;
+      }
+      /**
+       * Read a file from the sandbox
+       */
+      read = async (path2) => {
+        return this.sandbox.dataApi.readFile({ path: path2 });
+      };
+      /**
+       * Write a file to the sandbox
+       */
+      write = async (params) => {
+        return this.sandbox.dataApi.writeFile(params);
+      };
+    };
+    AioFileSystemOperations = class {
+      sandbox;
+      constructor(sandbox) {
+        this.sandbox = sandbox;
+      }
+      /**
+       * List directory contents
+       */
+      list = async (params) => {
+        return this.sandbox.dataApi.listDirectory(params);
+      };
+      /**
+       * Move a file or directory
+       */
+      move = async (params) => {
+        return this.sandbox.dataApi.moveFile(params);
+      };
+      /**
+       * Remove a file or directory
+       */
+      remove = async (params) => {
+        return this.sandbox.dataApi.removeFile(params);
+      };
+      /**
+       * Get file or directory statistics
+       */
+      stat = async (params) => {
+        return this.sandbox.dataApi.stat(params);
+      };
+      /**
+       * Create a directory
+       */
+      mkdir = async (params) => {
+        return this.sandbox.dataApi.mkdir(params);
+      };
+      /**
+       * Upload a file to the sandbox
+       */
+      upload = async (params) => {
+        return this.sandbox.dataApi.uploadFile(params);
+      };
+      /**
+       * Download a file from the sandbox
+       */
+      download = async (params) => {
+        return this.sandbox.dataApi.downloadFile(params);
+      };
+    };
+    AioProcessOperations = class {
+      sandbox;
+      constructor(sandbox) {
+        this.sandbox = sandbox;
+      }
+      /**
+       * Execute a command in the sandbox
+       */
+      cmd = async (params) => {
+        return this.sandbox.dataApi.cmd(params);
+      };
+      /**
+       * List all processes
+       */
+      list = async (params) => {
+        return this.sandbox.dataApi.listProcesses(params);
+      };
+      /**
+       * Get a specific process by PID
+       */
+      get = async (params) => {
+        return this.sandbox.dataApi.getProcess(params);
+      };
+      /**
+       * Kill a specific process by PID
+       */
+      kill = async (params) => {
+        return this.sandbox.dataApi.killProcess(params);
+      };
+    };
+    AioContextOperations = class {
+      sandbox;
+      _contextId;
+      _language;
+      _cwd;
+      constructor(sandbox) {
+        this.sandbox = sandbox;
+      }
+      /**
+       * Get the current context ID
+       */
+      get contextId() {
+        return this._contextId;
+      }
+      /**
+       * List all contexts
+       */
+      list = async (params) => {
+        return this.sandbox.dataApi.listContexts(params);
+      };
+      /**
+       * Create a new context and save its ID
+       */
+      create = async (params) => {
+        const language = params?.language || "python" /* PYTHON */;
+        const cwd = params?.cwd || "/home/user";
+        const result = await this.sandbox.dataApi.createContext({
+          language,
+          cwd
+        });
+        if (result?.id && result?.cwd && result?.language) {
+          this._contextId = result.id;
+          this._language = result.language;
+          this._cwd = result.cwd;
+          return this;
+        }
+        throw new ServerError(500, "Failed to create context");
+      };
+      /**
+       * Get a specific context by ID
+       */
+      get = async (params) => {
+        const id = params?.contextId || this._contextId;
+        if (!id) {
+          logger.error("context id is not set");
+          throw new Error("context id is not set");
+        }
+        const result = await this.sandbox.dataApi.getContext({ contextId: id });
+        if (result?.id && result?.cwd && result?.language) {
+          this._contextId = result.id;
+          this._language = result.language;
+          this._cwd = result.cwd;
+          return this;
+        }
+        throw new ServerError(500, "Failed to get context");
+      };
+      /**
+       * Execute code in a context
+       */
+      execute = async (params) => {
+        const { code, timeout = 30 } = params;
+        let { contextId, language } = params;
+        if (!contextId) {
+          contextId = this._contextId;
+        }
+        if (!contextId && !language) {
+          logger.debug("context id is not set, use default language: python");
+          language = "python" /* PYTHON */;
+        }
+        return this.sandbox.dataApi.executeCode({
+          code,
+          contextId,
+          language,
+          timeout
+        });
+      };
+      /**
+       * Delete a context
+       */
+      delete = async (params) => {
+        const id = params?.contextId || this._contextId;
+        if (!id) {
+          throw new Error(
+            "context_id is required. Either pass it as parameter or create a context first."
+          );
+        }
+        const result = await this.sandbox.dataApi.deleteContext({ contextId: id });
+        this._contextId = void 0;
+        return result;
+      };
+    };
+    AioSandbox = class extends Sandbox {
+      static templateType = "AllInOne" /* AIO */;
+      /**
+       * Create an AIO Sandbox from template
+       * 从模板创建 AIO 沙箱 / Create AIO Sandbox from Template
+       */
+      static async createFromTemplate(templateName, options, config2) {
+        const sandbox = await Sandbox.create({
+          input: {
+            templateName,
+            sandboxIdleTimeoutSeconds: options?.sandboxIdleTimeoutSeconds,
+            nasConfig: options?.nasConfig,
+            ossMountConfig: options?.ossMountConfig,
+            polarFsConfig: options?.polarFsConfig
+          },
+          templateType: "AllInOne" /* AIO */,
+          config: config2
+        });
+        return sandbox;
+      }
+      constructor(sandbox, config2) {
+        super(sandbox, config2);
+      }
+      _dataApi;
+      _file;
+      _fileSystem;
+      _context;
+      _process;
+      /**
+       * Get data API client
+       */
+      get dataApi() {
+        if (!this._dataApi) {
+          this._dataApi = new AioDataAPI({
+            sandboxId: this.sandboxId || "",
+            config: this._config
+          });
+        }
+        return this._dataApi;
+      }
+      /**
+       * Access file upload/download operations
+       */
+      get file() {
+        if (!this._file) {
+          this._file = new AioFileOperations(this);
+        }
+        return this._file;
+      }
+      /**
+       * Access file system operations
+       */
+      get fileSystem() {
+        if (!this._fileSystem) {
+          this._fileSystem = new AioFileSystemOperations(this);
+        }
+        return this._fileSystem;
+      }
+      /**
+       * Access context management operations
+       */
+      get context() {
+        if (!this._context) {
+          this._context = new AioContextOperations(this);
+        }
+        return this._context;
+      }
+      /**
+       * Access process management operations
+       */
+      get process() {
+        if (!this._process) {
+          this._process = new AioProcessOperations(this);
+        }
+        return this._process;
+      }
+      /**
+       * Check sandbox health
+       */
+      checkHealth = async (params) => {
+        return this.dataApi.checkHealth({
+          sandboxId: this.sandboxId,
+          config: params?.config
+        });
+      };
+      // ========================================
+      // Browser API Methods
+      // ========================================
+      /**
+       * Get CDP WebSocket URL for browser automation
+       */
+      getCdpUrl(record) {
+        return this.dataApi.getCdpUrl(record);
+      }
+      /**
+       * Get VNC WebSocket URL for live view
+       */
+      getVncUrl(record) {
+        return this.dataApi.getVncUrl(record);
+      }
+      /**
+       * List all browser recordings
+       */
+      listRecordings = async (params) => {
+        return this.dataApi.listRecordings(params);
+      };
+      /**
+       * Download a recording video file
+       */
+      downloadRecording = async (params) => {
+        return this.dataApi.downloadRecording(params);
+      };
+      /**
+       * Delete a recording
+       */
+      deleteRecording = async (params) => {
+        return this.dataApi.deleteRecording(params);
+      };
+      // ========================================
+      // Code Interpreter API Methods
+      // ========================================
+      /**
+       * Execute code (convenience method delegating to context.execute)
+       */
+      execute = async (params) => {
+        return this.context.execute(params);
+      };
+    };
+  }
+});
+
+// src/sandbox/template.ts
+var Template;
+var init_template = __esm({
+  "src/sandbox/template.ts"() {
+    init_resource();
+    Template = class _Template extends ResourceBase {
+      /**
+       * 模板 ARN / Template ARN
+       */
+      templateArn;
+      /**
+       * 模板 ID / Template ID
+       */
+      templateId;
+      /**
+       * 模板名称 / Template Name
+       */
+      templateName;
+      /**
+       * 模板类型 / Template Type
+       */
+      templateType;
+      /**
+       * CPU 核数 / CPU Cores
+       */
+      cpu;
+      /**
+       * 内存大小（MB） / Memory Size (MB)
+       */
+      memory;
+      /**
+       * 创建时间 / Creation Time
+       */
+      createdAt;
+      /**
+       * 描述 / Description
+       */
+      description;
+      /**
+       * 执行角色 ARN / Execution Role ARN
+       */
+      executionRoleArn;
+      /**
+       * 最后更新时间 / Last Updated Time
+       */
+      lastUpdatedAt;
+      /**
+       * 资源名称 / Resource Name
+       */
+      resourceName;
+      /**
+       * 沙箱空闲超时时间（秒） / Sandbox Idle Timeout (seconds)
+       */
+      sandboxIdleTimeoutInSeconds;
+      /**
+       * 沙箱存活时间（秒） / Sandbox TTL (seconds)
+       */
+      sandboxTtlInSeconds;
+      /**
+       * 每个沙箱的最大并发会话数 / Max Concurrency Limit Per Sandbox
+       */
+      shareConcurrencyLimitPerSandbox;
+      /**
+       * 状态原因 / Status Reason
+       */
+      statusReason;
+      /**
+       * 磁盘大小（GB） / Disk Size (GB)
+       */
+      diskSize;
+      /**
+       * 是否允许匿名管理 / Whether to allow anonymous management
+       */
+      allowAnonymousManage;
+      _config;
+      constructor(data, config2) {
+        super();
+        if (data) {
+          updateObjectProperties(this, data);
+          this.normalizeNumericFields();
+        }
+        this._config = config2;
+      }
+      uniqIdCallback = () => this.templateId;
+      static getClient() {
+        const { SandboxClient: SandboxClient2 } = (init_client(), __toCommonJS(client_exports));
+        return new SandboxClient2();
+      }
+      /**
+       * Create a new Template
+       */
+      static async create(params) {
+        return await _Template.getClient().createTemplate(params);
+      }
+      /**
+       * Delete a Template by name
+       */
+      static async delete(params) {
+        return await _Template.getClient().deleteTemplate(params);
+      }
+      /**
+       * Update a Template by name
+       */
+      static async update(params) {
+        return await _Template.getClient().updateTemplate(params);
+      }
+      /**
+       * Get a Template by name
+       */
+      static async get(params) {
+        return await _Template.getClient().getTemplate(params);
+      }
+      /**
+       * List Templates
+       */
+      static async list(params) {
+        return await _Template.getClient().listTemplates(params);
+      }
+      /**
+       * List all Templates (with pagination)
+       */
+      static listAll = listAllResourcesFunction(this.list);
+      get = async (params = {}) => {
+        return await _Template.get({
+          name: this.templateName,
+          config: params.config
+        });
+      };
+      /**
+       * Delete this template
+       */
+      delete = async (params) => {
+        const config2 = params?.config;
+        if (!this.templateName) {
+          throw new Error("templateName is required to delete a Template");
+        }
+        const result = await _Template.delete({
+          name: this.templateName,
+          config: config2 ?? this._config
+        });
+        updateObjectProperties(this, result);
+        this.normalizeNumericFields();
+        return this;
+      };
+      /**
+       * Update this template
+       */
+      update = async (params) => {
+        const { input, config: config2 } = params;
+        if (!this.templateName) {
+          throw new Error("templateName is required to update a Template");
+        }
+        const result = await _Template.update({
+          name: this.templateName,
+          input,
+          config: config2 ?? this._config
+        });
+        updateObjectProperties(this, result);
+        this.normalizeNumericFields();
+        return this;
+      };
+      /**
+       * Refresh this template's data
+       */
+      refresh = async (params) => {
+        const config2 = params?.config;
+        if (!this.templateName) {
+          throw new Error("templateName is required to refresh a Template");
+        }
+        const result = await _Template.get({
+          name: this.templateName,
+          config: config2 ?? this._config
+        });
+        updateObjectProperties(this, result);
+        this.normalizeNumericFields();
+        return this;
+      };
+      normalizeNumericFields() {
+        const toNumber = (value) => {
+          if (typeof value === "number") return value;
+          if (typeof value === "string") {
+            const parsed = Number(value);
+            return Number.isNaN(parsed) ? void 0 : parsed;
+          }
+          return void 0;
+        };
+        this.sandboxIdleTimeoutInSeconds = toNumber(this.sandboxIdleTimeoutInSeconds);
+        this.sandboxTtlInSeconds = toNumber(this.sandboxTtlInSeconds);
+        this.shareConcurrencyLimitPerSandbox = toNumber(this.shareConcurrencyLimitPerSandbox);
+        this.cpu = toNumber(this.cpu);
+        this.memory = toNumber(this.memory);
+        this.diskSize = toNumber(this.diskSize);
+      }
+    };
+  }
+});
+
+// src/sandbox/client.ts
+var client_exports = {};
+__export(client_exports, {
+  SandboxClient: () => SandboxClient
+});
+var SandboxClient;
+var init_client = __esm({
+  "src/sandbox/client.ts"() {
+    init_config();
+    init_exception();
+    init_log();
+    init_control();
+    init_aio_sandbox();
+    init_browser_sandbox();
+    init_code_interpreter_sandbox();
+    init_custom_sandbox();
+    init_model2();
+    init_sandbox();
+    init_template();
+    SandboxClient = class {
+      config;
+      controlApi;
+      constructor(config2) {
+        this.config = config2;
+        this.controlApi = new SandboxControlAPI(config2);
+      }
+      // ============ Template Operations ============
+      /**
+       * Create a Template
+       */
+      createTemplate = async (arg1, arg2) => {
+        let input;
+        let config2;
+        if ("input" in arg1) {
+          input = arg1.input;
+          config2 = arg1.config;
+        } else {
+          logger.warn(
+            "Deprecated: createTemplate(input, config) is deprecated. Use createTemplate({ input, config }) instead."
+          );
+          input = arg1;
+          config2 = arg2;
+        }
+        const cfg = Config.withConfigs(this.config, config2);
+        try {
+          const finalInput = this.prepareTemplateCreateInput(input);
+          const result = await this.controlApi.createTemplate({
+            input: new $AgentRun4.CreateTemplateInput({
+              ...finalInput,
+              networkConfiguration: finalInput.networkConfiguration ? new $AgentRun4.NetworkConfiguration({
+                ...finalInput.networkConfiguration
+              }) : void 0
+            }),
+            config: cfg
+          });
+          return new Template(result, cfg);
+        } catch (error) {
+          if (error instanceof HTTPError) {
+            throw error.toResourceError("Template", input.templateName);
+          }
+          throw error;
+        }
+      };
+      /**
+       * Delete a Template
+       */
+      deleteTemplate = async (arg1, arg2) => {
+        let name;
+        let config2;
+        if (typeof arg1 === "string") {
+          logger.warn(
+            "Deprecated: deleteTemplate(name, config) is deprecated. Use deleteTemplate({ name, config }) instead."
+          );
+          name = arg1;
+          config2 = arg2;
+        } else {
+          name = arg1.name;
+          config2 = arg1.config;
+        }
+        const cfg = Config.withConfigs(this.config, config2);
+        try {
+          const result = await this.controlApi.deleteTemplate({
+            templateName: name,
+            config: cfg
+          });
+          return new Template(result, cfg);
+        } catch (error) {
+          if (error instanceof HTTPError) {
+            throw error.toResourceError("Template", name);
+          }
+          throw error;
+        }
+      };
+      /**
+       * Update a Template
+       */
+      updateTemplate = async (arg1, arg2, arg3) => {
+        let name;
+        let input;
+        let config2;
+        if (typeof arg1 === "string") {
+          logger.warn(
+            "Deprecated: updateTemplate(name, input, config) is deprecated. Use updateTemplate({ name, input, config }) instead."
+          );
+          name = arg1;
+          input = arg2;
+          config2 = arg3;
+        } else {
+          name = arg1.name;
+          input = arg1.input;
+          config2 = arg1.config;
+        }
+        const cfg = Config.withConfigs(this.config, config2);
+        try {
+          const result = await this.controlApi.updateTemplate({
+            templateName: name,
+            input: new $AgentRun4.UpdateTemplateInput({
+              ...input,
+              networkConfiguration: input.networkConfiguration ? new $AgentRun4.NetworkConfiguration({
+                ...input.networkConfiguration
+              }) : void 0
+            }),
+            config: cfg
+          });
+          return new Template(result, cfg);
+        } catch (error) {
+          if (error instanceof HTTPError) {
+            throw error.toResourceError("Template", name);
+          }
+          throw error;
+        }
+      };
+      /**
+       * Get a Template
+       */
+      getTemplate = async (arg1, arg2) => {
+        let name;
+        let config2;
+        if (typeof arg1 === "string") {
+          logger.warn(
+            "Deprecated: getTemplate(name, config) is deprecated. Use getTemplate({ name, config }) instead."
+          );
+          name = arg1;
+          config2 = arg2;
+        } else {
+          name = arg1.name;
+          config2 = arg1.config;
+        }
+        const cfg = Config.withConfigs(this.config, config2);
+        try {
+          const result = await this.controlApi.getTemplate({
+            templateName: name,
+            config: cfg
+          });
+          return new Template(result, cfg);
+        } catch (error) {
+          if (error instanceof HTTPError) {
+            throw error.toResourceError("Template", name);
+          }
+          throw error;
+        }
+      };
+      /**
+       * List Templates
+       */
+      listTemplates = async (arg1, arg2) => {
+        let input;
+        let config2;
+        if (arg2 || arg1 && ("pageNumber" in arg1 || "pageSize" in arg1 || "templateType" in arg1)) {
+          logger.warn(
+            "Deprecated: listTemplates(input, config) is deprecated. Use listTemplates({ input, config }) instead."
+          );
+          input = arg1;
+          config2 = arg2;
+        } else {
+          const params = arg1 ?? {};
+          input = params.input;
+          config2 = params.config;
+        }
+        const cfg = Config.withConfigs(this.config, config2);
+        const request = new $AgentRun4.ListTemplatesRequest({
+          ...input
+        });
+        const result = await this.controlApi.listTemplates({
+          input: request,
+          config: cfg
+        });
+        return (result?.items || []).map((item) => new Template(item, cfg));
+      };
+      // ============ Sandbox Operations ============
+      /**
+       * Create a Sandbox
+       */
+      createSandbox = async (arg1, arg2) => {
+        let input;
+        let templateType;
+        let config2;
+        if ("input" in arg1) {
+          const params = arg1;
+          input = params.input;
+          templateType = params.templateType;
+          config2 = params.config;
+        } else {
+          logger.warn(
+            "Deprecated: createSandbox(input, config) is deprecated. Use createSandbox({ input, config }) instead."
+          );
+          input = arg1;
+          config2 = arg2;
+        }
+        const cfg = Config.withConfigs(this.config, config2);
+        try {
+          const result = await this.controlApi.createSandbox({
+            input: new $AgentRun4.CreateSandboxInput({
+              ...input
+            }),
+            config: cfg
+          });
+          const state = result.status ?? result.state;
+          const sb = new Sandbox({ ...result, state }, cfg);
+          if (templateType === "CodeInterpreter" /* CODE_INTERPRETER */)
+            return new CodeInterpreterSandbox(sb, cfg);
+          else if (templateType === "Browser" /* BROWSER */) return new BrowserSandbox(sb, cfg);
+          else if (templateType === "AllInOne" /* AIO */) return new AioSandbox(sb, cfg);
+          else if (templateType === "CustomImage" /* CUSTOM */) return new CustomSandbox(sb, cfg);
+          return sb;
+        } catch (error) {
+          if (error instanceof HTTPError) {
+            throw error.toResourceError("Sandbox", input.templateName);
+          }
+          throw error;
+        }
+      };
+      /**
+       * Create a Code Interpreter Sandbox
+       * 创建代码解释器沙箱 / Create Code Interpreter Sandbox
+       */
+      createCodeInterpreterSandbox = async (params) => {
+        const { templateName, options, config: config2 } = params;
+        return CodeInterpreterSandbox.createFromTemplate(templateName, options, config2 ?? this.config);
+      };
+      /**
+       * Create a Browser Sandbox
+       * 创建浏览器沙箱 / Create Browser Sandbox
+       */
+      createBrowserSandbox = async (params) => {
+        const { templateName, options, config: config2 } = params;
+        return BrowserSandbox.createFromTemplate(templateName, options, config2 ?? this.config);
+      };
+      /**
+       * Delete a Sandbox
+       */
+      deleteSandbox = async (arg1, arg2) => {
+        let id;
+        let config2;
+        if (typeof arg1 === "string") {
+          logger.warn(
+            "Deprecated: deleteSandbox(id, config) is deprecated. Use deleteSandbox({ id, config }) instead."
+          );
+          id = arg1;
+          config2 = arg2;
+        } else {
+          id = arg1.id;
+          config2 = arg1.config;
+        }
+        const cfg = Config.withConfigs(this.config, config2);
+        try {
+          const result = await this.controlApi.deleteSandbox({
+            sandboxId: id,
+            config: cfg
+          });
+          return Sandbox.fromInnerObject(result, cfg);
+        } catch (error) {
+          if (error instanceof HTTPError) {
+            throw error.toResourceError("Sandbox", id);
+          }
+          throw error;
+        }
+      };
+      /**
+       * Stop a Sandbox
+       */
+      stopSandbox = async (arg1, arg2) => {
+        let id;
+        let config2;
+        if (typeof arg1 === "string") {
+          logger.warn(
+            "Deprecated: stopSandbox(id, config) is deprecated. Use stopSandbox({ id, config }) instead."
+          );
+          id = arg1;
+          config2 = arg2;
+        } else {
+          id = arg1.id;
+          config2 = arg1.config;
+        }
+        const cfg = Config.withConfigs(this.config, config2);
+        try {
+          const result = await this.controlApi.stopSandbox({
+            sandboxId: id,
+            config: cfg
+          });
+          return Sandbox.fromInnerObject(result, cfg);
+        } catch (error) {
+          if (error instanceof HTTPError) {
+            throw error.toResourceError("Sandbox", id);
+          }
+          throw error;
+        }
+      };
+      /**
+       * Get a Sandbox
+       *
+       * @param params.id - Sandbox ID
+       * @param params.templateType - Template type to cast the result to the appropriate subclass
+       * @param params.config - Configuration
+       */
+      getSandbox = async (arg1, arg2, arg3) => {
+        let id;
+        let templateType;
+        let config2;
+        if (typeof arg1 === "string") {
+          logger.warn(
+            "Deprecated: getSandbox(id, templateType, config?) is deprecated. Use getSandbox({ id, templateType, config }) instead."
+          );
+          id = arg1;
+          if (arg2 && typeof arg2 === "string") {
+            templateType = arg2;
+            config2 = arg3;
+          } else {
+            config2 = arg2;
+          }
+        } else {
+          id = arg1.id;
+          templateType = arg1.templateType;
+          config2 = arg1.config;
+        }
+        const cfg = Config.withConfigs(this.config, config2);
+        try {
+          const result = await this.controlApi.getSandbox({
+            sandboxId: id,
+            config: cfg
+          });
+          const baseSandbox = Sandbox.fromInnerObject(result, cfg);
+          if (templateType) {
+            switch (templateType) {
+              case "CodeInterpreter" /* CODE_INTERPRETER */: {
+                return new CodeInterpreterSandbox(baseSandbox, cfg);
+              }
+              case "Browser" /* BROWSER */: {
+                return new BrowserSandbox(baseSandbox, cfg);
+              }
+              case "AllInOne" /* AIO */: {
+                const { AioSandbox: AioSandbox2 } = await Promise.resolve().then(() => (init_aio_sandbox(), aio_sandbox_exports));
+                return new AioSandbox2(baseSandbox, cfg);
+              }
+            }
+          }
+          return baseSandbox;
+        } catch (error) {
+          if (error instanceof HTTPError) {
+            throw error.toResourceError("Sandbox", id);
+          }
+          throw error;
+        }
+      };
+      /**
+       * List Sandboxes
+       */
+      listSandboxes = async (arg1, arg2) => {
+        let input;
+        let config2;
+        if (arg2 || arg1 && ("maxResults" in arg1 || "nextToken" in arg1 || "status" in arg1 || "templateName" in arg1 || "templateType" in arg1)) {
+          logger.warn(
+            "Deprecated: listSandboxes(input, config) is deprecated. Use listSandboxes({ input, config }) instead."
+          );
+          input = arg1;
+          config2 = arg2;
+        } else {
+          const params = arg1 ?? {};
+          input = params.input;
+          config2 = params.config;
+        }
+        const cfg = Config.withConfigs(this.config, config2);
+        const request = new $AgentRun4.ListSandboxesRequest({
+          ...input
+        });
+        const result = await this.controlApi.listSandboxes({
+          input: request,
+          config: cfg
+        });
+        return (result.sandboxes || []).map(
+          (item) => Sandbox.fromInnerObject(item, cfg)
+        );
+      };
+      prepareTemplateCreateInput(input) {
+        const defaults = this.getTemplateDefaults(input.templateType);
+        const finalInput = { ...defaults, ...input };
+        if (!finalInput.networkConfiguration) {
+          finalInput.networkConfiguration = {
+            networkMode: "PUBLIC" /* PUBLIC */
+          };
+        }
+        this.validateTemplateCreateInput(finalInput);
+        return finalInput;
+      }
+      getTemplateDefaults(templateType) {
+        const base = {
+          cpu: 2,
+          memory: 4096,
+          sandboxIdleTimeoutInSeconds: 1800,
+          sandboxTtlInSeconds: 21600,
+          shareConcurrencyLimitPerSandbox: 200
+        };
+        switch (templateType) {
+          case "CodeInterpreter" /* CODE_INTERPRETER */:
+            return { ...base, diskSize: 512 };
+          case "Browser" /* BROWSER */:
+          case "AllInOne" /* AIO */:
+            return { ...base, cpu: 4, memory: 8192, diskSize: 10240 };
+          default:
+            return { ...base, diskSize: 512 };
+        }
+      }
+      validateTemplateCreateInput(input) {
+        if ((input.templateType === "Browser" /* BROWSER */ || input.templateType === "AllInOne" /* AIO */) && input.diskSize !== 10240) {
+          throw new Error(
+            `When templateType is BROWSER or AIO, diskSize must be 10240, got ${input.diskSize}`
+          );
+        }
+        if ((input.templateType === "CodeInterpreter" /* CODE_INTERPRETER */ || input.templateType === "AllInOne" /* AIO */) && input.networkConfiguration?.networkMode === "PRIVATE" /* PRIVATE */) {
+          throw new Error(
+            `When templateType is CODE_INTERPRETER or AIO, networkMode cannot be PRIVATE`
+          );
+        }
+      }
+    };
+  }
+});
+
+// src/sandbox/index.ts
+init_version_check();
+init_client();
+init_sandbox();
+init_template();
+init_code_interpreter_sandbox();
+init_browser_sandbox();
+init_aio_sandbox();
+init_custom_sandbox();
+init_sandbox_data();
+init_code_interpreter_data();
+init_browser_data();
+init_aio_data();
+init_model2();
+
+export { AioDataAPI, AioSandbox, BrowserDataAPI, BrowserSandbox, CodeInterpreterDataAPI, CodeInterpreterSandbox, CodeLanguage, CustomSandbox, Sandbox, SandboxClient, SandboxDataAPI, SandboxState, Template, TemplateNetworkMode, TemplateOSSPermission, TemplateType };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map