@agentrun/sdk 0.0.3-test.21197424453 → 0.0.3

package/dist/index.cjs

@@ -4071,12 +4071,11 @@ exports.TemplateType = void 0; exports.SandboxState = void 0; exports.TemplateNe
 var init_model4 = __esm({
   "src/sandbox/model.ts"() {
     init_model();
-    exports.TemplateType = /* @__PURE__ */ ((TemplateType2) => {
-      TemplateType2["CODE_INTERPRETER"] = "CodeInterpreter";
-      TemplateType2["BROWSER"] = "Browser";
-      TemplateType2["AIO"] = "AllInOne";
-      TemplateType2["CUSTOM"] = "CustomImage";
-      return TemplateType2;
+    exports.TemplateType = /* @__PURE__ */ ((TemplateType3) => {
+      TemplateType3["CODE_INTERPRETER"] = "CodeInterpreter";
+      TemplateType3["BROWSER"] = "Browser";
+      TemplateType3["AIO"] = "AllInOne";
+      return TemplateType3;
     })(exports.TemplateType || {});
     exports.SandboxState = /* @__PURE__ */ ((SandboxState2) => {
       SandboxState2["CREATING"] = "Creating";
@@ -4104,675 +4103,618 @@ var init_model4 = __esm({
     })(exports.CodeLanguage || {});
   }
 });
-exports.CodeInterpreterDataAPI = void 0;
-var init_code_interpreter_data = __esm({
-  "src/sandbox/api/code-interpreter-data.ts"() {
+
+// src/sandbox/sandbox.ts
+exports.Sandbox = void 0;
+var init_sandbox = __esm({
+  "src/sandbox/sandbox.ts"() {
     init_config();
-    init_exception();
-    init_log();
+    init_resource();
     init_model4();
-    init_sandbox_data();
-    exports.CodeInterpreterDataAPI = class extends exports.SandboxDataAPI {
-      constructor(params) {
-        super({
-          sandboxId: params.sandboxId,
-          config: params.config,
-          // Set namespace to include sandboxId for correct API path generation
-          namespace: `sandboxes/${params.sandboxId}`
-        });
-      }
+    exports.Sandbox = class _Sandbox extends ResourceBase {
+      templateType;
       /**
-       * List directory contents
+       * 沙箱 ID / Sandbox ID
        */
-      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 });
-      }
+      sandboxId;
       /**
-       * Get file/directory stats
+       * 沙箱名称 / Sandbox Name
        */
-      async stat(params) {
-        const query = {
-          path: params.path
-        };
-        return this.get({ path: "/filesystem/stat", query, config: params.config });
-      }
+      sandboxName;
       /**
-       * Create directory
+       * 模板 ID / Template ID
        */
-      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 });
-      }
+      templateId;
       /**
-       * Move file or directory
+       * 模板名称 / Template Name
        */
-      async moveFile(params) {
-        const data = {
-          source: params.source,
-          destination: params.destination
-        };
-        return this.post({ path: "/filesystem/move", data, config: params.config });
-      }
+      templateName;
       /**
-       * Remove file or directory
+       * 沙箱状态 / Sandbox State
        */
-      async removeFile(params) {
-        const data = {
-          path: params.path
-        };
-        return this.post({ path: "/filesystem/remove", data, config: params.config });
-      }
+      state;
       /**
-       * List code execution contexts
+       * 状态原因 / State Reason
        */
-      async listContexts(params) {
-        return this.get({ path: "/contexts", config: params?.config });
-      }
+      stateReason;
       /**
-       * Create a new code execution context
+       * 沙箱创建时间 / Sandbox Creation Time
        */
-      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 });
-      }
+      createdAt;
       /**
-       * Get context details
+       * 最后更新时间 / Last Updated Time
        */
-      async getContext(params) {
-        return this.get({ path: `/contexts/${params.contextId}`, config: params.config });
-      }
+      lastUpdatedAt;
       /**
-       * Execute code in a context
+       * 沙箱空闲超时时间（秒） / Sandbox Idle Timeout (seconds)
        */
-      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 });
-      }
+      sandboxIdleTimeoutSeconds;
       /**
-       * Delete a context
+       * 沙箱结束时间 / Sandbox End Time
        */
-      async deleteContext(params) {
-        return this.delete({ path: `/contexts/${params.contextId}`, config: params.config });
-      }
+      endedAt;
       /**
-       * Read file contents
+       * 元数据 / Metadata
        */
-      async readFile(params) {
-        const query = {
-          path: params.path
-        };
-        return this.get({ path: "/files", query, config: params.config });
-      }
+      metadata;
       /**
-       * Write file contents
+       * 沙箱全局唯一资源名称 / Sandbox ARN
        */
-      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 });
-      }
+      sandboxArn;
       /**
-       * Upload file to sandbox
+       * 沙箱空闲 TTL（秒） / Sandbox Idle TTL (seconds)
        */
-      async uploadFile(params) {
-        return this.postFile({
-          path: "/filesystem/upload",
-          localFilePath: params.localFilePath,
-          targetFilePath: params.targetFilePath,
-          config: params.config
-        });
+      sandboxIdleTTLInSeconds;
+      _config;
+      constructor(data, config2) {
+        super();
+        if (data) {
+          updateObjectProperties(this, data);
+        }
+        this._config = config2;
       }
       /**
-       * Download file from sandbox
+       * Create sandbox from SDK response object
+       * 从 SDK 响应对象创建沙箱 / Create Sandbox from SDK Response Object
        */
-      async downloadFile(params) {
-        const query = { path: params.path };
-        return this.getFile({
-          path: "/filesystem/download",
-          savePath: params.savePath,
-          query,
-          config: params.config
-        });
+      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_client3(), __toCommonJS(client_exports3));
+        return new SandboxClient2();
       }
       /**
-       * Execute shell command
+       * Create a new Sandbox
+       * 创建新沙箱 / Create a New Sandbox
        */
-      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 });
+      static async create(input, config2) {
+        return await _Sandbox.getClient().createSandbox({ input, config: config2 });
       }
       /**
-       * List running processes
+       * Delete a Sandbox by ID
        */
-      async listProcesses(params) {
-        return this.get({ path: "/processes", config: params?.config });
+      static async delete(params) {
+        const { id, config: config2 } = params;
+        return await _Sandbox.getClient().deleteSandbox({ id, config: config2 });
       }
       /**
-       * Get process details
+       * Stop a Sandbox by ID
        */
-      async getProcess(params) {
-        return this.get({ path: `/processes/${params.pid}`, config: params.config });
+      static async stop(params) {
+        const { id, config: config2 } = params;
+        return await _Sandbox.getClient().stopSandbox({ id, config: config2 });
       }
       /**
-       * Kill a process
+       * Get a Sandbox by ID
        */
-      async killProcess(params) {
-        return this.delete({ path: `/processes/${params.pid}`, config: params.config });
+      static async get(params) {
+        const { id, templateType, config: config2 } = params;
+        return await _Sandbox.getClient().getSandbox({ id, templateType, config: config2 });
       }
       /**
-       * Helper method to upload file using multipart/form-data
+       * List Sandboxes
        */
-      async postFile(params) {
-        const filename = nodePath__namespace.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 fs__namespace.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 = exports.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 exports.ClientError(response.status, errorText);
-          }
-          return response.json();
-        } catch (error) {
-          if (error instanceof exports.ClientError) {
-            throw error;
-          }
-          logger.error(`Upload file error: ${error}`);
-          throw new exports.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 = exports.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 exports.ClientError(response.status, errorText);
-          }
-          const arrayBuffer = await response.arrayBuffer();
-          const buffer = Buffer.from(arrayBuffer);
-          await fs__namespace.promises.writeFile(params.savePath, buffer);
-          return {
-            savedPath: params.savePath,
-            size: buffer.length
-          };
-        } catch (error) {
-          if (error instanceof exports.ClientError) {
-            throw error;
-          }
-          logger.error(`Download file error: ${error}`);
-          throw new exports.ClientError(0, `Download file error: ${error}`);
-        }
-      }
-    };
-  }
-});
-
-// src/sandbox/code-interpreter-sandbox.ts
-var code_interpreter_sandbox_exports = {};
-__export(code_interpreter_sandbox_exports, {
-  CodeInterpreterSandbox: () => exports.CodeInterpreterSandbox,
-  ContextOperations: () => ContextOperations,
-  FileOperations: () => FileOperations,
-  FileSystemOperations: () => FileSystemOperations,
-  ProcessOperations: () => ProcessOperations
-});
-var FileOperations, FileSystemOperations, ProcessOperations, ContextOperations; exports.CodeInterpreterSandbox = void 0;
-var init_code_interpreter_sandbox = __esm({
-  "src/sandbox/code-interpreter-sandbox.ts"() {
-    init_log();
-    init_exception();
-    init_code_interpreter_data();
-    init_model4();
-    init_sandbox();
-    FileOperations = class {
-      sandbox;
-      constructor(sandbox) {
-        this.sandbox = sandbox;
+      static async list(input, config2) {
+        return await _Sandbox.getClient().listSandboxes({ input, config: config2 });
       }
-      /**
-       * Read a file from the code interpreter
-       */
-      read = async (params) => {
-        return this.sandbox.dataApi.readFile(params);
+      get = async (params) => {
+        const { config: config2 } = params ?? {};
+        return await _Sandbox.get({
+          id: this.sandboxId,
+          templateType: this.templateType,
+          config: exports.Config.withConfigs(this._config, config2)
+        });
       };
       /**
-       * Write a file to the code interpreter
+       * Delete this sandbox
        */
-      write = async (params) => {
-        return this.sandbox.dataApi.writeFile(params);
+      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;
       };
-    };
-    FileSystemOperations = class {
-      sandbox;
-      constructor(sandbox) {
-        this.sandbox = sandbox;
-      }
       /**
-       * List directory contents
+       * Stop this sandbox
        */
-      list = async (params) => {
-        return this.sandbox.dataApi.listDirectory(params);
+      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;
       };
       /**
-       * Move a file or directory
+       * Refresh this sandbox's data
        */
-      move = async (params) => {
-        return this.sandbox.dataApi.moveFile(params);
+      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;
       };
       /**
-       * Remove a file or directory
+       * Wait until the sandbox is running
        */
-      remove = async (params) => {
-        return this.sandbox.dataApi.removeFile(params);
+      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/browser-sandbox.ts
+exports.BrowserSandbox = void 0;
+var init_browser_sandbox = __esm({
+  "src/sandbox/browser-sandbox.ts"() {
+    init_browser_data();
+    init_model4();
+    init_sandbox();
+    exports.BrowserSandbox = class _BrowserSandbox extends exports.Sandbox {
+      static templateType = "Browser" /* BROWSER */;
       /**
-       * Get file or directory statistics
+       * Create a Browser Sandbox from template
+       * 从模板创建浏览器沙箱 / Create Browser Sandbox from Template
        */
-      stat = async (params) => {
-        return this.sandbox.dataApi.stat(params);
-      };
+      static async createFromTemplate(templateName, options, config2) {
+        const sandbox = await exports.Sandbox.create(
+          {
+            templateName,
+            sandboxIdleTimeoutSeconds: options?.sandboxIdleTimeoutSeconds,
+            nasConfig: options?.nasConfig,
+            ossMountConfig: options?.ossMountConfig,
+            polarFsConfig: options?.polarFsConfig
+          },
+          config2
+        );
+        const browserSandbox = new _BrowserSandbox(sandbox, config2);
+        return browserSandbox;
+      }
+      constructor(sandbox, config2) {
+        super(sandbox, config2);
+      }
+      _dataApi;
       /**
-       * Create a directory
+       * Get data API client
        */
-      mkdir = async (params) => {
-        return this.sandbox.dataApi.mkdir(params);
-      };
+      get dataApi() {
+        if (!this._dataApi) {
+          if (!this.sandboxId) {
+            throw new Error("Sandbox ID is not set");
+          }
+          this._dataApi = new exports.BrowserDataAPI({
+            sandboxId: this.sandboxId,
+            config: this._config
+          });
+        }
+        return this._dataApi;
+      }
       /**
-       * Upload a file to the code interpreter
+       * Check sandbox health
        */
-      upload = async (params) => {
-        return this.sandbox.dataApi.uploadFile(params);
+      checkHealth = async (params) => {
+        return this.dataApi.checkHealth({
+          sandboxId: this.sandboxId,
+          config: params?.config
+        });
       };
       /**
-       * Download a file from the code interpreter
+       * Get CDP WebSocket URL for browser automation
        */
-      download = async (params) => {
-        return this.sandbox.dataApi.downloadFile(params);
-      };
-    };
-    ProcessOperations = class {
-      sandbox;
-      constructor(sandbox) {
-        this.sandbox = sandbox;
+      getCdpUrl(record) {
+        return this.dataApi.getCdpUrl(record);
       }
       /**
-       * Execute a command in the code interpreter
+       * Get VNC WebSocket URL for live view
        */
-      cmd = async (params) => {
-        return this.sandbox.dataApi.cmd(params);
-      };
+      getVncUrl(record) {
+        return this.dataApi.getVncUrl(record);
+      }
       /**
-       * List all processes
+       * List all recordings
        */
-      list = async (params) => {
-        return this.sandbox.dataApi.listProcesses(params);
+      listRecordings = async (params) => {
+        return this.dataApi.listRecordings(params);
       };
       /**
-       * Get a specific process by PID
+       * Download a recording video file
        */
-      get = async (params) => {
-        return this.sandbox.dataApi.getProcess(params);
+      downloadRecording = async (params) => {
+        return this.dataApi.downloadRecording(params);
       };
       /**
-       * Kill a specific process by PID
+       * Delete a recording
        */
-      kill = async (params) => {
-        return this.sandbox.dataApi.killProcess(params);
+      deleteRecording = async (params) => {
+        return this.dataApi.deleteRecording(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
+  }
+});
+exports.CodeInterpreterDataAPI = void 0;
+var init_code_interpreter_data = __esm({
+  "src/sandbox/api/code-interpreter-data.ts"() {
+    init_config();
+    init_exception();
+    init_log();
+    init_model4();
+    init_sandbox_data();
+    exports.CodeInterpreterDataAPI = class extends exports.SandboxDataAPI {
+      constructor(params) {
+        super({
+          sandboxId: params.sandboxId,
+          config: params.config,
+          // Set namespace to include sandboxId for correct API path generation
+          namespace: `sandboxes/${params.sandboxId}`
         });
-        if (result?.id && result?.cwd && result?.language) {
-          this._contextId = result.id;
-          this._language = result.language;
-          this._cwd = result.cwd;
-          return this;
-        }
-        throw new exports.ServerError(500, "Failed to create context");
-      };
+      }
       /**
-       * Get a specific context by ID
+       * List directory contents
        */
-      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");
+      async listDirectory(params) {
+        const query = {};
+        if (params?.path !== void 0) {
+          query.path = params.path;
         }
-        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;
+        if (params?.depth !== void 0) {
+          query.depth = params.depth;
         }
-        throw new exports.ServerError(500, "Failed to get context");
-      };
+        return this.get({ path: "/filesystem", query, config: params?.config });
+      }
       /**
-       * Execute code in a context
+       * Get file/directory stats
        */
-      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
-        });
-      };
+      async stat(params) {
+        const query = {
+          path: params.path
+        };
+        return this.get({ path: "/filesystem/stat", query, config: params.config });
+      }
       /**
-       * Delete a context
+       * Create directory
        */
-      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;
-      };
-    };
-    exports.CodeInterpreterSandbox = class _CodeInterpreterSandbox extends exports.Sandbox {
-      static templateType = "CodeInterpreter" /* CODE_INTERPRETER */;
+      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 });
+      }
       /**
-       * Create a Code Interpreter Sandbox from template
-       * 从模板创建代码解释器沙箱 / Create Code Interpreter Sandbox from Template
+       * Move file or directory
        */
-      static async createFromTemplate(templateName, options, config2) {
-        const sandbox = await exports.Sandbox.create(
-          {
-            templateName,
-            sandboxIdleTimeoutSeconds: options?.sandboxIdleTimeoutSeconds,
-            nasConfig: options?.nasConfig,
-            ossMountConfig: options?.ossMountConfig,
-            polarFsConfig: options?.polarFsConfig
-          },
-          config2
-        );
-        const ciSandbox = new _CodeInterpreterSandbox(sandbox, config2);
-        return ciSandbox;
+      async moveFile(params) {
+        const data = {
+          source: params.source,
+          destination: params.destination
+        };
+        return this.post({ path: "/filesystem/move", data, config: params.config });
       }
-      constructor(sandbox, config2) {
-        super(sandbox, config2);
+      /**
+       * Remove file or directory
+       */
+      async removeFile(params) {
+        const data = {
+          path: params.path
+        };
+        return this.post({ path: "/filesystem/remove", data, config: params.config });
       }
-      _dataApi;
-      _file;
-      _fileSystem;
-      _context;
-      _process;
       /**
-       * Get data API client
+       * List code execution contexts
        */
-      get dataApi() {
-        if (!this._dataApi) {
-          this._dataApi = new exports.CodeInterpreterDataAPI({
-            sandboxId: this.sandboxId || "",
-            config: this._config
-          });
-        }
-        return this._dataApi;
+      async listContexts(params) {
+        return this.get({ path: "/contexts", config: params?.config });
       }
       /**
-       * Access file upload/download operations
+       * Create a new code execution context
        */
-      get file() {
-        if (!this._file) {
-          this._file = new FileOperations(this);
+      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}`
+          );
         }
-        return this._file;
+        const data = {
+          cwd,
+          language
+        };
+        return this.post({ path: "/contexts", data, config: params?.config });
       }
       /**
-       * Access file system operations
+       * Get context details
        */
-      get fileSystem() {
-        if (!this._fileSystem) {
-          this._fileSystem = new FileSystemOperations(this);
-        }
-        return this._fileSystem;
+      async getContext(params) {
+        return this.get({ path: `/contexts/${params.contextId}`, config: params.config });
       }
       /**
-       * Access context management operations
+       * Execute code in a context
        */
-      get context() {
-        if (!this._context) {
-          this._context = new ContextOperations(this);
+      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}`
+          );
         }
-        return this._context;
+        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 });
       }
       /**
-       * Access process management operations
+       * Delete a context
        */
-      get process() {
-        if (!this._process) {
-          this._process = new ProcessOperations(this);
-        }
-        return this._process;
+      async deleteContext(params) {
+        return this.delete({ path: `/contexts/${params.contextId}`, config: params.config });
       }
       /**
-       * Check sandbox health
+       * Read file contents
        */
-      checkHealth = async (params) => {
-        return this.dataApi.checkHealth({
-          sandboxId: this.sandboxId,
-          config: params?.config
-        });
-      };
+      async readFile(params) {
+        const query = {
+          path: params.path
+        };
+        return this.get({ path: "/files", query, config: params.config });
+      }
       /**
-       * Execute code (convenience method delegating to context.execute)
+       * Write file contents
        */
-      execute = async (params) => {
-        return this.context.execute(params);
-      };
-    };
-  }
-});
-
-// src/sandbox/api/aio-data.ts
-exports.AioDataAPI = void 0;
-var init_aio_data = __esm({
-  "src/sandbox/api/aio-data.ts"() {
-    init_browser_data();
-    init_code_interpreter_data();
-    exports.AioDataAPI = class extends exports.CodeInterpreterDataAPI {
-      browserAPI;
-      constructor(params) {
-        super({
-          sandboxId: params.sandboxId,
+      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
         });
-        this.browserAPI = new exports.BrowserDataAPI({
-          sandboxId: params.sandboxId,
+      }
+      /**
+       * 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
         });
       }
-      // Browser API methods - delegate to browserAPI
       /**
-       * Get CDP WebSocket URL for browser automation
+       * Execute shell command
        */
-      getCdpUrl(record) {
-        return this.browserAPI.getCdpUrl(record);
+      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 });
       }
       /**
-       * Get VNC WebSocket URL for live view
+       * List running processes
        */
-      getVncUrl(record) {
-        return this.browserAPI.getVncUrl(record);
+      async listProcesses(params) {
+        return this.get({ path: "/processes", config: params?.config });
       }
       /**
-       * List browser recordings
+       * Get process details
        */
-      listRecordings = async (params) => {
-        return this.browserAPI.listRecordings(params);
-      };
+      async getProcess(params) {
+        return this.get({ path: `/processes/${params.pid}`, config: params.config });
+      }
       /**
-       * Delete a recording
+       * Kill a process
        */
-      deleteRecording = async (params) => {
-        return this.browserAPI.deleteRecording(params);
-      };
+      async killProcess(params) {
+        return this.delete({ path: `/processes/${params.pid}`, config: params.config });
+      }
       /**
-       * Download a recording
+       * Helper method to upload file using multipart/form-data
+       */
+      async postFile(params) {
+        const filename = nodePath__namespace.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 fs__namespace.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 = exports.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 exports.ClientError(response.status, errorText);
+          }
+          return response.json();
+        } catch (error) {
+          if (error instanceof exports.ClientError) {
+            throw error;
+          }
+          logger.error(`Upload file error: ${error}`);
+          throw new exports.ClientError(0, `Upload file error: ${error}`);
+        }
+      }
+      /**
+       * Helper method to download file
        */
-      downloadRecording = async (params) => {
-        return this.browserAPI.downloadRecording(params);
-      };
+      async getFile(params) {
+        const url = this.withPath(params.path, params.query);
+        const reqHeaders = this.prepareHeaders({ headers: params.headers, config: params.config });
+        try {
+          const cfg = exports.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 exports.ClientError(response.status, errorText);
+          }
+          const arrayBuffer = await response.arrayBuffer();
+          const buffer = Buffer.from(arrayBuffer);
+          await fs__namespace.promises.writeFile(params.savePath, buffer);
+          return {
+            savedPath: params.savePath,
+            size: buffer.length
+          };
+        } catch (error) {
+          if (error instanceof exports.ClientError) {
+            throw error;
+          }
+          logger.error(`Download file error: ${error}`);
+          throw new exports.ClientError(0, `Download file error: ${error}`);
+        }
+      }
     };
   }
 });
 
-// src/sandbox/aio-sandbox.ts
-var aio_sandbox_exports = {};
-__export(aio_sandbox_exports, {
-  AioContextOperations: () => AioContextOperations,
-  AioFileOperations: () => AioFileOperations,
-  AioFileSystemOperations: () => AioFileSystemOperations,
-  AioProcessOperations: () => AioProcessOperations,
-  AioSandbox: () => exports.AioSandbox
-});
-var AioFileOperations, AioFileSystemOperations, AioProcessOperations, AioContextOperations; exports.AioSandbox = void 0;
-var init_aio_sandbox = __esm({
-  "src/sandbox/aio-sandbox.ts"() {
+// src/sandbox/code-interpreter-sandbox.ts
+var FileOperations, FileSystemOperations, ProcessOperations, ContextOperations; exports.CodeInterpreterSandbox = void 0;
+var init_code_interpreter_sandbox = __esm({
+  "src/sandbox/code-interpreter-sandbox.ts"() {
     init_log();
     init_exception();
-    init_aio_data();
+    init_code_interpreter_data();
     init_model4();
     init_sandbox();
-    AioFileOperations = class {
+    FileOperations = class {
       sandbox;
       constructor(sandbox) {
         this.sandbox = sandbox;
       }
       /**
-       * Read a file from the sandbox
+       * Read a file from the code interpreter
        */
-      read = async (path2) => {
-        return this.sandbox.dataApi.readFile({ path: path2 });
+      read = async (params) => {
+        return this.sandbox.dataApi.readFile(params);
       };
       /**
-       * Write a file to the sandbox
+       * Write a file to the code interpreter
        */
       write = async (params) => {
         return this.sandbox.dataApi.writeFile(params);
       };
     };
-    AioFileSystemOperations = class {
+    FileSystemOperations = class {
       sandbox;
       constructor(sandbox) {
         this.sandbox = sandbox;
@@ -4808,25 +4750,25 @@ var init_aio_sandbox = __esm({
         return this.sandbox.dataApi.mkdir(params);
       };
       /**
-       * Upload a file to the sandbox
+       * Upload a file to the code interpreter
        */
       upload = async (params) => {
         return this.sandbox.dataApi.uploadFile(params);
       };
       /**
-       * Download a file from the sandbox
+       * Download a file from the code interpreter
        */
       download = async (params) => {
         return this.sandbox.dataApi.downloadFile(params);
       };
     };
-    AioProcessOperations = class {
+    ProcessOperations = class {
       sandbox;
       constructor(sandbox) {
         this.sandbox = sandbox;
       }
       /**
-       * Execute a command in the sandbox
+       * Execute a command in the code interpreter
        */
       cmd = async (params) => {
         return this.sandbox.dataApi.cmd(params);
@@ -4850,7 +4792,7 @@ var init_aio_sandbox = __esm({
         return this.sandbox.dataApi.killProcess(params);
       };
     };
-    AioContextOperations = class {
+    ContextOperations = class {
       sandbox;
       _contextId;
       _language;
@@ -4941,11 +4883,11 @@ var init_aio_sandbox = __esm({
         return result;
       };
     };
-    exports.AioSandbox = class _AioSandbox extends exports.Sandbox {
-      static templateType = "AllInOne" /* AIO */;
+    exports.CodeInterpreterSandbox = class _CodeInterpreterSandbox extends exports.Sandbox {
+      static templateType = "CodeInterpreter" /* CODE_INTERPRETER */;
       /**
-       * Create an AIO Sandbox from template
-       * 从模板创建 AIO 沙箱 / Create AIO Sandbox from Template
+       * Create a Code Interpreter Sandbox from template
+       * 从模板创建代码解释器沙箱 / Create Code Interpreter Sandbox from Template
        */
       static async createFromTemplate(templateName, options, config2) {
         const sandbox = await exports.Sandbox.create(
@@ -4958,8 +4900,8 @@ var init_aio_sandbox = __esm({
           },
           config2
         );
-        const aioSandbox = new _AioSandbox(sandbox, config2);
-        return aioSandbox;
+        const ciSandbox = new _CodeInterpreterSandbox(sandbox, config2);
+        return ciSandbox;
       }
       constructor(sandbox, config2) {
         super(sandbox, config2);
@@ -4974,7 +4916,7 @@ var init_aio_sandbox = __esm({
        */
       get dataApi() {
         if (!this._dataApi) {
-          this._dataApi = new exports.AioDataAPI({
+          this._dataApi = new exports.CodeInterpreterDataAPI({
             sandboxId: this.sandboxId || "",
             config: this._config
           });
@@ -4982,438 +4924,504 @@ var init_aio_sandbox = __esm({
         return this._dataApi;
       }
       /**
-       * Access file upload/download operations
+       * 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/template.ts
+exports.Template = void 0;
+var init_template = __esm({
+  "src/sandbox/template.ts"() {
+    init_resource();
+    exports.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._config = config2;
+      }
+      uniqIdCallback = () => this.templateId;
+      static getClient() {
+        const { SandboxClient: SandboxClient2 } = (init_client3(), __toCommonJS(client_exports3));
+        return new SandboxClient2();
+      }
+      /**
+       * Create a new Template
+       */
+      static async create(params) {
+        const { input, config: config2 } = params;
+        return await _Template.getClient().createTemplate({ input, config: config2 });
+      }
+      /**
+       * Delete a Template by name
+       */
+      static async delete(params) {
+        const { name, config: config2 } = params;
+        return await _Template.getClient().deleteTemplate({ name, config: config2 });
+      }
+      /**
+       * Update a Template by name
+       */
+      static async update(params) {
+        const { name, input, config: config2 } = params;
+        return await _Template.getClient().updateTemplate({ name, input, config: config2 });
+      }
+      /**
+       * Get a Template by name
+       */
+      static async get(params) {
+        const { name, config: config2 } = params;
+        return await _Template.getClient().getTemplate({ name, config: config2 });
+      }
+      /**
+       * List Templates
        */
-      get file() {
-        if (!this._file) {
-          this._file = new AioFileOperations(this);
-        }
-        return this._file;
+      static async list(params) {
+        const { input, config: config2 } = params ?? {};
+        return await _Template.getClient().listTemplates({ input, config: config2 });
       }
       /**
-       * Access file system operations
+       * List all Templates (with pagination)
        */
-      get fileSystem() {
-        if (!this._fileSystem) {
-          this._fileSystem = new AioFileSystemOperations(this);
-        }
-        return this._fileSystem;
-      }
+      static listAll = listAllResourcesFunction(this.list);
+      get = async (params = {}) => {
+        return await _Template.get({
+          name: this.templateName,
+          config: params.config
+        });
+      };
       /**
-       * Access context management operations
+       * Delete this template
        */
-      get context() {
-        if (!this._context) {
-          this._context = new AioContextOperations(this);
+      delete = async (params) => {
+        const config2 = params?.config;
+        if (!this.templateName) {
+          throw new Error("templateName is required to delete a Template");
         }
-        return this._context;
-      }
+        const result = await _Template.delete({
+          name: this.templateName,
+          config: config2 ?? this._config
+        });
+        updateObjectProperties(this, result);
+        return this;
+      };
       /**
-       * Access process management operations
+       * Update this template
        */
-      get process() {
-        if (!this._process) {
-          this._process = new AioProcessOperations(this);
+      update = async (params) => {
+        const { input, config: config2 } = params;
+        if (!this.templateName) {
+          throw new Error("templateName is required to update a Template");
         }
-        return this._process;
-      }
+        const result = await _Template.update({
+          name: this.templateName,
+          input,
+          config: config2 ?? this._config
+        });
+        updateObjectProperties(this, result);
+        return this;
+      };
       /**
-       * Check sandbox health
+       * Refresh this template's data
        */
-      checkHealth = async (params) => {
-        return this.dataApi.checkHealth({
-          sandboxId: this.sandboxId,
-          config: params?.config
+      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);
+        return this;
       };
-      // ========================================
-      // Browser API Methods
-      // ========================================
+    };
+  }
+});
+
+// src/sandbox/api/aio-data.ts
+exports.AioDataAPI = void 0;
+var init_aio_data = __esm({
+  "src/sandbox/api/aio-data.ts"() {
+    init_browser_data();
+    init_code_interpreter_data();
+    exports.AioDataAPI = class extends exports.CodeInterpreterDataAPI {
+      browserAPI;
+      constructor(params) {
+        super({
+          sandboxId: params.sandboxId,
+          config: params.config
+        });
+        this.browserAPI = new exports.BrowserDataAPI({
+          sandboxId: params.sandboxId,
+          config: params.config
+        });
+      }
+      // Browser API methods - delegate to browserAPI
       /**
        * Get CDP WebSocket URL for browser automation
        */
       getCdpUrl(record) {
-        return this.dataApi.getCdpUrl(record);
+        return this.browserAPI.getCdpUrl(record);
       }
       /**
        * Get VNC WebSocket URL for live view
        */
       getVncUrl(record) {
-        return this.dataApi.getVncUrl(record);
+        return this.browserAPI.getVncUrl(record);
       }
       /**
-       * List all browser recordings
+       * List browser recordings
        */
       listRecordings = async (params) => {
-        return this.dataApi.listRecordings(params);
-      };
-      /**
-       * Download a recording video file
-       */
-      downloadRecording = async (params) => {
-        return this.dataApi.downloadRecording(params);
+        return this.browserAPI.listRecordings(params);
       };
       /**
        * Delete a recording
        */
       deleteRecording = async (params) => {
-        return this.dataApi.deleteRecording(params);
+        return this.browserAPI.deleteRecording(params);
       };
-      // ========================================
-      // Code Interpreter API Methods
-      // ========================================
       /**
-       * Execute code (convenience method delegating to context.execute)
+       * Download a recording
        */
-      execute = async (params) => {
-        return this.context.execute(params);
+      downloadRecording = async (params) => {
+        return this.browserAPI.downloadRecording(params);
       };
     };
   }
 });
 
-// src/sandbox/custom-sandbox.ts
-var custom_sandbox_exports = {};
-__export(custom_sandbox_exports, {
-  CustomSandbox: () => CustomSandbox
+// src/sandbox/aio-sandbox.ts
+var aio_sandbox_exports = {};
+__export(aio_sandbox_exports, {
+  AioContextOperations: () => AioContextOperations,
+  AioFileOperations: () => AioFileOperations,
+  AioFileSystemOperations: () => AioFileSystemOperations,
+  AioProcessOperations: () => AioProcessOperations,
+  AioSandbox: () => exports.AioSandbox
 });
-var CustomSandbox;
-var init_custom_sandbox = __esm({
-  "src/sandbox/custom-sandbox.ts"() {
-    init_config();
+var AioFileOperations, AioFileSystemOperations, AioProcessOperations, AioContextOperations; exports.AioSandbox = void 0;
+var init_aio_sandbox = __esm({
+  "src/sandbox/aio-sandbox.ts"() {
+    init_log();
+    init_exception();
+    init_aio_data();
     init_model4();
     init_sandbox();
-    init_sandbox_data();
-    CustomSandbox = class _CustomSandbox extends exports.Sandbox {
-      static templateType = "CustomImage" /* CUSTOM */;
-      /**
-       * Create a Custom Sandbox from template
-       * 从模板创建自定义沙箱 / Create Custom Sandbox from Template
-       */
-      static async createFromTemplate(templateName, options, config2) {
-        const sandbox = await exports.Sandbox.create(
-          {
-            templateName,
-            sandboxIdleTimeoutSeconds: options?.sandboxIdleTimeoutSeconds,
-            nasConfig: options?.nasConfig,
-            ossMountConfig: options?.ossMountConfig,
-            polarFsConfig: options?.polarFsConfig
-          },
-          config2
-        );
-        const customSandbox = new _CustomSandbox(sandbox, config2);
-        return customSandbox;
-      }
-      constructor(sandbox, config2) {
-        super(sandbox, config2);
+    AioFileOperations = class {
+      sandbox;
+      constructor(sandbox) {
+        this.sandbox = sandbox;
       }
-      _dataApi;
       /**
-       * Get data API client
+       * Read a file from the sandbox
        */
-      get dataApi() {
-        if (!this._dataApi) {
-          this._dataApi = new exports.SandboxDataAPI({
-            sandboxId: this.sandboxId || "",
-            config: this._config
-          });
-        }
-        return this._dataApi;
-      }
+      read = async (path2) => {
+        return this.sandbox.dataApi.readFile({ path: path2 });
+      };
       /**
-       * Get base URL for the sandbox
-       * 获取沙箱的基础 URL / Get base URL for the sandbox
-       *
-       * @returns 基础 URL / Base URL
+       * Write a file to the sandbox
        */
-      getBaseUrl() {
-        const cfg = exports.Config.withConfigs(this._config);
-        return `${cfg.dataEndpoint}/sandboxes/${this.sandboxId}`;
-      }
+      write = async (params) => {
+        return this.sandbox.dataApi.writeFile(params);
+      };
     };
-  }
-});
-
-// src/sandbox/sandbox.ts
-exports.Sandbox = void 0;
-var init_sandbox = __esm({
-  "src/sandbox/sandbox.ts"() {
-    init_utils();
-    init_config();
-    init_resource();
-    init_model4();
-    init_sandbox_data();
-    exports.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;
+    AioFileSystemOperations = class {
+      sandbox;
+      constructor(sandbox) {
+        this.sandbox = sandbox;
+      }
       /**
-       * 沙箱创建时间 / Sandbox Creation Time
+       * List directory contents
        */
-      createdAt;
+      list = async (params) => {
+        return this.sandbox.dataApi.listDirectory(params);
+      };
       /**
-       * 最后更新时间 / Last Updated Time
+       * Move a file or directory
        */
-      lastUpdatedAt;
+      move = async (params) => {
+        return this.sandbox.dataApi.moveFile(params);
+      };
       /**
-       * 沙箱空闲超时时间（秒） / Sandbox Idle Timeout (seconds)
+       * Remove a file or directory
        */
-      sandboxIdleTimeoutSeconds;
+      remove = async (params) => {
+        return this.sandbox.dataApi.removeFile(params);
+      };
       /**
-       * 沙箱结束时间 / Sandbox End Time
+       * Get file or directory statistics
        */
-      endedAt;
+      stat = async (params) => {
+        return this.sandbox.dataApi.stat(params);
+      };
       /**
-       * 元数据 / Metadata
+       * Create a directory
        */
-      metadata;
+      mkdir = async (params) => {
+        return this.sandbox.dataApi.mkdir(params);
+      };
       /**
-       * 沙箱全局唯一资源名称 / Sandbox ARN
+       * Upload a file to the sandbox
        */
-      sandboxArn;
+      upload = async (params) => {
+        return this.sandbox.dataApi.uploadFile(params);
+      };
       /**
-       * 沙箱空闲 TTL（秒） / Sandbox Idle TTL (seconds)
+       * Download a file from the sandbox
        */
-      sandboxIdleTTLInSeconds;
-      _config;
-      constructor(data, config2) {
-        super();
-        if (data) {
-          updateObjectProperties(this, data);
-        }
-        this._config = config2;
+      download = async (params) => {
+        return this.sandbox.dataApi.downloadFile(params);
+      };
+    };
+    AioProcessOperations = class {
+      sandbox;
+      constructor(sandbox) {
+        this.sandbox = sandbox;
       }
       /**
-       * Create sandbox from SDK response object
-       * 从 SDK 响应对象创建沙箱 / Create Sandbox from SDK Response Object
+       * Execute a command in the sandbox
        */
-      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_client3(), __toCommonJS(client_exports3));
-        return new SandboxClient2();
-      }
+      cmd = async (params) => {
+        return this.sandbox.dataApi.cmd(params);
+      };
       /**
-       * Create a new Sandbox
-       * 创建新沙箱 / Create a New Sandbox
+       * List all processes
        */
-      static async create(input, config2) {
-        return await _Sandbox.getClient().createSandbox({ input, config: config2 });
-      }
+      list = async (params) => {
+        return this.sandbox.dataApi.listProcesses(params);
+      };
       /**
-       * Delete a Sandbox by ID
+       * Get a specific process by PID
        */
-      static async delete(params) {
-        const { id, config: config2 } = params;
-        return await _Sandbox.getClient().deleteSandbox({ id, config: config2 });
-      }
+      get = async (params) => {
+        return this.sandbox.dataApi.getProcess(params);
+      };
       /**
-       * Stop a Sandbox by ID
+       * Kill a specific process by PID
        */
-      static async stop(params) {
-        const { id, config: config2 } = params;
-        return await _Sandbox.getClient().stopSandbox({ id, config: config2 });
+      kill = async (params) => {
+        return this.sandbox.dataApi.killProcess(params);
+      };
+    };
+    AioContextOperations = class {
+      sandbox;
+      _contextId;
+      _language;
+      _cwd;
+      constructor(sandbox) {
+        this.sandbox = sandbox;
       }
       /**
-       * Get a Sandbox by ID
+       * Get the current context ID
        */
-      static async get(params) {
-        const { id, templateType, config: config2 } = params;
-        try {
-          const cfg = exports.Config.withConfigs(config2);
-          const dataApi = new exports.SandboxDataAPI({
-            sandboxId: id,
-            config: cfg
-          });
-          const result = await dataApi.getSandbox({
-            sandboxId: id,
-            config: cfg
-          });
-          if (result.code !== "SUCCESS") {
-            throw new exports.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 exports.HTTPError) {
-            throw error.toResourceError("Sandbox", id);
-          }
-          throw error;
-        }
+      get contextId() {
+        return this._contextId;
       }
       /**
-       * List Sandboxes
+       * List all contexts
        */
-      static async list(input, config2) {
-        return await _Sandbox.getClient().listSandboxes({ input, config: config2 });
-      }
-      get = async (params) => {
-        const { config: config2 } = params ?? {};
-        return await _Sandbox.get({
-          id: this.sandboxId,
-          templateType: this.templateType,
-          config: exports.Config.withConfigs(this._config, config2)
-        });
+      list = async (params) => {
+        return this.sandbox.dataApi.listContexts(params);
       };
       /**
-       * Delete this sandbox
+       * Create a new context and save its ID
        */
-      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
+      create = async (params) => {
+        const language = params?.language || "python" /* PYTHON */;
+        const cwd = params?.cwd || "/home/user";
+        const result = await this.sandbox.dataApi.createContext({
+          language,
+          cwd
         });
-        updateObjectProperties(this, result);
-        return this;
+        if (result?.id && result?.cwd && result?.language) {
+          this._contextId = result.id;
+          this._language = result.language;
+          this._cwd = result.cwd;
+          return this;
+        }
+        throw new exports.ServerError(500, "Failed to create context");
       };
       /**
-       * Stop this sandbox
+       * Get a specific context by ID
        */
-      stop = async (params) => {
-        const config2 = params?.config;
-        if (!this.sandboxId) {
-          throw new Error("sandboxId is required to stop a Sandbox");
+      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 _Sandbox.stop({
-          id: this.sandboxId,
-          config: config2 ?? this._config
-        });
-        updateObjectProperties(this, result);
-        return this;
+        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 exports.ServerError(500, "Failed to get context");
       };
       /**
-       * Refresh this sandbox's data
+       * Execute code in a context
        */
-      refresh = async (params) => {
-        const config2 = params?.config;
-        if (!this.sandboxId) {
-          throw new Error("sandboxId is required to refresh a Sandbox");
+      execute = async (params) => {
+        const { code, timeout = 30 } = params;
+        let { contextId, language } = params;
+        if (!contextId) {
+          contextId = this._contextId;
         }
-        const result = await _Sandbox.get({
-          id: this.sandboxId,
-          config: config2 ?? this._config
+        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
         });
-        updateObjectProperties(this, result);
-        return this;
       };
       /**
-       * Wait until the sandbox is running
+       * Delete a context
        */
-      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/browser-sandbox.ts
-var browser_sandbox_exports = {};
-__export(browser_sandbox_exports, {
-  BrowserSandbox: () => exports.BrowserSandbox
-});
-exports.BrowserSandbox = void 0;
-var init_browser_sandbox = __esm({
-  "src/sandbox/browser-sandbox.ts"() {
-    init_browser_data();
-    init_model4();
-    init_sandbox();
-    exports.BrowserSandbox = class _BrowserSandbox extends exports.Sandbox {
-      static templateType = "Browser" /* BROWSER */;
+      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;
+      };
+    };
+    exports.AioSandbox = class _AioSandbox extends exports.Sandbox {
+      static templateType = "AllInOne" /* AIO */;
       /**
-       * Create a Browser Sandbox from template
-       * 从模板创建浏览器沙箱 / Create Browser Sandbox from Template
+       * Create an AIO Sandbox from template
+       * 从模板创建 AIO 沙箱 / Create AIO Sandbox from Template
        */
       static async createFromTemplate(templateName, options, config2) {
         const sandbox = await exports.Sandbox.create(
@@ -5426,28 +5434,65 @@ var init_browser_sandbox = __esm({
           },
           config2
         );
-        const browserSandbox = new _BrowserSandbox(sandbox, config2);
-        return browserSandbox;
+        const aioSandbox = new _AioSandbox(sandbox, config2);
+        return aioSandbox;
       }
       constructor(sandbox, config2) {
         super(sandbox, config2);
       }
       _dataApi;
+      _file;
+      _fileSystem;
+      _context;
+      _process;
       /**
        * Get data API client
        */
       get dataApi() {
         if (!this._dataApi) {
-          if (!this.sandboxId) {
-            throw new Error("Sandbox ID is not set");
-          }
-          this._dataApi = new exports.BrowserDataAPI({
-            sandboxId: this.sandboxId,
+          this._dataApi = new exports.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
        */
@@ -5457,6 +5502,9 @@ var init_browser_sandbox = __esm({
           config: params?.config
         });
       };
+      // ========================================
+      // Browser API Methods
+      // ========================================
       /**
        * Get CDP WebSocket URL for browser automation
        */
@@ -5470,7 +5518,7 @@ var init_browser_sandbox = __esm({
         return this.dataApi.getVncUrl(record);
       }
       /**
-       * List all recordings
+       * List all browser recordings
        */
       listRecordings = async (params) => {
         return this.dataApi.listRecordings(params);
@@ -5487,187 +5535,14 @@ var init_browser_sandbox = __esm({
       deleteRecording = async (params) => {
         return this.dataApi.deleteRecording(params);
       };
-    };
-  }
-});
-
-// src/sandbox/template.ts
-exports.Template = void 0;
-var init_template = __esm({
-  "src/sandbox/template.ts"() {
-    init_resource();
-    exports.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._config = config2;
-      }
-      uniqIdCallback = () => this.templateId;
-      static getClient() {
-        const { SandboxClient: SandboxClient2 } = (init_client3(), __toCommonJS(client_exports3));
-        return new SandboxClient2();
-      }
-      /**
-       * Create a new Template
-       */
-      static async create(params) {
-        const { input, config: config2 } = params;
-        return await _Template.getClient().createTemplate({ input, config: config2 });
-      }
-      /**
-       * Delete a Template by name
-       */
-      static async delete(params) {
-        const { name, config: config2 } = params;
-        return await _Template.getClient().deleteTemplate({ name, config: config2 });
-      }
-      /**
-       * Update a Template by name
-       */
-      static async update(params) {
-        const { name, input, config: config2 } = params;
-        return await _Template.getClient().updateTemplate({ name, input, config: config2 });
-      }
-      /**
-       * Get a Template by name
-       */
-      static async get(params) {
-        const { name, config: config2 } = params;
-        return await _Template.getClient().getTemplate({ name, config: config2 });
-      }
-      /**
-       * List Templates
-       */
-      static async list(params) {
-        const { input, config: config2 } = params ?? {};
-        return await _Template.getClient().listTemplates({ input, config: config2 });
-      }
-      /**
-       * 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);
-        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);
-        return this;
-      };
+      // ========================================
+      // Code Interpreter API Methods
+      // ========================================
       /**
-       * Refresh this template's data
+       * Execute code (convenience method delegating to context.execute)
        */
-      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);
-        return this;
+      execute = async (params) => {
+        return this.context.execute(params);
       };
     };
   }
@@ -5798,7 +5673,7 @@ var init_client3 = __esm({
           input: request,
           config: cfg
         });
-        return (result?.items || []).map((item) => new exports.Template(item, cfg));
+        return (result.items || []).map((item) => new exports.Template(item, cfg));
       };
       // ============ Sandbox Operations ============
       /**
@@ -8647,7 +8522,6 @@ 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();