aisolate-client 0.3.0__tar.gz → 0.3.2__tar.gz

{aisolate_client-0.3.0 → aisolate_client-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aisolate-client
-Version: 0.3.0
+Version: 0.3.2
 Summary: Client library for sandbox environments
 License: Apache-2.0
 Requires-Python: >=3.10
@@ -16,7 +16,7 @@ Client library for sandbox environments
 ## Local Installation
 
 ```bash
-pip install path/to/aisolate_client-0.3.0-py3-none-any.whl
+pip install path/to/aisolate_client-0.3.2-py3-none-any.whl
 ```
 
 ## Usage

{aisolate_client-0.3.0 → aisolate_client-0.3.2}/README.md

@@ -5,7 +5,7 @@ Client library for sandbox environments
 ## Local Installation
 
 ```bash
-pip install path/to/aisolate_client-0.3.0-py3-none-any.whl
+pip install path/to/aisolate_client-0.3.2-py3-none-any.whl
 ```
 
 ## Usage

{aisolate_client-0.3.0 → aisolate_client-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aisolate-client"
-version = "0.3.0"
+version = "0.3.2"
 description = "Client library for sandbox environments"
 readme = "README.md"
 requires-python = ">=3.10"

{aisolate_client-0.3.0 → aisolate_client-0.3.2}/src/aisolate/client/exception.py

@@ -48,3 +48,29 @@ class SandboxError(Exception):
     """Raised for any errors related to the Sandbox lifecycle or execution."""
 
     pass
+
+
+def is_infrastructure_fault(exc: BaseException) -> bool:
+    """True when a sandbox call failed because the sandbox itself is broken —
+    VM gone, websocket dropped, gateway 5xx, or a request timeout — rather than
+    because executed user code raised.
+
+    Executed user-code errors come back as kernel *results* (the kernel captures
+    the traceback), never as these exceptions, so a caught ``Sandbox*Error`` is
+    always an infrastructure fault the run can recover from by re-provisioning a
+    fresh VM. A gateway 4xx (client misuse, e.g. a bad request) is deliberately
+    excluded — re-provisioning would not help.
+    """
+    if isinstance(
+        exc,
+        (
+            SandboxConnectionError,
+            SandboxTimeoutError,
+            SandboxWebSocketError,
+            SandboxError,
+        ),
+    ):
+        return True
+    if isinstance(exc, SandboxAPIError):
+        return exc.status_code is None or exc.status_code >= 500
+    return False

{aisolate_client-0.3.0 → aisolate_client-0.3.2}/src/aisolate/client/sandbox.py

@@ -222,6 +222,24 @@ class Sandbox:
         """Async context manager exit point. Closes the sandbox."""
         await self._async_close(exc_type, exc, tb)
 
+    async def areset(self) -> "Sandbox":
+        """Force a fresh VM under the same id: tear the current sandbox down
+        (best-effort — the VM may already be gone server-side) and start a new
+        one.
+
+        The recovery path when the gateway reports the VM lost (guest
+        crash/OOM). A plain ``astart()`` cannot do this: it no-ops while
+        ``_is_active`` is set, and that client-side flag cannot observe a
+        server-side VM death. Dropping ``_client`` forces ``_async_start`` to
+        build a fresh connection rather than reuse the broken one.
+        """
+        with contextlib.suppress(Exception):
+            await self._async_close(None, None, None)
+        self._is_active = False
+        self._client = None
+        await self._async_start()
+        return self
+
     def run_code(
         self,
         code: str,

aisolate_client-0.3.2/src/aisolate/client/tests/integration/conftest.py

@@ -0,0 +1,24 @@
+import importlib
+
+import pytest_asyncio
+
+# The driver lives in the shared test-support module so the agent e2e
+# harness can use the same no-VM wiring.
+from aisolate.common.tests.fake_vm import FakeDriver
+
+# Import fixtures from common fixtures module
+from aisolate.common.tests.fixtures import *
+
+
+@pytest_asyncio.fixture(autouse=True)
+async def _inject_fake_vm_driver(kernel_gateway_proc):
+    """Set the driver override BEFORE gateway_test_client enters the app
+    lifespan (autouse fixtures at the same scope run first), clear it and
+    close the fake sandbox stacks after the client has torn down."""
+    gateway_app = importlib.import_module("aisolate.gateway.app.main").app
+    driver = FakeDriver()
+    gateway_app.state.vm_driver_override = driver
+    yield
+    del gateway_app.state.vm_driver_override
+    for stack in driver.stacks:
+        await stack.aclose()

aisolate_client-0.3.2/src/aisolate/common/output_window.py

@@ -0,0 +1,58 @@
+"""The one honest output window, shared by every execution lane.
+
+``window_stream`` is the single windowing policy for observation channels
+(shell stdout/stderr, jupyter streams and expression results): output at or
+under the budget passes through BYTE-IDENTICAL; anything larger keeps head
+AND tail and carries one explicit footer in the ``[TRUNCATED …]`` marker
+family the agent prompts promise ("truncation is always explicit").
+
+This module is imported by the sandbox guest (``ShellExecutor``) and by the
+agent host (``RemotePythonExecutor``) — imports must stay stdlib-only, like
+``codec.py``.
+"""
+
+from __future__ import annotations
+
+#: Default window per stream/field, in characters (~1.5k tokens). Chosen for
+#: the post ``-ub 2048``/``--swa-full`` era: a complete 31-row table
+#: (~2.4 KB) is a normal observation and must pass whole.
+DEFAULT_OUTPUT_WINDOW = 6000
+
+#: Env var that overrides the window — delivered via the context-creation
+#: env (shell lane) and read at construction (jupyter lane).
+OUTPUT_WINDOW_ENV = "AISOLATE_OUTPUT_WINDOW"
+
+
+def window_stream(
+    text: str,
+    *,
+    budget: int,
+    label: str,
+    spool_ref: str | None = None,
+    guidance: str = "",
+) -> str:
+    """Window ``text`` to ``budget`` chars: head + footer + tail.
+
+    Returns ``text`` unchanged (byte-identical — prefix-cache stability of
+    the common case) when it fits the budget or the budget is unlimited
+    (``<= 0``). Otherwise keeps the first 2/3 and last 1/3 of the budget
+    around one footer line naming the stream, the total size, where the
+    full output lives (``spool_ref``), and what to do instead of re-running
+    (``guidance``).
+    """
+    if not text or budget <= 0 or len(text) <= budget:
+        return text
+
+    tail = budget // 3
+    head = budget - tail
+
+    footer = f"... [TRUNCATED {label} — {len(text):,} chars total"
+    if spool_ref:
+        footer += f"; full output: {spool_ref}"
+    if guidance:
+        footer += f"; {guidance}"
+    footer += "]"
+
+    return f"{text[:head]}\n{footer}\n{text[-tail:]}" if tail else (
+        f"{text[:head]}\n{footer}"
+    )

aisolate_client-0.3.2/src/aisolate/common/tests/fake_vm.py

@@ -0,0 +1,118 @@
+"""In-process stand-in for the VM layer — the no-firecracker test driver.
+
+``FakeDriver`` implements the gateway's ``VMDriver`` protocol by booting the
+REAL sandbox ASGI app in-process (lifespan and all — including its
+DirectKernelExecutor python3 kernel) and handing the gateway a ``VMHandle``
+whose session/WS are ASGI test clients. Injected through the
+``app.state.vm_driver_override`` seam (``gateway/app/factory.py``): the
+gateway lifespan constructs the real FirecrackerDriver only when no override
+is present, so this fake is the app's one driver for the whole test —
+including lifespan-shutdown teardown of the handles it created.
+
+``process_match`` returns ``False`` for everything: nothing the fake creates
+is a real VM process, so the dummy pid must never be signalled, sampled for
+PSS, or reaped.
+
+Shared home for the driver previously defined inline in
+``client/tests/integration/conftest.py`` (which now imports from here), used
+by the agent e2e harness (``agent/tests/test_e2e/``) as well.
+"""
+
+import asyncio
+import importlib
+from contextlib import AsyncExitStack
+from pathlib import Path
+from types import SimpleNamespace
+from urllib.parse import unquote
+
+from asgi_lifespan import LifespanManager
+
+from aisolate.common.tests.utils import WsAliasTestClient
+
+
+class SingleEncodeTestClient(WsAliasTestClient):
+    """Keep pre-quoted query strings single-encoded through the ASGI client.
+
+    ``async_asgi_testclient`` re-quotes the query it splits off the URL
+    (``utils.make_test_headers_path_and_query_string``, ``safe="&="``).
+    The GatewayClient and the gateway's proxy routers bake PRE-QUOTED
+    queries into their URLs (the vsock session forwards method+url only,
+    so the query must ride the URL) — the re-quote turns ``%2F`` into
+    ``%252F`` and workspace paths like ``<lineage>/task.md`` degrade into
+    literal ``<lineage>%2Ftask.md`` files. Un-quote once before dispatch
+    so the client's own re-quote restores the wire encoding.
+    """
+
+    async def open(self, path, **kwargs):
+        base, sep, query = path.partition("?")
+        if sep and kwargs.get("query_string") is None:
+            path = f"{base}?{unquote(query)}"
+        return await super().open(path, **kwargs)
+
+
+class DummyProcess(SimpleNamespace):
+    returncode = None
+    pid = 12345
+
+    async def wait(self):
+        return 0
+
+    def kill(self):
+        self.returncode = -9
+
+    def terminate(self):
+        return 0
+
+
+class FakeDriver:
+    """In-process VM 'driver': boots the sandbox ASGI app instead of a VM."""
+
+    def __init__(self):
+        # One stack per sandbox to avoid WebSocket reuse issues; closed
+        # by the injecting fixture after the gateway client has exited.
+        self.stacks = []
+
+    def process_match(self, cmdline: str) -> bool:
+        return False
+
+    async def create(self, sbx):
+        from aisolate.gateway.app.models.sandbox import (
+            SandboxConnection,
+            SocatProcess,
+            VMHandle,
+        )
+
+        sandbox_app = importlib.import_module("aisolate.sandbox.app.main").app
+
+        stack = AsyncExitStack()
+        self.stacks.append(stack)
+
+        # bring up the ASGI sandbox app so WS paths exist
+        await stack.enter_async_context(LifespanManager(sandbox_app))
+        # get a test client that supports HTTP + WS
+        async_client = await stack.enter_async_context(
+            SingleEncodeTestClient(sandbox_app)
+        )
+        ws = await stack.enter_async_context(async_client.websocket_connect("/execute"))
+
+        conn = SandboxConnection(
+            session=async_client,
+            ws=ws,
+            base_url="http://sandbox.local",
+        )
+        socat = SocatProcess(
+            process=DummyProcess(),
+            socket_path=Path("/tmp/dummy.sock"),
+            vsock_port=1080,
+            protocol="TCP",
+            remote_host="127.0.0.1",
+            remote_port=1080,
+        )
+
+        return VMHandle(
+            sandbox=sbx,
+            vm_proc=DummyProcess(),
+            conn=conn,
+            socat=socat,
+            log_forwarder_task=asyncio.create_task(asyncio.sleep(0)),  # dummy task
+        )

aisolate_client-0.3.2/src/aisolate/common/tests/test_output_window.py

@@ -0,0 +1,74 @@
+"""Unit tests for the shared output window policy."""
+
+from aisolate.common.output_window import window_stream
+
+
+class TestWindowStream:
+    def test_under_budget_is_byte_identical(self):
+        text = "a" * 100
+        assert window_stream(text, budget=100, label="stdout") is text
+
+    def test_at_budget_boundary_passes_unchanged(self):
+        text = "x" * 6000
+        assert window_stream(text, budget=6000, label="stdout") == text
+
+    def test_over_budget_keeps_head_and_tail(self):
+        text = "H" * 4000 + "M" * 50000 + "T" * 2000
+        out = window_stream(text, budget=6000, label="stdout")
+        assert out.startswith("H" * 4000)
+        assert out.endswith("T" * 2000)
+        assert "M" * 100 not in out
+
+    def test_footer_names_stream_and_total(self):
+        text = "y" * 51_340
+        out = window_stream(text, budget=6000, label="stdout")
+        assert "[TRUNCATED stdout — 51,340 chars total]" in out
+
+    def test_footer_carries_spool_ref_and_guidance(self):
+        out = window_stream(
+            "z" * 10_000,
+            budget=600,
+            label="stdout",
+            spool_ref=".aisolate/out/7.stdout",
+            guidance="view a window: sed -n '1,120p' .aisolate/out/7.stdout",
+        )
+        assert "full output: .aisolate/out/7.stdout" in out
+        assert "sed -n '1,120p'" in out
+        assert out.count("[TRUNCATED") == 1
+
+    def test_guidance_without_spool(self):
+        out = window_stream(
+            "z" * 10_000,
+            budget=600,
+            label="stdout",
+            guidance="the kernel still holds your data",
+        )
+        assert "the kernel still holds your data" in out
+        assert "full output:" not in out
+
+    def test_head_tail_split_is_two_thirds_one_third(self):
+        text = "".join(str(i % 10) for i in range(20_000))
+        out = window_stream(text, budget=6000, label="stderr")
+        head, _, rest = out.partition("\n... [TRUNCATED")
+        tail = rest.partition("]\n")[2]
+        assert head == text[:4000]
+        assert tail == text[-2000:]
+
+    def test_zero_or_negative_budget_disables_windowing(self):
+        text = "q" * 10_000
+        assert window_stream(text, budget=0, label="stdout") == text
+        assert window_stream(text, budget=-1, label="stdout") == text
+
+    def test_empty_text_passes(self):
+        assert window_stream("", budget=100, label="stdout") == ""
+
+    def test_tiny_budget_still_has_head(self):
+        out = window_stream("abcdefghij" * 10, budget=2, label="stdout")
+        assert out.startswith("ab")
+        assert "[TRUNCATED stdout" in out
+
+    def test_unicode_slicing_is_char_safe(self):
+        text = "ä" * 10_000
+        out = window_stream(text, budget=600, label="stdout")
+        assert out.startswith("ä" * 400)
+        assert out.endswith("ä" * 200)

{aisolate_client-0.3.0 → aisolate_client-0.3.2}/src/aisolate_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aisolate-client
-Version: 0.3.0
+Version: 0.3.2
 Summary: Client library for sandbox environments
 License: Apache-2.0
 Requires-Python: >=3.10
@@ -16,7 +16,7 @@ Client library for sandbox environments
 ## Local Installation
 
 ```bash
-pip install path/to/aisolate_client-0.3.0-py3-none-any.whl
+pip install path/to/aisolate_client-0.3.2-py3-none-any.whl
 ```
 
 ## Usage

{aisolate_client-0.3.0 → aisolate_client-0.3.2}/src/aisolate_client.egg-info/SOURCES.txt

@@ -19,9 +19,12 @@ src/aisolate/common/__init__.py
 src/aisolate/common/codec.py
 src/aisolate/common/errors.py
 src/aisolate/common/models.py
+src/aisolate/common/output_window.py
 src/aisolate/common/tests/__init__.py
+src/aisolate/common/tests/fake_vm.py
 src/aisolate/common/tests/fixtures.py
 src/aisolate/common/tests/test_codec_channel.py
+src/aisolate/common/tests/test_output_window.py
 src/aisolate/common/tests/utils.py
 src/aisolate_client.egg-info/PKG-INFO
 src/aisolate_client.egg-info/SOURCES.txt

aisolate_client-0.3.0/src/aisolate/client/tests/integration/conftest.py

@@ -1,101 +0,0 @@
-import asyncio
-import importlib
-from contextlib import AsyncExitStack
-from pathlib import Path
-from types import SimpleNamespace
-
-import pytest_asyncio
-from asgi_lifespan import LifespanManager
-from aisolate.common.tests.utils import WsAliasTestClient
-
-# Import fixtures from common fixtures module
-from aisolate.common.tests.fixtures import *
-
-
-class _DummyProcess(SimpleNamespace):
-    returncode = None
-    pid = 12345
-
-    async def wait(self):
-        return 0
-
-    def kill(self):
-        self.returncode = -9
-
-    def terminate(self):
-        return 0
-
-
-class FakeDriver:
-    """In-process VM 'driver': boots the sandbox ASGI app instead of a VM.
-
-    Injected through the ``app.state.vm_driver_override`` seam
-    (vmm-driver.plan.md WI-5): the gateway lifespan constructs the real
-    FirecrackerDriver only when no override is present, so this fake is
-    the app's one driver for the whole test — including lifespan-shutdown
-    teardown of the handles it created.
-    """
-
-    def __init__(self):
-        # One stack per sandbox to avoid WebSocket reuse issues; closed
-        # by the injecting fixture after the gateway client has exited.
-        self.stacks = []
-
-    def process_match(self, cmdline: str) -> bool:
-        # Nothing the fake creates is a real VM process: the dummy pid
-        # (12345) must never be signalled, sampled for PSS, or reaped.
-        return False
-
-    async def create(self, sbx):
-        from aisolate.gateway.app.models.sandbox import (
-            SandboxConnection,
-            SocatProcess,
-            VMHandle,
-        )
-
-        sandbox_app = importlib.import_module("aisolate.sandbox.app.main").app
-
-        stack = AsyncExitStack()
-        self.stacks.append(stack)
-
-        # bring up the ASGI sandbox app so WS paths exist
-        await stack.enter_async_context(LifespanManager(sandbox_app))
-        # get a test client that supports HTTP + WS
-        async_client = await stack.enter_async_context(WsAliasTestClient(sandbox_app))
-        ws = await stack.enter_async_context(async_client.websocket_connect("/execute"))
-
-        conn = SandboxConnection(
-            session=async_client,
-            ws=ws,
-            base_url="http://sandbox.local",
-        )
-        socat = SocatProcess(
-            process=_DummyProcess(),
-            socket_path=Path("/tmp/dummy.sock"),
-            vsock_port=1080,
-            protocol="TCP",
-            remote_host="127.0.0.1",
-            remote_port=1080,
-        )
-
-        return VMHandle(
-            sandbox=sbx,
-            vm_proc=_DummyProcess(),
-            conn=conn,
-            socat=socat,
-            log_forwarder_task=asyncio.create_task(asyncio.sleep(0)),  # dummy task
-        )
-
-
-@pytest_asyncio.fixture(autouse=True)
-async def _inject_fake_vm_driver(kernel_gateway_proc):
-    """Set the driver override BEFORE gateway_test_client enters the app
-    lifespan (autouse fixtures at the same scope run first), clear it and
-    close the fake sandbox stacks after the client has torn down."""
-    gateway_app = importlib.import_module("aisolate.gateway.app.main").app
-    driver = FakeDriver()
-    gateway_app.state.vm_driver_override = driver
-    yield
-    del gateway_app.state.vm_driver_override
-    for stack in driver.stacks:
-        await stack.aclose()