fleet-python 0.2.69__py3-none-any.whl → 0.2.69b3__py3-none-any.whl

fleet/_async/verifiers/bundler.py

@@ -37,7 +37,7 @@ class FunctionBundler:
     ) -> bytes:
         """Create a function bundle with statically extracted code."""
 
-        # logger.info(f"Creating function bundle for {func.__name__}")
+        logger.info(f"Creating function bundle for {func.__name__}")
 
         # 1. Parse the main function and find dependencies
         mod_file = Path(func.__code__.co_filename)
@@ -115,7 +115,7 @@ class FunctionBundler:
 
         # Find function calls within the verifier function
         called_functions = self._extract_function_calls(main_func_ast)
-        # logger.debug(f"Functions called in verifier: {called_functions}")
+        logger.debug(f"Functions called in verifier: {called_functions}")
 
         # Find all functions defined in the module
         module_functions = {}
@@ -128,7 +128,7 @@ class FunctionBundler:
         for func_name in called_functions:
             if func_name in module_functions and func_name != func.__name__:
                 same_module_deps.append(func_name)
-                # logger.debug(f"Found same-module dependency: {func_name}")
+                logger.debug(f"Found same-module dependency: {func_name}")
 
         # Separate local and external imports
         local_imports = {}
@@ -292,7 +292,7 @@ class FunctionBundler:
                     code = ast.unparse(node)
                     extracted_code.append(code)
                 except Exception as e:
-                    # logger.warning(f"Could not unparse AST node: {e}")
+                    logger.warning(f"Could not unparse AST node: {e}")
                     # Fallback to original source extraction
                     lines = content.split("\n")
                     start_line = node.lineno - 1
@@ -305,11 +305,11 @@ class FunctionBundler:
                     extracted_code.append(code)
 
             result = "\n\n".join(extracted_code)
-            # logger.debug(f"Extracted {len(extracted_code)} items from {file_path}")
+            logger.debug(f"Extracted {len(extracted_code)} items from {file_path}")
             return result
 
         except Exception as e:
-            # logger.warning(f"Failed to extract functions from {file_path}: {e}")
+            logger.warning(f"Failed to extract functions from {file_path}: {e}")
             # Fallback to including the entire file
             with open(file_path, "r", encoding="utf-8") as f:
                 return f.read()
@@ -464,14 +464,14 @@ class FunctionBundler:
                 version = dist.version  # Get the installed version
                 package_with_version = f"{package_name}=={version}"
                 packages.add(package_with_version)
-                # logger.debug(f"Mapped {mod} -> {package_with_version}")
+                logger.debug(f"Mapped {mod} -> {package_with_version}")
             except imd.PackageNotFoundError:
                 # Skip stdlib or local modules
-                # logger.debug(f"Skipping {mod} (stdlib or local)")
+                logger.debug(f"Skipping {mod} (stdlib or local)")
                 continue
 
         package_list = list(packages)
-        # logger.debug(f"Final package list: {package_list}")
+        logger.debug(f"Final package list: {package_list}")
         return package_list
 
     def _merge_requirements(
@@ -511,10 +511,10 @@ class FunctionBundler:
             if pkg_name not in seen_packages:
                 final_requirements.append(req)
                 seen_packages.add(pkg_name)
-            # else:
-            #     logger.debug(
-            #         f"Skipping auto-detected {req}, using explicit version instead"
-            #     )
+            else:
+                logger.debug(
+                    f"Skipping auto-detected {req}, using explicit version instead"
+                )
 
         # Always ensure fleet-python is included
         if "fleet-python" not in seen_packages:
@@ -565,9 +565,9 @@ class FunctionBundler:
                         )
                         if dep_src:
                             same_module_code += f"\n{dep_src}\n"
-                            # logger.debug(
-                            #     f"Extracted same-module dependency: {dep_name}"
-                            # )
+                            logger.debug(
+                                f"Extracted same-module dependency: {dep_name}"
+                            )
 
                 # Create verifier.py with the main function
                 verifier_file = build_dir / "verifier.py"
@@ -586,7 +586,7 @@ class FunctionBundler:
 {code}
 """
                     dest_path.write_text(extracted_content)
-                    # logger.debug(f"Created extracted file: {relative_path}")
+                    logger.debug(f"Created extracted file: {relative_path}")
 
                     # Ensure __init__.py files exist
                     self._ensure_init_files(Path(relative_path), build_dir)
@@ -595,7 +595,7 @@ class FunctionBundler:
                 return self._create_zip_bundle(build_dir)
 
             except Exception as e:
-                # logger.error(f"Failed to build function bundle: {e}")
+                logger.error(f"Failed to build function bundle: {e}")
                 raise RuntimeError(f"Function bundle creation failed: {e}")
 
     def _ensure_init_files(self, rel_path: Path, build_dir: Path):
@@ -607,7 +607,7 @@ class FunctionBundler:
             if not init_file.exists():
                 init_file.parent.mkdir(parents=True, exist_ok=True)
                 init_file.write_text("# Auto-generated __init__.py")
-                # logger.debug(f"Created __init__.py: {current}")
+                logger.debug(f"Created __init__.py: {current}")
             current = current.parent
 
     def _create_zip_bundle(self, build_dir: Path) -> bytes:
@@ -621,7 +621,7 @@ class FunctionBundler:
                     zf.write(file_path, arcname)
 
         bundle_size = len(zip_buffer.getvalue())
-        # logger.debug(f"Created function bundle ({bundle_size:,} bytes)")
+        logger.debug(f"Created function bundle ({bundle_size:,} bytes)")
         return zip_buffer.getvalue()
 
     def _extract_function_source(
@@ -662,8 +662,7 @@ class FunctionBundler:
                     return "\n".join(func_lines)
 
         except Exception as e:
-            # logger.warning(f"Failed to extract function {function_name}: {e}")
-            pass
+            logger.warning(f"Failed to extract function {function_name}: {e}")
 
         return None
 

fleet/_async/verifiers/verifier.py

@@ -79,9 +79,9 @@ class AsyncVerifierFunction:
 
                 self._bundle_data = zip_buffer.getvalue()
                 self._bundle_sha = _get_bundle_sha(self._bundle_data)
-                # logger.debug(
-                #     f"Created bundle from raw code for {self.key} with SHA: {self._bundle_sha}"
-                # )
+                logger.debug(
+                    f"Created bundle from raw code for {self.key} with SHA: {self._bundle_sha}"
+                )
             else:
                 # Try to create bundle from function source
                 try:
@@ -89,9 +89,9 @@ class AsyncVerifierFunction:
                         self.func, self.extra_requirements, self.verifier_id
                     )
                     self._bundle_sha = _get_bundle_sha(self._bundle_data)
-                    # logger.debug(
-                    #     f"Created bundle for {self.key} with SHA: {self._bundle_sha}"
-                    # )
+                    logger.debug(
+                        f"Created bundle for {self.key} with SHA: {self._bundle_sha}"
+                    )
                 except OSError as e:
                     # Can't create bundle - no source and no raw code
                     raise OSError(f"Cannot create bundle for {self.key}: {e}")
@@ -104,21 +104,20 @@ class AsyncVerifierFunction:
 
         # If bundle_data is empty, we're using server-side bundle
         if not bundle_data:
-            # logger.debug(f"Using server-side bundle {bundle_sha[:8]}...")
+            logger.debug(f"Using server-side bundle {bundle_sha[:8]}...")
             return bundle_sha, False  # No upload needed, server has it
 
         # Always check if bundle exists on server
         try:
             exists = await env.check_bundle_exists(bundle_sha)
             if exists.success:
-                # logger.info(f"Bundle {bundle_sha[:8]}... found on server")
+                logger.info(f"Bundle {bundle_sha[:8]}... found on server")
                 return bundle_sha, False  # Found on server, no upload needed
         except Exception as e:
-            # logger.warning(f"Failed to check bundle existence: {e}")
-            pass
+            logger.warning(f"Failed to check bundle existence: {e}")
 
         # Bundle not found on server - upload needed
-        # logger.info(f"Bundle {bundle_sha[:8]}... needs to be uploaded")
+        logger.info(f"Bundle {bundle_sha[:8]}... needs to be uploaded")
         return bundle_sha, True  # Upload needed
 
     async def __call__(self, env: AsyncEnv, *args, **kwargs) -> float:
@@ -148,7 +147,7 @@ class AsyncVerifierFunction:
                     )
 
         except Exception as e:
-            # logger.error(f"Error in verifier {self.key}: {e}")
+            logger.error(f"Error in verifier {self.key}: {e}")
             # Return error score 0
             return 0.0
 
@@ -180,7 +179,7 @@ class AsyncVerifierFunction:
                 try:
                     return float(result)
                 except (ValueError, TypeError):
-                    # logger.warning(f"Could not convert result to float: {result}")
+                    logger.warning(f"Could not convert result to float: {result}")
                     return 0.0
 
     def _raise_remote_error(self, error_info: Dict[str, Any]):
@@ -239,7 +238,7 @@ Remote traceback:
 
             if needs_upload:
                 # Need to upload bundle to S3
-                # logger.info(f"Uploading bundle {bundle_sha[:8]}... for {self.key}")
+                logger.info(f"Uploading bundle {bundle_sha[:8]}... for {self.key}")
                 bundle_data, _ = self._get_or_create_bundle()
 
                 response = await env.execute_verifier_remote(
@@ -253,11 +252,11 @@ Remote traceback:
                     needs_upload=True,
                 )
 
-                # logger.debug(f"Bundle {bundle_sha[:8]}... uploaded successfully")
+                logger.debug(f"Bundle {bundle_sha[:8]}... uploaded successfully")
 
             else:
                 # Bundle already available - execute without upload
-                # logger.info(f"Bundle {bundle_sha[:8]}... already cached for {self.key}")
+                logger.info(f"Bundle {bundle_sha[:8]}... already cached for {self.key}")
                 response = await env.execute_verifier_remote(
                     bundle_data=b"",  # Empty bundle since it's cached
                     bundle_sha=bundle_sha,
@@ -274,9 +273,9 @@ Remote traceback:
         except Exception as e:
             # Check if error indicates bundle not found and retry with upload
             if self._is_bundle_not_found_error(e) and not needs_upload:
-                # logger.info(
-                #     f"Bundle {bundle_sha[:8]}... not found on server, uploading..."
-                # )
+                logger.info(
+                    f"Bundle {bundle_sha[:8]}... not found on server, uploading..."
+                )
                 bundle_data, _ = self._get_or_create_bundle()
                 response = await env.execute_verifier_remote(
                     bundle_data=bundle_data,
@@ -290,7 +289,7 @@ Remote traceback:
                 )
                 return response
             else:
-                # logger.error(f"Error in remote execution of {self.key}: {e}")
+                logger.error(f"Error in remote execution of {self.key}: {e}")
                 raise
 
 

fleet/base.py

@@ -48,7 +48,7 @@ class BaseWrapper:
         import logging
 
         logger = logging.getLogger(__name__)
-        # logger.debug(f"Headers being sent: {headers}")
+        logger.debug(f"Headers being sent: {headers}")
         return headers
 
 
@@ -93,9 +93,8 @@ class SyncWrapper(BaseWrapper):
 
         # Debug log 500 errors
         if status_code == 500:
-            # logger.error(f"Got 500 error from {response.url}")
-            # logger.error(f"Response text: {response.text}")
-            pass
+            logger.error(f"Got 500 error from {response.url}")
+            logger.error(f"Response text: {response.text}")
 
         # Try to parse error response as JSON
         try:

fleet/client.py

@@ -21,7 +21,8 @@ import httpx
 import json
 import logging
 import os
-from typing import List, Optional, Dict, Any, TYPE_CHECKING
+from typing import List, Optional, Dict, Any, TYPE_CHECKING, Union
+from urllib.parse import urlparse
 
 from .base import EnvironmentBase, SyncWrapper
 from .models import (
@@ -47,6 +48,11 @@ from .instance import (
     ResetResponse,
     ExecuteFunctionResponse,
 )
+from .instance.models import (
+    Resource as ResourceModel,
+    ResourceType,
+    ResourceMode,
+)
 from .config import (
     DEFAULT_MAX_RETRIES,
     DEFAULT_TIMEOUT,
@@ -69,6 +75,14 @@ class SyncEnv(EnvironmentBase):
         self._client = client
         self._apps: Dict[str, InstanceClient] = {}
         self._instance: Optional[InstanceClient] = None
+        self._manager_url_override: Optional[str] = None  # For URL mode
+
+    @property
+    def manager_url(self) -> str:
+        """Override to support URL mode where urls is None."""
+        if self._manager_url_override is not None:
+            return self._manager_url_override
+        return super().manager_url
 
     @property
     def instance(self) -> InstanceClient:
@@ -80,17 +94,17 @@ class SyncEnv(EnvironmentBase):
 
     def app(self, name: str) -> InstanceClient:
         if name not in self._apps:
-            # Extract base URL by removing the current app path (e.g., /sentry/api/v1/env)
-            # manager_url looks like: https://xxx.fleetai.com/sentry/api/v1/env
-            base_url = self.manager_url.split("/api/v1/env")[0]
-            # Remove the current app name (e.g., /sentry) to get the root
-            if "/" in base_url:
-                parts = base_url.rsplit("/", 1)
-                if len(parts) == 2 and parts[0] != "https:/":
-                    base_url = parts[0]
+            # Extract scheme://netloc from manager_url, then construct /{name}/api/v1/env
+            # Supports all URL formats:
+            #   https://host/api/v1/env -> https://host/{name}/api/v1/env
+            #   https://host/sentry/api/v1/env -> https://host/{name}/api/v1/env
+            #   http://localhost:8080/api/v1/env -> http://localhost:8080/{name}/api/v1/env
+            parsed = urlparse(self.manager_url)
+            root = f"{parsed.scheme}://{parsed.netloc}"
+            new_url = f"{root}/{name}/api/v1/env"
 
             self._apps[name] = InstanceClient(
-                f"{base_url}/{name}/api/v1/env",
+                new_url,
                 self._client.httpx_client if self._client else None,
             )
         return self._apps[name]
@@ -287,11 +301,165 @@ class Fleet:
             for instance_data in response.json()
         ]
 
-    def instance(self, instance_id: str) -> SyncEnv:
-        response = self.client.request("GET", f"/v1/env/instances/{instance_id}")
-        instance = SyncEnv(client=self.client, **response.json())
-        instance.instance.load()
-        return instance
+    def instance(self, instance_id: Union[str, Dict[str, str]]) -> SyncEnv:
+        """Create or connect to an environment instance.
+
+        Supports three modes based on input type:
+        1. dict: Local filesystem mode - {"current": "./data.db", "seed": "./seed.db"}
+        2. str starting with http:// or https://: Localhost/URL mode
+        3. str (other): Remote cloud instance mode
+
+        Args:
+            instance_id: Instance identifier (str), URL (str starting with http://),
+                        or local db mapping (dict)
+
+        Returns:
+            SyncEnv: Environment instance
+        """
+        # Local filesystem mode - dict of resource names to file paths
+        if isinstance(instance_id, dict):
+            return self._create_local_instance(instance_id)
+
+        # Localhost/direct URL mode - string starting with http:// or https://
+        elif isinstance(instance_id, str) and instance_id.startswith(("http://", "https://")):
+            return self._create_url_instance(instance_id)
+
+        # Remote mode - existing behavior
+        else:
+            response = self.client.request("GET", f"/v1/env/instances/{instance_id}")
+            instance = SyncEnv(client=self.client, **response.json())
+            instance.instance.load()
+            return instance
+
+    def _create_url_instance(self, base_url: str) -> SyncEnv:
+        """Create instance connected to a direct URL (localhost or custom).
+
+        Args:
+            base_url: URL of the instance manager API
+
+        Returns:
+            SyncEnv: Environment instance configured for URL mode
+        """
+        instance_client = InstanceClient(url=base_url, httpx_client=self._httpx_client)
+
+        # Create a minimal environment for URL mode
+        env = SyncEnv(
+            client=self.client,
+            instance_id=base_url,
+            env_key="localhost",
+            version="",
+            status="running",
+            subdomain="localhost",
+            created_at="",
+            updated_at="",
+            terminated_at=None,
+            team_id="",
+            region="localhost",
+            env_variables=None,
+            data_key=None,
+            data_version=None,
+            urls=None,
+            health=None,
+        )
+        env._instance = instance_client
+        env._manager_url_override = base_url  # Set manager_url for URL mode
+        return env
+
+    @staticmethod
+    def _normalize_db_path(path: str) -> tuple[str, bool]:
+        """Normalize database path and detect if it's in-memory.
+
+        Args:
+            path: Database path - can be:
+                  - File path: "./data.db"
+                  - Plain memory: ":memory:"
+                  - Named memory: ":memory:namespace"
+                  - URI: "file:name?mode=memory&cache=shared"
+
+        Returns:
+            Tuple of (normalized_path, is_memory)
+        """
+        import uuid
+        import sqlite3
+
+        if path == ":memory:":
+            # Plain :memory: - create unique namespace
+            name = f"mem_{uuid.uuid4().hex[:8]}"
+            return f"file:{name}?mode=memory&cache=shared", True
+        elif path.startswith(":memory:"):
+            # Named memory: :memory:current -> file:current?mode=memory&cache=shared
+            namespace = path[8:]  # Remove ":memory:" prefix
+            return f"file:{namespace}?mode=memory&cache=shared", True
+        elif "mode=memory" in path:
+            # Already a proper memory URI
+            return path, True
+        else:
+            # Regular file path
+            return path, False
+
+    def _create_local_instance(self, dbs: Dict[str, str]) -> SyncEnv:
+        """Create instance with local file-based or in-memory SQLite resources.
+
+        Args:
+            dbs: Map of resource names to paths (e.g., {"current": "./data.db"} or
+                 {"current": ":memory:current"})
+
+        Returns:
+            SyncEnv: Environment instance configured for local mode
+        """
+        import sqlite3
+
+        instance_client = InstanceClient(url="local://", httpx_client=None)
+        instance_client._resources = []  # Mark as loaded
+        instance_client._memory_anchors = {}  # Store anchor connections for in-memory DBs
+
+        # Store creation parameters for local SQLiteResources
+        # This allows db() to create new instances each time (matching HTTP mode behavior)
+        for name, path in dbs.items():
+            # Normalize path and detect if it's in-memory
+            normalized_path, is_memory = self._normalize_db_path(path)
+
+            # Create anchor connection for in-memory databases
+            # This keeps the database alive as long as the env exists
+            if is_memory:
+                anchor_conn = sqlite3.connect(normalized_path, uri=True)
+                instance_client._memory_anchors[name] = anchor_conn
+
+            resource_model = ResourceModel(
+                name=name,
+                type=ResourceType.db,
+                mode=ResourceMode.rw,
+                label=f"Local: {path}",
+            )
+            instance_client._resources_state[ResourceType.db.value][name] = {
+                'type': 'local',
+                'resource_model': resource_model,
+                'db_path': normalized_path,
+                'is_memory': is_memory
+            }
+
+        # Create a minimal environment for local mode
+        env = SyncEnv(
+            client=self.client,
+            instance_id="local",
+            env_key="local",
+            version="",
+            status="running",
+            subdomain="local",
+            created_at="",
+            updated_at="",
+            terminated_at=None,
+            team_id="",
+            region="local",
+            env_variables=None,
+            data_key=None,
+            data_version=None,
+            urls=None,
+            health=None,
+        )
+        env._instance = instance_client
+        env._manager_url_override = "local://"  # Set manager_url for local mode
+        return env
 
     def check_bundle_exists(self, bundle_hash: str) -> VerifiersCheckResponse:
         return _check_bundle_exists(self.client, bundle_hash)
@@ -404,8 +572,8 @@ class Fleet:
             error_msg = f"Failed to create verifier {task_json.get('key', task_json.get('id'))}: {e}"
             if raise_on_verifier_error:
                 raise ValueError(error_msg) from e
-            # else:
-            #     logger.warning(error_msg)
+            else:
+                logger.warning(error_msg)
 
         task = Task(
             key=task_json.get("key", task_json.get("id")),
@@ -495,23 +663,23 @@ class Fleet:
                                 verifier_sha=tr.verifier.sha256,
                             )
                         except Exception as e:
-                            # logger.warning(
-                            #     f"Failed to create verifier {tr.verifier.key}: {e}"
-                            # )
+                            logger.warning(
+                                f"Failed to create verifier {tr.verifier.key}: {e}"
+                            )
                             return None
                     else:
                         # Fallback: try fetching by ID
                         try:
-                            # logger.warning(
-                            #     f"Embedded verifier code missing for {tr.verifier.key} (NoSuchKey). "
-                            #     f"Attempting to refetch by id {tr.verifier.verifier_id}"
-                            # )
+                            logger.warning(
+                                f"Embedded verifier code missing for {tr.verifier.key} (NoSuchKey). "
+                                f"Attempting to refetch by id {tr.verifier.verifier_id}"
+                            )
                             return self._load_verifier(tr.verifier.verifier_id)
                         except Exception as e:
-                            # logger.warning(
-                            #     f"Refetch by verifier id failed for {tr.verifier.key}: {e}. "
-                            #     "Leaving verifier unset."
-                            # )
+                            logger.warning(
+                                f"Refetch by verifier id failed for {tr.verifier.key}: {e}. "
+                                "Leaving verifier unset."
+                            )
                             return None
 
                 # Add the task for parallel execution
@@ -551,7 +719,7 @@ class Fleet:
                             result = future.result()
                             verifier_results.append(result)
                         except Exception as e:
-                            # logger.warning(f"Verifier loading failed: {e}")
+                            logger.warning(f"Verifier loading failed: {e}")
                             verifier_results.append(None)
 
         # Build tasks with results
@@ -638,10 +806,10 @@ class Fleet:
             with open(filename, "w", encoding="utf-8") as f:
                 json.dump(tasks_data, f, indent=2, default=str)
 
-            # logger.info(f"Exported {len(tasks)} tasks to {filename}")
+            logger.info(f"Exported {len(tasks)} tasks to {filename}")
             return filename
         else:
-            # logger.info("No tasks found to export")
+            logger.info("No tasks found to export")
             return None
 
     def import_single_task(self, task: Task, project_key: Optional[str] = None):
@@ -670,7 +838,7 @@ class Fleet:
             )
             return response
         except Exception as e:
-            # logger.error(f"Failed to import task {task.key}: {e}")
+            logger.error(f"Failed to import task {task.key}: {e}")
             return None
 
     def import_tasks(self, filename: str, project_key: Optional[str] = None):
@@ -883,17 +1051,17 @@ def _execute_verifier_remote(
         request_data["bundle"] = bundle_b64
 
     # Debug logging
-    # logger.debug(
-    #     f"Sending verifier execute request: key={key}, sha256={bundle_sha[:8]}..., function_name={function_name}"
-    # )
-    # logger.debug(f"Request has bundle: {needs_upload}")
-    # logger.debug(f"Using client with base_url: {client.base_url}")
-    # logger.debug(f"Request data keys: {list(request_data.keys())}")
-    # logger.debug(
-    #     f"Bundle size: {len(request_data.get('bundle', ''))} chars"
-    #     if "bundle" in request_data
-    #     else "No bundle"
-    # )
+    logger.debug(
+        f"Sending verifier execute request: key={key}, sha256={bundle_sha[:8]}..., function_name={function_name}"
+    )
+    logger.debug(f"Request has bundle: {needs_upload}")
+    logger.debug(f"Using client with base_url: {client.base_url}")
+    logger.debug(f"Request data keys: {list(request_data.keys())}")
+    logger.debug(
+        f"Bundle size: {len(request_data.get('bundle', ''))} chars"
+        if "bundle" in request_data
+        else "No bundle"
+    )
 
     # Note: This should be called on the instance URL, not the orchestrator
     # The instance has manager URLs for verifier execution
@@ -901,6 +1069,6 @@ def _execute_verifier_remote(
 
     # Debug the response
     response_json = response.json()
-    # logger.debug(f"Verifier execute response: {response_json}")
+    logger.debug(f"Verifier execute response: {response_json}")
 
     return VerifiersExecuteResponse(**response_json)

fleet/instance/client.py

@@ -83,9 +83,17 @@ class InstanceClient:
         Returns:
             An SQLite database resource for the given database name
         """
-        return SQLiteResource(
-            self._resources_state[ResourceType.db.value][name], self.client
-        )
+        resource_info = self._resources_state[ResourceType.db.value][name]
+        # Local mode - resource_info is a dict with creation parameters
+        if isinstance(resource_info, dict) and resource_info.get('type') == 'local':
+            # Create new instance each time (matching HTTP mode behavior)
+            return SQLiteResource(
+                resource_info['resource_model'],
+                client=None,
+                db_path=resource_info['db_path']
+            )
+        # HTTP mode - resource_info is a ResourceModel, create new wrapper
+        return SQLiteResource(resource_info, self.client)
 
     def browser(self, name: str) -> BrowserResource:
         return BrowserResource(
@@ -175,10 +183,17 @@ class InstanceClient:
         response = self.client.request("GET", "/health")
         return HealthResponse(**response.json())
 
+    def close(self):
+        """Close anchor connections for in-memory databases."""
+        if hasattr(self, '_memory_anchors'):
+            for conn in self._memory_anchors.values():
+                conn.close()
+            self._memory_anchors.clear()
+
     def __enter__(self):
-        """Async context manager entry."""
+        """Context manager entry."""
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        """Async context manager exit."""
+        """Context manager exit."""
         self.close()