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

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/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/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/plugins/__init__.py

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

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

tactus/validation/semantic_visitor.py

@@ -131,29 +131,9 @@ class TactusDSLVisitor(LuaParserVisitor):
                     assignment_target_name = assignment_target_node.NAME().getText()
                     self._track_retriever_alias(assignment_target_name, expression_list)
 
-                    # Check if this is a DSL setting assignment
-                    setting_handlers_by_name = {
-                        "default_provider": self.builder.set_default_provider,
-                        "default_model": self.builder.set_default_model,
-                        "return_prompt": self.builder.set_return_prompt,
-                        "error_prompt": self.builder.set_error_prompt,
-                        "status_prompt": self.builder.set_status_prompt,
-                        "async": self.builder.set_async,
-                        "max_depth": self.builder.set_max_depth,
-                        "max_turns": self.builder.set_max_turns,
-                    }
-                    if assignment_target_name in setting_handlers_by_name:
-                        # Get the value from explist
-                        if expression_list.exp() and len(expression_list.exp()) > 0:
-                            first_expression = expression_list.exp()[0]
-                            literal_value = self._extract_literal_value(first_expression)
-                            # Process the assignment like a function call
-                            setting_handlers_by_name[assignment_target_name](literal_value)
-                    else:
-                        # Check for assignment-based DSL declarations
-                        # e.g., greeter = Agent {...}, done = Tool {...}
-                        if expression_list.exp() and len(expression_list.exp()) > 0:
-                            first_expression = expression_list.exp()[0]
+                    if not self._apply_setting_assignment(assignment_target_name, expression_list):
+                        first_expression = self._extract_first_expression(expression_list)
+                        if first_expression:
                             self._check_assignment_based_declaration(
                                 assignment_target_name, first_expression
                             )
@@ -219,105 +199,116 @@ class TactusDSLVisitor(LuaParserVisitor):
                         )
                         return
 
-                if function_name == "Agent" and not is_chained_method_call:
-                    # Extract config from Agent {...}
-                    declaration_config = self._extract_single_table_arg(function_call)
-                    # Filter out None values from tools list (variable refs can't be resolved)
-                    if declaration_config and "tools" in declaration_config:
-                        tool_name_list = declaration_config["tools"]
-                        if isinstance(tool_name_list, list):
-                            declaration_config["tools"] = [
-                                tool_name for tool_name in tool_name_list if tool_name is not None
-                            ]
-                    self.builder.register_agent(
-                        assignment_target_name,
-                        declaration_config if declaration_config else {},
-                        None,
-                    )
-                elif function_name == "Tool":
-                    # Extract config from Tool {...}
-                    declaration_config = self._extract_single_table_arg(function_call)
-                    if (
-                        declaration_config
-                        and isinstance(declaration_config, dict)
-                        and isinstance(declaration_config.get("name"), str)
-                        and declaration_config.get("name") != assignment_target_name
-                    ):
-                        self._record_error(
-                            message=(
-                                f"Tool name mismatch: '{assignment_target_name} = Tool {{ name = \"{declaration_config.get('name')}\" }}'. "
-                                f"Remove the 'name' field or set it to '{assignment_target_name}'."
-                            ),
-                            declaration="Tool",
-                        )
-                    self.builder.register_tool(
-                        assignment_target_name,
-                        declaration_config if declaration_config else {},
-                        None,
-                    )
-                elif function_name == "Toolset":
-                    # Extract config from Toolset {...}
-                    declaration_config = self._extract_single_table_arg(function_call)
-                    self.builder.register_toolset(
-                        assignment_target_name,
-                        declaration_config if declaration_config else {},
-                    )
-                elif function_name == "Context":
-                    declaration_config = self._extract_single_table_arg(function_call)
-                    self.builder.register_context(
-                        assignment_target_name,
-                        declaration_config if declaration_config else {},
-                    )
-                elif function_name == "Corpus":
-                    declaration_config = self._extract_single_table_arg(function_call)
-                    self.builder.register_corpus(
-                        assignment_target_name,
-                        declaration_config if declaration_config else {},
-                    )
-                elif function_name == "Retriever":
-                    declaration_config = self._extract_single_table_arg(function_call)
+                if function_name == "Agent" and is_chained_method_call:
+                    return
+                handled = self._register_assignment_based_declaration(
+                    assignment_target_name, function_name, function_call
+                )
+                if handled:
+                    return
+                declaration_config = self._extract_single_table_arg(function_call)
+                if isinstance(declaration_config, dict) and "corpus" in declaration_config:
                     retriever_id = self._resolve_retriever_id_from_call(function_call)
-                    if (
-                        isinstance(declaration_config, dict)
-                        and retriever_id
-                        and "retriever_id" not in declaration_config
-                    ):
+                    if retriever_id and "retriever_id" not in declaration_config:
                         declaration_config["retriever_id"] = retriever_id
                     self.builder.register_retriever(
                         assignment_target_name,
-                        declaration_config if declaration_config else {},
-                    )
-                elif function_name == "Compactor":
-                    declaration_config = self._extract_single_table_arg(function_call)
-                    self.builder.register_compactor(
-                        assignment_target_name,
-                        declaration_config if declaration_config else {},
-                    )
-                elif function_name == "Procedure":
-                    # New assignment syntax: main = Procedure { function(input) ... }
-                    # Register as a named procedure
-                    self.builder.register_named_procedure(
-                        assignment_target_name,
-                        None,  # Function not available during validation
-                        {},  # Input schema will be extracted from top-level input {}
-                        {},  # Output schema will be extracted from top-level output {}
-                        {},  # State schema
+                        declaration_config,
                     )
-                elif function_name == "Task":
-                    # Assignment-based task declaration: name = Task { ... }
-                    self._processed_task_calls.add(id(function_call))
-                    self._register_task_declaration(assignment_target_name, function_call)
-                else:
-                    # Heuristic: treat any assignment-based call with a 'corpus' field as a retriever.
-                    declaration_config = self._extract_single_table_arg(function_call)
-                    if isinstance(declaration_config, dict) and "corpus" in declaration_config:
-                        retriever_id = self._resolve_retriever_id_from_call(function_call)
-                        if retriever_id and "retriever_id" not in declaration_config:
-                            declaration_config["retriever_id"] = retriever_id
-                        self.builder.register_retriever(
-                            assignment_target_name,
-                            declaration_config,
-                        )
+
+    def _apply_setting_assignment(self, assignment_target_name: str, expression_list) -> bool:
+        setting_handlers_by_name = {
+            "default_provider": self.builder.set_default_provider,
+            "default_model": self.builder.set_default_model,
+            "return_prompt": self.builder.set_return_prompt,
+            "error_prompt": self.builder.set_error_prompt,
+            "status_prompt": self.builder.set_status_prompt,
+            "async": self.builder.set_async,
+            "max_depth": self.builder.set_max_depth,
+            "max_turns": self.builder.set_max_turns,
+        }
+        if assignment_target_name not in setting_handlers_by_name:
+            return False
+        first_expression = self._extract_first_expression(expression_list)
+        if not first_expression:
+            return True
+        literal_value = self._extract_literal_value(first_expression)
+        setting_handlers_by_name[assignment_target_name](literal_value)
+        return True
+
+    def _extract_first_expression(self, expression_list):
+        exp_list = getattr(expression_list, "exp", None)
+        if not callable(exp_list):
+            return None
+        expressions = exp_list()
+        if expressions:
+            return expressions[0]
+        return None
+
+    def _register_assignment_based_declaration(
+        self,
+        assignment_target_name: str,
+        function_name: str,
+        function_call,
+    ) -> bool:
+        declaration_config = self._extract_single_table_arg(function_call)
+        normalized_config = declaration_config if declaration_config else {}
+        if function_name == "Agent":
+            if "tools" in normalized_config:
+                tool_name_list = normalized_config["tools"]
+                if isinstance(tool_name_list, list):
+                    normalized_config["tools"] = [
+                        tool_name for tool_name in tool_name_list if tool_name is not None
+                    ]
+            self.builder.register_agent(assignment_target_name, normalized_config, None)
+            return True
+        if function_name == "Tool":
+            if (
+                isinstance(normalized_config, dict)
+                and isinstance(normalized_config.get("name"), str)
+                and normalized_config.get("name") != assignment_target_name
+            ):
+                self._record_error(
+                    message=(
+                        f"Tool name mismatch: '{assignment_target_name} = Tool {{ name = \"{normalized_config.get('name')}\" }}'. "
+                        f"Remove the 'name' field or set it to '{assignment_target_name}'."
+                    ),
+                    declaration="Tool",
+                )
+            self.builder.register_tool(assignment_target_name, normalized_config, None)
+            return True
+        if function_name == "Toolset":
+            self.builder.register_toolset(assignment_target_name, normalized_config)
+            return True
+        if function_name == "Context":
+            self.builder.register_context(assignment_target_name, normalized_config)
+            return True
+        if function_name == "Corpus":
+            self.builder.register_corpus(assignment_target_name, normalized_config)
+            return True
+        if function_name == "Retriever":
+            retriever_id = self._resolve_retriever_id_from_call(function_call)
+            if retriever_id and "retriever_id" not in normalized_config:
+                normalized_config["retriever_id"] = retriever_id
+            self.builder.register_retriever(assignment_target_name, normalized_config)
+            return True
+        if function_name == "Compactor":
+            self.builder.register_compactor(assignment_target_name, normalized_config)
+            return True
+        if function_name == "Procedure":
+            self.builder.register_named_procedure(
+                assignment_target_name,
+                None,
+                {},
+                {},
+                {},
+            )
+            return True
+        if function_name == "Task":
+            self._processed_task_calls.add(id(function_call))
+            self._register_task_declaration(assignment_target_name, function_call)
+            return True
+        return False
 
     def _extract_single_table_arg(self, function_call) -> dict:
         """Extract a single table argument from a function call like Agent {...}."""
@@ -1122,23 +1113,23 @@ class TactusDSLVisitor(LuaParserVisitor):
             return token_text[2:-2]
         elif token_text.startswith('"') and token_text.endswith('"'):
             # Double-quoted string
-            content = token_text[1:-1]
-            content = content.replace("\\n", "\n")
-            content = content.replace("\\t", "\t")
-            content = content.replace('\\"', '"')
-            content = content.replace("\\\\", "\\")
-            return content
+            return self._unescape_basic_string(token_text[1:-1], '"')
         elif token_text.startswith("'") and token_text.endswith("'"):
             # Single-quoted string
-            content = token_text[1:-1]
-            content = content.replace("\\n", "\n")
-            content = content.replace("\\t", "\t")
-            content = content.replace("\\'", "'")
-            content = content.replace("\\\\", "\\")
-            return content
+            return self._unescape_basic_string(token_text[1:-1], "'")
 
         return token_text
 
+    def _unescape_basic_string(self, content: str, quote_char: str) -> str:
+        content = content.replace("\\n", "\n")
+        content = content.replace("\\t", "\t")
+        if quote_char == '"':
+            content = content.replace('\\"', '"')
+        elif quote_char == "'":
+            content = content.replace("\\'", "'")
+        content = content.replace("\\\\", "\\")
+        return content
+
     def _parse_table_constructor(self, ctx: LuaParser.TableconstructorContext) -> Any:
         """Parse Lua table constructor to Python dict."""
         parsed_table = {}

{tactus-0.38.0.dist-info → tactus-0.39.0.dist-info}/METADATA

@@ -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.dist-info → tactus-0.39.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-tactus/__init__.py,sha256=g5cqIhFTf2v9_3EjAdhFDjXJWMvCrtSaYVs7B7LpU7M,1245
+tactus/__init__.py,sha256=FbndoB7McjD-smRU9tGDLvNIw7o7-dCqiKRP3LSD23c,1245
 tactus/adapters/__init__.py,sha256=47Y8kGBR4QGxqEGvjA1mneOSACb2L7oELnj6P2uI7uk,759
 tactus/adapters/broker_log.py,sha256=9ZR-rJdyW6bMNZx3OfXoQEnDxcAzNsiJ8aPxZGqJYrM,6019
 tactus/adapters/cli_hitl.py,sha256=Nrfoi35Ei9fTMReLG2QxKkhKyIvl3pYcAUdQCAUOZDk,17361
@@ -37,7 +37,7 @@ tactus/core/compaction.py,sha256=mVwFsEb9FEc-bMPFcKgXyAO-pVnAXeQGZka7RWtjVsY,397
 tactus/core/config_manager.py,sha256=kxz853j4Nx97SBh8-fAar_OfmfWZvvcfafLyxjTQG1A,35131
 tactus/core/context_assembler.py,sha256=tbd-XACBvAFkBlPrzAAZ_L-2JGnO4meS-GL4ilE7XHw,2406
 tactus/core/context_models.py,sha256=YHKjHKEzLk3fgpkmXYQ9RWDPKRNStt92ve40xcMv3p0,975
-tactus/core/dsl_stubs.py,sha256=3yg7yWcflDPOOzbLG7VmHh7yZPXf1G_q6sdYt5DWPOw,109777
+tactus/core/dsl_stubs.py,sha256=l1icTqTM092Z2AsrdLAo3WjZtDDVggMBG662KdWUIIU,110257
 tactus/core/exceptions.py,sha256=r-4IrZw_WrioBkpMR42Q3LNwEqimJ6jxXgfOo2wANTM,1962
 tactus/core/execution_context.py,sha256=OgTe9E0xc3nTQbCTEaaBfI11dVA1-J0eFz0eQR4XMZY,29402
 tactus/core/lua_sandbox.py,sha256=Ln2P1gdxVl396HLvEw7FmDKV3eVdVdbDzYHMbDSEciY,19106
@@ -47,7 +47,7 @@ tactus/core/output_validator.py,sha256=LcSjgAiDRvzsj2uWasQihengQRt7R-ZYaPiLQPbZy
 tactus/core/registry.py,sha256=z5HFoi1zb81-TJ_6qeTWSte4J0Zw-NYmN19VjjBjJE8,26577
 tactus/core/retrieval.py,sha256=AMDa4X4YWaSDNdf3T3hRUzgM4W1l_sGqxAX5Jki5PH0,12083
 tactus/core/retriever_tasks.py,sha256=i2wsoZN9cZOypkdPAJKqlrRP_jwtqpHVCFoxPL0Iirk,931
-tactus/core/runtime.py,sha256=kwDM88Ell2RkOkEbwmI5v92fQOLeruod-dpbCTq6hM0,155443
+tactus/core/runtime.py,sha256=YMZKfUj2sfyGyBFdKvXWjbt2dbf-mckz4CefeMm_7sw,157790
 tactus/core/template_resolver.py,sha256=r97KzFNaK4nFSoWtIFZeSKyuUWgbp-ay1_BGrb-BgUY,4179
 tactus/core/yaml_parser.py,sha256=JD7Nehaxw3uP1KV_uTU_xiXTbEWqoKOceU5tAJ4lcH8,13985
 tactus/core/dependencies/__init__.py,sha256=28-TM7_i-JqTD3hvkq1kMzr__A8VjfIKXymdW9mn5NM,362
@@ -76,6 +76,8 @@ tactus/ide/__init__.py,sha256=1fSC0xWP-Lq5wl4FgDq7SMnkvZ0DxXupreTl3ZRX1zw,143
 tactus/ide/coding_assistant.py,sha256=i2cfT6uMSM7TEFw-9p9Ed_BWSbAMqgokoaFdbjKAQcg,12187
 tactus/ide/config_server.py,sha256=U8OWxi5l24GH1lUHIAQ8WB8j0cJ5ofLX9iVecW1O2vc,18862
 tactus/ide/server.py,sha256=nE_UDiXJZN7G-RzPD-guZ_4qPxPl722qcrv4UY6bjII,111151
+tactus/plugins/__init__.py,sha256=MOSTLvPnXeDHKNcGzTv26bRxsK62pVRmTjEwbuoaWHk,39
+tactus/plugins/noaa.py,sha256=BTBxmbI55AFgDNB4ZhNR7NaKqJECRvRJRua4gahaSvU,2022
 tactus/primitives/__init__.py,sha256=x6bGwoa9DizKUwqsg7SqURfJxisEdctTCv1XnSAZxIk,1709
 tactus/primitives/control.py,sha256=jw-7ggHtNLfFL5aTUUs6Fo5y4xsxEG8OIRe0RyIjVnc,4783
 tactus/primitives/file.py,sha256=GFHmXOADRllfJw6gHpIdVMmZ_ZS7DVgresQ0F71nqJE,7458
@@ -122,7 +124,7 @@ tactus/stdlib/README.md,sha256=AqKYj7JxtphfKJlhq_sNezIUPfblzzubzdxE3PheiQE,2576
 tactus/stdlib/__init__.py,sha256=NkRsL413VXr0rLAadbb3meP5TelwcrEFVJd1u39XCbk,1047
 tactus/stdlib/loader.py,sha256=qjVnz5mn3Uu7g1O4vjSREHkR-YdRoON1vqJQq-oiFIE,8679
 tactus/stdlib/biblicus/__init__.py,sha256=Y6Nb-wp33KeDtkjBccZrGYlyR98yhZBm1RfmiKIJHm8,50
-tactus/stdlib/biblicus/text.py,sha256=KMbMlaGQsrAwXgCShoLs54xYDoLm-s0Ymob5zZOhOeY,6285
+tactus/stdlib/biblicus/text.py,sha256=aL7FF5MmX0aXskGwSTD970kGP4C0bAGHm0vJe7MThPU,6255
 tactus/stdlib/classify/__init__.py,sha256=51Lqge0g0Q6GWXkmw42HwuqkkDCsww9VBcoreYId374,5623
 tactus/stdlib/classify/classify.spec.tac,sha256=0yuRD_2dbPKTuhyqwk3vtsj_R3kwGoSEiEF4OY-ARqA,6475
 tactus/stdlib/classify/classify.tac,sha256=KvOXLihspPK1_g2GcT9wnLkynDubglp1S_JUfZlo-88,6850
@@ -210,7 +212,7 @@ tactus/validation/LuaParserBase.py,sha256=o3klCIY0ANkVCU0VHml0IOYE4CdEledeoyoIAP
 tactus/validation/README.md,sha256=AS6vr4blY7IKWRsj4wuvWBHVMTc5fto7IgNmv-Rjkdo,5366
 tactus/validation/__init__.py,sha256=rnap-YvNievWigYYUewuXBcLtAdjZ8YpeJDYS1T7XZM,153
 tactus/validation/error_listener.py,sha256=MPkvsVbojwYjNA8MpapG_GNtR6ZDyb3cTt7aLwekCtM,1010
-tactus/validation/semantic_visitor.py,sha256=frs7zc66rQkAKtPwshMSXYxXyqyYxEV9TokOiRY5lxo,57135
+tactus/validation/semantic_visitor.py,sha256=YLX54qXpGNrJSANr15UfbGmxT017vGE10dBtBZTphIQ,55149
 tactus/validation/validator.py,sha256=JSQHmI3EkNjJsPxrztTszJGuNuHyyaDdRsV62I4P0QU,11911
 tactus/validation/generated/LuaLexer.interp,sha256=B-Xb6HNXS7YYYQB_cvsWzf8OQLFnEhZHDN5vCOyP3yw,20444
 tactus/validation/generated/LuaLexer.py,sha256=6B-HNB_vAp3bA5iACLvMWw0R4KFENsuiG7bccysxbRQ,67252
@@ -224,8 +226,8 @@ tactus/validation/generated/LuaParserVisitor.py,sha256=ageKSmHPxnO3jBS2fBtkmYBOd
 tactus/validation/generated/__init__.py,sha256=5gWlwRI0UvmHw2fnBpj_IG6N8oZeabr5tbj1AODDvjc,196
 tactus/validation/grammar/LuaLexer.g4,sha256=t2MXiTCr127RWAyQGvamkcU_m4veqPzSuHUtAKwalw4,2771
 tactus/validation/grammar/LuaParser.g4,sha256=ceZenb90BdiZmVdOxMGj9qJk3QbbWVZe5HUqPgoePfY,3202
-tactus-0.38.0.dist-info/METADATA,sha256=aWNJ9IXllKc79gX9ed4X-MSGqjGSiEtGT8xTdYHQzjA,60383
-tactus-0.38.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-tactus-0.38.0.dist-info/entry_points.txt,sha256=vWseqty8m3z-Worje0IYxlioMjPDCoSsm0AtY4GghBY,47
-tactus-0.38.0.dist-info/licenses/LICENSE,sha256=ivohBcAIYnaLPQ-lKEeCXSMvQUVISpQfKyxHBHoa4GA,1066
-tactus-0.38.0.dist-info/RECORD,,
+tactus-0.39.0.dist-info/METADATA,sha256=5Axn0cmSvHUPhqcpvlbMouG27Gu2YkmxHfINh3ucnig,60383
+tactus-0.39.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+tactus-0.39.0.dist-info/entry_points.txt,sha256=vWseqty8m3z-Worje0IYxlioMjPDCoSsm0AtY4GghBY,47
+tactus-0.39.0.dist-info/licenses/LICENSE,sha256=ivohBcAIYnaLPQ-lKEeCXSMvQUVISpQfKyxHBHoa4GA,1066
+tactus-0.39.0.dist-info/RECORD,,