diff --git a/docker-compose/README.md b/docker-compose/README.md
index 7ef5bf440..74b9b9f81 100644
--- a/docker-compose/README.md
+++ b/docker-compose/README.md
@@ -45,7 +45,7 @@ This directory contains a Docker Compose setup for running Hypha Server with Min
 
 The Hypha Server provides the backend API for the Hypha application.
 
-- Image: `ghcr.io/amun-ai/hypha:0.20.51`
+- Image: `ghcr.io/amun-ai/hypha:0.20.54`
 - Port: 9520
 - Data: Stored in the local directory `./data/hypha`
 
diff --git a/docker-compose/docker-compose.yml b/docker-compose/docker-compose.yml
index 193fd09bd..65aded35e 100644
--- a/docker-compose/docker-compose.yml
+++ b/docker-compose/docker-compose.yml
@@ -2,7 +2,7 @@ version: '3.8'
 
 services:
   hypha-server:
-    image: ghcr.io/amun-ai/hypha:0.20.51
+    image: ghcr.io/amun-ai/hypha:0.20.54
     ports:
       - "${HYPHA_PORT:-9527}:9527"
     environment:
diff --git a/docs/_sidebar.md b/docs/_sidebar.md
index e5d84e0d4..8d4db3e42 100644
--- a/docs/_sidebar.md
+++ b/docs/_sidebar.md
@@ -3,6 +3,7 @@
  * [Hypha RPC](/hypha-rpc)
  * [Migration Guide](/migration-guide)
  * [Service Type Annotation](/service-type-annotation)
+ * [Service Load Balancing](/service-load-balancing)
  * [Serverless Functions](/serverless-functions)
  * [Serve ASGI Web Apps](/asgi-apps)
  * [Launch Service](/launch-service)
diff --git a/docs/artifact-manager.md b/docs/artifact-manager.md
index 0caba2e84..c6e4d87a2 100644
--- a/docs/artifact-manager.md
+++ b/docs/artifact-manager.md
@@ -689,7 +689,7 @@ manifest = await artifact_manager.read(artifact_id="other_workspace/example-data
 
 ---
 
-### `list(artifact_id: str=None, keywords: List[str] = None, filters: dict = None, mode: str = "AND", offset: int = 0, limit: int = 100, order_by: str = None, silent: bool = False, stage: bool = False) -> list`
+### `list(parent_id: str=None, keywords: List[str] = None, filters: dict = None, mode: str = "AND", offset: int = 0, limit: int = 100, order_by: str = None, silent: bool = False, stage: bool = False) -> list`
 
 Retrieve a list of child artifacts within a specified collection, supporting keyword-based fuzzy search, field-specific filters, and flexible ordering. This function allows detailed control over the search and pagination of artifacts in a collection, including staged artifacts if specified.
 
diff --git a/docs/getting-started.md b/docs/getting-started.md
index 442e8a889..3662f8d4f 100644
--- a/docs/getting-started.md
+++ b/docs/getting-started.md
@@ -183,10 +183,10 @@ pip install hypha-rpc
 
 The following code registers a service called "Hello World" with the ID "hello-world" and a function called `hello()`. The function takes a single argument, `name`, and prints "Hello" followed by the name. The function also returns a string containing "Hello" followed by the name.
 
-We provide two versions of the code: an asynchronous version for native CPython or Pyodide-based Python in the browser (without thread support), and a synchronous version for native Python with thread support (more details about the [synchronous wrapper](/hypha-rpc?id=synchronous-wrapper)):
+We provide three versions of the code: an asynchronous version for native CPython or Pyodide-based Python in the browser (without thread support), a synchronous version for native Python with thread support (more details about the [synchronous wrapper](/hypha-rpc?id=synchronous-wrapper)), and a JavaScript version for web browsers:
 
 <!-- tabs:start -->
-#### ** Asynchronous Worker **
+#### ** Asynchronous Server **
 
 ```python
 import asyncio
@@ -212,7 +212,7 @@ async def start_server(server_url):
 
     print(f'You can use this service using the service id: {svc.id}')
 
-    print(f"You can also test the service via the HTTP proxy: {server_url}/{server.config.workspace}/services/{svc.id}/hello?name=John")
+    print(f"You can also test the service via the HTTP proxy: {server_url}/{server.config.workspace}/services/{svc.id.split('/')[1]}/hello?name=John")
 
     # Keep the server running
     await server.serve()
@@ -222,7 +222,7 @@ if __name__ == "__main__":
     asyncio.run(start_server(server_url))
 ```
 
-#### ** Synchronous Worker **
+#### ** Synchronous Server **
 
 ```python
 from hypha_rpc.sync import connect_to_server
@@ -247,15 +247,77 @@ def start_server(server_url):
 
     print(f'You can use this service using the service id: {svc.id}')
 
-    print(f"You can also test the service via the HTTP proxy: {server_url}/{server.config.workspace}/services/{svc.id}/hello?name=John")
+    print(f"You can also test the service via the HTTP proxy: {server_url}/{server.config.workspace}/services/{svc.id.split('/')[1]}/hello?name=John")
 
 if __name__ == "__main__":
     server_url = "http://localhost:9527"
     start_server(server_url)
 ```
+
+#### ** JavaScript Server **
+
+First, install the `hypha-rpc` library:
+
+```bash
+npm install hypha-rpc
+```
+
+Or include it via CDN in your HTML file:
+
+```html
+<script src="https://cdn.jsdelivr.net/npm/hypha-rpc@0.20.54/dist/hypha-rpc-websocket.min.js"></script>
+```
+
+Then use the following JavaScript code to register a service:
+
+```javascript
+const serverUrl = "https://hypha.aicell.io"
+
+const loginCallback = (context) => {
+  window.open(context.login_url);
+};
+
+async function startServer(serverUrl) {
+  // Log in and connect to the Hypha server
+  const token = await hyphaWebsocketClient.login({
+    server_url: serverUrl,
+    login_callback: loginCallback,
+  });
+
+  const server = await hyphaWebsocketClient.connectToServer({
+    server_url: serverUrl,
+    token: token,
+  });
+
+  // Define a service method
+  function hello(name, context) {
+    console.log("Hello " + name);
+    return "Hello " + name;
+  }
+
+  // Register the service with the server
+  const myService = await server.registerService({
+    id: "hello-world",
+    name: "Hello World",
+    description: "A simple hello world service",
+    config: {
+      visibility: "public",
+      require_context: true,
+    },
+    hello: hello, // or just `hello,` in modern JS
+  });
+
+  console.log(`Hello world service registered at workspace: ${server.config.workspace}, id: ${myService.id}`);
+  console.log(`You can use this service using the service id: ${myService.id}`);
+  console.log(`You can also test the service via the HTTP proxy: ${serverUrl}/${server.config.workspace}/services/${myService.id.split('/')[1]}/hello?name=John`);
+}
+
+// Start the server
+startServer(serverUrl);
+```
 <!-- tabs:end -->
 
-Run the server via `python hello-world-worker.py` and keep it running. You can now access the service from a client script. You will see the service ID printed in the console, which you can use to access the service.
+Run the server script and keep it running. You can now access the service from a client script. You will see the service ID printed in the console, which you can use to access the service.
 
 Tips: You don't need to run the client script on the same server. If you want to connect to the server from another computer, make sure to change the `server_url` to an URL with the external IP or domain name of the server.
 
@@ -334,7 +396,7 @@ svc = await get_remote_service("http://localhost:9527/ws-user-scintillating-lawy
 Include the following script in your HTML file to load the `hypha-rpc` client:
 
 ```html
-<script src="https://cdn.jsdelivr.net/npm/hypha-rpc@0.20.51/dist/hypha-rpc-websocket.min.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/hypha-rpc@0.20.54/dist/hypha-rpc-websocket.min.js"></script>
 ```
 
 Use the following code in JavaScript to connect to the server and access an existing service:
@@ -343,7 +405,7 @@ Use the following code in JavaScript to connect to the server and access an exis
 async function main(){
     const server = await hyphaWebsocketClient.connectToServer({"server_url": "http://localhost:9527"})
     // NOTE: You need to replace the service id with the actual id you obtained when registering the service
-    const svc = await server.get_service("ws-user-scintillating-lawyer-94336986/YLNzuQvQHVqMAyDzmEpFgF:hello-world")
+    const svc = await server.getService("ws-user-scintillating-lawyer-94336986/YLNzuQvQHVqMAyDzmEpFgF:hello-world")
     const ret = await svc.hello("John")
     console.log(ret)
 }
diff --git a/docs/migration-guide.md b/docs/migration-guide.md
index 160648f11..36a7c1766 100644
--- a/docs/migration-guide.md
+++ b/docs/migration-guide.md
@@ -15,7 +15,7 @@ To connect to the server, instead of installing the `imjoy-rpc` module, you will
 pip install -U hypha-rpc # new install
 ```
 
-We also changed our versioning strategy, we use the same version number for the server and client, so it's easier to match the client and server versions. For example, `hypha-rpc` version `0.20.51` is compatible with Hypha server version `0.20.51`.
+We also changed our versioning strategy, we use the same version number for the server and client, so it's easier to match the client and server versions. For example, `hypha-rpc` version `0.20.54` is compatible with Hypha server version `0.20.54`.
 
 #### 2. Change the imports to use `hypha-rpc`
 
@@ -128,10 +128,10 @@ loop.run_forever()
 To connect to the server, instead of using the `imjoy-rpc` module, you will need to use the `hypha-rpc` module. The `hypha-rpc` module is a standalone module that provides the RPC connection to the Hypha server. You can include it in your HTML using a script tag:
 
 ```html
-<script src="https://cdn.jsdelivr.net/npm/hypha-rpc@0.20.51/dist/hypha-rpc-websocket.min.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/hypha-rpc@0.20.54/dist/hypha-rpc-websocket.min.js"></script>
 ```
 
-We also changed our versioning strategy, we use the same version number for the server and client, so it's easier to match the client and server versions. For example, `hypha-rpc` version `0.20.51` is compatible with Hypha server version `0.20.51`.
+We also changed our versioning strategy, we use the same version number for the server and client, so it's easier to match the client and server versions. For example, `hypha-rpc` version `0.20.54` is compatible with Hypha server version `0.20.54`.
 
 #### 2. Change the connection method and use camelCase for service function names
 
@@ -149,7 +149,7 @@ Here is a suggested list of search and replace operations to update your code:
 Here is an example of how the updated code might look:
 
 ```html
-<script src="https://cdn.jsdelivr.net/npm/hypha-rpc@0.20.51/dist/hypha-rpc-websocket.min.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/hypha-rpc@0.20.54/dist/hypha-rpc-websocket.min.js"></script>
 <script>
 async function main(){
     const server = await hyphaWebsocketClient.connectToServer({"server_url": "https://hypha.amun.ai"});
@@ -197,7 +197,7 @@ We created a tutorial to introduce this new feature: [service type annotation](.
 Here is a quick example in JavaScript:
 
 ```html
-<script src="https://cdn.jsdelivr.net/npm/hypha-rpc@0.20.51/dist/hypha-rpc-websocket.min.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/hypha-rpc@0.20.54/dist/hypha-rpc-websocket.min.js"></script>
 
 <script>
 async function main(){
diff --git a/docs/quick-guide.md b/docs/quick-guide.md
index a89199065..c525a0c0b 100644
--- a/docs/quick-guide.md
+++ b/docs/quick-guide.md
@@ -48,7 +48,7 @@ if __name__ == "__main__":
 ### JavaScript
 
 ```html
-<script src="https://cdn.jsdelivr.net/npm/hypha-rpc@0.20.51/dist/hypha-rpc-websocket.min.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/hypha-rpc@0.20.54/dist/hypha-rpc-websocket.min.js"></script>
 <script>
 async function registerService() {
     const server = await hyphaWebsocketClient.connectToServer({
@@ -106,7 +106,7 @@ if __name__ == "__main__":
 ### JavaScript Client
 
 ```html
-<script src="https://cdn.jsdelivr.net/npm/hypha-rpc@0.20.51/dist/hypha-rpc-websocket.min.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/hypha-rpc@0.20.54/dist/hypha-rpc-websocket.min.js"></script>
 <script>
 async function useService() {
     const server = await hyphaWebsocketClient.connectToServer({
diff --git a/docs/service-load-balancing.md b/docs/service-load-balancing.md
new file mode 100644
index 000000000..99cd309cb
--- /dev/null
+++ b/docs/service-load-balancing.md
@@ -0,0 +1,149 @@
+# Service Load Balancing
+
+## Overview
+
+Load balancing distributes workload across multiple service instances for better performance and availability. In Hypha, services expose numeric metrics through simple functions, and clients use the `select:criteria:function` syntax to route requests to the optimal instance.
+
+**Key Requirements:**
+
+- Service functions must return `int` or `float` values directly
+- Multiple instances of the same service must be registered
+- Client specifies selection criteria when getting the service
+
+## Syntax
+
+```python
+service = await client.get_service(
+    "service-name",
+    mode="select:criteria:function_name"
+)
+```
+
+Where:
+
+- **criteria**: `min`, `max`, or `first_success`
+- **function_name**: Service function that returns `int` or `float`
+
+## Selection Criteria
+
+### `min` - Select Minimum Value
+
+```python
+mode="select:min:get_load"        # Lowest load
+mode="select:min:get_response_time"  # Fastest response
+```
+
+### `max` - Select Maximum Value
+
+```python
+mode="select:max:get_priority"    # Highest priority
+mode="select:max:get_capacity"    # Most capacity
+```
+
+### `first_success` - First Responding Service
+
+```python
+mode="select:first_success:get_health"  # First available
+```
+
+## Service Implementation
+
+Services must expose functions that return numeric values:
+
+```python
+class MyService:
+    def __init__(self, instance_id):
+        self.instance_id = instance_id
+        self.current_load = 0.0
+    
+    async def get_load(self):
+        """Return load as float (0.0 to 1.0)."""
+        return self.current_load
+    
+    async def get_queue_length(self):
+        """Return queue length as int."""
+        return 5
+    
+    async def get_priority(self):
+        """Return priority score as int."""
+        return 10
+    
+    async def process_task(self, data):
+        """Main service functionality."""
+        return f"Processed by {self.instance_id}"
+
+# Register the service
+await api.register_service({
+    "id": "my-service",
+    "get_load": service.get_load,
+    "get_queue_length": service.get_queue_length, 
+    "get_priority": service.get_priority,
+    "process_task": service.process_task
+})
+```
+
+## Complete Example
+
+```python
+import asyncio
+from hypha_rpc import connect_to_server
+
+class TaskProcessor:
+    def __init__(self, name, base_load):
+        self.name = name
+        self.load = base_load
+    
+    async def get_load(self):
+        return self.load  # Must return float/int
+    
+    async def process(self, task):
+        return f"Task '{task}' processed by {self.name}"
+
+async def main():
+    # Start three service instances
+    instances = [
+        TaskProcessor("fast", 0.2),
+        TaskProcessor("medium", 0.5),
+        TaskProcessor("slow", 0.8)
+    ]
+    
+    # Register services (simplified registration)
+    for i, instance in enumerate(instances):
+        async with connect_to_server({"name": f"worker-{i}"}) as api:
+            await api.register_service({
+                "id": "task-processor",
+                "get_load": instance.get_load,
+                "process": instance.process
+            })
+    
+    # Use load balancing
+    async with connect_to_server({"name": "client"}) as client:
+        # Always select least loaded instance
+        service = await client.get_service(
+            "task-processor",
+            mode="select:min:get_load"
+        )
+        
+        result = await service.process("important-task")
+        print(result)  # Will use "fast" instance (load=0.2)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Configuration
+
+```python
+config = {
+    "mode": "select:min:get_load",
+    "select_timeout": 2.0  # Function call timeout (default: 2.0s)
+}
+```
+
+## Error Handling
+
+- Services without the specified function are skipped
+- If no services respond, random selection is used as fallback
+- Individual failures don't affect overall selection
+
+This approach provides simple, efficient load balancing without complex routing logic. 
diff --git a/docs/service-type-annotation.md b/docs/service-type-annotation.md
index 75c22e4e4..501227770 100644
--- a/docs/service-type-annotation.md
+++ b/docs/service-type-annotation.md
@@ -134,7 +134,7 @@ if __name__ == "__main__":
 **JavaScript Client: Service Usage**
 
 ```html
-<script src="https://cdn.jsdelivr.net/npm/hypha-rpc@0.20.51/dist/hypha-rpc-websocket.min.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/hypha-rpc@0.20.54/dist/hypha-rpc-websocket.min.js"></script>
 <script>
 async function main() {
     const server = await hyphaWebsocketClient.connectToServer({"server_url": "https://hypha.amun.ai"});
diff --git a/helm-charts/aks-hypha.md b/helm-charts/aks-hypha.md
index bf6d08dac..45142a83b 100644
--- a/helm-charts/aks-hypha.md
+++ b/helm-charts/aks-hypha.md
@@ -146,7 +146,7 @@ replicaCount: 1
 image:
   repository: ghcr.io/amun-ai/hypha
   pullPolicy: IfNotPresent
-  tag: "0.20.51"
+  tag: "0.20.54"
 
 serviceAccount:
   create: true
diff --git a/helm-charts/hypha-server/Chart.yaml b/helm-charts/hypha-server/Chart.yaml
index 39cc8af3c..e570a35bd 100644
--- a/helm-charts/hypha-server/Chart.yaml
+++ b/helm-charts/hypha-server/Chart.yaml
@@ -15,7 +15,7 @@ type: application
 # This is the chart version. This version number should be incremented each time you make changes
 # to the chart and its templates, including the app version.
 # Versions are expected to follow Semantic Versioning (https://semver.org/)
-version: 0.20.51
+version: 0.20.54
 
 # This is the version number of the application being deployed. This version number should be
 # incremented each time you make changes to the application. Versions are not expected to
diff --git a/helm-charts/hypha-server/values.yaml b/helm-charts/hypha-server/values.yaml
index 09346706d..971aeca6b 100644
--- a/helm-charts/hypha-server/values.yaml
+++ b/helm-charts/hypha-server/values.yaml
@@ -8,7 +8,7 @@ image:
   repository: ghcr.io/amun-ai/hypha
   pullPolicy: IfNotPresent
   # Overrides the image tag whose default is the chart appVersion.
-  tag: "0.20.51"
+  tag: "0.20.54"
 
 imagePullSecrets: []
 nameOverride: ""
diff --git a/hypha/VERSION b/hypha/VERSION
index 003d4f260..761f317cf 100644
--- a/hypha/VERSION
+++ b/hypha/VERSION
@@ -1,3 +1,3 @@
 {
-    "version": "0.20.52"
+    "version": "0.20.54.post8"
 }
diff --git a/hypha/artifact.py b/hypha/artifact.py
index 6212b8b34..26d7a1c7f 100644
--- a/hypha/artifact.py
+++ b/hypha/artifact.py
@@ -238,7 +238,7 @@ async def list_children(
             order_by: str = None,
             pagination: bool = False,
             silent: bool = False,
-            stage: str = 'false',
+            stage: str = "false",
             no_cache: bool = False,
             user_info: self.store.login_optional = Depends(self.store.login_optional),
         ):
@@ -255,23 +255,25 @@ async def list_children(
                     keywords = keywords.split(",")
                 if filters:
                     filters = json.loads(filters)
-                
+
                 # Convert stage parameter:
                 # 'true' -> True (only staged artifacts)
                 # 'false' -> False (only committed artifacts)
                 # 'all' -> 'all' (both staged and committed artifacts)
-                if stage == 'true':
+                if stage == "true":
                     stage_param = True
-                elif stage == 'false':
+                elif stage == "false":
                     stage_param = False
-                elif stage == 'all':
-                    stage_param = 'all'
+                elif stage == "all":
+                    stage_param = "all"
                 else:
                     # Default to committed artifacts for any invalid value
                     stage_param = False
-                
-                logger.info(f"HTTP list_children endpoint: stage={stage}, converted to stage_param={stage_param}")
-                    
+
+                logger.info(
+                    f"HTTP list_children endpoint: stage={stage}, converted to stage_param={stage_param}"
+                )
+
                 results = await self.list_children(
                     parent_id=parent_id,
                     offset=offset,
@@ -608,7 +610,7 @@ async def get_zip_file_content(
                             s3_key,
                             path=path,
                             zip_tail=zip_tail,
-                            cache_instance=self._cache
+                            cache_instance=self._cache,
                         )
 
             except KeyError:
@@ -887,7 +889,9 @@ async def _get_artifact_with_parent(self, session, artifact_id):
         except Exception as e:
             raise
 
-    def _generate_artifact_data(self, artifact, parent_artifact=None):
+    def _generate_artifact_data(
+        self, artifact: ArtifactModel, parent_artifact: ArtifactModel = None
+    ):
         artifact_data = model_to_dict(artifact)
         if parent_artifact:
             artifact_data["parent_id"] = (
@@ -985,6 +989,7 @@ def _expand_permission(self, permission):
                     "create",
                     "reset_stats",
                     "publish",
+                    "delete",
                 ],
             }
             return permission_map.get(permission, [])
@@ -1114,16 +1119,47 @@ def _get_zenodo_client(self, artifact, parent_artifact=None, publish_to=None):
 
         return zenodo_client
 
-    def _get_s3_config(self, artifact, parent_artifact):
+    def _get_s3_config(self, artifact=None, parent_artifact=None, workspace=None):
         """
         Get S3 configuration using credentials from the artifact's or parent artifact's secrets.
+        If artifact and parent_artifact are None, returns the default S3 configuration.
+        When both artifact and parent_artifact are None, workspace must be provided.
+
+        Args:
+            artifact: The artifact to get S3 config for
+            parent_artifact: The parent artifact to inherit S3 config from
+            workspace: The workspace to use for default config when artifact is None
+
+        Returns:
+            Dictionary with S3 configuration
         """
+        # If artifact is None, use default config
+        if artifact is None:
+            assert (
+                workspace is not None
+            ), "Workspace must be provided when artifact is None"
+            default_config = {
+                "endpoint_url": self.s3_controller.endpoint_url,
+                "access_key_id": self.s3_controller.access_key_id,
+                "secret_access_key": self.s3_controller.secret_access_key,
+                "region_name": self.s3_controller.region_name,
+                "bucket": self.workspace_bucket,
+                "prefix": safe_join(workspace, self._artifacts_dir),
+                "public_endpoint_url": None,
+            }
+            if self.s3_controller.enable_s3_proxy:
+                default_config["public_endpoint_url"] = (
+                    f"{self.store.public_base_url}/s3"
+                )
+            return default_config
+
         # merge secrets from parent and artifact
         if parent_artifact and parent_artifact.secrets:
             secrets = parent_artifact.secrets.copy()
         else:
             secrets = {}
-        secrets.update(artifact.secrets or {})
+        if artifact.secrets:
+            secrets.update(artifact.secrets)
 
         endpoint_url = secrets.get("S3_ENDPOINT_URL")
         access_key_id = secrets.get("S3_ACCESS_KEY_ID")
@@ -1291,6 +1327,33 @@ async def _save_version_to_s3(self, version_index: int, artifact, s3_config):
                 Body=json.dumps(model_to_dict(artifact)),
             )
 
+        # Check if we're using a custom S3 config (not the default one)
+        # and create a backup in the default S3 bucket
+        is_default_s3 = (
+            s3_config["bucket"] == self.workspace_bucket
+            and s3_config["endpoint_url"] == self.s3_controller.endpoint_url
+            and s3_config["access_key_id"] == self.s3_controller.access_key_id
+        )
+
+        if not is_default_s3:
+            # Get default S3 config using the workspace from the artifact
+            default_s3_config = self._get_s3_config(workspace=artifact.workspace)
+
+            # Save backup to default S3
+            async with self._create_client_async(default_s3_config) as backup_s3_client:
+                backup_version_key = safe_join(
+                    default_s3_config["prefix"],
+                    artifact.id,
+                    f"v{version_index}.json",
+                )
+
+                # Just save the full artifact data as-is
+                await backup_s3_client.put_object(
+                    Bucket=default_s3_config["bucket"],
+                    Key=backup_version_key,
+                    Body=json.dumps(model_to_dict(artifact)),
+                )
+
     async def _load_version_from_s3(
         self,
         artifact,
@@ -1382,8 +1445,8 @@ async def create(
         version: str = None,
         comment: str = None,
         overwrite: bool = False,
-        context: dict = None,
         stage: bool = False,  # Add stage parameter
+        context: dict = None,
     ):
         """Create a new artifact and store its manifest in the database."""
         if context is None or "ws" not in context:
@@ -1666,8 +1729,8 @@ async def edit(
         secrets: dict = None,
         version: str = None,
         comment: str = None,
+        stage: bool = False,
         context: dict = None,
-        stage: bool = False,  # Add stage parameter
     ):
         """Edit the artifact's manifest and save it in the database."""
         if context is None or "ws" not in context:
@@ -1827,6 +1890,9 @@ async def read(
                     artifact_data = await self._load_version_from_s3(
                         artifact, parent_artifact, version_index, s3_config
                     )
+                    artifact_data = self._generate_artifact_data(
+                        ArtifactModel(**artifact_data), parent_artifact
+                    )
 
                 if artifact.type == "collection":
                     # Use with_only_columns to optimize the count query
@@ -2621,7 +2687,7 @@ async def list_children(
     ):
         """
         List artifacts within a collection under a specific artifact_id.
-        
+
         Parameters:
             stage: Controls which artifacts to return based on their staging status
                 - True: Return only staged artifacts
@@ -2629,11 +2695,11 @@ async def list_children(
                 - 'all': Return both staged and committed artifacts
         """
         logger.info(f"list_children implementation: stage parameter value = {stage}")
-        
+
         # Convert 'all' to None for internal implementation
-        if stage == 'all':
+        if stage == "all":
             stage = None
-            
+
         if context is None or "ws" not in context:
             raise ValueError("Context must include 'ws' (workspace).")
         if parent_id:
@@ -2712,13 +2778,19 @@ async def list_children(
                                 "committed",
                             ], "Invalid version value, it should be 'stage', 'latest' or 'committed'."
                             if value == "stage":
-                                assert stage != None, "Stage parameter cannot be used with version filter."
+                                assert (
+                                    stage != None
+                                ), "Stage parameter cannot be used with version filter."
                                 stage = True
                             elif value == "latest":
-                                assert stage != True, "Stage parameter cannot be used with version filter."
+                                assert (
+                                    stage != True
+                                ), "Stage parameter cannot be used with version filter."
                                 stage = False
                             elif value == "committed":
-                                assert stage != True, "Stage parameter cannot be used with version filter."
+                                assert (
+                                    stage != True
+                                ), "Stage parameter cannot be used with version filter."
                                 stage = False
                             continue
 
@@ -2797,14 +2869,15 @@ async def list_children(
                                 ArtifactModel.staging.isnot(None),
                                 text("staging != 'null'"),
                             )
-                            logger.info("Adding condition to return ONLY STAGED artifacts")
+                            logger.info(
+                                "Adding condition to return ONLY STAGED artifacts"
+                            )
                         else:
                             # Return only committed artifacts
-                            stage_condition = or_(
-                                ArtifactModel.staging.is_(None),
-                                text("staging = 'null'"),
+                            stage_condition = text("json_array_length(versions) > 0")
+                            logger.info(
+                                "Adding condition to return ONLY COMMITTED artifacts (with at least 1 version)"
                             )
-                            logger.info("Adding condition to return ONLY COMMITTED artifacts")
                     else:
                         if stage:
                             # Return only staged artifacts
@@ -2812,19 +2885,24 @@ async def list_children(
                                 ArtifactModel.staging.isnot(None),
                                 text("staging::text != 'null'"),
                             )
-                            logger.info("Adding condition to return ONLY STAGED artifacts")
+                            logger.info(
+                                "Adding condition to return ONLY STAGED artifacts"
+                            )
                         else:
                             # Return only committed artifacts
-                            stage_condition = or_(
-                                ArtifactModel.staging.is_(None),
-                                text("staging::text = 'null'"),
+                            stage_condition = (
+                                func.json_array_length(ArtifactModel.versions) > 0
+                            )
+                            logger.info(
+                                "Adding condition to return ONLY COMMITTED artifacts (with at least 1 version)"
                             )
-                            logger.info("Adding condition to return ONLY COMMITTED artifacts")
 
                     query = query.where(stage_condition)
                     count_query = count_query.where(stage_condition)
                 else:
-                    logger.info("No stage filter applied - returning BOTH staged and committed artifacts")
+                    logger.info(
+                        "No stage filter applied - returning BOTH staged and committed artifacts"
+                    )
 
                 # Combine conditions based on mode (AND/OR)
                 if conditions:
diff --git a/hypha/core/workspace.py b/hypha/core/workspace.py
index 5c6ee48f2..f8a0fdb38 100644
--- a/hypha/core/workspace.py
+++ b/hypha/core/workspace.py
@@ -109,7 +109,7 @@ def validate_key_part(key_part: str):
 class GetServiceConfig(BaseModel):
     mode: Optional[str] = Field(
         None,
-        description="Mode for selecting the service, it can be 'random', 'first', 'last' or 'exact'",
+        description="Mode for selecting the service. Can be 'random', 'first', 'last', 'exact', or 'select:criteria:function' format (e.g., 'select:min:get_load', 'select:max:get_cpu_usage')",
     )
     timeout: Optional[float] = Field(
         10.0,
@@ -119,6 +119,10 @@ class GetServiceConfig(BaseModel):
         None,
         description="The case conversion for service keys, can be 'camel', 'snake' or None, default is None.",
     )
+    select_timeout: Optional[float] = Field(
+        2.0,
+        description="The timeout duration in seconds for calling service functions when using select mode.",
+    )
 
 
 class WorkspaceStatus:
@@ -557,7 +561,10 @@ async def create_workspace(
             self._active_ws.inc()
 
         # Skip S3 setup for anonymous users
-        if not workspace.id.startswith(ANONYMOUS_USER_WS_PREFIX) and self._s3_controller:
+        if (
+            not workspace.id.startswith(ANONYMOUS_USER_WS_PREFIX)
+            and self._s3_controller
+        ):
             await self._s3_controller.setup_workspace(workspace)
 
         # Verify workspace exists in Redis
@@ -1300,7 +1307,7 @@ async def get_service_info(
         ),
         config: Optional[dict] = Field(
             None,
-            description="Options for getting service, the only available config is `mode`, for selecting the service, it can be 'random', 'first', 'last' or 'exact'",
+            description="Options for getting service, available configs are `mode` (for selecting the service: 'random', 'first', 'last', 'exact', or 'select:criteria:function') and `select_timeout` (timeout for function calls when using select mode)",
         ),
         context: Optional[dict] = None,
     ):
@@ -1344,7 +1351,7 @@ async def get_service_info(
         if mode == "exact":
             assert (
                 len(keys) == 1
-            ), f"Multiple services found for {service_id}, e.g. {keys[:5]}. You can either specify the mode as 'random', 'first' or 'last', or provide the service id in `client_id:service_id` format."
+            ), f"Multiple services found for {service_id}, e.g. {keys[:5]}. You can either specify the mode as 'random', 'first', 'last', or use 'select:criteria:function' format."
             key = keys[0]
         elif mode == "random":
             key = random.choice(keys)
@@ -1352,9 +1359,18 @@ async def get_service_info(
             key = keys[0]
         elif mode == "last":
             key = keys[-1]
+        elif mode and mode.startswith("select:"):
+            # Parse the select syntax: select:criteria:function
+            parts = mode.split(":")
+            if len(parts) != 3:
+                raise ValueError(f"Invalid select mode format: {mode}. Expected 'select:criteria:function'")
+            
+            _, criteria, function_name = parts
+            select_timeout = config.get("select_timeout", 2.0) if isinstance(config, dict) else getattr(config, "select_timeout", 2.0)
+            key = await self._select_service_by_function(keys, criteria, function_name, select_timeout)
         else:
             raise ValueError(
-                f"Invalid mode: {mode}, the mode must be 'random', 'first', 'last' or 'exact'"
+                f"Invalid mode: {mode}. Mode must be 'random', 'first', 'last', 'exact', or 'select:criteria:function' format (e.g., 'select:min:get_load')"
             )
         # if it's a public service or the user has read permission
         if not key.startswith(b"services:public|") and not user_info.check_permission(
@@ -2154,3 +2170,70 @@ async def _set_workspace_status(self, workspace_id: str, status: str):
         except Exception as e:
             logger.error(f"Failed to set workspace status: {e}")
             raise
+
+    async def _select_service_by_function(self, keys: List[bytes], criteria: str, function_name: str, timeout: float = 2.0) -> bytes:
+        """Select service by calling a function on each service and applying selection criteria.
+        
+        Args:
+            keys: List of Redis keys for services
+            criteria: Selection criteria ('min', 'max', 'first_success', etc.)
+            function_name: Name of the function to call on each service
+            timeout: Timeout for function calls
+            
+        Returns:
+            bytes: The Redis key of the selected service
+        """
+        if len(keys) == 1:
+            return keys[0]
+        
+        # Get service APIs and call the specified function
+        service_values = []
+        
+        for key in keys:
+            try:
+                # Get service info
+                service_data = await self._redis.hgetall(key)
+                service_info = ServiceInfo.from_redis_dict(service_data)
+                
+                # Get the service API
+                service_api = await self._rpc.get_remote_service(
+                    service_info.id,
+                    {"timeout": timeout}
+                )
+                
+                # Check if the service has the required function
+                if not hasattr(service_api, function_name):
+                    logger.warning(f"Service {service_info.id} does not have function '{function_name}', skipping")
+                    continue
+                
+                # Call the function
+                func = getattr(service_api, function_name)
+                result = await func()
+                
+                service_values.append((key, result, service_info))
+                
+            except Exception as e:
+                logger.warning(f"Failed to call {function_name} on service {key}: {e}")
+                continue
+        
+        if not service_values:
+            logger.warning(f"No services responded to {function_name}, falling back to random selection")
+            return random.choice(keys)
+        
+        # Apply selection criteria
+        if criteria == "min":
+            # Select service with minimum value
+            selected_key, value, _ = min(service_values, key=lambda x: float(x[1]))
+            logger.debug(f"Selected service with minimum {function_name}: {value}")
+        elif criteria == "max":
+            # Select service with maximum value
+            selected_key, value, _ = max(service_values, key=lambda x: float(x[1]))
+            logger.debug(f"Selected service with maximum {function_name}: {value}")
+        elif criteria == "first_success":
+            # Select first service that successfully responded
+            selected_key, value, _ = service_values[0]
+            logger.debug(f"Selected first successful service: {value}")
+        else:
+            raise ValueError(f"Unknown selection criteria: {criteria}")
+        
+        return selected_key
diff --git a/hypha/minio.py b/hypha/minio.py
index 606e8065a..8d4185533 100644
--- a/hypha/minio.py
+++ b/hypha/minio.py
@@ -24,7 +24,9 @@
 MATH_PATTERN = re.compile("{(.+?)}")
 
 
-def setup_minio_executables(executable_path, minio_version=None, mc_version=None, file_system_mode=False):
+def setup_minio_executables(
+    executable_path, minio_version=None, mc_version=None, file_system_mode=False
+):
     """Download and install the minio client and server binary files."""
     if executable_path and not os.path.exists(executable_path):
         os.makedirs(executable_path, exist_ok=True)
@@ -32,13 +34,15 @@ def setup_minio_executables(executable_path, minio_version=None, mc_version=None
     # Default versions if not specified
     default_minio_version = "RELEASE.2024-07-16T23-46-41Z"
     default_mc_version = "RELEASE.2025-04-08T15-39-49Z"
-    
+
     # Use specific versions if file system mode is enabled
     if file_system_mode:
         minio_version = "RELEASE.2022-10-24T18-35-07Z"
         mc_version = "RELEASE.2022-10-29T10-09-23Z"
-        logger.info("Using Minio file system mode with fixed versions: "
-                   f"minio={minio_version}, mc={mc_version}")
+        logger.info(
+            "Using Minio file system mode with fixed versions: "
+            f"minio={minio_version}, mc={mc_version}"
+        )
     else:
         # Use provided versions or defaults
         minio_version = minio_version or default_minio_version
@@ -50,11 +54,15 @@ def setup_minio_executables(executable_path, minio_version=None, mc_version=None
     if sys.platform == "win32":
         mc_base += ".exe"
         minio_base += ".exe"
-    
+
     # Create versioned executable names
-    minio_version_short = minio_version.replace("RELEASE.", "").replace("-", "").replace(":", "")
-    mc_version_short = mc_version.replace("RELEASE.", "").replace("-", "").replace(":", "")
-    
+    minio_version_short = (
+        minio_version.replace("RELEASE.", "").replace("-", "").replace(":", "")
+    )
+    mc_version_short = (
+        mc_version.replace("RELEASE.", "").replace("-", "").replace(":", "")
+    )
+
     mc_executable = f"{mc_base}.{mc_version_short}"
     minio_executable = f"{minio_base}.{minio_version_short}"
 
@@ -84,7 +92,7 @@ def setup_minio_executables(executable_path, minio_version=None, mc_version=None
         )
 
     download_success = True
-    
+
     if not os.path.exists(minio_path):
         try:
             print(f"Minio server executable {minio_version} not found, downloading... ")
@@ -113,7 +121,7 @@ def setup_minio_executables(executable_path, minio_version=None, mc_version=None
                 stat_result = os.stat(minio_path)
                 if not bool(stat_result.st_mode & stat.S_IEXEC):
                     os.chmod(minio_path, stat_result.st_mode | stat.S_IEXEC)
-            
+
             if os.path.exists(mc_path):
                 stat_result = os.stat(mc_path)
                 if not bool(stat_result.st_mode & stat.S_IEXEC):
@@ -162,10 +170,7 @@ def start_minio_server(
 
     # Setup the minio executables with specified versions
     minio_version, mc_version, minio_path, mc_path = setup_minio_executables(
-        executable_path, 
-        minio_version, 
-        mc_version, 
-        file_system_mode
+        executable_path, minio_version, mc_version, file_system_mode
     )
 
     # Create temp directory if workdir not provided
@@ -176,28 +181,30 @@ def start_minio_server(
     else:
         workdir_path = Path(workdir)
         workdir_path.mkdir(parents=True, exist_ok=True)
-        
+
         # When using file system mode, create the format.json file
         if file_system_mode:
             minio_sys_dir = workdir_path / ".minio.sys"
             # Ensure the .minio.sys directory exists
             minio_sys_dir.mkdir(exist_ok=True)
-            
+
             format_file_path = minio_sys_dir / "format.json"
             format_content = {
                 "version": "1",
                 "format": "fs",
                 "id": "avoid-going-into-snsd-mode-legacy-is-fine-with-me",
-                "fs": {"version": "2"}
+                "fs": {"version": "2"},
             }
-            
+
             try:
-                with open(format_file_path, 'w', encoding='utf-8') as f:
+                with open(format_file_path, "w", encoding="utf-8") as f:
                     json.dump(format_content, f, ensure_ascii=False, indent=4)
-                logger.info(f"Created format.json for legacy FS mode in {minio_sys_dir}")
+                logger.info(
+                    f"Created format.json for legacy FS mode in {minio_sys_dir}"
+                )
             except Exception as e:
                 logger.warning(f"Failed to create format.json for legacy FS mode: {e}")
-        
+
         workdir = str(workdir_path)
 
     # Default console port if not provided
@@ -210,7 +217,7 @@ def start_minio_server(
     my_env = os.environ.copy()
     my_env["MINIO_ROOT_USER"] = root_user
     my_env["MINIO_ROOT_PASSWORD"] = root_password
-    
+
     # In file system mode, set additional environment variables
     # Note: Some of these might be redundant or conflicting with the format.json approach,
     # but keeping them for now based on previous attempts.
@@ -235,11 +242,11 @@ def start_minio_server(
         f"--address=:{port}",
         f"--console-address=:{console_port}",
     ]
-    
+
     # Add filesystem mode specific arguments
     if file_system_mode:
         cmd.append("--quiet")  # Run in quiet mode for file system usage
-    
+
     # Add the data directory as the last argument
     cmd.append(workdir)
 
@@ -447,12 +454,9 @@ def __init__(
         """Initialize the client."""
         # setup minio executables with specified versions
         _, _, _, mc_path = setup_minio_executables(
-            executable_path, 
-            minio_version, 
-            mc_version, 
-            file_system_mode
+            executable_path, minio_version, mc_version, file_system_mode
         )
-        
+
         # generate alias by hash of endpoint_url, access_key_id, and secret_access_key
         # Ensure alias starts with a letter (a-z) and contains only alphanumeric characters
         hash_str = hashlib.sha256(
@@ -460,10 +464,10 @@ def __init__(
         ).hexdigest()
         # Use 'mc' prefix followed by first 8 chars of hash
         self.alias = f"mc{hash_str[:8]}"
-        
+
         # Use the versioned executable path
         self.mc_executable = mc_path
-        
+
         self.endpoint_url = endpoint_url
         self.access_key_id = access_key_id
         self.secret_access_key = secret_access_key
diff --git a/hypha/runner/browser.py b/hypha/runner/browser.py
index f92743c6d..617310111 100644
--- a/hypha/runner/browser.py
+++ b/hypha/runner/browser.py
@@ -76,12 +76,9 @@ async def initialize(self) -> Browser:
         # so it works in the docker image
         if self.in_docker:
             args.append("--no-sandbox")
-        
+
         self.browser = await self._playwright.chromium.launch(
-            args=args,
-            handle_sigint=True,
-            handle_sigterm=True,
-            handle_sighup=True
+            args=args, handle_sigint=True, handle_sigterm=True, handle_sighup=True
         )
         self._initialized = True
         return self.browser
@@ -94,13 +91,13 @@ async def shutdown(self) -> None:
             session_ids = list(self._browser_sessions.keys())
             for session_id in session_ids:
                 await self.stop(session_id)
-            
+
             if self.browser:
                 await self.browser.close()
-            
+
             if self._playwright:
                 await self._playwright.stop()
-                
+
             self._initialized = False
             logger.info("Browser app controller closed successfully.")
         except Exception as e:
@@ -116,20 +113,19 @@ async def start(
         """Start a browser app instance."""
         if session_id is None:
             session_id = str(uuid.uuid4())
-            
+
         if not self.browser:
             await self.initialize()
-            
+
         try:
             # Create a new context for isolation
             context = await self.browser.new_context(
-                viewport={'width': 1280, 'height': 720},
-                accept_downloads=True
+                viewport={"width": 1280, "height": 720}, accept_downloads=True
             )
-            
+
             # Create a new page in the context
             page = await context.new_page()
-            
+
             logs = {}
             self._browser_sessions[session_id] = {
                 "url": url,
@@ -144,25 +140,25 @@ async def start(
 
             logger.info("Loading browser app: %s", url)
             response = await page.goto(url, timeout=60000, wait_until="load")
-            
+
             if not response:
                 raise Exception(f"Failed to load URL: {url}")
-                
+
             if response.status != 200:
                 raise Exception(
                     f"Failed to start browser app instance, "
                     f"status: {response.status}, url: {url}"
                 )
-                
+
             logger.info("Browser app loaded successfully: %s", url)
             self._browser_sessions[session_id]["status"] = "connected"
-            
+
             return {
                 "session_id": session_id,
                 "status": "connected",
                 "url": url,
             }
-            
+
         except Exception as e:
             logger.error("Error starting browser session: %s", str(e))
             if session_id in self._browser_sessions:
@@ -190,10 +186,7 @@ async def stop(self, session_id: str) -> None:
     async def list(self, workspace) -> List[Dict[str, Any]]:
         """List the browser apps for the current user."""
         sessions = [
-            {
-                k: v for k, v in page_info.items() 
-                if k not in ["page", "context"]
-            }
+            {k: v for k, v in page_info.items() if k not in ["page", "context"]}
             for session_id, page_info in self._browser_sessions.items()
             if session_id.startswith(workspace + "/")
         ]
@@ -209,24 +202,23 @@ async def get_log(
         """Get the logs for a browser app instance."""
         if session_id not in self._browser_sessions:
             raise Exception(f"Browser app instance not found: {session_id}")
-            
+
         if type is None:
             return self._browser_sessions[session_id]["logs"]
-            
+
         if type not in self._browser_sessions[session_id]["logs"]:
             return []
-            
+
         if limit is None:
             limit = MAXIMUM_LOG_ENTRIES
-            
-        return self._browser_sessions[session_id]["logs"][type][
-            offset : offset + limit
-        ]
+
+        return self._browser_sessions[session_id]["logs"][type][offset : offset + limit]
 
     async def close_workspace(self, workspace: str) -> None:
         """Close all browser app instances for a workspace."""
         session_ids = [
-            session_id for session_id in self._browser_sessions.keys()
+            session_id
+            for session_id in self._browser_sessions.keys()
             if session_id.startswith(workspace + "/")
         ]
         for session_id in session_ids:
diff --git a/hypha/s3.py b/hypha/s3.py
index be1e98118..92c968e5c 100644
--- a/hypha/s3.py
+++ b/hypha/s3.py
@@ -16,9 +16,7 @@
 from fastapi.responses import FileResponse, JSONResponse
 from starlette.datastructures import Headers
 from starlette.types import Receive, Scope, Send
-from asgiproxy.simple_proxy import make_simple_proxy_app
-from asgiproxy.context import ProxyContext
-from asgiproxy.config import BaseURLProxyConfigMixin, ProxyConfig
+from hypha.utils.asgi_proxy import make_simple_proxy_app, ProxyContext, BaseURLProxyConfigMixin, ProxyConfig
 
 from hypha.core import UserInfo, WorkspaceInfo, UserPermission
 from hypha.minio import MinioClient
@@ -747,3 +745,4 @@ def get_s3_service(self):
         if self.minio_client:
             svc["generate_credential"] = self.generate_credential
         return svc
+    
\ No newline at end of file
diff --git a/hypha/server.py b/hypha/server.py
index 488d92418..a518c3fe2 100644
--- a/hypha/server.py
+++ b/hypha/server.py
@@ -176,7 +176,7 @@ def norm_url(base_path, url):
 def create_application(args):
     """Create a hypha application."""
     global minio_proc
-    
+
     if args.from_env:
         logger.info("Loading arguments from environment variables")
         _args = get_args_from_env()
@@ -245,7 +245,9 @@ async def lifespan(app: FastAPI):
                 minio_proc.wait(timeout=5)
             except subprocess.TimeoutExpired:
                 # Force kill if it doesn't terminate gracefully
-                logger.warning("Minio server did not terminate gracefully, forcing termination")
+                logger.warning(
+                    "Minio server did not terminate gracefully, forcing termination"
+                )
                 minio_proc.kill()
 
     application = FastAPI(
diff --git a/hypha/templates/hypha-core-app/hypha-app-webpython.js b/hypha/templates/hypha-core-app/hypha-app-webpython.js
index e107dbd3a..b8a497408 100644
--- a/hypha/templates/hypha-core-app/hypha-app-webpython.js
+++ b/hypha/templates/hypha-core-app/hypha-app-webpython.js
@@ -27,7 +27,7 @@ loadPyodide().then(async (pyodide) => {
     pyodide.setStderr({ batched: (msg) => console.error(msg) });
     await pyodide.loadPackage("micropip");
     const micropip = pyodide.pyimport("micropip");
-    await micropip.install('hypha-rpc==0.20.51');
+    await micropip.install('hypha-rpc==0.20.54');
     const isWindow = typeof window !== "undefined";
     
     setTimeout(() => {
diff --git a/hypha/templates/ws/index.html b/hypha/templates/ws/index.html
index 5169d72db..fed1d51d8 100644
--- a/hypha/templates/ws/index.html
+++ b/hypha/templates/ws/index.html
@@ -160,7 +160,7 @@
 <body class="bg-black text-white font-poppins">
     <div id="app"></div>
     <script type="module">
-        import { HyphaCore } from "https://cdn.jsdelivr.net/npm/hypha-core@0.20.51/dist/hypha-core.mjs";
+        import { HyphaCore } from "https://cdn.jsdelivr.net/npm/hypha-core@0.20.54/dist/hypha-core.mjs";
 
         const defaultService = {
             getServerConfig(context){
diff --git a/hypha/utils/asgi_proxy.py b/hypha/utils/asgi_proxy.py
new file mode 100644
index 000000000..dfe549085
--- /dev/null
+++ b/hypha/utils/asgi_proxy.py
@@ -0,0 +1,416 @@
+"""
+Custom ASGI proxy implementation based on asgiproxy but with fixes for session management issues.
+
+This implementation addresses the problems that cause asgiproxy to become unresponsive:
+1. Session reuse leading to connection exhaustion
+2. Missing connection limits and timeouts
+3. No proper cleanup mechanisms
+4. Content-encoding issues for compressed files
+
+Portions of this code are derived from asgiproxy:
+The MIT License (MIT)
+
+Copyright (c) 2019 Valohai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+"""
+
+import asyncio
+import logging
+from typing import Optional, Union
+from urllib.parse import urljoin, urlparse
+
+import aiohttp
+from starlette.datastructures import Headers
+from starlette.requests import Request
+from starlette.responses import Response, StreamingResponse
+from starlette.types import ASGIApp, Receive, Scope, Send
+
+logger = logging.getLogger(__name__)
+
+Headerlike = Union[dict, Headers]
+
+
+class ProxyConfig:
+    """Base proxy configuration class."""
+    
+    def get_upstream_url(self, *, scope: Scope) -> str:
+        """Get the upstream URL for a client request."""
+        raise NotImplementedError("...")
+
+    def get_upstream_url_with_query(self, *, scope: Scope) -> str:
+        """Get the upstream URL for a client request, including query parameters."""
+        url = self.get_upstream_url(scope=scope)
+        query_string = scope.get("query_string")
+        if query_string:
+            sep = "&" if "?" in url else "?"
+            url += f"{sep}{query_string.decode('utf-8')}"
+        return url
+
+    def process_client_headers(self, *, scope: Scope, headers: Headers) -> Headerlike:
+        """Process client HTTP headers before they're passed upstream."""
+        return headers
+
+    def process_upstream_headers(
+        self, *, scope: Scope, proxy_response: aiohttp.ClientResponse
+    ) -> Headerlike:
+        """Process upstream HTTP headers before they're passed to the client."""
+        return proxy_response.headers
+
+    def get_upstream_http_options(self, *, scope: Scope, client_request: Request, data) -> dict:
+        """Get request options (as passed to aiohttp.ClientSession.request)."""
+        return dict(
+            method=client_request.method,
+            url=self.get_upstream_url_with_query(scope=scope),
+            data=data,
+            headers=self.process_client_headers(
+                scope=scope,
+                headers=client_request.headers,
+            ),
+            allow_redirects=False,
+        )
+
+
+class BaseURLProxyConfigMixin:
+    """Mixin for proxy configs that proxy to a base URL."""
+    
+    upstream_base_url: str
+    rewrite_host_header: Optional[str] = None
+
+    def get_upstream_url(self, scope: Scope) -> str:
+        return urljoin(self.upstream_base_url, scope["path"])
+
+    def process_client_headers(self, *, scope: Scope, headers: Headerlike) -> Headerlike:
+        """Process client HTTP headers before they're passed upstream."""
+        if self.rewrite_host_header:
+            headers = headers.mutablecopy()  # type: ignore
+            headers["host"] = self.rewrite_host_header
+        return super().process_client_headers(scope=scope, headers=headers)  # type: ignore
+
+
+class ProxyContext:
+    """
+    Improved proxy context that creates fresh sessions to avoid connection issues.
+    
+    Unlike the original asgiproxy, this doesn't reuse sessions which can lead to
+    connection exhaustion and unresponsiveness.
+    """
+    
+    def __init__(
+        self,
+        config: ProxyConfig,
+        max_concurrency: int = 20,
+    ) -> None:
+        self.config = config
+        self.semaphore = asyncio.Semaphore(max_concurrency)
+
+    def create_session(self) -> aiohttp.ClientSession:
+        """Create a fresh session with proper connection management."""
+        connector = aiohttp.TCPConnector(
+            limit=100,  # Total connection pool size
+            limit_per_host=30,  # Per-host connection limit
+            ttl_dns_cache=300,  # DNS cache TTL
+            use_dns_cache=True,
+            keepalive_timeout=30,
+            enable_cleanup_closed=True
+        )
+        
+        timeout = aiohttp.ClientTimeout(
+            total=60,  # Total timeout
+            connect=10,  # Connection timeout
+            sock_read=30  # Socket read timeout
+        )
+        
+        return aiohttp.ClientSession(
+            connector=connector,
+            timeout=timeout,
+            cookie_jar=aiohttp.DummyCookieJar(),
+            auto_decompress=False  # We'll handle content-encoding manually
+        )
+
+    async def __aenter__(self) -> "ProxyContext":
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+        # No session to close since we create fresh ones per request
+        pass
+
+    async def close(self) -> None:
+        # No persistent session to close
+        pass
+
+
+def _should_remove_gzip_encoding(content_type: str, file_path: str) -> bool:
+    """
+    Determine if gzip content-encoding should be removed for already-compressed content.
+    
+    Uses a simple heuristic: if the content type indicates binary/compressed data
+    or the file extension suggests a compressed format, remove gzip encoding.
+    """
+    import mimetypes
+    from pathlib import Path
+    
+    # Normalize inputs
+    content_type = (content_type or "").lower().split(';')[0].strip()
+    file_extension = Path(file_path).suffix.lower()
+    
+    # Simple heuristic: remove gzip for binary content types that are typically compressed
+    if content_type.startswith(('image/', 'video/', 'audio/', 'application/')):
+        # Allow gzip for text-based application types
+        if content_type.startswith(('application/json', 'application/xml', 'application/javascript')):
+            return False
+        return True
+        
+    # Check common compressed file extensions
+    compressed_extensions = {
+        '.jpg', '.jpeg', '.png', '.gif', '.webp', '.mp4', '.avi', '.mov', 
+        '.mp3', '.wav', '.pdf', '.zip', '.rar', '.gz', '.bz2', '.7z'
+    }
+    if file_extension in compressed_extensions:
+        return True
+        
+    # Use mimetypes as fallback
+    guessed_type, _ = mimetypes.guess_type(file_path)
+    if guessed_type and not guessed_type.startswith('text/'):
+        return True
+        
+    return False
+
+
+# Streaming thresholds
+INCOMING_STREAMING_THRESHOLD = 512 * 1024  # 512KB
+OUTGOING_STREAMING_THRESHOLD = 1024 * 1024 * 5  # 5MB
+
+
+def determine_incoming_streaming(request: Request) -> bool:
+    """Determine if we should stream the incoming request."""
+    if request.method in ("GET", "HEAD"):
+        return False
+
+    try:
+        return int(request.headers["content-length"]) > INCOMING_STREAMING_THRESHOLD
+    except (TypeError, ValueError, KeyError):
+        # Malformed or missing content-length header; assume a very large payload
+        return True
+
+
+def determine_outgoing_streaming(proxy_response: aiohttp.ClientResponse) -> bool:
+    """Determine if we should stream the outgoing response."""
+    if proxy_response.status != 200:
+        return False
+    try:
+        return int(proxy_response.headers["content-length"]) > OUTGOING_STREAMING_THRESHOLD
+    except (TypeError, ValueError, KeyError):
+        # Malformed or missing content-length header; assume a streaming payload
+        return True
+
+
+async def read_stream_in_chunks(stream, chunk_size: int = 64 * 1024):
+    """Read stream in chunks."""
+    while True:
+        chunk = await stream.read(chunk_size)
+        if not chunk:
+            break
+        yield chunk
+
+
+async def get_proxy_response(
+    *,
+    context: ProxyContext,
+    scope: Scope,
+    receive: Receive,
+) -> tuple[aiohttp.ClientResponse, aiohttp.ClientSession]:
+    """Get the proxy response from upstream, returning both response and session."""
+    request = Request(scope, receive)
+    should_stream_incoming = determine_incoming_streaming(request)
+    
+    async with context.semaphore:
+        data = None
+        if request.method not in ("GET", "HEAD"):
+            if should_stream_incoming:
+                data = request.stream()
+            else:
+                data = await request.body()
+
+        kwargs = context.config.get_upstream_http_options(
+            scope=scope, client_request=request, data=data
+        )
+
+        # Create fresh session for this request
+        session = context.create_session()
+        try:
+            response = await session.request(**kwargs)
+            return response, session
+        except Exception:
+            # Clean up session on error
+            await session.close()
+            raise
+
+
+async def convert_proxy_response_to_user_response(
+    *,
+    context: ProxyContext,
+    scope: Scope,
+    proxy_response: aiohttp.ClientResponse,
+    session: aiohttp.ClientSession,
+) -> Response:
+    """Convert the proxy response to a user response."""
+    try:
+        # Process headers
+        headers_to_client = dict(context.config.process_upstream_headers(
+            scope=scope, proxy_response=proxy_response
+        ))
+        
+        # Remove headers that shouldn't be forwarded
+        for header in ["connection", "transfer-encoding"]:
+            headers_to_client.pop(header, None)
+        
+        # Handle content-encoding for compressed files
+        original_encoding = proxy_response.headers.get("content-encoding", "").lower()
+        path = scope.get("path", "")
+        
+        if original_encoding == "gzip" and _should_remove_gzip_encoding(
+            proxy_response.headers.get("content-type", ""), path
+        ):
+            logger.debug(f"Removing incorrect gzip encoding for {path}")
+            headers_to_client.pop("content-encoding", None)
+        elif original_encoding:
+            # Preserve other encodings
+            headers_to_client["content-encoding"] = original_encoding
+        
+        status_to_client = proxy_response.status
+        
+        if determine_outgoing_streaming(proxy_response):
+            # Stream large responses
+            async def stream_content():
+                try:
+                    async for chunk in read_stream_in_chunks(proxy_response.content):
+                        if chunk:
+                            yield chunk
+                except Exception as e:
+                    logger.warning(f"Streaming error for {path}: {e}")
+                finally:
+                    # Clean up session after streaming
+                    try:
+                        await session.close()
+                    except Exception as e:
+                        logger.warning(f"Error closing session: {e}")
+                        
+            return StreamingResponse(
+                content=stream_content(),
+                status_code=status_to_client,
+                headers=headers_to_client,
+                media_type=headers_to_client.get("content-type", "application/octet-stream")
+            )
+        else:
+            # Buffer small responses
+            try:
+                content = await proxy_response.read()
+                return Response(
+                    content=content,
+                    status_code=status_to_client,
+                    headers=headers_to_client,
+                    media_type=headers_to_client.get("content-type", "application/octet-stream")
+                )
+            finally:
+                # Clean up session after reading
+                await session.close()
+                
+    except Exception:
+        # Clean up session on any error
+        try:
+            await session.close()
+        except Exception:
+            pass
+        raise
+
+
+async def proxy_http(
+    *,
+    context: ProxyContext,
+    scope: Scope,
+    receive: Receive,
+    send: Send,
+) -> None:
+    """Proxy HTTP requests."""
+    try:
+        proxy_response, session = await get_proxy_response(
+            context=context, scope=scope, receive=receive
+        )
+        
+        user_response = await convert_proxy_response_to_user_response(
+            context=context, scope=scope, proxy_response=proxy_response, session=session
+        )
+        return await user_response(scope, receive, send)
+        
+    except asyncio.TimeoutError:
+        logger.error(f"Proxy timeout for {scope.get('path', 'unknown')}")
+        response = Response(
+            content="Gateway Timeout",
+            status_code=504,
+            headers={"Content-Type": "text/plain"},
+        )
+        return await response(scope, receive, send)
+    except aiohttp.ClientError as e:
+        logger.error(f"Proxy client error for {scope.get('path', 'unknown')}: {e}")
+        response = Response(
+            content="Bad Gateway",
+            status_code=502,
+            headers={"Content-Type": "text/plain"},
+        )
+        return await response(scope, receive, send)
+    except Exception as e:
+        logger.error(f"Proxy error for {scope.get('path', 'unknown')}: {e}")
+        response = Response(
+            content="Internal Server Error",
+            status_code=500,
+            headers={"Content-Type": "text/plain"},
+        )
+        return await response(scope, receive, send)
+
+
+def make_simple_proxy_app(
+    proxy_context: ProxyContext,
+    *,
+    proxy_http_handler=proxy_http,
+    proxy_websocket_handler=None,  # We don't need websocket support for S3
+) -> ASGIApp:
+    """
+    Create a simple ASGI proxy application.
+    
+    This is compatible with the asgiproxy API but uses improved session management.
+    """
+
+    async def app(scope: Scope, receive: Receive, send: Send):
+        if scope["type"] == "lifespan":
+            return None  # We explicitly do nothing here for this simple app.
+
+        if scope["type"] == "http" and proxy_http_handler:
+            return await proxy_http_handler(
+                context=proxy_context, scope=scope, receive=receive, send=send
+            )
+
+        if scope["type"] == "websocket" and proxy_websocket_handler:
+            return await proxy_websocket_handler(
+                context=proxy_context, scope=scope, receive=receive, send=send
+            )
+
+        raise NotImplementedError(f"Scope {scope} is not understood")
+
+    return app 
\ No newline at end of file
diff --git a/hypha/utils/zip_utils.py b/hypha/utils/zip_utils.py
index 83cab419f..df072e004 100644
--- a/hypha/utils/zip_utils.py
+++ b/hypha/utils/zip_utils.py
@@ -1,6 +1,6 @@
 """Utilities for working with ZIP files.
 
-This module provides utilities for working with ZIP files stored in S3, particularly 
+This module provides utilities for working with ZIP files stored in S3, particularly
 for streaming the content of files from inside ZIP archives without having to download
 the entire ZIP file first (for large archives).
 
@@ -34,24 +34,21 @@
 # Setup logger
 logger = logging.getLogger("zip_utils")
 
+
 async def fetch_zip_tail(
-    s3_client, 
-    bucket: str, 
-    key: str, 
-    content_length: int,
-    cache_instance=None
+    s3_client, bucket: str, key: str, content_length: int, cache_instance=None
 ) -> bytes:
     """
     Fetch the tail part of the zip file that contains the central directory.
     Uses an adaptive approach to find the central directory, supporting both standard ZIP and ZIP64 formats.
-    
+
     Args:
         s3_client: S3 client to use for fetching
         bucket: S3 bucket name
         key: S3 object key
         content_length: Total size of the ZIP file
         cache_instance: Optional Redis cache instance
-        
+
     Returns:
         bytes: The ZIP file tail containing the central directory
     """
@@ -62,43 +59,51 @@ async def fetch_zip_tail(
         if cached_tail:
             logger.debug(f"Using cached ZIP tail for {key}")
             return cached_tail
-    
+
     # For small files (< 50MB), just download the entire file
     # This is more reliable for tests and small files
     if content_length < 50 * 1024 * 1024:  # < 50MB
         try:
-            logger.debug(f"File is small ({content_length} bytes), downloading entire ZIP file")
+            logger.debug(
+                f"File is small ({content_length} bytes), downloading entire ZIP file"
+            )
             response = await s3_client.get_object(Bucket=bucket, Key=key)
             complete_zip = await response["Body"].read()
-            
+
             # Verify this is a valid ZIP file
             try:
                 with zipfile.ZipFile(BytesIO(complete_zip)) as zf:
                     # Just checking if it opens correctly
                     num_files = len(zf.namelist())
-                    logger.debug(f"Successfully loaded complete ZIP file ({len(complete_zip)} bytes) with {num_files} files")
-                
+                    logger.debug(
+                        f"Successfully loaded complete ZIP file ({len(complete_zip)} bytes) with {num_files} files"
+                    )
+
                 # Cache the entire file
                 if cache_instance:
                     logger.debug(f"Caching entire ZIP file for {key}")
-                    await cache_instance.set(cache_key, complete_zip, ttl=3600)  # Cache for 1 hour
-                
+                    await cache_instance.set(
+                        cache_key, complete_zip, ttl=3600
+                    )  # Cache for 1 hour
+
                 return complete_zip
             except zipfile.BadZipFile as e:
                 logger.error(f"Downloaded file is not a valid ZIP file: {str(e)}")
                 # Continue with partial download approach
-            
+
         except Exception as e:
             logger.error(f"Failed to download entire ZIP file: {str(e)}")
             # Continue with partial download approach
-            
+
     # ZIP End of Central Directory (EOCD) signature
-    EOCD_SIGNATURE = b'PK\x05\x06'
-    ZIP64_EOCD_LOCATOR = b'PK\x06\x07'  # ZIP64 End of Central Directory Locator signature
-    
+    EOCD_SIGNATURE = b"PK\x05\x06"
+    ZIP64_EOCD_LOCATOR = (
+        b"PK\x06\x07"  # ZIP64 End of Central Directory Locator signature
+    )
+
     # Adaptive tail size based on file size
     MAX_TAIL = 128 * 1024 * 1024  # 128MB absolute maximum for very large ZIP files
-    
+
     # Determine starting tail size based on file size
     # For small files (<10MB), start with 64KB
     # For medium files (10MB-100MB), start with 256KB
@@ -112,16 +117,16 @@ async def fetch_zip_tail(
         min_tail = 1024 * 1024  # 1MB
     else:
         min_tail = 4 * 1024 * 1024  # 4MB
-        
+
     # Limit max tail to 10% of file size for small/medium files to avoid overhead
     if content_length < 100 * 1024 * 1024:
         MAX_TAIL = min(MAX_TAIL, max(content_length // 10, min_tail * 2))
-    
+
     tail_length = min_tail
     found = False
-    zip_tail = b''
+    zip_tail = b""
     current_offset = content_length
-    
+
     # Adaptive approach: start small and increase until we find the central directory
     while tail_length <= MAX_TAIL:
         central_directory_offset = max(content_length - tail_length, 0)
@@ -144,53 +149,63 @@ async def fetch_zip_tail(
             )
             zip_tail = await response["Body"].read()
             current_offset = central_directory_offset
-            
+
         # First check for regular ZIP EOCD signature
         eocd_offset = zip_tail.rfind(EOCD_SIGNATURE)
-        
+
         # Also check for ZIP64 format
         zip64_locator_offset = zip_tail.rfind(ZIP64_EOCD_LOCATOR)
-        
+
         if eocd_offset != -1:
             # Found standard ZIP EOCD
             found = True
-            logger.debug(f"Found EOCD at offset {eocd_offset} in tail of size {len(zip_tail)}")
+            logger.debug(
+                f"Found EOCD at offset {eocd_offset} in tail of size {len(zip_tail)}"
+            )
             break
         elif zip64_locator_offset != -1:
             # Found ZIP64 EOCD Locator
             found = True
-            logger.debug(f"Found ZIP64 EOCD Locator at offset {zip64_locator_offset} in tail of size {len(zip_tail)}")
+            logger.debug(
+                f"Found ZIP64 EOCD Locator at offset {zip64_locator_offset} in tail of size {len(zip_tail)}"
+            )
             break
-            
+
         # Double the tail size and try again
-        tail_length *= 2  
+        tail_length *= 2
         logger.debug(f"Increasing tail size to {tail_length}")
-    
+
     # If we still haven't found the central directory, try one final approach: get the whole file
     # This is only for small enough files where it's reasonable to do so
     if not found and content_length <= 100 * 1024 * 1024:  # Only for files <= 100MB
-        logger.warning(f"Central directory not found in tail, downloading entire ZIP file for {key}")
+        logger.warning(
+            f"Central directory not found in tail, downloading entire ZIP file for {key}"
+        )
         try:
             response = await s3_client.get_object(Bucket=bucket, Key=key)
             zip_tail = await response["Body"].read()
-            
+
             # Verify this is a valid ZIP file
             try:
                 with zipfile.ZipFile(BytesIO(zip_tail)) as zf:
                     # Just checking if it opens correctly
                     found = True
-                    logger.debug(f"Successfully loaded complete ZIP file ({len(zip_tail)} bytes)")
+                    logger.debug(
+                        f"Successfully loaded complete ZIP file ({len(zip_tail)} bytes)"
+                    )
             except zipfile.BadZipFile:
                 logger.error(f"File is not a valid ZIP file: {key}")
                 # Continue with what we have anyway
         except Exception as e:
             logger.error(f"Failed to download entire ZIP file: {str(e)}")
             # Continue with what we have
-    
+
     if not found:
         # Fallback: return the largest tail we got, but warn
-        logger.warning(f"ZIP directory signatures not found in last {tail_length//2} bytes of zip file {key}. Returning largest tail.")
-    
+        logger.warning(
+            f"ZIP directory signatures not found in last {tail_length//2} bytes of zip file {key}. Returning largest tail."
+        )
+
     # Verify the tail can be opened as a ZIP file before returning
     try:
         with zipfile.ZipFile(BytesIO(zip_tail)) as zf:
@@ -199,14 +214,15 @@ async def fetch_zip_tail(
     except zipfile.BadZipFile as e:
         logger.error(f"Invalid ZIP file structure: {str(e)}")
         # We'll still return what we have, the caller will handle the error
-    
+
     # Cache result if cache instance provided and we found something valid
     if cache_instance and found:
         logger.debug(f"Caching ZIP tail for {key}")
         await cache_instance.set(cache_key, zip_tail, ttl=3600)  # Cache for 1 hour
-        
+
     return zip_tail
 
+
 async def get_zip_file_content(
     s3_client,
     bucket: str,
@@ -217,7 +233,7 @@ async def get_zip_file_content(
 ) -> Response:
     """
     Extract and stream content from a ZIP file stored in S3.
-    
+
     Args:
         s3_client: S3 client
         bucket: S3 bucket name
@@ -225,7 +241,7 @@ async def get_zip_file_content(
         path: Path within the ZIP file to retrieve
         zip_tail: Optional pre-fetched ZIP tail data
         cache_instance: Optional Redis cache instance
-        
+
     Returns:
         Response: Either a StreamingResponse with file content or a JSONResponse with directory listing
     """
@@ -248,18 +264,26 @@ async def get_zip_file_content(
                 logger.error(f"[zip] Failed to fetch file metadata: {str(e)}")
                 return JSONResponse(
                     status_code=500,
-                    content={"success": False, "detail": f"Failed to fetch file metadata: {str(e)}"},
+                    content={
+                        "success": False,
+                        "detail": f"Failed to fetch file metadata: {str(e)}",
+                    },
                 )
 
         # Fetch the ZIP's central directory if not provided
         if not zip_tail:
             try:
-                zip_tail = await fetch_zip_tail(s3_client, bucket, key, content_length, cache_instance)
+                zip_tail = await fetch_zip_tail(
+                    s3_client, bucket, key, content_length, cache_instance
+                )
             except Exception as e:
                 logger.error(f"[zip] Failed to fetch ZIP tail: {str(e)}")
                 return JSONResponse(
                     status_code=500,
-                    content={"success": False, "detail": f"Failed to fetch ZIP file structure: {str(e)}"},
+                    content={
+                        "success": False,
+                        "detail": f"Failed to fetch ZIP file structure: {str(e)}",
+                    },
                 )
 
         # Open the in-memory ZIP tail and parse it
@@ -269,7 +293,7 @@ async def get_zip_file_content(
                 if not path or path.endswith("/"):
                     logger.info(f"[zip] Listing directory: path={path}")
                     directory_contents = []
-                    
+
                     for zip_info in zip_file.infolist():
                         # Handle root directory or subdirectory files
                         if not path:
@@ -279,17 +303,28 @@ async def get_zip_file_content(
                                 # Top-level file
                                 directory_contents.append(
                                     {
-                                        "type": "file" if not zip_info.is_dir() else "directory",
+                                        "type": (
+                                            "file"
+                                            if not zip_info.is_dir()
+                                            else "directory"
+                                        ),
                                         "name": relative_path,
-                                        "size": zip_info.file_size if not zip_info.is_dir() else None,
-                                        "last_modified": datetime(*zip_info.date_time).timestamp()
+                                        "size": (
+                                            zip_info.file_size
+                                            if not zip_info.is_dir()
+                                            else None
+                                        ),
+                                        "last_modified": datetime(
+                                            *zip_info.date_time
+                                        ).timestamp(),
                                     }
                                 )
                             else:
                                 # Top-level directory
                                 top_level_dir = relative_path.split("/")[0]
                                 if not any(
-                                    d["name"] == top_level_dir and d["type"] == "directory"
+                                    d["name"] == top_level_dir
+                                    and d["type"] == "directory"
                                     for d in directory_contents
                                 ):
                                     directory_contents.append(
@@ -297,13 +332,19 @@ async def get_zip_file_content(
                                     )
                         else:
                             # Subdirectory: Include only immediate children
-                            if zip_info.filename.startswith(path) and zip_info.filename != path:
-                                relative_path = zip_info.filename[len(path):].strip("/")
+                            if (
+                                zip_info.filename.startswith(path)
+                                and zip_info.filename != path
+                            ):
+                                relative_path = zip_info.filename[len(path) :].strip(
+                                    "/"
+                                )
                                 if "/" in relative_path:
                                     # Subdirectory case
                                     child_name = relative_path.split("/")[0]
                                     if not any(
-                                        d["name"] == child_name and d["type"] == "directory"
+                                        d["name"] == child_name
+                                        and d["type"] == "directory"
                                         for d in directory_contents
                                     ):
                                         directory_contents.append(
@@ -316,22 +357,31 @@ async def get_zip_file_content(
                                             "type": "file",
                                             "name": relative_path,
                                             "size": zip_info.file_size,
-                                            "last_modified": datetime(*zip_info.date_time).timestamp()
+                                            "last_modified": datetime(
+                                                *zip_info.date_time
+                                            ).timestamp(),
                                         }
                                     )
-                                    
-                    logger.info(f"[zip] Directory listing complete, returning {len(directory_contents)} items")
+
+                    logger.info(
+                        f"[zip] Directory listing complete, returning {len(directory_contents)} items"
+                    )
                     return JSONResponse(status_code=200, content=directory_contents)
 
                 # Otherwise, find the file inside the ZIP
                 try:
                     zip_info = zip_file.getinfo(path)
-                    logger.info(f"[zip] Found file in ZIP: {path}, size: {zip_info.file_size}, compression: {zip_info.compress_type}")
+                    logger.info(
+                        f"[zip] Found file in ZIP: {path}, size: {zip_info.file_size}, compression: {zip_info.compress_type}"
+                    )
                 except KeyError:
                     logger.error(f"[zip] File not found inside ZIP: {path}")
                     return JSONResponse(
                         status_code=404,
-                        content={"success": False, "detail": f"File not found inside ZIP: {path}"},
+                        content={
+                            "success": False,
+                            "detail": f"File not found inside ZIP: {path}",
+                        },
                     )
 
                 # Set content type based on file extension if possible
@@ -364,17 +414,23 @@ async def get_zip_file_content(
                     chunk_size = 256 * 1024  # 256KB
                 else:
                     # For smaller files, use smaller chunks for lower latency
-                    chunk_size = 64 * 1024   # 64KB
+                    chunk_size = 64 * 1024  # 64KB
+
+                logger.info(
+                    f"[zip] Returning StreamingResponse for {path} with chunk size {chunk_size}"
+                )
 
-                logger.info(f"[zip] Returning StreamingResponse for {path} with chunk size {chunk_size}")
-                
                 # Stream the file data
                 return StreamingResponse(
-                    stream_file_from_zip(s3_client, bucket, key, zip_info, zip_tail, chunk_size),
+                    stream_file_from_zip(
+                        s3_client, bucket, key, zip_info, zip_tail, chunk_size
+                    ),
                     media_type=content_type,
                     headers={
                         "Content-Disposition": f'attachment; filename="{os.path.basename(path)}"',
-                        "Content-Length": str(zip_info.file_size)  # Add file size for client progress tracking
+                        "Content-Length": str(
+                            zip_info.file_size
+                        ),  # Add file size for client progress tracking
                     },
                 )
         except zipfile.BadZipFile as e:
@@ -383,26 +439,27 @@ async def get_zip_file_content(
                 status_code=500,
                 content={"success": False, "detail": f"Invalid ZIP file: {str(e)}"},
             )
-                
+
     except Exception as e:
         logger.error(f"[zip] Unhandled exception in get_zip_file_content: {str(e)}")
         return JSONResponse(
             status_code=500,
-            content={"success": False, "detail": f"Internal server error: {str(e)}"}
+            content={"success": False, "detail": f"Internal server error: {str(e)}"},
         )
 
+
 async def read_file_from_zip(s3_client, bucket, key, zip_info, zip_tail):
     """
     Extract a file from a ZIP archive efficiently by directly reading the compressed data
     and decompressing it on the fly.
-    
+
     Args:
         s3_client: S3 client
         bucket: S3 bucket name
         key: S3 object key for the ZIP file
         zip_info: ZipInfo object for the file to extract
         zip_tail: The ZIP central directory data
-        
+
     Returns:
         bytes: The decompressed file content
     """
@@ -411,20 +468,25 @@ async def read_file_from_zip(s3_client, bucket, key, zip_info, zip_tail):
         if zip_info.file_size < 10 * 1024 * 1024:  # < 10MB
             with zipfile.ZipFile(BytesIO(zip_tail)) as zf:
                 return zf.read(zip_info.filename)
-                
+
         # For larger files, use streaming approach
         chunks = []
-        async for chunk in stream_file_chunks_from_zip(s3_client, bucket, key, zip_info, zip_tail):
+        async for chunk in stream_file_chunks_from_zip(
+            s3_client, bucket, key, zip_info, zip_tail
+        ):
             chunks.append(chunk)
-        return b''.join(chunks)
+        return b"".join(chunks)
     except Exception as e:
         logger.error(f"Error reading file from ZIP: {str(e)}")
         raise
 
-async def stream_file_from_zip(s3_client, bucket, key, zip_info, zip_tail, chunk_size=64*1024):
+
+async def stream_file_from_zip(
+    s3_client, bucket, key, zip_info, zip_tail, chunk_size=64 * 1024
+):
     """
     Stream a file from a ZIP archive, yielding chunks of decompressed data.
-    
+
     Args:
         s3_client: S3 client
         bucket: S3 bucket name
@@ -432,31 +494,39 @@ async def stream_file_from_zip(s3_client, bucket, key, zip_info, zip_tail, chunk
         zip_info: ZipInfo object for the file to extract
         zip_tail: The ZIP central directory data
         chunk_size: Size of decompressed chunks to yield
-        
+
     Yields:
         bytes: Chunks of decompressed file data
     """
     try:
         # For small files or stored files, use the simpler approach
-        if zip_info.file_size < 1 * 1024 * 1024 or zip_info.compress_type == zipfile.ZIP_STORED:  # < 1MB
+        if (
+            zip_info.file_size < 1 * 1024 * 1024
+            or zip_info.compress_type == zipfile.ZIP_STORED
+        ):  # < 1MB
             with zipfile.ZipFile(BytesIO(zip_tail)) as zf:
                 file_content = zf.read(zip_info.filename)
                 for i in range(0, len(file_content), chunk_size):
-                    yield file_content[i:i + chunk_size]
+                    yield file_content[i : i + chunk_size]
             return
-        
+
         # For larger files, use the streaming implementation
-        async for chunk in stream_file_chunks_from_zip(s3_client, bucket, key, zip_info, zip_tail, chunk_size):
+        async for chunk in stream_file_chunks_from_zip(
+            s3_client, bucket, key, zip_info, zip_tail, chunk_size
+        ):
             yield chunk
     except Exception as e:
         logger.error(f"Error streaming file from ZIP: {str(e)}")
         raise
 
-async def stream_file_chunks_from_zip(s3_client, bucket, key, zip_info, zip_tail, chunk_size=64*1024):
+
+async def stream_file_chunks_from_zip(
+    s3_client, bucket, key, zip_info, zip_tail, chunk_size=64 * 1024
+):
     """
     Stream a file from a ZIP archive using true streaming without loading the entire file into memory.
     This fetches compressed data in chunks and decompresses on-the-fly.
-    
+
     Args:
         s3_client: S3 client
         bucket: S3 bucket name
@@ -464,13 +534,13 @@ async def stream_file_chunks_from_zip(s3_client, bucket, key, zip_info, zip_tail
         zip_info: ZipInfo object for the file to extract
         zip_tail: The ZIP central directory data
         chunk_size: Size of decompressed chunks to yield
-        
+
     Yields:
         bytes: Chunks of decompressed file data
     """
     # Get the local header offset from the central directory
     file_header_offset = zip_info.header_offset
-    
+
     # Calculate data offset: header offset + size of the local file header + filename length + extra field length
     try:
         with zipfile.ZipFile(BytesIO(zip_tail)) as zf:
@@ -479,78 +549,92 @@ async def stream_file_chunks_from_zip(s3_client, bucket, key, zip_info, zip_tail
             local_header_size = 30  # Fixed size of the local file header
             filename_length = len(zip_info.filename)
             extra_field_length = len(zip_info.extra)
-            
+
             # Calculate the offset where the actual file data begins
-            data_offset = file_header_offset + local_header_size + filename_length + extra_field_length
-            
+            data_offset = (
+                file_header_offset
+                + local_header_size
+                + filename_length
+                + extra_field_length
+            )
+
             compression_method = zip_info.compress_type
             compressed_size = zip_info.compress_size
             uncompressed_size = zip_info.file_size
-            
-            logger.debug(f"Streaming file {zip_info.filename}, "
-                        f"compression: {compression_method}, "
-                        f"compressed size: {compressed_size}, "
-                        f"uncompressed size: {uncompressed_size}, "
-                        f"data offset: {data_offset}")
+
+            logger.debug(
+                f"Streaming file {zip_info.filename}, "
+                f"compression: {compression_method}, "
+                f"compressed size: {compressed_size}, "
+                f"uncompressed size: {uncompressed_size}, "
+                f"data offset: {data_offset}"
+            )
     except Exception as e:
         logger.error(f"Error calculating data offset: {str(e)}")
         # Fall back to simple approach if we can't calculate the offset
         with zipfile.ZipFile(BytesIO(zip_tail)) as zf:
             file_content = zf.read(zip_info.filename)
             for i in range(0, len(file_content), chunk_size):
-                yield file_content[i:i + chunk_size]
+                yield file_content[i : i + chunk_size]
         return
-    
+
     # For DEFLATE compression, we need to use zlib to decompress
     if compression_method == zipfile.ZIP_DEFLATED:
         decompressor = zlib.decompressobj(-15)  # -15 for raw deflate data
-        
+
         # Fetch compressed data in chunks and decompress on-the-fly
         # Optimize chunk size based on compression ratio
-        fetch_size = max(64 * 1024, min(1 * 1024 * 1024, int(chunk_size * compressed_size / uncompressed_size)))
-        
+        fetch_size = max(
+            64 * 1024,
+            min(1 * 1024 * 1024, int(chunk_size * compressed_size / uncompressed_size)),
+        )
+
         # Stream the compressed data
         bytes_read = 0
-        buffer = b''  # Buffer for decompressed data
-        
+        buffer = b""  # Buffer for decompressed data
+
         while bytes_read < compressed_size:
             # Calculate the byte range to fetch
             start = data_offset + bytes_read
             end = min(start + fetch_size - 1, data_offset + compressed_size - 1)
             range_header = f"bytes={start}-{end}"
-            
+
             try:
                 # Fetch a chunk of compressed data
                 response = await s3_client.get_object(
                     Bucket=bucket, Key=key, Range=range_header
                 )
-                
+
                 # Read the data chunk
                 chunk = await response["Body"].read()
                 bytes_read += len(chunk)
-                
+
                 # Decompress the chunk
                 if bytes_read >= compressed_size:
                     # Last chunk - use flush
-                    decompressed = buffer + decompressor.decompress(chunk) + decompressor.flush()
+                    decompressed = (
+                        buffer + decompressor.decompress(chunk) + decompressor.flush()
+                    )
                 else:
                     decompressed = buffer + decompressor.decompress(chunk)
-                
+
                 # Yield complete chunks
                 for i in range(0, len(decompressed) - chunk_size + 1, chunk_size):
-                    yield decompressed[i:i + chunk_size]
-                
+                    yield decompressed[i : i + chunk_size]
+
                 # Keep remainder in buffer
-                buffer = decompressed[len(decompressed) - (len(decompressed) % chunk_size):]
-                
+                buffer = decompressed[
+                    len(decompressed) - (len(decompressed) % chunk_size) :
+                ]
+
             except Exception as e:
                 logger.error(f"Error fetching or decompressing chunk: {str(e)}")
                 raise
-        
+
         # Yield any remaining data in the buffer
         if buffer:
             yield buffer
-            
+
     elif compression_method == zipfile.ZIP_STORED:
         # For uncompressed files, directly stream the data
         bytes_read = 0
@@ -559,25 +643,27 @@ async def stream_file_chunks_from_zip(s3_client, bucket, key, zip_info, zip_tail
             start = data_offset + bytes_read
             end = min(start + chunk_size - 1, data_offset + uncompressed_size - 1)
             range_header = f"bytes={start}-{end}"
-            
+
             try:
                 # Fetch a chunk of data
                 response = await s3_client.get_object(
                     Bucket=bucket, Key=key, Range=range_header
                 )
-                
+
                 # Read and yield the data chunk
                 chunk = await response["Body"].read()
                 bytes_read += len(chunk)
                 yield chunk
-                
+
             except Exception as e:
                 logger.error(f"Error fetching chunk: {str(e)}")
                 raise
     else:
         # For other compression methods, fall back to the zipfile module
-        logger.info(f"Unsupported compression method {compression_method}, falling back to zipfile module")
+        logger.info(
+            f"Unsupported compression method {compression_method}, falling back to zipfile module"
+        )
         with zipfile.ZipFile(BytesIO(zip_tail)) as zf:
             file_content = zf.read(zip_info.filename)
             for i in range(0, len(file_content), chunk_size):
-                yield file_content[i:i + chunk_size] 
\ No newline at end of file
+                yield file_content[i : i + chunk_size]
diff --git a/requirements.txt b/requirements.txt
index 3ec50d6a8..93629b091 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,9 +1,9 @@
 aioboto3==13.1.1
 aiofiles==23.2.1
-websockets==13.1
+websockets==14.0
 base58==2.1.1
-fastapi==0.115.8
-hypha-rpc==0.20.51
+fastapi==0.106.0
+hypha-rpc==0.20.54
 jinja2==3.1.4
 lxml==4.9.3
 msgpack==1.0.8
@@ -36,7 +36,6 @@ alembic==1.14.0
 hrid==0.2.4
 ollama==0.3.3
 fastembed==0.4.2
-asgiproxy==0.1.1
 stream-zip==0.0.83
 greenlet==3.1.1
 prompt-toolkit==3.0.50
diff --git a/setup.py b/setup.py
index a149cec69..d78526e48 100644
--- a/setup.py
+++ b/setup.py
@@ -11,9 +11,10 @@
 )
 
 REQUIREMENTS = [
+    "websockets>=14.0",
     "aiofiles",
     "fastapi>=0.70.0,<=0.106.0",
-    "hypha-rpc>=0.20.51",
+    "hypha-rpc>=0.20.54",
     "msgpack>=1.0.2",
     "numpy",
     "pydantic[email]>=2.6.1",
@@ -45,7 +46,6 @@
     "sqlmodel>=0.0.22",
     "alembic>=1.14.0",
     "hrid>=0.2.4",
-    "asgiproxy>=0.1.1",
     "stream-zip>=0.0.83",
     "prompt-toolkit>=3.0.50",
     "ptpython>=3.0.29",
@@ -77,7 +77,7 @@
             "aiobotocore>=2.1.0",
         ],
         "server-apps": [
-            "redis>=5.2.0",
+            "redis==5.2.0",
             "aiobotocore>=2.1.0",
             "aiortc>=1.9.0",
             "requests>=2.26.0",
diff --git a/tests/conftest.py b/tests/conftest.py
index ea9742c8a..be89ec6dc 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -125,7 +125,7 @@ def generate_authenticated_user_6():
 def generate_authenticated_user_7():
     """Generate a test user token."""
     yield from _generate_token("user-7", [])
-    
+
 
 @pytest_asyncio.fixture(name="test_user_token_8", scope="session")
 def generate_authenticated_user_8():
@@ -133,6 +133,12 @@ def generate_authenticated_user_8():
     yield from _generate_token("user-8", [])
 
 
+@pytest_asyncio.fixture(name="test_user_token_9", scope="session")
+def generate_authenticated_user_9():
+    """Generate a test user token."""
+    yield from _generate_token("user-8", [])
+
+
 @pytest_asyncio.fixture(name="triton_server", scope="session")
 def triton_server():
     """Start a triton server as test fixture and tear down after test."""
@@ -353,6 +359,7 @@ def fastapi_server_sqlite_fixture(minio_server):
             f"--port={SIO_PORT_SQLITE}",
             "--enable-server-apps",
             "--enable-s3",
+            "--enable-s3-proxy",
             f"--database-uri={db_path}",
             "--migrate-database=head",
             "--reset-redis",
@@ -506,12 +513,12 @@ def minio_server_fixture():
     # Use start_minio_server to manage the Minio instance
     proc, server_url, workdir = start_minio_server(
         executable_path="./bin",  # Specify where executables are/should be downloaded
-        workdir=tempfile.mkdtemp(), # Create a temporary directory for this session
+        workdir=tempfile.mkdtemp(),  # Create a temporary directory for this session
         port=MINIO_PORT,
-        console_port=MINIO_PORT + 1, # Keep console port logic if needed
+        console_port=MINIO_PORT + 1,  # Keep console port logic if needed
         root_user=MINIO_ROOT_USER,
         root_password=MINIO_ROOT_PASSWORD,
-        timeout=10, # Keep timeout
+        timeout=10,  # Keep timeout
     )
 
     if not proc:
@@ -520,16 +527,16 @@ def minio_server_fixture():
     print(f"Minio server started successfully at {server_url}")
     print(f"Minio data directory: {workdir}")
 
-    yield server_url # Yield the URL provided by the function
+    yield server_url  # Yield the URL provided by the function
 
     print("Stopping Minio server...")
     proc.terminate()
     try:
-        proc.wait(timeout=5) # Wait for graceful termination
+        proc.wait(timeout=5)  # Wait for graceful termination
         print("Minio server stopped.")
     except subprocess.TimeoutExpired:
         print("Minio server did not terminate gracefully, killing...")
-        proc.kill() # Force kill if necessary
+        proc.kill()  # Force kill if necessary
     finally:
         # Clean up the temporary directory
         if workdir and os.path.exists(workdir):
diff --git a/tests/test_artifact.py b/tests/test_artifact.py
index 6a504967e..5d9f259c9 100644
--- a/tests/test_artifact.py
+++ b/tests/test_artifact.py
@@ -1007,7 +1007,7 @@ async def test_artifact_filtering(
     )
     assert len(results) == 2
 
-     # Backwards compatibility with version filter
+    # Backwards compatibility with version filter
     # Filter by `stage`: Only staged artifacts should be returned
     results = await artifact_manager.list(
         parent_id=collection.id, filters={"version": "stage"}, mode="AND"
@@ -2347,10 +2347,15 @@ async def test_list_stage_parameter(minio_server, fastapi_server, test_user_toke
     assert names == {"Staged Artifact", "Another Staged"}
 
     # Test 4: stage='all' should show both staged and committed artifacts
-    results = await artifact_manager.list(parent_id=collection.id, stage='all')
+    results = await artifact_manager.list(parent_id=collection.id, stage="all")
     assert len(results) == 4
     names = {r["manifest"]["name"] for r in results}
-    assert names == {"Committed Artifact", "Another Committed", "Staged Artifact", "Another Staged"}
+    assert names == {
+        "Committed Artifact",
+        "Another Committed",
+        "Staged Artifact",
+        "Another Staged",
+    }
 
     # Test 5: Backward compatibility with filters={"version": "stage"}
     results = await artifact_manager.list(
@@ -2440,7 +2445,7 @@ async def test_http_children_endpoint(minio_server, fastapi_server, test_user_to
     assert len(results) == 3
     names = {r["manifest"]["name"] for r in results}
     assert "Staged Artifact" not in names
-    
+
     # Test keyword search
     response = requests.get(
         f"{SERVER_URL}/{api.config.workspace}/artifacts/{collection.alias}/children?keywords=two"
@@ -2460,11 +2465,7 @@ async def test_http_children_endpoint(minio_server, fastapi_server, test_user_to
     assert results[0]["manifest"]["name"] == "Child Artifact 3"
 
     # Test filtering by manifest field (in nested format)
-    filters = {
-        "manifest": {
-            "name": "Child Artifact 1"
-        }
-    }
+    filters = {"manifest": {"name": "Child Artifact 1"}}
     response = requests.get(
         f"{SERVER_URL}/{api.config.workspace}/artifacts/{collection.alias}/children?filters={json.dumps(filters)}"
     )
@@ -2490,20 +2491,20 @@ async def test_http_children_endpoint(minio_server, fastapi_server, test_user_to
     )
     assert response.status_code == 200
     results_asc = response.json()
-    
+
     response = requests.get(
         f"{SERVER_URL}/{api.config.workspace}/artifacts/{collection.alias}/children?order_by=created_at<"
     )
     assert response.status_code == 200
     results_desc = response.json()
-    
+
     # Verify that both queries return the same set of results
     asc_ids = [item["_id"] for item in results_asc]
     desc_ids = [item["_id"] for item in results_desc]
     assert set(asc_ids) == set(desc_ids), "Results should contain the same items"
 
     # Skip checking order difference since artifacts might be created at the same timestamp
-    
+
     # Test no_cache parameter
     # First create a new artifact
     new_child = await artifact_manager.create(
@@ -2514,7 +2515,7 @@ async def test_http_children_endpoint(minio_server, fastapi_server, test_user_to
             "description": "Newly created artifact for testing no_cache",
         },
     )
-    
+
     # Then immediately request with no_cache to ensure it's included
     response = requests.get(
         f"{SERVER_URL}/{api.config.workspace}/artifacts/{collection.alias}/children?no_cache=true"
@@ -2522,7 +2523,7 @@ async def test_http_children_endpoint(minio_server, fastapi_server, test_user_to
     assert response.status_code == 200
     results = response.json()
     assert len(results) == 4  # Should include the new artifact (3 original + 1 new)
-    
+
     # Clean up
     await artifact_manager.delete(artifact_id=child1.id)
     await artifact_manager.delete(artifact_id=child2.id)
@@ -2532,7 +2533,9 @@ async def test_http_children_endpoint(minio_server, fastapi_server, test_user_to
     await artifact_manager.delete(artifact_id=collection.id)
 
 
-async def test_http_children_endpoint_stage_parameter(minio_server, fastapi_server, test_user_token):
+async def test_http_children_endpoint_stage_parameter(
+    minio_server, fastapi_server, test_user_token
+):
     """Test the stage parameter functionality in HTTP endpoint for listing child artifacts."""
     api = await connect_to_server(
         {"name": "test-client", "server_url": SERVER_URL, "token": test_user_token}
@@ -2673,7 +2676,9 @@ async def test_get_zip_file_content_endpoint_large_scale(
 
     # Create a ZIP file in memory with 2000 files in various directories
     zip_buffer = BytesIO()
-    with ZipFile(zip_buffer, "w", compression=zipfile.ZIP_DEFLATED, compresslevel=1) as zip_file:
+    with ZipFile(
+        zip_buffer, "w", compression=zipfile.ZIP_DEFLATED, compresslevel=1
+    ) as zip_file:
         # Create files in root directory
         for i in range(100):
             zip_file.writestr(f"root_file_{i}.txt", f"Content of root file {i}")
@@ -2688,7 +2693,9 @@ async def test_get_zip_file_content_endpoint_large_scale(
             # Add some larger files (10 per directory)
             for large_file_num in range(10):
                 file_path = f"dir_{dir_num}/large_file_{large_file_num}.txt"
-                content = f"Large content repeated many times {large_file_num}" * 100  # Reduced content size
+                content = (
+                    f"Large content repeated many times {large_file_num}" * 100
+                )  # Reduced content size
                 zip_file.writestr(file_path, content)
 
     zip_buffer.seek(0)
@@ -2701,7 +2708,7 @@ async def test_get_zip_file_content_endpoint_large_scale(
         file_path=f"{zip_file_path}.zip",
         download_weight=1,
     )
-    
+
     # Upload in multiple chunks to ensure that the S3 implementation handles it properly
     chunk_size = 1024 * 1024  # 1MB chunks
     async with httpx.AsyncClient(timeout=300) as client:
@@ -2723,7 +2730,7 @@ async def test_get_zip_file_content_endpoint_large_scale(
         root_files = [item for item in items if item["type"] == "file"]
         root_dirs = [item for item in items if item["type"] == "directory"]
         assert len(root_files) == 100  # 100 files in root
-        assert len(root_dirs) == 10    # 10 directories
+        assert len(root_dirs) == 10  # 10 directories
 
     # Test listing a specific directory
     async with httpx.AsyncClient(timeout=300) as client:
diff --git a/tests/test_asgi.py b/tests/test_asgi.py
index 0a9db1742..33b5a07ad 100644
--- a/tests/test_asgi.py
+++ b/tests/test_asgi.py
@@ -336,11 +336,8 @@ async def stream_generator():
             for i in range(5):
                 yield f"chunk {i}\n".encode()
                 await asyncio.sleep(0.1)
-        
-        return StreamingResponse(
-            stream_generator(),
-            media_type="text/plain"
-        )
+
+        return StreamingResponse(stream_generator(), media_type="text/plain")
 
     api = await connect_to_server(
         {"name": "test client", "server_url": WS_SERVER_URL, "token": test_user_token}
@@ -364,7 +361,7 @@ async def serve_fastapi(args):
 
     # Test with httpx streaming client
     url = f"{SERVER_URL}/{workspace}/apps/test-streaming/stream"
-    
+
     # Test chunked transfer with streaming client
     async with httpx.AsyncClient() as client:
         chunks = []
@@ -372,16 +369,16 @@ async def serve_fastapi(args):
             assert response.headers.get("transfer-encoding") == "chunked"
             async for chunk in response.aiter_bytes():
                 chunks.append(chunk.decode())
-    
+
     # Verify that we received 5 chunks
     assert len(chunks) > 1  # Might be coalesced but should be more than one
     complete_response = "".join(chunks)
     assert "chunk 0" in complete_response
     assert "chunk 4" in complete_response
-    
+
     # Check all expected chunks are in the response
     for i in range(5):
         assert f"chunk {i}" in complete_response
-    
+
     # Clean up
     await api.disconnect()
diff --git a/tests/test_s3.py b/tests/test_s3.py
index 937539058..7bd58f21e 100644
--- a/tests/test_s3.py
+++ b/tests/test_s3.py
@@ -21,18 +21,18 @@
     UserPermission,
 )
 
-from . import WS_SERVER_URL, SERVER_URL, find_item
+from . import WS_SERVER_URL, SERVER_URL, SIO_PORT_SQLITE, find_item
 
 # All test coroutines will be treated as marked.
 pytestmark = pytest.mark.asyncio
 
 
-async def test_s3_proxy(minio_server, fastapi_server, test_user_token):
+async def test_s3_proxy(minio_server, fastapi_server_sqlite, test_user_token):
     """Test s3 proxy."""
     api = await connect_to_server(
         {
             "name": "anonymous client",
-            "server_url": WS_SERVER_URL,
+            "server_url": f"ws://127.0.0.1:{SIO_PORT_SQLITE}/ws",
             "token": test_user_token,
         }
     )
@@ -52,6 +52,8 @@ async def test_s3_proxy(minio_server, fastapi_server, test_user_token):
     presigned_url = await s3controller.generate_presigned_url(
         f"apps/test.zip", client_method="put_object"
     )
+    # Ensure we're testing the S3 proxy, not direct MinIO access
+    assert "/s3/" in presigned_url, "Presigned URL should be a proxy URL"
     # Use requests to upload the ZIP file to the presigned URL
     response = requests.put(
         presigned_url,
@@ -64,6 +66,8 @@ async def test_s3_proxy(minio_server, fastapi_server, test_user_token):
     presigned_url = await s3controller.generate_presigned_url(
         f"apps/test.zip", client_method="get_object"
     )
+    # Ensure we're testing the S3 proxy, not direct MinIO access
+    assert "/s3/" in presigned_url, "Presigned URL should be a proxy URL"
     response = requests.get(presigned_url)
     assert response.status_code == 200
     assert response.content == zip_buffer.getvalue()
@@ -80,6 +84,8 @@ async def test_s3_proxy(minio_server, fastapi_server, test_user_token):
     presigned_url = await s3controller.generate_presigned_url(
         f"apps/test.zip", client_method="get_object"
     )
+    # Ensure we're testing the S3 proxy, not direct MinIO access
+    assert "/s3/" in presigned_url, "Presigned URL should be a proxy URL"
     response = requests.get(presigned_url)
     assert response.status_code == 200
     assert response.content == zip_buffer.getvalue()
@@ -249,6 +255,8 @@ def test_file_requests():
 
         url = await s3controller.generate_presigned_url("hello.txt")
         assert url.startswith("http") and "X-Amz-Algorithm" in url
+        # Ensure we're testing the S3 proxy, not direct MinIO access
+        assert "/s3/" in url, "Presigned URL should be a proxy URL"
 
         response = requests.get(url)
         assert response.ok, response.text
diff --git a/tests/test_services.py b/tests/test_services.py
index d4bc0e02e..0797b7294 100644
--- a/tests/test_services.py
+++ b/tests/test_services.py
@@ -259,3 +259,141 @@ async def test_list_service_types(fastapi_server):
     assert len(service_types) == 2
     assert any(st["id"] == service_type_info_1["id"] for st in service_types)
     assert any(st["id"] == service_type_info_2["id"] for st in service_types)
+
+async def test_simple_select_service_syntax(fastapi_server, test_user_token):
+    """Test the simple select service syntax: select:criteria:function."""
+    import asyncio
+    import time
+    
+    # Create multiple service instances with different characteristics
+    class SimpleService:
+        def __init__(self, instance_id: str, load_value: float = 0.0):
+            self.instance_id = instance_id
+            self.load_value = load_value
+            self.cpu_usage = load_value * 100  # Convert to percentage
+            self.priority = 10 - load_value * 10  # Higher load = lower priority
+        
+        async def get_load(self):
+            """Return current load as a simple number."""
+            return self.load_value
+        
+        async def get_cpu_usage(self):
+            """Return CPU usage percentage."""
+            return self.cpu_usage
+        
+        async def get_priority(self):
+            """Return priority score."""
+            return self.priority
+        
+        async def process_task(self, task_data: str):
+            """Process a task."""
+            return f"Task '{task_data}' completed by service {self.instance_id}"
+    
+    # Create service instances with different load values
+    service_a = SimpleService("A", 0.1)  # Low load
+    service_b = SimpleService("B", 0.5)  # Medium load  
+    service_c = SimpleService("C", 0.8)  # High load
+    
+    # Register service instances
+    async with connect_to_server(
+        {"name": "simple-test-client-a", "server_url": SERVER_URL, "token": test_user_token}
+    ) as api_a:
+        await api_a.register_service({
+            "id": "simple-select-service",
+            "name": "Simple Service Instance A",
+            "get_load": service_a.get_load,
+            "get_cpu_usage": service_a.get_cpu_usage,
+            "get_priority": service_a.get_priority,
+            "process_task": service_a.process_task,
+        })
+        
+        async with connect_to_server(
+            {"name": "simple-test-client-b", "server_url": SERVER_URL, "token": test_user_token}
+        ) as api_b:
+            await api_b.register_service({
+                "id": "simple-select-service",
+                "name": "Simple Service Instance B", 
+                "get_load": service_b.get_load,
+                "get_cpu_usage": service_b.get_cpu_usage,
+                "get_priority": service_b.get_priority,
+                "process_task": service_b.process_task,
+            })
+            
+            async with connect_to_server(
+                {"name": "simple-test-client-c", "server_url": SERVER_URL, "token": test_user_token}
+            ) as api_c:
+                await api_c.register_service({
+                    "id": "simple-select-service",
+                    "name": "Simple Service Instance C",
+                    "get_load": service_c.get_load,
+                    "get_cpu_usage": service_c.get_cpu_usage,
+                    "get_priority": service_c.get_priority,
+                    "process_task": service_c.process_task,
+                })
+                
+                # Wait for services to register
+                await asyncio.sleep(0.5)
+                
+                # Create a client to test the new syntax
+                async with connect_to_server(
+                    {"name": "simple-select-client", "server_url": SERVER_URL, "token": test_user_token}
+                ) as client_api:
+                    
+                    print("Testing simple select syntax...")
+                    
+                    # Test 1: select:min:get_load (should select service A - lowest load)
+                    print("\n1. Testing select:min:get_load")
+                    for i in range(5):
+                        service = await client_api.get_service(
+                            "simple-select-service",
+                            mode="select:min:get_load"
+                        )
+                        result = await service.process_task(f"min-load-task-{i}")
+                        print(f"  {result}")
+                        # Should consistently select service A (lowest load)
+                        assert "service A" in result
+                    
+                    # Test 2: select:max:get_load (should select service C - highest load)
+                    print("\n2. Testing select:max:get_load")
+                    for i in range(3):
+                        service = await client_api.get_service(
+                            "simple-select-service",
+                            mode="select:max:get_load"
+                        )
+                        result = await service.process_task(f"max-load-task-{i}")
+                        print(f"  {result}")
+                        # Should consistently select service C (highest load)
+                        assert "service C" in result
+                    
+                    # Test 3: select:max:get_priority (should select service A - highest priority)
+                    print("\n3. Testing select:max:get_priority")
+                    for i in range(3):
+                        service = await client_api.get_service(
+                            "simple-select-service",
+                            mode="select:max:get_priority"
+                        )
+                        result = await service.process_task(f"max-priority-task-{i}")
+                        print(f"  {result}")
+                        # Should consistently select service A (highest priority)
+                        assert "service A" in result
+                    
+                    # Test 4: select:min:get_cpu_usage (should select service A - lowest CPU)
+                    print("\n4. Testing select:min:get_cpu_usage")
+                    service = await client_api.get_service(
+                        "simple-select-service",
+                        mode="select:min:get_cpu_usage"
+                    )
+                    result = await service.process_task("min-cpu-task")
+                    print(f"  {result}")
+                    assert "service A" in result
+                    
+                    # Test 5: first_success criteria
+                    print("\n5. Testing select:first_success:get_load")
+                    service = await client_api.get_service(
+                        "simple-select-service",
+                        mode="select:first_success:get_load"
+                    )
+                    result = await service.process_task("first-success-task")
+                    print(f"  {result}")
+                    # Should work with any service that responds first
+                    assert "service" in result
diff --git a/tests/test_vectors.py b/tests/test_vectors.py
index d031ab4e1..91d9c2d8d 100644
--- a/tests/test_vectors.py
+++ b/tests/test_vectors.py
@@ -188,7 +188,7 @@ async def test_delete_collection(vector_search_engine):
 
 
 async def test_artifact_vector_collection(
-    minio_server, fastapi_server_redis_1, test_user_token
+    minio_server, fastapi_server_redis_1, test_user_token_9
 ):
     """Test vector-related functions within a vector-collection artifact."""
 
@@ -197,7 +197,7 @@ async def test_artifact_vector_collection(
         {
             "name": "test deploy client",
             "server_url": SERVER_URL_REDIS_1,
-            "token": test_user_token,
+            "token": test_user_token_9,
         }
     ) as api:
         await api.create_workspace(
@@ -213,7 +213,7 @@ async def test_artifact_vector_collection(
         {
             "name": "test deploy client",
             "server_url": SERVER_URL_REDIS_1,
-            "token": test_user_token,
+            "token": test_user_token_9,
             "workspace": "my-vector-test-workspace",
         }
     ) as api:
diff --git a/tests/test_workspace.py b/tests/test_workspace.py
index cf7491202..c3e0ee111 100644
--- a/tests/test_workspace.py
+++ b/tests/test_workspace.py
@@ -164,7 +164,6 @@ async def test_create_workspace_token(fastapi_server, test_user_token):
 
     print(f"Workspace created: {workspace['name']}")
 
-
     # Generate a workspace token
     token = await user.generate_token(
         {
diff --git a/utils/__init__.py b/utils/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/utils/artifact_model.py b/utils/artifact_model.py
new file mode 100644
index 000000000..1f17c3f54
--- /dev/null
+++ b/utils/artifact_model.py
@@ -0,0 +1,26 @@
+from typing import Optional
+from sqlmodel import Field, SQLModel
+from sqlalchemy import Column, JSON, UniqueConstraint
+
+
+class ArtifactModel(SQLModel, table=True):
+    __tablename__ = "artifacts"
+    id: str = Field(primary_key=True)
+    type: Optional[str] = Field(default=None)
+    workspace: str = Field(index=True)
+    parent_id: Optional[str] = Field(default=None)
+    alias: Optional[str] = Field(default=None)
+    manifest: Optional[dict] = Field(default=None, sa_column=Column(JSON))
+    staging: Optional[list] = Field(default=None, sa_column=Column(JSON))
+    download_count: float = Field(default=0.0)
+    view_count: float = Field(default=0.0)
+    file_count: int = Field(default=0)
+    created_at: int = Field()
+    created_by: Optional[str] = Field(default=None)
+    last_modified: int = Field()
+    versions: Optional[list] = Field(default=None, sa_column=Column(JSON))
+    config: Optional[dict] = Field(default=None, sa_column=Column(JSON))
+    secrets: Optional[dict] = Field(default=None, sa_column=Column(JSON))
+    __table_args__ = (
+        UniqueConstraint("workspace", "alias", name="_workspace_alias_uc"),
+    )
diff --git a/utils/backup_database.py b/utils/backup_database.py
new file mode 100644
index 000000000..b16fa7d9a
--- /dev/null
+++ b/utils/backup_database.py
@@ -0,0 +1,179 @@
+import asyncio
+import argparse
+from collections import defaultdict, deque
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker
+from sqlalchemy import text
+from typing import List, Optional
+from sqlalchemy import Column, JSON, UniqueConstraint, select
+from sqlmodel import SQLModel, Field
+from datetime import datetime
+
+
+# --- Model ---
+class ArtifactModel(SQLModel, table=True):
+    __tablename__ = "artifacts"
+    id: str = Field(primary_key=True)
+    type: Optional[str] = Field(default=None)
+    workspace: str = Field(index=True)
+    parent_id: Optional[str] = Field(default=None)
+    alias: Optional[str] = Field(default=None)
+    manifest: Optional[dict] = Field(default=None, sa_column=Column(JSON))
+    staging: Optional[list] = Field(default=None, sa_column=Column(JSON))
+    download_count: float = Field(default=0.0)
+    view_count: float = Field(default=0.0)
+    file_count: int = Field(default=0)
+    created_at: int = Field()
+    created_by: Optional[str] = Field(default=None)
+    last_modified: int = Field()
+    versions: Optional[list] = Field(default=None, sa_column=Column(JSON))
+    config: Optional[dict] = Field(default=None, sa_column=Column(JSON))
+    secrets: Optional[dict] = Field(default=None, sa_column=Column(JSON))
+    __table_args__ = (
+        UniqueConstraint("workspace", "alias", name="_workspace_alias_uc"),
+    )
+
+
+def setup_engines(pg_uri: str, sqlite_prefix: str):
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    sqlite_path = f"./{sqlite_prefix}-{timestamp}.db"
+
+    print(f"📦 Backup SQLite DB will be stored at: {sqlite_path}")
+
+    # Globalize engine/session variables
+    global pg_engine, pg_session_maker
+    global sqlite_engine, sqlite_session_maker
+
+    pg_engine = create_async_engine(pg_uri, echo=False)
+    pg_session_maker = async_sessionmaker(
+        pg_engine, class_=AsyncSession, expire_on_commit=False
+    )
+
+    sqlite_engine = create_async_engine(
+        f"sqlite+aiosqlite:///{sqlite_path}", echo=False
+    )
+    sqlite_session_maker = async_sessionmaker(
+        sqlite_engine, class_=AsyncSession, expire_on_commit=False
+    )
+
+
+def build_dependency_graph(artifacts):
+    graph = defaultdict(list)
+    indegree = defaultdict(int)
+    id_map = {a.id: a for a in artifacts}
+
+    for a in artifacts:
+        if a.parent_id and a.parent_id in id_map:
+            graph[a.parent_id].append(a.id)
+            indegree[a.id] += 1
+        else:
+            indegree[a.id] = indegree.get(a.id, 0)
+
+    return graph, indegree, id_map
+
+
+def topological_sort_artifacts(artifacts):
+    graph, indegree, id_map = build_dependency_graph(artifacts)
+    queue = deque([aid for aid, deg in indegree.items() if deg == 0])
+    ordered = []
+
+    while queue:
+        aid = queue.popleft()
+        ordered.append(id_map[aid])
+        for neighbor in graph[aid]:
+            indegree[neighbor] -= 1
+            if indegree[neighbor] == 0:
+                queue.append(neighbor)
+
+    return ordered
+
+
+def clean_artifact(a: ArtifactModel) -> ArtifactModel:
+    return ArtifactModel(
+        id=a.id,
+        type=a.type,
+        workspace=a.workspace,
+        parent_id=a.parent_id,
+        alias=a.alias,
+        manifest=a.manifest,
+        staging=a.staging,
+        download_count=a.download_count,
+        view_count=a.view_count,
+        file_count=a.file_count,
+        created_at=a.created_at,
+        created_by=a.created_by,
+        last_modified=a.last_modified,
+        versions=a.versions,
+        config=a.config,
+        secrets=a.secrets,
+    )
+
+
+async def init_sqlite_db():
+    async with sqlite_engine.begin() as conn:
+        await conn.run_sync(SQLModel.metadata.create_all)
+
+
+async def backup_artifacts_to_sqlite():
+    async with pg_session_maker() as pg_session:
+        result = await pg_session.execute(select(ArtifactModel))
+        all_artifacts = result.scalars().all()
+
+    ordered = topological_sort_artifacts(all_artifacts)
+    print(f"Backing up {len(ordered)} artifacts to SQLite...")
+
+    async with sqlite_session_maker() as sqlite_session:
+        async with sqlite_session.begin():
+            for a in ordered:
+                try:
+                    clean = clean_artifact(a)
+                    sqlite_session.add(clean)
+                except Exception as e:
+                    print(f"⚠️ Failed to backup {a.id} ({a.alias}): {e}")
+        await sqlite_session.commit()
+
+    print("✅ Backup to SQLite completed.")
+
+
+async def verify_migration_counts():
+    async with pg_session_maker() as pg_session:
+        pg_result = await pg_session.execute(select(ArtifactModel))
+        pg_count = len(pg_result.scalars().all())
+
+    async with sqlite_session_maker() as sqlite_session:
+        sqlite_result = await sqlite_session.execute(select(ArtifactModel))
+        sqlite_count = len(sqlite_result.scalars().all())
+
+    print("📊 Migration Verification Summary")
+    print(f" - PostgreSQL artifact count: {pg_count}")
+    print(f" - SQLite artifact count:     {sqlite_count}")
+
+    if pg_count == sqlite_count:
+        print("✅ Verification passed: Record counts match.")
+    else:
+        print("❌ Verification failed: Mismatched record counts.")
+
+
+async def main(pg_uri: str, sqlite_prefix: str):
+    setup_engines(pg_uri, sqlite_prefix)
+    await init_sqlite_db()
+    await backup_artifacts_to_sqlite()
+    await verify_migration_counts()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Backup PostgreSQL artifacts table to SQLite."
+    )
+    parser.add_argument(
+        "--database-uri",
+        required=True,
+        help="PostgreSQL database URI (e.g., postgresql+asyncpg://user:pass@host/db)",
+    )
+    parser.add_argument(
+        "--database-name",
+        default="hypha-app-backup",
+        help="Prefix for the SQLite backup file (default: hypha-app-backup)",
+    )
+
+    args = parser.parse_args()
+    asyncio.run(main(args.database_uri, args.database_name))
diff --git a/utils/constants.py b/utils/constants.py
new file mode 100644
index 000000000..4040066d6
--- /dev/null
+++ b/utils/constants.py
@@ -0,0 +1,20 @@
+ENV_FILE = ".env"
+DATABASE_PATH = "./hypha-app-database.db"
+LOGLEVEL = "DEBUG"
+S3_BUCKET = "hypha-workspaces"
+ADDITIONAL_ENV_FILES = ["bioimageio_env", "shareloc_env"]
+ADDITIONAL_ENV_KEYS = [
+    "SANDBOX_ZENODO_ACCESS_TOKEN",
+    "ZENODO_ACCESS_TOKEN",
+    "S3_ENDPOINT_URL",
+    "S3_ACCESS_KEY_ID",
+    "S3_SECRET_ACCESS_KEY",
+    "S3_REGION_NAME",
+    "S3_PREFIX",
+    "S3_BUCKET",
+]
+DATABASE_URI = f"sqlite+aiosqlite:///{DATABASE_PATH}"
+DATABASE_URL = ""
+DB_USER_DEFAULT = "hypha-admin"
+DB_NAME_DEFAULT = "hypha-db"
+DB_PORT_DEFAULT = "5432"
diff --git a/utils/extra-artifact-actions.py b/utils/extra-artifact-actions.py
new file mode 100644
index 000000000..cdd8c720e
--- /dev/null
+++ b/utils/extra-artifact-actions.py
@@ -0,0 +1,700 @@
+import asyncio
+from datetime import datetime
+from sqlalchemy import select, text, or_, and_
+from sqlalchemy.ext.asyncio import (
+    AsyncSession,
+    async_sessionmaker,
+    create_async_engine,
+)
+from sqlmodel import SQLModel
+from utils.artifact_model import ArtifactModel
+from utils.constants import (
+    DATABASE_URI,
+    DATABASE_URL,
+    DB_USER_DEFAULT,
+    DB_NAME_DEFAULT,
+    DB_PORT_DEFAULT,
+)
+
+engine = create_async_engine(DATABASE_URI, echo=False)
+session_maker = async_sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
+
+# PostgreSQL engine and session
+pg_engine = create_async_engine(DATABASE_URL, echo=False)
+pg_session_maker = async_sessionmaker(
+    pg_engine, expire_on_commit=False, class_=AsyncSession
+)
+pg_engine_local = create_async_engine(
+    DATABASE_URI, echo=False  # Set echo to False to reduce output
+)
+pg_session_maker_local = async_sessionmaker(
+    pg_engine_local, expire_on_commit=False, class_=AsyncSession
+)
+
+
+async def get_artifact(workspace: str, alias: str):
+    async with session_maker() as session:
+        stmt = select(ArtifactModel).where(
+            ArtifactModel.workspace == workspace, ArtifactModel.alias == alias
+        )
+        result = await session.exec(stmt)
+        return result.one_or_none()
+
+
+async def list_children(parent_id: str):
+    async with session_maker() as session:
+        stmt = select(ArtifactModel).where(ArtifactModel.parent_id == parent_id)
+        children = await session.exec(stmt)
+        children = children.all()
+        print(f"🔗 Found {len(children)} child artifacts:")
+        for child in children:
+            print(
+                f" - {child.alias} ({child.id}), workspace: {child.workspace}, file_count: {child.file_count}, last_modified: {datetime.utcfromtimestamp(child.last_modified).isoformat()}"
+            )
+
+
+async def inspect_collection(workspace: str, alias: str):
+    print(f"🔍 Inspecting: {workspace}/{alias}")
+    artifact = await get_artifact(workspace, alias)
+    if not artifact:
+        print("❌ Artifact not found.")
+        return
+
+    print(f"🧬 ID: {artifact.id}")
+    print(f"📦 Created at: {datetime.utcfromtimestamp(artifact.created_at)}")
+    print(f"🛠️  File count: {artifact.file_count}")
+    print(f"👤 Created by: {artifact.created_by}")
+    print(
+        f"📝 Manifest name: {artifact.manifest.get('name') if artifact.manifest else 'N/A'}"
+    )
+    print(f"📅 Last modified: {datetime.utcfromtimestamp(artifact.last_modified)}")
+
+    await list_children(artifact.id)
+
+
+# Replace with your PostgreSQL session maker
+async def test_raw_list_children(parent_id: str):
+    async with pg_session_maker() as session:
+        print(f"🔍 Looking for children of artifact: {parent_id}")
+
+        query = select(ArtifactModel).where(ArtifactModel.parent_id == parent_id)
+        result = await session.execute(query)
+        children = result.scalars().all()
+
+        print(f"✅ Found {len(children)} children")
+        for a in children[:10]:  # Preview first 10
+            created = (
+                datetime.utcfromtimestamp(a.created_at).isoformat()
+                if a.created_at
+                else "?"
+            )
+            print(
+                f" - {a.id}: {a.alias} (created: {created}, file_count: {a.file_count})"
+            )
+
+
+async def list_children_test(
+    session: AsyncSession, parent_alias: str, workspace: str
+) -> list[ArtifactModel]:
+    """
+    Test function to list children artifacts for a given parent alias in a workspace.
+    """
+    # Step 1: Get the parent artifact
+    result = await session.execute(
+        select(ArtifactModel).where(
+            ArtifactModel.alias == parent_alias, ArtifactModel.workspace == workspace
+        )
+    )
+    parent = result.scalar_one_or_none()
+
+    if not parent:
+        print(f"❌ Parent artifact not found: {workspace}/{parent_alias}")
+        return []
+
+    print(f"📁 Found parent artifact: {parent.id} ({parent.alias})")
+
+    # Step 2: Get children artifacts
+    result = await session.execute(
+        select(ArtifactModel).where(ArtifactModel.parent_id == parent.id)
+    )
+    children = result.scalars().all()
+
+    print(f"🔍 Found {len(children)} children artifacts for {parent.alias}:")
+    for child in children:
+        created_at = datetime.datetime.fromtimestamp(child.created_at).isoformat()
+        print(
+            f" - {child.id}: {child.alias} (created: {created_at}, file_count: {child.file_count})"
+        )
+
+    return children
+
+
+async def debug_list_children_like(
+    parent_id: str, stage=None, keyword=None, config_permission_filter=None
+):
+    async with pg_session_maker() as session:
+        print(f"🔍 Testing children of parent: {parent_id}")
+        backend = pg_engine.dialect.name
+        query = select(ArtifactModel).where(ArtifactModel.parent_id == parent_id)
+
+        # Simulate `stage` filter
+        if stage is not None:
+            print(f"⚙️ Adding stage filter: {stage}")
+            if stage:
+                query = query.where(
+                    and_(
+                        ArtifactModel.staging.isnot(None),
+                        text("staging::text != 'null'"),
+                    )
+                )
+            else:
+                query = query.where(
+                    or_(ArtifactModel.staging.is_(None), text("staging::text = 'null'"))
+                )
+
+        # Simulate keyword filter
+        if keyword:
+            print(f"🔍 Adding keyword filter: '{keyword}'")
+            query = query.where(text(f"manifest::text ILIKE '%{keyword}%'"))
+
+        # Simulate config.permissions filter
+        if config_permission_filter:
+            print(f"🔐 Adding permission filter: {config_permission_filter}")
+            for user_id, permission in config_permission_filter.items():
+                condition = text(
+                    f"config->'permissions'->>'{user_id}' = '{permission}'"
+                )
+                query = query.where(condition)
+
+        query = query.order_by(ArtifactModel.created_at.asc()).limit(10)
+        result = await session.execute(query)
+        children = result.scalars().all()
+
+        print(f"✅ Found {len(children)} children")
+        for a in children:
+            created = datetime.utcfromtimestamp(a.created_at).isoformat()
+            print(
+                f" - {a.id}: {a.alias} (created: {created}, file_count: {a.file_count})"
+            )
+
+
+async def test_pg_list_children(parent_id: str, stage: bool = None, limit: int = 10):
+    print(f"\n🔍 Looking for children of artifact: {parent_id}")
+    async with pg_session_maker() as session:
+        stmt = select(ArtifactModel).where(ArtifactModel.parent_id == parent_id)
+
+        # Safe cross-database filter on staging status
+        if stage is True:
+            stmt = stmt.where(ArtifactModel.staging.isnot(None))
+        elif stage is False:
+            stmt = stmt.where(ArtifactModel.staging.is_(None))
+
+        stmt = stmt.order_by(ArtifactModel.created_at.asc()).limit(limit)
+
+        result = await session.execute(stmt)
+        children = result.scalars().all()
+
+        print(f"✅ Found {len(children)} children")
+        for a in children:
+            ts = datetime.fromtimestamp(a.created_at).isoformat()
+            print(f" - {a.id}: {a.alias} (created: {ts}, file_count: {a.file_count})")
+
+
+async def list_children_pg_test(
+    parent_id: str,
+    workspace: str,
+    keywords: list = None,
+    filters: dict = None,
+    stage: bool = None,
+    order_by: str = "created_at<",
+    limit: int = 10,
+    offset: int = 0,
+):
+    print(f"\n🔍 Looking for children of artifact: {parent_id}")
+    # PostgreSQL engine and session
+    pg_engine = create_async_engine(DATABASE_URL, echo=False)
+    print(DATABASE_URL)
+    pg_session_maker = async_sessionmaker(
+        pg_engine, expire_on_commit=False, class_=AsyncSession
+    )
+
+    async with pg_session_maker() as session:
+        query = select(ArtifactModel).where(ArtifactModel.parent_id == parent_id)
+        conditions = []
+
+        # 🔍 Keyword matching (manifest text search)
+        if keywords:
+            for keyword in keywords:
+                conditions.append(text(f"manifest::text ILIKE '%{keyword}%'"))
+
+        # 🎯 Filter matching
+        if filters:
+            for key, value in filters.items():
+                if key == "type":
+                    conditions.append(ArtifactModel.type == value)
+                elif key == "created_by":
+                    conditions.append(ArtifactModel.created_by == value)
+                elif key == "alias":
+                    conditions.append(ArtifactModel.alias == value)
+                elif key == "manifest" and isinstance(value, dict):
+                    for k, v in value.items():
+                        conditions.append(text(f"manifest->>'{k}' = '{v}'"))
+                elif key == "config" and isinstance(value, dict):
+                    for k, v in value.items():
+                        conditions.append(text(f"config->>'{k}' = '{v}'"))
+
+        # ✅ Stage filter (PostgreSQL-safe)
+        if stage is not None:
+            if stage:
+                stage_condition = and_(
+                    ArtifactModel.staging.isnot(None), text("staging::text != 'null'")
+                )
+            else:
+                stage_condition = or_(
+                    ArtifactModel.staging.is_(None), text("staging::text = 'null'")
+                )
+            conditions.append(stage_condition)
+
+        # Combine all conditions
+        if conditions:
+            query = query.where(and_(*conditions))
+
+        # Sort order parsing
+        order_field_map = {
+            "id": ArtifactModel.id,
+            "created_at": ArtifactModel.created_at,
+            "last_modified": ArtifactModel.last_modified,
+            "download_count": ArtifactModel.download_count,
+            "view_count": ArtifactModel.view_count,
+        }
+        field_name = order_by.split("<")[0]
+        ascending = "<" in order_by
+        order_field = order_field_map.get(field_name, ArtifactModel.created_at)
+        query = query.order_by(order_field.asc() if ascending else order_field.desc())
+        query = query.limit(limit).offset(offset)
+
+        # Execute and format result
+        result = await session.execute(query)
+        children = result.scalars().all()
+
+        print(f"✅ Found {len(children)} children")
+        for a in children:
+            ts = datetime.fromtimestamp(a.created_at).isoformat()
+            print(f" - {a.id}: {a.alias} (created: {ts}, file_count: {a.file_count})")
+
+
+# TODO: use pg_engine_local from here
+
+
+async def check_database_stats(a_session_maker):
+    """Query the database and display table statistics without writing data"""
+    print("🔍 Checking PostgreSQL database status...")
+
+    try:
+        async with a_session_maker() as session:
+            # Get list of all tables
+            result = await session.execute(
+                text("SELECT tablename FROM pg_tables WHERE schemaname = 'public'")
+            )
+            tables = result.scalars().all()
+
+            print(f"📊 Database contains {len(tables)} tables:")
+            for table in tables:
+                print(f"  - {table}")
+
+                # Get count of rows per table
+                count_query = text(f"SELECT COUNT(*) FROM {table}")
+                count_result = await session.execute(count_query)
+                row_count = count_result.scalar()
+                print(f"    • Rows: {row_count}")
+
+                # Get table size
+                size_query = text(
+                    f"SELECT pg_size_pretty(pg_total_relation_size('{table}'))"
+                )
+                size_result = await session.execute(size_query)
+                table_size = size_result.scalar()
+                print(f"    • Size: {table_size}")
+
+                # If it's the artifacts table and it exists, show some stats
+                if table == "artifacts":
+                    # Count by workspace
+                    try:
+                        workspace_query = text(
+                            "SELECT workspace, COUNT(*) FROM artifacts GROUP BY workspace"
+                        )
+                        workspace_result = await session.execute(workspace_query)
+                        workspace_counts = workspace_result.all()
+
+                        if workspace_counts:
+                            print(f"    • Artifacts by workspace:")
+                            for workspace, count in workspace_counts:
+                                print(f"      - {workspace}: {count} artifacts")
+                    except Exception as e:
+                        print(f"    • Could not get workspace stats: {str(e)}")
+
+            # Get database size
+            db_size_query = text(
+                "SELECT pg_size_pretty(pg_database_size(current_database()))"
+            )
+            db_size_result = await session.execute(db_size_query)
+            db_size = db_size_result.scalar()
+            print(f"\n💾 Total database size: {db_size}")
+
+            # Get connection info
+            version_query = text("SELECT version()")
+            version_result = await session.execute(version_query)
+            version = version_result.scalar()
+            print(f"\n🔌 Connected to: {version}")
+
+            return True
+
+    except Exception as e:
+        print(f"❌ Error checking database stats: {str(e)}")
+        try_sync_connection()
+        return False
+
+
+async def test_database_write_read(a_session_maker):
+    """Test database by creating a temporary table, writing data, reading it back, and dropping the table"""
+    print("\n🧪 Testing database write/read operations...")
+
+    test_table_name = "test_hypha_table"
+
+    try:
+        async with pg_session_maker() as session:
+            # Check if test table exists and drop it to ensure clean test
+            check_table = text(f"SELECT to_regclass('public.{test_table_name}')")
+            result = await session.execute(check_table)
+            if result.scalar():
+                print(f"  • Found existing test table, dropping it first")
+                await session.execute(text(f"DROP TABLE {test_table_name}"))
+                await session.commit()
+
+            # Create test table
+            create_table = text(
+                f"""
+                CREATE TABLE {test_table_name} (
+                    id SERIAL PRIMARY KEY,
+                    name TEXT NOT NULL,
+                    value INTEGER,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+            """
+            )
+            await session.execute(create_table)
+            await session.commit()
+            print(f"  • Created test table: {test_table_name}")
+
+            # Insert test data
+            test_data = [("item1", 100), ("item2", 200), ("item3", 300)]
+
+            for name, value in test_data:
+                insert = text(
+                    f"INSERT INTO {test_table_name} (name, value) VALUES (:name, :value)"
+                )
+                await session.execute(insert, {"name": name, "value": value})
+
+            await session.commit()
+            print(f"  • Inserted {len(test_data)} rows of test data")
+
+            # Read back data to verify
+            select = text(f"SELECT id, name, value FROM {test_table_name} ORDER BY id")
+            result = await session.execute(select)
+            rows = result.fetchall()
+
+            # Verify data integrity
+            if len(rows) == len(test_data):
+                print(f"  • Successfully read back {len(rows)} rows:")
+                for row in rows:
+                    print(f"    - ID: {row[0]}, Name: {row[1]}, Value: {row[2]}")
+
+                # Verify values match what we inserted
+                all_match = True
+                for i, (name, value) in enumerate(test_data):
+                    if rows[i][1] != name or rows[i][2] != value:
+                        all_match = False
+                        break
+
+                if all_match:
+                    print("  ✅ Data verification successful - all values match")
+                else:
+                    print("  ❌ Data verification failed - values don't match")
+            else:
+                print(
+                    f"  ❌ Data count mismatch: inserted {len(test_data)}, read back {len(rows)}"
+                )
+
+            # Drop test table
+            drop_table = text(f"DROP TABLE {test_table_name}")
+            await session.execute(drop_table)
+            await session.commit()
+            print(f"  • Cleaned up: dropped test table {test_table_name}")
+
+            return True
+
+    except Exception as e:
+        print(f"❌ Error during database write/read test: {str(e)}")
+        return False
+
+
+async def try_sync_connection(  # should be sync
+    db_user=DB_USER_DEFAULT,
+    db_password="",
+    db_host="",
+    db_port=DB_PORT_DEFAULT,
+    db_name=DB_NAME_DEFAULT,
+):
+    """Fallback to sync connection for troubleshooting"""
+    try:
+        print("\nTrying sync connection with psycopg2...")
+        sync_url = f"postgresql://{db_user}:{db_password}@{db_host}:{db_port}/{db_name}"
+
+        # Create synchronous engine
+        sync_engine = create_async_engine(sync_url)  # should be create_engine for sync
+
+        # Test connection
+        async with sync_engine.connect() as conn:  # should be sync
+            tables = conn.execute(
+                text("SELECT tablename FROM pg_tables WHERE schemaname = 'public'")
+            )
+            print(f"Tables in database: {[table[0] for table in tables]}")
+
+            db_size = conn.execute(
+                text("SELECT pg_size_pretty(pg_database_size(current_database()))")
+            )
+            print(f"Database size: {db_size.scalar()}")
+
+            version = conn.execute(text("SELECT version()"))
+            print(f"Connected to: {version.scalar()}")
+
+        print("✅ Successfully connected with psycopg2!")
+
+    except Exception as e2:
+        print(f"❌ Error with sync connection: {str(e2)}")
+
+
+async def verify_migration():
+    print("🔍 Starting migration verification...")
+
+    async with pg_session_maker_local() as sqlite_session, pg_session_maker() as pg_session:
+        # Fetch from SQLite
+        sqlite_result = await sqlite_session.exec(select(ArtifactModel))
+        sqlite_artifacts = {a.id: a for a in sqlite_result.all()}
+
+        # Fetch from PostgreSQL
+        pg_result = await pg_session.execute(select(ArtifactModel))
+        pg_artifacts = {a.id: a for a in pg_result.scalars().all()}
+
+    total_sqlite = len(sqlite_artifacts)
+    total_pg = len(pg_artifacts)
+    print(f"📦 SQLite artifacts: {total_sqlite}")
+    print(f"📥 PostgreSQL artifacts: {total_pg}")
+
+    missing_in_pg = []
+    mismatches = []
+
+    for id_, sa in sqlite_artifacts.items():
+        pa = pg_artifacts.get(id_)
+        if not pa:
+            missing_in_pg.append(id_)
+        else:
+            # Optional: compare specific fields
+            if (
+                sa.alias != pa.alias
+                or sa.workspace != pa.workspace
+                or sa.last_modified != pa.last_modified
+            ):
+                mismatches.append((id_, sa, pa))
+
+    print(f"❌ Missing in PostgreSQL: {len(missing_in_pg)}")
+    print(f"⚠️  Mismatched artifacts: {len(mismatches)}")
+
+    if missing_in_pg:
+        print("Missing artifact IDs:")
+        for id_ in missing_in_pg[:5]:
+            print(f" - {id_}")
+        if len(missing_in_pg) > 5:
+            print(" ...")
+
+    if mismatches:
+        print("Examples of mismatches:")
+        for id_, sa, pa in mismatches[:3]:
+            print(f" - ID: {id_}")
+            print(
+                f"   → SQLite: alias={sa.alias}, workspace={sa.workspace}, last_modified={sa.last_modified}"
+            )
+            print(
+                f"   → Postgres: alias={pa.alias}, workspace={pa.workspace}, last_modified={pa.last_modified}"
+            )
+
+    print("✅ Verification complete.")
+
+
+async def minimal_pg_list_children_repro(parent_id: str, stage=None, limit=10):
+    async with session_maker() as session:
+        query = select(ArtifactModel).where(ArtifactModel.parent_id == parent_id)
+
+        if stage is not None:
+            print(f"Applying stage filter: {stage}")
+            if stage:
+                # staged artifacts
+                query = query.where(ArtifactModel.staging.isnot(None))
+            else:
+                # committed artifacts
+                query = query.where(
+                    text("json_array_length(versions) > 0")
+                    # func.json_array_length(ArtifactModel.versions) > 0
+                    # or_(
+                    #     ArtifactModel.staging.is_(None),
+                    #     text("staging::text = 'null'"),
+                    # )
+                )
+        else:
+            print("No stage filter applied")
+
+        query = query.order_by(ArtifactModel.created_at.asc()).limit(limit)
+
+        result = await session.execute(query)
+        artifacts = result.scalars().all()
+
+        print(f"\nFound {len(artifacts)} children (stage={stage}):")
+        for a in artifacts:
+            ts = datetime.fromtimestamp(a.created_at).isoformat()
+            print(f" - {a.id}: {a.alias} (created: {ts}, file_count: {a.file_count})")
+
+
+# stop using pg_engine_local from here
+
+
+async def drop_artifacts_table(pg_engine):
+    async with pg_engine.begin() as conn:
+        await conn.run_sync(
+            lambda conn: ArtifactModel.__table__.drop(conn, checkfirst=True)
+        )
+    print("🗑️ Dropped existing 'artifacts' table.")
+
+
+async def init_postgres_schema(pg_engine):
+    async with pg_engine.begin() as conn:
+        await conn.run_sync(
+            lambda conn: SQLModel.metadata.create_all(conn, checkfirst=True)
+        )
+    print("✅ PostgreSQL schema initialized.")
+
+
+async def debug_pg_schema():
+    async with pg_engine.begin() as conn:
+        result = await conn.execute(
+            text(
+                """
+            SELECT table_schema, table_name
+            FROM information_schema.tables
+            WHERE table_type = 'BASE TABLE'
+        """
+            )
+        )
+        rows = result.fetchall()
+        for schema, table in rows:
+            print(f"📦 Found table: {schema}.{table}")
+
+
+async def inspect_artifacts():
+    async with pg_engine.begin() as conn:
+        result = await conn.execute(text("SELECT COUNT(*) FROM artifacts"))
+        count = result.scalar()
+        print(f"📊 Total artifacts in PostgreSQL: {count}")
+
+        # Show 5 example entries
+        result = await conn.execute(
+            text(
+                """
+            SELECT id, alias, workspace, file_count, created_at, last_modified
+            FROM artifacts
+            ORDER BY last_modified DESC
+            LIMIT 5
+        """
+            )
+        )
+        rows = result.fetchall()
+        for row in rows:
+            print("📄", row)
+
+
+async def main():
+    # Run both inspections
+    await inspect_collection("bioimage-io", "bioimage.io")
+    print("\n" + "-" * 60 + "\n")
+    await inspect_collection("shareloc-xyz", "shareloc-collection")
+    await test_raw_list_children("019362db-e4b7-7fd1-92b3-dd451eefeaa1")  # bioimage.io
+
+    # ✅ Works: no filters
+    await debug_list_children_like("019362db-e4b7-7fd1-92b3-dd451eefeaa1")
+
+    # 🔍 Test stage=False filter (should work if correctly implemented)
+    await debug_list_children_like("019362db-e4b7-7fd1-92b3-dd451eefeaa1", stage=False)
+
+    # 🔍 Test stage=True filter (may return fewer or none)
+    await debug_list_children_like("019362db-e4b7-7fd1-92b3-dd451eefeaa1", stage=True)
+
+    # 🧪 Test keyword filter — replace with a known string if needed
+    await debug_list_children_like(
+        "019362db-e4b7-7fd1-92b3-dd451eefeaa1", keyword="crab"
+    )
+
+    # 🔐 Simulate permission filter
+    await debug_list_children_like(
+        "019362db-e4b7-7fd1-92b3-dd451eefeaa1",
+        config_permission_filter={"sophisticated-humidity-98268842": "*"},
+    )
+
+    parent_id = "019362db-e4b7-7fd1-92b3-dd451eefeaa1"
+
+    await test_pg_list_children(parent_id, stage=None)
+    await test_pg_list_children(parent_id, stage=True)
+    await test_pg_list_children(parent_id, stage=False)
+
+    await list_children_pg_test(
+        parent_id="019362db-e4b7-7fd1-92b3-dd451eefeaa1",
+        workspace="bioimage-io",
+        keywords=["deep"],
+        filters={"type": "model"},
+        stage=False,
+        limit=10,
+    )
+    print("🔄 Starting database connection test...")
+    stats_success = await check_database_stats(pg_session_maker)
+    await verify_migration()
+    async with pg_session_maker() as session:
+        await list_children_test(session, "bioimage.io", "bioimage-io")
+    await debug_pg_schema()
+    test_parent_id = "019362db-e4b7-7fd1-92b3-dd451eefeaa1"
+    await minimal_pg_list_children_repro(test_parent_id, stage=None)
+    await minimal_pg_list_children_repro(test_parent_id, stage=True)
+    await minimal_pg_list_children_repro(test_parent_id, stage=False)
+    await inspect_artifacts()
+
+    limit = 10
+    async with pg_session_maker_local() as session:
+        print("📡 Connecting to PostgreSQL and querying artifacts...")
+        result = await session.execute(
+            select(ArtifactModel)
+            .order_by(ArtifactModel.last_modified.desc())
+            .limit(limit)
+        )
+        artifacts = result.all()
+        print(f"✅ Retrieved {len(artifacts)} artifacts:\n")
+        for (art,) in artifacts:
+            created = datetime.utcfromtimestamp(art.created_at).strftime(
+                "%Y-%m-%d %H:%M:%S"
+            )
+            modified = datetime.utcfromtimestamp(art.last_modified).strftime(
+                "%Y-%m-%d %H:%M:%S"
+            )
+            print(
+                f"📦 {art.workspace}/{art.alias or art.id} — files: {art.file_count}, created: {created}, modified: {modified}"
+            )
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/utils/recover-artifacts.py b/utils/recover-artifacts.py
new file mode 100644
index 000000000..76f44295a
--- /dev/null
+++ b/utils/recover-artifacts.py
@@ -0,0 +1,603 @@
+#!/usr/bin/env python3
+"""
+Hypha Database Recovery Script (with additional S3 sources)
+
+This script rebuilds a Hypha SQLite database from S3 backups.
+It scans S3 for all workspaces and artifacts, including collection artifacts in alternative S3 buckets.
+"""
+
+import os
+import json
+import asyncio
+import logging
+import argparse
+from collections import defaultdict, deque
+from pathlib import Path
+from botocore.config import Config
+from sqlalchemy import select, text
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+from sqlmodel import SQLModel
+from aiobotocore.session import get_session
+from utils.artifact_model import ArtifactModel
+from utils.constants import (
+    ENV_FILE,
+    DATABASE_PATH,
+    LOGLEVEL,
+    S3_BUCKET,
+    ADDITIONAL_ENV_FILES,
+    ADDITIONAL_ENV_KEYS,
+    DATABASE_URI,
+    DB_USER_DEFAULT,
+    DB_NAME_DEFAULT,
+    DB_PORT_DEFAULT,
+)
+
+# Global dry run flag
+DRY_RUN = False
+
+
+# --- Load env ---
+def load_env_file(filepath: str) -> dict:
+    env = {}
+    with open(filepath, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if line and not line.startswith("#") and "=" in line:
+                key, value = line.split("=", 1)
+                value = value.strip().strip('"').strip("'")
+                env[key] = value
+    return env
+
+
+logger = logging.getLogger("hypha_recovery")
+logger.setLevel(getattr(logging, LOGLEVEL))
+if not logger.handlers:
+    handler = logging.StreamHandler()
+    handler.setFormatter(
+        logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+    )
+    logger.addHandler(handler)
+
+if not DRY_RUN and os.path.exists(DATABASE_PATH):
+    os.remove(DATABASE_PATH)
+    logger.info("Removed existing database at %s", DATABASE_PATH)
+elif DRY_RUN and os.path.exists(DATABASE_PATH):
+    logger.info("[DRY RUN] Would remove existing database at %s", DATABASE_PATH)
+
+
+def safe_join(directory, *pathnames):
+    result = directory
+    for pathname in pathnames:
+        result = result.rstrip("/") + "/" + pathname.lstrip("/")
+    return result
+
+
+async def create_s3_client(config):
+    url = config["endpoint_url"]
+    if not url.startswith("http"):
+        url = "https://" + url
+    return get_session().create_client(
+        "s3",
+        endpoint_url=url.rstrip("/"),
+        aws_access_key_id=config["access_key_id"],
+        aws_secret_access_key=config["secret_access_key"],
+        region_name=config["region_name"],
+        config=Config(connect_timeout=60, read_timeout=300),
+    )
+
+
+async def list_objects_async(s3_client, bucket, prefix=None, delimiter="/"):
+    prefix = prefix or ""
+    response = await s3_client.list_objects_v2(
+        Bucket=bucket, Prefix=prefix, Delimiter=delimiter
+    )
+
+    def parse(resp):
+        out = []
+        for p in resp.get("CommonPrefixes", []):
+            out.append(
+                {
+                    "name": p["Prefix"].rstrip(delimiter).split(delimiter)[-1],
+                    "type": "directory",
+                }
+            )
+        for obj in resp.get("Contents", []):
+            if not obj["Key"].endswith("/"):
+                out.append(
+                    {
+                        "name": obj["Key"].split("/")[-1],
+                        "type": "file",
+                        "size": obj["Size"],
+                        "last_modified": obj["LastModified"],
+                    }
+                )
+        return out
+
+    items = parse(response)
+    while response.get("IsTruncated"):
+        token = response["NextContinuationToken"]
+        response = await s3_client.list_objects_v2(
+            Bucket=bucket, Prefix=prefix, Delimiter=delimiter, ContinuationToken=token
+        )
+        items += parse(response)
+    return items
+
+
+async def init_db(engine):
+    if DRY_RUN:
+        logger.info("[DRY RUN] Would initialize database tables")
+        return
+    async with engine.begin() as conn:
+        await conn.run_sync(SQLModel.metadata.create_all)
+
+
+async def scan_artifact_prefix(s3_config, prefix, infer_workspace=False):
+    artifacts = {}
+    total_dirs = 0
+    skipped_dirs = 0
+    loaded = 0
+    failed = 0
+
+    async with await create_s3_client(s3_config) as s3_client:
+        logger.info("Scanning bucket: %s, prefix: %s", s3_config["bucket"], prefix)
+        try:
+            artifact_dirs = await list_objects_async(
+                s3_client, s3_config["bucket"], prefix.rstrip("/") + "/", delimiter="/"
+            )
+        except Exception as e:
+            logger.error("Failed to list prefix %s: %s", prefix, e)
+            return artifacts
+
+        total_dirs = len(artifact_dirs)
+        logger.info("Found %d artifact directories under %s", total_dirs, prefix)
+
+        for artifact_dir in artifact_dirs:
+            if artifact_dir["type"] != "directory":
+                skipped_dirs += 1
+                continue
+
+            artifact_id = artifact_dir["name"]
+            version_prefix = safe_join(prefix.rstrip("/"), artifact_id)
+
+            try:
+                version_objects = await list_objects_async(
+                    s3_client, s3_config["bucket"], version_prefix + "/"
+                )
+            except Exception as e:
+                logger.warning(
+                    "Failed to list versions for artifact %s in prefix %s: %s",
+                    artifact_id,
+                    version_prefix,
+                    e,
+                )
+                failed += 1
+                continue
+
+            json_files = [
+                obj
+                for obj in version_objects
+                if obj["type"] == "file" and obj["name"].endswith(".json")
+            ]
+            if not json_files:
+                logger.debug(
+                    "No JSON version files for artifact %s under %s",
+                    artifact_id,
+                    version_prefix,
+                )
+                continue
+
+            json_files.sort(key=lambda x: x["last_modified"])
+            latest_version_key = safe_join(version_prefix, json_files[-1]["name"])
+
+            try:
+                response = await s3_client.get_object(
+                    Bucket=s3_config["bucket"], Key=latest_version_key
+                )
+                content = await response["Body"].read()
+                data = json.loads(content)
+                data.setdefault("id", artifact_id)
+                if infer_workspace:
+                    workspace = prefix.split("/")[0]
+                    data.setdefault("workspace", workspace)
+                else:
+                    data.setdefault("workspace", "external")
+                artifacts[artifact_id] = data
+                loaded += 1
+                logger.debug(
+                    "Loaded artifact %s from %s", artifact_id, latest_version_key
+                )
+            except Exception as e:
+                logger.warning(
+                    "Failed to load artifact %s from %s: %s",
+                    artifact_id,
+                    latest_version_key,
+                    e,
+                )
+                failed += 1
+
+    logger.info(
+        "Finished scanning prefix '%s': %d artifacts loaded, %d skipped, %d failed",
+        prefix,
+        loaded,
+        skipped_dirs,
+        failed,
+    )
+    return artifacts
+
+
+async def rebuild_database(s3_config, additional_s3_sources):
+    logger.info("Starting database recovery")
+    engine = create_async_engine(DATABASE_URI, echo=False)
+    await init_db(engine)
+    session_maker = async_sessionmaker(
+        engine, class_=AsyncSession, expire_on_commit=False
+    )
+    artifacts_by_id = {}
+
+    # Main bucket: scan workspace folders
+    async with await create_s3_client(s3_config) as s3_client:
+        workspaces = await list_objects_async(s3_client, s3_config["bucket"])
+        logger.info("Found %d top-level entries in main S3 bucket", len(workspaces))
+
+        for ws in [
+            w for w in workspaces if w["type"] == "directory" and w["name"] != "etc"
+        ]:
+            ws_name = ws["name"]
+            artifacts_prefix = safe_join(ws_name, "artifacts")
+            logger.info("Scanning workspace: %s", ws_name)
+            artifacts = await scan_artifact_prefix(
+                s3_config, artifacts_prefix, infer_workspace=True
+            )
+            logger.info("Workspace %s: %d artifacts found", ws_name, len(artifacts))
+            artifacts_by_id.update(artifacts)
+
+    # Additional buckets: use flat prefix
+    for source in additional_s3_sources:
+        logger.info(
+            "Scanning additional S3 source: %s/%s/%s",
+            source["endpoint_url"],
+            source["bucket"],
+            source["prefix"],
+        )
+        artifacts = await scan_artifact_prefix(
+            source, source["prefix"], infer_workspace=False
+        )
+        logger.info(
+            "Source %s:%s: %d artifacts found",
+            source["bucket"],
+            source["prefix"],
+            len(artifacts),
+        )
+        artifacts_by_id.update(artifacts)
+
+    logger.info(
+        "Total artifacts collected: %d. %s into database...",
+        len(artifacts_by_id),
+        "Would insert" if DRY_RUN else "Inserting",
+    )
+
+    inserted = 0
+    skipped = 0
+    overwritten = 0
+    failed = 0
+
+    if DRY_RUN:
+        # In dry run mode, just log what would be done
+        for artifact_id, artifact_data in artifacts_by_id.items():
+            alias = artifact_data.get("alias")
+            ws = artifact_data.get("workspace")
+
+            logger.info(
+                "[DRY RUN] Would insert artifact: %s, alias: %s, workspace: %s, file_count: %s, created_at: %s, created_by: %s, last_modified: %s",
+                artifact_id,
+                alias,
+                ws,
+                artifact_data.get("file_count"),
+                artifact_data.get("created_at"),
+                artifact_data.get("created_by"),
+                artifact_data.get("last_modified"),
+            )
+            inserted += 1
+    else:
+        # Actual database operations
+        async with session_maker() as session:
+            for artifact_id, artifact_data in artifacts_by_id.items():
+                try:
+                    async with session.begin():
+                        alias = artifact_data.get("alias")
+                        ws = artifact_data.get("workspace")
+                        if alias:
+                            stmt = select(ArtifactModel).where(
+                                ArtifactModel.workspace == ws,
+                                ArtifactModel.alias == alias,
+                            )
+                            result = await session.execute(stmt)
+                            existing_artifact = result.scalar_one_or_none()
+
+                            if existing_artifact:
+                                s3_time = artifact_data.get("last_modified", 0)
+                                db_time = existing_artifact.last_modified or 0
+
+                                if s3_time > db_time:
+                                    logger.warning(
+                                        "Duplicate alias found for workspace='%s', alias='%s' — S3 artifact is NEWER (S3: %s, DB: %s). Overwriting.\n"
+                                        "→ S3 created_at: %s, file_count: %s\n"
+                                        "→ DB created_at: %s, file_count: %s",
+                                        ws,
+                                        alias,
+                                        s3_time,
+                                        db_time,
+                                        artifact_data.get("created_at"),
+                                        artifact_data.get("file_count"),
+                                        existing_artifact.created_at,
+                                        existing_artifact.file_count,
+                                    )
+                                    await session.delete(existing_artifact)
+                                    await session.flush()
+                                    overwritten += 1
+                                else:
+                                    logger.warning(
+                                        "Duplicate alias found for workspace='%s', alias='%s' — S3 artifact is OLDER (S3: %s, DB: %s). Skipping.\n"
+                                        "→ S3 created_at: %s, file_count: %s\n"
+                                        "→ DB created_at: %s, file_count: %s",
+                                        ws,
+                                        alias,
+                                        s3_time,
+                                        db_time,
+                                        artifact_data.get("created_at"),
+                                        artifact_data.get("file_count"),
+                                        existing_artifact.created_at,
+                                        existing_artifact.file_count,
+                                    )
+                                    skipped += 1
+                                    continue
+
+                        artifact = ArtifactModel(**artifact_data)
+                        session.add(artifact)
+                        inserted += 1
+                        logger.info(
+                            "Inserted artifact: %s, alias: %s, workspace: %s, file_count: %s, created_at: %s, created_by: %s, last_modified: %s",
+                            artifact.id,
+                            artifact.alias,
+                            artifact.workspace,
+                            artifact.file_count,
+                            artifact.created_at,
+                            artifact.created_by,
+                            artifact.last_modified,
+                        )
+                except Exception as e:
+                    logger.error("Insert error for artifact %s: %s", artifact_id, e)
+                    failed += 1
+
+    logger.info(
+        "Database recovery completed. %s: %d, Overwritten: %d, Skipped: %d, Failed: %d",
+        "Would insert" if DRY_RUN else "Inserted",
+        inserted,
+        overwritten,
+        skipped,
+        failed,
+    )
+
+
+async def remove_orphan_artifacts(session_maker):
+    if DRY_RUN:
+        logger.info("[DRY RUN] Would scan for orphan artifacts to remove")
+        return
+
+    async with session_maker() as session:
+        result = await session.execute(select(ArtifactModel))
+        all_artifacts = result.all()
+        id_set = {a.id for a, in all_artifacts}
+
+        orphans = [
+            a for a, in all_artifacts if a.parent_id and a.parent_id not in id_set
+        ]
+
+        print(f"🧹 Found {len(orphans)} orphan artifacts to delete...")
+        for orphan in orphans:
+            print(
+                f" - Removing: {orphan.id} (alias: {orphan.alias}, missing parent: {orphan.parent_id})"
+            )
+            await session.delete(orphan)
+
+        await session.commit()
+        print("✅ Orphan cleanup complete.")
+
+
+def get_s3_config(env_vars):
+    return {
+        "endpoint_url": env_vars.get(
+            "ENDPOINT_URL", os.environ.get("HYPHA_ENDPOINT_URL")
+        ),
+        "access_key_id": env_vars.get(
+            "ACCESS_KEY_ID", os.environ.get("HYPHA_ACCESS_KEY_ID")
+        ),
+        "secret_access_key": env_vars.get(
+            "SECRET_ACCESS_KEY", os.environ.get("HYPHA_SECRET_ACCESS_KEY")
+        ),
+        "region_name": "us-east-1",
+        "bucket": S3_BUCKET,
+        "prefix": "artifacts",
+    }
+
+
+def get_additional_s3_sources(additional_env_files, additional_env_keys):
+    additional_s3_sources = []
+    for env_file in additional_env_files:
+        if not Path(env_file).exists():
+            logger.warning("Additional env file not found: %s", env_file)
+            continue
+        env = load_env_file(env_file)
+        conf = {k: env.get(k, "") for k in additional_env_keys}
+        if not conf["S3_BUCKET"] or not conf["S3_PREFIX"]:
+            logger.warning("Skipping incomplete S3 config in %s", env_file)
+            continue
+        additional_s3_sources.append(
+            {
+                "endpoint_url": conf["S3_ENDPOINT_URL"],
+                "access_key_id": conf["S3_ACCESS_KEY_ID"],
+                "secret_access_key": conf["S3_SECRET_ACCESS_KEY"],
+                "region_name": conf.get("S3_REGION_NAME", "us-east-1"),
+                "bucket": conf["S3_BUCKET"],
+                "prefix": conf["S3_PREFIX"],
+                "secrets": conf,
+            }
+        )
+    return additional_s3_sources
+
+
+async def check_pg_table_rows(pg_engine):
+    async with pg_engine.begin() as conn:
+        result = await conn.execute(text("SELECT COUNT(*) FROM artifacts"))
+        count = result.scalar()
+        print(f"📊 PostgreSQL: artifacts table has {count} rows.")
+
+
+def clean_artifact(a: ArtifactModel) -> ArtifactModel:
+    """Return a clean ArtifactModel instance without relationships."""
+    return ArtifactModel(
+        id=a.id,
+        type=a.type,
+        workspace=a.workspace,
+        parent_id=a.parent_id,
+        alias=a.alias,
+        manifest=a.manifest,
+        staging=a.staging,
+        download_count=a.download_count,
+        view_count=a.view_count,
+        file_count=a.file_count,
+        created_at=a.created_at,
+        created_by=a.created_by,
+        last_modified=a.last_modified,
+        versions=a.versions,
+        config=a.config,
+        secrets=a.secrets,
+    )
+
+
+def build_dependency_graph(artifacts):
+    graph = defaultdict(list)
+    indegree = defaultdict(int)
+    id_map = {a.id: a for a in artifacts}
+
+    for a in artifacts:
+        if a.parent_id and a.parent_id in id_map:
+            graph[a.parent_id].append(a.id)
+            indegree[a.id] += 1
+        else:
+            indegree[a.id] = indegree.get(a.id, 0)
+
+    return graph, indegree, id_map
+
+
+def topological_sort_artifacts(artifacts):
+    graph, indegree, id_map = build_dependency_graph(artifacts)
+    queue = deque([aid for aid, deg in indegree.items() if deg == 0])
+    ordered = []
+
+    while queue:
+        aid = queue.popleft()
+        ordered.append(id_map[aid])
+        for neighbor in graph[aid]:
+            indegree[neighbor] -= 1
+            if indegree[neighbor] == 0:
+                queue.append(neighbor)
+
+    return ordered
+
+
+async def transfer_artifacts_topo(pg_engine, sqlite_session_maker, pg_session_maker):
+    if DRY_RUN:
+        print("🔄 [DRY RUN] Would transfer artifacts with topological ordering")
+        return
+
+    async with sqlite_session_maker() as sqlite_session:
+        result = await sqlite_session.exec(select(ArtifactModel))
+        all_artifacts = result.all()
+
+    print(f"🔄 Transferring with topological order: {len(all_artifacts)} artifacts")
+
+    ordered = topological_sort_artifacts(all_artifacts)
+    inserted = 0
+    print(ordered)
+
+    async with pg_session_maker() as pg_session:
+        async with pg_session.begin():
+            for a in ordered:
+                try:
+                    obj = clean_artifact(a)
+                    pg_session.add(obj)
+                    inserted += 1
+                except Exception as e:
+                    print(f"⚠️ Failed to insert {a.id} ({a.alias}): {e}")
+        await pg_session.commit()
+
+    print(f"✅ Inserted {inserted}/{len(all_artifacts)}")
+    await check_pg_table_rows(pg_engine)
+
+
+async def main():
+    global DRY_RUN
+
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(
+        description="Hypha Database Recovery Script - Rebuild SQLite database from S3 backups"
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Show what would be done without actually making changes",
+    )
+    args = parser.parse_args()
+
+    DRY_RUN = args.dry_run
+
+    if DRY_RUN:
+        logger.info("🔍 DRY RUN MODE: No changes will be made to the database")
+
+    SQLModel.metadata.clear()
+
+    env_vars = load_env_file(ENV_FILE) if Path(ENV_FILE).exists() else {}
+    s3_config = get_s3_config(env_vars)
+    additional_s3_sources = get_additional_s3_sources(
+        ADDITIONAL_ENV_FILES, ADDITIONAL_ENV_KEYS
+    )
+
+    await rebuild_database(s3_config, additional_s3_sources)
+
+    if not DRY_RUN:
+        engine = create_async_engine(DATABASE_URI, echo=False)
+        sqlite_session_maker = async_sessionmaker(
+            engine, class_=AsyncSession, expire_on_commit=False
+        )
+
+        await remove_orphan_artifacts(sqlite_session_maker)
+        db_password = env_vars.get("DB_PASSWORD", "")
+        db_host = env_vars.get("DB_HOST", "")
+        db_user = env_vars.get("DB_USER", DB_USER_DEFAULT)
+        db_port = env_vars.get("DB_PORT", DB_PORT_DEFAULT)
+        db_name = env_vars.get("DB_NAME", DB_NAME_DEFAULT)
+
+        database_url = f"postgresql+asyncpg://{db_user}:{db_password}@{db_host}:{db_port}/{db_name}"
+        pg_engine = create_async_engine(database_url, echo=False)
+        pg_session_maker = async_sessionmaker(
+            pg_engine, expire_on_commit=False, class_=AsyncSession
+        )
+
+        await transfer_artifacts_topo(pg_engine, sqlite_session_maker, pg_session_maker)
+    else:
+        logger.info("🔍 DRY RUN completed - no database operations were performed")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Hypha Database Recovery Script")
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="Perform a trial run with no changes made",
+    )
+    args = parser.parse_args()
+
+    DRY_RUN = args.dry_run
+
+    asyncio.run(main())