tactus 0.35.1__py3-none-any.whl → 0.37.0__py3-none-any.whl

tactus/ide/server.py

@@ -11,7 +11,7 @@ import queue
 import subprocess
 import threading
 import time
-from datetime import datetime
+from datetime import datetime, timezone
 from pathlib import Path
 from flask import Flask, request, jsonify, Response, stream_with_context
 from flask_cors import CORS
@@ -29,6 +29,11 @@ WORKSPACE_ROOT = None
 _clear_runtime_caches_fn = None
 
 
+def _utc_now_iso() -> str:
+    """Return an ISO-8601 UTC timestamp with a trailing Z."""
+    return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
+
+
 def clear_runtime_caches():
     """Clear cached runtime instances. Must be called after create_app() initializes."""
     if _clear_runtime_caches_fn:
@@ -559,7 +564,6 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                 """Generator function that yields SSE validation events."""
                 try:
                     import json
-                    from datetime import datetime
 
                     # Read and validate file
                     content = path.read_text()
@@ -588,7 +592,7 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                             }
                             for warn in result.warnings
                         ],
-                        "timestamp": datetime.utcnow().isoformat() + "Z",
+                        "timestamp": _utc_now_iso(),
                     }
                     yield f"data: {json.dumps(validation_event)}\n\n"
 
@@ -597,7 +601,7 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                     error_event = {
                         "event_type": "execution",
                         "lifecycle_stage": "error",
-                        "timestamp": datetime.utcnow().isoformat() + "Z",
+                        "timestamp": _utc_now_iso(),
                         "details": {"error": str(e)},
                     }
                     yield f"data: {json.dumps(error_event)}\n\n"
@@ -720,7 +724,6 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                 try:
                     # Send start event
                     import json
-                    from datetime import datetime
                     from tactus.adapters.ide_log import IDELogHandler
                     from tactus.core.runtime import TactusRuntime
                     from tactus.adapters.file_storage import FileStorage
@@ -734,7 +737,7 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                         "lifecycle_stage": "start",
                         "procedure_id": procedure_id,
                         "run_id": run_id,
-                        "timestamp": datetime.utcnow().isoformat() + "Z",
+                        "timestamp": _utc_now_iso(),
                         "details": {"path": file_path},
                         "inputs": inputs,  # Include inputs in start event
                     }
@@ -837,7 +840,7 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                             "event_type": "container_status",
                             "status": "starting",
                             "execution_id": run_id,
-                            "timestamp": datetime.utcnow().isoformat() + "Z",
+                            "timestamp": _utc_now_iso(),
                         }
                         all_events.append(container_starting_event)
                         yield f"data: {json.dumps(container_starting_event)}\n\n"
@@ -992,7 +995,7 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                             "event_type": "container_status",
                             "status": "running",
                             "execution_id": run_id,
-                            "timestamp": datetime.utcnow().isoformat() + "Z",
+                            "timestamp": _utc_now_iso(),
                         }
                         all_events.append(container_running_event)
                         yield f"data: {json.dumps(container_running_event)}\n\n"
@@ -1088,12 +1091,41 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                             "event_type": "container_status",
                             "status": "stopped",
                             "execution_id": run_id,
-                            "timestamp": datetime.utcnow().isoformat() + "Z",
+                            "timestamp": _utc_now_iso(),
                         }
                         all_events.append(container_stopped_event)
                         yield f"data: {json.dumps(container_stopped_event)}\n\n"
                     else:
                         # Drain IDELogHandler events (direct execution)
+                        # Drain queued events that may have been enqueued before execution completed.
+                        while True:
+                            try:
+                                event = log_handler.events.get(timeout=0.01)
+                            except queue.Empty:
+                                break
+                            try:
+                                event_dict = event.model_dump(mode="json")
+                                iso_string = event.timestamp.isoformat()
+                                if not (
+                                    iso_string.endswith("Z")
+                                    or "+" in iso_string
+                                    or iso_string.count("-") > 2
+                                ):
+                                    iso_string += "Z"
+                                event_dict["timestamp"] = iso_string
+                                all_events.append(event_dict)
+                                yield f"data: {json.dumps(event_dict)}\n\n"
+                            except Exception as e:
+                                logger.error(
+                                    "Error serializing event: %s",
+                                    e,
+                                    exc_info=True,
+                                )
+                                logger.error(
+                                    "Event type: %s, Event: %s",
+                                    type(event),
+                                    event,
+                                )
                         events = log_handler.get_events(timeout=0.1)
                         for event in events:
                             try:
@@ -1132,7 +1164,7 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                             "lifecycle_stage": "error",
                             "procedure_id": procedure_id,
                             "exit_code": 1,
-                            "timestamp": datetime.utcnow().isoformat() + "Z",
+                            "timestamp": _utc_now_iso(),
                             "details": {"success": False, "error": str(result_container["error"])},
                         }
                     else:
@@ -1141,7 +1173,7 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                             "lifecycle_stage": "complete",
                             "procedure_id": procedure_id,
                             "exit_code": 0,
-                            "timestamp": datetime.utcnow().isoformat() + "Z",
+                            "timestamp": _utc_now_iso(),
                             "details": {"success": True},
                         }
                     all_events.append(complete_event)
@@ -1186,7 +1218,7 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                         "event_type": "execution",
                         "lifecycle_stage": "error",
                         "procedure_id": procedure_id,
-                        "timestamp": datetime.utcnow().isoformat() + "Z",
+                        "timestamp": _utc_now_iso(),
                         "details": {"error": str(e)},
                     }
                     yield f"data: {json.dumps(error_event)}\n\n"
@@ -1241,7 +1273,6 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                 """Generator function that yields SSE test events."""
                 try:
                     import json
-                    from datetime import datetime
                     from tactus.validation import TactusValidator
                     from tactus.testing import TactusTestRunner, GherkinParser
 
@@ -1255,7 +1286,7 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                             "event_type": "execution",
                             "lifecycle_stage": "error",
                             "procedure_id": procedure_id,
-                            "timestamp": datetime.utcnow().isoformat() + "Z",
+                            "timestamp": _utc_now_iso(),
                             "details": {
                                 "error": "Validation failed",
                                 "errors": [
@@ -1276,7 +1307,7 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                             "event_type": "execution",
                             "lifecycle_stage": "error",
                             "procedure_id": procedure_id,
-                            "timestamp": datetime.utcnow().isoformat() + "Z",
+                            "timestamp": _utc_now_iso(),
                             "details": {"error": "No specifications found in procedure"},
                         }
                         yield f"data: {json.dumps(error_event)}\n\n"
@@ -1327,7 +1358,7 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                         "event_type": "test_started",
                         "procedure_file": str(path),
                         "total_scenarios": total_scenarios,
-                        "timestamp": datetime.utcnow().isoformat() + "Z",
+                        "timestamp": _utc_now_iso(),
                     }
                     yield f"data: {json.dumps(start_event)}\n\n"
 
@@ -1347,7 +1378,7 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                                 "llm_calls": scenario.llm_calls,
                                 "iterations": scenario.iterations,
                                 "tools_used": scenario.tools_used,
-                                "timestamp": datetime.utcnow().isoformat() + "Z",
+                                "timestamp": _utc_now_iso(),
                             }
                             yield f"data: {json.dumps(scenario_event)}\n\n"
 
@@ -1387,7 +1418,7 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                                 for f in test_result.features
                             ],
                         },
-                        "timestamp": datetime.utcnow().isoformat() + "Z",
+                        "timestamp": _utc_now_iso(),
                     }
                     yield f"data: {json.dumps(complete_event)}\n\n"
 
@@ -1400,7 +1431,7 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                         "event_type": "execution",
                         "lifecycle_stage": "error",
                         "procedure_id": procedure_id,
-                        "timestamp": datetime.utcnow().isoformat() + "Z",
+                        "timestamp": _utc_now_iso(),
                         "details": {"error": str(e)},
                     }
                     yield f"data: {json.dumps(error_event)}\n\n"
@@ -1457,7 +1488,6 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                 """Generator function that yields SSE evaluation events."""
                 try:
                     import json
-                    from datetime import datetime
                     from tactus.validation import TactusValidator
                     from tactus.testing import TactusEvaluationRunner, GherkinParser
 
@@ -1470,7 +1500,7 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                             "event_type": "execution",
                             "lifecycle_stage": "error",
                             "procedure_id": procedure_id,
-                            "timestamp": datetime.utcnow().isoformat() + "Z",
+                            "timestamp": _utc_now_iso(),
                             "details": {
                                 "error": "Validation failed",
                                 "errors": [
@@ -1490,7 +1520,7 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                             "event_type": "execution",
                             "lifecycle_stage": "error",
                             "procedure_id": procedure_id,
-                            "timestamp": datetime.utcnow().isoformat() + "Z",
+                            "timestamp": _utc_now_iso(),
                             "details": {"error": "No specifications found in procedure"},
                         }
                         yield f"data: {json.dumps(error_event)}\n\n"
@@ -1512,7 +1542,7 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                         "procedure_file": str(path),
                         "total_scenarios": total_scenarios,
                         "runs_per_scenario": runs,
-                        "timestamp": datetime.utcnow().isoformat() + "Z",
+                        "timestamp": _utc_now_iso(),
                     }
                     yield f"data: {json.dumps(start_event)}\n\n"
 
@@ -1526,7 +1556,7 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                             "scenario_name": eval_result.scenario_name,
                             "completed_runs": eval_result.total_runs,
                             "total_runs": eval_result.total_runs,
-                            "timestamp": datetime.utcnow().isoformat() + "Z",
+                            "timestamp": _utc_now_iso(),
                         }
                         yield f"data: {json.dumps(progress_event)}\n\n"
 
@@ -1547,7 +1577,7 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                             }
                             for r in eval_results
                         ],
-                        "timestamp": datetime.utcnow().isoformat() + "Z",
+                        "timestamp": _utc_now_iso(),
                     }
                     yield f"data: {json.dumps(complete_event)}\n\n"
 
@@ -1560,7 +1590,7 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                         "event_type": "execution",
                         "lifecycle_stage": "error",
                         "procedure_id": procedure_id,
-                        "timestamp": datetime.utcnow().isoformat() + "Z",
+                        "timestamp": _utc_now_iso(),
                         "details": {"error": str(e)},
                     }
                     yield f"data: {json.dumps(error_event)}\n\n"
@@ -1629,7 +1659,7 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                             "event_type": "execution",
                             "lifecycle_stage": "error",
                             "procedure_id": procedure_id,
-                            "timestamp": datetime.utcnow().isoformat() + "Z",
+                            "timestamp": _utc_now_iso(),
                             "details": {
                                 "error": "Validation failed",
                                 "errors": [e.message for e in validation_result.errors],
@@ -1646,7 +1676,7 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                             "event_type": "execution",
                             "lifecycle_stage": "error",
                             "procedure_id": procedure_id,
-                            "timestamp": datetime.utcnow().isoformat() + "Z",
+                            "timestamp": _utc_now_iso(),
                             "details": {"error": "No evaluations found in procedure"},
                         }
                         yield f"data: {json.dumps(error_event)}\n\n"
@@ -1672,7 +1702,7 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                         "event_type": "execution",
                         "lifecycle_stage": "started",
                         "procedure_id": procedure_id,
-                        "timestamp": datetime.utcnow().isoformat() + "Z",
+                        "timestamp": _utc_now_iso(),
                         "details": {"type": "pydantic_eval", "runs": actual_runs},
                     }
                     yield f"data: {json.dumps(start_event)}\n\n"
@@ -1747,7 +1777,7 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                         "event_type": "execution",
                         "lifecycle_stage": "complete",
                         "procedure_id": procedure_id,
-                        "timestamp": datetime.utcnow().isoformat() + "Z",
+                        "timestamp": _utc_now_iso(),
                         "details": result_details,
                     }
                     yield f"data: {json.dumps(result_event)}\n\n"
@@ -1757,7 +1787,7 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                         "event_type": "execution",
                         "lifecycle_stage": "error",
                         "procedure_id": procedure_id,
-                        "timestamp": datetime.utcnow().isoformat() + "Z",
+                        "timestamp": _utc_now_iso(),
                         "details": {"error": f"pydantic_evals not installed: {e}"},
                     }
                     yield f"data: {json.dumps(error_event)}\n\n"
@@ -1767,7 +1797,7 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                         "event_type": "execution",
                         "lifecycle_stage": "error",
                         "procedure_id": procedure_id,
-                        "timestamp": datetime.utcnow().isoformat() + "Z",
+                        "timestamp": _utc_now_iso(),
                         "details": {"error": str(e)},
                     }
                     yield f"data: {json.dumps(error_event)}\n\n"
@@ -2484,7 +2514,7 @@ def create_app(initial_workspace: Optional[str] = None, frontend_dist_dir: Optio
                 connection_event = {
                     "type": "connection",
                     "status": "connected",
-                    "timestamp": datetime.utcnow().isoformat() + "Z",
+                    "timestamp": _utc_now_iso(),
                 }
                 logger.info("[HITL-SSE] Sending connection event to client")
                 yield f"data: {json.dumps(connection_event)}\n\n"

tactus/primitives/host.py

@@ -37,27 +37,30 @@ class HostPrimitive:
         try:
             asyncio.get_running_loop()
 
-            import threading
+            return self._run_coro_in_thread(coroutine)
 
-            thread_result = {"value": None, "exception": None}
+        except RuntimeError:
+            clear_closed_event_loop()
+            return asyncio.run(coroutine)
+
+    def _run_coro_in_thread(self, coroutine: Any) -> Any:
+        import threading
 
-            def run_in_thread():
-                try:
-                    thread_result["value"] = asyncio.run(coroutine)
-                except Exception as error:
-                    thread_result["exception"] = error
+        result_container = {"value": None, "exception": None}
 
-            thread = threading.Thread(target=run_in_thread)
-            thread.start()
-            thread.join()
+        def run_in_thread():
+            try:
+                result_container["value"] = asyncio.run(coroutine)
+            except Exception as error:
+                result_container["exception"] = error
 
-            if thread_result["exception"]:
-                raise thread_result["exception"]
-            return thread_result["value"]
+        worker_thread = threading.Thread(target=run_in_thread)
+        worker_thread.start()
+        worker_thread.join()
 
-        except RuntimeError:
-            clear_closed_event_loop()
-            return asyncio.run(coroutine)
+        if result_container["exception"]:
+            raise result_container["exception"]
+        return result_container["value"]
 
     def _lua_to_python(self, value: Any) -> Any:
         if value is None:

tactus/primitives/message_history.py

@@ -58,13 +58,7 @@ class MessageHistoryPrimitive:
             return
 
         message_payload = self._normalize_message_payload(message_payload)
-        role = message_payload.get("role", "user")
-        content = message_payload.get("content", "")
-
-        # Create a message dict and preserve extra fields
-        message_entry = dict(message_payload)
-        message_entry["role"] = role
-        message_entry["content"] = content
+        message_entry = self._build_message_entry(message_payload)
 
         self.message_history_manager.add_message(self.agent_name, message_entry)
 
@@ -116,13 +110,7 @@ class MessageHistoryPrimitive:
             return []
         messages = self._get_history_ref()
 
-        # Convert to Lua-friendly format
-        result: list[dict[str, Any]] = []
-        for message in messages:
-            serialized_message = self._serialize_message(message)
-            result.append(serialized_message)
-
-        return result
+        return self._serialize_messages(messages)
 
     def replace(self, messages: list[Any]) -> None:
         """
@@ -345,6 +333,15 @@ class MessageHistoryPrimitive:
                 pass
         return {"role": "user", "content": str(message_payload)}
 
+    def _build_message_entry(self, message_payload: dict[str, Any]) -> dict[str, Any]:
+        role = message_payload.get("role", "user")
+        content = message_payload.get("content", "")
+
+        message_entry = dict(message_payload)
+        message_entry["role"] = role
+        message_entry["content"] = content
+        return message_entry
+
     def _normalize_message_data(self, message_data: Any) -> dict[str, Any]:
         """Compatibility alias for existing tests and external callers."""
         return self._normalize_message_payload(message_data)

tactus/primitives/model.py

@@ -27,7 +27,7 @@ class ModelPrimitive:
         self,
         model_name: str,
         config: dict,
-        context: ExecutionContext | None = None,
+        context: Optional[ExecutionContext] = None,
         mock_manager: Optional[Any] = None,
     ):
         """

tactus/primitives/procedure.py

@@ -330,16 +330,11 @@ class ProcedurePrimitive:
             # Create runtime for sub-procedure
             runtime = self.runtime_factory(name, params)
 
-            # Execute in new event loop (thread-safe)
-            event_loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(event_loop)
-
-            result = event_loop.run_until_complete(
+            # Execute in a dedicated event loop for thread safety
+            result = self._run_in_new_event_loop(
                 runtime.execute(source=source, context=params, format="lua")
             )
 
-            event_loop.close()
-
             # Update handle
             with self._lock:
                 if result.get("success"):
@@ -368,6 +363,14 @@ class ProcedurePrimitive:
                 handle.error = str(error)
                 handle.completed_at = datetime.now()
 
+    def _run_in_new_event_loop(self, coroutine: Any) -> dict[str, Any]:
+        event_loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(event_loop)
+        try:
+            return event_loop.run_until_complete(coroutine)
+        finally:
+            event_loop.close()
+
     def status(self, handle: ProcedureHandle) -> dict[str, Any]:
         """
         Get procedure status.
@@ -547,7 +550,7 @@ class ProcedurePrimitive:
 
         name_path = Path(name)
 
-        def add_candidates(base: Path | None, rel: Path) -> None:
+        def add_candidates(base: Optional[Path], rel: Path) -> None:
             candidate = (base / rel) if base is not None else rel
             add_path(candidate)
             if candidate.suffix != ".tac":

tactus/primitives/session.py

@@ -80,11 +80,7 @@ class SessionPrimitive:
         if not self._has_session_context():
             return
 
-        message_role = message_payload.get("role", "user")
-        message_content = message_payload.get("content", "")
-
-        # Create a simple message dict
-        message_entry = {"role": message_role, "content": message_content}
+        message_entry = self._build_message_entry(message_payload)
 
         self.session_manager.add_message(self.agent_name, message_entry)
 
@@ -134,11 +130,15 @@ class SessionPrimitive:
         messages = self.session_manager.histories.get(self.agent_name, [])
 
         # Convert to Lua-friendly format
-        serialized_messages: list[dict[str, str]] = [
-            self._serialize_message(message) for message in messages
-        ]
+        return self._serialize_messages(messages)
+
+    def _build_message_entry(self, message_payload: dict[str, Any]) -> dict[str, Any]:
+        message_role = message_payload.get("role", "user")
+        message_content = message_payload.get("content", "")
+        return {"role": message_role, "content": message_content}
 
-        return serialized_messages
+    def _serialize_messages(self, messages: list[Any]) -> list[dict[str, str]]:
+        return [self._serialize_message(message) for message in messages]
 
     def load_from_node(self, node: Any) -> None:
         """

tactus/primitives/state.py

@@ -10,7 +10,7 @@ Provides:
 """
 
 import logging
-from typing import Any
+from typing import Any, Dict, Optional
 
 logger = logging.getLogger(__name__)
 
@@ -23,7 +23,7 @@ class StatePrimitive:
     progress, accumulate results, and coordinate between agents.
     """
 
-    def __init__(self, state_schema: dict[str, Any] | None = None):
+    def __init__(self, state_schema: Optional[Dict[str, Any]] = None):
         """
         Initialize state storage.
 

tactus/primitives/tool_handle.py

@@ -251,30 +251,7 @@ class ToolHandle:
                 return asyncio.run(self.implementation_function(args))
             except ImportError:
                 # nest_asyncio not available, fall back to threading
-                import threading
-
-                async_result = {"value": None, "exception": None}
-
-                def run_in_thread():
-                    try:
-                        thread_event_loop = asyncio.new_event_loop()
-                        asyncio.set_event_loop(thread_event_loop)
-                        try:
-                            async_result["value"] = thread_event_loop.run_until_complete(
-                                self.implementation_function(args)
-                            )
-                        finally:
-                            thread_event_loop.close()
-                    except Exception as error:
-                        async_result["exception"] = error
-
-                worker_thread = threading.Thread(target=run_in_thread)
-                worker_thread.start()
-                worker_thread.join()
-
-                if async_result["exception"]:
-                    raise async_result["exception"]
-                return async_result["value"]
+                return self._run_async_in_thread(args)
 
         except RuntimeError:
             # No event loop running - safe to use asyncio.run()
@@ -297,5 +274,31 @@ class ToolHandle:
                 result[key] = value
         return result
 
+    def _run_async_in_thread(self, args: dict[str, Any]) -> Any:
+        import threading
+
+        thread_result = {"value": None, "exception": None}
+
+        def run_in_thread():
+            try:
+                thread_event_loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(thread_event_loop)
+                try:
+                    thread_result["value"] = thread_event_loop.run_until_complete(
+                        self.implementation_function(args)
+                    )
+                finally:
+                    thread_event_loop.close()
+            except Exception as error:
+                thread_result["exception"] = error
+
+        worker_thread = threading.Thread(target=run_in_thread)
+        worker_thread.start()
+        worker_thread.join()
+
+        if thread_result["exception"]:
+            raise thread_result["exception"]
+        return thread_result["value"]
+
     def __repr__(self) -> str:
         return f"ToolHandle('{self.name}')"

tactus/sandbox/container_runner.py

@@ -17,7 +17,7 @@ import tempfile
 import time
 import uuid
 from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional
+from typing import Any, Callable, Dict, List, Optional, Tuple
 
 from .config import SandboxConfig
 from .docker_manager import (
@@ -523,6 +523,11 @@ class ContainerRunner:
                         llm_backend_config=llm_backend_config,
                     )
                 finally:
+                    try:
+                        await broker_server.aclose()
+                        broker_server = None
+                    except Exception:
+                        logger.debug("[BROKER] Failed to close broker server", exc_info=True)
                     # Cancel broker task when container finishes
                     broker_task.cancel()
                     try:
@@ -589,7 +594,7 @@ class ContainerRunner:
         """
         broker_transport = (self.config.broker_transport or "stdio").lower()
 
-        stdio_request_prefix: str | None = None
+        stdio_request_prefix: Optional[str] = None
         if broker_transport == "stdio":
             from tactus.broker.server import OpenAIChatBackend
             from tactus.broker.server import HostToolRegistry
@@ -950,9 +955,9 @@ class ContainerRunner:
         )
         logger.debug("[SANDBOX] Spawned container process pid=%s", process.pid)
 
-        stdout_task: asyncio.Task[None] | None = None
-        stderr_task: asyncio.Task[None] | None = None
-        wait_task: asyncio.Task[int] | None = None
+        stdout_task: Optional[asyncio.Task[None]] = None
+        stderr_task: Optional[asyncio.Task[None]] = None
+        wait_task: Optional[asyncio.Task[int]] = None
 
         try:
             assert process.stdin is not None
@@ -1159,7 +1164,7 @@ class ContainerRunner:
             return
 
         # Rich/terminal: parse our container log format and re-emit.
-        current: tuple[str, int, list[str]] | None = None  # (logger_name, levelno, lines)
+        current: Optional[Tuple[str, int, List[str]]] = None  # (logger_name, levelno, lines)
 
         def flush_current() -> None:
             nonlocal current