deepagents-microsandbox 1.0.0__py3-none-any.whl

deepagents_microsandbox/__init__.py

@@ -0,0 +1,21 @@
+"""Microsandbox integration for DeepAgents.
+
+This package provides:
+- MicrosandboxBackend: Sandbox backend for executing commands in Microsandbox containers
+- MicrosandboxProvider: Provider for managing Microsandbox lifecycle
+
+Example usage:
+    ```python
+    from deepagents_microsandbox import MicrosandboxBackend, MicrosandboxProvider
+
+    provider = MicrosandboxProvider(server_url="http://localhost:5555")
+    sandbox = provider.get_or_create(sandbox_id=None)
+    result = sandbox.execute("echo 'Hello'")
+    provider.delete(sandbox_id=sandbox.id)
+    ```
+"""
+
+from deepagents_microsandbox.backend import MicrosandboxBackend
+from deepagents_microsandbox.provider import MicrosandboxProvider
+
+__all__ = ["MicrosandboxBackend", "MicrosandboxProvider"]

deepagents_microsandbox/backend.py

@@ -0,0 +1,250 @@
+"""Microsandbox backend for DeepAgents.
+
+This module provides MicrosandboxBackend, a sandbox backend implementation
+that executes commands in Microsandbox containers.
+"""
+
+from __future__ import annotations
+import asyncio
+import base64
+from contextlib import asynccontextmanager
+from typing import TYPE_CHECKING, cast
+
+import aiohttp
+from deepagents.backends.protocol import ExecuteResponse, FileDownloadResponse, FileOperationError, FileUploadResponse
+from deepagents.backends.sandbox import BaseSandbox
+
+if TYPE_CHECKING:
+    from microsandbox import PythonSandbox
+
+
+class MicrosandboxBackend(BaseSandbox):
+    """Microsandbox backend for DeepAgents.
+
+    This backend executes commands in Microsandbox containers via the
+    Microsandbox SDK. It inherits from BaseSandbox, which provides
+    implementations for read, write, edit, grep, and glob operations
+    using shell commands executed via execute().
+
+    The Microsandbox SDK is async-only, so this backend uses asyncio.run()
+    to bridge sync execute() calls to the async API. For async callers,
+    use aexecute() directly for better performance.
+
+    Example:
+        ```python
+        from microsandbox import PythonSandbox
+        from deepagents_microsandbox import MicrosandboxBackend
+
+
+        async def main():
+            async with PythonSandbox.create(name="my-sandbox") as sandbox:
+                backend = MicrosandboxBackend(sandbox, sandbox.name)
+                result = backend.execute("echo 'Hello, World!'")
+                print(result.output)
+
+
+        asyncio.run(main())
+        ```
+    """
+
+    def __init__(
+        self,
+        sandbox: PythonSandbox,
+        sandbox_id: str,
+        *,
+        timeout: int = 30 * 60,
+    ) -> None:
+        """Initialize the Microsandbox backend.
+
+        Args:
+            sandbox: An active Microsandbox PythonSandbox instance.
+                Must already be started (inside async context manager or
+                after calling start()).
+            sandbox_id: Unique identifier for this sandbox instance.
+                Typically, in the format "namespace/name".
+            timeout: Command execution timeout in seconds. Default: 30 minutes.
+        """
+        self._sandbox = sandbox
+        self._sandbox_id = sandbox_id
+        self._timeout = timeout
+
+    @property
+    def id(self) -> str:
+        """Return the unique identifier for this sandbox."""
+        return self._sandbox_id
+
+    def execute(self, command: str) -> ExecuteResponse:
+        """Execute a command synchronously.
+
+        This method bridges to the async Microsandbox SDK by using
+        asyncio.run(). For async callers, use aexecute() instead.
+
+        Args:
+            command: Shell command to execute.
+
+        Returns:
+            ExecuteResponse with combined stdout/stderr output and exit code.
+        """
+        return asyncio.run(self.aexecute(command))
+
+    async def aexecute(self, command: str) -> ExecuteResponse:
+        """Execute a command asynchronously.
+
+        This is the native async implementation that directly calls
+        the Microsandbox SDK.
+
+        Args:
+            command: Shell command to execute.
+
+        Returns:
+            ExecuteResponse with combined stdout/stderr output and exit code.
+        """
+        async with self._ensure_session():
+            result = await self._sandbox.command.run(
+                command="bash",
+                args=["-c", command],
+                timeout=self._timeout,
+            )
+
+            # Get stdout and stderr
+            stdout = await result.output()
+            stderr = await result.error()
+
+        # Combine stdout and stderr (stderr appended if non-empty)
+        output = stdout
+        if stderr:
+            output += "\n" if not output.endswith("\n") else ""
+            output += stderr
+
+        # Truncate output if it exceeds limits (default 10MB) to prevent memory issues
+        # The underlying JSON-RPC still transfers everything, but we protect the agent here.
+        max_output_length = 10 * 1024 * 1024  # 10MB
+        truncated = False
+        if len(output) > max_output_length:
+            output = output[:max_output_length] + "\n... [Output truncated]"
+            truncated = True
+
+        return ExecuteResponse(
+            output=output,
+            exit_code=result.exit_code,
+            # ExecuteResponse protocol doesn't strictly define 'truncated' yet but it's good practice
+            # and might be supported in future versions or custom implementations.
+            # We ignore mypy check here if the attribute is missing in the installed version.
+            # truncated=truncated, # type: ignore
+        )
+
+    @asynccontextmanager
+    async def _ensure_session(self):
+        """Ensure the sandbox has a valid session for the current loop.
+
+        If the sandbox's session is closed or belongs to a different loop
+        (which happens when bridging sync calls via asyncio.run), this
+        creates a temporary session for the duration of the context.
+        """
+        session = getattr(self._sandbox, "_session", None)
+        try:
+            current_loop = asyncio.get_running_loop()
+        except RuntimeError:
+            current_loop = None
+
+        # Check if existing session is valid for this loop
+        if (
+            session is not None
+            and not session.closed
+            and getattr(session, "_loop", None) is current_loop
+        ):
+            yield
+            return
+
+        # Create a temporary session
+        async with aiohttp.ClientSession() as new_session:
+            old_session = session
+            # We have to access the private attribute to inject the session
+            # because the SDK doesn't expose a way to swap it.
+            self._sandbox._session = new_session  # noqa: SLF001
+            try:
+                yield
+            finally:
+                self._sandbox._session = old_session  # noqa: SLF001
+
+    def upload_files(self, files: list[tuple[str, bytes]]) -> list[FileUploadResponse]:
+        """Upload files to the sandbox via base64-encoded shell commands.
+
+        Microsandbox doesn't have a native file upload API, so we use
+        shell commands with base64 encoding to transfer file contents.
+        Content is split into chunks to avoid ARG_MAX limits.
+
+        Args:
+            files: List of (path, content) tuples to upload.
+
+        Returns:
+            List of FileUploadResponse objects, one per input file.
+        """
+        return asyncio.run(self._aupload_files(files))
+
+    async def _aupload_files(self, files: list[tuple[str, bytes]]) -> list[FileUploadResponse]:
+        return [await self._aupload_file(path, content) for path, content in files]
+
+    async def _aupload_file(self, file_path: str, content: bytes) -> FileUploadResponse:
+        """Upload a single file using chunked writes."""
+        # 1. Create parent directory
+        # 2. Truncate/create the file
+        cmd_init = f"mkdir -p \"$(dirname '{file_path}')\" && : > '{file_path}'"
+        result = await self.aexecute(cmd_init)
+        if result.exit_code != 0:
+            return FileUploadResponse(path=file_path, error="permission_denied") # Generic error
+
+        if not content:
+            return FileUploadResponse(path=file_path, error=None)
+
+        # 3. Append chunks avoiding ARG_MAX
+        # Typical ARG_MAX is ~128KB - 2MB. usage of 50KB chunks is safe.
+        chunk_size = 50 * 1024
+        
+        for i in range(0, len(content), chunk_size):
+            chunk = content[i : i + chunk_size]
+            chunk_b64 = base64.b64encode(chunk).decode("ascii")
+            
+            # append chunk to file
+            cmd_append = f"echo -n '{chunk_b64}' | base64 -d >> '{file_path}'"
+            result = await self.aexecute(cmd_append)
+            if result.exit_code != 0:
+                 return FileUploadResponse(path=file_path, error="permission_denied")
+
+        return FileUploadResponse(path=file_path, error=None)
+
+    def download_files(self, paths: list[str]) -> list[FileDownloadResponse]:
+        """Download files from the sandbox via base64-encoded shell commands.
+
+        Microsandbox doesn't have a native file download API, so we use
+        shell commands with base64 encoding to transfer file contents.
+
+        Args:
+            paths: List of file paths to download.
+
+        Returns:
+            List of FileDownloadResponse objects, one per input path.
+        """
+        return asyncio.run(self._adownload_files(paths))
+
+    async def _adownload_files(self, paths: list[str]) -> list[FileDownloadResponse]:
+        return [await self._adownload_file(path) for path in paths]
+
+    async def _adownload_file(self, file_path: str) -> FileDownloadResponse:
+        """Download a single file."""
+        cmd = (
+            f"[ -d '{file_path}' ] && echo '__IS_DIRECTORY__' && exit 1; "
+            f"[ ! -f '{file_path}' ] && echo '__FILE_NOT_FOUND__' && exit 1; "
+            f"base64 '{file_path}'"
+        )
+        result = await self.aexecute(cmd)
+
+        if result.exit_code == 0:
+            content = base64.b64decode(result.output.strip())
+            return FileDownloadResponse(path=file_path, content=content, error=None)
+
+        output = result.output.strip()
+        errors = {"__IS_DIRECTORY__": "is_directory", "__FILE_NOT_FOUND__": "file_not_found"}
+        error = cast("FileOperationError", errors.get(output, "permission_denied"))
+        return FileDownloadResponse(path=file_path, content=None, error=error)
+

deepagents_microsandbox/provider.py

@@ -0,0 +1,356 @@
+"""Microsandbox provider for DeepAgents.
+
+This module provides MicrosandboxProvider, a sandbox provider that manages
+the lifecycle of Microsandbox containers.
+"""
+
+from __future__ import annotations
+import asyncio
+import os
+import uuid
+from typing import Any
+
+import aiohttp
+from deepagents.backends.sandbox import SandboxInfo, SandboxListResponse, SandboxProvider
+from microsandbox import PythonSandbox
+
+from deepagents_microsandbox.backend import MicrosandboxBackend
+
+
+class MicrosandboxProvider(SandboxProvider[dict[str, Any]]):
+    """Microsandbox provider for managing sandbox lifecycle.
+
+    This provider creates, connects to, and deletes Microsandbox containers.
+    It integrates with the DeepAgents framework via the SandboxProvider interface.
+
+    The provider manages aiohttp.ClientSession instances manually rather than
+    using the async context manager pattern, since DeepAgents expects persistent
+    sandbox instances.
+
+    Sandbox IDs are in the format "namespace/name".
+
+    Example:
+        ```python
+        from deepagents_microsandbox import MicrosandboxProvider
+
+        provider = MicrosandboxProvider(server_url="http://localhost:5555", namespace="my-project")
+
+        # Create a new sandbox
+        sandbox = provider.get_or_create(
+            sandbox_id=None,
+            image="microsandbox/python",
+            memory=1024,
+        )
+
+        # Execute commands
+        result = sandbox.execute("python --version")
+
+        # Clean up
+        provider.delete(sandbox_id=sandbox.id)
+        ```
+    """
+
+    def __init__(
+        self,
+        server_url: str | None = None,
+        api_key: str | None = None,
+        namespace: str = "default",
+    ) -> None:
+        """Initialize the Microsandbox provider.
+
+        Args:
+            server_url: Microsandbox server URL. Defaults to MSB_SERVER_URL
+                environment variable or "http://127.0.0.1:5555".
+            api_key: API key for authentication. Defaults to MSB_API_KEY
+                environment variable.
+            namespace: Namespace for organizing sandboxes. Default: "default".
+        """
+        self._server_url = server_url or os.environ.get("MSB_SERVER_URL", "http://127.0.0.1:5555")
+        self._api_key = api_key or os.environ.get("MSB_API_KEY")
+        self._namespace = namespace
+
+        # Track active sandboxes and their sessions for cleanup
+        self._active_sandboxes: dict[str, tuple[PythonSandbox, aiohttp.ClientSession]] = {}
+
+        # Shared session for API calls (alist)
+        self._shared_session: aiohttp.ClientSession | None = None
+
+    async def close(self) -> None:
+        """Close the provider and release resources."""
+        if self._shared_session:
+            await self._shared_session.close()
+            self._shared_session = None
+
+        # Note: We don't automatically close active sandboxes here as they might be
+        # intended to persist. Use delete() for that.
+
+    def list(
+        self,
+        *,
+        cursor: str | None = None,
+        **kwargs: Any,  # noqa: ANN401
+    ) -> SandboxListResponse[dict[str, Any]]:
+        """Async list of sandboxes via the sandbox.metrics.get JSON-RPC endpoint.
+
+        Args:
+            cursor: Ignored (the API does not support pagination).
+            **kwargs: Optional provider-specific filters:
+                namespace: Namespace to query. Defaults to ``"*"`` (all).
+
+        Returns:
+            SandboxListResponse with sandbox info items and cursor=None.
+        """
+        return asyncio.run(self.alist(cursor=cursor, **kwargs))
+
+    async def alist(
+        self,
+        *,
+        cursor: str | None = None,
+        **kwargs: Any,  # noqa: ANN401
+    ) -> SandboxListResponse[dict[str, Any]]:
+        """Async list of sandboxes via the sandbox.metrics.get JSON-RPC endpoint.
+
+        Args:
+            cursor: Ignored (the API does not support pagination).
+            **kwargs: Optional provider-specific filters:
+                namespace: Namespace to query. Defaults to ``"*"`` (all).
+
+        Returns:
+            SandboxListResponse with sandbox info items and cursor=None.
+        """
+        namespace = kwargs.get("namespace", "*")
+
+        payload = {
+            "jsonrpc": "2.0",
+            "method": "sandbox.metrics.get",
+            "params": {"namespace": namespace},
+            "id": str(uuid.uuid4()),
+        }
+
+        headers: dict[str, str] = {"Content-Type": "application/json"}
+        if self._api_key:
+            headers["Authorization"] = f"Bearer {self._api_key}"
+
+        current_loop = asyncio.get_running_loop()
+        if (
+            self._shared_session is None
+            or self._shared_session.closed
+            or getattr(self._shared_session, "_loop", None) is not current_loop
+        ):
+            self._shared_session = aiohttp.ClientSession()
+
+        async with self._shared_session.post(
+            f"{self._server_url}/api/v1/rpc",
+            json=payload,
+            headers=headers,
+        ) as resp:
+            resp.raise_for_status()
+            data = await resp.json()
+
+        result = data.get("result", {})
+        sandboxes = result.get("sandboxes", [])
+
+        items: list[SandboxInfo[dict[str, Any]]] = []
+        for entry in sandboxes:
+            ns = entry.get("namespace", self._namespace)
+            name = entry.get("name", "")
+            metadata = {k: v for k, v in entry.items() if k not in ("namespace", "name")}
+            items.append(
+                SandboxInfo(
+                    sandbox_id=f"{ns}/{name}",
+                    metadata=metadata,  # type: ignore[arg-type]
+                )
+            )
+
+        return SandboxListResponse(items=items, cursor=None)
+
+    def get_or_create(
+        self,
+        *,
+        sandbox_id: str | None = None,
+        timeout: int = 180,
+        image: str | None = None,
+        memory: int = 512,
+        cpus: float = 1.0,
+        **kwargs: Any,  # noqa: ANN401, ARG002
+    ) -> MicrosandboxBackend:
+        """Get an existing sandbox or create a new one.
+
+        Args:
+            sandbox_id: Unique identifier of an existing sandbox to retrieve.
+                Format: "namespace/name" or just "name" (uses default namespace).
+                If None, creates a new sandbox with an auto-generated name.
+            timeout: Sandbox startup timeout in seconds. Default: 180.
+            image: Docker image to use. Default: Microsandbox Python image.
+            memory: Memory limit in MB. Default: 512.
+            cpus: CPU limit. Default: 1.0.
+            **kwargs: Additional arguments (ignored).
+
+        Returns:
+            MicrosandboxBackend instance connected to the sandbox.
+
+        Raises:
+            RuntimeError: If connection to an existing sandbox fails.
+        """
+        return asyncio.run(
+            self.aget_or_create(
+                sandbox_id=sandbox_id,
+                timeout=timeout,
+                image=image,
+                memory=memory,
+                cpus=cpus,
+            )
+        )
+
+    async def aget_or_create(
+        self,
+        *,
+        sandbox_id: str | None = None,
+        timeout: int = 180,
+        image: str | None = None,
+        memory: int = 512,
+        cpus: float = 1.0,
+        **kwargs: Any,  # noqa: ANN401, ARG002
+    ) -> MicrosandboxBackend:
+        """Async version of get_or_create.
+
+        Args:
+            sandbox_id: Unique identifier of an existing sandbox to retrieve.
+            timeout: Sandbox startup timeout in seconds. Default: 180.
+            image: Docker image to use. Default: Microsandbox Python image.
+            memory: Memory limit in MB. Default: 512.
+            cpus: CPU limit. Default: 1.0.
+            **kwargs: Additional arguments (ignored).
+
+        Returns:
+            MicrosandboxBackend instance connected to the sandbox.
+        """
+        # Parse sandbox_id to extract namespace and name
+        if sandbox_id is not None:
+            if "/" in sandbox_id:
+                namespace, name = sandbox_id.split("/", 1)
+            else:
+                namespace = self._namespace
+                name = sandbox_id
+        else:
+            namespace = self._namespace
+            name = None  # Auto-generate
+
+        # Check if we already have this sandbox active
+        full_id = f"{namespace}/{name}" if name else None
+        if full_id and full_id in self._active_sandboxes:
+            sandbox, _ = self._active_sandboxes[full_id]
+            return MicrosandboxBackend(sandbox, full_id)
+
+        # Create aiohttp session manually (not using context manager)
+        session = aiohttp.ClientSession()
+
+        try:
+            # Create PythonSandbox instance
+            sandbox = PythonSandbox(
+                server_url=self._server_url,
+                namespace=namespace,
+                name=name,
+                api_key=self._api_key,
+            )
+
+            # Inject our session
+            sandbox._session = session  # noqa: SLF001
+
+            # Start the sandbox
+            start_kwargs: dict[str, Any] = {
+                "timeout": float(timeout),
+                "memory": memory,
+                "cpus": cpus,
+            }
+            if image is not None:
+                start_kwargs["image"] = image
+
+            await sandbox.start(**start_kwargs)
+
+            # Get the actual sandbox ID (name may have been auto-generated)
+            actual_name = sandbox._name  # noqa: SLF001
+            full_sandbox_id = f"{namespace}/{actual_name}"
+
+            # Track the sandbox
+            self._active_sandboxes[full_sandbox_id] = (sandbox, session)
+
+            return MicrosandboxBackend(sandbox, full_sandbox_id)
+
+        except Exception:
+            # Clean up session on failure
+            await session.close()
+            raise
+
+    def delete(
+        self,
+        *,
+        sandbox_id: str,
+        **kwargs: Any,  # noqa: ANN401, ARG002
+    ) -> None:
+        """Delete a sandbox instance.
+
+        This method is idempotent - calling delete on a non-existent or
+        already-deleted sandbox will succeed without raising an error.
+
+        Args:
+            sandbox_id: Unique identifier of the sandbox to delete.
+                Format: "namespace/name".
+            **kwargs: Additional arguments (ignored).
+        """
+        asyncio.run(self.adelete(sandbox_id=sandbox_id))
+
+    async def adelete(
+        self,
+        *,
+        sandbox_id: str,
+        **kwargs: Any,  # noqa: ANN401, ARG002
+    ) -> None:
+        """Async version of delete.
+
+        Args:
+            sandbox_id: Unique identifier of the sandbox to delete.
+            **kwargs: Additional arguments (ignored).
+        """
+        # Normalize sandbox_id
+        if "/" not in sandbox_id:
+            sandbox_id = f"{self._namespace}/{sandbox_id}"
+
+        # Check if we have this sandbox tracked
+        if sandbox_id not in self._active_sandboxes:
+            # Sandbox not tracked - either never created or already deleted
+            # Idempotent: don't raise an error
+            return
+
+        sandbox, session = self._active_sandboxes.pop(sandbox_id)
+
+        current_loop = asyncio.get_running_loop()
+        
+        try:
+            # If session is invalid for current loop, use a temporary one for stopping
+            if (
+                session.closed 
+                or getattr(session, "_loop", None) is not current_loop
+            ):
+                async with aiohttp.ClientSession() as temp_session:
+                    # We need to temporarily set the session on the sandbox to stop it
+                    original_session = getattr(sandbox, "_session", None)
+                    sandbox._session = temp_session
+                    try:
+                        await sandbox.stop()
+                    finally:
+                        sandbox._session = original_session
+            else:
+                # Session is valid, just stop
+                await sandbox.stop()
+
+        except Exception:  # noqa: BLE001, S110, S112
+            # Ignore errors during stop (sandbox might already be stopped)
+            pass
+        finally:
+            # Only close the session if it belongs to the current loop
+            if (
+                not session.closed 
+                and getattr(session, "_loop", None) is current_loop
+            ):
+                await session.close()

deepagents_microsandbox-1.0.0.dist-info/METADATA

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: deepagents-microsandbox
+Version: 1.0.0
+Summary: Microsandbox backend for DeepAgents
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: deepagents>=0.3.10
+Requires-Dist: microsandbox>=0.1.8
+Description-Content-Type: text/markdown
+
+# deepagents-microsandbox
+
+Microsandbox backend for the [DeepAgents](https://github.com/shkarupa-alex/deepagents) framework. This package enables DeepAgents to launch and control isolated sandbox environments using [Microsandbox](https://github.com/shkarupa-alex/microsandbox).
+
+## Key Features
+
+- **Sandbox Provider**: Manages the lifecycle of microsandbox instances (create, list, delete).
+- **Sandbox Backend**: Provides a standard interface for file operations and command execution within a sandbox.
+- **DeepAgents Integration**: Fully compatible with the DeepAgents `SandboxProvider` and `SandboxBackend` interfaces.
+
+## Installation
+
+```bash
+pip install deepagents-microsandbox
+```
+
+## Usage
+
+```python
+from deepagents_microsandbox import MicrosandboxProvider
+
+# Initialize the provider connecting to a microsandbox server
+provider = MicrosandboxProvider(server_url="http://localhost:5555")
+
+# Create or get a sandbox
+sandbox = provider.get_or_create(sandbox_id=None)
+
+# Execute a command
+result = sandbox.execute("echo 'Hello World'")
+print(result.stdout)
+
+# Clean up
+provider.delete(sandbox_id=sandbox.id)
+```
+
+## Development
+
+This project uses `uv` for dependency management.
+
+### Prerequisites
+
+- [uv](https://github.com/astral-sh/uv) installed.
+- Python 3.11 or higher.
+
+### Setup
+
+Install dependencies:
+
+```bash
+uv sync
+```
+
+### Testing
+
+Tests are split into unit tests (mocked) and integration tests (requiring a real server).
+
+**Run Unit Tests (Mocked)**
+These tests mock the HTTP interactions and do not require a running server.
+```bash
+uv run pytest
+```
+
+**Run Integration Tests**
+These tests verify behavior against a real microsandbox server.
+1. Start a microsandbox server in dev mode:
+   ```bash
+   msb server start --dev
+   ```
+2. Run the tests with the environment variable:
+   ```bash
+   MICROSANDBOX_DEV_SERVER=http://127.0.0.1:5555 uv run pytest
+   ```

deepagents_microsandbox-1.0.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+deepagents_microsandbox/__init__.py,sha256=8MCy9kr-EqB-sxq4uvcPeLYVkdh683csCHK9J6xANZo,755
+deepagents_microsandbox/backend.py,sha256=Pq-Byw5saaSiIONPGZ79pzLdxqZWWhhEgLFdheT-LMM,9489
+deepagents_microsandbox/provider.py,sha256=M0hG4aUwSakgYvkKpcBZWuVMR-JvguFKjbrBYIyhKd8,12305
+deepagents_microsandbox-1.0.0.dist-info/METADATA,sha256=_fV8jFwH4_H0b2UTU1JGy09CDjoSb9JewoISb_3KWWA,2148
+deepagents_microsandbox-1.0.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+deepagents_microsandbox-1.0.0.dist-info/licenses/LICENSE,sha256=3PvsVOKxa67dur4MbUpUsjPIHomzUPIZ2fJ72Ntzkz4,1070
+deepagents_microsandbox-1.0.0.dist-info/RECORD,,

deepagents_microsandbox-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

deepagents_microsandbox-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shkarupa Alex
+
+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.