tactus 0.35.0__py3-none-any.whl → 0.36.0__py3-none-any.whl

tactus/core/runtime.py

@@ -221,17 +221,7 @@ class TactusRuntime:
             logger.info("Step 0: Setting up Lua sandbox")
             strict_determinism = self.external_config.get("strict_determinism", False)
 
-            # Compute base_path for sandbox from source file path if available
-            # This ensures require() works correctly even when running from different directories
-            sandbox_base_path = None
-            if self.source_file_path:
-                from pathlib import Path
-
-                sandbox_base_path = str(Path(self.source_file_path).parent.resolve())
-                logger.debug(
-                    "Using source file directory as sandbox base_path: %s",
-                    sandbox_base_path,
-                )
+            sandbox_base_path = self._resolve_sandbox_base_path()
 
             self.lua_sandbox = LuaSandbox(
                 execution_context=None,
@@ -242,13 +232,7 @@ class TactusRuntime:
             # 0.5. Create execution context EARLY so it's available during DSL parsing
             # This is critical for immediate agent creation during parsing
             logger.info("Step 0.5: Creating execution context (early)")
-            self.execution_context = BaseExecutionContext(
-                procedure_id=self.procedure_id,
-                storage_backend=self.storage_backend,
-                hitl_handler=self.hitl_handler,
-                strict_determinism=strict_determinism,
-                log_handler=self.log_handler,
-            )
+            self.execution_context = self._create_execution_context(strict_determinism)
 
             # Set run_id if provided
             if self.run_id:
@@ -788,6 +772,30 @@ class TactusRuntime:
                 except Exception as e:
                     logger.warning("Error cleaning up dependencies: %s", e)
 
+    def _resolve_sandbox_base_path(self) -> str | None:
+        # Compute base_path for sandbox from source file path if available.
+        # This ensures require() works correctly even when running from different directories.
+        if not self.source_file_path:
+            return None
+
+        from pathlib import Path
+
+        sandbox_base_path = str(Path(self.source_file_path).parent.resolve())
+        logger.debug(
+            "Using source file directory as sandbox base_path: %s",
+            sandbox_base_path,
+        )
+        return sandbox_base_path
+
+    def _create_execution_context(self, strict_determinism: bool) -> BaseExecutionContext:
+        return BaseExecutionContext(
+            procedure_id=self.procedure_id,
+            storage_backend=self.storage_backend,
+            hitl_handler=self.hitl_handler,
+            strict_determinism=strict_determinism,
+            log_handler=self.log_handler,
+        )
+
     async def _initialize_primitives(
         self,
         placeholder_tool: ToolPrimitive | None = None,

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/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.

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/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/testing/mock_hitl.py

@@ -6,7 +6,7 @@ allowing tests to run without human intervention.
 """
 
 import logging
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Dict, Optional
 
 from tactus.protocols.models import HITLRequest, HITLResponse
@@ -71,7 +71,7 @@ class MockHITLHandler:
 
         return HITLResponse(
             value=value,
-            responded_at=datetime.utcnow(),
+            responded_at=datetime.now(timezone.utc),
             timed_out=False,
         )
 

tactus/testing/models.py

@@ -82,6 +82,8 @@ class FeatureResult(BaseModel):
 class TestResult(BaseModel):
     """Result from 'tactus test' command."""
 
+    __test__ = False
+
     features: List[FeatureResult] = Field(default_factory=list)
     total_scenarios: int
     passed_scenarios: int