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

texttools/tools/sync_tools.py

@@ -4,19 +4,20 @@ from collections.abc import Callable
 
 from openai import OpenAI
 
-from texttools.tools.internals.sync_operator import Operator
-import texttools.tools.internals.models as Models
+from texttools.internals.sync_operator import Operator
+import texttools.internals.models as Models
+from texttools.internals.exceptions import (
+    TextToolsError,
+    PromptError,
+    LLMError,
+    ValidationError,
+)
 
 
 class TheTool:
     """
     Each method configures the operator with a specific YAML prompt,
     output schema, and flags, then delegates execution to `operator.run()`.
-
-    Usage:
-        client = OpenAI(...)
-        tool = TheTool(client, model="model-name")
-        result = tool.categorize("text ...", with_analysis=True)
     """
 
     def __init__(
@@ -43,6 +44,8 @@ class TheTool:
         """
         Categorize a text into a category / category tree.
 
+        Important Note: category_tree mode is EXPERIMENTAL, you can use it but it isn't reliable.
+
         Arguments:
             text: The input text to categorize
             categories: The category / category_tree to give to LLM
@@ -66,41 +69,97 @@ class TheTool:
                 - 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 = 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 = 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 = self._operator.run(
                     # User parameters
                     text=text,
-                    category_list=category_list,
+                    category_list=categories,
                     with_analysis=with_analysis,
                     user_prompt=user_prompt,
                     temperature=temperature,
@@ -112,65 +171,25 @@ class TheTool:
                     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
-
-                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 = 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,
-            )
-            end = datetime.now()
-            output.execution_time = (end - start).total_seconds()
-            return output
+        return output
 
     def extract_keywords(
         self,
@@ -212,27 +231,43 @@ class TheTool:
                 - 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 = 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 = 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
 
     def extract_entities(
@@ -273,26 +308,42 @@ class TheTool:
                 - 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 = 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 = 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
 
     def is_question(
@@ -331,26 +382,42 @@ class TheTool:
                 - 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 = 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 = 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
 
     def text_to_question(
@@ -391,26 +458,42 @@ class TheTool:
                 - 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 = 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 = 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
 
     def merge_questions(
@@ -453,27 +536,43 @@ class TheTool:
                 - 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 = ", ".join(text)
-        output = 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()
+        output = Models.ToolOutput()
+
+        try:
+            start = datetime.now()
+            text = ", ".join(text)
+            output = 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
 
     def rewrite(
@@ -516,26 +615,42 @@ class TheTool:
                 - 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 = 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 = 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
 
     def subject_to_question(
@@ -578,27 +693,43 @@ class TheTool:
                 - 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 = 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 = 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
 
     def summarize(
@@ -639,26 +770,42 @@ class TheTool:
                 - 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 = 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 = 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
 
     def translate(
@@ -677,6 +824,8 @@ class TheTool:
         """
         Translate text between languages.
 
+        Important Note: This tool is EXPERIMENTAL, you can use it but it isn't reliable.
+
         Arguments:
             text: The input text to translate
             target_language: The target language for translation
@@ -699,30 +848,46 @@ class TheTool:
                 - 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 = 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 = 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
 
-    def detect_entity(
+    def propositionize(
         self,
         text: str,
         with_analysis: bool = False,
@@ -736,7 +901,9 @@ class TheTool:
         priority: int | None = 0,
     ) -> Models.ToolOutput:
         """
-        Detects entities in a given text based on the entity_detector.yaml prompt.
+        Proposition input text to meaningful sentences.
+
+        Important Note: This tool is EXPERIMENTAL, you can use it but it isn't reliable.
 
         Arguments:
             text: The input text
@@ -752,7 +919,7 @@ class TheTool:
 
         Returns:
             ToolOutput: Object containing:
-                - result (list[Entity]): The entities
+                - 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
@@ -760,31 +927,48 @@ class TheTool:
                 - 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 = 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 = 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
 
-    def propositionize(
+    def check_fact(
         self,
         text: str,
+        source_text: str,
         with_analysis: bool = False,
         output_lang: str | None = None,
         user_prompt: str | None = None,
@@ -796,10 +980,13 @@ class TheTool:
         priority: int | None = 0,
     ) -> Models.ToolOutput:
         """
-        Proposition input text to meaningful sentences.
+        Checks wheather a statement is relevant to the source text or not.
+
+        Important Note: This tool is EXPERIMENTAL, you can use it but it isn't reliable.
 
         Arguments:
             text: The input text
+            source_text: the source text that we want to check relation of text to it
             with_analysis: Whether to include detailed reasoning analysis
             output_lang: Language for the output summary
             user_prompt: Additional instructions for summarization
@@ -812,7 +999,7 @@ class TheTool:
 
         Returns:
             ToolOutput: Object containing:
-                - result (list[str]): The propositions
+                - 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
@@ -820,32 +1007,50 @@ class TheTool:
                 - 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 = 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 = 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="check_fact.yaml",
+                output_model=Models.BoolOutput,
+                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
 
     def run_custom(
         self,
         prompt: str,
         output_model: Any,
+        with_analysis: bool = False,
+        analyze_template: str | None = None,
         output_lang: str | None = None,
         temperature: float | None = None,
         logprobs: bool | None = None,
@@ -857,8 +1062,13 @@ class TheTool:
         """
         Custom tool that can do almost anything!
 
+        Important Note: This tool is EXPERIMENTAL, you can use it but it isn't reliable.
+
         Arguments:
-            text: The user prompt
+            prompt: The user prompt
+            output_model: Pydantic BaseModel used for structured output
+            with_analysis: Whether to include detailed reasoning analysis
+            analyze_template: The analyze template used for reasoning analysis
             output_lang: Language for the output summary
             temperature: Controls randomness (0.0 = deterministic, 1.0 = creative)
             logprobs: Whether to return token probability information
@@ -877,25 +1087,42 @@ class TheTool:
                 - 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 = 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 = self._operator.run(
+                # User paramaeters
+                text=prompt,
+                output_model=output_model,
+                with_analysis=with_analysis,
+                analyze_template=analyze_template,
+                output_model_str=output_model.model_json_schema(),
+                output_lang=output_lang,
+                temperature=temperature,
+                logprobs=logprobs,
+                top_logprobs=top_logprobs,
+                validator=validator,
+                max_validation_retries=max_validation_retries,
+                priority=priority,
+                # Internal parameters
+                prompt_file="run_custom.yaml",
+                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