plato-sdk-v2 2.8.6__tar.gz → 2.8.8__tar.gz

{plato_sdk_v2-2.8.6 → plato_sdk_v2-2.8.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plato-sdk-v2
-Version: 2.8.6
+Version: 2.8.8
 Summary: Python SDK for the Plato API
 Author-email: Plato <support@plato.so>
 License-Expression: MIT

plato_sdk_v2-2.8.8/VERSION

@@ -0,0 +1 @@
+2.8.8

plato_sdk_v2-2.8.8/examples/preview_local_dev.py

@@ -0,0 +1,250 @@
+#!/usr/bin/env python3
+"""Start a preview local development environment.
+
+This example:
+1. Starts a blank VM with sufficient resources
+2. Clones the plato repo via SSH with a deploy key
+3. Checks out the preview-deployments branch
+4. Starts docker-compose with the preview config
+5. Waits for user input before closing
+
+Usage:
+    export PLATO_API_KEY=your-key
+    python preview_local_dev.py
+"""
+
+import logging
+import os
+import sys
+import time
+
+from dotenv import load_dotenv
+
+from plato.v2 import Env, Plato
+from plato.v2.types import SimConfigCompute
+
+load_dotenv()
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+# GitHub repo to clone
+GITHUB_REPO = "git@github.com:useplato/plato.git"
+GITHUB_BRANCH = "preview-deployments"
+
+# SSH deploy key for cloning useplato/plato (ed25519)
+SSH_PRIVATE_KEY = """-----BEGIN OPENSSH PRIVATE KEY-----
+b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAAAMwAAAAtzc2gtZW
+QyNTUxOQAAACCzSn8opb8nWXEZ8yEv3WQG8P+vVbZGwgEDjhbmSSqIsgAAAJhF9JNKRfST
+SgAAAAtzc2gtZWQyNTUxOQAAACCzSn8opb8nWXEZ8yEv3WQG8P+vVbZGwgEDjhbmSSqIsg
+AAAEC5AlVUuWLCtviqAI8iI+8A4LTeDiNgjL6zlGk6NJp16bNKfyilvydZcRnzIS/dZAbw
+/69VtkbCAQOOFuZJKoiyAAAAD3BsYXRvLXZtLWRlcGxveQECAwQFBg==
+-----END OPENSSH PRIVATE KEY-----"""
+
+
+def execute_and_log(session, command: str, description: str, timeout: int = 60) -> bool:
+    """Execute a command and log the result. Returns True on success."""
+    logger.info(f"{description}...")
+    result = session.execute(command, timeout=timeout)
+    for job_id, res in result.results.items():
+        if res.exit_code != 0:
+            logger.error(f"  Failed (exit {res.exit_code}): {res.stderr[:500] if res.stderr else 'no stderr'}")
+            return False
+        if res.stdout and len(res.stdout.strip()) > 0:
+            # Show first few lines of output
+            lines = res.stdout.strip().split("\n")
+            if len(lines) <= 5:
+                for line in lines:
+                    logger.info(f"  {line}")
+            else:
+                for line in lines[:3]:
+                    logger.info(f"  {line}")
+                logger.info(f"  ... ({len(lines) - 3} more lines)")
+    return True
+
+
+def main():
+    api_key = os.environ.get("PLATO_API_KEY")
+    if not api_key:
+        logger.error("PLATO_API_KEY not set")
+        return 1
+
+    logger.info("=" * 70)
+    logger.info("PREVIEW LOCAL DEV ENVIRONMENT")
+    logger.info("=" * 70)
+    logger.info(f"Repo: {GITHUB_REPO}")
+    logger.info(f"Branch: {GITHUB_BRANCH}")
+    logger.info("")
+
+    plato = Plato()
+    session = None
+
+    try:
+        # Create a blank VM with enough resources for docker-compose
+        logger.info("Creating session with blank VM...")
+        start_time = time.time()
+
+        session = plato.sessions.create(
+            envs=[
+                Env.resource(
+                    simulator="preview-dev",
+                    sim_config=SimConfigCompute(
+                        cpus=4,
+                        memory=8192,  # 8GB RAM for docker
+                        disk=20480,  # 20GB disk for docker images
+                    ),
+                    alias="dev",
+                )
+            ],
+            timeout=600,
+            connect_network=True,
+        )
+
+        elapsed = time.time() - start_time
+        logger.info(f"Session created in {elapsed:.1f}s: {session.session_id}")
+
+        env = session.envs[0]
+        logger.info(f"Environment: {env.job_id}")
+        logger.info(f"Public URL: {env.public_url}")
+        logger.info("")
+
+        # Start heartbeat to keep session alive
+        session.start_heartbeat()
+
+        # Setup Docker overlay (faster than vfs)
+        logger.info("Setting up Docker overlay storage...")
+        session.setup_sandbox(timeout=120)
+        logger.info("  Docker overlay setup complete")
+
+        # Setup SSH key for git clone
+        if not execute_and_log(session, "mkdir -p /root/.ssh && chmod 700 /root/.ssh", "Creating SSH directory"):
+            return 1
+
+        # Write the SSH private key
+        escaped_key = SSH_PRIVATE_KEY.replace("'", "'\\''")
+        if not execute_and_log(
+            session,
+            f"echo '{escaped_key}' > /root/.ssh/plato_deploy && chmod 600 /root/.ssh/plato_deploy",
+            "Writing SSH deploy key",
+        ):
+            return 1
+
+        # Add GitHub to known hosts
+        if not execute_and_log(
+            session,
+            "ssh-keyscan -t ed25519 github.com >> /root/.ssh/known_hosts 2>/dev/null",
+            "Adding GitHub to known hosts",
+        ):
+            return 1
+
+        # Clone the repo with deploy key
+        logger.info(f"Cloning {GITHUB_REPO}...")
+        clone_cmd = f'GIT_SSH_COMMAND="ssh -i /root/.ssh/plato_deploy -o StrictHostKeyChecking=no" git clone --depth 1 -b {GITHUB_BRANCH} {GITHUB_REPO} /root/plato'
+        clone_result = session.execute(clone_cmd, timeout=300)
+        for job_id, res in clone_result.results.items():
+            if res.exit_code != 0:
+                logger.error(f"  git clone failed: {res.stderr}")
+                return 1
+            logger.info("  git clone completed successfully")
+
+        # Configure git to use deploy key for future operations
+        if not execute_and_log(
+            session,
+            'cd /root/plato && git config core.sshCommand "ssh -i /root/.ssh/plato_deploy -o StrictHostKeyChecking=no"',
+            "Configuring git SSH",
+        ):
+            return 1
+
+        # Start docker-compose with preview config
+        logger.info("Starting docker-compose (this may take a few minutes for first build)...")
+        compose_result = session.execute(
+            "cd /root/plato/local-dev && docker compose -f docker-compose.preview.yml up -d --build",
+            timeout=900,  # 15 minutes for first build
+        )
+        for job_id, res in compose_result.results.items():
+            if res.exit_code != 0:
+                logger.warning(f"  docker-compose may have issues: {res.stderr[:500] if res.stderr else ''}")
+                # Don't fail - might still be starting
+            else:
+                logger.info("  docker-compose started")
+
+        # Wait a bit for services to initialize
+        logger.info("Waiting for services to initialize (60s)...")
+        session.execute("sleep 60", timeout=120)
+
+        # Check running containers
+        logger.info("Checking running containers...")
+        execute_and_log(session, "docker ps --format 'table {{.Names}}\t{{.Status}}'", "Container status")
+
+        # Check if nginx is healthy
+        logger.info("Checking nginx health...")
+        health_result = session.execute("curl -sf http://localhost:8080/health || echo 'not ready'", timeout=30)
+        for job_id, res in health_result.results.items():
+            if "not ready" in (res.stdout or ""):
+                logger.warning("  Nginx not ready yet - services may still be starting")
+            else:
+                logger.info("  Nginx is healthy!")
+
+        # Print access info
+        logger.info("")
+        logger.info("=" * 70)
+        logger.info("PREVIEW ENVIRONMENT READY")
+        logger.info("=" * 70)
+        logger.info(f"Session ID: {session.session_id}")
+        logger.info(f"Job ID: {env.job_id}")
+        logger.info("")
+        logger.info("Access URLs:")
+        logger.info(f"  Public URL: {env.public_url}")
+        logger.info(f"  Connect URL: https://{env.job_id}.connect.plato.so")
+        logger.info(f"  API (via connect): https://{env.job_id}--8080.connect.plato.so")
+        logger.info("")
+        logger.info("SSH access (if network connected):")
+        logger.info("  SSH to VM: plato sandbox ssh (from directory with .plato/state.json)")
+        logger.info("")
+        logger.info("Docker compose logs:")
+        logger.info("  docker compose -f docker-compose.preview.yml logs -f")
+        logger.info("")
+        logger.info("=" * 70)
+        logger.info("Press Enter to stop the session and clean up...")
+        logger.info("=" * 70)
+
+        # Wait for user input
+        try:
+            input()
+        except EOFError:
+            # Running non-interactively, wait forever
+            logger.info("Running non-interactively. Press Ctrl+C to stop.")
+            try:
+                while True:
+                    time.sleep(60)
+            except KeyboardInterrupt:
+                pass
+
+        logger.info("")
+        logger.info("Shutting down...")
+        return 0
+
+    except KeyboardInterrupt:
+        logger.info("\nInterrupted by user")
+        return 0
+
+    except Exception as e:
+        logger.error(f"Error: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return 1
+
+    finally:
+        if session:
+            logger.info("Closing session...")
+            try:
+                session.close()
+            except Exception as e:
+                logger.warning(f"Error closing session: {e}")
+        plato.close()
+        logger.info("Done.")
+
+
+if __name__ == "__main__":
+    sys.exit(main())

plato_sdk_v2-2.8.8/examples/snapshot_docker_image.py

@@ -0,0 +1,115 @@
+#!/usr/bin/env python3
+"""Snapshot a custom Docker base image.
+
+This example starts a blank VM with a custom Docker image (e.g., computer-use agent)
+and creates a snapshot using the snapshot-store pipeline.
+
+Usage:
+    export PLATO_API_KEY=your-key
+    python snapshot_docker_image.py
+"""
+
+import logging
+import os
+
+from dotenv import load_dotenv
+
+from plato.v2 import Env, Plato
+from plato.v2.types import SimConfigCompute
+
+load_dotenv()
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+# Custom Docker image to snapshot
+DOCKER_IMAGE = "383806609161.dkr.ecr.us-west-1.amazonaws.com/agents/plato/computer-use:1.3.0"
+
+# Simulator name for the snapshot artifact
+SIMULATOR_NAME = "computer-use-agent"
+
+
+def main():
+    api_key = os.environ.get("PLATO_API_KEY")
+    if not api_key:
+        logger.error("PLATO_API_KEY not set")
+        return 1
+
+    logger.info("=" * 70)
+    logger.info("SNAPSHOT DOCKER IMAGE EXAMPLE")
+    logger.info("=" * 70)
+    logger.info(f"Docker image: {DOCKER_IMAGE}")
+    logger.info(f"Simulator name: {SIMULATOR_NAME}")
+    logger.info("")
+
+    plato = Plato()
+    session = None
+
+    try:
+        # Create a blank VM with custom Docker image
+        logger.info("Creating session with custom Docker image...")
+        session = plato.from_envs(
+            envs=[
+                Env.resource(
+                    simulator=SIMULATOR_NAME,
+                    sim_config=SimConfigCompute(
+                        cpus=4,
+                        memory=8192,
+                        disk=20480,
+                    ),
+                    docker_image_url=DOCKER_IMAGE,
+                    alias="agent",
+                )
+            ],
+            timeout=600,
+        )
+
+        logger.info(f"Session created: {session.session_id}")
+        logger.info(f"Environment: {session.envs[0].job_id}")
+
+        # Wait for VM to be fully ready
+        logger.info("Waiting for VM to be ready...")
+        session.wait_until_ready(timeout=300)
+
+        # Optionally run some setup commands
+        logger.info("Running setup commands...")
+        result = session.execute("uname -a && df -h", timeout=30)
+        for job_id, res in result.results.items():
+            logger.info(f"  {job_id}: {res.stdout[:200] if res.stdout else '(no output)'}")
+
+        # Create disk snapshot (disk-only, uses snapshot-store for chunk-based dedup)
+        logger.info("Creating disk snapshot...")
+        snapshot_result = session.disk_snapshot(
+            override_service=SIMULATOR_NAME,
+            override_version="1.3.0",
+            override_dataset="base",
+        )
+
+        for job_id, info in snapshot_result.results.items():
+            if info.artifact_id:
+                logger.info(f"  {job_id}: artifact_id={info.artifact_id}")
+            else:
+                logger.error(f"  {job_id}: snapshot failed - {info.error}")
+
+        logger.info("")
+        logger.info("SUCCESS: Snapshot created!")
+        logger.info("You can now use this artifact with:")
+        logger.info(f'  Env.simulator("{SIMULATOR_NAME}", tag="1.3.0")')
+        return 0
+
+    except Exception as e:
+        logger.error(f"Error: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return 1
+
+    finally:
+        if session:
+            logger.info("Closing session...")
+            session.close()
+        plato.close()
+
+
+if __name__ == "__main__":
+    exit(main())

plato_sdk_v2-2.8.8/examples/snapshot_local_dev.py

@@ -0,0 +1,206 @@
+#!/usr/bin/env python3
+"""Snapshot a local development environment.
+
+This example:
+1. Starts a blank VM
+2. Clones the plato repo via SSH with a deploy key
+3. Starts local dev docker-compose
+4. Waits for user confirmation before snapshotting
+5. Creates a disk snapshot
+
+Usage:
+    export PLATO_API_KEY=your-key
+    python snapshot_local_dev.py
+"""
+
+import logging
+import os
+import time
+
+from dotenv import load_dotenv
+
+from plato.v2 import Env, Plato
+from plato.v2.types import SimConfigCompute
+
+load_dotenv()
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+
+# Simulator name for the snapshot
+SIMULATOR_NAME = "plato-local-dev"
+
+# GitHub repo to clone
+GITHUB_REPO = "git@github.com:useplato/plato.git"
+GITHUB_BRANCH = "preview-deployments"
+
+# SSH deploy key for cloning useplato/plato (ed25519)
+SSH_PRIVATE_KEY = """-----BEGIN OPENSSH PRIVATE KEY-----
+b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAAAMwAAAAtzc2gtZW
+QyNTUxOQAAACCzSn8opb8nWXEZ8yEv3WQG8P+vVbZGwgEDjhbmSSqIsgAAAJhF9JNKRfST
+SgAAAAtzc2gtZWQyNTUxOQAAACCzSn8opb8nWXEZ8yEv3WQG8P+vVbZGwgEDjhbmSSqIsg
+AAAEC5AlVUuWLCtviqAI8iI+8A4LTeDiNgjL6zlGk6NJp16bNKfyilvydZcRnzIS/dZAbw
+/69VtkbCAQOOFuZJKoiyAAAAD3BsYXRvLXZtLWRlcGxveQECAwQFBg==
+-----END OPENSSH PRIVATE KEY-----"""
+
+
+def main():
+    api_key = os.environ.get("PLATO_API_KEY")
+    if not api_key:
+        logger.error("PLATO_API_KEY not set")
+        return 1
+
+    logger.info("=" * 70)
+    logger.info("SNAPSHOT LOCAL DEV ENVIRONMENT")
+    logger.info("=" * 70)
+    logger.info(f"Repo: {GITHUB_REPO}")
+    logger.info(f"Simulator: {SIMULATOR_NAME}")
+    logger.info("")
+
+    plato = Plato()
+    session = None
+
+    try:
+        # Create a blank VM with enough resources for docker-compose
+        logger.info("Creating session with blank VM...")
+        session = plato.sessions.create(
+            envs=[
+                Env.resource(
+                    simulator=SIMULATOR_NAME,
+                    sim_config=SimConfigCompute(
+                        cpus=2,
+                        memory=4096,
+                        disk=8192,  # 8GB for docker images
+                    ),
+                    alias="dev",
+                )
+            ],
+            timeout=7200,  # 2 hours
+            connect_network=True,
+        )
+
+        logger.info(f"Session created: {session.session_id}")
+        env = session.envs[0]
+        logger.info(f"Environment: {env.job_id}")
+
+        # Setup SSH key for git clone
+        logger.info("Setting up SSH key for GitHub...")
+        session.execute("mkdir -p /root/.ssh && chmod 700 /root/.ssh", timeout=30)
+
+        # Write the SSH private key
+        escaped_key = SSH_PRIVATE_KEY.replace("'", "'\\''")
+        session.execute(
+            f"echo '{escaped_key}' > /root/.ssh/plato_deploy && chmod 600 /root/.ssh/plato_deploy",
+            timeout=30,
+        )
+
+        # Add GitHub to known hosts
+        session.execute(
+            "ssh-keyscan -t ed25519 github.com >> /root/.ssh/known_hosts 2>/dev/null",
+            timeout=30,
+        )
+
+        # Clone the repo with deploy key
+        logger.info(f"Cloning {GITHUB_REPO} (branch: {GITHUB_BRANCH})...")
+        clone_cmd = f'GIT_SSH_COMMAND="ssh -i /root/.ssh/plato_deploy -o StrictHostKeyChecking=no" git clone --depth 1 -b {GITHUB_BRANCH} {GITHUB_REPO} /root/plato'
+        clone_result = session.execute(clone_cmd, timeout=300)
+        for job_id, res in clone_result.results.items():
+            if res.exit_code != 0:
+                logger.error(f"  git clone failed: {res.stderr}")
+                return 1
+            logger.info("  git clone completed successfully")
+
+        # Configure git to use deploy key for future operations
+        session.execute(
+            'cd /root/plato && git config core.sshCommand "ssh -i /root/.ssh/plato_deploy -o StrictHostKeyChecking=no"',
+            timeout=30,
+        )
+
+        # Start docker-compose with preview config
+        logger.info("Starting docker-compose (this may take a few minutes for first build)...")
+        compose_result = session.execute(
+            "cd /root/plato/local-dev && docker compose -f docker-compose.preview.yml up -d --build",
+            timeout=900,  # 15 minutes for first build
+        )
+        for job_id, res in compose_result.results.items():
+            if res.exit_code != 0:
+                logger.warning(f"  docker-compose may have issues: {res.stderr[:500] if res.stderr else ''}")
+            else:
+                logger.info("  docker-compose started")
+
+        # Wait for services to initialize
+        logger.info("Waiting for services to initialize (60s)...")
+        session.execute("sleep 60", timeout=120)
+
+        # Check running containers
+        logger.info("Checking running containers...")
+        check_result = session.execute("docker ps --format 'table {{.Names}}\\t{{.Status}}'", timeout=30)
+        for job_id, res in check_result.results.items():
+            if res.stdout:
+                for line in res.stdout.strip().split("\n"):
+                    logger.info(f"  {line}")
+
+        # Check if nginx is healthy
+        logger.info("Checking nginx health...")
+        health_result = session.execute("curl -sf http://localhost:8080/health || echo 'not ready'", timeout=30)
+        for job_id, res in health_result.results.items():
+            if "not ready" in (res.stdout or ""):
+                logger.warning("  Nginx not ready yet - services may still be starting")
+            else:
+                logger.info("  Nginx is healthy!")
+
+        # Wait for user confirmation before snapshotting
+        logger.info("")
+        logger.info("=" * 70)
+        logger.info("ENVIRONMENT READY - WAITING FOR CONFIRMATION")
+        logger.info("=" * 70)
+        logger.info(f"Session ID: {session.session_id}")
+        logger.info(f"Job ID: {env.job_id}")
+        logger.info("")
+        logger.info("Please verify the environment is set up correctly.")
+        logger.info("Press Enter to create the disk snapshot, or Ctrl+C to abort...")
+        logger.info("=" * 70)
+
+        try:
+            input()
+        except EOFError:
+            # Running non-interactively, wait for Ctrl+C
+            logger.info("Running non-interactively. Press Ctrl+C to abort or wait 60s to continue...")
+            time.sleep(60)
+
+        # Create disk snapshot (uses snapshot-store for chunk-based dedup)
+        logger.info("Creating disk snapshot...")
+        snapshot_result = session.disk_snapshot(
+            override_service=SIMULATOR_NAME,
+            override_version="dev",
+            override_dataset="local",
+        )
+
+        for job_id, info in snapshot_result.results.items():
+            if info.artifact_id:
+                logger.info(f"  {job_id}: artifact_id={info.artifact_id}")
+            else:
+                logger.error(f"  {job_id}: snapshot failed - {info.error}")
+
+        logger.info("")
+        logger.info("SUCCESS: Disk snapshot created!")
+        logger.info("You can now use this artifact with:")
+        logger.info(f'  Env.simulator("{SIMULATOR_NAME}", tag="dev", dataset="local")')
+        return 0
+
+    except Exception as e:
+        logger.error(f"Error: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return 1
+
+    finally:
+        if session:
+            logger.info("Closing session...")
+            session.close()
+        plato.close()
+
+
+if __name__ == "__main__":
+    exit(main())

{plato_sdk_v2-2.8.6 → plato_sdk_v2-2.8.8}/plato/_generated/models/__init__.py

@@ -1,6 +1,6 @@
 # generated by datamodel-codegen:
-#   filename:  tmp97yexy9o.json
-#   timestamp: 2026-02-02T07:59:03+00:00
+#   filename:  tmpu23ownyz.json
+#   timestamp: 2026-02-02T20:25:20+00:00
 
 from __future__ import annotations
 
@@ -1206,6 +1206,11 @@ class RootfsStorageBackend(Enum):
     blockdiff_disk = "blockdiff_disk"
 
 
+class RootfsStorageBackend1(Enum):
+    snapshot_store = "snapshot-store"
+    snapshot_store_disk = "snapshot-store-disk"
+
+
 class EnvFromSimulator(BaseModel):
     model_config = ConfigDict(
         extra="allow",
@@ -1218,9 +1223,13 @@ class EnvFromSimulator(BaseModel):
     """
     Simulator/service name
     """
-    tag: Annotated[str | None, Field(title="Tag")] = "latest"
+    tag: Annotated[str | None, Field(title="Tag")] = None
+    """
+    Artifact tag. If neither tag nor version provided, defaults to 'latest'.
+    """
+    version: Annotated[str | None, Field(title="Version")] = None
     """
-    Artifact tag (defaults to 'latest')
+    Artifact version (git_hash). If provided, looks up by version instead of tag.
     """
     dataset: Annotated[str | None, Field(title="Dataset")] = None
     """
@@ -1872,7 +1881,7 @@ class NodeBuildConfig(BaseModel):
     SSH public key for VM access. Derived from private key if not set.
     """
     default_image: Annotated[str | None, Field(title="Default Image")] = (
-        "383806609161.dkr.ecr.us-west-1.amazonaws.com/vm/rootfs/plato-ubuntu-22.04:1.1.0"
+        "383806609161.dkr.ecr.us-west-1.amazonaws.com/vm/rootfs/plato-ubuntu-22.04:2.0.0"
     )
     """
     Default VM image URL with tag (e.g., 'ecr-url/repo:tag').
@@ -2099,9 +2108,9 @@ class NodeSnapshotStoreConfig(BaseModel):
     """
     Postgres DSN for snapshot-store metadata.
     """
-    cache_mb: Annotated[int | None, Field(title="Cache Mb")] = 0
+    cache_mb: Annotated[int | None, Field(title="Cache Mb")] = 10240
     """
-    Snapshot-store userspace decompressed page cache size in MB (0 to disable). This cache deduplicates pages by content hash across all manifests. For memory mounts (mount-mem): direct_io is disabled by default, so the kernel page cache already handles caching and deduplication for mmap'd files. Multiple VMs restoring from the same snapshot share kernel-cached pages automatically. The userspace cache is redundant here. For disk mounts (mount-tree): direct_io is enabled by default for overlay write coherency, bypassing the kernel cache. However, the userspace cache only helps for unmodified base image pages read by multiple VMs. Since disk workloads involve frequent writes (logs, temp files, databases), written pages are served from the overlay and bypass this cache entirely. The benefit is marginal for typical workloads. Recommendation: Leave at 0 for most deployments.
+    Snapshot-store userspace decompressed page cache size in MB (0 to disable). This cache deduplicates pages by content hash across all manifests. For memory mounts (mount-mem): direct_io is disabled by default, so the kernel page cache already handles caching and deduplication for mmap'd files. Multiple VMs restoring from the same snapshot share kernel-cached pages automatically. The userspace cache is less beneficial here but can still help. For disk mounts (mount-tree): direct_io is enabled by default for overlay write coherency, bypassing the kernel cache. The userspace cache is important here for read-heavy workloads (Docker builds, package installs, etc.) that read many base image pages. Without caching, every read goes through FUSE decompression. Recommendation: 512MB for most deployments, increase for heavy disk I/O workloads.
     """
     compression_workers: Annotated[int | None, Field(title="Compression Workers")] = 1
     """
@@ -4617,7 +4626,10 @@ class EnvFromResource(BaseModel):
     """
     Custom Docker image URL (ECR). If not set, uses default from settings.
     """
-    rootfs_storage_backend: Annotated[RootfsStorageBackend | str | None, Field(title="Rootfs Storage Backend")] = None
+    rootfs_storage_backend: Annotated[
+        RootfsStorageBackend | RootfsStorageBackend1 | str | None,
+        Field(title="Rootfs Storage Backend"),
+    ] = None
     """
     Storage backend for rootfs ('sparse-s3' or 'snapshot-store'). If not set, uses default.
     """