hamtaa-texttools 1.1.17__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__(
@@ -66,42 +65,99 @@ class AsyncTheTool:
                 - 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.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"
+        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,
@@ -110,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.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
+        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}")
 
-                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=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,
@@ -211,27 +229,43 @@ class AsyncTheTool:
                 - 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(
@@ -272,26 +306,42 @@ class AsyncTheTool:
                 - 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(
@@ -330,26 +380,42 @@ class AsyncTheTool:
                 - 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(
@@ -390,26 +456,42 @@ class AsyncTheTool:
                 - 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(
@@ -452,27 +534,43 @@ class AsyncTheTool:
                 - 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(
@@ -515,26 +613,42 @@ class AsyncTheTool:
                 - 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(
@@ -577,27 +691,43 @@ class AsyncTheTool:
                 - 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(
@@ -638,26 +768,42 @@ class AsyncTheTool:
                 - 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(
@@ -698,27 +844,43 @@ class AsyncTheTool:
                 - 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(
@@ -759,26 +921,42 @@ class AsyncTheTool:
                 - 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="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(
@@ -819,26 +997,42 @@ class AsyncTheTool:
                 - 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="propositionize.yaml",
-            output_model=Models.ListStrOutput,
-            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(
@@ -876,25 +1070,41 @@ class AsyncTheTool:
                 - 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