tactus 0.30.0__py3-none-any.whl → 0.31.1__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.30.0"
+__version__ = "0.31.1"
 
 # Core exports
 from tactus.core.runtime import TactusRuntime

tactus/adapters/lua_tools.py

@@ -156,6 +156,15 @@ class LuaToolsAdapter:
             Async Python function suitable for FunctionToolset
         """
         lua_handler = tool_spec.get("handler")
+        if lua_handler is None:
+            # Tool/Toolset DSL blocks can specify the handler as an unnamed function value.
+            # `lua_table_to_dict()` preserves that as numeric key `1` for mixed tables.
+            try:
+                candidate = tool_spec.get(1)
+            except Exception:
+                candidate = None
+            if candidate is not None and callable(candidate):
+                lua_handler = candidate
         description = tool_spec.get("description", f"Tool: {tool_name}")
         # Only support 'input' field name (new DSL syntax only)
         input_schema = tool_spec.get("input", {})
@@ -226,7 +235,20 @@ class LuaToolsAdapter:
         # Build proper signature for Pydantic AI tool discovery
         sig_params = []
         logger.debug(f"Building signature for tool '{tool_name}' with schema: {input_schema}")
-        for param_name, param_spec in input_schema.items():
+
+        # Lua table iteration order is undefined, so ensure signature is always valid:
+        # required params (no defaults) must come before optional params (with defaults).
+        required_param_names: list[str] = []
+        optional_param_names: list[str] = []
+        for param_name in sorted(input_schema.keys()):
+            param_spec = input_schema.get(param_name, {}) or {}
+            if param_spec.get("required", True):
+                required_param_names.append(param_name)
+            else:
+                optional_param_names.append(param_name)
+
+        for param_name in required_param_names + optional_param_names:
+            param_spec = input_schema.get(param_name, {}) or {}
             param_type = self._map_lua_type(param_spec.get("type", "string"))
             required = param_spec.get("required", True)
 

tactus/adapters/mcp_manager.py

@@ -8,6 +8,7 @@ Handles lifecycle, tool prefixing, and tool call tracking.
 import logging
 import os
 import re
+import asyncio
 from contextlib import AsyncExitStack
 from typing import Dict, Any, List
 
@@ -62,43 +63,69 @@ class MCPServerManager:
     async def __aenter__(self):
         """Connect to all configured MCP servers."""
         for name, config in self.configs.items():
-            try:
-                logger.info(f"Connecting to MCP server '{name}'...")
-
-                # Substitute environment variables in config
-                config = substitute_env_vars(config)
-
-                # Create base server
-                server = MCPServerStdio(
-                    command=config["command"],
-                    args=config.get("args", []),
-                    env=config.get("env"),
-                    process_tool_call=self._create_trace_callback(name),  # Tracking hook
-                )
-
-                # Wrap with prefix to namespace tools
-                prefixed_server = server.prefixed(name)
-
-                # Connect the prefixed server
-                await self._exit_stack.enter_async_context(prefixed_server)
-                self.servers.append(prefixed_server)
-                self.server_toolsets[name] = prefixed_server  # Store by name for lookup
-                logger.info(f"Successfully connected to MCP server '{name}' with prefix '{name}_'")
-            except Exception as e:
-                # Check if this is a fileno error (common in test environments)
-                import io
-
-                error_str = str(e)
-                if "fileno" in error_str or isinstance(e, io.UnsupportedOperation):
-                    logger.warning(
-                        f"Failed to connect to MCP server '{name}': {e} "
-                        f"(test environment with redirected streams)"
+            # Retry a few times for transient stdio startup issues.
+            last_error: Exception | None = None
+            for attempt in range(1, 4):
+                try:
+                    logger.info(f"Connecting to MCP server '{name}' (attempt {attempt}/3)...")
+
+                    # Substitute environment variables in config
+                    config = substitute_env_vars(config)
+
+                    # Create base server
+                    server = MCPServerStdio(
+                        command=config["command"],
+                        args=config.get("args", []),
+                        env=config.get("env"),
+                        cwd=config.get("cwd"),
+                        process_tool_call=self._create_trace_callback(name),  # Tracking hook
                     )
-                else:
+
+                    # Wrap with prefix to namespace tools
+                    prefixed_server = server.prefixed(name)
+
+                    # Connect the prefixed server
+                    await self._exit_stack.enter_async_context(prefixed_server)
+                    self.servers.append(prefixed_server)
+                    self.server_toolsets[name] = prefixed_server  # Store by name for lookup
+                    logger.info(
+                        f"Successfully connected to MCP server '{name}' with prefix '{name}_'"
+                    )
+                    last_error = None
+                    break
+                except Exception as e:
+                    last_error = e
+
+                    # Check if this is a fileno error (common in test environments)
+                    import io
+
+                    error_str = str(e)
+                    if "fileno" in error_str or isinstance(e, io.UnsupportedOperation):
+                        logger.warning(
+                            f"Failed to connect to MCP server '{name}': {e} "
+                            f"(test environment with redirected streams)"
+                        )
+                        # Allow procedures to continue without MCP in this environment.
+                        last_error = None
+                        break
+
+                    # Retry transient anyio TaskGroup/broken stream issues.
+                    if (
+                        "BrokenResourceError" in error_str
+                        or "unhandled errors in a TaskGroup" in error_str
+                    ):
+                        logger.warning(
+                            f"Transient MCP connection failure for '{name}': {e} (retrying)"
+                        )
+                        await asyncio.sleep(0.05 * attempt)
+                        continue
+
                     logger.error(f"Failed to connect to MCP server '{name}': {e}", exc_info=True)
-                # Don't raise - allow procedure to continue without this MCP server
-                logger.info(f"Continuing without MCP server '{name}'")
-                continue
+                    break
+
+            if last_error is not None:
+                # For non-transient failures, raise so callers can decide whether to ignore.
+                raise last_error
 
         return self
 

tactus/broker/server.py

@@ -38,6 +38,21 @@ async def _write_event_anyio(stream: anyio.abc.ByteStream, event: dict[str, Any]
     await write_message_anyio(stream, event)
 
 
+async def _write_event_asyncio(writer: asyncio.StreamWriter, event: dict[str, Any]) -> None:
+    """Write an event using length-prefixed protocol."""
+    await write_message(writer, event)
+
+
+def _flatten_exceptions(exc: BaseException) -> list[BaseException]:
+    """Flatten BaseExceptionGroup into a list of leaf exceptions."""
+    if isinstance(exc, BaseExceptionGroup):
+        leaves: list[BaseException] = []
+        for child in exc.exceptions:
+            leaves.extend(_flatten_exceptions(child))
+        return leaves
+    return [exc]
+
+
 @dataclass(frozen=True)
 class OpenAIChatConfig:
     api_key_env: str = "OPENAI_API_KEY"
@@ -127,6 +142,7 @@ class _BaseBrokerServer:
         event_handler: Optional[Callable[[dict[str, Any]], None]] = None,
     ):
         self._listener = None
+        self._serve_task: asyncio.Task[None] | None = None
         self._openai = openai_backend or OpenAIChatBackend()
         self._tools = tool_registry or HostToolRegistry.default()
         self._event_handler = event_handler
@@ -145,8 +161,27 @@ class _BaseBrokerServer:
             await self._listener.aclose()
             self._listener = None
 
+        task = self._serve_task
+        self._serve_task = None
+        if task is not None:
+            try:
+                await task
+            except BaseExceptionGroup as eg:
+                # AnyIO raises ClosedResourceError during normal listener shutdown.
+                leaves = _flatten_exceptions(eg)
+                if leaves and all(isinstance(e, anyio.ClosedResourceError) for e in leaves):
+                    return
+                raise
+            except asyncio.CancelledError:
+                pass
+
     async def __aenter__(self) -> "_BaseBrokerServer":
         await self.start()
+
+        # AnyIO listeners (TCP/TLS) require an explicit serve loop. Run it in the background
+        # so `async with TcpBrokerServer(...)` is sufficient to accept connections.
+        if self._listener is not None:
+            self._serve_task = asyncio.create_task(self.serve(), name="tactus-broker-serve")
         return self
 
     async def __aexit__(self, exc_type, exc, tb) -> None:
@@ -221,6 +256,275 @@ class _BaseBrokerServer:
             except Exception:
                 pass
 
+    async def _handle_connection_asyncio(
+        self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter
+    ) -> None:
+        """
+        Handle a single broker request over asyncio streams.
+
+        UDS uses asyncio's StreamReader/StreamWriter APIs, while TCP uses AnyIO streams.
+        """
+        try:
+            req = await read_message(reader)
+            req_id = req.get("id")
+            method = req.get("method")
+            params = req.get("params") or {}
+
+            if not req_id or not method:
+                await _write_event_asyncio(
+                    writer,
+                    {
+                        "id": req_id or "",
+                        "event": "error",
+                        "error": {"type": "BadRequest", "message": "Missing id/method"},
+                    },
+                )
+                return
+
+            if method == "events.emit":
+                await self._handle_events_emit_asyncio(req_id, params, writer)
+                return
+
+            if method == "llm.chat":
+                await self._handle_llm_chat_asyncio(req_id, params, writer)
+                return
+
+            if method == "tool.call":
+                await self._handle_tool_call_asyncio(req_id, params, writer)
+                return
+
+            await _write_event_asyncio(
+                writer,
+                {
+                    "id": req_id,
+                    "event": "error",
+                    "error": {"type": "MethodNotFound", "message": f"Unknown method: {method}"},
+                },
+            )
+        except Exception as e:
+            logger.debug("[BROKER] asyncio connection handler error", exc_info=True)
+            try:
+                await _write_event_asyncio(
+                    writer,
+                    {
+                        "id": "",
+                        "event": "error",
+                        "error": {"type": type(e).__name__, "message": str(e)},
+                    },
+                )
+            except Exception:
+                pass
+        finally:
+            try:
+                writer.close()
+                await writer.wait_closed()
+            except Exception:
+                pass
+
+    async def _handle_events_emit_asyncio(
+        self, req_id: str, params: dict[str, Any], writer: asyncio.StreamWriter
+    ) -> None:
+        event = params.get("event")
+        if not isinstance(event, dict):
+            await _write_event_asyncio(
+                writer,
+                {
+                    "id": req_id,
+                    "event": "error",
+                    "error": {"type": "BadRequest", "message": "params.event must be an object"},
+                },
+            )
+            return
+
+        try:
+            if self._event_handler is not None:
+                self._event_handler(event)
+        except Exception:
+            logger.debug("[BROKER] event_handler raised", exc_info=True)
+
+        await _write_event_asyncio(writer, {"id": req_id, "event": "done", "data": {"ok": True}})
+
+    async def _handle_llm_chat_asyncio(
+        self, req_id: str, params: dict[str, Any], writer: asyncio.StreamWriter
+    ) -> None:
+        provider = params.get("provider") or "openai"
+        if provider != "openai":
+            await _write_event_asyncio(
+                writer,
+                {
+                    "id": req_id,
+                    "event": "error",
+                    "error": {
+                        "type": "UnsupportedProvider",
+                        "message": f"Unsupported provider: {provider}",
+                    },
+                },
+            )
+            return
+
+        model = params.get("model")
+        messages = params.get("messages")
+        stream = bool(params.get("stream", False))
+        temperature = params.get("temperature")
+        max_tokens = params.get("max_tokens")
+
+        if not isinstance(model, str) or not model:
+            await _write_event_asyncio(
+                writer,
+                {
+                    "id": req_id,
+                    "event": "error",
+                    "error": {"type": "BadRequest", "message": "params.model must be a string"},
+                },
+            )
+            return
+        if not isinstance(messages, list):
+            await _write_event_asyncio(
+                writer,
+                {
+                    "id": req_id,
+                    "event": "error",
+                    "error": {"type": "BadRequest", "message": "params.messages must be a list"},
+                },
+            )
+            return
+
+        try:
+            if stream:
+                stream_iter = await self._openai.chat(
+                    model=model,
+                    messages=messages,
+                    temperature=temperature,
+                    max_tokens=max_tokens,
+                    stream=True,
+                )
+
+                full_text = ""
+                async for chunk in stream_iter:
+                    try:
+                        delta = chunk.choices[0].delta
+                        text = getattr(delta, "content", None)
+                    except Exception:
+                        text = None
+
+                    if not text:
+                        continue
+
+                    full_text += text
+                    await _write_event_asyncio(
+                        writer, {"id": req_id, "event": "delta", "data": {"text": text}}
+                    )
+
+                await _write_event_asyncio(
+                    writer,
+                    {
+                        "id": req_id,
+                        "event": "done",
+                        "data": {
+                            "text": full_text,
+                            "usage": {
+                                "prompt_tokens": 0,
+                                "completion_tokens": 0,
+                                "total_tokens": 0,
+                            },
+                        },
+                    },
+                )
+                return
+
+            resp = await self._openai.chat(
+                model=model,
+                messages=messages,
+                temperature=temperature,
+                max_tokens=max_tokens,
+                stream=False,
+            )
+            text = ""
+            try:
+                text = resp.choices[0].message.content or ""
+            except Exception:
+                text = ""
+
+            await _write_event_asyncio(
+                writer,
+                {
+                    "id": req_id,
+                    "event": "done",
+                    "data": {
+                        "text": text,
+                        "usage": {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0},
+                    },
+                },
+            )
+        except Exception as e:
+            logger.debug("[BROKER] llm.chat error", exc_info=True)
+            await _write_event_asyncio(
+                writer,
+                {
+                    "id": req_id,
+                    "event": "error",
+                    "error": {"type": type(e).__name__, "message": str(e)},
+                },
+            )
+
+    async def _handle_tool_call_asyncio(
+        self, req_id: str, params: dict[str, Any], writer: asyncio.StreamWriter
+    ) -> None:
+        name = params.get("name")
+        args = params.get("args") or {}
+
+        if not isinstance(name, str) or not name:
+            await _write_event_asyncio(
+                writer,
+                {
+                    "id": req_id,
+                    "event": "error",
+                    "error": {"type": "BadRequest", "message": "params.name must be a string"},
+                },
+            )
+            return
+        if not isinstance(args, dict):
+            await _write_event_asyncio(
+                writer,
+                {
+                    "id": req_id,
+                    "event": "error",
+                    "error": {"type": "BadRequest", "message": "params.args must be an object"},
+                },
+            )
+            return
+
+        try:
+            result = self._tools.call(name, args)
+        except KeyError:
+            await _write_event_asyncio(
+                writer,
+                {
+                    "id": req_id,
+                    "event": "error",
+                    "error": {
+                        "type": "ToolNotAllowed",
+                        "message": f"Tool not allowlisted: {name}",
+                    },
+                },
+            )
+            return
+        except Exception as e:
+            logger.debug("[BROKER] tool.call error", exc_info=True)
+            await _write_event_asyncio(
+                writer,
+                {
+                    "id": req_id,
+                    "event": "error",
+                    "error": {"type": type(e).__name__, "message": str(e)},
+                },
+            )
+            return
+
+        await _write_event_asyncio(
+            writer, {"id": req_id, "event": "done", "data": {"result": result}}
+        )
+
     async def _handle_events_emit(
         self, req_id: str, params: dict[str, Any], byte_stream: anyio.abc.ByteStream
     ) -> None:
@@ -472,6 +776,16 @@ class BrokerServer(_BaseBrokerServer):
         logger.info(f"[BROKER] Listening on UDS: {self.socket_path}")
 
     async def aclose(self) -> None:
+        server = getattr(self, "_server", None)
+        if server is not None:
+            try:
+                server.close()
+                await server.wait_closed()
+            except Exception:
+                logger.debug("[BROKER] Failed to close asyncio server", exc_info=True)
+            finally:
+                self._server = None
+
         await super().aclose()
 
         if self._server is not None:

tactus/cli/app.py

@@ -722,6 +722,7 @@ def run(
         # Handle global flags
         if mock_all:
             mock_manager.enable_mock()
+            runtime.mock_all_agents = True
             console.print("[yellow]Mocking enabled for all tools[/yellow]")
         elif real_all:
             mock_manager.disable_mock()
@@ -807,7 +808,16 @@ def run(
             # Display results
             if result.get("result"):
                 console.print("\n[green]Result:[/green]")
-                console.print(f"  {result['result']}")
+                display_result = result["result"]
+                try:
+                    from tactus.protocols.result import TactusResult
+
+                    if isinstance(display_result, TactusResult):
+                        display_result = display_result.output
+                except Exception:
+                    pass
+
+                console.print(f"  {display_result}")
 
             # Display state
             if result.get("state"):