tactus 0.38.0__tar.gz → 0.39.0__tar.gz

{tactus-0.38.0 → tactus-0.39.0}/CHANGELOG.md

@@ -2,6 +2,9 @@
 
 <!-- version list -->
 
+## v0.39.0 (2026-02-05)
+
+
 ## v0.38.0 (2026-02-03)
 
 ### Bug Fixes

{tactus-0.38.0 → tactus-0.39.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tactus
-Version: 0.38.0
+Version: 0.39.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

{tactus-0.38.0 → tactus-0.39.0}/examples/90-noaa-brief.tac

@@ -6,47 +6,13 @@
 local FilesystemCorpus = require("tactus.corpora.filesystem")
 local TfVector = require("tactus.retrievers.tf_vector")
 
-python = Tool {
-  use = "cli.python3",
-  description = "Run python3 scripts"
+FetchNoaaAfd = Tool {
+  use = "plugin.noaa.fetch_noaa_afd",
+  description = "Fetch NOAA AFD fixtures and import into Biblicus"
 }
 
-FetchNoaaAfd = function(params)
-  Log.info("FetchNoaaAfd: fetching NOAA AFD fixtures")
-  python({
-    args = {
-      "scripts/fetch_noaa_afd_corpus.py",
-      "--wfo", params.wfo,
-      "--max-items", tostring(params.max_items),
-      "--output", "tests/fixtures/noaa_afd",
-    }
-  })
-  Log.info("FetchNoaaAfd: building Biblicus corpus + tf-vector index")
-  python({
-    args = {
-      "scripts/prepare_noaa_afd_biblicus_corpus.py",
-      "--retriever", "tf-vector",
-      "--wfo", params.wfo,
-      "--force",
-    }
-  })
-  return {
-    status = "ok",
-    wfo = params.wfo,
-    max_items = params.max_items,
-  }
-end
-
 miami_afd = FilesystemCorpus.Corpus {
-  root = "tests/fixtures/noaa_afd_corpus/MFL",
-  configuration = {
-    pipeline = {
-      -- Extraction runs automatically on ingest.
-      extract = {
-        -- Placeholder for composed extraction steps.
-      }
-    }
-  }
+  root = "tests/fixtures/noaa_afd_corpus/MFL"
 }
 
 miami_search = TfVector.Retriever {
@@ -77,12 +43,11 @@ Miami = Agent {
   context = miami_context
 }
 
-fetch = Task {
+Task "fetch" {
   entry = function()
     return FetchNoaaAfd({
       wfo = "MFL",
       max_items = 5,
-      corpus = miami_afd
     })
   end
 }

{tactus-0.38.0 → tactus-0.39.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "tactus"
-version = "0.38.0"
+version = "0.39.0"
 description = "Tactus: Lua-based DSL for agentic workflows"
 readme = "README.md"
 requires-python = ">=3.9"

{tactus-0.38.0 → tactus-0.39.0}/scripts/prepare_noaa_afd_biblicus_corpus.py

@@ -52,6 +52,11 @@ def main() -> None:
         help="Snippet length budget for evidence text",
     )
     parser.add_argument("--force", action="store_true", help="Recreate the corpus directory")
+    parser.add_argument(
+        "--no-index",
+        action="store_true",
+        help="Only import items into the corpus (skip retriever snapshot build)",
+    )
     args = parser.parse_args()
 
     source_dir = _resolve_source_dir(args.source, args.wfo)
@@ -74,6 +79,11 @@ def main() -> None:
     for path in (corpus_dir / "raw").rglob("*.biblicus.yml.biblicus.yml"):
         path.unlink(missing_ok=True)
 
+    if args.no_index:
+        print(f"Corpus: {corpus_dir}")
+        print("Snapshot id: (skipped)")
+        return
+
     configuration: dict[str, object] = {}
     if args.retriever in {"embedding-index-file", "embedding-index-inmemory"}:
         configuration["embedding_provider"] = {

{tactus-0.38.0 → tactus-0.39.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.38.0"
+__version__ = "0.39.0"
 
 # Core exports
 from tactus.core.runtime import TactusRuntime

{tactus-0.38.0 → tactus-0.39.0}/tactus/core/dsl_stubs.py

@@ -413,6 +413,17 @@ def create_dsl_stubs(
         # Task "name" { ... }
         if isinstance(name_or_config, str):
             task_name = name_or_config
+            if config is None:
+
+                def _curried(task_config=None):
+                    if task_config is None or not hasattr(task_config, "items"):
+                        raise TypeError(
+                            f"Task '{task_name}' requires a configuration table. "
+                            'Use: Task "name" { ... } or name = Task { ... }.'
+                        )
+                    return _task(task_name, task_config)
+
+                return _curried
             task_config = config or {}
             if hasattr(task_config, "__setitem__"):
                 try:

{tactus-0.38.0 → tactus-0.39.0}/tactus/core/runtime.py

@@ -2499,6 +2499,7 @@ class TactusRuntime:
         """
         if not self.task_name and self.registry:
             explicit_tasks = getattr(self.registry, "tasks", {}) or {}
+            named_procedures = getattr(self.registry, "named_procedures", {}) or {}
 
             def _flatten_tasks(task_map: dict, prefix: str = "") -> list[str]:
                 names: list[str] = []
@@ -2528,10 +2529,12 @@ class TactusRuntime:
                         implicit_tasks.append(f"{task}:{retriever_name}")
 
             if explicit_tasks:
-                if len(explicit_tasks) == 1:
-                    self.task_name = next(iter(explicit_tasks.keys()))
-                elif "run" in explicit_tasks:
+                if "run" in explicit_tasks:
                     self.task_name = "run"
+                elif "main" in named_procedures:
+                    self.task_name = None
+                elif len(explicit_tasks) == 1:
+                    self.task_name = next(iter(explicit_tasks.keys()))
                 else:
                     from tactus.core.exceptions import TaskSelectionRequired
 
@@ -2892,7 +2895,11 @@ class TactusRuntime:
             r"^\s*[A-Za-z_][A-Za-z0-9_]*\s*=\s*(?:"
             r"Agent|Toolset|Tool|Model|Module|Signature|LM|Dependency|Prompt|"
             r"Task|TaskFunction|Context|Corpus|Retriever|Compactor|function|"
-            r"[A-Za-z_][A-Za-z0-9_]*Retriever|[A-Za-z_][A-Za-z0-9_]*\.Retriever"
+            r"[A-Za-z_][A-Za-z0-9_]*Retriever|"
+            r"[A-Za-z_][A-Za-z0-9_]*\.Retriever|"
+            r"[A-Za-z_][A-Za-z0-9_]*\.Corpus|"
+            r"[A-Za-z_][A-Za-z0-9_]*\.Context|"
+            r"[A-Za-z_][A-Za-z0-9_]*\.Compactor"
             r")\b"
         )
         # Match function definitions: function name() or local function name()
@@ -3167,6 +3174,9 @@ class TactusRuntime:
         except LuaSandboxError as e:
             raise TactusRuntimeError(f"Failed to parse DSL: {e}")
 
+        lua_globals = sandbox.lua.globals()
+        self._register_assignment_tasks(builder, lua_globals)
+
         self._expand_inline_task_children(builder.registry)
 
         # Execute IncludeTasks files to register additional tasks
@@ -3269,7 +3279,6 @@ class TactusRuntime:
         # The script mode transformation (in _maybe_transform_script_mode_source)
         # is designed to skip files with named function definitions to avoid wrapping
         # them incorrectly.
-        lua_globals = sandbox.lua.globals()
         if "main" in lua_globals:
             main_func = lua_globals["main"]
             # Check if it's a function and not already registered
@@ -3297,6 +3306,49 @@ class TactusRuntime:
         logger.debug(f"Registry after parsing: lua_tools={list(result.registry.lua_tools.keys())}")
         return result.registry
 
+    def _register_assignment_tasks(self, builder: RegistryBuilder, lua_globals: Any) -> None:
+        if not lua_globals:
+            return
+
+        for key, value in lua_globals.items():
+            if not isinstance(key, str):
+                continue
+            if not hasattr(value, "items"):
+                continue
+            try:
+                marker = value["__tactus_task_config"]
+            except Exception:
+                continue
+            if not marker:
+                continue
+            task_config = lua_table_to_dict(value)
+            if not isinstance(task_config, dict):
+                continue
+            if key in builder.registry.tasks:
+                continue
+            if "entry" in task_config and not callable(task_config["entry"]):
+                raise TactusRuntimeError(f"Task '{key}' entry must be a function")
+            builder.register_task(key, task_config)
+
+            child_sources = task_config.get("__tactus_child_tasks")
+            if isinstance(child_sources, dict):
+                child_iter = child_sources.items()
+            else:
+                child_iter = value.items()
+            for child_key, child_value in child_iter:
+                child_name = child_key if isinstance(child_key, str) else None
+                if not hasattr(child_value, "items"):
+                    continue
+                child_config = lua_table_to_dict(child_value)
+                if not child_name and isinstance(child_config, dict):
+                    child_name = child_config.get("__task_name")
+                if child_name and isinstance(child_config, dict):
+                    if "entry" in child_config and not callable(child_config["entry"]):
+                        raise TactusRuntimeError(
+                            f"Task '{key}:{child_name}' entry must be a function"
+                        )
+                    builder.register_task(child_name, child_config, parent=key)
+
     def _registry_to_config(self, registry: ProcedureRegistry) -> dict[str, Any]:
         """
         Convert registry to config dict format.

tactus-0.39.0/tactus/plugins/__init__.py

@@ -0,0 +1,3 @@
+"""
+Local plugin tools for Tactus.
+"""

tactus-0.39.0/tactus/plugins/noaa.py

@@ -0,0 +1,76 @@
+"""
+NOAA AFD helper tools for Tactus demos.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any, Dict
+
+
+def fetch_noaa_afd(
+    *,
+    wfo: str,
+    max_items: int = 5,
+    output_root: str = "tests/fixtures/noaa_afd",
+    corpus_root: str = "tests/fixtures/noaa_afd_corpus",
+    force: bool = True,
+) -> Dict[str, Any]:
+    """
+    Fetch NOAA AFD fixtures and import them into a Biblicus corpus (no index).
+
+    :param wfo: Weather Forecast Office code (e.g., MFL).
+    :type wfo: str
+    :param max_items: Maximum number of items to fetch.
+    :type max_items: int
+    :param output_root: Directory for raw fixture output.
+    :type output_root: str
+    :param corpus_root: Directory for Biblicus corpus output.
+    :type corpus_root: str
+    :param force: Whether to recreate the corpus directory.
+    :type force: bool
+    :return: Summary of the fetch/import operation.
+    :rtype: dict[str, Any]
+    """
+    repo_root = Path(__file__).resolve().parents[2]
+    fetch_script = repo_root / "scripts" / "fetch_noaa_afd_corpus.py"
+    prepare_script = repo_root / "scripts" / "prepare_noaa_afd_biblicus_corpus.py"
+
+    output_root_path = Path(output_root)
+    corpus_root_path = Path(corpus_root) / wfo.upper()
+
+    fetch_args = [
+        sys.executable,
+        str(fetch_script),
+        "--wfo",
+        wfo,
+        "--max-items",
+        str(max_items),
+        "--output",
+        str(output_root_path),
+    ]
+    subprocess.run(fetch_args, check=True)
+
+    prepare_args = [
+        sys.executable,
+        str(prepare_script),
+        "--wfo",
+        wfo,
+        "--corpus",
+        str(corpus_root_path),
+        "--no-index",
+    ]
+    if force:
+        prepare_args.append("--force")
+    subprocess.run(prepare_args, check=True)
+
+    return {
+        "status": "ok",
+        "wfo": wfo,
+        "max_items": max_items,
+        "output_root": str(output_root_path),
+        "corpus_root": str(corpus_root_path),
+        "indexed": False,
+    }

{tactus-0.38.0 → tactus-0.39.0}/tactus/stdlib/biblicus/text.py

@@ -62,10 +62,18 @@ def _normalize_client_config(client: Any) -> Any:
 
     payload = dict(client)
     model = payload.get("model")
-    provider = payload.get("provider")
     if not model:
         raise ValueError("client.model is required")
 
+    provider, model = _resolve_provider_and_model(payload.get("provider"), model)
+    payload["provider"] = provider
+    payload["model"] = model
+
+    biblicus = _require_biblicus_text()
+    return biblicus["LlmClientConfig"](**payload)
+
+
+def _resolve_provider_and_model(provider: str | None, model: Any) -> tuple[str, Any]:
     if provider is None and isinstance(model, str) and "/" in model:
         provider, model = model.split("/", 1)
     elif provider is not None and isinstance(model, str) and model.startswith(f"{provider}/"):
@@ -74,11 +82,7 @@ def _normalize_client_config(client: Any) -> Any:
     if provider is None:
         raise ValueError("client.provider is required when model lacks a provider prefix")
 
-    payload["provider"] = provider
-    payload["model"] = model
-
-    biblicus = _require_biblicus_text()
-    return biblicus["LlmClientConfig"](**payload)
+    return provider, model
 
 
 def _prepare_request(request: Dict[str, Any]) -> Dict[str, Any]:
@@ -97,11 +101,7 @@ def _prepare_request(request: Dict[str, Any]) -> Dict[str, Any]:
 
 
 def _maybe_mock(tool_name: str, payload: Dict[str, Any]) -> Dict[str, Any] | None:
-    try:
-        from tactus.core.mocking import get_current_mock_manager
-    except Exception:
-        return None
-    mock_manager = get_current_mock_manager()
+    mock_manager = _get_mock_manager()
     if mock_manager is None:
         return None
     mock_result = mock_manager.get_mock_response(tool_name, payload)
@@ -111,54 +111,73 @@ def _maybe_mock(tool_name: str, payload: Dict[str, Any]) -> Dict[str, Any] | Non
     return mock_result
 
 
-def extract(request: Dict[str, Any]) -> Dict[str, Any]:
+def _get_mock_manager() -> Any | None:
+    try:
+        from tactus.core.mocking import get_current_mock_manager
+    except Exception:
+        return None
+    return get_current_mock_manager()
+
+
+def _run_text_tool(
+    request: Dict[str, Any],
+    *,
+    tool_name: str,
+    request_model_key: str,
+    apply_key: str,
+) -> Dict[str, Any]:
     payload = _prepare_request(request)
-    mock_result = _maybe_mock("biblicus.text.extract", payload)
+    mock_result = _maybe_mock(tool_name, payload)
     if mock_result is not None:
         return mock_result
     biblicus = _require_biblicus_text()
-    result = biblicus["apply_text_extract"](biblicus["TextExtractRequest"](**payload))
+    result = biblicus[apply_key](biblicus[request_model_key](**payload))
     return result.model_dump()
 
 
+def extract(request: Dict[str, Any]) -> Dict[str, Any]:
+    return _run_text_tool(
+        request,
+        tool_name="biblicus.text.extract",
+        request_model_key="TextExtractRequest",
+        apply_key="apply_text_extract",
+    )
+
+
 def slice(request: Dict[str, Any]) -> Dict[str, Any]:
-    payload = _prepare_request(request)
-    mock_result = _maybe_mock("biblicus.text.slice", payload)
-    if mock_result is not None:
-        return mock_result
-    biblicus = _require_biblicus_text()
-    result = biblicus["apply_text_slice"](biblicus["TextSliceRequest"](**payload))
-    return result.model_dump()
+    return _run_text_tool(
+        request,
+        tool_name="biblicus.text.slice",
+        request_model_key="TextSliceRequest",
+        apply_key="apply_text_slice",
+    )
 
 
 def annotate(request: Dict[str, Any]) -> Dict[str, Any]:
-    payload = _prepare_request(request)
-    mock_result = _maybe_mock("biblicus.text.annotate", payload)
-    if mock_result is not None:
-        return mock_result
-    biblicus = _require_biblicus_text()
-    result = biblicus["apply_text_annotate"](biblicus["TextAnnotateRequest"](**payload))
-    return result.model_dump()
+    return _run_text_tool(
+        request,
+        tool_name="biblicus.text.annotate",
+        request_model_key="TextAnnotateRequest",
+        apply_key="apply_text_annotate",
+    )
 
 
 def redact(request: Dict[str, Any]) -> Dict[str, Any]:
-    payload = _prepare_request(request)
-    mock_result = _maybe_mock("biblicus.text.redact", payload)
-    if mock_result is not None:
-        return mock_result
-    biblicus = _require_biblicus_text()
-    result = biblicus["apply_text_redact"](biblicus["TextRedactRequest"](**payload))
-    return result.model_dump()
+    return _run_text_tool(
+        request,
+        tool_name="biblicus.text.redact",
+        request_model_key="TextRedactRequest",
+        apply_key="apply_text_redact",
+    )
 
 
 def link(request: Dict[str, Any]) -> Dict[str, Any]:
-    payload = _prepare_request(request)
-    mock_result = _maybe_mock("biblicus.text.link", payload)
-    if mock_result is not None:
-        return mock_result
-    biblicus = _require_biblicus_text()
-    result = biblicus["apply_text_link"](biblicus["TextLinkRequest"](**payload))
-    return result.model_dump()
+    return _run_text_tool(
+        request,
+        tool_name="biblicus.text.link",
+        request_model_key="TextLinkRequest",
+        apply_key="apply_text_link",
+    )
 
 
 def strip_span_tags(marked_up_text: str) -> str: