tactus 0.37.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.37.0"
+__version__ = "0.39.0"
 
 # Core exports
 from tactus.core.runtime import TactusRuntime

tactus/adapters/channels/base.py

@@ -198,4 +198,6 @@ class InProcessChannel(ABC):
         """
         if self._response_queue is None:
             loop.call_soon_threadsafe(self._ensure_asyncio_primitives)
+            loop.call_soon_threadsafe(lambda: self._response_queue.put_nowait(response))
+            return
         loop.call_soon_threadsafe(self._response_queue.put_nowait, response)

tactus/cli/app.py

@@ -5,6 +5,9 @@ Main entry point for the Tactus command-line interface.
 Provides commands for running, validating, and testing workflows.
 """
 
+# Future annotations prevent runtime evaluation of PEP 604 unions on Python 3.9.
+from __future__ import annotations
+
 # Disable Pydantic plugins for PyInstaller builds
 # This prevents logfire (and other plugins) from being loaded via Pydantic's plugin system
 # which causes errors when trying to inspect source code in frozen apps
@@ -61,6 +64,13 @@ def main_callback(
 
     # If no subcommand was invoked and version flag not set, show help
     if ctx.invoked_subcommand is None:
+        if getattr(ctx, "args", None) and ctx.args[0].endswith((".tac", ".lua")):
+            workflow_file = Path(ctx.args[0])
+            task_name = None
+            if len(ctx.args) >= 2 and not ctx.args[1].startswith("-"):
+                task_name = ctx.args[1]
+            ctx.invoke(run, workflow_file=workflow_file, task=task_name)
+            raise typer.Exit()
         console.print(ctx.get_help())
         raise typer.Exit()
 
@@ -179,10 +189,11 @@ def setup_logging(
     verbose: bool = False,
     log_level: Optional[str] = None,
     log_format: str = "rich",
+    debug: bool = False,
 ) -> None:
     """Setup CLI logging (level + format)."""
     if log_level is None:
-        level = logging.DEBUG if verbose else logging.INFO
+        level = logging.DEBUG if (verbose or debug) else logging.INFO
     else:
         key = str(log_level).strip().lower()
         if key not in _LOG_LEVELS:
@@ -198,6 +209,10 @@ def setup_logging(
             f"Invalid --log-format '{log_format}'. Use one of: {', '.join(sorted(_LOG_FORMATS))}"
         )
 
+    if debug:
+        os.environ["TACTUS_TRACE_LLM_MESSAGES"] = "1"
+        os.environ["TACTUS_TRACE_CONTEXT"] = "1"
+
     # Default: rich logs (group repeated timestamps).
     if fmt == "rich":
         handler: logging.Handler = RichHandler(
@@ -422,15 +437,54 @@ def _check_missing_required_inputs(input_schema: dict, provided_params: dict) ->
     return missing
 
 
+def _print_available_tasks(
+    console: Console,
+    *,
+    workflow_filename: str,
+    tasks: list[str],
+    show_example_when_empty: bool,
+) -> None:
+    console.print("\n[cyan]Available tasks:[/cyan]")
+    for task_name in tasks:
+        console.print(f"  [bold]{task_name}[/bold]")
+
+    if tasks:
+        example_task = tasks[0]
+    elif show_example_when_empty:
+        example_task = "run"
+    else:
+        return
+
+    console.print(
+        "\n[dim]Run a task explicitly, e.g.:[/dim] "
+        f"[bold]tactus {workflow_filename} {example_task}[/bold]"
+    )
+
+
+def _print_waiting_for_human(console: Console, *, pending_message_id: str | None) -> None:
+    console.print("\n[yellow]Procedure paused - waiting for human response[/yellow]")
+    if pending_message_id:
+        console.print(f"[dim]Message ID: {pending_message_id}[/dim]")
+
+    console.print("\n[cyan]The procedure has been paused and is waiting for input.[/cyan]")
+    console.print(
+        "[cyan]To resume, run the procedure again or provide a response via another channel.[/cyan]\n"
+    )
+
+
 @app.command()
 def run(
     workflow_file: Path = typer.Argument(..., help="Path to workflow file (.tac)"),
+    task: Optional[str] = typer.Argument(
+        None, help="Optional task name (e.g., run, index, fetch:NOAA)"
+    ),
     storage: str = typer.Option("memory", help="Storage backend: memory, file"),
     storage_path: Optional[Path] = typer.Option(None, help="Path for file storage"),
     openai_api_key: Optional[str] = typer.Option(
         None, envvar="OPENAI_API_KEY", help="OpenAI API key"
     ),
     verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose logging"),
+    debug: bool = typer.Option(False, "--debug", help="Enable debug logging + context tracing"),
     log_level: Optional[str] = typer.Option(
         None, "--log-level", help="Log level: debug, info, warning, error, critical"
     ),
@@ -499,7 +553,15 @@ def run(
         # Use real implementation for specific tools while mocking others
         tactus run workflow.tac --mock-all --real done
     """
-    setup_logging(verbose=verbose, log_level=log_level, log_format=log_format)
+    setup_logging(verbose=verbose, log_level=log_level, log_format=log_format, debug=debug)
+    import warnings
+
+    warnings.filterwarnings(
+        "ignore",
+        message="Pydantic serializer warnings:",
+        category=UserWarning,
+        module="pydantic.main",
+    )
 
     # Check if file exists
     if not workflow_file.exists():
@@ -637,6 +699,17 @@ def run(
     if sandbox_broker_host is not None:
         sandbox_config_dict["broker_host"] = sandbox_broker_host
 
+    if "dev_mode" not in sandbox_config_dict:
+        try:
+            import tactus
+
+            tactus_module_path = Path(tactus.__file__).resolve()
+            repo_root = tactus_module_path.parent.parent
+            if (repo_root / "tactus").is_dir() and (repo_root / "pyproject.toml").exists():
+                sandbox_config_dict["dev_mode"] = True
+        except Exception:
+            pass
+
     sandbox_config_dict["broker_transport"] = sandbox_broker
     if (
         sandbox_network is None
@@ -649,9 +722,12 @@ def run(
 
     # Pass logging preferences through to the sandbox container so container stderr matches CLI UX.
     sandbox_config.env.setdefault(
-        "TACTUS_LOG_LEVEL", str(log_level or ("debug" if verbose else "info"))
+        "TACTUS_LOG_LEVEL", str(log_level or ("debug" if (verbose or debug) else "info"))
     )
     sandbox_config.env.setdefault("TACTUS_LOG_FORMAT", str(log_format))
+    if debug:
+        sandbox_config.env.setdefault("TACTUS_TRACE_LLM_MESSAGES", "1")
+        sandbox_config.env.setdefault("TACTUS_TRACE_CONTEXT", "1")
 
     # Check Docker availability
     docker_available, docker_reason = is_docker_available()
@@ -733,14 +809,15 @@ def run(
         source_file_path=str(workflow_file),
     )
 
-    # Set up mocking based on CLI flags
-    if mock_all or real_all or mock or real:
-        from tactus.core.mocking import MockManager
+    # Always create a mock manager so Mocks {} blocks can register tool mocks.
+    from tactus.core.mocking import MockManager, set_current_mock_manager
 
-        # Create and configure mock manager
-        mock_manager = MockManager()
-        runtime.mock_manager = mock_manager
+    mock_manager = MockManager()
+    runtime.mock_manager = mock_manager
+    set_current_mock_manager(mock_manager)
 
+    # Set up mocking based on CLI flags
+    if mock_all or real_all or mock or real:
         # Handle global flags
         if mock_all:
             mock_manager.enable_mock()
@@ -801,6 +878,7 @@ def run(
                     params=context,
                     source_file_path=str(workflow_file),
                     format=file_format,
+                    task_name=task,
                 )
             )
 
@@ -814,6 +892,25 @@ def run(
                     "tools_used": sandbox_result.metadata.get("tools_used", []),
                 }
             else:
+                # Special-case: sandbox task selection (avoid a scary error dump).
+                if sandbox_result.error_type == "TaskSelectionRequired":
+                    tasks = sandbox_result.metadata.get("tasks", [])
+                    _print_available_tasks(
+                        console,
+                        workflow_filename=workflow_file.name,
+                        tasks=tasks,
+                        show_example_when_empty=False,
+                    )
+                    return
+
+                # Special-case: sandbox waiting for human (treat as a pause, not a failure).
+                if sandbox_result.metadata.get("waiting_for_human"):
+                    _print_waiting_for_human(
+                        console,
+                        pending_message_id=sandbox_result.metadata.get("pending_message_id"),
+                    )
+                    return
+
                 result = {
                     "success": False,
                     "error": sandbox_result.error,
@@ -823,42 +920,29 @@ def run(
         else:
             # Execute directly (non-sandboxed)
             try:
-                result = asyncio.run(runtime.execute(source_content, context, format=file_format))
-            except Exception as e:
-                from tactus.core.exceptions import ProcedureWaitingForHuman
-
-                # Check both the exception itself and its __cause__
-                console.print(f"[dim]DEBUG: Caught exception type: {type(e).__name__}[/dim]")
-                console.print(
-                    f"[dim]DEBUG: Exception __cause__ type: {type(e.__cause__).__name__ if e.__cause__ else 'None'}[/dim]"
-                )
-                console.print(
-                    f"[dim]DEBUG: Is ProcedureWaitingForHuman: {isinstance(e, ProcedureWaitingForHuman)}[/dim]"
-                )
-                console.print(
-                    f"[dim]DEBUG: __cause__ is ProcedureWaitingForHuman: {isinstance(e.__cause__, ProcedureWaitingForHuman) if e.__cause__ else False}[/dim]"
+                result = asyncio.run(
+                    runtime.execute(source_content, context, format=file_format, task_name=task)
                 )
-
+            except Exception as e:
+                from tactus.core.exceptions import ProcedureWaitingForHuman, TaskSelectionRequired
+
+                task_error = e.__cause__ if isinstance(e.__cause__, TaskSelectionRequired) else e
+                if isinstance(task_error, TaskSelectionRequired):
+                    _print_available_tasks(
+                        console,
+                        workflow_filename=workflow_file.name,
+                        tasks=task_error.tasks,
+                        show_example_when_empty=True,
+                    )
+                    return
                 if isinstance(e, ProcedureWaitingForHuman):
                     # Direct exception
-                    console.print(
-                        "\n[yellow]⏸ Procedure paused - waiting for human response[/yellow]"
-                    )
-                    console.print(f"[dim]Message ID: {e.pending_message_id}[/dim]")
-                    console.print("\n[cyan]The procedure has been paused and is waiting for input.")
-                    console.print(
-                        "To resume, run the procedure again or provide a response via another channel.[/cyan]\n"
-                    )
+                    _print_waiting_for_human(console, pending_message_id=e.pending_message_id)
                     return
                 elif e.__cause__ and isinstance(e.__cause__, ProcedureWaitingForHuman):
                     # Wrapped exception
-                    console.print(
-                        "\n[yellow]⏸ Procedure paused - waiting for human response[/yellow]"
-                    )
-                    console.print(f"[dim]Message ID: {e.__cause__.pending_message_id}[/dim]")
-                    console.print("\n[cyan]The procedure has been paused and is waiting for input.")
-                    console.print(
-                        "To resume, run the procedure again or provide a response via another channel.[/cyan]\n"
+                    _print_waiting_for_human(
+                        console, pending_message_id=e.__cause__.pending_message_id
                     )
                     return
                 else:
@@ -910,6 +994,24 @@ def run(
         if verbose:
             console.print_exception()
         raise typer.Exit(1)
+    finally:
+        try:
+            import litellm
+
+            close_clients = getattr(litellm, "close_litellm_async_clients", None)
+            if close_clients:
+                close_result = close_clients()
+                if asyncio.iscoroutine(close_result):
+                    asyncio.run(close_result)
+        except Exception:
+            pass
+        try:
+            asyncio.run(control_handler.shutdown_channels())
+        except RuntimeError:
+            # Best-effort cleanup if an event loop is already running.
+            pass
+        except Exception:
+            pass
 
 
 # Sandbox subcommand group
@@ -1264,16 +1366,13 @@ def info(
     # Determine format based on extension
     file_format = "lua" if workflow_file.suffix in [".tac", ".lua"] else "yaml"
 
-    # Read workflow file
-    source_content = workflow_file.read_text()
-
     console.print(f"[blue]Procedure info:[/blue] [bold]{workflow_file.name}[/bold]\n")
 
     try:
         if file_format == "lua":
             # Use validator to parse procedure
             validator = TactusValidator()
-            result = validator.validate(source_content, ValidationMode.FULL)
+            result = validator.validate_file(str(workflow_file), ValidationMode.FULL)
 
             if not result.valid:
                 console.print("[red]✗ Invalid procedure - cannot display info[/red]\n")
@@ -1327,6 +1426,48 @@ def info(
                         console.print(f"  [bold]{name}[/bold]: {type(field_config).__name__}")
                 console.print()
 
+            # Show tasks (including nested tasks + implicit retriever tasks)
+            implicit_task_targets: dict[str, list[str]] = {}
+            if registry.retrievers:
+                from tactus.core.retriever_tasks import (
+                    resolve_retriever_id,
+                    supported_retriever_tasks,
+                )
+
+                for retriever_name, retriever in registry.retrievers.items():
+                    config = getattr(retriever, "config", {})
+                    retriever_id = resolve_retriever_id(config if isinstance(config, dict) else {})
+                    for task_name in sorted(supported_retriever_tasks(retriever_id)):
+                        implicit_task_targets.setdefault(task_name, []).append(retriever_name)
+
+            if registry.tasks or implicit_task_targets:
+                console.print("[cyan]Tasks:[/cyan]")
+
+                def _emit_tasks(task_map: dict, prefix: str = "") -> None:
+                    for task_name, task in task_map.items():
+                        full_name = (
+                            f"{prefix}{task_name}" if not prefix else f"{prefix}:{task_name}"
+                        )
+                        console.print(f"  [bold]{full_name}[/bold]")
+                        if task.children:
+                            _emit_tasks(task.children, full_name)
+
+                if registry.tasks:
+                    _emit_tasks(registry.tasks)
+
+                for task_name, retriever_names in implicit_task_targets.items():
+                    if task_name in registry.tasks:
+                        continue
+                    console.print(
+                        f"  [bold]{task_name}[/bold] [dim](implicit from retrievers)[/dim]"
+                    )
+                    for retriever_name in retriever_names:
+                        console.print(
+                            f"  [bold]{task_name}:{retriever_name}[/bold] [dim](implicit)[/dim]"
+                        )
+
+                console.print()
+
             # Show agents
             if registry.agents:
                 console.print("[cyan]Agents:[/cyan]")
@@ -1380,6 +1521,7 @@ def test(
     mock_config: Optional[Path] = typer.Option(None, help="Path to mock config JSON"),
     param: Optional[list[str]] = typer.Option(None, help="Parameters in format key=value"),
     verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose logging"),
+    debug: bool = typer.Option(False, "--debug", help="Enable debug logging + context tracing"),
 ):
     """
     Run BDD specifications for a procedure.
@@ -1400,7 +1542,7 @@ def test(
         # Run specific scenario
         tactus test procedure.tac --scenario "Agent completes research"
     """
-    setup_logging(verbose)
+    setup_logging(verbose=verbose, debug=debug)
 
     if not procedure_file.exists():
         console.print(f"[red]Error:[/red] File not found: {procedure_file}")
@@ -1489,7 +1631,10 @@ def test(
         if runs > 1:
             # Run consistency evaluation
             evaluator = TactusEvaluationRunner(
-                procedure_file, mock_tools=mock_tools, params=test_params
+                procedure_file,
+                mock_tools=mock_tools,
+                params=test_params,
+                mocked=bool(mock or mock_config),
             )
             evaluator.setup(
                 result.registry.gherkin_specifications,
@@ -1506,7 +1651,12 @@ def test(
 
         else:
             # Run standard test
-            runner = TactusTestRunner(procedure_file, mock_tools=mock_tools, params=test_params)
+            runner = TactusTestRunner(
+                procedure_file,
+                mock_tools=mock_tools,
+                params=test_params,
+                mocked=bool(mock or mock_config),
+            )
             runner.setup(
                 result.registry.gherkin_specifications,
                 custom_steps_dict=result.registry.custom_steps,
@@ -1540,13 +1690,13 @@ def _display_test_results(test_result):
             # Include execution metrics in scenario display
             metrics_parts = []
             if scenario.total_cost > 0:
-                metrics_parts.append(f"💰 ${scenario.total_cost:.6f}")
+                metrics_parts.append(f"$ {scenario.total_cost:.6f}")
             if scenario.llm_calls > 0:
-                metrics_parts.append(f"🤖 {scenario.llm_calls} LLM calls")
+                metrics_parts.append(f"{scenario.llm_calls} LLM calls")
             if scenario.iterations > 0:
-                metrics_parts.append(f"🔄 {scenario.iterations} iterations")
+                metrics_parts.append(f"{scenario.iterations} iterations")
             if scenario.tools_used:
-                metrics_parts.append(f"🔧 {len(scenario.tools_used)} tools")
+                metrics_parts.append(f"{len(scenario.tools_used)} tools")
 
             metrics_str = f" ({', '.join(metrics_parts)})" if metrics_parts else ""
             console.print(
@@ -1573,14 +1723,14 @@ def _display_test_results(test_result):
         console.print("\n[bold]Execution Metrics:[/bold]")
         if test_result.total_cost > 0:
             console.print(
-                f"  💰 Cost: ${test_result.total_cost:.6f} ({test_result.total_tokens:,} tokens)"
+                f"  $ Cost: ${test_result.total_cost:.6f} ({test_result.total_tokens:,} tokens)"
             )
         if test_result.total_llm_calls > 0:
-            console.print(f"  🤖 LLM Calls: {test_result.total_llm_calls}")
+            console.print(f"  LLM Calls: {test_result.total_llm_calls}")
         if test_result.total_iterations > 0:
-            console.print(f"  🔄 Iterations: {test_result.total_iterations}")
+            console.print(f"  Iterations: {test_result.total_iterations}")
         if test_result.unique_tools_used:
-            console.print(f"  🔧 Tools: {', '.join(test_result.unique_tools_used)}")
+            console.print(f"  Tools: {', '.join(test_result.unique_tools_used)}")
 
 
 def _display_evaluation_results(eval_results):
@@ -1609,7 +1759,7 @@ def _display_evaluation_results(eval_results):
 
         # Flakiness warning
         if eval_result.is_flaky:
-            console.print("  [yellow]⚠️  FLAKY - Inconsistent results detected[/yellow]")
+            console.print("  [yellow]! FLAKY - Inconsistent results detected[/yellow]")
 
 
 def _display_eval_results(report, runs: int, console):
@@ -1722,6 +1872,7 @@ def eval(
     runs: int = typer.Option(1, help="Number of runs per case"),
     parallel: bool = typer.Option(True, help="Run cases in parallel"),
     verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose logging"),
+    debug: bool = typer.Option(False, "--debug", help="Enable debug logging + context tracing"),
 ):
     """
     Run Pydantic Evals evaluation on procedure.
@@ -1741,7 +1892,7 @@ def eval(
         # Run sequentially (for debugging)
         tactus eval procedure.tac --no-parallel
     """
-    setup_logging(verbose)
+    setup_logging(verbose=verbose, debug=debug)
     load_tactus_config()
 
     if not procedure_file.exists():
@@ -2309,10 +2460,14 @@ def stdlib_test(
         tactus stdlib test classify     # Run only classify tests
         tactus stdlib test extract      # Run only extract tests
     """
+    import os
     import tactus
     from tactus.validation import TactusValidator
     from tactus.testing.test_runner import TactusTestRunner
 
+    # Force deterministic mocks for stdlib tests (CI-safe, offline).
+    os.environ["TACTUS_MOCK_MODE"] = "1"
+
     # Find stdlib spec files
     package_root = Path(tactus.__file__).parent
     stdlib_tac_path = package_root / "stdlib" / "tac" / "tactus"
@@ -2362,7 +2517,7 @@ def stdlib_test(
 
         # Run tests
         try:
-            runner = TactusTestRunner(spec_file, mock_tools={}, params={})
+            runner = TactusTestRunner(spec_file, mock_tools={}, params={}, mocked=True)
             runner.setup(
                 result.registry.gherkin_specifications,
                 custom_steps_dict=result.registry.custom_steps,

tactus/core/compaction.py

@@ -0,0 +1,17 @@
+"""Re-export Biblicus Context Engine compaction utilities for Tactus."""
+
+from biblicus.context_engine import (
+    BaseCompactor,
+    CompactionRequest,
+    SummaryCompactor,
+    TruncateCompactor,
+)
+from biblicus.context_engine.compaction import build_compactor
+
+__all__ = [
+    "BaseCompactor",
+    "CompactionRequest",
+    "SummaryCompactor",
+    "TruncateCompactor",
+    "build_compactor",
+]

tactus/core/context_assembler.py

@@ -0,0 +1,73 @@
+"""Tactus wrapper for the Biblicus Context Engine assembler."""
+
+from __future__ import annotations
+
+from biblicus.context_engine import ContextAssembler as BiblicusContextAssembler
+from biblicus.context_engine import ContextAssemblyResult
+from typing import Any, Optional
+import logging
+import os
+
+
+logger = logging.getLogger(__name__)
+
+
+class ContextAssembler(BiblicusContextAssembler):
+    """
+    Context assembler that defaults to Tactus test retrievers.
+
+    :param default_retriever: Optional default retriever override.
+    :type default_retriever: callable or None
+    """
+
+    def __init__(
+        self,
+        context_registry,
+        retriever_registry: Optional[dict[str, Any]] = None,
+        corpus_registry: Optional[dict[str, Any]] = None,
+        compactor_registry: Optional[dict[str, Any]] = None,
+        default_retriever: Optional[Any] = None,
+    ):
+        from tactus.core import retrieval as retrieval_module
+
+        retriever_router = retrieval_module.make_retriever_router(
+            corpus_registry, retriever_registry
+        )
+        super().__init__(
+            context_registry,
+            retriever_registry=retriever_registry,
+            corpus_registry=corpus_registry,
+            compactor_registry=compactor_registry,
+            default_retriever=default_retriever or retriever_router,
+        )
+
+    def assemble(
+        self,
+        context_name: str,
+        base_system_prompt: str,
+        history_messages: list[dict[str, Any]],
+        user_message: Optional[str],
+        template_context: dict[str, Any],
+        retriever_override: Optional[Any] = None,
+    ):
+        result = super().assemble(
+            context_name=context_name,
+            base_system_prompt=base_system_prompt,
+            history_messages=history_messages,
+            user_message=user_message,
+            template_context=template_context,
+            retriever_override=retriever_override,
+        )
+        if os.environ.get("TACTUS_TRACE_CONTEXT") == "1":
+            logger.debug(
+                "[CONTEXT] name=%s system_chars=%s history_items=%s user_chars=%s token_est=%s",
+                context_name,
+                len(result.system_prompt),
+                len(result.history),
+                len(result.user_message),
+                result.token_count,
+            )
+        return result
+
+
+__all__ = ["ContextAssembler", "ContextAssemblyResult"]

tactus/core/context_models.py

@@ -0,0 +1,41 @@
+"""Re-export Biblicus Context Engine models for Tactus."""
+
+from biblicus.context_engine import (
+    AssistantMessageSpec,
+    CompactorDeclaration,
+    ContextBudgetSpec,
+    ContextDeclaration,
+    ContextExpansionSpec,
+    ContextInsertSpec,
+    ContextMessageSpec,
+    ContextPackBudgetSpec,
+    ContextPackSpec,
+    ContextPolicySpec,
+    ContextRetrieverRequest,
+    ContextTemplateSpec,
+    CorpusDeclaration,
+    HistoryInsertSpec,
+    RetrieverDeclaration,
+    SystemMessageSpec,
+    UserMessageSpec,
+)
+
+__all__ = [
+    "AssistantMessageSpec",
+    "CompactorDeclaration",
+    "ContextBudgetSpec",
+    "ContextDeclaration",
+    "ContextExpansionSpec",
+    "ContextInsertSpec",
+    "ContextMessageSpec",
+    "ContextPackBudgetSpec",
+    "ContextPackSpec",
+    "ContextPolicySpec",
+    "ContextRetrieverRequest",
+    "ContextTemplateSpec",
+    "CorpusDeclaration",
+    "HistoryInsertSpec",
+    "RetrieverDeclaration",
+    "SystemMessageSpec",
+    "UserMessageSpec",
+]