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

tactus/stdlib/tac/tactus/corpora/filesystem.tac

@@ -0,0 +1,5 @@
+local base = require("tactus.corpora.base")
+
+return {
+  Corpus = base.wrap_corpus({}),
+}

tactus/stdlib/tac/tactus/retrievers/base.tac

@@ -0,0 +1,37 @@
+local function merge_defaults(defaults, config)
+  local merged = {}
+  if defaults then
+    for key, value in pairs(defaults) do
+      merged[key] = value
+    end
+  end
+  if config then
+    for key, value in pairs(config) do
+      merged[key] = value
+    end
+  end
+  return merged
+end
+
+local corpora_base = require("tactus.corpora.base")
+
+local function wrap_retriever(defaults)
+  local function constructor(config)
+    local merged = merge_defaults(defaults, config or {})
+    return _tactus_internal_retriever(merged)
+  end
+  local cls = {}
+  function cls:new(config)
+    return constructor(config)
+  end
+  return setmetatable(cls, {
+    __call = function(_, config)
+      return constructor(config)
+    end,
+  })
+end
+
+return {
+  wrap_corpus = corpora_base.wrap_corpus,
+  wrap_retriever = wrap_retriever,
+}

tactus/stdlib/tac/tactus/retrievers/embedding_index_file.tac

@@ -0,0 +1,6 @@
+local base = require("tactus.retrievers.base")
+
+return {
+  Corpus = base.wrap_corpus({}),
+  Retriever = base.wrap_retriever({ retriever_id = "embedding-index-file" }),
+}

tactus/stdlib/tac/tactus/retrievers/embedding_index_inmemory.tac

@@ -0,0 +1,6 @@
+local base = require("tactus.retrievers.base")
+
+return {
+  Corpus = base.wrap_corpus({}),
+  Retriever = base.wrap_retriever({ retriever_id = "embedding-index-inmemory" }),
+}

tactus/stdlib/tac/tactus/retrievers/index.md

@@ -0,0 +1,137 @@
+# Retriever Modules
+
+Tactus exposes Biblicus-backed retrievers as Lua modules so you can select a retriever explicitly at the top of your `.tac` file.
+
+## Embedding index (file-backed)
+
+```lua
+local FilesystemCorpus = require("tactus.corpora.filesystem")
+local vector = require("tactus.retrievers.embedding_index_file")
+
+support_notes = FilesystemCorpus.Corpus {
+  root = "corpora/support-notes",
+  configuration = {
+    pipeline = {
+      extract = {
+        -- extraction steps (optional)
+      }
+    }
+  }
+}
+
+support_search = vector.Retriever {
+  corpus = support_notes,
+  configuration = {
+    pipeline = {
+      index = {
+        embedding_provider = { provider_id = "hash-embedding", dimensions = 64 }
+      },
+      query = {
+        limit = 3,
+        maximum_total_characters = 1200
+      }
+    }
+  }
+}
+```
+
+## Embedding index (in-memory)
+
+```lua
+local FilesystemCorpus = require("tactus.corpora.filesystem")
+local vector = require("tactus.retrievers.embedding_index_inmemory")
+
+notes = FilesystemCorpus.Corpus {
+  root = "corpora/notes",
+  configuration = {
+    pipeline = {
+      extract = {
+        -- extraction steps (optional)
+      }
+    }
+  }
+}
+
+search = vector.Retriever {
+  corpus = notes,
+  configuration = {
+    pipeline = {
+      index = {
+        embedding_provider = { provider_id = "hash-embedding", dimensions = 64 },
+        maximum_cache_total_items = 5000
+      },
+      query = {
+        limit = 2
+      }
+    }
+  }
+}
+```
+
+## SQLite full-text search
+
+```lua
+local FilesystemCorpus = require("tactus.corpora.filesystem")
+local vector = require("tactus.retrievers.sqlite_full_text_search")
+
+notes = FilesystemCorpus.Corpus {
+  root = "corpora/notes",
+  configuration = {
+    pipeline = {
+      extract = {
+        -- extraction steps (optional)
+      }
+    }
+  }
+}
+
+search = vector.Retriever {
+  corpus = notes,
+  configuration = {
+    pipeline = {
+      index = {
+        snippet_characters = 400,
+        chunk_size = 800,
+        chunk_overlap = 200
+      },
+      query = {
+        limit = 2,
+        maximum_total_characters = 1200
+      }
+    }
+  }
+}
+```
+
+## TF vector (term-frequency)
+
+```lua
+local FilesystemCorpus = require("tactus.corpora.filesystem")
+local vector = require("tactus.retrievers.tf_vector")
+
+notes = FilesystemCorpus.Corpus {
+  root = "corpora/notes",
+  configuration = {
+    pipeline = {
+      extract = {
+        -- extraction steps (optional)
+      }
+    }
+  }
+}
+
+search = vector.Retriever {
+  corpus = notes,
+  configuration = {
+    pipeline = {
+      index = {
+        -- optional index settings
+      },
+      query = {
+        limit = 2,
+        maximum_total_characters = 1200
+      }
+    }
+  }
+}
+```

tactus/stdlib/tac/tactus/retrievers/init.tac

@@ -0,0 +1,11 @@
+local embedding_index_file = require("tactus.retrievers.embedding_index_file")
+local embedding_index_inmemory = require("tactus.retrievers.embedding_index_inmemory")
+local sqlite_full_text_search = require("tactus.retrievers.sqlite_full_text_search")
+local tf_vector = require("tactus.retrievers.tf_vector")
+
+return {
+  EmbeddingIndexFile = embedding_index_file,
+  EmbeddingIndexInMemory = embedding_index_inmemory,
+  SqliteFullTextSearch = sqlite_full_text_search,
+  TfVector = tf_vector,
+}

tactus/stdlib/tac/tactus/retrievers/sqlite_full_text_search.tac

@@ -0,0 +1,6 @@
+local base = require("tactus.retrievers.base")
+
+return {
+  Corpus = base.wrap_corpus({}),
+  Retriever = base.wrap_retriever({ retriever_id = "sqlite-full-text-search" }),
+}

tactus/stdlib/tac/tactus/retrievers/tf_vector.tac

@@ -0,0 +1,6 @@
+local base = require("tactus.retrievers.base")
+
+return {
+  Corpus = base.wrap_corpus({}),
+  Retriever = base.wrap_retriever({ retriever_id = "tf-vector" }),
+}

tactus/testing/behave_integration.py

@@ -413,6 +413,7 @@ class BehaveEnvironmentGenerator:
             f.write('"""\n\n')
 
             f.write("import sys\n")
+            f.write("import os\n")
             f.write("import json\n")
             f.write("from pathlib import Path\n\n")
 
@@ -440,6 +441,7 @@ class BehaveEnvironmentGenerator:
             f.write(f"    context.mcp_servers = json.loads('{mcp_servers_json}')\n")
             f.write(f"    context.tool_paths = json.loads('{tool_paths_json}')\n")
             f.write(f"    context.mocked = {mocked}\n\n")
+            f.write("    os.environ['TACTUS_MOCK_MODE'] = '1' if context.mocked else '0'\n\n")
 
             f.write("def before_scenario(context, scenario):\n")
             f.write('    """Setup before each scenario."""\n')

tactus/testing/context.py

@@ -45,18 +45,18 @@ class TactusTestContext:
         self.total_tokens: int = 0  # Track total tokens
         self.cost_breakdown: List[Any] = []  # Track per-call costs
         self._agent_mock_turns: Dict[str, List[Dict[str, Any]]] = {}
-        self._scenario_message: str | None = None
+        self._scenario_message: Optional[str] = None
 
     def set_scenario_message(self, message: str) -> None:
         """Set the scenario's primary injected message (for in-spec mocking coordination)."""
         self._scenario_message = message
 
-    def get_scenario_message(self) -> str | None:
+    def get_scenario_message(self) -> Optional[str]:
         """Get the scenario's primary injected message, if set."""
         return self._scenario_message
 
     def mock_agent_response(
-        self, agent: str, message: str, when_message: str | None = None
+        self, agent: str, message: str, when_message: Optional[str] = None
     ) -> None:
         """Add a mocked agent response for this scenario (temporal; 1 per agent turn).
 
@@ -79,8 +79,8 @@ class TactusTestContext:
         self,
         agent: str,
         tool: str,
-        args: Dict[str, Any] | None = None,
-        when_message: str | None = None,
+        args: Optional[Dict[str, Any]] = None,
+        when_message: Optional[str] = None,
     ) -> None:
         """Add a mocked tool call to an agent's next mocked turn for this scenario."""
         args = args or {}
@@ -114,7 +114,7 @@ class TactusTestContext:
             self.runtime.external_agent_mocks = self._agent_mock_turns
 
     def mock_agent_data(
-        self, agent: str, data: Dict[str, Any], when_message: str | None = None
+        self, agent: str, data: Dict[str, Any], when_message: Optional[str] = None
     ) -> None:
         """Set structured output mock data for an agent's next mocked turn.
 
@@ -171,6 +171,7 @@ class TactusTestContext:
         from tactus.testing.mock_registry import UnifiedMockRegistry
         from tactus.adapters.cli_log import CLILogHandler
 
+        os.environ["TACTUS_MOCK_MODE"] = "1" if self.mocked else "0"
         storage = MemoryStorage()
 
         # Setup mock registry if in mocked mode
@@ -209,6 +210,9 @@ class TactusTestContext:
             from tactus.core.mocking import MockManager
 
             self.runtime.mock_manager = MockManager()
+            from tactus.core.mocking import set_current_mock_manager
+
+            set_current_mock_manager(self.runtime.mock_manager)
             logger.info("Created MockManager for Mocks {} block support")
             # Mocked-mode tests should never call real LLMs by default.
             self.runtime.mock_all_agents = True

tactus/testing/evaluation_runner.py

@@ -94,6 +94,9 @@ class TactusEvaluationRunner(TactusTestRunner):
             EvaluationResult with all metrics
         """
         logger.info(f"Evaluating scenario '{scenario_name}' with {runs} runs")
+        run_iteration = self._run_single_iteration
+        if isinstance(run_iteration, staticmethod):
+            run_iteration = run_iteration.__func__
 
         # Run scenario N times
         if parallel:
@@ -102,12 +105,9 @@ class TactusEvaluationRunner(TactusTestRunner):
             ctx = multiprocessing.get_context("spawn")
             with ctx.Pool(processes=workers) as pool:
                 iteration_args = [(scenario_name, str(self.work_dir), i) for i in range(runs)]
-                results = pool.starmap(self._run_single_iteration, iteration_args)
+                results = pool.starmap(run_iteration, iteration_args)
         else:
-            results = [
-                self._run_single_iteration(scenario_name, str(self.work_dir), i)
-                for i in range(runs)
-            ]
+            results = [run_iteration(scenario_name, str(self.work_dir), i) for i in range(runs)]
 
         # Calculate metrics
         return self._calculate_metrics(scenario_name, results)

tactus/testing/steps/builtin.py

@@ -14,7 +14,7 @@ Provides a comprehensive library of steps for testing:
 import logging
 import re
 import ast
-from typing import Any
+from typing import Any, Optional
 
 from .registry import StepRegistry
 
@@ -645,7 +645,7 @@ def step_agent_takes_turn(context: Any, agent: str) -> None:
 
 
 def step_mock_agent_responds_with(
-    context: Any, agent: str, message: str, when_message: str | None = None
+    context: Any, agent: str, message: str, when_message: Optional[str] = None
 ) -> None:
     """Configure a per-scenario mock agent response (temporal)."""
     message, _ = _parse_step_string_literal(message)

tactus/testing/test_runner.py

@@ -128,6 +128,10 @@ class TactusTestRunner:
             if not scenarios:
                 raise ValueError(f"Scenario not found: {scenario_filter}")
 
+        run_scenario = self._run_single_scenario
+        if isinstance(run_scenario, staticmethod):
+            run_scenario = run_scenario.__func__
+
         # Run scenarios
         if parallel and len(scenarios) > 1:
             # Run in parallel using 'spawn' to avoid Behave global state conflicts
@@ -135,13 +139,11 @@ class TactusTestRunner:
             ctx = multiprocessing.get_context("spawn")
             with ctx.Pool(processes=min(len(scenarios), os.cpu_count() or 1)) as pool:
                 scenario_results = pool.starmap(
-                    self._run_single_scenario, [(s.name, str(self.work_dir)) for s in scenarios]
+                    run_scenario, [(s.name, str(self.work_dir)) for s in scenarios]
                 )
         else:
             # Run sequentially
-            scenario_results = [
-                self._run_single_scenario(s.name, str(self.work_dir)) for s in scenarios
-            ]
+            scenario_results = [run_scenario(s.name, str(self.work_dir)) for s in scenarios]
 
         # Build feature result
         feature_result = self._build_feature_result(scenario_results)

tactus/utils/asyncio_helpers.py

@@ -24,4 +24,5 @@ def clear_closed_event_loop() -> None:
         return
 
     if getattr(current_loop, "is_closed", lambda: False)():
-        asyncio.set_event_loop(None)
+        replacement_loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(replacement_loop)