agentixx 0.2.2__tar.gz → 0.2.4__tar.gz

{agentixx-0.2.2 → agentixx-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentixx
-Version: 0.2.2
+Version: 0.2.4
 Summary: Sandboxed rollouts you call like typed Python (import as `agentix`)
 Project-URL: Homepage, https://github.com/Agentiix/Agentix
 Author: Agentiix

{agentixx-0.2.2 → agentixx-0.2.4}/agentix/__init__.py

@@ -24,7 +24,7 @@ from agentix.runtime.client import RemoteCallError, RuntimeClient
 from agentix.runtime.client._sio_facade import AsyncClientNamespace
 from agentix.sio import Namespace, RemoteSioError, register_namespace
 
-__version__ = "0.2.2"
+__version__ = "0.2.4"
 
 __all__ = [
     "AsyncClientNamespace",

{agentixx-0.2.2 → agentixx-0.2.4}/agentix/cli/build.py

@@ -87,13 +87,23 @@ def _stage_builder(dest: Path) -> None:
         (dest / fname).write_bytes(src.read_bytes())
 
 
-def _discover_plugin_nix(stage_plugin_dir: Path) -> list[str]:
-    """Find every `agentix.<short>/default.nix` shipped by installed wheels.
-
-    Returns the list of nix-relative paths (one per plugin) ready to drop
-    into the generated wrapper flake. Each plugin's default.nix is copied
-    into `stage_plugin_dir/<short>.nix` so the flake context is self-
-    contained — Nix won't follow absolute paths outside the flake root.
+def _discover_plugin_nix(stage_plugin_dir: Path, project_src: Path) -> list[str]:
+    """Find every `default.nix` that contributes system binaries to the bundle.
+
+    Two sources, in order:
+
+    1. Plugin wheels installed under the `agentix` namespace
+       (`agentix.<short>/default.nix`). These ship via `pip install
+       agentix-<plugin>` and are how runtime extensions add their CLI
+       deps (e.g. `agentix-runtime-basic` adds `bash`).
+    2. The **user project root**'s own `default.nix`, if present —
+       lets a project pull in extra binaries (`claude`, `ffmpeg`, ...)
+       without packaging a fake plugin.
+
+    Each discovered file is copied into `stage_plugin_dir/<name>.nix`
+    so the flake context is self-contained; Nix won't follow absolute
+    paths outside the flake root. Returns the list of nix-relative
+    paths ready to drop into the generated wrapper flake.
     """
     stage_plugin_dir.mkdir(parents=True)
     nix_paths: list[str] = []
@@ -101,18 +111,27 @@ def _discover_plugin_nix(stage_plugin_dir: Path) -> list[str]:
     try:
         agentix_root = resources.files("agentix")
     except (ModuleNotFoundError, FileNotFoundError):
-        return nix_paths
+        agentix_root = None
+
+    if agentix_root is not None:
+        for entry in agentix_root.iterdir():
+            if not entry.is_dir():
+                continue
+            nix_file = entry / "default.nix"
+            if not nix_file.is_file():
+                continue
+            short = entry.name
+            target = stage_plugin_dir / f"{short}.nix"
+            target.write_bytes(nix_file.read_bytes())
+            nix_paths.append(f"./plugins/{short}.nix")
+
+    # Project root default.nix, when present.
+    project_nix = project_src / "default.nix"
+    if project_nix.is_file():
+        target = stage_plugin_dir / "project.nix"
+        target.write_bytes(project_nix.read_bytes())
+        nix_paths.append("./plugins/project.nix")
 
-    for entry in agentix_root.iterdir():
-        if not entry.is_dir():
-            continue
-        nix_file = entry / "default.nix"
-        if not nix_file.is_file():
-            continue
-        short = entry.name
-        target = stage_plugin_dir / f"{short}.nix"
-        target.write_bytes(nix_file.read_bytes())
-        nix_paths.append(f"./plugins/{short}.nix")
     return nix_paths
 
 
@@ -274,7 +293,7 @@ def main(argv: Sequence[str] | None = None) -> int:
     def _stage(stage: Path) -> None:
         _stage_builder(stage / "_builder")
         _stage_project(src, stage / "project")
-        plugin_paths = _discover_plugin_nix(stage / "plugins")
+        plugin_paths = _discover_plugin_nix(stage / "plugins", src)
         wrapper = _render_wrapper(
             name=name,
             tag=tag,

{agentixx-0.2.2 → agentixx-0.2.4}/agentix/nix/wrapper.nix.tmpl

@@ -6,7 +6,13 @@
   outputs = { self, agentix }:
     let
       system = "@SYSTEM@";
-      pkgs = agentix.inputs.nixpkgs.legacyPackages.${system};
+      # Re-import nixpkgs with `config.allowUnfree = true` so plugin
+      # `default.nix` files can pull unfree binaries (e.g. claude CLI).
+      # Plugins that don't need unfree packages are unaffected.
+      pkgs = import agentix.inputs.nixpkgs {
+        inherit system;
+        config.allowUnfree = true;
+      };
     in {
       packages.${system}.bundle = agentix.lib.mkBundle {
         inherit pkgs;

agentixx-0.2.4/agentix/runtime/client/_sio_facade.py

@@ -0,0 +1,87 @@
+"""Host-side namespace helpers.
+
+`AsyncClientNamespace` is a thin subclass of `socketio.AsyncClientNamespace`
+that msgpack-wraps event payloads — so plugin authors write
+`await self.emit("x", {"a": 1})` and `async def on_x(self, data)`, and
+the bytes/msgpack wire format stays internal.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Any
+
+import socketio
+
+from agentix.runtime.shared.codec import pack, unpack
+
+logger = logging.getLogger("agentix.runtime.client.sio")
+
+
+def _decode(raw: Any) -> Any:
+    if isinstance(raw, memoryview):
+        raw = raw.tobytes()
+    elif isinstance(raw, bytearray):
+        raw = bytes(raw)
+    if isinstance(raw, bytes):
+        return unpack(raw)
+    return raw
+
+
+# Socket.IO lifecycle events run inline (they're cheap and ordering
+# matters); everything else is a user data event and is detached.
+_LIFECYCLE_EVENTS = frozenset({"connect", "disconnect", "connect_error"})
+
+
+class AsyncClientNamespace(socketio.AsyncClientNamespace):
+    """`socketio.AsyncClientNamespace` with msgpack at the boundary.
+
+    Override `on_<event>` for inbound; call `await self.emit(...)` for
+    outbound. Data is plain Python — packing happens automatically.
+
+    Data-event handlers are dispatched as **detached tasks**, never
+    awaited inline. `socketio.AsyncClient` awaits `trigger_event` inside
+    its single websocket receive loop — so a slow handler (e.g. one
+    that calls a slow LLM) would stall *every* inbound event on the
+    connection, including unrelated `c.remote` results. Detaching keeps
+    the receive loop free; handler ordering per event is still
+    preserved by the order tasks are created.
+    """
+
+    _detached_tasks: set[asyncio.Task]
+
+    async def emit(self, event: str, data: Any = None, **kwargs: Any) -> Any:
+        return await super().emit(event, pack(data), **kwargs)
+
+    async def trigger_event(self, event: str, *args: Any) -> Any:
+        if event in _LIFECYCLE_EVENTS:
+            # Lifecycle: run inline. No msgpack payload to unwrap.
+            return await super().trigger_event(event, *args)
+
+        # Data event: unwrap the msgpack payload, then dispatch detached.
+        if args and isinstance(args[0], (bytes, bytearray, memoryview)):
+            args = (_decode(args[0]),) + args[1:]
+
+        handler = getattr(self, "on_" + event, None)
+        if handler is None:
+            return None
+
+        result = handler(*args)
+        if asyncio.iscoroutine(result):
+            if not hasattr(self, "_detached_tasks"):
+                self._detached_tasks = set()
+            task = asyncio.create_task(self._guard(result, event))
+            self._detached_tasks.add(task)
+            task.add_done_callback(self._detached_tasks.discard)
+        return None
+
+    @staticmethod
+    async def _guard(coro: Any, event: str) -> None:
+        try:
+            await coro
+        except Exception:
+            logger.exception("namespace handler for %r raised", event)
+
+
+__all__ = ["AsyncClientNamespace"]

{agentixx-0.2.2 → agentixx-0.2.4}/agentix/runtime/server/worker/client.py

@@ -26,6 +26,11 @@ logger = logging.getLogger("agentix.runtime.server.worker.client")
 
 _WORKER_START_TIMEOUT = 15.0
 _DEFAULT_WORKER_PATH = "/usr/local/bin:/usr/bin:/bin"
+# Plugin `default.nix` derivations are symlink-joined into this path
+# inside the bundle image (see `agentix/nix/builder.nix`). Worker code
+# (`subprocess.run("claude", ...)`, `c.remote(cc.run, ...)`, ...) must
+# be able to find those binaries by bare name.
+_RUNTIME_BIN_PATH = "/nix/runtime/bin"
 _STRIPPED_ENV = {
     "LD_LIBRARY_PATH",
     "LD_PRELOAD",
@@ -43,7 +48,17 @@ def _clean_worker_env(runtime_bin_dir: Path | None) -> dict[str, str]:
         for key, value in os.environ.items()
         if key not in _STRIPPED_ENV and not any(key.startswith(prefix) for prefix in _STRIPPED_ENV_PREFIXES)
     }
-    env["PATH"] = f"{runtime_bin_dir}:{_DEFAULT_WORKER_PATH}" if runtime_bin_dir is not None else _DEFAULT_WORKER_PATH
+    # Build PATH from: the venv's bin (`runtime_bin_dir`), the bundle's
+    # symlink-join (`/nix/runtime/bin`), then a minimal system fallback.
+    # Inside the bundle image the first two are siblings and both must
+    # be searchable; outside the bundle, only the first one exists.
+    parts: list[str] = []
+    if runtime_bin_dir is not None:
+        parts.append(str(runtime_bin_dir))
+    if _RUNTIME_BIN_PATH not in parts:
+        parts.append(_RUNTIME_BIN_PATH)
+    parts.append(_DEFAULT_WORKER_PATH)
+    env["PATH"] = ":".join(parts)
     return env
 
 

{agentixx-0.2.2 → agentixx-0.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agentixx"
-version = "0.2.2"
+version = "0.2.4"
 description = "Sandboxed rollouts you call like typed Python (import as `agentix`)"
 readme = "README.md"
 requires-python = ">=3.11"

{agentixx-0.2.2 → agentixx-0.2.4}/tests/_namespace_target.py

@@ -27,6 +27,15 @@ async def echo_via_namespace(payload: dict) -> dict:
     return await svc.request("echo", payload, timeout=10.0)
 
 
+async def fire_namespace_event(payload: dict) -> str:
+    """Emit `slow` on `/plugin-test` and return immediately — does NOT
+    wait for the host handler. Used to prove a slow host handler does
+    not stall the runtime's other traffic."""
+    svc = _get()
+    await svc.emit("slow", payload)
+    return "fired"
+
+
 async def emit_log_line(message: str, level: str = "INFO") -> None:
     """Log via stdlib logging; the worker's log bridge ships it to host."""
     import logging

{agentixx-0.2.2 → agentixx-0.2.4}/tests/test_namespace_roundtrip.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 
 import asyncio
 import logging
+import time
 
 import pytest
 
@@ -15,6 +16,7 @@ from tests._namespace_target import (
     emit_log_line,
     emit_log_with_exception,
     emit_log_with_extra,
+    fire_namespace_event,
 )
 
 
@@ -49,6 +51,51 @@ async def test_plugin_namespace_round_trip(live_server):
     assert host_ns.seen[0]["data"] == {"hello": 1}
 
 
+class _SlowHost(AsyncClientNamespace):
+    """Host namespace whose `slow` handler blocks for a long time."""
+
+    def __init__(self, hold: float) -> None:
+        super().__init__("/plugin-test")
+        self._hold = hold
+        self.started = False
+        self.finished = False
+
+    async def on_slow(self, data):
+        self.started = True
+        await asyncio.sleep(self._hold)
+        self.finished = True
+
+
+@pytest.mark.asyncio
+async def test_slow_namespace_handler_does_not_block_runtime(live_server):
+    """A slow plugin handler must not stall the SIO receive loop —
+    otherwise unrelated `c.remote` results queue up behind it.
+
+    Regression: `socketio.AsyncClient` awaits `trigger_event` inline in
+    its single websocket receive loop. `AsyncClientNamespace` detaches
+    data-event handlers so a slow one can't freeze the connection.
+    """
+    base_url = await live_server()
+    slow_host = _SlowHost(hold=30.0)
+
+    client = RuntimeClient(base_url)
+    client.register_namespace(slow_host)
+    async with client as c:
+        # Fire the event whose host handler sleeps 30s.
+        await c.remote(fire_namespace_event, {"k": "v"})
+
+        # Immediately do a normal RPC. If the slow handler blocked the
+        # receive loop, this `call:result` would be stuck behind it for
+        # ~30s. With the fix it returns near-instantly.
+        t0 = time.perf_counter()
+        result = await asyncio.wait_for(c.remote(abs, -5), timeout=10)
+        elapsed = time.perf_counter() - t0
+
+    assert result == 5
+    assert elapsed < 8.0, f"runtime stalled behind slow handler: {elapsed:.1f}s"
+    assert slow_host.started, "slow handler never ran"
+
+
 @pytest.mark.asyncio
 async def test_log_records_arrive_on_host(live_server):
     """Verify the full /log experience: plain messages, %-format args,

agentixx-0.2.2/agentix/runtime/client/_sio_facade.py

@@ -1,47 +0,0 @@
-"""Host-side namespace helpers.
-
-`AsyncClientNamespace` is a thin subclass of `socketio.AsyncClientNamespace`
-that msgpack-wraps event payloads — so plugin authors write
-`await self.emit("x", {"a": 1})` and `async def on_x(self, data)`, and
-the bytes/msgpack wire format stays internal.
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-import socketio
-
-from agentix.runtime.shared.codec import pack, unpack
-
-
-def _decode(raw: Any) -> Any:
-    if isinstance(raw, memoryview):
-        raw = raw.tobytes()
-    elif isinstance(raw, bytearray):
-        raw = bytes(raw)
-    if isinstance(raw, bytes):
-        return unpack(raw)
-    return raw
-
-
-class AsyncClientNamespace(socketio.AsyncClientNamespace):
-    """`socketio.AsyncClientNamespace` with msgpack at the boundary.
-
-    Override `on_<event>` for inbound; call `await self.emit(...)` for
-    outbound. Data is plain Python — packing happens automatically.
-    """
-
-    async def emit(self, event: str, data: Any = None, **kwargs: Any) -> Any:
-        return await super().emit(event, pack(data), **kwargs)
-
-    async def trigger_event(self, event: str, *args: Any) -> Any:
-        # Unpack the single data payload (socketio always emits one arg
-        # for a bytes event). Lifecycle events (`connect`, `disconnect`)
-        # come with no data and we let them pass through untouched.
-        if args and isinstance(args[0], (bytes, bytearray, memoryview)):
-            args = (_decode(args[0]),) + args[1:]
-        return await super().trigger_event(event, *args)
-
-
-__all__ = ["AsyncClientNamespace"]