tactus 0.27.0__py3-none-any.whl → 0.28.0__py3-none-any.whl

tactus/__init__.py

@@ -5,7 +5,7 @@ Tactus provides a declarative workflow engine for AI agents with pluggable
 backends for storage, HITL, and chat recording.
 """
 
-__version__ = "0.27.0"
+__version__ = "0.28.0"
 
 # Core exports
 from tactus.core.runtime import TactusRuntime

tactus/adapters/broker_log.py

@@ -7,10 +7,10 @@ host-side broker without requiring container networking.
 
 from __future__ import annotations
 
+import asyncio
+import threading
 from typing import Optional
 
-from asyncer import syncify
-
 from tactus.broker.client import BrokerClient
 from tactus.protocols.models import LogEvent, CostEvent
 
@@ -25,6 +25,19 @@ class BrokerLogHandler:
     def __init__(self, client: BrokerClient):
         self._client = client
         self.cost_events: list[CostEvent] = []
+        self._loop: Optional[asyncio.AbstractEventLoop] = None
+        self._loop_lock = threading.Lock()
+
+    def _get_or_create_loop(self) -> asyncio.AbstractEventLoop:
+        """Get the event loop, creating one if needed for cross-thread calls."""
+        with self._loop_lock:
+            if self._loop is None or self._loop.is_closed():
+                try:
+                    self._loop = asyncio.get_running_loop()
+                except RuntimeError:
+                    # No running loop - create a new one
+                    self._loop = asyncio.new_event_loop()
+            return self._loop
 
     @classmethod
     def from_environment(cls) -> Optional["BrokerLogHandler"]:
@@ -49,7 +62,15 @@ class BrokerLogHandler:
 
         # Best-effort forwarding; never crash the procedure due to streaming.
         try:
-            syncify(self._client.emit_event)(event_dict)
+            # Try to get the running loop first
+            try:
+                loop = asyncio.get_running_loop()
+                # We're in an async context - schedule and don't wait
+                loop.create_task(self._client.emit_event(event_dict))
+            except RuntimeError:
+                # No running loop - we're being called from a sync thread.
+                # Use asyncio.run() which creates a new event loop for this call.
+                asyncio.run(self._client.emit_event(event_dict))
         except Exception:
             # Swallow errors; container remains networkless and secretless even if streaming fails.
-            return
+            pass

tactus/broker/client.py

@@ -17,6 +17,7 @@ import uuid
 from pathlib import Path
 from typing import Any, AsyncIterator, Optional
 
+from tactus.broker.protocol import read_message, write_message
 from tactus.broker.stdio import STDIO_REQUEST_PREFIX, STDIO_TRANSPORT_VALUE
 
 
@@ -161,19 +162,11 @@ class BrokerClient:
                     ssl_ctx.verify_mode = ssl.CERT_NONE
 
             reader, writer = await asyncio.open_connection(host, port, ssl=ssl_ctx)
-            writer.write(
-                (_json_dumps({"id": req_id, "method": method, "params": params}) + "\n").encode(
-                    "utf-8"
-                )
-            )
-            await writer.drain()
+            await write_message(writer, {"id": req_id, "method": method, "params": params})
 
             try:
                 while True:
-                    line = await reader.readline()
-                    if not line:
-                        return
-                    event = json.loads(line.decode("utf-8"))
+                    event = await read_message(reader)
                     if event.get("id") != req_id:
                         continue
                     yield event
@@ -187,17 +180,11 @@ class BrokerClient:
                     pass
 
         reader, writer = await asyncio.open_unix_connection(self.socket_path)
-        writer.write(
-            (_json_dumps({"id": req_id, "method": method, "params": params}) + "\n").encode("utf-8")
-        )
-        await writer.drain()
+        await write_message(writer, {"id": req_id, "method": method, "params": params})
 
         try:
             while True:
-                line = await reader.readline()
-                if not line:
-                    return
-                event = json.loads(line.decode("utf-8"))
+                event = await read_message(reader)
                 # Ignore unrelated messages (defensive; current server is 1-req/conn).
                 if event.get("id") != req_id:
                     continue

tactus/broker/protocol.py

@@ -0,0 +1,183 @@
+"""
+Length-prefixed JSON protocol for broker communication.
+
+This module provides utilities for sending and receiving JSON messages
+with a length prefix, avoiding the buffer size limitations of newline-delimited JSON.
+
+Wire format:
+    <10-digit-decimal-length>\n<json-payload>
+
+Example:
+    0000000123
+    {"id":"abc","method":"llm.chat","params":{...}}
+"""
+
+import json
+import asyncio
+import logging
+from typing import Any, Dict, AsyncIterator
+
+import anyio
+from anyio.streams.buffered import BufferedByteReceiveStream
+
+logger = logging.getLogger(__name__)
+
+# Length prefix is exactly 10 decimal digits + newline
+LENGTH_PREFIX_SIZE = 11  # "0000000123\n"
+MAX_MESSAGE_SIZE = 100 * 1024 * 1024  # 100MB safety limit
+
+
+async def write_message(writer: asyncio.StreamWriter, message: Dict[str, Any]) -> None:
+    """
+    Write a JSON message with length prefix.
+
+    Args:
+        writer: asyncio StreamWriter
+        message: Dictionary to encode as JSON
+
+    Raises:
+        ValueError: If message is too large
+    """
+    json_bytes = json.dumps(message).encode("utf-8")
+    length = len(json_bytes)
+
+    if length > MAX_MESSAGE_SIZE:
+        raise ValueError(f"Message size {length} exceeds maximum {MAX_MESSAGE_SIZE}")
+
+    # Write 10-digit length prefix + newline
+    length_prefix = f"{length:010d}\n".encode("ascii")
+    writer.write(length_prefix)
+    writer.write(json_bytes)
+    await writer.drain()
+
+
+async def read_message(reader: asyncio.StreamReader) -> Dict[str, Any]:
+    """
+    Read a JSON message with length prefix.
+
+    Args:
+        reader: asyncio StreamReader
+
+    Returns:
+        Parsed JSON message as dictionary
+
+    Raises:
+        EOFError: If connection closed
+        ValueError: If message is invalid or too large
+    """
+    # Read exactly 11 bytes for length prefix
+    length_bytes = await reader.readexactly(LENGTH_PREFIX_SIZE)
+
+    if not length_bytes:
+        raise EOFError("Connection closed")
+
+    try:
+        length_str = length_bytes[:10].decode("ascii")
+        length = int(length_str)
+    except (ValueError, UnicodeDecodeError) as e:
+        raise ValueError(f"Invalid length prefix: {length_bytes!r}") from e
+
+    if length > MAX_MESSAGE_SIZE:
+        raise ValueError(f"Message size {length} exceeds maximum {MAX_MESSAGE_SIZE}")
+
+    if length == 0:
+        raise ValueError("Zero-length message not allowed")
+
+    # Read exactly that many bytes for the JSON payload
+    json_bytes = await reader.readexactly(length)
+
+    try:
+        message = json.loads(json_bytes.decode("utf-8"))
+    except (json.JSONDecodeError, UnicodeDecodeError) as e:
+        raise ValueError("Invalid JSON payload") from e
+
+    return message
+
+
+async def read_messages(reader: asyncio.StreamReader) -> AsyncIterator[Dict[str, Any]]:
+    """
+    Read a stream of length-prefixed JSON messages.
+
+    Args:
+        reader: asyncio StreamReader
+
+    Yields:
+        Parsed JSON messages as dictionaries
+
+    Stops when connection is closed or error occurs.
+    """
+    try:
+        while True:
+            message = await read_message(reader)
+            yield message
+    except EOFError:
+        return
+    except asyncio.IncompleteReadError:
+        return
+
+
+# AnyIO-compatible versions for broker server
+async def write_message_anyio(stream: anyio.abc.ByteStream, message: Dict[str, Any]) -> None:
+    """
+    Write a JSON message with length prefix using AnyIO streams.
+
+    Args:
+        stream: anyio ByteStream
+        message: Dictionary to encode as JSON
+
+    Raises:
+        ValueError: If message is too large
+    """
+    json_bytes = json.dumps(message).encode("utf-8")
+    length = len(json_bytes)
+
+    if length > MAX_MESSAGE_SIZE:
+        raise ValueError(f"Message size {length} exceeds maximum {MAX_MESSAGE_SIZE}")
+
+    # Write 10-digit length prefix + newline
+    length_prefix = f"{length:010d}\n".encode("ascii")
+    await stream.send(length_prefix)
+    await stream.send(json_bytes)
+
+
+async def read_message_anyio(stream: BufferedByteReceiveStream) -> Dict[str, Any]:
+    """
+    Read a JSON message with length prefix using AnyIO streams.
+
+    Args:
+        stream: anyio BufferedByteReceiveStream
+
+    Returns:
+        Parsed JSON message as dictionary
+
+    Raises:
+        EOFError: If connection closed
+        ValueError: If message is invalid or too large
+    """
+    # Read exactly 11 bytes for length prefix
+    length_bytes = await stream.receive_exactly(LENGTH_PREFIX_SIZE)
+
+    if not length_bytes:
+        raise EOFError("Connection closed")
+
+    try:
+        length_str = length_bytes[:10].decode("ascii")
+        length = int(length_str)
+    except (ValueError, UnicodeDecodeError) as e:
+        raise ValueError(f"Invalid length prefix: {length_bytes!r}") from e
+
+    if length > MAX_MESSAGE_SIZE:
+        raise ValueError(f"Message size {length} exceeds maximum {MAX_MESSAGE_SIZE}")
+
+    if length == 0:
+        raise ValueError("Zero-length message not allowed")
+
+    # Read exactly that many bytes for the JSON payload
+    json_bytes = await stream.receive_exactly(length)
+
+    try:
+        message = json.loads(json_bytes.decode("utf-8"))
+    except (json.JSONDecodeError, UnicodeDecodeError) as e:
+        raise ValueError("Invalid JSON payload") from e
+
+    return message

tactus/broker/server.py

@@ -15,6 +15,12 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Optional
 
+import anyio
+from anyio.streams.buffered import BufferedByteReceiveStream
+from anyio.streams.tls import TLSStream
+
+from tactus.broker.protocol import read_message_anyio, write_message_anyio
+
 logger = logging.getLogger(__name__)
 
 
@@ -22,9 +28,9 @@ def _json_dumps(obj: Any) -> str:
     return json.dumps(obj, ensure_ascii=False, separators=(",", ":"))
 
 
-async def _write_event(writer: asyncio.StreamWriter, event: dict[str, Any]) -> None:
-    writer.write((_json_dumps(event) + "\n").encode("utf-8"))
-    await writer.drain()
+async def _write_event_anyio(stream: anyio.abc.ByteStream, event: dict[str, Any]) -> None:
+    """Write an event using length-prefixed protocol."""
+    await write_message_anyio(stream, event)
 
 
 @dataclass(frozen=True)
@@ -115,7 +121,7 @@ class _BaseBrokerServer:
         tool_registry: Optional[HostToolRegistry] = None,
         event_handler: Optional[Callable[[dict[str, Any]], None]] = None,
     ):
-        self._server: Optional[asyncio.AbstractServer] = None
+        self._listener = None
         self._openai = openai_backend or OpenAIChatBackend()
         self._tools = tool_registry or HostToolRegistry.default()
         self._event_handler = event_handler
@@ -123,11 +129,16 @@ class _BaseBrokerServer:
     async def start(self) -> None:
         raise NotImplementedError
 
+    async def serve(self) -> None:
+        """Serve connections (blocks until listener is closed)."""
+        if self._listener is None:
+            raise RuntimeError("Server not started - call start() first")
+        await self._listener.serve(self._handle_connection)
+
     async def aclose(self) -> None:
-        if self._server is not None:
-            self._server.close()
-            await self._server.wait_closed()
-            self._server = None
+        if self._listener is not None:
+            await self._listener.aclose()
+            self._listener = None
 
     async def __aenter__(self) -> "_BaseBrokerServer":
         await self.start()
@@ -136,22 +147,27 @@ class _BaseBrokerServer:
     async def __aexit__(self, exc_type, exc, tb) -> None:
         await self.aclose()
 
-    async def _handle_connection(
-        self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter
-    ) -> None:
-        try:
-            line = await reader.readline()
-            if not line:
-                return
+    async def _handle_connection(self, byte_stream: anyio.abc.ByteStream) -> None:
+        # For TLS connections, wrap the stream with TLS
+        # Note: TcpBrokerServer subclass can override self.ssl_context
+        if hasattr(self, "ssl_context") and self.ssl_context is not None:
+            byte_stream = await TLSStream.wrap(
+                byte_stream, ssl_context=self.ssl_context, server_side=True
+            )
+
+        # Wrap the stream for buffered reading
+        buffered_stream = BufferedByteReceiveStream(byte_stream)
 
-            req = json.loads(line.decode("utf-8"))
+        try:
+            # Use length-prefixed protocol to handle arbitrarily large messages
+            req = await read_message_anyio(buffered_stream)
             req_id = req.get("id")
             method = req.get("method")
             params = req.get("params") or {}
 
             if not req_id or not method:
-                await _write_event(
-                    writer,
+                await _write_event_anyio(
+                    byte_stream,
                     {
                         "id": req_id or "",
                         "event": "error",
@@ -161,19 +177,19 @@ class _BaseBrokerServer:
                 return
 
             if method == "events.emit":
-                await self._handle_events_emit(req_id, params, writer)
+                await self._handle_events_emit(req_id, params, byte_stream)
                 return
 
             if method == "llm.chat":
-                await self._handle_llm_chat(req_id, params, writer)
+                await self._handle_llm_chat(req_id, params, byte_stream)
                 return
 
             if method == "tool.call":
-                await self._handle_tool_call(req_id, params, writer)
+                await self._handle_tool_call(req_id, params, byte_stream)
                 return
 
-            await _write_event(
-                writer,
+            await _write_event_anyio(
+                byte_stream,
                 {
                     "id": req_id,
                     "event": "error",
@@ -184,8 +200,8 @@ class _BaseBrokerServer:
         except Exception as e:
             logger.debug("[BROKER] Connection handler error", exc_info=True)
             try:
-                await _write_event(
-                    writer,
+                await _write_event_anyio(
+                    byte_stream,
                     {
                         "id": "",
                         "event": "error",
@@ -196,18 +212,17 @@ class _BaseBrokerServer:
                 pass
         finally:
             try:
-                writer.close()
-                await writer.wait_closed()
+                await byte_stream.aclose()
             except Exception:
                 pass
 
     async def _handle_events_emit(
-        self, req_id: str, params: dict[str, Any], writer: asyncio.StreamWriter
+        self, req_id: str, params: dict[str, Any], byte_stream: anyio.abc.ByteStream
     ) -> None:
         event = params.get("event")
         if not isinstance(event, dict):
-            await _write_event(
-                writer,
+            await _write_event_anyio(
+                byte_stream,
                 {
                     "id": req_id,
                     "event": "error",
@@ -222,15 +237,15 @@ class _BaseBrokerServer:
         except Exception:
             logger.debug("[BROKER] event_handler raised", exc_info=True)
 
-        await _write_event(writer, {"id": req_id, "event": "done", "data": {"ok": True}})
+        await _write_event_anyio(byte_stream, {"id": req_id, "event": "done", "data": {"ok": True}})
 
     async def _handle_llm_chat(
-        self, req_id: str, params: dict[str, Any], writer: asyncio.StreamWriter
+        self, req_id: str, params: dict[str, Any], byte_stream: anyio.abc.ByteStream
     ) -> None:
         provider = params.get("provider") or "openai"
         if provider != "openai":
-            await _write_event(
-                writer,
+            await _write_event_anyio(
+                byte_stream,
                 {
                     "id": req_id,
                     "event": "error",
@@ -249,8 +264,8 @@ class _BaseBrokerServer:
         max_tokens = params.get("max_tokens")
 
         if not isinstance(model, str) or not model:
-            await _write_event(
-                writer,
+            await _write_event_anyio(
+                byte_stream,
                 {
                     "id": req_id,
                     "event": "error",
@@ -259,8 +274,8 @@ class _BaseBrokerServer:
             )
             return
         if not isinstance(messages, list):
-            await _write_event(
-                writer,
+            await _write_event_anyio(
+                byte_stream,
                 {
                     "id": req_id,
                     "event": "error",
@@ -291,12 +306,12 @@ class _BaseBrokerServer:
                         continue
 
                     full_text += text
-                    await _write_event(
-                        writer, {"id": req_id, "event": "delta", "data": {"text": text}}
+                    await _write_event_anyio(
+                        byte_stream, {"id": req_id, "event": "delta", "data": {"text": text}}
                     )
 
-                await _write_event(
-                    writer,
+                await _write_event_anyio(
+                    byte_stream,
                     {
                         "id": req_id,
                         "event": "done",
@@ -325,8 +340,8 @@ class _BaseBrokerServer:
             except Exception:
                 text = ""
 
-            await _write_event(
-                writer,
+            await _write_event_anyio(
+                byte_stream,
                 {
                     "id": req_id,
                     "event": "done",
@@ -338,8 +353,8 @@ class _BaseBrokerServer:
             )
         except Exception as e:
             logger.debug("[BROKER] llm.chat error", exc_info=True)
-            await _write_event(
-                writer,
+            await _write_event_anyio(
+                byte_stream,
                 {
                     "id": req_id,
                     "event": "error",
@@ -348,14 +363,14 @@ class _BaseBrokerServer:
             )
 
     async def _handle_tool_call(
-        self, req_id: str, params: dict[str, Any], writer: asyncio.StreamWriter
+        self, req_id: str, params: dict[str, Any], byte_stream: anyio.abc.ByteStream
     ) -> None:
         name = params.get("name")
         args = params.get("args") or {}
 
         if not isinstance(name, str) or not name:
-            await _write_event(
-                writer,
+            await _write_event_anyio(
+                byte_stream,
                 {
                     "id": req_id,
                     "event": "error",
@@ -364,8 +379,8 @@ class _BaseBrokerServer:
             )
             return
         if not isinstance(args, dict):
-            await _write_event(
-                writer,
+            await _write_event_anyio(
+                byte_stream,
                 {
                     "id": req_id,
                     "event": "error",
@@ -377,8 +392,8 @@ class _BaseBrokerServer:
         try:
             result = self._tools.call(name, args)
         except KeyError:
-            await _write_event(
-                writer,
+            await _write_event_anyio(
+                byte_stream,
                 {
                     "id": req_id,
                     "event": "error",
@@ -391,8 +406,8 @@ class _BaseBrokerServer:
             return
         except Exception as e:
             logger.debug("[BROKER] tool.call error", exc_info=True)
-            await _write_event(
-                writer,
+            await _write_event_anyio(
+                byte_stream,
                 {
                     "id": req_id,
                     "event": "error",
@@ -401,7 +416,9 @@ class _BaseBrokerServer:
             )
             return
 
-        await _write_event(writer, {"id": req_id, "event": "done", "data": {"result": result}})
+        await _write_event_anyio(
+            byte_stream, {"id": req_id, "event": "done", "data": {"result": result}}
+        )
 
 
 class BrokerServer(_BaseBrokerServer):
@@ -484,20 +501,15 @@ class TcpBrokerServer(_BaseBrokerServer):
         self.bound_port: int | None = None
 
     async def start(self) -> None:
-        self._server = await asyncio.start_server(
-            self._handle_connection,
-            host=self.host,
-            port=self.port,
-            ssl=self.ssl_context,
-        )
+        # Create AnyIO TCP listener (doesn't block, just binds to port)
+        self._listener = await anyio.create_tcp_listener(local_host=self.host, local_port=self.port)
 
-        sockets = self._server.sockets or []
-        if sockets:
-            try:
-                sockname = sockets[0].getsockname()
-                self.bound_port = int(sockname[1])
-            except Exception:
-                self.bound_port = None
+        # Get the bound port
+        try:
+            sockname = self._listener.extra(anyio.abc.SocketAttribute.raw_socket).getsockname()
+            self.bound_port = int(sockname[1])
+        except Exception:
+            self.bound_port = None
 
         scheme = "tls" if self.ssl_context is not None else "tcp"
         logger.info(

tactus/cli/app.py

@@ -456,9 +456,9 @@ def run(
         "Use --no-sandbox to run without isolation (security risk).",
     ),
     sandbox_broker: str = typer.Option(
-        "stdio",
+        "tcp",
         "--sandbox-broker",
-        help="Broker transport for sandbox runtime: stdio (default, --network none) or tcp/tls (remote-mode spike).",
+        help="Broker transport for sandbox runtime: tcp (default), tls, or stdio (deprecated due to buffering issues).",
     ),
     sandbox_network: Optional[str] = typer.Option(
         None,