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

texttools/tools/async_tools.py

@@ -1,11 +1,10 @@
-import sys
 from collections.abc import Callable
 from time import perf_counter
 from typing import Any, Literal
 
 from openai import AsyncOpenAI
 
-from ..core.engine import text_to_chunks
+from ..core.engine import text_to_chunks, run_with_timeout
 from ..core.exceptions import LLMError, PromptError, TextToolsError, ValidationError
 from ..core.internal_models import (
     Bool,
@@ -44,6 +43,7 @@ class AsyncTheTool:
         validator: Callable[[Any], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = None,
+        timeout: float | None = None,
     ) -> ToolOutput:
         """
         Categorize a text into a category / category tree.
@@ -61,33 +61,37 @@ class AsyncTheTool:
             validator: Custom validation function to validate the output
             max_validation_retries: Maximum number of retry attempts if validation fails
             priority: Task execution priority (if enabled by vLLM and the model)
+            timeout: Maximum time in seconds to wait for the response before raising a timeout error
 
         Returns:
             ToolOutput
 
         """
-        tool_name = sys._getframe().f_code.co_name
+        tool_name = "categorize"
         start = perf_counter()
 
         try:
             if isinstance(categories, list):
-                operator_output = await self._operator.run(
-                    # User parameters
-                    text=text,
-                    category_list=categories,
-                    with_analysis=with_analysis,
-                    user_prompt=user_prompt,
-                    temperature=temperature,
-                    logprobs=logprobs,
-                    top_logprobs=top_logprobs,
-                    validator=validator,
-                    max_validation_retries=max_validation_retries,
-                    priority=priority,
-                    # Internal parameters
-                    tool_name=tool_name,
-                    output_model=create_dynamic_model(categories),
-                    mode=None,
-                    output_lang=None,
+                operator_output = await run_with_timeout(
+                    self._operator.run(
+                        # User parameters
+                        text=text,
+                        category_list=categories,
+                        with_analysis=with_analysis,
+                        user_prompt=user_prompt,
+                        temperature=temperature,
+                        logprobs=logprobs,
+                        top_logprobs=top_logprobs,
+                        validator=validator,
+                        max_validation_retries=max_validation_retries,
+                        priority=priority,
+                        # Internal parameters
+                        tool_name=tool_name,
+                        output_model=create_dynamic_model(categories),
+                        mode=None,
+                        output_lang=None,
+                    ),
+                    timeout=timeout,
                 )
 
                 metadata = ToolOutputMetadata(
@@ -117,23 +121,26 @@ class AsyncTheTool:
                     ]
                     category_names = list(parent_node.children.keys())
 
-                    level_operator_output = await self._operator.run(
-                        # User parameters
-                        text=text,
-                        category_list=category_list,
-                        with_analysis=with_analysis,
-                        user_prompt=user_prompt,
-                        temperature=temperature,
-                        logprobs=logprobs,
-                        top_logprobs=top_logprobs,
-                        validator=validator,
-                        max_validation_retries=max_validation_retries,
-                        priority=priority,
-                        # Internal parameters
-                        tool_name=tool_name,
-                        output_model=create_dynamic_model(category_names),
-                        mode=None,
-                        output_lang=None,
+                    level_operator_output = await run_with_timeout(
+                        self._operator.run(
+                            # User parameters
+                            text=text,
+                            category_list=category_list,
+                            with_analysis=with_analysis,
+                            user_prompt=user_prompt,
+                            temperature=temperature,
+                            logprobs=logprobs,
+                            top_logprobs=top_logprobs,
+                            validator=validator,
+                            max_validation_retries=max_validation_retries,
+                            priority=priority,
+                            # Internal parameters
+                            tool_name=tool_name,
+                            output_model=create_dynamic_model(category_names),
+                            mode=None,
+                            output_lang=None,
+                        ),
+                        timeout=timeout,
                     )
 
                     chosen_category = level_operator_output.result
@@ -179,6 +186,7 @@ class AsyncTheTool:
         validator: Callable[[Any], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = None,
+        timeout: float | None = None,
     ) -> ToolOutput:
         """
         Extract salient keywords from text.
@@ -194,31 +202,35 @@ class AsyncTheTool:
             validator: Custom validation function to validate the output
             max_validation_retries: Maximum number of retry attempts if validation fails
             priority: Task execution priority (if enabled by vLLM and the model)
+            timeout: Maximum time in seconds to wait for the response before raising a timeout error
 
         Returns:
             ToolOutput
         """
-        tool_name = sys._getframe().f_code.co_name
+        tool_name = "extract_keywords"
         start = perf_counter()
 
         try:
-            operator_output = await self._operator.run(
-                # User parameters
-                text=text,
-                with_analysis=with_analysis,
-                output_lang=output_lang,
-                user_prompt=user_prompt,
-                temperature=temperature,
-                logprobs=logprobs,
-                top_logprobs=top_logprobs,
-                mode=mode,
-                number_of_keywords=number_of_keywords,
-                validator=validator,
-                max_validation_retries=max_validation_retries,
-                priority=priority,
-                # Internal parameters
-                tool_name=tool_name,
-                output_model=ListStr,
+            operator_output = await run_with_timeout(
+                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,
+                    number_of_keywords=number_of_keywords,
+                    validator=validator,
+                    max_validation_retries=max_validation_retries,
+                    priority=priority,
+                    # Internal parameters
+                    tool_name=tool_name,
+                    output_model=ListStr,
+                    mode=mode,
+                ),
+                timeout=timeout,
             )
 
             metadata = ToolOutputMetadata(
@@ -252,6 +264,7 @@ class AsyncTheTool:
         validator: Callable[[Any], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = None,
+        timeout: float | None = None,
     ) -> ToolOutput:
         """
         Perform Named Entity Recognition (NER) over the input text.
@@ -268,32 +281,36 @@ class AsyncTheTool:
             validator: Custom validation function to validate the output
             max_validation_retries: Maximum number of retry attempts if validation fails
             priority: Task execution priority (if enabled by vLLM and the model)
+            timeout: Maximum time in seconds to wait for the response before raising a timeout error
 
         Returns:
             ToolOutput
         """
-        tool_name = sys._getframe().f_code.co_name
+        tool_name = "extract_entities"
         start = perf_counter()
 
         try:
-            operator_output = await self._operator.run(
-                # User parameters
-                text=text,
-                entities=entities
-                or "all named entities (e.g., PER, ORG, LOC, DAT, etc.)",
-                with_analysis=with_analysis,
-                output_lang=output_lang,
-                user_prompt=user_prompt,
-                temperature=temperature,
-                logprobs=logprobs,
-                top_logprobs=top_logprobs,
-                validator=validator,
-                max_validation_retries=max_validation_retries,
-                priority=priority,
-                # Internal parameters
-                tool_name=tool_name,
-                output_model=ListDictStrStr,
-                mode=None,
+            operator_output = await run_with_timeout(
+                self._operator.run(
+                    # User parameters
+                    text=text,
+                    entities=entities
+                    or "all named entities (e.g., PER, ORG, LOC, DAT, etc.)",
+                    with_analysis=with_analysis,
+                    output_lang=output_lang,
+                    user_prompt=user_prompt,
+                    temperature=temperature,
+                    logprobs=logprobs,
+                    top_logprobs=top_logprobs,
+                    validator=validator,
+                    max_validation_retries=max_validation_retries,
+                    priority=priority,
+                    # Internal parameters
+                    tool_name=tool_name,
+                    output_model=ListDictStrStr,
+                    mode=None,
+                ),
+                timeout=timeout,
             )
 
             metadata = ToolOutputMetadata(
@@ -325,6 +342,7 @@ class AsyncTheTool:
         validator: Callable[[Any], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = None,
+        timeout: float | None = None,
     ) -> ToolOutput:
         """
         Detect if the input is phrased as a question.
@@ -339,31 +357,34 @@ class AsyncTheTool:
             validator: Custom validation function to validate the output
             max_validation_retries: Maximum number of retry attempts if validation fails
             priority: Task execution priority (if enabled by vLLM and the model)
+            timeout: Maximum time in seconds to wait for the response before raising a timeout error
 
         Returns:
             ToolOutput
         """
-        tool_name = sys._getframe().f_code.co_name
-
+        tool_name = "is_question"
         start = perf_counter()
 
         try:
-            operator_output = await self._operator.run(
-                # User parameters
-                text=text,
-                with_analysis=with_analysis,
-                user_prompt=user_prompt,
-                temperature=temperature,
-                logprobs=logprobs,
-                top_logprobs=top_logprobs,
-                validator=validator,
-                max_validation_retries=max_validation_retries,
-                priority=priority,
-                # Internal parameters
-                tool_name=tool_name,
-                output_model=Bool,
-                mode=None,
-                output_lang=None,
+            operator_output = await run_with_timeout(
+                self._operator.run(
+                    # User parameters
+                    text=text,
+                    with_analysis=with_analysis,
+                    user_prompt=user_prompt,
+                    temperature=temperature,
+                    logprobs=logprobs,
+                    top_logprobs=top_logprobs,
+                    validator=validator,
+                    max_validation_retries=max_validation_retries,
+                    priority=priority,
+                    # Internal parameters
+                    tool_name=tool_name,
+                    output_model=Bool,
+                    mode=None,
+                    output_lang=None,
+                ),
+                timeout=timeout,
             )
 
             metadata = ToolOutputMetadata(
@@ -397,6 +418,7 @@ class AsyncTheTool:
         validator: Callable[[Any], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = None,
+        timeout: float | None = None,
     ) -> ToolOutput:
         """
         Generate a single question from the given text.
@@ -413,31 +435,35 @@ class AsyncTheTool:
             validator: Custom validation function to validate the output
             max_validation_retries: Maximum number of retry attempts if validation fails
             priority: Task execution priority (if enabled by vLLM and the model)
+            timeout: Maximum time in seconds to wait for the response before raising a timeout error
 
         Returns:
             ToolOutput
         """
-        tool_name = sys._getframe().f_code.co_name
+        tool_name = "text_to_question"
         start = perf_counter()
 
         try:
-            operator_output = await self._operator.run(
-                # User parameters
-                text=text,
-                number_of_questions=number_of_questions,
-                with_analysis=with_analysis,
-                output_lang=output_lang,
-                user_prompt=user_prompt,
-                temperature=temperature,
-                logprobs=logprobs,
-                top_logprobs=top_logprobs,
-                validator=validator,
-                max_validation_retries=max_validation_retries,
-                priority=priority,
-                # Internal parameters
-                tool_name=tool_name,
-                output_model=ReasonListStr,
-                mode=None,
+            operator_output = await run_with_timeout(
+                self._operator.run(
+                    # User parameters
+                    text=text,
+                    number_of_questions=number_of_questions,
+                    with_analysis=with_analysis,
+                    output_lang=output_lang,
+                    user_prompt=user_prompt,
+                    temperature=temperature,
+                    logprobs=logprobs,
+                    top_logprobs=top_logprobs,
+                    validator=validator,
+                    max_validation_retries=max_validation_retries,
+                    priority=priority,
+                    # Internal parameters
+                    tool_name=tool_name,
+                    output_model=ReasonListStr,
+                    mode=None,
+                ),
+                timeout=timeout,
             )
 
             metadata = ToolOutputMetadata(
@@ -471,6 +497,7 @@ class AsyncTheTool:
         validator: Callable[[Any], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = None,
+        timeout: float | None = None,
     ) -> ToolOutput:
         """
         Merge multiple questions into a single unified question.
@@ -486,31 +513,35 @@ class AsyncTheTool:
             validator: Custom validation function to validate the output
             max_validation_retries: Maximum number of retry attempts if validation fails
             priority: Task execution priority (if enabled by vLLM and the model)
+            timeout: Maximum time in seconds to wait for the response before raising a timeout error
 
         Returns:
             ToolOutput
         """
-        tool_name = sys._getframe().f_code.co_name
+        tool_name = "merge_questions"
         start = perf_counter()
 
         try:
             text = ", ".join(text)
-            operator_output = await self._operator.run(
-                # User parameters
-                text=text,
-                with_analysis=with_analysis,
-                output_lang=output_lang,
-                user_prompt=user_prompt,
-                temperature=temperature,
-                logprobs=logprobs,
-                top_logprobs=top_logprobs,
-                validator=validator,
-                max_validation_retries=max_validation_retries,
-                priority=priority,
-                # Internal parameters
-                tool_name=tool_name,
-                output_model=Str,
-                mode=mode,
+            operator_output = await run_with_timeout(
+                self._operator.run(
+                    # User parameters
+                    text=text,
+                    with_analysis=with_analysis,
+                    output_lang=output_lang,
+                    user_prompt=user_prompt,
+                    temperature=temperature,
+                    logprobs=logprobs,
+                    top_logprobs=top_logprobs,
+                    validator=validator,
+                    max_validation_retries=max_validation_retries,
+                    priority=priority,
+                    # Internal parameters
+                    tool_name=tool_name,
+                    output_model=Str,
+                    mode=mode,
+                ),
+                timeout=timeout,
             )
 
             metadata = ToolOutputMetadata(
@@ -544,6 +575,7 @@ class AsyncTheTool:
         validator: Callable[[Any], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = None,
+        timeout: float | None = None,
     ) -> ToolOutput:
         """
         Rewrite a text with different modes.
@@ -559,30 +591,34 @@ class AsyncTheTool:
             validator: Custom validation function to validate the output
             max_validation_retries: Maximum number of retry attempts if validation fails
             priority: Task execution priority (if enabled by vLLM and the model)
+            timeout: Maximum time in seconds to wait for the response before raising a timeout error
 
         Returns:
             ToolOutput
         """
-        tool_name = sys._getframe().f_code.co_name
+        tool_name = "rewrite"
         start = perf_counter()
 
         try:
-            operator_output = await self._operator.run(
-                # User parameters
-                text=text,
-                with_analysis=with_analysis,
-                output_lang=output_lang,
-                user_prompt=user_prompt,
-                temperature=temperature,
-                logprobs=logprobs,
-                top_logprobs=top_logprobs,
-                validator=validator,
-                max_validation_retries=max_validation_retries,
-                priority=priority,
-                # Internal parameters
-                tool_name=tool_name,
-                output_model=Str,
-                mode=mode,
+            operator_output = await run_with_timeout(
+                self._operator.run(
+                    # User parameters
+                    text=text,
+                    with_analysis=with_analysis,
+                    output_lang=output_lang,
+                    user_prompt=user_prompt,
+                    temperature=temperature,
+                    logprobs=logprobs,
+                    top_logprobs=top_logprobs,
+                    validator=validator,
+                    max_validation_retries=max_validation_retries,
+                    priority=priority,
+                    # Internal parameters
+                    tool_name=tool_name,
+                    output_model=Str,
+                    mode=mode,
+                ),
+                timeout=timeout,
             )
 
             metadata = ToolOutputMetadata(
@@ -616,6 +652,7 @@ class AsyncTheTool:
         validator: Callable[[Any], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = None,
+        timeout: float | None = None,
     ) -> ToolOutput:
         """
         Generate a list of questions about a subject.
@@ -632,31 +669,35 @@ class AsyncTheTool:
             validator: Custom validation function to validate the output
             max_validation_retries: Maximum number of retry attempts if validation fails
             priority: Task execution priority (if enabled by vLLM and the model)
+            timeout: Maximum time in seconds to wait for the response before raising a timeout error
 
         Returns:
             ToolOutput
         """
-        tool_name = sys._getframe().f_code.co_name
+        tool_name = "subject_to_question"
         start = perf_counter()
 
         try:
-            operator_output = await self._operator.run(
-                # User parameters
-                text=text,
-                number_of_questions=number_of_questions,
-                with_analysis=with_analysis,
-                output_lang=output_lang,
-                user_prompt=user_prompt,
-                temperature=temperature,
-                logprobs=logprobs,
-                top_logprobs=top_logprobs,
-                validator=validator,
-                max_validation_retries=max_validation_retries,
-                priority=priority,
-                # Internal parameters
-                tool_name=tool_name,
-                output_model=ReasonListStr,
-                mode=None,
+            operator_output = await run_with_timeout(
+                self._operator.run(
+                    # User parameters
+                    text=text,
+                    number_of_questions=number_of_questions,
+                    with_analysis=with_analysis,
+                    output_lang=output_lang,
+                    user_prompt=user_prompt,
+                    temperature=temperature,
+                    logprobs=logprobs,
+                    top_logprobs=top_logprobs,
+                    validator=validator,
+                    max_validation_retries=max_validation_retries,
+                    priority=priority,
+                    # Internal parameters
+                    tool_name=tool_name,
+                    output_model=ReasonListStr,
+                    mode=None,
+                ),
+                timeout=timeout,
             )
 
             metadata = ToolOutputMetadata(
@@ -689,6 +730,7 @@ class AsyncTheTool:
         validator: Callable[[Any], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = None,
+        timeout: float | None = None,
     ) -> ToolOutput:
         """
         Summarize the given subject text.
@@ -704,30 +746,34 @@ class AsyncTheTool:
             validator: Custom validation function to validate the output
             max_validation_retries: Maximum number of retry attempts if validation fails
             priority: Task execution priority (if enabled by vLLM and the model)
+            timeout: Maximum time in seconds to wait for the response before raising a timeout error
 
         Returns:
             ToolOutput
         """
-        tool_name = sys._getframe().f_code.co_name
+        tool_name = "summarize"
         start = perf_counter()
 
         try:
-            operator_output = await self._operator.run(
-                # User parameters
-                text=text,
-                with_analysis=with_analysis,
-                output_lang=output_lang,
-                user_prompt=user_prompt,
-                temperature=temperature,
-                logprobs=logprobs,
-                top_logprobs=top_logprobs,
-                validator=validator,
-                max_validation_retries=max_validation_retries,
-                priority=priority,
-                # Internal parameters
-                tool_name=tool_name,
-                output_model=Str,
-                mode=None,
+            operator_output = await run_with_timeout(
+                self._operator.run(
+                    # User parameters
+                    text=text,
+                    with_analysis=with_analysis,
+                    output_lang=output_lang,
+                    user_prompt=user_prompt,
+                    temperature=temperature,
+                    logprobs=logprobs,
+                    top_logprobs=top_logprobs,
+                    validator=validator,
+                    max_validation_retries=max_validation_retries,
+                    priority=priority,
+                    # Internal parameters
+                    tool_name=tool_name,
+                    output_model=Str,
+                    mode=None,
+                ),
+                timeout=timeout,
             )
 
             metadata = ToolOutputMetadata(
@@ -761,6 +807,7 @@ class AsyncTheTool:
         validator: Callable[[Any], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = None,
+        timeout: float | None = None,
     ) -> ToolOutput:
         """
         Translate text between languages.
@@ -779,11 +826,12 @@ class AsyncTheTool:
             validator: Custom validation function to validate the output
             max_validation_retries: Maximum number of retry attempts if validation fails
             priority: Task execution priority (if enabled by vLLM and the model)
+            timeout: Maximum time in seconds to wait for the response before raising a timeout error
 
         Returns:
             ToolOutput
         """
-        tool_name = sys._getframe().f_code.co_name
+        tool_name = "translate"
         start = perf_counter()
 
         try:
@@ -794,23 +842,26 @@ class AsyncTheTool:
                 logprobs_list = []
 
                 for chunk in chunks:
-                    chunk_operator_output = await self._operator.run(
-                        # User parameters
-                        text=chunk,
-                        target_language=target_language,
-                        with_analysis=with_analysis,
-                        user_prompt=user_prompt,
-                        temperature=temperature,
-                        logprobs=logprobs,
-                        top_logprobs=top_logprobs,
-                        validator=validator,
-                        max_validation_retries=max_validation_retries,
-                        priority=priority,
-                        # Internal parameters
-                        tool_name=tool_name,
-                        output_model=Str,
-                        mode=None,
-                        output_lang=None,
+                    chunk_operator_output = await run_with_timeout(
+                        self._operator.run(
+                            # User parameters
+                            text=chunk,
+                            target_language=target_language,
+                            with_analysis=with_analysis,
+                            user_prompt=user_prompt,
+                            temperature=temperature,
+                            logprobs=logprobs,
+                            top_logprobs=top_logprobs,
+                            validator=validator,
+                            max_validation_retries=max_validation_retries,
+                            priority=priority,
+                            # Internal parameters
+                            tool_name=tool_name,
+                            output_model=Str,
+                            mode=None,
+                            output_lang=None,
+                        ),
+                        timeout=timeout,
                     )
 
                     translation += chunk_operator_output.result + "\n"
@@ -831,23 +882,26 @@ class AsyncTheTool:
                 )
 
             else:
-                operator_output = await self._operator.run(
-                    # User parameters
-                    text=text,
-                    target_language=target_language,
-                    with_analysis=with_analysis,
-                    user_prompt=user_prompt,
-                    temperature=temperature,
-                    logprobs=logprobs,
-                    top_logprobs=top_logprobs,
-                    validator=validator,
-                    max_validation_retries=max_validation_retries,
-                    priority=priority,
-                    # Internal parameters
-                    tool_name=tool_name,
-                    output_model=Str,
-                    mode=None,
-                    output_lang=None,
+                operator_output = await run_with_timeout(
+                    self._operator.run(
+                        # User parameters
+                        text=text,
+                        target_language=target_language,
+                        with_analysis=with_analysis,
+                        user_prompt=user_prompt,
+                        temperature=temperature,
+                        logprobs=logprobs,
+                        top_logprobs=top_logprobs,
+                        validator=validator,
+                        max_validation_retries=max_validation_retries,
+                        priority=priority,
+                        # Internal parameters
+                        tool_name=tool_name,
+                        output_model=Str,
+                        mode=None,
+                        output_lang=None,
+                    ),
+                    timeout=timeout,
                 )
 
                 metadata = ToolOutputMetadata(
@@ -880,6 +934,7 @@ class AsyncTheTool:
         validator: Callable[[Any], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = None,
+        timeout: float | None = None,
     ) -> ToolOutput:
         """
         Proposition input text to meaningful sentences.
@@ -897,30 +952,34 @@ class AsyncTheTool:
             validator: Custom validation function to validate the output
             max_validation_retries: Maximum number of retry attempts if validation fails
             priority: Task execution priority (if enabled by vLLM and the model)
+            timeout: Maximum time in seconds to wait for the response before raising a timeout error
 
         Returns:
             ToolOutput
         """
-        tool_name = sys._getframe().f_code.co_name
+        tool_name = "propositionize"
         start = perf_counter()
 
         try:
-            operator_output = await self._operator.run(
-                # User parameters
-                text=text,
-                with_analysis=with_analysis,
-                output_lang=output_lang,
-                user_prompt=user_prompt,
-                temperature=temperature,
-                logprobs=logprobs,
-                top_logprobs=top_logprobs,
-                validator=validator,
-                max_validation_retries=max_validation_retries,
-                priority=priority,
-                # Internal parameters
-                tool_name=tool_name,
-                output_model=ListStr,
-                mode=None,
+            operator_output = await run_with_timeout(
+                self._operator.run(
+                    # User parameters
+                    text=text,
+                    with_analysis=with_analysis,
+                    output_lang=output_lang,
+                    user_prompt=user_prompt,
+                    temperature=temperature,
+                    logprobs=logprobs,
+                    top_logprobs=top_logprobs,
+                    validator=validator,
+                    max_validation_retries=max_validation_retries,
+                    priority=priority,
+                    # Internal parameters
+                    tool_name=tool_name,
+                    output_model=ListStr,
+                    mode=None,
+                ),
+                timeout=timeout,
             )
 
             metadata = ToolOutputMetadata(
@@ -954,6 +1013,7 @@ class AsyncTheTool:
         validator: Callable[[Any], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = None,
+        timeout: float | None = None,
     ) -> ToolOutput:
         """
         Checks wheather a statement is relevant to the source text or not.
@@ -962,7 +1022,7 @@ class AsyncTheTool:
 
         Arguments:
             text: The input text
-            source_text: the source text that we want to check relation of text to it
+            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
             user_prompt: Additional instructions
@@ -972,31 +1032,35 @@ class AsyncTheTool:
             validator: Custom validation function to validate the output
             max_validation_retries: Maximum number of retry attempts if validation fails
             priority: Task execution priority (if enabled by vLLM and the model)
+            timeout: Maximum time in seconds to wait for the response before raising a timeout error
 
         Returns:
             ToolOutput
         """
-        tool_name = sys._getframe().f_code.co_name
+        tool_name = "check_fact"
         start = perf_counter()
 
         try:
-            operator_output = await self._operator.run(
-                # User parameters
-                text=text,
-                with_analysis=with_analysis,
-                output_lang=output_lang,
-                user_prompt=user_prompt,
-                temperature=temperature,
-                logprobs=logprobs,
-                top_logprobs=top_logprobs,
-                validator=validator,
-                max_validation_retries=max_validation_retries,
-                priority=priority,
-                # Internal parameters
-                tool_name=tool_name,
-                output_model=Bool,
-                mode=None,
-                source_text=source_text,
+            operator_output = await run_with_timeout(
+                self._operator.run(
+                    # User parameters
+                    text=text,
+                    source_text=source_text,
+                    with_analysis=with_analysis,
+                    output_lang=output_lang,
+                    user_prompt=user_prompt,
+                    temperature=temperature,
+                    logprobs=logprobs,
+                    top_logprobs=top_logprobs,
+                    validator=validator,
+                    max_validation_retries=max_validation_retries,
+                    priority=priority,
+                    # Internal parameters
+                    tool_name=tool_name,
+                    output_model=Bool,
+                    mode=None,
+                ),
+                timeout=timeout,
             )
 
             metadata = ToolOutputMetadata(
@@ -1030,6 +1094,7 @@ class AsyncTheTool:
         validator: Callable[[Any], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = None,
+        timeout: float | None = None,
     ) -> ToolOutput:
         """
         Custom tool that can do almost anything!
@@ -1046,32 +1111,36 @@ class AsyncTheTool:
             validator: Custom validation function to validate the output
             max_validation_retries: Maximum number of retry attempts if validation fails
             priority: Task execution priority (if enabled by vLLM and the model)
+            timeout: Maximum time in seconds to wait for the response before raising a timeout error
 
         Returns:
             ToolOutput
         """
-        tool_name = sys._getframe().f_code.co_name
+        tool_name = "run_custom"
         start = perf_counter()
 
         try:
-            operator_output = await self._operator.run(
-                # User paramaeters
-                text=prompt,
-                output_model=output_model,
-                with_analysis=with_analysis,
-                analyze_template=analyze_template,
-                output_model_str=output_model.model_json_schema(),
-                output_lang=output_lang,
-                temperature=temperature,
-                logprobs=logprobs,
-                top_logprobs=top_logprobs,
-                validator=validator,
-                max_validation_retries=max_validation_retries,
-                priority=priority,
-                # Internal parameters
-                tool_name=tool_name,
-                user_prompt=None,
-                mode=None,
+            operator_output = await run_with_timeout(
+                self._operator.run(
+                    # User paramaeters
+                    text=prompt,
+                    output_model=output_model,
+                    with_analysis=with_analysis,
+                    analyze_template=analyze_template,
+                    output_model_str=output_model.model_json_schema(),
+                    output_lang=output_lang,
+                    temperature=temperature,
+                    logprobs=logprobs,
+                    top_logprobs=top_logprobs,
+                    validator=validator,
+                    max_validation_retries=max_validation_retries,
+                    priority=priority,
+                    # Internal parameters
+                    tool_name=tool_name,
+                    user_prompt=None,
+                    mode=None,
+                ),
+                timeout=timeout,
             )
 
             metadata = ToolOutputMetadata(