Merge pull request #62 from Serverless-Devs/add-create-sandbox_id-define

Add create sandbox id define

Author: OhYee

agentrun/sandbox/__client_async_template.py

@@ -276,6 +276,7 @@ async def create_sandbox_async(
         self,
         template_name: str,
         sandbox_idle_timeout_seconds: Optional[int] = 600,
+        sandbox_id: Optional[str] = None,
         nas_config: Optional[NASConfig] = None,
         oss_mount_config: Optional[OSSMountConfig] = None,
         polar_fs_config: Optional[PolarFsConfig] = None,
@@ -286,6 +287,7 @@ async def create_sandbox_async(
         Args:
             template_name: 模板名称 / Template name
             sandbox_idle_timeout_seconds: 沙箱空闲超时时间（秒） / Sandbox idle timeout (seconds)
+            sandbox_id: 沙箱 ID（可选，用户可指定） / Sandbox ID (optional, user can specify)
             nas_config: NAS 配置 / NAS configuration
             oss_mount_config: OSS 挂载配置 / OSS mount configuration
             polar_fs_config: PolarFS 配置 / PolarFS configuration
@@ -314,6 +316,7 @@ async def create_sandbox_async(
         result = await self.__sandbox_data_api.create_sandbox_async(
             template_name=template_name,
             sandbox_idle_timeout_seconds=sandbox_idle_timeout_seconds,
+            sandbox_id=sandbox_id,
             nas_config=nas_config_dict,
             oss_mount_config=oss_mount_config_dict,
             polar_fs_config=polar_fs_config_dict,
@@ -353,7 +356,7 @@ async def stop_sandbox_async(
         """
         try:
             result = await self.__sandbox_data_api.stop_sandbox_async(
-                sandbox_id
+                sandbox_id, config=config
             )
 
             # 判断返回结果是否成功
@@ -393,7 +396,7 @@ async def delete_sandbox_async(
         """
         try:
             result = await self.__sandbox_data_api.delete_sandbox_async(
-                sandbox_id
+                sandbox_id, config=config
             )
 
             # 判断返回结果是否成功
@@ -434,7 +437,9 @@ async def get_sandbox_async(
             ServerError: 服务器错误
         """
         try:
-            result = await self.__sandbox_data_api.get_sandbox_async(sandbox_id)
+            result = await self.__sandbox_data_api.get_sandbox_async(
+                sandbox_id, config=config
+            )
 
             # 判断返回结果是否成功
             if result.get("code") != "SUCCESS":

agentrun/sandbox/__sandbox_async_template.py

@@ -87,6 +87,7 @@ async def create_async(
         template_type: Literal[TemplateType.CODE_INTERPRETER],
         template_name: Optional[str] = None,
         sandbox_idle_timeout_seconds: Optional[int] = 600,
+        sandbox_id: Optional[str] = None,
         nas_config: Optional["NASConfig"] = None,
         oss_mount_config: Optional["OSSMountConfig"] = None,
         polar_fs_config: Optional["PolarFsConfig"] = None,
@@ -101,6 +102,7 @@ async def create_async(
         template_type: Literal[TemplateType.BROWSER],
         template_name: Optional[str] = None,
         sandbox_idle_timeout_seconds: Optional[int] = 600,
+        sandbox_id: Optional[str] = None,
         nas_config: Optional["NASConfig"] = None,
         oss_mount_config: Optional["OSSMountConfig"] = None,
         polar_fs_config: Optional["PolarFsConfig"] = None,
@@ -115,6 +117,7 @@ async def create_async(
         template_type: Literal[TemplateType.AIO],
         template_name: Optional[str] = None,
         sandbox_idle_timeout_seconds: Optional[int] = 600,
+        sandbox_id: Optional[str] = None,
         nas_config: Optional["NASConfig"] = None,
         oss_mount_config: Optional["OSSMountConfig"] = None,
         polar_fs_config: Optional["PolarFsConfig"] = None,
@@ -129,6 +132,7 @@ async def create_async(
         template_type: Literal[TemplateType.CUSTOM],
         template_name: Optional[str] = None,
         sandbox_idle_timeout_seconds: Optional[int] = 600,
+        sandbox_id: Optional[str] = None,
         nas_config: Optional["NASConfig"] = None,
         oss_mount_config: Optional["OSSMountConfig"] = None,
         polar_fs_config: Optional["PolarFsConfig"] = None,
@@ -142,6 +146,7 @@ async def create_async(
         template_type: TemplateType,
         template_name: Optional[str] = None,
         sandbox_idle_timeout_seconds: Optional[int] = 600,
+        sandbox_id: Optional[str] = None,
         nas_config: Optional["NASConfig"] = None,
         oss_mount_config: Optional["OSSMountConfig"] = None,
         polar_fs_config: Optional["PolarFsConfig"] = None,
@@ -178,6 +183,7 @@ async def create_async(
         base_sandbox = await cls.__get_client().create_sandbox_async(
             template_name=template_name,
             sandbox_idle_timeout_seconds=sandbox_idle_timeout_seconds,
+            sandbox_id=sandbox_id,
             nas_config=nas_config,
             oss_mount_config=oss_mount_config,
             polar_fs_config=polar_fs_config,
@@ -308,7 +314,9 @@ async def connect_async(
 
         Args:
             sandbox_id: Sandbox ID
-            type: 可选的类型参数，用于类型提示和运行时验证
+            template_type: 可选的类型参数，用于类型提示和运行时类型决定。
+                提供时直接使用该类型决定返回的子类，不调用 get_template（无需 AKSK）。
+                未提供时通过 get_template 获取类型（需要 AKSK）。
             config: 配置对象
 
         Returns:
@@ -325,47 +333,38 @@ async def connect_async(
             sandbox_id, config=config
         )
 
-        # 根据 template_name 获取 template 类型
-        if sandbox.template_name is None:
-            raise ValueError(f"Sandbox {sandbox_id} has no template_name")
+        resolved_type = template_type
+        if resolved_type is None:
+            if sandbox.template_name is None:
+                raise ValueError(f"Sandbox {sandbox_id} has no template_name")
 
-        template = await cls.get_template_async(
-            sandbox.template_name, config=config
-        )
-
-        # 如果提供了 type 参数，验证类型是否匹配
-        if (
-            template_type is not None
-            and template.template_type != template_type
-        ):
-            raise ValueError(
-                f"Sandbox {sandbox_id} has template type"
-                f" {template.template_type}, but expected {template_type}"
+            template = await cls.get_template_async(
+                sandbox.template_name, config=config
             )
+            resolved_type = template.template_type
 
-        # 根据 template 类型创建相应的 Sandbox 子类
         from agentrun.sandbox.aio_sandbox import AioSandbox
         from agentrun.sandbox.browser_sandbox import BrowserSandbox
         from agentrun.sandbox.code_interpreter_sandbox import (
             CodeInterpreterSandbox,
         )
 
         result = None
-        if template.template_type == TemplateType.CODE_INTERPRETER:
+        if resolved_type == TemplateType.CODE_INTERPRETER:
             result = CodeInterpreterSandbox.model_validate(
                 sandbox.model_dump(by_alias=False)
             )
-        elif template.template_type == TemplateType.BROWSER:
+        elif resolved_type == TemplateType.BROWSER:
             result = BrowserSandbox.model_validate(
                 sandbox.model_dump(by_alias=False)
             )
-        elif template.template_type == TemplateType.AIO:
+        elif resolved_type == TemplateType.AIO:
             result = AioSandbox.model_validate(
                 sandbox.model_dump(by_alias=False)
             )
         else:
             raise ValueError(
-                f"Unsupported template type: {template.template_type}. "
+                f"Unsupported template type: {resolved_type}. "
                 "Expected 'code-interpreter', 'browser' or 'aio'"
             )
 

agentrun/sandbox/api/__sandbox_data_async_template.py

@@ -70,6 +70,7 @@ async def create_sandbox_async(
         self,
         template_name: str,
         sandbox_idle_timeout_seconds: Optional[int] = 600,
+        sandbox_id: Optional[str] = None,
         nas_config: Optional[Dict[str, Any]] = None,
         oss_mount_config: Optional[Dict[str, Any]] = None,
         polar_fs_config: Optional[Dict[str, Any]] = None,
@@ -80,28 +81,30 @@ async def create_sandbox_async(
             "templateName": template_name,
             "sandboxIdleTimeoutSeconds": sandbox_idle_timeout_seconds,
         }
+        if sandbox_id is not None:
+            data["sandboxId"] = sandbox_id
         if nas_config is not None:
             data["nasConfig"] = nas_config
         if oss_mount_config is not None:
             data["ossMountConfig"] = oss_mount_config
         if polar_fs_config is not None:
             data["polarFsConfig"] = polar_fs_config
-        return await self.post_async("/", data=data)
+        return await self.post_async("/", data=data, config=config)
 
     async def delete_sandbox_async(
         self, sandbox_id: str, config: Optional[Config] = None
     ):
         self.__refresh_access_token(sandbox_id=sandbox_id, config=config)
-        return await self.delete_async("/")
+        return await self.delete_async("/", config=config)
 
     async def stop_sandbox_async(
         self, sandbox_id: str, config: Optional[Config] = None
     ):
         self.__refresh_access_token(sandbox_id=sandbox_id, config=config)
-        return await self.post_async("/stop")
+        return await self.post_async("/stop", config=config)
 
     async def get_sandbox_async(
         self, sandbox_id: str, config: Optional[Config] = None
     ):
         self.__refresh_access_token(sandbox_id=sandbox_id, config=config)
-        return await self.get_async("/")
+        return await self.get_async("/", config=config)

agentrun/sandbox/api/sandbox_data.py

@@ -83,6 +83,7 @@ async def create_sandbox_async(
         self,
         template_name: str,
         sandbox_idle_timeout_seconds: Optional[int] = 600,
+        sandbox_id: Optional[str] = None,
         nas_config: Optional[Dict[str, Any]] = None,
         oss_mount_config: Optional[Dict[str, Any]] = None,
         polar_fs_config: Optional[Dict[str, Any]] = None,
@@ -93,18 +94,21 @@ async def create_sandbox_async(
             "templateName": template_name,
             "sandboxIdleTimeoutSeconds": sandbox_idle_timeout_seconds,
         }
+        if sandbox_id is not None:
+            data["sandboxId"] = sandbox_id
         if nas_config is not None:
             data["nasConfig"] = nas_config
         if oss_mount_config is not None:
             data["ossMountConfig"] = oss_mount_config
         if polar_fs_config is not None:
             data["polarFsConfig"] = polar_fs_config
-        return await self.post_async("/", data=data)
+        return await self.post_async("/", data=data, config=config)
 
     def create_sandbox(
         self,
         template_name: str,
         sandbox_idle_timeout_seconds: Optional[int] = 600,
+        sandbox_id: Optional[str] = None,
         nas_config: Optional[Dict[str, Any]] = None,
         oss_mount_config: Optional[Dict[str, Any]] = None,
         polar_fs_config: Optional[Dict[str, Any]] = None,
@@ -115,40 +119,42 @@ def create_sandbox(
             "templateName": template_name,
             "sandboxIdleTimeoutSeconds": sandbox_idle_timeout_seconds,
         }
+        if sandbox_id is not None:
+            data["sandboxId"] = sandbox_id
         if nas_config is not None:
             data["nasConfig"] = nas_config
         if oss_mount_config is not None:
             data["ossMountConfig"] = oss_mount_config
         if polar_fs_config is not None:
             data["polarFsConfig"] = polar_fs_config
-        return self.post("/", data=data)
+        return self.post("/", data=data, config=config)
 
     async def delete_sandbox_async(
         self, sandbox_id: str, config: Optional[Config] = None
     ):
         self.__refresh_access_token(sandbox_id=sandbox_id, config=config)
-        return await self.delete_async("/")
+        return await self.delete_async("/", config=config)
 
     def delete_sandbox(self, sandbox_id: str, config: Optional[Config] = None):
         self.__refresh_access_token(sandbox_id=sandbox_id, config=config)
-        return self.delete("/")
+        return self.delete("/", config=config)
 
     async def stop_sandbox_async(
         self, sandbox_id: str, config: Optional[Config] = None
     ):
         self.__refresh_access_token(sandbox_id=sandbox_id, config=config)
-        return await self.post_async("/stop")
+        return await self.post_async("/stop", config=config)
 
     def stop_sandbox(self, sandbox_id: str, config: Optional[Config] = None):
         self.__refresh_access_token(sandbox_id=sandbox_id, config=config)
-        return self.post("/stop")
+        return self.post("/stop", config=config)
 
     async def get_sandbox_async(
         self, sandbox_id: str, config: Optional[Config] = None
     ):
         self.__refresh_access_token(sandbox_id=sandbox_id, config=config)
-        return await self.get_async("/")
+        return await self.get_async("/", config=config)
 
     def get_sandbox(self, sandbox_id: str, config: Optional[Config] = None):
         self.__refresh_access_token(sandbox_id=sandbox_id, config=config)
-        return self.get("/")
+        return self.get("/", config=config)