hamtaa-texttools 1.1.16__py3-none-any.whl → 1.2.0__py3-none-any.whl

texttools/tools/async_tools.py

@@ -1,24 +1,28 @@
-from datetime import datetime
-from typing import Literal, Any
+import sys
 from collections.abc import Callable
+from time import perf_counter
+from typing import Any, Literal
 
 from openai import AsyncOpenAI
 
-from texttools.tools.internals.async_operator import AsyncOperator
-import texttools.tools.internals.models as Models
+from ..core.engine import text_to_chunks
+from ..core.exceptions import LLMError, PromptError, TextToolsError, ValidationError
+from ..core.internal_models import (
+    Bool,
+    ListDictStrStr,
+    ListStr,
+    ReasonListStr,
+    Str,
+    create_dynamic_model,
+)
+from ..core.operators.async_operator import AsyncOperator
+from ..models import CategoryTree, ToolOutput, ToolOutputMetadata
 
 
 class AsyncTheTool:
     """
-    Async counterpart to TheTool.
-
-    Each method configures the async operator with a specific YAML prompt,
+    Each method configures the operator with a specific YAML prompt,
     output schema, and flags, then delegates execution to `operator.run()`.
-
-    Usage:
-        async_client = AsyncOpenAI(...)
-        tool = TheToolAsync(async_client, model="model-name")
-        result = await tool.categorize("text ...", with_analysis=True)
     """
 
     def __init__(
@@ -31,142 +35,135 @@ class AsyncTheTool:
     async def categorize(
         self,
         text: str,
-        categories: list[str] | Models.CategoryTree,
+        categories: list[str] | CategoryTree,
         with_analysis: bool = False,
         user_prompt: str | None = None,
         temperature: float | None = 0.0,
         logprobs: bool = False,
-        top_logprobs: int | None = None,
-        mode: Literal["category_list", "category_tree"] = "category_list",
+        top_logprobs: int = 3,
         validator: Callable[[Any], bool] | None = None,
         max_validation_retries: int | None = None,
-        priority: int | None = 0,
-    ) -> Models.ToolOutput:
+        priority: int | None = None,
+    ) -> ToolOutput:
         """
         Categorize a text into a category / category tree.
 
+        Important Note: category_tree mode is EXPERIMENTAL, you can use it but it isn't reliable.
+
         Arguments:
-            text: The input text to categorize
-            categories: The category / category_tree to give to LLM
+            text: The input text
+            categories: The category list / category tree
             with_analysis: Whether to include detailed reasoning analysis
-            user_prompt: Additional instructions for the categorization
-            temperature: Controls randomness (0.0 = deterministic, 1.0 = creative)
+            user_prompt: Additional instructions
+            temperature: Controls randomness (0.0 - 2.0)
             logprobs: Whether to return token probability information
             top_logprobs: Number of top token alternatives to return if logprobs enabled
             validator: Custom validation function to validate the output
             max_validation_retries: Maximum number of retry attempts if validation fails
-            priority: Task execution priority (if enabled by vLLM and model)
+            priority: Task execution priority (if enabled by vLLM and the model)
 
         Returns:
-            ToolOutput: Object containing:
-                - result (str): The assigned category
-                - logprobs (list | None): Probability data if logprobs enabled
-                - analysis (str | None): Detailed reasoning if with_analysis enabled
-                - errors (list(str) | None): Errors occured during tool call
+            ToolOutput
+
         """
-        start = datetime.now()
-
-        if mode == "category_tree":
-            # Initializations
-            output = Models.ToolOutput()
-            levels = categories.get_level_count()
-            parent_id = 0
-            final_output = []
-
-            for _ in range(levels):
-                # Get child nodes for current parent
-                parent_node = categories.find_node(parent_id)
-                children = categories.find_children(parent_node)
-
-                # Check if child nodes exist
-                if not children:
-                    output.errors.append(
-                        f"No categories found for parent_id {parent_id} in the tree"
-                    )
-                    end = datetime.now()
-                    output.execution_time = (end - start).total_seconds()
-                    return output
-
-                # Extract category names and descriptions
-                category_list = [
-                    f"Category Name: {node.name}, Description: {node.description}"
-                    for node in children
-                ]
-                category_names = [node.name for node in children]
-
-                # Run categorization for this level
-                level_output = await self._operator.run(
+        tool_name = sys._getframe().f_code.co_name
+        start = perf_counter()
+
+        try:
+            if isinstance(categories, list):
+                operator_output = await self._operator.run(
                     # User parameters
                     text=text,
-                    category_list=category_list,
+                    category_list=categories,
                     with_analysis=with_analysis,
                     user_prompt=user_prompt,
                     temperature=temperature,
                     logprobs=logprobs,
                     top_logprobs=top_logprobs,
-                    mode=mode,
                     validator=validator,
                     max_validation_retries=max_validation_retries,
+                    priority=priority,
                     # Internal parameters
-                    prompt_file="categorize.yaml",
-                    output_model=Models.create_dynamic_model(category_names),
+                    tool_name=tool_name,
+                    output_model=create_dynamic_model(categories),
+                    mode=None,
                     output_lang=None,
                 )
 
-                # Check for errors from operator
-                if level_output.errors:
-                    output.errors.extend(level_output.errors)
-                    end = datetime.now()
-                    output.execution_time = (end - start).total_seconds()
-                    return output
-
-                # Get the chosen category
-                chosen_category = level_output.result
-
-                # Find the corresponding node
-                parent_node = categories.find_node(chosen_category)
-                if parent_node is None:
-                    output.errors.append(
-                        f"Category '{chosen_category}' not found in tree after selection"
+                metadata = ToolOutputMetadata(
+                    tool_name=tool_name, execution_time=perf_counter() - start
+                )
+                tool_output = ToolOutput(
+                    result=operator_output.result,
+                    analysis=operator_output.analysis,
+                    logprobs=operator_output.logprobs,
+                    metadata=metadata,
+                )
+
+            else:
+                levels = categories.get_level_count()
+                parent_node = categories.get_node("root")
+                final_categories = []
+                analysis = ""
+                logprobs_list = []
+
+                for _ in range(levels):
+                    if not parent_node.children:
+                        break
+
+                    category_list = [
+                        f"Category Name: {name}, Description: {node.description}"
+                        for name, node in parent_node.children.items()
+                    ]
+                    category_names = list(parent_node.children.keys())
+
+                    level_operator_output = await self._operator.run(
+                        # User parameters
+                        text=text,
+                        category_list=category_list,
+                        with_analysis=with_analysis,
+                        user_prompt=user_prompt,
+                        temperature=temperature,
+                        logprobs=logprobs,
+                        top_logprobs=top_logprobs,
+                        validator=validator,
+                        max_validation_retries=max_validation_retries,
+                        priority=priority,
+                        # Internal parameters
+                        tool_name=tool_name,
+                        output_model=create_dynamic_model(category_names),
+                        mode=None,
+                        output_lang=None,
                     )
-                    end = datetime.now()
-                    output.execution_time = (end - start).total_seconds()
-                    return output
 
-                parent_id = parent_node.node_id
-                final_output.append(parent_node.name)
+                    chosen_category = level_operator_output.result
+                    parent_node = categories.get_node(chosen_category)
+                    if not parent_node:
+                        break
+                    final_categories.append(chosen_category)
 
-                # Copy analysis/logprobs/process from the last level's output
-                output.analysis = level_output.analysis
-                output.logprobs = level_output.logprobs
-                output.process = level_output.process
+                    if with_analysis:
+                        analysis += level_operator_output.analysis
+                    if logprobs:
+                        logprobs_list.extend(level_operator_output.logprobs)
 
-            output.result = final_output
-            end = datetime.now()
-            output.execution_time = (end - start).total_seconds()
-            return output
+                metadata = ToolOutputMetadata(
+                    tool_name=tool_name, execution_time=(perf_counter() - start)
+                )
+                tool_output = ToolOutput(
+                    result=final_categories,
+                    analysis=analysis,
+                    logprobs=logprobs_list,
+                    metadata=metadata,
+                )
 
-        else:
-            output = await self._operator.run(
-                # User parameters
-                text=text,
-                category_list=categories,
-                with_analysis=with_analysis,
-                user_prompt=user_prompt,
-                temperature=temperature,
-                logprobs=logprobs,
-                top_logprobs=top_logprobs,
-                mode=mode,
-                validator=validator,
-                max_validation_retries=max_validation_retries,
-                # Internal parameters
-                prompt_file="categorize.yaml",
-                output_model=Models.create_dynamic_model(categories),
-                output_lang=None,
+        except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            metadata = ToolOutputMetadata(tool_name=tool_name)
+            tool_output = ToolOutput(
+                errors=[f"{type(e).__name__}: {e}"], metadata=metadata
             )
-            end = datetime.now()
-            output.execution_time = (end - start).total_seconds()
-            return output
+
+        return tool_output
 
     async def extract_keywords(
         self,
@@ -176,114 +173,146 @@ class AsyncTheTool:
         user_prompt: str | None = None,
         temperature: float | None = 0.0,
         logprobs: bool = False,
-        top_logprobs: int | None = None,
+        top_logprobs: int = 3,
         mode: Literal["auto", "threshold", "count"] = "auto",
         number_of_keywords: int | None = None,
         validator: Callable[[Any], bool] | None = None,
         max_validation_retries: int | None = None,
-        priority: int | None = 0,
-    ) -> Models.ToolOutput:
+        priority: int | None = None,
+    ) -> ToolOutput:
         """
         Extract salient keywords from text.
 
         Arguments:
-            text: The input text to extract keywords from
+            text: The input text
             with_analysis: Whether to include detailed reasoning analysis
-            output_lang: Language for the output response
-            user_prompt: Additional instructions for keyword extraction
-            temperature: Controls randomness (0.0 = deterministic, 1.0 = creative)
+            output_lang: Language for the output
+            user_prompt: Additional instructions
+            temperature: Controls randomness (0.0 - 2.0)
             logprobs: Whether to return token probability information
             top_logprobs: Number of top token alternatives to return if logprobs enabled
             validator: Custom validation function to validate the output
             max_validation_retries: Maximum number of retry attempts if validation fails
-            priority: Task execution priority (if enabled by vLLM and model)
+            priority: Task execution priority (if enabled by vLLM and the model)
 
         Returns:
-            ToolOutput: Object containing:
-                - result (list[str]): List of extracted keywords
-                - logprobs (list | None): Probability data if logprobs enabled
-                - analysis (str | None): Detailed reasoning if with_analysis enabled
-                - errors (list(str) | None): Errors occured during tool call
+            ToolOutput
         """
-        start = datetime.now()
-        output = await self._operator.run(
-            # User parameters
-            text=text,
-            with_analysis=with_analysis,
-            output_lang=output_lang,
-            user_prompt=user_prompt,
-            temperature=temperature,
-            logprobs=logprobs,
-            top_logprobs=top_logprobs,
-            mode=mode,
-            number_of_keywords=number_of_keywords,
-            validator=validator,
-            max_validation_retries=max_validation_retries,
-            priority=priority,
-            # Internal parameters
-            prompt_file="extract_keywords.yaml",
-            output_model=Models.ListStrOutput,
-        )
-        end = datetime.now()
-        output.execution_time = (end - start).total_seconds()
-        return output
+        tool_name = sys._getframe().f_code.co_name
+        start = perf_counter()
+
+        try:
+            operator_output = await self._operator.run(
+                # User parameters
+                text=text,
+                with_analysis=with_analysis,
+                output_lang=output_lang,
+                user_prompt=user_prompt,
+                temperature=temperature,
+                logprobs=logprobs,
+                top_logprobs=top_logprobs,
+                mode=mode,
+                number_of_keywords=number_of_keywords,
+                validator=validator,
+                max_validation_retries=max_validation_retries,
+                priority=priority,
+                # Internal parameters
+                tool_name=tool_name,
+                output_model=ListStr,
+            )
+
+            metadata = ToolOutputMetadata(
+                tool_name=tool_name, execution_time=perf_counter() - start
+            )
+            tool_output = ToolOutput(
+                result=operator_output.result,
+                logprobs=operator_output.logprobs,
+                analysis=operator_output.analysis,
+                metadata=metadata,
+            )
+
+        except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            metadata = ToolOutputMetadata(tool_name=tool_name)
+            tool_output = ToolOutput(
+                errors=[f"{type(e).__name__}: {e}"], metadata=metadata
+            )
+
+        return tool_output
 
     async def extract_entities(
         self,
         text: str,
+        entities: list[str] | None = None,
         with_analysis: bool = False,
         output_lang: str | None = None,
         user_prompt: str | None = None,
         temperature: float | None = 0.0,
         logprobs: bool = False,
-        top_logprobs: int | None = None,
+        top_logprobs: int = 3,
         validator: Callable[[Any], bool] | None = None,
         max_validation_retries: int | None = None,
-        priority: int | None = 0,
-    ) -> Models.ToolOutput:
+        priority: int | None = None,
+    ) -> ToolOutput:
         """
         Perform Named Entity Recognition (NER) over the input text.
 
         Arguments:
-            text: The input text to extract entities from
+            text: The input text
+            entities: List of entities provided by user (Optional)
             with_analysis: Whether to include detailed reasoning analysis
-            output_lang: Language for the output response
-            user_prompt: Additional instructions for entity extraction
-            temperature: Controls randomness (0.0 = deterministic, 1.0 = creative)
+            output_lang: Language for the output
+            user_prompt: Additional instructions
+            temperature: Controls randomness (0.0 - 2.0)
             logprobs: Whether to return token probability information
             top_logprobs: Number of top token alternatives to return if logprobs enabled
             validator: Custom validation function to validate the output
             max_validation_retries: Maximum number of retry attempts if validation fails
-            priority: Task execution priority (if enabled by vLLM and model)
+            priority: Task execution priority (if enabled by vLLM and the model)
 
         Returns:
-            ToolOutput: Object containing:
-                - result (list[dict]): List of entities with 'text' and 'type' keys
-                - logprobs (list | None): Probability data if logprobs enabled
-                - analysis (str | None): Detailed reasoning if with_analysis enabled
-                - errors (list(str) | None): Errors occured during tool call
+            ToolOutput
         """
-        start = datetime.now()
-        output = await self._operator.run(
-            # User parameters
-            text=text,
-            with_analysis=with_analysis,
-            output_lang=output_lang,
-            user_prompt=user_prompt,
-            temperature=temperature,
-            logprobs=logprobs,
-            top_logprobs=top_logprobs,
-            validator=validator,
-            max_validation_retries=max_validation_retries,
-            priority=priority,
-            # Internal parameters
-            prompt_file="extract_entities.yaml",
-            output_model=Models.ListDictStrStrOutput,
-            mode=None,
-        )
-        end = datetime.now()
-        output.execution_time = (end - start).total_seconds()
-        return output
+        tool_name = sys._getframe().f_code.co_name
+        start = perf_counter()
+
+        try:
+            operator_output = await self._operator.run(
+                # User parameters
+                text=text,
+                entities=entities
+                or "all named entities (e.g., PER, ORG, LOC, DAT, etc.)",
+                with_analysis=with_analysis,
+                output_lang=output_lang,
+                user_prompt=user_prompt,
+                temperature=temperature,
+                logprobs=logprobs,
+                top_logprobs=top_logprobs,
+                validator=validator,
+                max_validation_retries=max_validation_retries,
+                priority=priority,
+                # Internal parameters
+                tool_name=tool_name,
+                output_model=ListDictStrStr,
+                mode=None,
+            )
+
+            metadata = ToolOutputMetadata(
+                tool_name=tool_name, execution_time=perf_counter() - start
+            )
+            tool_output = ToolOutput(
+                result=operator_output.result,
+                logprobs=operator_output.logprobs,
+                analysis=operator_output.analysis,
+                metadata=metadata,
+            )
+
+        except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            metadata = ToolOutputMetadata(tool_name=tool_name)
+            tool_output = ToolOutput(
+                errors=[f"{type(e).__name__}: {e}"], metadata=metadata
+            )
+
+        return tool_output
 
     async def is_question(
         self,
@@ -292,110 +321,142 @@ class AsyncTheTool:
         user_prompt: str | None = None,
         temperature: float | None = 0.0,
         logprobs: bool = False,
-        top_logprobs: int | None = None,
+        top_logprobs: int = 3,
         validator: Callable[[Any], bool] | None = None,
         max_validation_retries: int | None = None,
-        priority: int | None = 0,
-    ) -> Models.ToolOutput:
+        priority: int | None = None,
+    ) -> ToolOutput:
         """
         Detect if the input is phrased as a question.
 
         Arguments:
-            text: The input text to analyze
+            text: The input text
             with_analysis: Whether to include detailed reasoning analysis
-            user_prompt: Additional instructions for question detection
-            temperature: Controls randomness (0.0 = deterministic, 1.0 = creative)
+            user_prompt: Additional instructions
+            temperature: Controls randomness (0.0 - 2.0)
             logprobs: Whether to return token probability information
             top_logprobs: Number of top token alternatives to return if logprobs enabled
             validator: Custom validation function to validate the output
             max_validation_retries: Maximum number of retry attempts if validation fails
-            priority: Task execution priority (if enabled by vLLM and model)
+            priority: Task execution priority (if enabled by vLLM and the model)
 
         Returns:
-            ToolOutput: Object containing:
-                - result (bool): True if text is a question, False otherwise
-                - logprobs (list | None): Probability data if logprobs enabled
-                - analysis (str | None): Detailed reasoning if with_analysis enabled
-                - errors (list(str) | None): Errors occured during tool call
+            ToolOutput
         """
-        start = datetime.now()
-        output = await self._operator.run(
-            # User parameters
-            text=text,
-            with_analysis=with_analysis,
-            user_prompt=user_prompt,
-            temperature=temperature,
-            logprobs=logprobs,
-            top_logprobs=top_logprobs,
-            validator=validator,
-            max_validation_retries=max_validation_retries,
-            priority=priority,
-            # Internal parameters
-            prompt_file="is_question.yaml",
-            output_model=Models.BoolOutput,
-            mode=None,
-            output_lang=None,
-        )
-        end = datetime.now()
-        output.execution_time = (end - start).total_seconds()
-        return output
+        tool_name = sys._getframe().f_code.co_name
+
+        start = perf_counter()
+
+        try:
+            operator_output = await self._operator.run(
+                # User parameters
+                text=text,
+                with_analysis=with_analysis,
+                user_prompt=user_prompt,
+                temperature=temperature,
+                logprobs=logprobs,
+                top_logprobs=top_logprobs,
+                validator=validator,
+                max_validation_retries=max_validation_retries,
+                priority=priority,
+                # Internal parameters
+                tool_name=tool_name,
+                output_model=Bool,
+                mode=None,
+                output_lang=None,
+            )
+
+            metadata = ToolOutputMetadata(
+                tool_name=tool_name, execution_time=perf_counter() - start
+            )
+            tool_output = ToolOutput(
+                result=operator_output.result,
+                logprobs=operator_output.logprobs,
+                analysis=operator_output.analysis,
+                metadata=metadata,
+            )
+
+        except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            metadata = ToolOutputMetadata(tool_name=tool_name)
+            tool_output = ToolOutput(
+                errors=[f"{type(e).__name__}: {e}"], metadata=metadata
+            )
+
+        return tool_output
 
     async def text_to_question(
         self,
         text: str,
+        number_of_questions: int,
         with_analysis: bool = False,
         output_lang: str | None = None,
         user_prompt: str | None = None,
         temperature: float | None = 0.0,
         logprobs: bool = False,
-        top_logprobs: int | None = None,
+        top_logprobs: int = 3,
         validator: Callable[[Any], bool] | None = None,
         max_validation_retries: int | None = None,
-        priority: int | None = 0,
-    ) -> Models.ToolOutput:
+        priority: int | None = None,
+    ) -> ToolOutput:
         """
         Generate a single question from the given text.
 
         Arguments:
-            text: The input text to generate a question from
+            text: The input text
+            number_of_questions: Number of questions to generate
             with_analysis: Whether to include detailed reasoning analysis
-            output_lang: Language for the output question
-            user_prompt: Additional instructions for question generation
-            temperature: Controls randomness (0.0 = deterministic, 1.0 = creative)
+            output_lang: Language for the output
+            user_prompt: Additional instructions
+            temperature: Controls randomness (0.0 - 2.0)
             logprobs: Whether to return token probability information
             top_logprobs: Number of top token alternatives to return if logprobs enabled
             validator: Custom validation function to validate the output
             max_validation_retries: Maximum number of retry attempts if validation fails
-            priority: Task execution priority (if enabled by vLLM and model)
+            priority: Task execution priority (if enabled by vLLM and the model)
 
         Returns:
-            ToolOutput: Object containing:
-                - result (str): The generated question
-                - logprobs (list | None): Probability data if logprobs enabled
-                - analysis (str | None): Detailed reasoning if with_analysis enabled
-                - errors (list(str) | None): Errors occured during tool call
+            ToolOutput
         """
-        start = datetime.now()
-        output = await self._operator.run(
-            # User parameters
-            text=text,
-            with_analysis=with_analysis,
-            output_lang=output_lang,
-            user_prompt=user_prompt,
-            temperature=temperature,
-            logprobs=logprobs,
-            top_logprobs=top_logprobs,
-            validator=validator,
-            max_validation_retries=max_validation_retries,
-            priority=priority,
-            # Internal parameters
-            prompt_file="text_to_question.yaml",
-            output_model=Models.StrOutput,
-            mode=None,
-        )
-        end = datetime.now()
-        output.execution_time = (end - start).total_seconds()
-        return output
+        tool_name = sys._getframe().f_code.co_name
+        start = perf_counter()
+
+        try:
+            operator_output = await self._operator.run(
+                # User parameters
+                text=text,
+                number_of_questions=number_of_questions,
+                with_analysis=with_analysis,
+                output_lang=output_lang,
+                user_prompt=user_prompt,
+                temperature=temperature,
+                logprobs=logprobs,
+                top_logprobs=top_logprobs,
+                validator=validator,
+                max_validation_retries=max_validation_retries,
+                priority=priority,
+                # Internal parameters
+                tool_name=tool_name,
+                output_model=ReasonListStr,
+                mode=None,
+            )
+
+            metadata = ToolOutputMetadata(
+                tool_name=tool_name, execution_time=perf_counter() - start
+            )
+            tool_output = ToolOutput(
+                result=operator_output.result,
+                logprobs=operator_output.logprobs,
+                analysis=operator_output.analysis,
+                metadata=metadata,
+            )
+
+        except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            metadata = ToolOutputMetadata(tool_name=tool_name)
+            tool_output = ToolOutput(
+                errors=[f"{type(e).__name__}: {e}"], metadata=metadata
+            )
+
+        return tool_output
 
     async def merge_questions(
         self,
@@ -405,57 +466,70 @@ class AsyncTheTool:
         user_prompt: str | None = None,
         temperature: float | None = 0.0,
         logprobs: bool = False,
-        top_logprobs: int | None = None,
+        top_logprobs: int = 3,
         mode: Literal["default", "reason"] = "default",
         validator: Callable[[Any], bool] | None = None,
         max_validation_retries: int | None = None,
-        priority: int | None = 0,
-    ) -> Models.ToolOutput:
+        priority: int | None = None,
+    ) -> ToolOutput:
         """
         Merge multiple questions into a single unified question.
 
         Arguments:
             text: List of questions to merge
             with_analysis: Whether to include detailed reasoning analysis
-            output_lang: Language for the output merged question
-            user_prompt: Additional instructions for question merging
-            temperature: Controls randomness (0.0 = deterministic, 1.0 = creative)
+            output_lang: Language for the output
+            user_prompt: Additional instructions
+            temperature: Controls randomness (0.0 - 2.0)
             logprobs: Whether to return token probability information
             top_logprobs: Number of top token alternatives to return if logprobs enabled
-            mode: Merging strategy - 'default' for direct merge, 'reason' for reasoned merge
             validator: Custom validation function to validate the output
             max_validation_retries: Maximum number of retry attempts if validation fails
-            priority: Task execution priority (if enabled by vLLM and model)
+            priority: Task execution priority (if enabled by vLLM and the model)
 
         Returns:
-            ToolOutput: Object containing:
-                - result (str): The merged question
-                - logprobs (list | None): Probability data if logprobs enabled
-                - analysis (str | None): Detailed reasoning if with_analysis enabled
-                - errors (list(str) | None): Errors occured during tool call
+            ToolOutput
         """
-        start = datetime.now()
-        text_combined = ", ".join(text)
-        output = await self._operator.run(
-            # User parameters
-            text=text_combined,
-            with_analysis=with_analysis,
-            output_lang=output_lang,
-            user_prompt=user_prompt,
-            temperature=temperature,
-            logprobs=logprobs,
-            top_logprobs=top_logprobs,
-            validator=validator,
-            max_validation_retries=max_validation_retries,
-            priority=priority,
-            # Internal parameters
-            prompt_file="merge_questions.yaml",
-            output_model=Models.StrOutput,
-            mode=mode,
-        )
-        end = datetime.now()
-        output.execution_time = (end - start).total_seconds()
-        return output
+        tool_name = sys._getframe().f_code.co_name
+        start = perf_counter()
+
+        try:
+            text = ", ".join(text)
+            operator_output = await self._operator.run(
+                # User parameters
+                text=text,
+                with_analysis=with_analysis,
+                output_lang=output_lang,
+                user_prompt=user_prompt,
+                temperature=temperature,
+                logprobs=logprobs,
+                top_logprobs=top_logprobs,
+                validator=validator,
+                max_validation_retries=max_validation_retries,
+                priority=priority,
+                # Internal parameters
+                tool_name=tool_name,
+                output_model=Str,
+                mode=mode,
+            )
+
+            metadata = ToolOutputMetadata(
+                tool_name=tool_name, execution_time=perf_counter() - start
+            )
+            tool_output = ToolOutput(
+                result=operator_output.result,
+                logprobs=operator_output.logprobs,
+                analysis=operator_output.analysis,
+                metadata=metadata,
+            )
+
+        except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            metadata = ToolOutputMetadata(tool_name=tool_name)
+            tool_output = ToolOutput(
+                errors=[f"{type(e).__name__}: {e}"], metadata=metadata
+            )
+
+        return tool_output
 
     async def rewrite(
         self,
@@ -465,56 +539,69 @@ class AsyncTheTool:
         user_prompt: str | None = None,
         temperature: float | None = 0.0,
         logprobs: bool = False,
-        top_logprobs: int | None = None,
+        top_logprobs: int = 3,
         mode: Literal["positive", "negative", "hard_negative"] = "positive",
         validator: Callable[[Any], bool] | None = None,
         max_validation_retries: int | None = None,
-        priority: int | None = 0,
-    ) -> Models.ToolOutput:
+        priority: int | None = None,
+    ) -> ToolOutput:
         """
         Rewrite a text with different modes.
 
         Arguments:
-            text: The input text to rewrite
+            text: The input text
             with_analysis: Whether to include detailed reasoning analysis
-            output_lang: Language for the output rewritten text
-            user_prompt: Additional instructions for rewriting
-            temperature: Controls randomness (0.0 = deterministic, 1.0 = creative)
+            output_lang: Language for the output
+            user_prompt: Additional instructions
+            temperature: Controls randomness (0.0 - 2.0)
             logprobs: Whether to return token probability information
             top_logprobs: Number of top token alternatives to return if logprobs enabled
-            mode: Rewriting mode - 'positive', 'negative', or 'hard_negative'
             validator: Custom validation function to validate the output
             max_validation_retries: Maximum number of retry attempts if validation fails
-            priority: Task execution priority (if enabled by vLLM and model)
+            priority: Task execution priority (if enabled by vLLM and the model)
 
         Returns:
-            ToolOutput: Object containing:
-                - result (str): The rewritten text
-                - logprobs (list | None): Probability data if logprobs enabled
-                - analysis (str | None): Detailed reasoning if with_analysis enabled
-                - errors (list(str) | None): Errors occured during tool call
+            ToolOutput
         """
-        start = datetime.now()
-        output = await self._operator.run(
-            # User parameters
-            text=text,
-            with_analysis=with_analysis,
-            output_lang=output_lang,
-            user_prompt=user_prompt,
-            temperature=temperature,
-            logprobs=logprobs,
-            top_logprobs=top_logprobs,
-            validator=validator,
-            max_validation_retries=max_validation_retries,
-            priority=priority,
-            # Internal parameters
-            prompt_file="rewrite.yaml",
-            output_model=Models.StrOutput,
-            mode=mode,
-        )
-        end = datetime.now()
-        output.execution_time = (end - start).total_seconds()
-        return output
+        tool_name = sys._getframe().f_code.co_name
+        start = perf_counter()
+
+        try:
+            operator_output = await self._operator.run(
+                # User parameters
+                text=text,
+                with_analysis=with_analysis,
+                output_lang=output_lang,
+                user_prompt=user_prompt,
+                temperature=temperature,
+                logprobs=logprobs,
+                top_logprobs=top_logprobs,
+                validator=validator,
+                max_validation_retries=max_validation_retries,
+                priority=priority,
+                # Internal parameters
+                tool_name=tool_name,
+                output_model=Str,
+                mode=mode,
+            )
+
+            metadata = ToolOutputMetadata(
+                tool_name=tool_name, execution_time=perf_counter() - start
+            )
+            tool_output = ToolOutput(
+                result=operator_output.result,
+                logprobs=operator_output.logprobs,
+                analysis=operator_output.analysis,
+                metadata=metadata,
+            )
+
+        except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            metadata = ToolOutputMetadata(tool_name=tool_name)
+            tool_output = ToolOutput(
+                errors=[f"{type(e).__name__}: {e}"], metadata=metadata
+            )
+
+        return tool_output
 
     async def subject_to_question(
         self,
@@ -525,11 +612,11 @@ class AsyncTheTool:
         user_prompt: str | None = None,
         temperature: float | None = 0.0,
         logprobs: bool = False,
-        top_logprobs: int | None = None,
+        top_logprobs: int = 3,
         validator: Callable[[Any], bool] | None = None,
         max_validation_retries: int | None = None,
-        priority: int | None = 0,
-    ) -> Models.ToolOutput:
+        priority: int | None = None,
+    ) -> ToolOutput:
         """
         Generate a list of questions about a subject.
 
@@ -537,44 +624,58 @@ class AsyncTheTool:
             text: The subject text to generate questions about
             number_of_questions: Number of questions to generate
             with_analysis: Whether to include detailed reasoning analysis
-            output_lang: Language for the output questions
-            user_prompt: Additional instructions for question generation
-            temperature: Controls randomness (0.0 = deterministic, 1.0 = creative)
+            output_lang: Language for the output
+            user_prompt: Additional instructions
+            temperature: Controls randomness (0.0 - 2.0)
             logprobs: Whether to return token probability information
             top_logprobs: Number of top token alternatives to return if logprobs enabled
             validator: Custom validation function to validate the output
             max_validation_retries: Maximum number of retry attempts if validation fails
-            priority: Task execution priority (if enabled by vLLM and model)
+            priority: Task execution priority (if enabled by vLLM and the model)
 
         Returns:
-            ToolOutput: Object containing:
-                - result (list[str]): List of generated questions
-                - logprobs (list | None): Probability data if logprobs enabled
-                - analysis (str | None): Detailed reasoning if with_analysis enabled
-                - errors (list(str) | None): Errors occured during tool call
+            ToolOutput
         """
-        start = datetime.now()
-        output = await self._operator.run(
-            # User parameters
-            text=text,
-            number_of_questions=number_of_questions,
-            with_analysis=with_analysis,
-            output_lang=output_lang,
-            user_prompt=user_prompt,
-            temperature=temperature,
-            logprobs=logprobs,
-            top_logprobs=top_logprobs,
-            validator=validator,
-            max_validation_retries=max_validation_retries,
-            priority=priority,
-            # Internal parameters
-            prompt_file="subject_to_question.yaml",
-            output_model=Models.ReasonListStrOutput,
-            mode=None,
-        )
-        end = datetime.now()
-        output.execution_time = (end - start).total_seconds()
-        return output
+        tool_name = sys._getframe().f_code.co_name
+        start = perf_counter()
+
+        try:
+            operator_output = await self._operator.run(
+                # User parameters
+                text=text,
+                number_of_questions=number_of_questions,
+                with_analysis=with_analysis,
+                output_lang=output_lang,
+                user_prompt=user_prompt,
+                temperature=temperature,
+                logprobs=logprobs,
+                top_logprobs=top_logprobs,
+                validator=validator,
+                max_validation_retries=max_validation_retries,
+                priority=priority,
+                # Internal parameters
+                tool_name=tool_name,
+                output_model=ReasonListStr,
+                mode=None,
+            )
+
+            metadata = ToolOutputMetadata(
+                tool_name=tool_name, execution_time=perf_counter() - start
+            )
+            tool_output = ToolOutput(
+                result=operator_output.result,
+                logprobs=operator_output.logprobs,
+                analysis=operator_output.analysis,
+                metadata=metadata,
+            )
+
+        except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            metadata = ToolOutputMetadata(tool_name=tool_name)
+            tool_output = ToolOutput(
+                errors=[f"{type(e).__name__}: {e}"], metadata=metadata
+            )
+
+        return tool_output
 
     async def summarize(
         self,
@@ -584,221 +685,409 @@ class AsyncTheTool:
         user_prompt: str | None = None,
         temperature: float | None = 0.0,
         logprobs: bool = False,
-        top_logprobs: int | None = None,
+        top_logprobs: int = 3,
         validator: Callable[[Any], bool] | None = None,
         max_validation_retries: int | None = None,
-        priority: int | None = 0,
-    ) -> Models.ToolOutput:
+        priority: int | None = None,
+    ) -> ToolOutput:
         """
         Summarize the given subject text.
 
         Arguments:
-            text: The input text to summarize
+            text: The input text
             with_analysis: Whether to include detailed reasoning analysis
-            output_lang: Language for the output summary
-            user_prompt: Additional instructions for summarization
-            temperature: Controls randomness (0.0 = deterministic, 1.0 = creative)
+            output_lang: Language for the output
+            user_prompt: Additional instructions
+            temperature: Controls randomness (0.0 - 2.0)
             logprobs: Whether to return token probability information
             top_logprobs: Number of top token alternatives to return if logprobs enabled
             validator: Custom validation function to validate the output
             max_validation_retries: Maximum number of retry attempts if validation fails
-            priority: Task execution priority (if enabled by vLLM and model)
+            priority: Task execution priority (if enabled by vLLM and the model)
 
         Returns:
-            ToolOutput: Object containing:
-                - result (str): The summary text
-                - logprobs (list | None): Probability data if logprobs enabled
-                - analysis (str | None): Detailed reasoning if with_analysis enabled
-                - errors (list(str) | None): Errors occured during tool call
+            ToolOutput
         """
-        start = datetime.now()
-        output = await self._operator.run(
-            # User parameters
-            text=text,
-            with_analysis=with_analysis,
-            output_lang=output_lang,
-            user_prompt=user_prompt,
-            temperature=temperature,
-            logprobs=logprobs,
-            top_logprobs=top_logprobs,
-            validator=validator,
-            max_validation_retries=max_validation_retries,
-            priority=priority,
-            # Internal parameters
-            prompt_file="summarize.yaml",
-            output_model=Models.StrOutput,
-            mode=None,
-        )
-        end = datetime.now()
-        output.execution_time = (end - start).total_seconds()
-        return output
+        tool_name = sys._getframe().f_code.co_name
+        start = perf_counter()
+
+        try:
+            operator_output = await self._operator.run(
+                # User parameters
+                text=text,
+                with_analysis=with_analysis,
+                output_lang=output_lang,
+                user_prompt=user_prompt,
+                temperature=temperature,
+                logprobs=logprobs,
+                top_logprobs=top_logprobs,
+                validator=validator,
+                max_validation_retries=max_validation_retries,
+                priority=priority,
+                # Internal parameters
+                tool_name=tool_name,
+                output_model=Str,
+                mode=None,
+            )
+
+            metadata = ToolOutputMetadata(
+                tool_name=tool_name, execution_time=perf_counter() - start
+            )
+            tool_output = ToolOutput(
+                result=operator_output.result,
+                logprobs=operator_output.logprobs,
+                analysis=operator_output.analysis,
+                metadata=metadata,
+            )
+
+        except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            metadata = ToolOutputMetadata(tool_name=tool_name)
+            tool_output = ToolOutput(
+                errors=[f"{type(e).__name__}: {e}"], metadata=metadata
+            )
+
+        return tool_output
 
     async def translate(
         self,
         text: str,
         target_language: str,
+        use_chunker: bool = True,
         with_analysis: bool = False,
         user_prompt: str | None = None,
         temperature: float | None = 0.0,
         logprobs: bool = False,
-        top_logprobs: int | None = None,
+        top_logprobs: int = 3,
         validator: Callable[[Any], bool] | None = None,
         max_validation_retries: int | None = None,
-        priority: int | None = 0,
-    ) -> Models.ToolOutput:
+        priority: int | None = None,
+    ) -> ToolOutput:
         """
         Translate text between languages.
 
+        Important Note: This tool is EXPERIMENTAL, you can use it but it isn't reliable.
+
         Arguments:
-            text: The input text to translate
+            text: The input text
             target_language: The target language for translation
+            use_chunker: Whether to use text chunker for text length bigger than 1500
+            with_analysis: Whether to include detailed reasoning analysis
+            user_prompt: Additional instructions
+            temperature: Controls randomness (0.0 - 2.0)
+            logprobs: Whether to return token probability information
+            top_logprobs: Number of top token alternatives to return if logprobs enabled
+            validator: Custom validation function to validate the output
+            max_validation_retries: Maximum number of retry attempts if validation fails
+            priority: Task execution priority (if enabled by vLLM and the model)
+
+        Returns:
+            ToolOutput
+        """
+        tool_name = sys._getframe().f_code.co_name
+        start = perf_counter()
+
+        try:
+            if len(text.split(" ")) > 1500 and use_chunker:
+                chunks = text_to_chunks(text, 1200, 0)
+                translation = ""
+                analysis = ""
+                logprobs_list = []
+
+                for chunk in chunks:
+                    chunk_operator_output = await self._operator.run(
+                        # User parameters
+                        text=chunk,
+                        target_language=target_language,
+                        with_analysis=with_analysis,
+                        user_prompt=user_prompt,
+                        temperature=temperature,
+                        logprobs=logprobs,
+                        top_logprobs=top_logprobs,
+                        validator=validator,
+                        max_validation_retries=max_validation_retries,
+                        priority=priority,
+                        # Internal parameters
+                        tool_name=tool_name,
+                        output_model=Str,
+                        mode=None,
+                        output_lang=None,
+                    )
+
+                    translation += chunk_operator_output.result + "\n"
+
+                    if with_analysis:
+                        analysis += chunk_operator_output.analysis
+                    if logprobs:
+                        logprobs_list.extend(chunk_operator_output.logprobs)
+
+                metadata = ToolOutputMetadata(
+                    tool_name=tool_name, execution_time=perf_counter() - start
+                )
+                tool_output = ToolOutput(
+                    result=translation,
+                    logprobs=logprobs_list,
+                    analysis=analysis,
+                    metadata=metadata,
+                )
+
+            else:
+                operator_output = await self._operator.run(
+                    # User parameters
+                    text=text,
+                    target_language=target_language,
+                    with_analysis=with_analysis,
+                    user_prompt=user_prompt,
+                    temperature=temperature,
+                    logprobs=logprobs,
+                    top_logprobs=top_logprobs,
+                    validator=validator,
+                    max_validation_retries=max_validation_retries,
+                    priority=priority,
+                    # Internal parameters
+                    tool_name=tool_name,
+                    output_model=Str,
+                    mode=None,
+                    output_lang=None,
+                )
+
+                metadata = ToolOutputMetadata(
+                    tool_name=tool_name, execution_time=perf_counter() - start
+                )
+                tool_output = ToolOutput(
+                    result=operator_output.result,
+                    logprobs=operator_output.logprobs,
+                    analysis=operator_output.analysis,
+                    metadata=metadata,
+                )
+
+        except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            metadata = ToolOutputMetadata(tool_name=tool_name)
+            tool_output = ToolOutput(
+                errors=[f"{type(e).__name__}: {e}"], metadata=metadata
+            )
+
+        return tool_output
+
+    async def propositionize(
+        self,
+        text: str,
+        with_analysis: bool = False,
+        output_lang: str | None = None,
+        user_prompt: str | None = None,
+        temperature: float | None = 0.0,
+        logprobs: bool = False,
+        top_logprobs: int = 3,
+        validator: Callable[[Any], bool] | None = None,
+        max_validation_retries: int | None = None,
+        priority: int | None = None,
+    ) -> ToolOutput:
+        """
+        Proposition input text to meaningful sentences.
+
+        Important Note: This tool is EXPERIMENTAL, you can use it but it isn't reliable.
+
+        Arguments:
+            text: The input text
             with_analysis: Whether to include detailed reasoning analysis
-            user_prompt: Additional instructions for translation
-            temperature: Controls randomness (0.0 = deterministic, 1.0 = creative)
+            output_lang: Language for the output
+            user_prompt: Additional instructions
+            temperature: Controls randomness (0.0 - 2.0)
             logprobs: Whether to return token probability information
             top_logprobs: Number of top token alternatives to return if logprobs enabled
             validator: Custom validation function to validate the output
             max_validation_retries: Maximum number of retry attempts if validation fails
-            priority: Task execution priority (if enabled by vLLM and model)
+            priority: Task execution priority (if enabled by vLLM and the model)
 
         Returns:
-            ToolOutput: Object containing:
-                - result (str): The translated text
-                - logprobs (list | None): Probability data if logprobs enabled
-                - analysis (str | None): Detailed reasoning if with_analysis enabled
-                - errors (list(str) | None): Errors occured during tool call
+            ToolOutput
         """
-        start = datetime.now()
-        output = await self._operator.run(
-            # User parameters
-            text=text,
-            target_language=target_language,
-            with_analysis=with_analysis,
-            user_prompt=user_prompt,
-            temperature=temperature,
-            logprobs=logprobs,
-            top_logprobs=top_logprobs,
-            validator=validator,
-            max_validation_retries=max_validation_retries,
-            priority=priority,
-            # Internal parameters
-            prompt_file="translate.yaml",
-            output_model=Models.StrOutput,
-            mode=None,
-            output_lang=None,
-        )
-        end = datetime.now()
-        output.execution_time = (end - start).total_seconds()
-        return output
-
-    async def detect_entity(
+        tool_name = sys._getframe().f_code.co_name
+        start = perf_counter()
+
+        try:
+            operator_output = await self._operator.run(
+                # User parameters
+                text=text,
+                with_analysis=with_analysis,
+                output_lang=output_lang,
+                user_prompt=user_prompt,
+                temperature=temperature,
+                logprobs=logprobs,
+                top_logprobs=top_logprobs,
+                validator=validator,
+                max_validation_retries=max_validation_retries,
+                priority=priority,
+                # Internal parameters
+                tool_name=tool_name,
+                output_model=ListStr,
+                mode=None,
+            )
+
+            metadata = ToolOutputMetadata(
+                tool_name=tool_name, execution_time=perf_counter() - start
+            )
+            tool_output = ToolOutput(
+                result=operator_output.result,
+                logprobs=operator_output.logprobs,
+                analysis=operator_output.analysis,
+                metadata=metadata,
+            )
+
+        except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            metadata = ToolOutputMetadata(tool_name=tool_name)
+            tool_output = ToolOutput(
+                errors=[f"{type(e).__name__}: {e}"], metadata=metadata
+            )
+
+        return tool_output
+
+    async def check_fact(
         self,
         text: str,
+        source_text: str,
         with_analysis: bool = False,
         output_lang: str | None = None,
         user_prompt: str | None = None,
         temperature: float | None = 0.0,
         logprobs: bool = False,
-        top_logprobs: int | None = None,
+        top_logprobs: int = 3,
         validator: Callable[[Any], bool] | None = None,
         max_validation_retries: int | None = None,
-        priority: int | None = 0,
-    ) -> Models.ToolOutput:
+        priority: int | None = None,
+    ) -> ToolOutput:
         """
-        Detects entities in a given text based on the entity_detector.yaml prompt.
+        Checks wheather a statement is relevant to the source text or not.
+
+        Important Note: This tool is EXPERIMENTAL, you can use it but it isn't reliable.
 
         Arguments:
             text: The input text
+            source_text: the source text that we want to check relation of text to it
             with_analysis: Whether to include detailed reasoning analysis
-            output_lang: Language for the output summary
-            user_prompt: Additional instructions for summarization
-            temperature: Controls randomness (0.0 = deterministic, 1.0 = creative)
+            output_lang: Language for the output
+            user_prompt: Additional instructions
+            temperature: Controls randomness (0.0 - 2.0)
             logprobs: Whether to return token probability information
             top_logprobs: Number of top token alternatives to return if logprobs enabled
             validator: Custom validation function to validate the output
             max_validation_retries: Maximum number of retry attempts if validation fails
-            priority: Task execution priority (if enabled by vLLM and model)
+            priority: Task execution priority (if enabled by vLLM and the model)
 
         Returns:
-            ToolOutput: Object containing:
-                - result (list[Entity]): The entities
-                - logprobs (list | None): Probability data if logprobs enabled
-                - analysis (str | None): Detailed reasoning if with_analysis enabled
-                - errors (list(str) | None): Errors occured during tool call
+            ToolOutput
         """
-        start = datetime.now()
-        output = await self._operator.run(
-            # User parameters
-            text=text,
-            with_analysis=with_analysis,
-            output_lang=output_lang,
-            user_prompt=user_prompt,
-            temperature=temperature,
-            logprobs=logprobs,
-            top_logprobs=top_logprobs,
-            validator=validator,
-            max_validation_retries=max_validation_retries,
-            priority=priority,
-            # Internal parameters
-            prompt_file="detect_entity.yaml",
-            output_model=Models.EntityDetectorOutput,
-            mode=None,
-        )
-        end = datetime.now()
-        output.execution_time = (end - start).total_seconds()
-        return output
+        tool_name = sys._getframe().f_code.co_name
+        start = perf_counter()
+
+        try:
+            operator_output = await self._operator.run(
+                # User parameters
+                text=text,
+                with_analysis=with_analysis,
+                output_lang=output_lang,
+                user_prompt=user_prompt,
+                temperature=temperature,
+                logprobs=logprobs,
+                top_logprobs=top_logprobs,
+                validator=validator,
+                max_validation_retries=max_validation_retries,
+                priority=priority,
+                # Internal parameters
+                tool_name=tool_name,
+                output_model=Bool,
+                mode=None,
+                source_text=source_text,
+            )
+
+            metadata = ToolOutputMetadata(
+                tool_name=tool_name, execution_time=perf_counter() - start
+            )
+            tool_output = ToolOutput(
+                result=operator_output.result,
+                logprobs=operator_output.logprobs,
+                analysis=operator_output.analysis,
+                metadata=metadata,
+            )
+
+        except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            metadata = ToolOutputMetadata(tool_name=tool_name)
+            tool_output = ToolOutput(
+                errors=[f"{type(e).__name__}: {e}"], metadata=metadata
+            )
+
+        return tool_output
 
     async def run_custom(
         self,
         prompt: str,
         output_model: Any,
+        with_analysis: bool = False,
+        analyze_template: str | None = None,
         output_lang: str | None = None,
         temperature: float | None = None,
         logprobs: bool | None = None,
-        top_logprobs: int | None = None,
+        top_logprobs: int = 3,
         validator: Callable[[Any], bool] | None = None,
         max_validation_retries: int | None = None,
-        priority: int | None = 0,
-    ) -> Models.ToolOutput:
+        priority: int | None = None,
+    ) -> ToolOutput:
         """
         Custom tool that can do almost anything!
 
         Arguments:
-            text: The user prompt
-            output_lang: Language for the output summary
-            temperature: Controls randomness (0.0 = deterministic, 1.0 = creative)
+            prompt: The user prompt
+            output_model: Pydantic BaseModel used for structured output
+            with_analysis: Whether to include detailed reasoning analysis
+            analyze_template: The analyze template used for reasoning analysis
+            output_lang: Language for the output
+            temperature: Controls randomness (0.0 - 2.0)
             logprobs: Whether to return token probability information
             top_logprobs: Number of top token alternatives to return if logprobs enabled
             validator: Custom validation function to validate the output
             max_validation_retries: Maximum number of retry attempts if validation fails
-            priority: Task execution priority (if enabled by vLLM and model)
+            priority: Task execution priority (if enabled by vLLM and the model)
 
         Returns:
-            ToolOutput: Object containing:
-                - result (str): The translated text
-                - logprobs (list | None): Probability data if logprobs enabled
-                - analysis (str | None): Detailed reasoning if with_analysis enabled
-                - errors (list(str) | None): Errors occured during tool call
+            ToolOutput
         """
-        start = datetime.now()
-        output = await self._operator.run(
-            # User paramaeters
-            text=prompt,
-            output_model=output_model,
-            output_model_str=output_model.model_json_schema(),
-            output_lang=output_lang,
-            temperature=temperature,
-            logprobs=logprobs,
-            top_logprobs=top_logprobs,
-            validator=validator,
-            max_validation_retries=max_validation_retries,
-            priority=priority,
-            # Internal parameters
-            prompt_file="run_custom.yaml",
-            user_prompt=None,
-            with_analysis=False,
-            mode=None,
-        )
-        end = datetime.now()
-        output.execution_time = (end - start).total_seconds()
-        return output
+        tool_name = sys._getframe().f_code.co_name
+        start = perf_counter()
+
+        try:
+            operator_output = await self._operator.run(
+                # User paramaeters
+                text=prompt,
+                output_model=output_model,
+                with_analysis=with_analysis,
+                analyze_template=analyze_template,
+                output_model_str=output_model.model_json_schema(),
+                output_lang=output_lang,
+                temperature=temperature,
+                logprobs=logprobs,
+                top_logprobs=top_logprobs,
+                validator=validator,
+                max_validation_retries=max_validation_retries,
+                priority=priority,
+                # Internal parameters
+                tool_name=tool_name,
+                user_prompt=None,
+                mode=None,
+            )
+
+            metadata = ToolOutputMetadata(
+                tool_name=tool_name, execution_time=perf_counter() - start
+            )
+            tool_output = ToolOutput(
+                result=operator_output.result,
+                logprobs=operator_output.logprobs,
+                analysis=operator_output.analysis,
+                metadata=metadata,
+            )
+
+        except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            metadata = ToolOutputMetadata(tool_name=tool_name)
+            tool_output = ToolOutput(
+                errors=[f"{type(e).__name__}: {e}"], metadata=metadata
+            )
+
+        return tool_output