fleet-python 0.2.10__py3-none-any.whl → 0.2.12__py3-none-any.whl

examples/example.py

@@ -9,6 +9,9 @@ load_dotenv()
 
 
 async def main():
+    regions = await flt.env.list_regions_async()
+    print("Regions:", regions)
+
     environments = await flt.env.list_envs_async()
     print("Environments:", len(environments))
 

fleet/_async/base.py

@@ -9,6 +9,13 @@ from .exceptions import (
     FleetRateLimitError,
     FleetInstanceLimitError,
     FleetTimeoutError,
+    FleetTeamNotFoundError,
+    FleetEnvironmentAccessError,
+    FleetRegionError,
+    FleetEnvironmentNotFoundError,
+    FleetVersionNotFoundError,
+    FleetBadRequestError,
+    FleetPermissionError,
 )
 
 
@@ -47,86 +54,170 @@ class AsyncWrapper(BaseWrapper):
         url: str,
         params: Optional[Dict[str, Any]] = None,
         json: Optional[Any] = None,
+        base_url: Optional[str] = None,
         **kwargs,
     ) -> httpx.Response:
+        base_url = base_url or self.base_url
         try:
             response = await self.httpx_client.request(
                 method,
-                f"{self.base_url}{url}",
+                f"{base_url}{url}",
                 headers=self.get_headers(),
                 params=params,
                 json=json,
                 **kwargs,
             )
-            
+
             # Check for HTTP errors
             if response.status_code >= 400:
                 self._handle_error_response(response)
-            
+
             return response
         except httpx.TimeoutException as e:
             raise FleetTimeoutError(f"Request timed out: {str(e)}")
         except httpx.RequestError as e:
             raise FleetAPIError(f"Request failed: {str(e)}")
-    
+
     def _handle_error_response(self, response: httpx.Response) -> None:
         """Handle HTTP error responses and convert to appropriate Fleet exceptions."""
         status_code = response.status_code
-        
+
         # Try to parse error response as JSON
         try:
             error_data = response.json()
             detail = error_data.get("detail", response.text)
-            
+
             # Handle structured error responses
             if isinstance(detail, dict):
                 error_type = detail.get("error_type", "")
                 error_message = detail.get("message", str(detail))
-                
+
                 if error_type == "instance_limit_exceeded":
                     raise FleetInstanceLimitError(
                         error_message,
                         running_instances=detail.get("running_instances"),
-                        instance_limit=detail.get("instance_limit")
+                        instance_limit=detail.get("instance_limit"),
                     )
                 else:
                     error_message = detail.get("message", str(detail))
             else:
                 error_message = detail
-                
+
         except (json.JSONDecodeError, ValueError):
             error_message = response.text
             error_data = None
-        
+
         # Handle specific error types
         if status_code == 401:
             raise FleetAuthenticationError(error_message)
-        elif status_code == 429:
-            # Check if it's an instance limit error vs rate limit error (fallback for unstructured errors)
+        elif status_code == 403:
+            # Handle 403 errors - instance limit, permissions, team not found
             if "instance limit" in error_message.lower():
                 # Try to extract instance counts from the error message
                 running_instances = None
                 instance_limit = None
-                if "You have" in error_message and "running instances out of a maximum of" in error_message:
+                if (
+                    "You have" in error_message
+                    and "running instances out of a maximum of" in error_message
+                ):
                     try:
                         # Extract numbers from message like "You have 5 running instances out of a maximum of 10"
-                        parts = error_message.split("You have ")[1].split(" running instances out of a maximum of ")
+                        parts = error_message.split("You have ")[1].split(
+                            " running instances out of a maximum of "
+                        )
                         if len(parts) == 2:
                             running_instances = int(parts[0])
                             instance_limit = int(parts[1].split(".")[0])
                     except (IndexError, ValueError):
                         pass
-                
+
                 raise FleetInstanceLimitError(
-                    error_message, 
-                    running_instances=running_instances, 
-                    instance_limit=instance_limit
+                    error_message,
+                    running_instances=running_instances,
+                    instance_limit=instance_limit,
                 )
+            elif "team not found" in error_message.lower():
+                raise FleetTeamNotFoundError(error_message)
+            elif (
+                "does not have permission" in error_message.lower()
+                and "environment" in error_message.lower()
+            ):
+                # Extract environment key from error message if possible
+                env_key = None
+                if "'" in error_message:
+                    # Look for quoted environment key
+                    parts = error_message.split("'")
+                    if len(parts) >= 2:
+                        env_key = parts[1]
+                raise FleetEnvironmentAccessError(error_message, env_key=env_key)
             else:
-                raise FleetRateLimitError(error_message)
+                raise FleetPermissionError(error_message)
+        elif status_code == 400:
+            # Handle 400 errors - bad requests, region errors, environment/version not found
+            if "region" in error_message.lower() and (
+                "not supported" in error_message.lower()
+                or "unsupported" in error_message.lower()
+            ):
+                # Extract region and supported regions if possible
+                region = None
+                supported_regions = []
+                if "Region" in error_message:
+                    # Try to extract region from "Region X not supported"
+                    try:
+                        parts = error_message.split("Region ")[1].split(
+                            " not supported"
+                        )
+                        if parts:
+                            region = parts[0]
+                    except (IndexError, ValueError):
+                        pass
+                    # Try to extract supported regions from "Please use [...]"
+                    if "Please use" in error_message and "[" in error_message:
+                        try:
+                            regions_str = error_message.split("[")[1].split("]")[0]
+                            supported_regions = [
+                                r.strip().strip("'\"") for r in regions_str.split(",")
+                            ]
+                        except (IndexError, ValueError):
+                            pass
+                raise FleetRegionError(
+                    error_message, region=region, supported_regions=supported_regions
+                )
+            elif (
+                "environment" in error_message.lower()
+                and "not found" in error_message.lower()
+            ):
+                # Extract env_key if possible
+                env_key = None
+                if "'" in error_message:
+                    parts = error_message.split("'")
+                    if len(parts) >= 2:
+                        env_key = parts[1]
+                raise FleetEnvironmentNotFoundError(error_message, env_key=env_key)
+            elif (
+                "version" in error_message.lower()
+                and "not found" in error_message.lower()
+            ):
+                # Extract version and env_key if possible
+                version = None
+                env_key = None
+                if "'" in error_message:
+                    parts = error_message.split("'")
+                    if len(parts) >= 2:
+                        version = parts[1]
+                    if len(parts) >= 4:
+                        env_key = parts[3]
+                raise FleetVersionNotFoundError(
+                    error_message, version=version, env_key=env_key
+                )
+            else:
+                raise FleetBadRequestError(error_message)
+        elif status_code == 429:
+            # Rate limit errors (not instance limit which is now 403)
+            raise FleetRateLimitError(error_message)
         else:
             raise FleetAPIError(
                 error_message,
                 status_code=status_code,
-                response_data=error_data if 'error_data' in locals() else None
-            )
+                response_data=error_data if "error_data" in locals() else None,
+            )

fleet/_async/client.py

@@ -29,6 +29,8 @@ from .instance import (
     ValidatorType,
     ExecuteFunctionResponse,
 )
+from .config import DEFAULT_MAX_RETRIES, REGION_BASE_URL
+from .instance.base import default_httpx_client
 from .resources.base import Resource
 from .resources.sqlite import AsyncSQLiteResource
 from .resources.browser import AsyncBrowserResource
@@ -37,15 +39,17 @@ logger = logging.getLogger(__name__)
 
 
 class AsyncEnvironment(EnvironmentBase):
-    def __init__(self, httpx_client: Optional[httpx.AsyncClient] = None, **kwargs):
+    def __init__(self, client: AsyncWrapper, **kwargs):
         super().__init__(**kwargs)
-        self._httpx_client = httpx_client or httpx.AsyncClient(timeout=180.0)
+        self._client = client
         self._instance: Optional[AsyncInstanceClient] = None
 
     @property
     def instance(self) -> AsyncInstanceClient:
         if self._instance is None:
-            self._instance = AsyncInstanceClient(self.manager_url, self._httpx_client)
+            self._instance = AsyncInstanceClient(
+                self.manager_url, self._client.httpx_client
+            )
         return self._instance
 
     async def reset(
@@ -66,7 +70,10 @@ class AsyncEnvironment(EnvironmentBase):
         return await self.instance.resources()
 
     async def close(self) -> InstanceRecord:
-        return await AsyncFleet().delete(self.instance_id)
+        response = await self._client.request(
+            "DELETE", f"/v1/env/instances/{self.instance_id}"
+        )
+        return InstanceRecord(**response.json())
 
     async def verify(self, validator: ValidatorType) -> ExecuteFunctionResponse:
         return await self.instance.verify(validator)
@@ -83,8 +90,9 @@ class AsyncFleet:
         api_key: Optional[str] = os.getenv("FLEET_API_KEY"),
         base_url: Optional[str] = None,
         httpx_client: Optional[httpx.AsyncClient] = None,
+        max_retries: int = DEFAULT_MAX_RETRIES,
     ):
-        self._httpx_client = httpx_client or httpx.AsyncClient(timeout=180.0)
+        self._httpx_client = httpx_client or default_httpx_client(max_retries)
         self.client = AsyncWrapper(
             api_key=api_key,
             base_url=base_url,
@@ -95,6 +103,10 @@ class AsyncFleet:
         response = await self.client.request("GET", "/v1/env/")
         return [EnvironmentModel(**env_data) for env_data in response.json()]
 
+    async def list_regions(self) -> List[str]:
+        response = await self.client.request("GET", "/v1/regions")
+        return response.json()
+
     async def environment(self, env_key: str) -> EnvironmentModel:
         response = await self.client.request("GET", f"/v1/env/{env_key}")
         return EnvironmentModel(**response.json())
@@ -111,10 +123,14 @@ class AsyncFleet:
             version = None
 
         request = InstanceRequest(env_key=env_key_part, version=version, region=region)
+        region_base_url = REGION_BASE_URL.get(region)
         response = await self.client.request(
-            "POST", "/v1/env/instances", json=request.model_dump()
+            "POST",
+            "/v1/env/instances",
+            json=request.model_dump(),
+            base_url=region_base_url,
         )
-        instance = AsyncEnvironment(**response.json())
+        instance = AsyncEnvironment(client=self.client, **response.json())
         await instance.instance.load()
         return instance
 
@@ -128,11 +144,14 @@ class AsyncFleet:
             params["region"] = region
 
         response = await self.client.request("GET", "/v1/env/instances", params=params)
-        return [AsyncEnvironment(**instance_data) for instance_data in response.json()]
+        return [
+            AsyncEnvironment(client=self.client, **instance_data)
+            for instance_data in response.json()
+        ]
 
     async def instance(self, instance_id: str) -> AsyncEnvironment:
         response = await self.client.request("GET", f"/v1/env/instances/{instance_id}")
-        instance = AsyncEnvironment(**response.json())
+        instance = AsyncEnvironment(client=self.client, **response.json())
         await instance.instance.load()
         return instance
 

fleet/_async/config.py

@@ -0,0 +1,8 @@
+DEFAULT_MAX_RETRIES = 5
+
+GLOBAL_BASE_URL = "https://orchestrator.fleetai.com"
+REGION_BASE_URL = {
+    "us-west-1": "https://us-west-1.fleetai.com",
+    "us-east-1": "https://us-east-1.fleetai.com",
+    "eu-west-2": "https://eu-west-2.fleetai.com",
+}

fleet/_async/env/client.py

@@ -11,6 +11,10 @@ async def list_envs_async() -> List[EnvironmentModel]:
     return await AsyncFleet().list_envs()
 
 
+async def list_regions_async() -> List[str]:
+    return await AsyncFleet().list_regions()
+
+
 async def list_instances_async(
     status: Optional[str] = None, region: Optional[str] = None
 ) -> List[AsyncEnvironment]:

fleet/_async/exceptions.py

@@ -5,7 +5,7 @@ from typing import Any, Dict, Optional
 
 class FleetError(Exception):
     """Base exception for all Fleet SDK errors."""
-    
+
     def __init__(self, message: str, details: Optional[Dict[str, Any]] = None):
         super().__init__(message)
         self.message = message
@@ -14,7 +14,7 @@ class FleetError(Exception):
 
 class FleetAPIError(FleetError):
     """Exception raised when Fleet API returns an error."""
-    
+
     def __init__(
         self,
         message: str,
@@ -29,7 +29,7 @@ class FleetAPIError(FleetError):
 
 class FleetTimeoutError(FleetError):
     """Exception raised when a Fleet operation times out."""
-    
+
     def __init__(self, message: str, timeout_duration: Optional[float] = None):
         super().__init__(message)
         self.timeout_duration = timeout_duration
@@ -37,30 +37,109 @@ class FleetTimeoutError(FleetError):
 
 class FleetAuthenticationError(FleetAPIError):
     """Exception raised when authentication fails."""
-    
+
     def __init__(self, message: str = "Authentication failed"):
         super().__init__(message, status_code=401)
 
 
 class FleetRateLimitError(FleetAPIError):
     """Exception raised when rate limit is exceeded."""
-    
+
     def __init__(self, message: str = "Rate limit exceeded"):
         super().__init__(message, status_code=429)
 
 
 class FleetInstanceLimitError(FleetAPIError):
     """Exception raised when team instance limit is exceeded."""
-    
-    def __init__(self, message: str = "Instance limit exceeded", running_instances: Optional[int] = None, instance_limit: Optional[int] = None):
-        super().__init__(message, status_code=429)
+
+    def __init__(
+        self,
+        message: str = "Instance limit exceeded",
+        running_instances: Optional[int] = None,
+        instance_limit: Optional[int] = None,
+    ):
+        super().__init__(message, status_code=403)
         self.running_instances = running_instances
         self.instance_limit = instance_limit
 
 
+class FleetBadRequestError(FleetAPIError):
+    """Exception raised for bad request errors (400)."""
+
+    def __init__(self, message: str, error_type: Optional[str] = None):
+        super().__init__(message, status_code=400)
+        self.error_type = error_type
+
+
+class FleetPermissionError(FleetAPIError):
+    """Exception raised when permission is denied (403)."""
+
+    def __init__(
+        self,
+        message: str,
+        resource_type: Optional[str] = None,
+        resource_id: Optional[str] = None,
+    ):
+        super().__init__(message, status_code=403)
+        self.resource_type = resource_type
+        self.resource_id = resource_id
+
+
+class FleetRegionError(FleetBadRequestError):
+    """Exception raised when an unsupported region is specified."""
+
+    def __init__(
+        self,
+        message: str,
+        region: Optional[str] = None,
+        supported_regions: Optional[list] = None,
+    ):
+        super().__init__(message, error_type="unsupported_region")
+        self.region = region
+        self.supported_regions = supported_regions or []
+
+
+class FleetEnvironmentNotFoundError(FleetBadRequestError):
+    """Exception raised when environment is not found."""
+
+    def __init__(self, message: str, env_key: Optional[str] = None):
+        super().__init__(message, error_type="environment_not_found")
+        self.env_key = env_key
+
+
+class FleetVersionNotFoundError(FleetBadRequestError):
+    """Exception raised when version is not found."""
+
+    def __init__(
+        self, message: str, env_key: Optional[str] = None, version: Optional[str] = None
+    ):
+        super().__init__(message, error_type="version_not_found")
+        self.env_key = env_key
+        self.version = version
+
+
+class FleetEnvironmentAccessError(FleetPermissionError):
+    """Exception raised when team doesn't have access to an environment."""
+
+    def __init__(
+        self, message: str, env_key: Optional[str] = None, version: Optional[str] = None
+    ):
+        super().__init__(message, resource_type="environment", resource_id=env_key)
+        self.env_key = env_key
+        self.version = version
+
+
+class FleetTeamNotFoundError(FleetPermissionError):
+    """Exception raised when team is not found."""
+
+    def __init__(self, message: str, team_id: Optional[str] = None):
+        super().__init__(message, resource_type="team", resource_id=team_id)
+        self.team_id = team_id
+
+
 class FleetEnvironmentError(FleetError):
     """Exception raised when environment operations fail."""
-    
+
     def __init__(self, message: str, environment_id: Optional[str] = None):
         super().__init__(message)
         self.environment_id = environment_id
@@ -68,7 +147,7 @@ class FleetEnvironmentError(FleetError):
 
 class FleetFacetError(FleetError):
     """Exception raised when facet operations fail."""
-    
+
     def __init__(self, message: str, facet_type: Optional[str] = None):
         super().__init__(message)
         self.facet_type = facet_type
@@ -76,7 +155,7 @@ class FleetFacetError(FleetError):
 
 class FleetConfigurationError(FleetError):
     """Exception raised when configuration is invalid."""
-    
+
     def __init__(self, message: str, config_key: Optional[str] = None):
         super().__init__(message)
-        self.config_key = config_key 
+        self.config_key = config_key

fleet/_async/instance/base.py

@@ -1,7 +1,31 @@
 import httpx
+import httpx_retries
 from typing import Dict, Any, Optional
 
 
+def default_httpx_client(max_retries: int) -> httpx.AsyncClient:
+    policy = httpx_retries.Retry(
+        total=max_retries,
+        status_forcelist=[
+            404,
+            429,
+            500,
+            502,
+            503,
+            504,
+        ],
+        allowed_methods=["GET", "POST", "PATCH", "DELETE"],
+        backoff_factor=0.5,
+    )
+    retry = httpx_retries.RetryTransport(
+        transport=httpx.AsyncHTTPTransport(retries=2), retry=policy
+    )
+    return httpx.AsyncClient(
+        timeout=300.0,
+        transport=retry,
+    )
+
+
 class BaseWrapper:
     def __init__(self, *, url: str):
         self.url = url
@@ -34,4 +58,4 @@ class AsyncWrapper(BaseWrapper):
             params=params,
             json=json,
             **kwargs,
-        )
+        )

fleet/_async/instance/client.py

@@ -1,7 +1,6 @@
 """Fleet SDK Instance Client."""
 
 from typing import Any, Callable, Dict, List, Optional, Tuple
-import asyncio
 import httpx
 import inspect
 import time
@@ -14,9 +13,10 @@ from ..resources.base import Resource
 
 from fleet.verifiers import DatabaseSnapshot
 
-from ..exceptions import FleetEnvironmentError, FleetAPIError
+from ..exceptions import FleetEnvironmentError
+from ..config import DEFAULT_MAX_RETRIES
 
-from .base import AsyncWrapper
+from .base import AsyncWrapper, default_httpx_client
 from .models import (
     ResetRequest,
     ResetResponse,
@@ -51,7 +51,7 @@ class AsyncInstanceClient:
         self.base_url = url
         self.client = AsyncWrapper(
             url=self.base_url,
-            httpx_client=httpx_client or httpx.AsyncClient(timeout=180.0),
+            httpx_client=httpx_client or default_httpx_client(DEFAULT_MAX_RETRIES),
         )
         self._resources: Optional[List[ResourceModel]] = None
         self._resources_state: Dict[str, Dict[str, Resource]] = {

fleet/base.py

@@ -9,6 +9,13 @@ from .exceptions import (
     FleetRateLimitError,
     FleetInstanceLimitError,
     FleetTimeoutError,
+    FleetTeamNotFoundError,
+    FleetEnvironmentAccessError,
+    FleetRegionError,
+    FleetEnvironmentNotFoundError,
+    FleetVersionNotFoundError,
+    FleetBadRequestError,
+    FleetPermissionError,
 )
 
 
@@ -47,86 +54,170 @@ class SyncWrapper(BaseWrapper):
         url: str,
         params: Optional[Dict[str, Any]] = None,
         json: Optional[Any] = None,
+        base_url: Optional[str] = None,
         **kwargs,
     ) -> httpx.Response:
+        base_url = base_url or self.base_url
         try:
             response = self.httpx_client.request(
                 method,
-                f"{self.base_url}{url}",
+                f"{base_url}{url}",
                 headers=self.get_headers(),
                 params=params,
                 json=json,
                 **kwargs,
             )
-            
+
             # Check for HTTP errors
             if response.status_code >= 400:
                 self._handle_error_response(response)
-            
+
             return response
         except httpx.TimeoutException as e:
             raise FleetTimeoutError(f"Request timed out: {str(e)}")
         except httpx.RequestError as e:
             raise FleetAPIError(f"Request failed: {str(e)}")
-    
+
     def _handle_error_response(self, response: httpx.Response) -> None:
         """Handle HTTP error responses and convert to appropriate Fleet exceptions."""
         status_code = response.status_code
-        
+
         # Try to parse error response as JSON
         try:
             error_data = response.json()
             detail = error_data.get("detail", response.text)
-            
+
             # Handle structured error responses
             if isinstance(detail, dict):
                 error_type = detail.get("error_type", "")
                 error_message = detail.get("message", str(detail))
-                
+
                 if error_type == "instance_limit_exceeded":
                     raise FleetInstanceLimitError(
                         error_message,
                         running_instances=detail.get("running_instances"),
-                        instance_limit=detail.get("instance_limit")
+                        instance_limit=detail.get("instance_limit"),
                     )
                 else:
                     error_message = detail.get("message", str(detail))
             else:
                 error_message = detail
-                
+
         except (json.JSONDecodeError, ValueError):
             error_message = response.text
             error_data = None
-        
+
         # Handle specific error types
         if status_code == 401:
             raise FleetAuthenticationError(error_message)
-        elif status_code == 429:
-            # Check if it's an instance limit error vs rate limit error (fallback for unstructured errors)
+        elif status_code == 403:
+            # Handle 403 errors - instance limit, permissions, team not found
             if "instance limit" in error_message.lower():
                 # Try to extract instance counts from the error message
                 running_instances = None
                 instance_limit = None
-                if "You have" in error_message and "running instances out of a maximum of" in error_message:
+                if (
+                    "You have" in error_message
+                    and "running instances out of a maximum of" in error_message
+                ):
                     try:
                         # Extract numbers from message like "You have 5 running instances out of a maximum of 10"
-                        parts = error_message.split("You have ")[1].split(" running instances out of a maximum of ")
+                        parts = error_message.split("You have ")[1].split(
+                            " running instances out of a maximum of "
+                        )
                         if len(parts) == 2:
                             running_instances = int(parts[0])
                             instance_limit = int(parts[1].split(".")[0])
                     except (IndexError, ValueError):
                         pass
-                
+
                 raise FleetInstanceLimitError(
-                    error_message, 
-                    running_instances=running_instances, 
-                    instance_limit=instance_limit
+                    error_message,
+                    running_instances=running_instances,
+                    instance_limit=instance_limit,
                 )
+            elif "team not found" in error_message.lower():
+                raise FleetTeamNotFoundError(error_message)
+            elif (
+                "does not have permission" in error_message.lower()
+                and "environment" in error_message.lower()
+            ):
+                # Extract environment key from error message if possible
+                env_key = None
+                if "'" in error_message:
+                    # Look for quoted environment key
+                    parts = error_message.split("'")
+                    if len(parts) >= 2:
+                        env_key = parts[1]
+                raise FleetEnvironmentAccessError(error_message, env_key=env_key)
             else:
-                raise FleetRateLimitError(error_message)
+                raise FleetPermissionError(error_message)
+        elif status_code == 400:
+            # Handle 400 errors - bad requests, region errors, environment/version not found
+            if "region" in error_message.lower() and (
+                "not supported" in error_message.lower()
+                or "unsupported" in error_message.lower()
+            ):
+                # Extract region and supported regions if possible
+                region = None
+                supported_regions = []
+                if "Region" in error_message:
+                    # Try to extract region from "Region X not supported"
+                    try:
+                        parts = error_message.split("Region ")[1].split(
+                            " not supported"
+                        )
+                        if parts:
+                            region = parts[0]
+                    except (IndexError, ValueError):
+                        pass
+                    # Try to extract supported regions from "Please use [...]"
+                    if "Please use" in error_message and "[" in error_message:
+                        try:
+                            regions_str = error_message.split("[")[1].split("]")[0]
+                            supported_regions = [
+                                r.strip().strip("'\"") for r in regions_str.split(",")
+                            ]
+                        except (IndexError, ValueError):
+                            pass
+                raise FleetRegionError(
+                    error_message, region=region, supported_regions=supported_regions
+                )
+            elif (
+                "environment" in error_message.lower()
+                and "not found" in error_message.lower()
+            ):
+                # Extract env_key if possible
+                env_key = None
+                if "'" in error_message:
+                    parts = error_message.split("'")
+                    if len(parts) >= 2:
+                        env_key = parts[1]
+                raise FleetEnvironmentNotFoundError(error_message, env_key=env_key)
+            elif (
+                "version" in error_message.lower()
+                and "not found" in error_message.lower()
+            ):
+                # Extract version and env_key if possible
+                version = None
+                env_key = None
+                if "'" in error_message:
+                    parts = error_message.split("'")
+                    if len(parts) >= 2:
+                        version = parts[1]
+                    if len(parts) >= 4:
+                        env_key = parts[3]
+                raise FleetVersionNotFoundError(
+                    error_message, version=version, env_key=env_key
+                )
+            else:
+                raise FleetBadRequestError(error_message)
+        elif status_code == 429:
+            # Rate limit errors (not instance limit which is now 403)
+            raise FleetRateLimitError(error_message)
         else:
             raise FleetAPIError(
                 error_message,
                 status_code=status_code,
-                response_data=error_data if 'error_data' in locals() else None
-            )
+                response_data=error_data if "error_data" in locals() else None,
+            )

fleet/client.py

@@ -29,6 +29,8 @@ from .instance import (
     ValidatorType,
     ExecuteFunctionResponse,
 )
+from .config import DEFAULT_MAX_RETRIES, REGION_BASE_URL
+from .instance.base import default_httpx_client
 from .resources.base import Resource
 from .resources.sqlite import SQLiteResource
 from .resources.browser import BrowserResource
@@ -37,15 +39,17 @@ logger = logging.getLogger(__name__)
 
 
 class Environment(EnvironmentBase):
-    def __init__(self, httpx_client: Optional[httpx.Client] = None, **kwargs):
+    def __init__(self, client: SyncWrapper, **kwargs):
         super().__init__(**kwargs)
-        self._httpx_client = httpx_client or httpx.Client(timeout=180.0)
+        self._client = client
         self._instance: Optional[InstanceClient] = None
 
     @property
     def instance(self) -> InstanceClient:
         if self._instance is None:
-            self._instance = InstanceClient(self.manager_url, self._httpx_client)
+            self._instance = InstanceClient(
+                self.manager_url, self._client.httpx_client
+            )
         return self._instance
 
     def reset(
@@ -66,7 +70,10 @@ class Environment(EnvironmentBase):
         return self.instance.resources()
 
     def close(self) -> InstanceRecord:
-        return Fleet().delete(self.instance_id)
+        response = self._client.request(
+            "DELETE", f"/v1/env/instances/{self.instance_id}"
+        )
+        return InstanceRecord(**response.json())
 
     def verify(self, validator: ValidatorType) -> ExecuteFunctionResponse:
         return self.instance.verify(validator)
@@ -83,8 +90,9 @@ class Fleet:
         api_key: Optional[str] = os.getenv("FLEET_API_KEY"),
         base_url: Optional[str] = None,
         httpx_client: Optional[httpx.Client] = None,
+        max_retries: int = DEFAULT_MAX_RETRIES,
     ):
-        self._httpx_client = httpx_client or httpx.Client(timeout=180.0)
+        self._httpx_client = httpx_client or default_httpx_client(max_retries)
         self.client = SyncWrapper(
             api_key=api_key,
             base_url=base_url,
@@ -95,6 +103,10 @@ class Fleet:
         response = self.client.request("GET", "/v1/env/")
         return [EnvironmentModel(**env_data) for env_data in response.json()]
 
+    def list_regions(self) -> List[str]:
+        response = self.client.request("GET", "/v1/regions")
+        return response.json()
+
     def environment(self, env_key: str) -> EnvironmentModel:
         response = self.client.request("GET", f"/v1/env/{env_key}")
         return EnvironmentModel(**response.json())
@@ -111,10 +123,14 @@ class Fleet:
             version = None
 
         request = InstanceRequest(env_key=env_key_part, version=version, region=region)
+        region_base_url = REGION_BASE_URL.get(region)
         response = self.client.request(
-            "POST", "/v1/env/instances", json=request.model_dump()
+            "POST",
+            "/v1/env/instances",
+            json=request.model_dump(),
+            base_url=region_base_url,
         )
-        instance = Environment(**response.json())
+        instance = Environment(client=self.client, **response.json())
         instance.instance.load()
         return instance
 
@@ -128,11 +144,14 @@ class Fleet:
             params["region"] = region
 
         response = self.client.request("GET", "/v1/env/instances", params=params)
-        return [Environment(**instance_data) for instance_data in response.json()]
+        return [
+            Environment(client=self.client, **instance_data)
+            for instance_data in response.json()
+        ]
 
     def instance(self, instance_id: str) -> Environment:
         response = self.client.request("GET", f"/v1/env/instances/{instance_id}")
-        instance = Environment(**response.json())
+        instance = Environment(client=self.client, **response.json())
         instance.instance.load()
         return instance
 

fleet/config.py

@@ -0,0 +1,8 @@
+DEFAULT_MAX_RETRIES = 5
+
+GLOBAL_BASE_URL = "https://orchestrator.fleetai.com"
+REGION_BASE_URL = {
+    "us-west-1": "https://us-west-1.fleetai.com",
+    "us-east-1": "https://us-east-1.fleetai.com",
+    "eu-west-2": "https://eu-west-2.fleetai.com",
+}

fleet/env/__init__.py

@@ -1,17 +1,25 @@
 """Fleet env module - convenience functions for environment management."""
 
-from .client import make, list_envs, get, list_instances
+from .client import make, list_envs, list_regions, get, list_instances
 
 # Import async versions from _async
-from .._async.env.client import make_async, list_envs_async, get_async, list_instances_async
+from .._async.env.client import (
+    make_async,
+    list_envs_async,
+    list_regions_async,
+    get_async,
+    list_instances_async,
+)
 
 __all__ = [
     "make",
-    "list_envs", 
+    "list_envs",
+    "list_regions",
     "list_instances",
     "get",
     "make_async",
     "list_envs_async",
+    "list_regions_async",
     "list_instances_async",
     "get_async",
-]
+]

fleet/env/client.py

@@ -11,6 +11,10 @@ def list_envs() -> List[EnvironmentModel]:
     return Fleet().list_envs()
 
 
+def list_regions() -> List[str]:
+    return Fleet().list_regions()
+
+
 def list_instances(
     status: Optional[str] = None, region: Optional[str] = None
 ) -> List[Environment]:

fleet/exceptions.py

@@ -5,7 +5,7 @@ from typing import Any, Dict, Optional
 
 class FleetError(Exception):
     """Base exception for all Fleet SDK errors."""
-    
+
     def __init__(self, message: str, details: Optional[Dict[str, Any]] = None):
         super().__init__(message)
         self.message = message
@@ -14,7 +14,7 @@ class FleetError(Exception):
 
 class FleetAPIError(FleetError):
     """Exception raised when Fleet API returns an error."""
-    
+
     def __init__(
         self,
         message: str,
@@ -29,7 +29,7 @@ class FleetAPIError(FleetError):
 
 class FleetTimeoutError(FleetError):
     """Exception raised when a Fleet operation times out."""
-    
+
     def __init__(self, message: str, timeout_duration: Optional[float] = None):
         super().__init__(message)
         self.timeout_duration = timeout_duration
@@ -37,30 +37,109 @@ class FleetTimeoutError(FleetError):
 
 class FleetAuthenticationError(FleetAPIError):
     """Exception raised when authentication fails."""
-    
+
     def __init__(self, message: str = "Authentication failed"):
         super().__init__(message, status_code=401)
 
 
 class FleetRateLimitError(FleetAPIError):
     """Exception raised when rate limit is exceeded."""
-    
+
     def __init__(self, message: str = "Rate limit exceeded"):
         super().__init__(message, status_code=429)
 
 
 class FleetInstanceLimitError(FleetAPIError):
     """Exception raised when team instance limit is exceeded."""
-    
-    def __init__(self, message: str = "Instance limit exceeded", running_instances: Optional[int] = None, instance_limit: Optional[int] = None):
-        super().__init__(message, status_code=429)
+
+    def __init__(
+        self,
+        message: str = "Instance limit exceeded",
+        running_instances: Optional[int] = None,
+        instance_limit: Optional[int] = None,
+    ):
+        super().__init__(message, status_code=403)
         self.running_instances = running_instances
         self.instance_limit = instance_limit
 
 
+class FleetBadRequestError(FleetAPIError):
+    """Exception raised for bad request errors (400)."""
+
+    def __init__(self, message: str, error_type: Optional[str] = None):
+        super().__init__(message, status_code=400)
+        self.error_type = error_type
+
+
+class FleetPermissionError(FleetAPIError):
+    """Exception raised when permission is denied (403)."""
+
+    def __init__(
+        self,
+        message: str,
+        resource_type: Optional[str] = None,
+        resource_id: Optional[str] = None,
+    ):
+        super().__init__(message, status_code=403)
+        self.resource_type = resource_type
+        self.resource_id = resource_id
+
+
+class FleetRegionError(FleetBadRequestError):
+    """Exception raised when an unsupported region is specified."""
+
+    def __init__(
+        self,
+        message: str,
+        region: Optional[str] = None,
+        supported_regions: Optional[list] = None,
+    ):
+        super().__init__(message, error_type="unsupported_region")
+        self.region = region
+        self.supported_regions = supported_regions or []
+
+
+class FleetEnvironmentNotFoundError(FleetBadRequestError):
+    """Exception raised when environment is not found."""
+
+    def __init__(self, message: str, env_key: Optional[str] = None):
+        super().__init__(message, error_type="environment_not_found")
+        self.env_key = env_key
+
+
+class FleetVersionNotFoundError(FleetBadRequestError):
+    """Exception raised when version is not found."""
+
+    def __init__(
+        self, message: str, env_key: Optional[str] = None, version: Optional[str] = None
+    ):
+        super().__init__(message, error_type="version_not_found")
+        self.env_key = env_key
+        self.version = version
+
+
+class FleetEnvironmentAccessError(FleetPermissionError):
+    """Exception raised when team doesn't have access to an environment."""
+
+    def __init__(
+        self, message: str, env_key: Optional[str] = None, version: Optional[str] = None
+    ):
+        super().__init__(message, resource_type="environment", resource_id=env_key)
+        self.env_key = env_key
+        self.version = version
+
+
+class FleetTeamNotFoundError(FleetPermissionError):
+    """Exception raised when team is not found."""
+
+    def __init__(self, message: str, team_id: Optional[str] = None):
+        super().__init__(message, resource_type="team", resource_id=team_id)
+        self.team_id = team_id
+
+
 class FleetEnvironmentError(FleetError):
     """Exception raised when environment operations fail."""
-    
+
     def __init__(self, message: str, environment_id: Optional[str] = None):
         super().__init__(message)
         self.environment_id = environment_id
@@ -68,7 +147,7 @@ class FleetEnvironmentError(FleetError):
 
 class FleetFacetError(FleetError):
     """Exception raised when facet operations fail."""
-    
+
     def __init__(self, message: str, facet_type: Optional[str] = None):
         super().__init__(message)
         self.facet_type = facet_type
@@ -76,7 +155,7 @@ class FleetFacetError(FleetError):
 
 class FleetConfigurationError(FleetError):
     """Exception raised when configuration is invalid."""
-    
+
     def __init__(self, message: str, config_key: Optional[str] = None):
         super().__init__(message)
-        self.config_key = config_key 
+        self.config_key = config_key

fleet/instance/base.py

@@ -1,7 +1,31 @@
 import httpx
+import httpx_retries
 from typing import Dict, Any, Optional
 
 
+def default_httpx_client(max_retries: int) -> httpx.Client:
+    policy = httpx_retries.Retry(
+        total=max_retries,
+        status_forcelist=[
+            404,
+            429,
+            500,
+            502,
+            503,
+            504,
+        ],
+        allowed_methods=["GET", "POST", "PATCH", "DELETE"],
+        backoff_factor=0.5,
+    )
+    retry = httpx_retries.RetryTransport(
+        transport=httpx.HTTPTransport(retries=2), retry=policy
+    )
+    return httpx.Client(
+        timeout=300.0,
+        transport=retry,
+    )
+
+
 class BaseWrapper:
     def __init__(self, *, url: str):
         self.url = url
@@ -34,4 +58,4 @@ class SyncWrapper(BaseWrapper):
             params=params,
             json=json,
             **kwargs,
-        )
+        )

fleet/instance/client.py

@@ -13,9 +13,10 @@ from ..resources.base import Resource
 
 from ..verifiers import DatabaseSnapshot
 
-from ..exceptions import FleetEnvironmentError, FleetAPIError
+from ..exceptions import FleetEnvironmentError
+from ..config import DEFAULT_MAX_RETRIES
 
-from .base import SyncWrapper
+from .base import SyncWrapper, default_httpx_client
 from .models import (
     ResetRequest,
     ResetResponse,
@@ -50,7 +51,7 @@ class InstanceClient:
         self.base_url = url
         self.client = SyncWrapper(
             url=self.base_url,
-            httpx_client=httpx_client or httpx.Client(timeout=180.0),
+            httpx_client=httpx_client or default_httpx_client(DEFAULT_MAX_RETRIES),
         )
         self._resources: Optional[List[ResourceModel]] = None
         self._resources_state: Dict[str, Dict[str, Resource]] = {

{fleet_python-0.2.10.dist-info → fleet_python-0.2.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fleet-python
-Version: 0.2.10
+Version: 0.2.12
 Summary: Python SDK for Fleet environments
 Author-email: Fleet AI <nic@fleet.so>
 License: Apache-2.0
@@ -23,6 +23,7 @@ License-File: LICENSE
 Requires-Dist: aiohttp>=3.8.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: httpx>=0.27.0
+Requires-Dist: httpx-retries>=0.4.0
 Requires-Dist: typing-extensions>=4.0.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"

{fleet_python-0.2.10.dist-info → fleet_python-0.2.12.dist-info}/RECORD

@@ -1,5 +1,5 @@
 examples/dsl_example.py,sha256=3Eu5924a8x61nuSGXqGz8XjPLNKKH8Ye7lSYHSvixtk,5361
-examples/example.py,sha256=FFPfM5Oso7IP9Q8aELpof1J41zslELdHHJhAAck9vLk,1008
+examples/example.py,sha256=62rjLU3LdGEW9QJZjMP44Gtdjalv-6oRnClDFk67Oec,1089
 examples/example_client.py,sha256=70HKEhz_Gb79YcvKQauCPdS08AAwjo9unt2dh1jN_Oo,1030
 examples/example_sync.py,sha256=_XaM3E0osxdt7AJQrJdtgE_I4-ChWuANQ5HIxCisbJk,983
 examples/gemini_example.py,sha256=8mDXGGCaodyK6uXgpWhxi-DQ5OA-GFW12Gfwh0b3EDY,16177
@@ -9,32 +9,34 @@ examples/openai_example.py,sha256=I2vk_SJN9BkSRQCYRJfbtGJ-HJ2xzQj-lOjwqmLos5M,82
 examples/openai_simple_example.py,sha256=I42ytIwv0INgDO39pp1MOQSqsJz2YYH8GeNNBaUtq3A,1748
 examples/quickstart.py,sha256=1VT39IRRhemsJgxi0O0gprdpcw7HB4pYO97GAYagIcg,3788
 fleet/__init__.py,sha256=-EFlLzHmyJIUGSZ4_XIts6OhXIXGPyu5PgI9JxgDzTg,2165
-fleet/base.py,sha256=0ZxYHuIW3e4BKA2jRK41IP2N6SiOcoQwmTqBM5Z236I,4876
-fleet/client.py,sha256=RDU7uJesgOERTnIIz4wSq6BP_uQuY_M9TSXrlr1-jbU,4921
-fleet/exceptions.py,sha256=UHKUYK5OSeyLj9bmIPXwdtBkDMpAzfD3uxnH4yuE6k8,2659
+fleet/base.py,sha256=E4gUv_eQEU4eSzTBy8gLGwl0s4t57OCTnsMYTKP3qI0,8782
+fleet/client.py,sha256=5Cf9eGO_PaJaG_Um8WDo2b_Hv8HNZcPtuJ971e25QQU,5509
+fleet/config.py,sha256=9JoDqeAOV7JPcivKSUsxm0EghAY8tFUzU8NyCH4SR1E,250
+fleet/exceptions.py,sha256=fUmPwWhnT8SR97lYsRq0kLHQHKtSh2eJS0VQ2caSzEI,5055
 fleet/models.py,sha256=Jf6Zmk689TPXhTSnVENK_VCw0VsujWzEWsN3T29MQ0k,3713
 fleet/playwright.py,sha256=BmRvez5DUa0ttAQB084hPAyt9_8WxdzCGBGF-GZbTuQ,8593
 fleet/_async/__init__.py,sha256=AJWCnuo7XKja4yBb8fK2wX7ntciLXQrpzdRHwjTRP6M,62
-fleet/_async/base.py,sha256=j6Pqo0disJU3Nl2dLOacL9_7pYBslm5puIzFgDU54zg,4894
-fleet/_async/client.py,sha256=lubzRY8rzqDkpj_cCev5sN4OmTN6szittA3BQkC4ATY,5172
-fleet/_async/exceptions.py,sha256=UHKUYK5OSeyLj9bmIPXwdtBkDMpAzfD3uxnH4yuE6k8,2659
+fleet/_async/base.py,sha256=c84QR8NBXeRjmdXkCFrK0cvpAiE3VeJm2ELysg4hL-o,8800
+fleet/_async/client.py,sha256=5AiyAethOoNH19r1tJU63ANlKQ9AiuHLZyZqFtA7YIY,5753
+fleet/_async/config.py,sha256=9JoDqeAOV7JPcivKSUsxm0EghAY8tFUzU8NyCH4SR1E,250
+fleet/_async/exceptions.py,sha256=fUmPwWhnT8SR97lYsRq0kLHQHKtSh2eJS0VQ2caSzEI,5055
 fleet/_async/models.py,sha256=Jf6Zmk689TPXhTSnVENK_VCw0VsujWzEWsN3T29MQ0k,3713
 fleet/_async/playwright.py,sha256=2r4ywuv2ZqT0Qu3-k8A7V4YijeAOHnN8HiqJreLEYGI,8924
 fleet/_async/env/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fleet/_async/env/client.py,sha256=JPFTWRjyFkUVYFodQ4bRlafH5GRu34LckeFSmb8YdZo,692
+fleet/_async/env/client.py,sha256=lBLcuEeQ9B2JMp6xUPb7ANgBYl9XTJMoVaOzGW7s9Pk,784
 fleet/_async/instance/__init__.py,sha256=jIt-7EEJ0WM_ipheT_s0lniCbLei6yUdN0qQv1bMJ3E,524
-fleet/_async/instance/base.py,sha256=QgcCTHdcqhi5VQi6_a1uuR-uO2_2Z19-RwVPp1k266A,947
-fleet/_async/instance/client.py,sha256=XTQWCQ6QfTpmw4x8ctlWvvnkcO8fCYnYkzbPAgs2_U4,5654
+fleet/_async/instance/base.py,sha256=wL-Lb33QjwKvBsK1borBg9jLIwCjEOh0il8XqFDfo7w,1531
+fleet/_async/instance/client.py,sha256=S2MBIz4cilNm8u3yJWWIo8n5y8QE7we7COE74ykNxjk,5696
 fleet/_async/instance/models.py,sha256=ZTiue0YOuhuwX8jYfJAoCzGfqjLqqXRLqK1LVFhq6rQ,4183
 fleet/_async/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fleet/_async/resources/base.py,sha256=203gD54NP1IvjuSqFo-f7FvrkhtjChggtzrxJK7xf2E,667
 fleet/_async/resources/browser.py,sha256=x11y4aKHogIEv83FByHtExerjV-cDWI3U62349Guq_Q,1368
 fleet/_async/resources/sqlite.py,sha256=sRiII_qJ8X6-FSemlBsXThz4ZPjkNy9wDT8g5UAz2XM,1501
-fleet/env/__init__.py,sha256=dlh41oWCKwg1-wUsy1c4lCA34hRKlBjfGpgEXO96TyY,426
-fleet/env/client.py,sha256=kS6Qx466i37CA6gU-LR18p7c16OzL7rb80Gsa7ggcrM,575
+fleet/env/__init__.py,sha256=yYk657kVDnMWYbuPS_2o0kpVC99AYD85o5WG1jCaWSY,531
+fleet/env/client.py,sha256=HwJ-xCg3oZMJ48nP9_EaHk4Rao-na9myPX9X5JxYMbo,644
 fleet/instance/__init__.py,sha256=Hr8xPPoqzKOViXZXWmaL6dQ7NOBn-GooTGzoIvGmiE4,514
-fleet/instance/base.py,sha256=U-qW1EQVBo6yvMpP1JeKiPRhCjZ3y3aTsYFhLPNOTtQ,929
-fleet/instance/client.py,sha256=6Qm81vjVD-7p6ZMx9gbJwLP2R1vkqRe6Drs89w4Tf7I,5468
+fleet/instance/base.py,sha256=MMq3IoXFT5dl3lTxA0qzhw12OEe43b3h7qCQdUR1yvk,1498
+fleet/instance/client.py,sha256=KBVIojg5-OfRWf0MkHeuSt3C3NyZNhDtHKJmJoLuQs8,5530
 fleet/instance/models.py,sha256=ZTiue0YOuhuwX8jYfJAoCzGfqjLqqXRLqK1LVFhq6rQ,4183
 fleet/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fleet/resources/base.py,sha256=203gD54NP1IvjuSqFo-f7FvrkhtjChggtzrxJK7xf2E,667
@@ -44,10 +46,10 @@ fleet/verifiers/__init__.py,sha256=mRMN8x0gDWFJ1MRLqdBtQw0gn_q8kDV3lMLyoiEf1yY,2
 fleet/verifiers/code.py,sha256=NJ4OLZnpqLkI1lXY7-5m2GuZklLxMzHUCnRMVyN2_OI,25
 fleet/verifiers/db.py,sha256=tssmvJjDHuBIy8qlL_P5-UdmEFUw2DZcqLsWZ8ot3Xw,27766
 fleet/verifiers/sql_differ.py,sha256=dmiGCFXVMEMbAX519OjhVqgA8ZvhnvdmC1BVpL7QCF0,6490
-fleet_python-0.2.10.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-scripts/fix_sync_imports.py,sha256=b7tRvShgOFqyildqs1qI-Io0gaHappykBI-PSWWqUwE,2941
+fleet_python-0.2.12.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+scripts/fix_sync_imports.py,sha256=nIPK0xIIuH17sOa-SI1QPGGWkz5K1gBxuL1rTN_5PFU,3103
 scripts/unasync.py,sha256=--Fmaae47o-dZ1HYgX1c3Nvi-rMjcFymTRlJcWWnmpw,725
-fleet_python-0.2.10.dist-info/METADATA,sha256=aJB94O9zI2KjgEwcXhRYF0CTnhPSMAfUsMHIvOB4Mlc,4322
-fleet_python-0.2.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fleet_python-0.2.10.dist-info/top_level.txt,sha256=_3DSmTohvSDf3AIP_BYfGzhwO1ECFwuzg83X-wHCx3Y,23
-fleet_python-0.2.10.dist-info/RECORD,,
+fleet_python-0.2.12.dist-info/METADATA,sha256=E-uVjx2PGP2Es79eQ7VSLu_Nc5beqAwefdF7jng7OXE,4358
+fleet_python-0.2.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fleet_python-0.2.12.dist-info/top_level.txt,sha256=_3DSmTohvSDf3AIP_BYfGzhwO1ECFwuzg83X-wHCx3Y,23
+fleet_python-0.2.12.dist-info/RECORD,,

scripts/fix_sync_imports.py

@@ -25,6 +25,9 @@ def fix_file(filepath: Path) -> bool:
     # Fix any remaining AsyncFleetPlaywrightWrapper references in docstrings
     content = content.replace('AsyncFleetPlaywrightWrapper', 'FleetPlaywrightWrapper')
     
+    # Fix httpx transport classes
+    content = content.replace('httpx.SyncHTTPTransport', 'httpx.HTTPTransport')
+    
     # Fix playwright imports for sync version
     if 'playwright' in str(filepath):
         # Fix the import statement
@@ -54,6 +57,7 @@ def main():
     # Files to fix
     files_to_fix = [
         sync_dir / "instance" / "client.py",
+        sync_dir / "instance" / "base.py",
         sync_dir / "playwright.py",
         # Add other files here as needed
     ]