deepanalysts 0.9.2__tar.gz → 0.9.3__tar.gz

{deepanalysts-0.9.2 → deepanalysts-0.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepanalysts
-Version: 0.9.2
+Version: 0.9.3
 Summary: LangChain/LangGraph middleware for building AI agents with memory, skills, and filesystem support
 Author-email: Ganchuluun Narantsatsralt <tsatsralt@swifttech.cloud>
 License: MIT

{deepanalysts-0.9.2 → deepanalysts-0.9.3}/deepanalysts/backends/e2b.py

@@ -25,6 +25,7 @@ from __future__ import annotations
 
 import inspect
 import logging
+import threading
 import time
 from collections.abc import Callable, Sequence
 from dataclasses import dataclass
@@ -71,6 +72,15 @@ Verified against e2b 2.31.0 (`e2b/envd/rpc.py`, `e2b/exceptions.py`)."""
 _DEFAULT_WORKDIR = "/workspace"
 """Where the workspace bridge mounts agent files inside the sandbox."""
 
+_UPLOAD_BATCH_MAX_FILES = 100
+"""Files per `files.write_files` multipart request in `upload_files`."""
+
+_UPLOAD_BATCH_MAX_BYTES = 8 * 1024 * 1024
+"""Payload ceiling per `files.write_files` request. The SDK buffers a
+multipart body in memory and applies one request timeout to it, so a chunk
+stays small enough to finish well inside that timeout. A single file larger
+than this still goes alone in its own request."""
+
 
 _EGRESS_FLAG = "allow_internet_access"
 
@@ -114,6 +124,23 @@ def _ctor_accepts_egress_flag(ctor: Callable[..., Any]) -> bool:
     return False
 
 
+def _upload_chunks(files: Sequence[tuple[str, bytes]]) -> list[list[tuple[str, bytes]]]:
+    """Split uploads into request-sized chunks (by count and by bytes), in order."""
+    chunks: list[list[tuple[str, bytes]]] = []
+    current: list[tuple[str, bytes]] = []
+    current_bytes = 0
+    for path, content in files:
+        size = len(content)
+        if current and (len(current) >= _UPLOAD_BATCH_MAX_FILES or current_bytes + size > _UPLOAD_BATCH_MAX_BYTES):
+            chunks.append(current)
+            current, current_bytes = [], 0
+        current.append((path, content))
+        current_bytes += size
+    if current:
+        chunks.append(current)
+    return chunks
+
+
 def _classify_file_error(error: Exception) -> FileOperationError:
     """Map an E2B SDK exception to a structured per-file error code.
 
@@ -225,6 +252,12 @@ class E2BSandboxBackend(BaseSandbox):
         self._sandbox_class = sandbox_class
         self._closed = False
         self._expired = False
+        # Serializes lazy creation: two threads hitting an unstarted session
+        # (a host's background upload + a tool call) must not boot two VMs.
+        self._create_lock = threading.Lock()
+        # Makes "publish the new VM" and close() atomic with respect to each
+        # other, so a boot that finishes after close() is killed, not leaked.
+        self._state_lock = threading.Lock()
         # glob/grep scans are clamped to these trees (BaseSandbox scan safety);
         # a full-VM walk from "/" would run until the execute timeout kills it.
         # Default: the workdir. Pass additional read-only trees (e.g. baked
@@ -388,28 +421,31 @@ class E2BSandboxBackend(BaseSandbox):
         if self._expired:
             raise E2BSandboxError(self._expired_output())
         if self._sandbox is None:
-            self._sandbox = self._create_sandbox()
-            self._ttl_refreshed_at = time.monotonic()
-            # Materialize the workdir so cwd exists from command one. Root-
-            # level dirs like /workspace need root on the base template
-            # (commands run as `user` — live-verified: plain mkdir gets
-            # "Permission denied" and every later cwd= call then fails);
-            # chown hands the dir back to the command user.
+            self._boot_sandbox()
+        sandbox = self._sandbox
+        if sandbox is None:  # closed by another thread right after the boot
+            raise E2BSandboxError("This E2B sandbox session is closed.")
+        self._maybe_refresh_ttl()
+        return sandbox
+
+    def _bootstrap_workdir(self, sandbox: Any) -> None:
+        """Materialize the workdir so cwd exists from command one. Root-level
+        dirs like /workspace need root on the base template (commands run as
+        `user` — live-verified: plain mkdir gets "Permission denied" and every
+        later cwd= call then fails); chown hands the dir back to the user."""
+        try:
+            sandbox.commands.run(
+                f"mkdir -p {self._workdir} && chown user:user {self._workdir}",
+                user="root",
+            )
+        except TypeError:
+            # SDK without the `user` kwarg — best effort as default user.
             try:
-                self._sandbox.commands.run(
-                    f"mkdir -p {self._workdir} && chown user:user {self._workdir}",
-                    user="root",
-                )
-            except TypeError:
-                # SDK without the `user` kwarg — best effort as default user.
-                try:
-                    self._sandbox.commands.run(f"mkdir -p {self._workdir}")
-                except Exception:
-                    logger.warning("e2b workdir bootstrap failed", exc_info=True)
+                sandbox.commands.run(f"mkdir -p {self._workdir}")
             except Exception:
                 logger.warning("e2b workdir bootstrap failed", exc_info=True)
-        self._maybe_refresh_ttl()
-        return self._sandbox
+        except Exception:
+            logger.warning("e2b workdir bootstrap failed", exc_info=True)
 
     @property
     def started(self) -> bool:
@@ -417,19 +453,42 @@ class E2BSandboxBackend(BaseSandbox):
         return self._sandbox is not None and not self._closed
 
     def close(self) -> None:
-        """Kill the microVM. Idempotent; safe when never started."""
-        if self._sandbox is not None and not self._closed:
-            try:
-                self._sandbox.kill()
-                logger.info(
-                    "e2b sandbox killed id=%s",
-                    getattr(self._sandbox, "sandbox_id", "?"),
-                )
-            except Exception:
-                # the session_ttl reaps the VM server-side regardless.
-                logger.warning("e2b sandbox kill failed", exc_info=True)
-        self._closed = True
-        self._sandbox = None
+        """Kill the microVM. Idempotent; safe when never started, and safe
+        while another thread is still booting it (that boot kills its own VM
+        when it sees the session closed)."""
+        with self._state_lock:
+            sandbox, self._sandbox = self._sandbox, None
+            self._closed = True
+        if sandbox is not None:
+            self._kill(sandbox)
+
+    @staticmethod
+    def _kill(sandbox: Any) -> None:
+        try:
+            sandbox.kill()
+            logger.info("e2b sandbox killed id=%s", getattr(sandbox, "sandbox_id", "?"))
+        except Exception:
+            # the session_ttl reaps the VM server-side regardless.
+            logger.warning("e2b sandbox kill failed", exc_info=True)
+
+    def _boot_sandbox(self) -> None:
+        """Create the session's VM once, even under concurrent first use."""
+        with self._create_lock:
+            if self._sandbox is not None:
+                return  # another thread booted it while we waited
+            if self._closed:
+                raise E2BSandboxError("This E2B sandbox session is closed.")
+            sandbox = self._create_sandbox()
+            if not self._closed:
+                self._bootstrap_workdir(sandbox)
+            with self._state_lock:
+                closed_meanwhile = self._closed
+                if not closed_meanwhile:
+                    self._sandbox = sandbox
+                    self._ttl_refreshed_at = time.monotonic()
+            if closed_meanwhile:
+                self._kill(sandbox)
+                raise E2BSandboxError("This E2B sandbox session is closed.")
 
     # ------------------------------------------------------------------
     # SandboxBackendProtocol
@@ -507,7 +566,18 @@ class E2BSandboxBackend(BaseSandbox):
         return _classify_file_error(exc)
 
     def upload_files(self, files: list[tuple[str, bytes]]) -> list[FileUploadResponse]:
-        """Write files into the sandbox filesystem (workspace bridge down-sync)."""
+        """Write files into the sandbox filesystem (workspace bridge down-sync).
+
+        Files go up in chunks through the SDK's multipart `files.write_files`
+        (one HTTP request per chunk, not per file). Chunks are sent one after
+        another, never concurrently: concurrent writes against one live
+        microVM failed per file in prod (2026-09-15). `write_files` is
+        all-or-nothing, so a chunk that fails is retried file by file to keep
+        the per-file partial-success contract, unless the sandbox itself is
+        gone, which latches and fails the rest fast.
+        """
+        if not files:
+            return []
         try:
             sbx = self._ensure_sandbox()
         except E2BSandboxError:
@@ -515,6 +585,32 @@ class E2BSandboxBackend(BaseSandbox):
             code: FileOperationError = "sandbox_unavailable" if self._expired else "permission_denied"
             return [FileUploadResponse(path=p, error=code) for p, _ in files]
 
+        write_files = getattr(sbx.files, "write_files", None)
+        if not callable(write_files):
+            return self._upload_one_by_one(sbx, files)
+
+        responses: list[FileUploadResponse] = []
+        for chunk in _upload_chunks(files):
+            if self._expired:
+                responses.extend(FileUploadResponse(path=p, error="sandbox_unavailable") for p, _ in chunk)
+                continue
+            try:
+                write_files([{"path": path, "data": content} for path, content in chunk])
+                responses.extend(FileUploadResponse(path=p) for p, _ in chunk)
+            except Exception as exc:
+                if self._is_sandbox_gone_error(exc) and self._confirm_gone(exc):
+                    self._mark_expired()
+                    responses.extend(FileUploadResponse(path=p, error="sandbox_unavailable") for p, _ in chunk)
+                    continue
+                logger.warning(
+                    "e2b batched upload of %d file(s) failed; retrying one by one: %s",
+                    len(chunk),
+                    exc,
+                )
+                responses.extend(self._upload_one_by_one(sbx, chunk))
+        return responses
+
+    def _upload_one_by_one(self, sbx: Any, files: Sequence[tuple[str, bytes]]) -> list[FileUploadResponse]:
         responses: list[FileUploadResponse] = []
         for path, content in files:
             if self._expired:

{deepanalysts-0.9.2 → deepanalysts-0.9.3}/deepanalysts.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepanalysts
-Version: 0.9.2
+Version: 0.9.3
 Summary: LangChain/LangGraph middleware for building AI agents with memory, skills, and filesystem support
 Author-email: Ganchuluun Narantsatsralt <tsatsralt@swifttech.cloud>
 License: MIT

{deepanalysts-0.9.2 → deepanalysts-0.9.3}/deepanalysts.egg-info/SOURCES.txt

@@ -37,6 +37,7 @@ deepanalysts/utils/retry.py
 tests/test_basement.py
 tests/test_composite_backend.py
 tests/test_e2b_backend.py
+tests/test_e2b_batch_upload.py
 tests/test_e2b_integration.py
 tests/test_e2b_watch.py
 tests/test_e2b_watch_live.py

{deepanalysts-0.9.2 → deepanalysts-0.9.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "deepanalysts"
-version = "0.9.2"
+version = "0.9.3"
 description = "LangChain/LangGraph middleware for building AI agents with memory, skills, and filesystem support"
 readme = "README.md"
 license = { text = "MIT" }

deepanalysts-0.9.3/tests/test_e2b_batch_upload.py

@@ -0,0 +1,268 @@
+"""Regression tests: E2BSandboxBackend.upload_files batches its writes.
+
+Prod 2026-10-09: an agent run's workspace checkout uploaded 548 files with
+one `sbx.files.write` HTTP request EACH, sequentially (~0.31 s per file), and
+the run sat ~170 s before its first model call. The SDK's
+`files.write_files([...])` sends many files in one multipart request; these
+tests pin that upload_files uses it in bounded chunks while keeping the
+per-file partial-success contract callers rely on.
+"""
+
+from __future__ import annotations
+
+from deepanalysts.backends.e2b import (
+    _UPLOAD_BATCH_MAX_BYTES,
+    _UPLOAD_BATCH_MAX_FILES,
+    E2BSandboxBackend,
+)
+
+
+class TimeoutException(Exception):
+    """Name-matched like e2b's TimeoutException."""
+
+
+_DEAD_SANDBOX_MSG = (
+    "sandbox is probably not running anymore: This error is likely due to sandbox "
+    "timeout. You can modify the sandbox timeout by passing 'timeout' when starting "
+    "the sandbox or calling '.set_timeout' on the sandbox with the desired timeout."
+)
+
+
+class _Commands:
+    def run(self, command, timeout=None, cwd=None, user=None):
+        class _R:
+            stdout, stderr, exit_code = "", "", 0
+
+        return _R()
+
+
+class BatchingFakeSandbox:
+    """SDK-shaped fake exposing BOTH `files.write` and `files.write_files`.
+
+    Like the real SDK, `write_files` is all-or-nothing: if any entry would
+    fail, the whole request raises and nothing from that request lands.
+    Every call is recorded so tests can count HTTP requests.
+    """
+
+    def __init__(self):
+        self.sandbox_id = "fake-batch"
+        self.store: dict[str, bytes] = {}
+        self.write_errors: dict[str, Exception] = {}
+        self.batch_calls: list[list[str]] = []
+        self.single_calls: list[str] = []
+        self.alive = True
+        self.commands = _Commands()
+        self.files = self._Files(self)
+
+    class _Files:
+        def __init__(self, outer):
+            self._outer = outer
+
+        def write(self, path, data):
+            self._outer.single_calls.append(path)
+            if path in self._outer.write_errors:
+                raise self._outer.write_errors[path]
+            self._outer.store[path] = data
+
+        def write_files(self, files):
+            paths = [entry["path"] for entry in files]
+            self._outer.batch_calls.append(paths)
+            for path in paths:
+                if path in self._outer.write_errors:
+                    raise self._outer.write_errors[path]
+            for entry in files:
+                self._outer.store[entry["path"]] = entry["data"]
+            return [{"path": p} for p in paths]
+
+        def read(self, path, format="text"):
+            if path not in self._outer.store:
+                raise FileNotFoundError(f"file not found: {path}")
+            return self._outer.store[path]
+
+    def is_running(self, request_timeout=None):
+        return self.alive
+
+    def kill(self):
+        pass
+
+
+def _backend() -> tuple[E2BSandboxBackend, BatchingFakeSandbox]:
+    fake = BatchingFakeSandbox()
+    return E2BSandboxBackend(sandbox=fake), fake
+
+
+def _files(n: int, size: int = 10) -> list[tuple[str, bytes]]:
+    return [(f"/workspace/shared/f{i:04d}.md", bytes([65 + i % 26]) * size) for i in range(n)]
+
+
+class TestBatchedUpload:
+    def test_many_files_use_few_requests_not_one_per_file(self):
+        """The prod repro: 548 files must not cost 548 sequential requests."""
+        backend, fake = _backend()
+        files = _files(548)
+
+        responses = backend.upload_files(files)
+
+        assert [r.error for r in responses] == [None] * 548
+        assert fake.single_calls == []
+        expected_requests = -(-548 // _UPLOAD_BATCH_MAX_FILES)  # ceil
+        assert len(fake.batch_calls) == expected_requests
+        assert all(fake.store[p] == c for p, c in files)
+
+    def test_chunks_are_bounded_by_bytes(self):
+        backend, fake = _backend()
+        big = _UPLOAD_BATCH_MAX_BYTES // 2 + 1  # two of these never share a request
+        files = _files(3, size=big)
+
+        responses = backend.upload_files(files)
+
+        assert [r.error for r in responses] == [None, None, None]
+        assert [len(call) for call in fake.batch_calls] == [1, 1, 1]
+
+    def test_single_oversized_file_still_uploads_alone(self):
+        backend, fake = _backend()
+        files = _files(1, size=_UPLOAD_BATCH_MAX_BYTES + 5)
+
+        responses = backend.upload_files(files)
+
+        assert responses[0].error is None
+        assert fake.batch_calls == [[files[0][0]]]
+
+    def test_responses_keep_input_order(self):
+        backend, _fake = _backend()
+        files = _files(_UPLOAD_BATCH_MAX_FILES + 7)
+
+        responses = backend.upload_files(files)
+
+        assert [r.path for r in responses] == [p for p, _ in files]
+
+    def test_empty_upload_makes_no_request(self):
+        backend, fake = _backend()
+        assert backend.upload_files([]) == []
+        assert fake.batch_calls == [] and fake.single_calls == []
+
+
+class TestBatchFailureKeepsPerFileContract:
+    def test_one_bad_path_fails_only_that_file(self):
+        """write_files is all-or-nothing; a failed chunk is retried per file
+        so one EACCES path doesn't fail its 99 neighbours."""
+        backend, fake = _backend()
+        files = _files(5)
+        bad = files[2][0]
+        fake.write_errors[bad] = PermissionError("permission denied")
+
+        responses = backend.upload_files(files)
+
+        assert [r.error for r in responses] == [None, None, "permission_denied", None, None]
+        assert bad not in fake.store
+        assert all(fake.store[p] == c for p, c in files if p != bad)
+
+    def test_failure_in_one_chunk_does_not_degrade_other_chunks(self):
+        backend, fake = _backend()
+        files = _files(_UPLOAD_BATCH_MAX_FILES * 2)
+        bad = files[_UPLOAD_BATCH_MAX_FILES + 3][0]  # second chunk
+        fake.write_errors[bad] = PermissionError("permission denied")
+
+        backend.upload_files(files)
+
+        # chunk 1 and chunk 2 batched; only chunk 2 falls back per file
+        assert len(fake.batch_calls) == 2
+        assert len(fake.single_calls) == _UPLOAD_BATCH_MAX_FILES
+        assert set(fake.single_calls) == {p for p, _ in files[_UPLOAD_BATCH_MAX_FILES:]}
+
+    def test_dead_sandbox_latches_without_per_file_retries(self):
+        backend, fake = _backend()
+        fake.alive = False
+        files = _files(_UPLOAD_BATCH_MAX_FILES + 3)
+        fake.write_errors[files[0][0]] = TimeoutException(_DEAD_SANDBOX_MSG)
+
+        responses = backend.upload_files(files)
+
+        assert {r.error for r in responses} == {"sandbox_unavailable"}
+        assert backend.expired is True
+        assert len(fake.batch_calls) == 1  # later chunks short-circuited
+        assert fake.single_calls == []  # no 100 doomed per-file retries
+
+
+class TestSdkWithoutBatchWrite:
+    def test_falls_back_to_per_file_writes(self):
+        """Older SDKs / fakes exposing only files.write keep working."""
+        backend, fake = _backend()
+
+        class _OnlyWrite:
+            def write(self, path, data):
+                fake.single_calls.append(path)
+                fake.store[path] = data
+
+        fake.files = _OnlyWrite()
+        files = _files(3)
+
+        responses = backend.upload_files(files)
+
+        assert [r.error for r in responses] == [None, None, None]
+        assert all(fake.store[p] == c for p, c in files)
+
+
+class TestCloseDuringBoot:
+    """Regression (code review 2026-10-09): park now boots the VM in a
+    background preparation thread. If the run ends while that boot is still
+    in flight, close() runs first and finds no sandbox to kill; the boot then
+    completes and the microVM ran unowned until its TTL reaped it."""
+
+    def test_vm_finishing_boot_after_close_is_killed(self):
+        booted: list[BatchingFakeSandbox] = []
+        backend_ref: list[E2BSandboxBackend] = []
+
+        def factory():
+            vm = BatchingFakeSandbox()
+            vm.killed = False
+            vm.kill = lambda: setattr(vm, "killed", True)
+            booted.append(vm)
+            backend_ref[0].close()  # the run ended while the VM was booting
+            return vm
+
+        backend = E2BSandboxBackend(sandbox_factory=factory)
+        backend_ref.append(backend)
+
+        responses = backend.upload_files([("/workspace/a.md", b"x")])
+
+        assert len(booted) == 1
+        assert booted[0].killed is True
+        assert responses[0].error is not None
+        assert backend.started is False
+
+    def test_concurrent_first_use_boots_one_vm(self):
+        import threading
+        import time
+
+        booted: list[BatchingFakeSandbox] = []
+
+        def factory():
+            time.sleep(0.05)  # a boot takes a while; let the other thread arrive
+            vm = BatchingFakeSandbox()
+            booted.append(vm)
+            return vm
+
+        backend = E2BSandboxBackend(sandbox_factory=factory)
+        barrier = threading.Barrier(4)
+
+        def use():
+            barrier.wait()
+            backend.upload_files([(f"/workspace/{threading.get_ident()}.md", b"x")])
+
+        threads = [threading.Thread(target=use) for _ in range(4)]
+        for t in threads:
+            t.start()
+        for t in threads:
+            t.join()
+
+        assert len(booted) == 1
+
+    def test_close_after_boot_kills_once(self):
+        backend, fake = _backend()
+        kills: list[bool] = []
+        fake.kill = lambda: kills.append(True)
+        backend.upload_files([("/workspace/a.md", b"x")])
+        backend.close()
+        backend.close()
+        assert kills == [True]

{deepanalysts-0.9.2 → deepanalysts-0.9.3}/tests/test_e2b_integration.py

@@ -59,6 +59,43 @@ def test_files_roundtrip(backend):
     assert missing[0].error == "file_not_found"
 
 
+def test_batched_upload_many_nested_files(backend):
+    """Regression (prod 2026-10-09): a workspace checkout of hundreds of files
+    goes up in a few multipart requests and every byte lands, nested dirs
+    included (write_files creates parents)."""
+    import time
+
+    from deepanalysts.backends.e2b import _UPLOAD_BATCH_MAX_FILES
+
+    files = [(f"/workspace/batch/d{i % 7}/sub/f{i:03d}.md", f"file {i}\n".encode()) for i in range(250)]
+    started = time.monotonic()
+    up = backend.upload_files(files)
+    elapsed = time.monotonic() - started
+
+    assert [r.error for r in up] == [None] * len(files)
+    down = backend.download_files([p for p, _ in files[:: _UPLOAD_BATCH_MAX_FILES // 2]])
+    assert [d.content for d in down] == [c for _, c in files[:: _UPLOAD_BATCH_MAX_FILES // 2]]
+    count = backend.execute("find /workspace/batch -type f | wc -l")
+    assert count.output.strip() == "250"
+    # One request per file took ~0.3 s each in prod (75 s here); batched is a few requests.
+    assert elapsed < 20, f"250-file upload took {elapsed:.1f}s — batching regressed?"
+
+
+def test_batched_upload_failure_isolated_to_bad_path(backend):
+    """write_files is all-or-nothing; one root-owned path must fail alone."""
+    files = [
+        ("/workspace/iso/ok1.md", b"one"),
+        ("/proc/forbidden/x.md", b"nope"),
+        ("/workspace/iso/ok2.md", b"two"),
+    ]
+    up = backend.upload_files(files)
+    assert up[0].error is None
+    assert up[1].error is not None
+    assert up[2].error is None
+    down = backend.download_files(["/workspace/iso/ok1.md", "/workspace/iso/ok2.md"])
+    assert [d.content for d in down] == [b"one", b"two"]
+
+
 def test_base_sandbox_file_helpers(backend):
     """ls/read derive from execute() — prove they work inside the microVM."""
     backend.upload_files([("/workspace/notes/hello.md", b"# hi\nline2\n")])
@@ -162,3 +199,31 @@ def test_reaped_sandbox_classified_expired_and_fails_fast():
         assert down[0].error == "sandbox_unavailable"
     finally:
         b.close()
+
+
+def test_close_during_boot_kills_the_late_vm():
+    """Regression (code review 2026-10-09): a host closing the session while
+    a background thread is still booting it must not leave a running VM."""
+    import threading
+
+    from e2b import Sandbox
+
+    from deepanalysts.backends.e2b import E2BSandboxBackend
+
+    booted: list = []
+    backend_ref: list = []
+
+    def factory():
+        vm = Sandbox.create(api_key=os.environ["E2B_API_KEY"], timeout=120)
+        booted.append(vm)
+        backend_ref[0].close()  # the run ended while this VM was booting
+        return vm
+
+    backend = E2BSandboxBackend(sandbox_factory=factory)
+    backend_ref.append(backend)
+    worker = threading.Thread(target=backend.upload_files, args=([("/workspace/a.md", b"x")],))
+    worker.start()
+    worker.join(timeout=120)
+
+    assert len(booted) == 1
+    assert booted[0].is_running() is False