hamtaa-texttools 1.1.19__py3-none-any.whl → 1.1.21__py3-none-any.whl

texttools/tools/async_tools.py

@@ -1,5 +1,6 @@
-from datetime import datetime
-from typing import Literal, Any
+import sys
+from time import perf_counter
+from typing import Literal
 from collections.abc import Callable
 
 from openai import AsyncOpenAI
@@ -12,6 +13,7 @@ from texttools.internals.exceptions import (
     LLMError,
     ValidationError,
 )
+from texttools.internals.text_to_chunks import text_to_chunks
 
 
 class AsyncTheTool:
@@ -35,11 +37,10 @@ class AsyncTheTool:
         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",
-        validator: Callable[[Any], bool] | None = None,
+        top_logprobs: int = 3,
+        validator: Callable[[object], bool] | None = None,
         max_validation_retries: int | None = None,
-        priority: int | None = 0,
+        priority: int = 0,
     ) -> Models.ToolOutput:
         """
         Categorize a text into a category / category tree.
@@ -48,62 +49,73 @@ class AsyncTheTool:
 
         Arguments:
             text: The input text to categorize
-            categories: The category / category_tree to give to LLM
+            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)
+            temperature: Controls randomness
             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
-                - process (str | None): Description of the process used
-                - processed_at (datetime): Timestamp when the processing occurred
-                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
-                - errors (list(str) | None): Errors occured during tool call
+            ToolOutput
 
         """
-        output = Models.ToolOutput()
+        tool_name = sys._getframe().f_code.co_name
+        prompt_file = tool_name + ".yaml"
+        start = perf_counter()
 
         try:
-            start = datetime.now()
+            if isinstance(categories, list):
+                operator_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,
+                    validator=validator,
+                    max_validation_retries=max_validation_retries,
+                    priority=priority,
+                    # Internal parameters
+                    prompt_file=prompt_file,
+                    output_model=Models.create_dynamic_model(categories),
+                    mode=None,
+                    output_lang=None,
+                )
 
-            if mode == "category_tree":
-                # Initializations
-                output = Models.ToolOutput()
+                metadata = Models.ToolOutputMetadata(
+                    tool_name=tool_name, execution_time=perf_counter() - start
+                )
+                tool_output = Models.ToolOutput(
+                    result=operator_output.result,
+                    analysis=operator_output.analysis,
+                    logprobs=operator_output.logprobs,
+                    metadata=metadata,
+                )
+
+            else:
                 levels = categories.get_level_count()
-                parent_id = 0
-                final_output = []
+                parent_node = categories.get_node("root")
+                final_categories = []
+                analysis = ""
+                logprobs_list = []
 
                 for _ in range(levels):
-                    # Get child nodes for current parent
-                    parent_node = categories.get_node(parent_id)
-                    children = categories.get_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
+                    if not parent_node.children:
+                        break
+
                     category_list = [
-                        f"Category Name: {node.name}, Description: {node.description}"
-                        for node in children
+                        f"Category Name: {name}, Description: {node.description}"
+                        for name, node in parent_node.children.items()
                     ]
-                    category_names = [node.name for node in children]
+                    category_names = list(parent_node.children.keys())
 
-                    # Run categorization for this level
-                    level_output = await self._operator.run(
+                    level_operator_output = await self._operator.run(
                         # User parameters
                         text=text,
                         category_list=category_list,
@@ -112,84 +124,44 @@ class AsyncTheTool:
                         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",
+                        prompt_file=prompt_file,
                         output_model=Models.create_dynamic_model(category_names),
+                        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
+                    chosen_category = level_operator_output.result
                     parent_node = categories.get_node(chosen_category)
-                    if parent_node is None:
-                        output.errors.append(
-                            f"Category '{chosen_category}' not found in tree after selection"
-                        )
-                        end = datetime.now()
-                        output.execution_time = (end - start).total_seconds()
-                        return output
-
-                    parent_id = parent_node.node_id
-                    final_output.append(parent_node.name)
-
-                    # 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
-
-                output.result = final_output
-                end = datetime.now()
-                output.execution_time = (end - start).total_seconds()
-                return output
+                    if not parent_node:
+                        break
+                    final_categories.append(chosen_category)
 
-            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,
-                    priority=priority,
-                    # Internal parameters
-                    prompt_file="categorize.yaml",
-                    output_model=Models.create_dynamic_model(categories),
-                    output_lang=None,
+                    if with_analysis:
+                        analysis += level_operator_output.analysis
+                    if logprobs:
+                        logprobs_list.extend(level_operator_output.logprobs)
+
+                metadata = Models.ToolOutputMetadata(
+                    tool_name=tool_name, execution_time=(perf_counter() - start)
+                )
+                tool_output = Models.ToolOutput(
+                    result=final_categories,
+                    analysis=analysis,
+                    logprobs=logprobs_list,
+                    metadata=metadata,
                 )
-                end = datetime.now()
-                output.execution_time = (end - start).total_seconds()
-                return output
-
-        except PromptError as e:
-            output.errors.append(f"Prompt error: {e}")
-        except LLMError as e:
-            output.errors.append(f"LLM error: {e}")
-        except ValidationError as e:
-            output.errors.append(f"Validation error: {e}")
-        except TextToolsError as e:
-            output.errors.append(f"TextTools error: {e}")
-        except Exception as e:
-            output.errors.append(f"Unexpected error: {e}")
-
-        return output
+
+        except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            metadata = Models.ToolOutputMetadata(tool_name=tool_name)
+            tool_output = Models.ToolOutput(
+                errors=[f"{type(e).__name__}: {e}"], metadata=metadata
+            )
+
+        return tool_output
 
     async def extract_keywords(
         self,
@@ -199,10 +171,10 @@ 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,
+        validator: Callable[[object], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = 0,
     ) -> Models.ToolOutput:
@@ -214,28 +186,22 @@ class AsyncTheTool:
             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)
+            temperature: Controls randomness
             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
-                - process (str | None): Description of the process used
-                - processed_at (datetime): Timestamp when the processing occurred
-                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
-                - errors (list(str) | None): Errors occured during tool call
+            ToolOutput
         """
-        output = Models.ToolOutput()
+        tool_name = sys._getframe().f_code.co_name
+        prompt_file = tool_name + ".yaml"
+        start = perf_counter()
 
         try:
-            start = datetime.now()
-            output = await self._operator.run(
+            operator_output = await self._operator.run(
                 # User parameters
                 text=text,
                 with_analysis=with_analysis,
@@ -250,36 +216,39 @@ class AsyncTheTool:
                 max_validation_retries=max_validation_retries,
                 priority=priority,
                 # Internal parameters
-                prompt_file="extract_keywords.yaml",
-                output_model=Models.ListStrOutput,
+                prompt_file=prompt_file,
+                output_model=Models.ListStr,
+            )
+
+            metadata = Models.ToolOutputMetadata(
+                tool_name=tool_name, execution_time=perf_counter() - start
+            )
+            tool_output = Models.ToolOutput(
+                result=operator_output.result,
+                logprobs=operator_output.logprobs,
+                analysis=operator_output.analysis,
+                metadata=metadata,
             )
-            end = datetime.now()
-            output.execution_time = (end - start).total_seconds()
-            return output
-
-        except PromptError as e:
-            output.errors.append(f"Prompt error: {e}")
-        except LLMError as e:
-            output.errors.append(f"LLM error: {e}")
-        except ValidationError as e:
-            output.errors.append(f"Validation error: {e}")
-        except TextToolsError as e:
-            output.errors.append(f"TextTools error: {e}")
-        except Exception as e:
-            output.errors.append(f"Unexpected error: {e}")
-
-        return output
+
+        except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            metadata = Models.ToolOutputMetadata(tool_name=tool_name)
+            tool_output = Models.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,
-        validator: Callable[[Any], bool] | None = None,
+        top_logprobs: int = 3,
+        validator: Callable[[object], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = 0,
     ) -> Models.ToolOutput:
@@ -288,33 +257,30 @@ class AsyncTheTool:
 
         Arguments:
             text: The input text to extract entities from
+            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)
+            temperature: Controls randomness
             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
-                - process (str | None): Description of the process used
-                - processed_at (datetime): Timestamp when the processing occurred
-                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
-                - errors (list(str) | None): Errors occured during tool call
+            ToolOutput
         """
-        output = Models.ToolOutput()
+        tool_name = sys._getframe().f_code.co_name
+        prompt_file = tool_name + ".yaml"
+        start = perf_counter()
 
         try:
-            start = datetime.now()
-            output = await self._operator.run(
+            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,
@@ -325,26 +291,28 @@ class AsyncTheTool:
                 max_validation_retries=max_validation_retries,
                 priority=priority,
                 # Internal parameters
-                prompt_file="extract_entities.yaml",
-                output_model=Models.ListDictStrStrOutput,
+                prompt_file=prompt_file,
+                output_model=Models.ListDictStrStr,
                 mode=None,
             )
-            end = datetime.now()
-            output.execution_time = (end - start).total_seconds()
-            return output
-
-        except PromptError as e:
-            output.errors.append(f"Prompt error: {e}")
-        except LLMError as e:
-            output.errors.append(f"LLM error: {e}")
-        except ValidationError as e:
-            output.errors.append(f"Validation error: {e}")
-        except TextToolsError as e:
-            output.errors.append(f"TextTools error: {e}")
-        except Exception as e:
-            output.errors.append(f"Unexpected error: {e}")
-
-        return output
+
+            metadata = Models.ToolOutputMetadata(
+                tool_name=tool_name, execution_time=perf_counter() - start
+            )
+            tool_output = Models.ToolOutput(
+                result=operator_output.result,
+                logprobs=operator_output.logprobs,
+                analysis=operator_output.analysis,
+                metadata=metadata,
+            )
+
+        except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            metadata = Models.ToolOutputMetadata(tool_name=tool_name)
+            tool_output = Models.ToolOutput(
+                errors=[f"{type(e).__name__}: {e}"], metadata=metadata
+            )
+
+        return tool_output
 
     async def is_question(
         self,
@@ -353,8 +321,8 @@ class AsyncTheTool:
         user_prompt: str | None = None,
         temperature: float | None = 0.0,
         logprobs: bool = False,
-        top_logprobs: int | None = None,
-        validator: Callable[[Any], bool] | None = None,
+        top_logprobs: int = 3,
+        validator: Callable[[object], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = 0,
     ) -> Models.ToolOutput:
@@ -365,28 +333,22 @@ class AsyncTheTool:
             text: The input text to analyze
             with_analysis: Whether to include detailed reasoning analysis
             user_prompt: Additional instructions for question detection
-            temperature: Controls randomness (0.0 = deterministic, 1.0 = creative)
+            temperature: Controls randomness
             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
-                - process (str | None): Description of the process used
-                - processed_at (datetime): Timestamp when the processing occurred
-                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
-                - errors (list(str) | None): Errors occured during tool call
+            ToolOutput
         """
-        output = Models.ToolOutput()
+        tool_name = sys._getframe().f_code.co_name
+        prompt_file = tool_name + ".yaml"
+        start = perf_counter()
 
         try:
-            start = datetime.now()
-            output = await self._operator.run(
+            operator_output = await self._operator.run(
                 # User parameters
                 text=text,
                 with_analysis=with_analysis,
@@ -398,38 +360,41 @@ class AsyncTheTool:
                 max_validation_retries=max_validation_retries,
                 priority=priority,
                 # Internal parameters
-                prompt_file="is_question.yaml",
-                output_model=Models.BoolOutput,
+                prompt_file=prompt_file,
+                output_model=Models.Bool,
                 mode=None,
                 output_lang=None,
             )
-            end = datetime.now()
-            output.execution_time = (end - start).total_seconds()
-            return output
-
-        except PromptError as e:
-            output.errors.append(f"Prompt error: {e}")
-        except LLMError as e:
-            output.errors.append(f"LLM error: {e}")
-        except ValidationError as e:
-            output.errors.append(f"Validation error: {e}")
-        except TextToolsError as e:
-            output.errors.append(f"TextTools error: {e}")
-        except Exception as e:
-            output.errors.append(f"Unexpected error: {e}")
-
-        return output
+
+            metadata = Models.ToolOutputMetadata(
+                tool_name=tool_name, execution_time=perf_counter() - start
+            )
+            tool_output = Models.ToolOutput(
+                result=operator_output.result,
+                logprobs=operator_output.logprobs,
+                analysis=operator_output.analysis,
+                metadata=metadata,
+            )
+
+        except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            metadata = Models.ToolOutputMetadata(tool_name=tool_name)
+            tool_output = Models.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,
-        validator: Callable[[Any], bool] | None = None,
+        top_logprobs: int = 3,
+        validator: Callable[[object], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = 0,
     ) -> Models.ToolOutput:
@@ -438,33 +403,29 @@ class AsyncTheTool:
 
         Arguments:
             text: The input text to generate a question from
+            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)
+            temperature: Controls randomness
             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
-                - process (str | None): Description of the process used
-                - processed_at (datetime): Timestamp when the processing occurred
-                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
-                - errors (list(str) | None): Errors occured during tool call
+            ToolOutput
         """
-        output = Models.ToolOutput()
+        tool_name = sys._getframe().f_code.co_name
+        prompt_file = tool_name + ".yaml"
+        start = perf_counter()
 
         try:
-            start = datetime.now()
-            output = await self._operator.run(
+            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,
@@ -475,26 +436,28 @@ class AsyncTheTool:
                 max_validation_retries=max_validation_retries,
                 priority=priority,
                 # Internal parameters
-                prompt_file="text_to_question.yaml",
-                output_model=Models.StrOutput,
+                prompt_file=prompt_file,
+                output_model=Models.ReasonListStr,
                 mode=None,
             )
-            end = datetime.now()
-            output.execution_time = (end - start).total_seconds()
-            return output
-
-        except PromptError as e:
-            output.errors.append(f"Prompt error: {e}")
-        except LLMError as e:
-            output.errors.append(f"LLM error: {e}")
-        except ValidationError as e:
-            output.errors.append(f"Validation error: {e}")
-        except TextToolsError as e:
-            output.errors.append(f"TextTools error: {e}")
-        except Exception as e:
-            output.errors.append(f"Unexpected error: {e}")
-
-        return output
+
+            metadata = Models.ToolOutputMetadata(
+                tool_name=tool_name, execution_time=perf_counter() - start
+            )
+            tool_output = Models.ToolOutput(
+                result=operator_output.result,
+                logprobs=operator_output.logprobs,
+                analysis=operator_output.analysis,
+                metadata=metadata,
+            )
+
+        except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            metadata = Models.ToolOutputMetadata(tool_name=tool_name)
+            tool_output = Models.ToolOutput(
+                errors=[f"{type(e).__name__}: {e}"], metadata=metadata
+            )
+
+        return tool_output
 
     async def merge_questions(
         self,
@@ -504,9 +467,9 @@ 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,
+        validator: Callable[[object], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = 0,
     ) -> Models.ToolOutput:
@@ -518,30 +481,24 @@ class AsyncTheTool:
             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)
+            temperature: Controls randomness
             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
-                - process (str | None): Description of the process used
-                - processed_at (datetime): Timestamp when the processing occurred
-                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
-                - errors (list(str) | None): Errors occured during tool call
+            ToolOutput
         """
-        output = Models.ToolOutput()
+        tool_name = sys._getframe().f_code.co_name
+        prompt_file = tool_name + ".yaml"
+        start = perf_counter()
 
         try:
-            start = datetime.now()
             text = ", ".join(text)
-            output = await self._operator.run(
+            operator_output = await self._operator.run(
                 # User parameters
                 text=text,
                 with_analysis=with_analysis,
@@ -554,26 +511,28 @@ class AsyncTheTool:
                 max_validation_retries=max_validation_retries,
                 priority=priority,
                 # Internal parameters
-                prompt_file="merge_questions.yaml",
-                output_model=Models.StrOutput,
+                prompt_file=prompt_file,
+                output_model=Models.Str,
                 mode=mode,
             )
-            end = datetime.now()
-            output.execution_time = (end - start).total_seconds()
-            return output
-
-        except PromptError as e:
-            output.errors.append(f"Prompt error: {e}")
-        except LLMError as e:
-            output.errors.append(f"LLM error: {e}")
-        except ValidationError as e:
-            output.errors.append(f"Validation error: {e}")
-        except TextToolsError as e:
-            output.errors.append(f"TextTools error: {e}")
-        except Exception as e:
-            output.errors.append(f"Unexpected error: {e}")
-
-        return output
+
+            metadata = Models.ToolOutputMetadata(
+                tool_name=tool_name, execution_time=perf_counter() - start
+            )
+            tool_output = Models.ToolOutput(
+                result=operator_output.result,
+                logprobs=operator_output.logprobs,
+                analysis=operator_output.analysis,
+                metadata=metadata,
+            )
+
+        except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            metadata = Models.ToolOutputMetadata(tool_name=tool_name)
+            tool_output = Models.ToolOutput(
+                errors=[f"{type(e).__name__}: {e}"], metadata=metadata
+            )
+
+        return tool_output
 
     async def rewrite(
         self,
@@ -583,9 +542,9 @@ 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,
+        validator: Callable[[object], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = 0,
     ) -> Models.ToolOutput:
@@ -597,29 +556,23 @@ class AsyncTheTool:
             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)
+            temperature: Controls randomness
             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
-                - process (str | None): Description of the process used
-                - processed_at (datetime): Timestamp when the processing occurred
-                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
-                - errors (list(str) | None): Errors occured during tool call
+            ToolOutput
         """
-        output = Models.ToolOutput()
+        tool_name = sys._getframe().f_code.co_name
+        prompt_file = tool_name + ".yaml"
+        start = perf_counter()
 
         try:
-            start = datetime.now()
-            output = await self._operator.run(
+            operator_output = await self._operator.run(
                 # User parameters
                 text=text,
                 with_analysis=with_analysis,
@@ -632,26 +585,28 @@ class AsyncTheTool:
                 max_validation_retries=max_validation_retries,
                 priority=priority,
                 # Internal parameters
-                prompt_file="rewrite.yaml",
-                output_model=Models.StrOutput,
+                prompt_file=prompt_file,
+                output_model=Models.Str,
                 mode=mode,
             )
-            end = datetime.now()
-            output.execution_time = (end - start).total_seconds()
-            return output
-
-        except PromptError as e:
-            output.errors.append(f"Prompt error: {e}")
-        except LLMError as e:
-            output.errors.append(f"LLM error: {e}")
-        except ValidationError as e:
-            output.errors.append(f"Validation error: {e}")
-        except TextToolsError as e:
-            output.errors.append(f"TextTools error: {e}")
-        except Exception as e:
-            output.errors.append(f"Unexpected error: {e}")
-
-        return output
+
+            metadata = Models.ToolOutputMetadata(
+                tool_name=tool_name, execution_time=perf_counter() - start
+            )
+            tool_output = Models.ToolOutput(
+                result=operator_output.result,
+                logprobs=operator_output.logprobs,
+                analysis=operator_output.analysis,
+                metadata=metadata,
+            )
+
+        except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            metadata = Models.ToolOutputMetadata(tool_name=tool_name)
+            tool_output = Models.ToolOutput(
+                errors=[f"{type(e).__name__}: {e}"], metadata=metadata
+            )
+
+        return tool_output
 
     async def subject_to_question(
         self,
@@ -662,8 +617,8 @@ class AsyncTheTool:
         user_prompt: str | None = None,
         temperature: float | None = 0.0,
         logprobs: bool = False,
-        top_logprobs: int | None = None,
-        validator: Callable[[Any], bool] | None = None,
+        top_logprobs: int = 3,
+        validator: Callable[[object], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = 0,
     ) -> Models.ToolOutput:
@@ -676,28 +631,22 @@ class AsyncTheTool:
             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)
+            temperature: Controls randomness
             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
-                - process (str | None): Description of the process used
-                - processed_at (datetime): Timestamp when the processing occurred
-                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
-                - errors (list(str) | None): Errors occured during tool call
+            ToolOutput
         """
-        output = Models.ToolOutput()
+        tool_name = sys._getframe().f_code.co_name
+        prompt_file = tool_name + ".yaml"
+        start = perf_counter()
 
         try:
-            start = datetime.now()
-            output = await self._operator.run(
+            operator_output = await self._operator.run(
                 # User parameters
                 text=text,
                 number_of_questions=number_of_questions,
@@ -711,26 +660,28 @@ class AsyncTheTool:
                 max_validation_retries=max_validation_retries,
                 priority=priority,
                 # Internal parameters
-                prompt_file="subject_to_question.yaml",
-                output_model=Models.ReasonListStrOutput,
+                prompt_file=prompt_file,
+                output_model=Models.ReasonListStr,
                 mode=None,
             )
-            end = datetime.now()
-            output.execution_time = (end - start).total_seconds()
-            return output
-
-        except PromptError as e:
-            output.errors.append(f"Prompt error: {e}")
-        except LLMError as e:
-            output.errors.append(f"LLM error: {e}")
-        except ValidationError as e:
-            output.errors.append(f"Validation error: {e}")
-        except TextToolsError as e:
-            output.errors.append(f"TextTools error: {e}")
-        except Exception as e:
-            output.errors.append(f"Unexpected error: {e}")
-
-        return output
+
+            metadata = Models.ToolOutputMetadata(
+                tool_name=tool_name, execution_time=perf_counter() - start
+            )
+            tool_output = Models.ToolOutput(
+                result=operator_output.result,
+                logprobs=operator_output.logprobs,
+                analysis=operator_output.analysis,
+                metadata=metadata,
+            )
+
+        except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            metadata = Models.ToolOutputMetadata(tool_name=tool_name)
+            tool_output = Models.ToolOutput(
+                errors=[f"{type(e).__name__}: {e}"], metadata=metadata
+            )
+
+        return tool_output
 
     async def summarize(
         self,
@@ -740,8 +691,8 @@ class AsyncTheTool:
         user_prompt: str | None = None,
         temperature: float | None = 0.0,
         logprobs: bool = False,
-        top_logprobs: int | None = None,
-        validator: Callable[[Any], bool] | None = None,
+        top_logprobs: int = 3,
+        validator: Callable[[object], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = 0,
     ) -> Models.ToolOutput:
@@ -753,28 +704,22 @@ class AsyncTheTool:
             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)
+            temperature: Controls randomness
             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
-                - process (str | None): Description of the process used
-                - processed_at (datetime): Timestamp when the processing occurred
-                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
-                - errors (list(str) | None): Errors occured during tool call
+            ToolOutput
         """
-        output = Models.ToolOutput()
+        tool_name = sys._getframe().f_code.co_name
+        prompt_file = tool_name + ".yaml"
+        start = perf_counter()
 
         try:
-            start = datetime.now()
-            output = await self._operator.run(
+            operator_output = await self._operator.run(
                 # User parameters
                 text=text,
                 with_analysis=with_analysis,
@@ -787,37 +732,40 @@ class AsyncTheTool:
                 max_validation_retries=max_validation_retries,
                 priority=priority,
                 # Internal parameters
-                prompt_file="summarize.yaml",
-                output_model=Models.StrOutput,
+                prompt_file=prompt_file,
+                output_model=Models.Str,
                 mode=None,
             )
-            end = datetime.now()
-            output.execution_time = (end - start).total_seconds()
-            return output
-
-        except PromptError as e:
-            output.errors.append(f"Prompt error: {e}")
-        except LLMError as e:
-            output.errors.append(f"LLM error: {e}")
-        except ValidationError as e:
-            output.errors.append(f"Validation error: {e}")
-        except TextToolsError as e:
-            output.errors.append(f"TextTools error: {e}")
-        except Exception as e:
-            output.errors.append(f"Unexpected error: {e}")
-
-        return output
+
+            metadata = Models.ToolOutputMetadata(
+                tool_name=tool_name, execution_time=perf_counter() - start
+            )
+            tool_output = Models.ToolOutput(
+                result=operator_output.result,
+                logprobs=operator_output.logprobs,
+                analysis=operator_output.analysis,
+                metadata=metadata,
+            )
+
+        except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            metadata = Models.ToolOutputMetadata(tool_name=tool_name)
+            tool_output = Models.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,
-        validator: Callable[[Any], bool] | None = None,
+        top_logprobs: int = 3,
+        validator: Callable[[object], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = 0,
     ) -> Models.ToolOutput:
@@ -829,63 +777,104 @@ class AsyncTheTool:
         Arguments:
             text: The input text to translate
             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 for translation
-            temperature: Controls randomness (0.0 = deterministic, 1.0 = creative)
+            temperature: Controls randomness
             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
-                - process (str | None): Description of the process used
-                - processed_at (datetime): Timestamp when the processing occurred
-                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
-                - errors (list(str) | None): Errors occured during tool call
+            ToolOutput
         """
-        output = Models.ToolOutput()
+        tool_name = sys._getframe().f_code.co_name
+        prompt_file = tool_name + ".yaml"
+        start = perf_counter()
 
         try:
-            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,
+            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
+                        prompt_file=prompt_file,
+                        output_model=Models.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 = Models.ToolOutputMetadata(
+                    tool_name=tool_name, execution_time=perf_counter() - start
+                )
+                tool_output = Models.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
+                    prompt_file=prompt_file,
+                    output_model=Models.Str,
+                    mode=None,
+                    output_lang=None,
+                )
+
+                metadata = Models.ToolOutputMetadata(
+                    tool_name=tool_name, execution_time=perf_counter() - start
+                )
+                tool_output = Models.ToolOutput(
+                    result=operator_output.result,
+                    logprobs=operator_output.logprobs,
+                    analysis=operator_output.analysis,
+                    metadata=metadata,
+                )
+
+        except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            metadata = Models.ToolOutputMetadata(tool_name=tool_name)
+            tool_output = Models.ToolOutput(
+                errors=[f"{type(e).__name__}: {e}"], metadata=metadata
             )
-            end = datetime.now()
-            output.execution_time = (end - start).total_seconds()
-            return output
-
-        except PromptError as e:
-            output.errors.append(f"Prompt error: {e}")
-        except LLMError as e:
-            output.errors.append(f"LLM error: {e}")
-        except ValidationError as e:
-            output.errors.append(f"Validation error: {e}")
-        except TextToolsError as e:
-            output.errors.append(f"TextTools error: {e}")
-        except Exception as e:
-            output.errors.append(f"Unexpected error: {e}")
-
-        return output
+
+        return tool_output
 
     async def propositionize(
         self,
@@ -895,8 +884,8 @@ class AsyncTheTool:
         user_prompt: str | None = None,
         temperature: float | None = 0.0,
         logprobs: bool = False,
-        top_logprobs: int | None = None,
-        validator: Callable[[Any], bool] | None = None,
+        top_logprobs: int = 3,
+        validator: Callable[[object], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = 0,
     ) -> Models.ToolOutput:
@@ -910,28 +899,22 @@ class AsyncTheTool:
             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)
+            temperature: Controls randomness
             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]): The propositions
-                - logprobs (list | None): Probability data if logprobs enabled
-                - analysis (str | None): Detailed reasoning if with_analysis enabled
-                - process (str | None): Description of the process used
-                - processed_at (datetime): Timestamp when the processing occurred
-                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
-                - errors (list(str) | None): Errors occured during tool call
+            ToolOutput
         """
-        output = Models.ToolOutput()
+        tool_name = sys._getframe().f_code.co_name
+        prompt_file = tool_name + ".yaml"
+        start = perf_counter()
 
         try:
-            start = datetime.now()
-            output = await self._operator.run(
+            operator_output = await self._operator.run(
                 # User parameters
                 text=text,
                 with_analysis=with_analysis,
@@ -944,26 +927,28 @@ class AsyncTheTool:
                 max_validation_retries=max_validation_retries,
                 priority=priority,
                 # Internal parameters
-                prompt_file="propositionize.yaml",
-                output_model=Models.ListStrOutput,
+                prompt_file=prompt_file,
+                output_model=Models.ListStr,
                 mode=None,
             )
-            end = datetime.now()
-            output.execution_time = (end - start).total_seconds()
-            return output
-
-        except PromptError as e:
-            output.errors.append(f"Prompt error: {e}")
-        except LLMError as e:
-            output.errors.append(f"LLM error: {e}")
-        except ValidationError as e:
-            output.errors.append(f"Validation error: {e}")
-        except TextToolsError as e:
-            output.errors.append(f"TextTools error: {e}")
-        except Exception as e:
-            output.errors.append(f"Unexpected error: {e}")
-
-        return output
+
+            metadata = Models.ToolOutputMetadata(
+                tool_name=tool_name, execution_time=perf_counter() - start
+            )
+            tool_output = Models.ToolOutput(
+                result=operator_output.result,
+                logprobs=operator_output.logprobs,
+                analysis=operator_output.analysis,
+                metadata=metadata,
+            )
+
+        except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            metadata = Models.ToolOutputMetadata(tool_name=tool_name)
+            tool_output = Models.ToolOutput(
+                errors=[f"{type(e).__name__}: {e}"], metadata=metadata
+            )
+
+        return tool_output
 
     async def check_fact(
         self,
@@ -974,8 +959,8 @@ class AsyncTheTool:
         user_prompt: str | None = None,
         temperature: float | None = 0.0,
         logprobs: bool = False,
-        top_logprobs: int | None = None,
-        validator: Callable[[Any], bool] | None = None,
+        top_logprobs: int = 3,
+        validator: Callable[[object], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = 0,
     ) -> Models.ToolOutput:
@@ -990,28 +975,22 @@ class AsyncTheTool:
             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)
+            temperature: Controls randomness
             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): statement is relevant to source text or not
-                - logprobs (list | None): Probability data if logprobs enabled
-                - analysis (str | None): Detailed reasoning if with_analysis enabled
-                - process (str | None): Description of the process used
-                - processed_at (datetime): Timestamp when the processing occurred
-                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
-                - errors (list(str) | None): Errors occured during tool call
+            ToolOutput
         """
-        output = Models.ToolOutput()
+        tool_name = sys._getframe().f_code.co_name
+        prompt_file = tool_name + ".yaml"
+        start = perf_counter()
 
         try:
-            start = datetime.now()
-            output = await self._operator.run(
+            operator_output = await self._operator.run(
                 # User parameters
                 text=text,
                 with_analysis=with_analysis,
@@ -1024,38 +1003,41 @@ class AsyncTheTool:
                 max_validation_retries=max_validation_retries,
                 priority=priority,
                 # Internal parameters
-                prompt_file="check_fact.yaml",
-                output_model=Models.BoolOutput,
+                prompt_file=prompt_file,
+                output_model=Models.Bool,
                 mode=None,
                 source_text=source_text,
             )
-            end = datetime.now()
-            output.execution_time = (end - start).total_seconds()
-            return output
-        except PromptError as e:
-            output.errors.append(f"Prompt error: {e}")
-        except LLMError as e:
-            output.errors.append(f"LLM error: {e}")
-        except ValidationError as e:
-            output.errors.append(f"Validation error: {e}")
-        except TextToolsError as e:
-            output.errors.append(f"TextTools error: {e}")
-        except Exception as e:
-            output.errors.append(f"Unexpected error: {e}")
-
-        return output
+
+            metadata = Models.ToolOutputMetadata(
+                tool_name=tool_name, execution_time=perf_counter() - start
+            )
+            tool_output = Models.ToolOutput(
+                result=operator_output.result,
+                logprobs=operator_output.logprobs,
+                analysis=operator_output.analysis,
+                metadata=metadata,
+            )
+
+        except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            metadata = Models.ToolOutputMetadata(tool_name=tool_name)
+            tool_output = Models.ToolOutput(
+                errors=[f"{type(e).__name__}: {e}"], metadata=metadata
+            )
+
+        return tool_output
 
     async def run_custom(
         self,
         prompt: str,
-        output_model: Any,
+        output_model: object,
         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,
-        validator: Callable[[Any], bool] | None = None,
+        top_logprobs: int = 3,
+        validator: Callable[[object], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = 0,
     ) -> Models.ToolOutput:
@@ -1070,28 +1052,22 @@ class AsyncTheTool:
             with_analysis: Whether to include detailed reasoning analysis
             analyze_template: The analyze template used for reasoning analysis
             output_lang: Language for the output summary
-            temperature: Controls randomness (0.0 = deterministic, 1.0 = creative)
+            temperature: Controls randomness
             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
-                - process (str | None): Description of the process used
-                - processed_at (datetime): Timestamp when the processing occurred
-                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
-                - errors (list(str) | None): Errors occured during tool call
+            ToolOutput
         """
-        output = Models.ToolOutput()
+        tool_name = sys._getframe().f_code.co_name
+        prompt_file = tool_name + ".yaml"
+        start = perf_counter()
 
         try:
-            start = datetime.now()
-            output = await self._operator.run(
+            operator_output = await self._operator.run(
                 # User paramaeters
                 text=prompt,
                 output_model=output_model,
@@ -1106,23 +1082,25 @@ class AsyncTheTool:
                 max_validation_retries=max_validation_retries,
                 priority=priority,
                 # Internal parameters
-                prompt_file="run_custom.yaml",
+                prompt_file=prompt_file,
                 user_prompt=None,
                 mode=None,
             )
-            end = datetime.now()
-            output.execution_time = (end - start).total_seconds()
-            return output
-
-        except PromptError as e:
-            output.errors.append(f"Prompt error: {e}")
-        except LLMError as e:
-            output.errors.append(f"LLM error: {e}")
-        except ValidationError as e:
-            output.errors.append(f"Validation error: {e}")
-        except TextToolsError as e:
-            output.errors.append(f"TextTools error: {e}")
-        except Exception as e:
-            output.errors.append(f"Unexpected error: {e}")
-
-        return output
+
+            metadata = Models.ToolOutputMetadata(
+                tool_name=tool_name, execution_time=perf_counter() - start
+            )
+            tool_output = Models.ToolOutput(
+                result=operator_output.result,
+                logprobs=operator_output.logprobs,
+                analysis=operator_output.analysis,
+                metadata=metadata,
+            )
+
+        except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            metadata = Models.ToolOutputMetadata(tool_name=tool_name)
+            tool_output = Models.ToolOutput(
+                errors=[f"{type(e).__name__}: {e}"], metadata=metadata
+            )
+
+        return tool_output