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

texttools/tools/async_tools.py

@@ -4,21 +4,20 @@ from collections.abc import Callable
 
 from openai import AsyncOpenAI
 
-from texttools.tools.internals.async_operator import AsyncOperator
-import texttools.tools.internals.models as Models
+from texttools.internals.async_operator import AsyncOperator
+import texttools.internals.models as Models
+from texttools.internals.exceptions import (
+    TextToolsError,
+    PromptError,
+    LLMError,
+    ValidationError,
+)
 
 
 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__(
@@ -62,43 +61,103 @@ class AsyncTheTool:
                 - 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
+
         """
-        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"
+        output = Models.ToolOutput()
+
+        try:
+            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.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
+                    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(
+                        # User parameters
+                        text=text,
+                        category_list=category_list,
+                        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),
+                        output_lang=None,
                     )
-                    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(
+
+                    # 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.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
+
+            else:
+                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,
@@ -107,66 +166,28 @@ class AsyncTheTool:
                     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),
+                    output_model=Models.create_dynamic_model(categories),
                     output_lang=None,
                 )
+                end = datetime.now()
+                output.execution_time = (end - start).total_seconds()
+                return output
 
-                # 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"
-                    )
-                    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
+        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}")
 
-            output.result = final_output
-            end = datetime.now()
-            output.execution_time = (end - start).total_seconds()
-            return output
-
-        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,
-            )
-            end = datetime.now()
-            output.execution_time = (end - start).total_seconds()
-            return output
+        return output
 
     async def extract_keywords(
         self,
@@ -203,29 +224,48 @@ class AsyncTheTool:
                 - 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
         """
-        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()
+        output = Models.ToolOutput()
+
+        try:
+            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
+
+        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
 
     async def extract_entities(
@@ -261,28 +301,47 @@ class AsyncTheTool:
                 - 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
         """
-        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()
+        output = Models.ToolOutput()
+
+        try:
+            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
+
+        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
 
     async def is_question(
@@ -316,28 +375,47 @@ class AsyncTheTool:
                 - 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
         """
-        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()
+        output = Models.ToolOutput()
+
+        try:
+            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
+
+        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
 
     async def text_to_question(
@@ -373,28 +451,47 @@ class AsyncTheTool:
                 - 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
         """
-        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()
+        output = Models.ToolOutput()
+
+        try:
+            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
+
+        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
 
     async def merge_questions(
@@ -432,29 +529,48 @@ class AsyncTheTool:
                 - 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
         """
-        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()
+        output = Models.ToolOutput()
+
+        try:
+            start = datetime.now()
+            text = ", ".join(text)
+            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="merge_questions.yaml",
+                output_model=Models.StrOutput,
+                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
 
     async def rewrite(
@@ -492,28 +608,47 @@ class AsyncTheTool:
                 - 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
         """
-        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()
+        output = Models.ToolOutput()
+
+        try:
+            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
+
+        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
 
     async def subject_to_question(
@@ -551,29 +686,48 @@ class AsyncTheTool:
                 - 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
         """
-        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()
+        output = Models.ToolOutput()
+
+        try:
+            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
+
+        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
 
     async def summarize(
@@ -609,28 +763,47 @@ class AsyncTheTool:
                 - 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
         """
-        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()
+        output = Models.ToolOutput()
+
+        try:
+            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
+
+        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
 
     async def translate(
@@ -666,29 +839,48 @@ class AsyncTheTool:
                 - 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
         """
-        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()
+        output = Models.ToolOutput()
+
+        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,
+            )
+            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
 
     async def detect_entity(
@@ -724,28 +916,123 @@ class AsyncTheTool:
                 - result (list[Entity]): The entities
                 - 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
+        """
+        output = Models.ToolOutput()
+
+        try:
+            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
+
+        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
+
+    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 | None = None,
+        validator: Callable[[Any], bool] | None = None,
+        max_validation_retries: int | None = None,
+        priority: int | None = 0,
+    ) -> Models.ToolOutput:
+        """
+        Proposition input text to meaningful sentences.
+
+        Arguments:
+            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)
+            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)
+
+        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
         """
-        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()
+        output = Models.ToolOutput()
+
+        try:
+            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="propositionize.yaml",
+                output_model=Models.ListStrOutput,
+                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
 
     async def run_custom(
@@ -778,27 +1065,46 @@ class AsyncTheTool:
                 - 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
         """
-        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()
+        output = Models.ToolOutput()
+
+        try:
+            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
+
+        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