tactus 0.35.0__tar.gz → 0.36.0__tar.gz

{tactus-0.35.0 → tactus-0.36.0}/.github/workflows/release.yml

@@ -13,8 +13,11 @@ permissions:
 
 jobs:
   quality-checks:
-    name: Quality Checks
+    name: Quality Checks (Python ${{ matrix.python-version }})
     runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ['3.11', '3.12']
 
     steps:
       - name: Checkout code
@@ -25,7 +28,7 @@ jobs:
       - name: Set up Python
         uses: actions/setup-python@v5
         with:
-          python-version: '3.13'
+          python-version: ${{ matrix.python-version }}
           cache: 'pip'
 
       - name: Install dependencies

{tactus-0.35.0 → tactus-0.36.0}/.gitignore

@@ -19,6 +19,8 @@ pip-delete-this-directory.txt
 .cache
 nosetests.xml
 coverage.xml
+coverage.json
+coverage_html/
 *.cover
 *.log
 .pytest_cache/

{tactus-0.35.0 → tactus-0.36.0}/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 <!-- version list -->
 
+## v0.36.0 (2026-01-31)
+
+### Features
+
+- Test CI on supported Python versions
+  ([`37c1791`](https://github.com/AnthusAI/Tactus/commit/37c1791810690e26965415046fee02351415eeb5))
+
+
+## v0.35.1 (2026-01-31)
+
+### Bug Fixes
+
+- **code**: Quality iteration.
+  ([`6a456df`](https://github.com/AnthusAI/Tactus/commit/6a456df70c6a5e0338815079e75757cbe8b66af3))
+
+
 ## v0.35.0 (2026-01-31)
 
 ### Bug Fixes

{tactus-0.35.0 → tactus-0.36.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tactus
-Version: 0.35.0
+Version: 0.36.0
 Summary: Tactus: Lua-based DSL for agentic workflows
 Project-URL: Homepage, https://github.com/AnthusAI/Tactus
 Project-URL: Documentation, https://github.com/AnthusAI/Tactus/tree/main/docs
@@ -29,11 +29,15 @@ Requires-Dist: flask>=3.0.0
 Requires-Dist: gherkin-official>=28.0.0
 Requires-Dist: h5py>=3.10
 Requires-Dist: jinja2>=3.0
+Requires-Dist: litellm>=1.81.5
+Requires-Dist: logfire>=4.20.0
 Requires-Dist: lupa>=2.6
 Requires-Dist: markdown>=3.0
 Requires-Dist: nanoid>=2.0.0
 Requires-Dist: nest-asyncio>=1.5.0
 Requires-Dist: openpyxl>=3.1
+Requires-Dist: opentelemetry-api>=1.39.1
+Requires-Dist: opentelemetry-sdk>=1.39.1
 Requires-Dist: pyarrow>=14.0
 Requires-Dist: pydantic-ai-slim[bedrock,evals]
 Requires-Dist: pydantic>=2.0
@@ -68,6 +72,7 @@ Description-Content-Type: text/markdown
 
 ![Continuous integration][continuous-integration-badge]
 ![Coverage][coverage-badge]
+[![Documentation][documentation-badge]][documentation-link]
 
 **A programming language for reliable, tool-using AI agents.**
 
@@ -1830,3 +1835,5 @@ MIT License - see LICENSE file for details.
 
 [continuous-integration-badge]: https://github.com/AnthusAI/Tactus/actions/workflows/release.yml/badge.svg?branch=main
 [coverage-badge]: https://img.shields.io/endpoint?url=https%3A%2F%2Fraw.githubusercontent.com%2FAnthusAI%2FTactus%2Fmain%2Fcoverage_badge.json
+[documentation-badge]: https://img.shields.io/badge/docs-GitHub%20Pages-blue
+[documentation-link]: https://anthusai.github.io/Tactus/

{tactus-0.35.0 → tactus-0.36.0}/README.md

@@ -2,6 +2,7 @@
 
 ![Continuous integration][continuous-integration-badge]
 ![Coverage][coverage-badge]
+[![Documentation][documentation-badge]][documentation-link]
 
 **A programming language for reliable, tool-using AI agents.**
 
@@ -1764,3 +1765,5 @@ MIT License - see LICENSE file for details.
 
 [continuous-integration-badge]: https://github.com/AnthusAI/Tactus/actions/workflows/release.yml/badge.svg?branch=main
 [coverage-badge]: https://img.shields.io/endpoint?url=https%3A%2F%2Fraw.githubusercontent.com%2FAnthusAI%2FTactus%2Fmain%2Fcoverage_badge.json
+[documentation-badge]: https://img.shields.io/badge/docs-GitHub%20Pages-blue
+[documentation-link]: https://anthusai.github.io/Tactus/

{tactus-0.35.0 → tactus-0.36.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "tactus"
-version = "0.35.0"
+version = "0.36.0"
 description = "Tactus: Lua-based DSL for agentic workflows"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -29,6 +29,10 @@ dependencies = [
     "pyyaml",
     "pydantic>=2.0",
     "pydantic-ai-slim[bedrock,evals]",
+    "logfire>=4.20.0",
+    "litellm>=1.81.5",
+    "opentelemetry-api>=1.39.1",
+    "opentelemetry-sdk>=1.39.1",
     # NOTE: We use LiteLLM (via DSPy) for all LLM calls - do not add provider-specific SDKs
     "boto3>=1.28.0",
     "rich>=13.9.4",
@@ -109,6 +113,9 @@ markers = [
     "docker: Requires a running Docker daemon (opt-in; see TACTUS_RUN_DOCKER_TESTS)",
     "xdist_group: pytest-xdist grouping marker",
 ]
+filterwarnings = [
+    "ignore:(?s).*DETERMINISM WARNING.*File\\.read\\(\\).*:UserWarning",
+]
 
 [tool.black]
 line-length = 100

{tactus-0.35.0 → tactus-0.36.0}/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.35.0"
+__version__ = "0.36.0"
 
 # Core exports
 from tactus.core.runtime import TactusRuntime

{tactus-0.35.0 → tactus-0.36.0}/tactus/adapters/channels/host.py

@@ -102,7 +102,7 @@ class HostControlChannel(InProcessChannel):
 
         # Start background thread for input collection
         self._input_thread = threading.Thread(
-            target=self._input_thread_main,
+            target=self._collect_input_in_thread,
             args=(request,),
             daemon=True,
         )
@@ -142,7 +142,7 @@ class HostControlChannel(InProcessChannel):
         if self._input_thread and self._input_thread.is_alive():
             self._input_thread.join(timeout=1.0)
 
-    def _input_thread_main(self, request: ControlRequest) -> None:
+    def _collect_input_in_thread(self, request: ControlRequest) -> None:
         """
         Background thread main function.
 
@@ -154,32 +154,38 @@ class HostControlChannel(InProcessChannel):
         """
         try:
             # Collect input (may block)
-            response_value = self._prompt_for_input(request)
+            user_response_value = self._prompt_for_input(request)
 
             # Check if cancelled while waiting
             if self._cancel_event.is_set():
                 return
 
-            if response_value is not None:
-                # Create response and push to queue
-                response = ControlResponse(
-                    request_id=request.request_id,
-                    value=response_value,
-                    responded_at=datetime.now(timezone.utc),
-                    timed_out=False,
-                    channel_id=self.channel_id,
-                )
-
-                # Push thread-safe
-                if self._event_loop:
-                    self.push_response_threadsafe(response, self._event_loop)
-                else:
-                    self.push_response(response)
+            if user_response_value is not None:
+                response = self._build_response(request, user_response_value)
+                self._push_response_from_thread(response)
 
         except Exception as error:
             if not self._cancel_event.is_set():
                 logger.error("%s: input error: %s", self.channel_id, error)
 
+    def _input_thread_main(self, request: ControlRequest) -> None:
+        self._collect_input_in_thread(request)
+
+    def _build_response(self, request: ControlRequest, response_value: Any) -> ControlResponse:
+        return ControlResponse(
+            request_id=request.request_id,
+            value=response_value,
+            responded_at=datetime.now(timezone.utc),
+            timed_out=False,
+            channel_id=self.channel_id,
+        )
+
+    def _push_response_from_thread(self, response: ControlResponse) -> None:
+        if self._event_loop:
+            self.push_response_threadsafe(response, self._event_loop)
+        else:
+            self.push_response(response)
+
     @abstractmethod
     def _display_request(self, request: ControlRequest) -> None:
         """

{tactus-0.35.0 → tactus-0.36.0}/tactus/adapters/channels/sse.py

@@ -248,7 +248,14 @@ class SSEControlChannel(InProcessChannel):
         """
         logger.info("%s: received response for %s", self.channel_id, request_id)
 
-        response = ControlResponse(
+        response = self._build_response(request_id, value)
+
+        # Push to queue from sync context (Flask thread)
+        # Get the running event loop and schedule the put operation
+        self._enqueue_response_from_sync_context(request_id, response)
+
+    def _build_response(self, request_id: str, value: Any) -> ControlResponse:
+        return ControlResponse(
             request_id=request_id,
             value=value,
             responded_at=datetime.now(timezone.utc),
@@ -256,15 +263,14 @@ class SSEControlChannel(InProcessChannel):
             channel_id=self.channel_id,
         )
 
-        # Push to queue from sync context (Flask thread)
-        # Get the running event loop and schedule the put operation
+    def _enqueue_response_from_sync_context(
+        self, request_id: str, response: ControlResponse
+    ) -> None:
         try:
             event_loop = asyncio.get_event_loop()
             if event_loop.is_running():
-                # Schedule the coroutine in the running loop
                 asyncio.run_coroutine_threadsafe(self._response_queue.put(response), event_loop)
             else:
-                # If no loop is running, use put_nowait (shouldn't happen)
                 self._response_queue.put_nowait(response)
         except Exception as error:
             logger.error(

{tactus-0.35.0 → tactus-0.36.0}/tactus/adapters/control_loop.py

@@ -201,37 +201,12 @@ class ControlLoopHandler:
             message[:50],
         )
 
-        # Run the async request flow
-        # Check if we're already in an async context
-        try:
-            event_loop = asyncio.get_running_loop()
-            if event_loop.is_closed():
-                raise RuntimeError("Running event loop is closed")
+        # Run the async request flow.
+        running_event_loop = self._get_running_event_loop()
+        if running_event_loop is not None:
+            return self._run_request_in_running_loop(running_event_loop, request)
 
-            # Already in async context - create task and run it
-            # This shouldn't normally happen since request_interaction is sync
-            import nest_asyncio
-
-            nest_asyncio.apply()
-            return event_loop.run_until_complete(self._request_interaction_async(request))
-        except RuntimeError:
-            # Not in async context - create a temporary event loop.
-            previous_event_loop: asyncio.AbstractEventLoop | None = None
-            try:
-                previous_event_loop = asyncio.get_event_loop()
-            except RuntimeError:
-                previous_event_loop = None
-            else:
-                if getattr(previous_event_loop, "is_closed", lambda: False)():
-                    previous_event_loop = None
-
-            event_loop = asyncio.new_event_loop()
-            try:
-                asyncio.set_event_loop(event_loop)
-                return event_loop.run_until_complete(self._request_interaction_async(request))
-            finally:
-                event_loop.close()
-                asyncio.set_event_loop(previous_event_loop)
+        return self._run_request_in_new_loop(request)
 
     async def _request_interaction_async(self, request: ControlRequest) -> ControlResponse:
         """
@@ -312,6 +287,45 @@ class ControlLoopHandler:
 
         raise ProcedureWaitingForHuman(request.procedure_id, request.request_id)
 
+    def _get_running_event_loop(self) -> Optional[asyncio.AbstractEventLoop]:
+        try:
+            event_loop = asyncio.get_running_loop()
+        except RuntimeError:
+            return None
+
+        if event_loop.is_closed():
+            return None
+        return event_loop
+
+    def _run_request_in_running_loop(
+        self, event_loop: asyncio.AbstractEventLoop, request: ControlRequest
+    ) -> ControlResponse:
+        # Already in async context - create task and run it.
+        # This shouldn't normally happen since request_interaction is sync.
+        import nest_asyncio
+
+        nest_asyncio.apply()
+        return event_loop.run_until_complete(self._request_interaction_async(request))
+
+    def _run_request_in_new_loop(self, request: ControlRequest) -> ControlResponse:
+        # Not in async context - create a temporary event loop.
+        previous_event_loop: Optional[asyncio.AbstractEventLoop] = None
+        try:
+            previous_event_loop = asyncio.get_event_loop()
+        except RuntimeError:
+            previous_event_loop = None
+        else:
+            if getattr(previous_event_loop, "is_closed", lambda: False)():
+                previous_event_loop = None
+
+        event_loop = asyncio.new_event_loop()
+        try:
+            asyncio.set_event_loop(event_loop)
+            return event_loop.run_until_complete(self._request_interaction_async(request))
+        finally:
+            event_loop.close()
+            asyncio.set_event_loop(previous_event_loop)
+
     async def _fanout(
         self,
         request: ControlRequest,

{tactus-0.35.0 → tactus-0.36.0}/tactus/core/execution_context.py

@@ -155,11 +155,16 @@ class BaseExecutionContext(ExecutionContext):
         self.lua_sandbox: Any | None = None
 
         # Rich metadata for HITL notifications
-        self.procedure_name: str = procedure_id  # Use procedure_id as default name
-        self.invocation_id: str = str(uuid.uuid4())
-        self._started_at: datetime = datetime.now(timezone.utc)
-        self._input_data: Any = None
+        self._initialize_run_metadata(procedure_id)
+        self._load_and_reset_metadata(procedure_id)
 
+    def _initialize_run_metadata(self, procedure_id: str) -> None:
+        self.procedure_name = procedure_id
+        self.invocation_id = str(uuid.uuid4())
+        self._started_at = datetime.now(timezone.utc)
+        self._input_data = None
+
+    def _load_and_reset_metadata(self, procedure_id: str) -> None:
         # Load procedure metadata (contains execution_log and replay_index)
         self.metadata = self.storage.load_procedure_metadata(procedure_id)
 

{tactus-0.35.0 → tactus-0.36.0}/tactus/core/lua_sandbox.py

@@ -241,7 +241,7 @@ class LuaSandbox:
         """Setup safe global functions and utilities."""
         # Keep safe standard library functions
         # (These are already available by default, just documenting them)
-        safe_functions = {
+        safe_global_symbols = {
             # Math
             "math",  # Math library (will be replaced with safe version if context available)
             "tonumber",  # Convert to number
@@ -264,54 +264,62 @@ class LuaSandbox:
         }
 
         # Just log what's available - no need to explicitly set
-        logger.debug("Safe Lua functions available: %s", ", ".join(safe_functions))
+        logger.debug("Safe Lua functions available: %s", ", ".join(safe_global_symbols))
 
         # Replace math and os libraries with safe versions if context available
         if self.execution_context is not None:
-            from tactus.utils.safe_libraries import (
-                create_safe_math_library,
-                create_safe_os_library,
-            )
+            self._install_context_safe_libraries()
+            return  # Skip default os.date setup below
 
-            def get_context():
-                return self.execution_context
+        self._install_fallback_os_date()
 
-            safe_math_dict = create_safe_math_library(get_context, self.strict_determinism)
-            safe_os_dict = create_safe_os_library(get_context, self.strict_determinism)
+    def _install_context_safe_libraries(self) -> None:
+        """Install safe math and os libraries based on execution context."""
+        from tactus.utils.safe_libraries import (
+            create_safe_math_library,
+            create_safe_os_library,
+        )
 
-            safe_math_table = self._dict_to_lua_table(safe_math_dict)
-            safe_os_table = self._dict_to_lua_table(safe_os_dict)
+        def get_execution_context() -> Any:
+            return self.execution_context
 
-            self.lua.globals()["math"] = safe_math_table
-            self.lua.globals()["os"] = safe_os_table
+        safe_math_dict = create_safe_math_library(get_execution_context, self.strict_determinism)
+        safe_os_dict = create_safe_os_library(get_execution_context, self.strict_determinism)
 
-            logger.debug("Installed safe math and os libraries with determinism checking")
-            return  # Skip default os.date setup below
+        safe_math_table = self._dict_to_lua_table(safe_math_dict)
+        safe_os_table = self._dict_to_lua_table(safe_os_dict)
 
-        # Add safe subset of os module (only date function for timestamps)
-        # This is a fallback when no execution context is available (testing/REPL)
-        from datetime import datetime
+        self.lua.globals()["math"] = safe_math_table
+        self.lua.globals()["os"] = safe_os_table
+
+        logger.debug("Installed safe math and os libraries with determinism checking")
+
+    def _install_fallback_os_date(self) -> None:
+        """Install a safe os.date() fallback when no execution context is available."""
+        safe_os_table = self._build_fallback_os_table()
+        self.lua.globals()["os"] = safe_os_table
+        logger.debug("Added safe os.date() function")
 
-        def safe_date(format_str=None):
+    def _build_fallback_os_table(self) -> Any:
+        """Build a Lua os table with a safe date() implementation."""
+        from datetime import datetime, timezone
+
+        def safe_date(format_string: Optional[str] = None) -> str:
             """Safe implementation of os.date() for timestamp generation."""
-            now = datetime.utcnow()
-            if format_str is None:
+            now = datetime.now(timezone.utc)
+            if format_string is None:
                 # Return default format like Lua's os.date()
                 return now.strftime("%a %b %d %H:%M:%S %Y")
-            elif format_str == "%Y-%m-%dT%H:%M:%SZ":
+            if format_string == "%Y-%m-%dT%H:%M:%SZ":
                 # ISO 8601 format
                 return now.strftime("%Y-%m-%dT%H:%M:%SZ")
-            else:
-                # Support Python strftime formats
-                try:
-                    return now.strftime(format_str)
-                except Exception:  # noqa: E722
-                    return now.strftime("%a %b %d %H:%M:%S %Y")
-
-        # Create safe os table with only date function
-        safe_os = self.lua.table(date=safe_date)
-        self.lua.globals()["os"] = safe_os
-        logger.debug("Added safe os.date() function")
+            # Support Python strftime formats
+            try:
+                return now.strftime(format_string)
+            except Exception:  # noqa: E722
+                return now.strftime("%a %b %d %H:%M:%S %Y")
+
+        return self.lua.table(date=safe_date)
 
     def setup_assignment_interception(self, callback: Any) -> None:
         """

{tactus-0.35.0 → tactus-0.36.0}/tactus/core/message_history_manager.py

@@ -136,37 +136,60 @@ class MessageHistoryManager:
                 print(f"Warning: Filter function failed: {exception}")
                 return messages
 
-        # Otherwise it's a tuple (filter_type, filter_arg)
-        if not isinstance(filter_specification, tuple) or len(filter_specification) < 2:
+        filter_name, filter_value = self._parse_filter_spec(filter_specification)
+        if filter_name is None:
             return messages
 
-        filter_name = filter_specification[0]
-        filter_value = filter_specification[1]
-
-        if filter_name == "last_n":
-            return self._filter_last_n(messages, filter_value)
-        elif filter_name == "first_n":
-            return self._filter_first_n(messages, filter_value)
-        elif filter_name == "token_budget":
-            return self._filter_by_token_budget(messages, filter_value)
-        elif filter_name == "head_tokens":
-            return self._filter_head_tokens(messages, filter_value)
-        elif filter_name == "tail_tokens":
-            return self._filter_tail_tokens(messages, filter_value)
-        elif filter_name == "by_role":
-            return self._filter_by_role(messages, filter_value)
-        elif filter_name == "system_prefix":
-            return self._filter_system_prefix(messages)
-        elif filter_name == "compose":
-            # Apply multiple filters in sequence
-            filtered_messages = messages
-            for filter_step in filter_value:
-                filtered_messages = self._apply_filter(filtered_messages, filter_step, context)
-            return filtered_messages
-        else:
-            # Unknown filter type, return unfiltered
+        if filter_name == "compose":
+            return self._apply_composed_filters(messages, filter_value, context)
+
+        return self._apply_named_filter(messages, filter_name, filter_value)
+
+    @staticmethod
+    def _parse_filter_spec(filter_specification: Any) -> tuple[str | None, Any]:
+        if not isinstance(filter_specification, tuple) or len(filter_specification) < 2:
+            return None, None
+
+        return filter_specification[0], filter_specification[1]
+
+    def _apply_composed_filters(
+        self,
+        messages: list[ModelMessage],
+        filter_steps: Any,
+        context: Optional[Any],
+    ) -> list[ModelMessage]:
+        filtered_messages = messages
+        for filter_step in filter_steps:
+            filtered_messages = self._apply_filter(filtered_messages, filter_step, context)
+        return filtered_messages
+
+    def _apply_named_filter(
+        self,
+        messages: list[ModelMessage],
+        filter_name: str,
+        filter_value: Any,
+    ) -> list[ModelMessage]:
+        filter_function = self._filter_dispatch.get(filter_name)
+        if filter_function is None:
             return messages
 
+        if filter_name == "system_prefix":
+            return filter_function(messages)
+
+        return filter_function(messages, filter_value)
+
+    @property
+    def _filter_dispatch(self) -> dict[str, Any]:
+        return {
+            "last_n": self._filter_last_n,
+            "first_n": self._filter_first_n,
+            "token_budget": self._filter_by_token_budget,
+            "head_tokens": self._filter_head_tokens,
+            "tail_tokens": self._filter_tail_tokens,
+            "by_role": self._filter_by_role,
+            "system_prefix": self._filter_system_prefix,
+        }
+
     def _filter_last_n(
         self,
         messages: list[ModelMessage],