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

{hamtaa_texttools-1.2.0.dist-info → hamtaa_texttools-1.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hamtaa-texttools
-Version: 1.2.0
+Version: 1.3.0
 Summary: A high-level NLP toolkit built on top of modern LLMs.
 Author-email: Tohidi <the.mohammad.tohidi@gmail.com>, Erfan Moosavi <erfanmoosavi84@gmail.com>, Montazer <montazerh82@gmail.com>, Givechi <mohamad.m.givechi@gmail.com>, Zareshahi <a.zareshahi1377@gmail.com>
 Maintainer-email: Erfan Moosavi <erfanmoosavi84@gmail.com>, Tohidi <the.mohammad.tohidi@gmail.com>
@@ -73,7 +73,7 @@ pip install -U hamtaa-texttools
 
 ---
 
-## ⚙️ `with_analysis`, `logprobs`, `output_lang`, `user_prompt`, `temperature`, `validator` and `priority` parameters
+## ⚙️ `with_analysis`, `logprobs`, `output_lang`, `user_prompt`, `temperature`, `validator`, `priority` and `timeout` parameters
 
 TextTools provides several optional flags to customize LLM behavior:
 
@@ -94,6 +94,10 @@ TextTools provides several optional flags to customize LLM behavior:
 - **`priority: int (Experimental)`** → Task execution priority level. Affects processing order in queues.
 **Note:** This feature works if it's supported by the model and vLLM.
 
+- **`timeout: float`** → Maximum time in seconds to wait for the response before raising a timeout error
+**Note:** This feature only exists in `AsyncTheTool`.
+
+
 ---
 
 ## 🧩 ToolOutput

{hamtaa_texttools-1.2.0.dist-info → hamtaa_texttools-1.3.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-hamtaa_texttools-1.2.0.dist-info/licenses/LICENSE,sha256=Hb2YOBKy2MJQLnyLrX37B4ZVuac8eaIcE71SvVIMOLg,1082
+hamtaa_texttools-1.3.0.dist-info/licenses/LICENSE,sha256=Hb2YOBKy2MJQLnyLrX37B4ZVuac8eaIcE71SvVIMOLg,1082
 texttools/__init__.py,sha256=4z7wInlrgbGSlWlXHQNeZMCGQH1sN2xtARsbgLHOLd8,283
 texttools/models.py,sha256=5eT2cSrFq8Xa38kANznV7gbi7lwB2PoDxciLKTpsd6c,2516
 texttools/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -7,7 +7,7 @@ texttools/batch/config.py,sha256=GDDXuhRZ_bOGVwSIlU4tWP247tx1_A7qzLJn7VqDyLU,105
 texttools/batch/manager.py,sha256=XZtf8UkdClfQlnRKne4nWEcFvdSKE67EamEePKy7jwI,8730
 texttools/batch/runner.py,sha256=9qxXIMfYRXW5SXDqqKtRr61rnQdYZkbCGqKImhSrY6I,9923
 texttools/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-texttools/core/engine.py,sha256=WhEtxZjYEbCnD0gExGRR4eSmAY4J05E9csovt2Qqlm8,9281
+texttools/core/engine.py,sha256=iRHdlIOPuUwIN6_72HNyTQQE7h_7xUZhC-WO-fDA5k8,9597
 texttools/core/exceptions.py,sha256=6SDjUL1rmd3ngzD3ytF4LyTRj3bQMSFR9ECrLoqXXHw,395
 texttools/core/internal_models.py,sha256=aExdLvhXhSev8NY1kuAJckeXdFBEisQtKZPxybd3rW8,1703
 texttools/core/operators/async_operator.py,sha256=wFs7eZ9QJrL0jBOu00YffgfPnIrCSavNjecSorXh-mE,6452
@@ -26,9 +26,9 @@ texttools/prompts/summarize.yaml,sha256=rPh060Bx_yI1W2JNg-nr83LUk9itatYLKM8ciH2p
 texttools/prompts/text_to_question.yaml,sha256=pUwPgK9l5f8S4E5fCht9JY7PFVK2aY1InPfASr7R5o4,1017
 texttools/prompts/translate.yaml,sha256=Dd5bs3O8SI-FlVSwHMYGeEjMmdOWeRlcfBHkhixCx7c,665
 texttools/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-texttools/tools/async_tools.py,sha256=DonASaaOPbWp7Gh1UY4RlP3yPoYTuhJtVmLns8KYupE,42949
-texttools/tools/sync_tools.py,sha256=y4nMlabgvRapb-YFoiGA5-5HflKrRHttiWSHpkg9tug,42742
-hamtaa_texttools-1.2.0.dist-info/METADATA,sha256=vN4XmIWdH6mdAGfgSkjRdQLEoFNzbhhH32jOyEv9H6w,7846
-hamtaa_texttools-1.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-hamtaa_texttools-1.2.0.dist-info/top_level.txt,sha256=5Mh0jIxxZ5rOXHGJ6Mp-JPKviywwN0MYuH0xk5bEWqE,10
-hamtaa_texttools-1.2.0.dist-info/RECORD,,
+texttools/tools/async_tools.py,sha256=2suwx8N0aRnowaSOpV6C57AqPlmQe5Z0Yx4E5QIMkmU,46939
+texttools/tools/sync_tools.py,sha256=mEuL-nlbxVW30dPE3hGkAUnYXbul-3gN2Le4CMVFCgU,42528
+hamtaa_texttools-1.3.0.dist-info/METADATA,sha256=_CXrOjvT2jwWcs1LHID0vVyo9eKlSIK_BzU8YUeNypo,8024
+hamtaa_texttools-1.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+hamtaa_texttools-1.3.0.dist-info/top_level.txt,sha256=5Mh0jIxxZ5rOXHGJ6Mp-JPKviywwN0MYuH0xk5bEWqE,10
+hamtaa_texttools-1.3.0.dist-info/RECORD,,

texttools/core/engine.py

@@ -1,3 +1,4 @@
+import asyncio
 import math
 import random
 import re
@@ -252,3 +253,12 @@ def text_to_chunks(text: str, size: int, overlap: int) -> list[str]:
         return final_chunks
 
     return _split_text(text, separators)
+
+
+async def run_with_timeout(coro, timeout: float | None):
+    if timeout is None:
+        return await coro
+    try:
+        return await asyncio.wait_for(coro, timeout=timeout)
+    except asyncio.TimeoutError:
+        raise TimeoutError(f"Operation exceeded timeout of {timeout} seconds")

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(

texttools/tools/sync_tools.py

@@ -1,4 +1,3 @@
-import sys
 from collections.abc import Callable
 from time import perf_counter
 from typing import Any, Literal
@@ -66,7 +65,7 @@ class TheTool:
             ToolOutput
 
         """
-        tool_name = sys._getframe().f_code.co_name
+        tool_name = "categorize"
         start = perf_counter()
 
         try:
@@ -198,7 +197,7 @@ class TheTool:
         Returns:
             ToolOutput
         """
-        tool_name = sys._getframe().f_code.co_name
+        tool_name = "extract_keywords"
         start = perf_counter()
 
         try:
@@ -211,7 +210,6 @@ class TheTool:
                 temperature=temperature,
                 logprobs=logprobs,
                 top_logprobs=top_logprobs,
-                mode=mode,
                 number_of_keywords=number_of_keywords,
                 validator=validator,
                 max_validation_retries=max_validation_retries,
@@ -219,6 +217,7 @@ class TheTool:
                 # Internal parameters
                 tool_name=tool_name,
                 output_model=ListStr,
+                mode=mode,
             )
 
             metadata = ToolOutputMetadata(
@@ -272,7 +271,7 @@ class TheTool:
         Returns:
             ToolOutput
         """
-        tool_name = sys._getframe().f_code.co_name
+        tool_name = "extract_entities"
         start = perf_counter()
 
         try:
@@ -343,7 +342,7 @@ class TheTool:
         Returns:
             ToolOutput
         """
-        tool_name = sys._getframe().f_code.co_name
+        tool_name = "is_question"
         start = perf_counter()
 
         try:
@@ -416,7 +415,7 @@ class TheTool:
         Returns:
             ToolOutput
         """
-        tool_name = sys._getframe().f_code.co_name
+        tool_name = "text_to_question"
         start = perf_counter()
 
         try:
@@ -489,7 +488,7 @@ class TheTool:
         Returns:
             ToolOutput
         """
-        tool_name = sys._getframe().f_code.co_name
+        tool_name = "merge_questions"
         start = perf_counter()
 
         try:
@@ -562,7 +561,7 @@ class TheTool:
         Returns:
             ToolOutput
         """
-        tool_name = sys._getframe().f_code.co_name
+        tool_name = "rewrite"
         start = perf_counter()
 
         try:
@@ -635,7 +634,7 @@ class TheTool:
         Returns:
             ToolOutput
         """
-        tool_name = sys._getframe().f_code.co_name
+        tool_name = "subject_to_question"
         start = perf_counter()
 
         try:
@@ -707,7 +706,7 @@ class TheTool:
         Returns:
             ToolOutput
         """
-        tool_name = sys._getframe().f_code.co_name
+        tool_name = "summarize"
         start = perf_counter()
 
         try:
@@ -782,7 +781,7 @@ class TheTool:
         Returns:
             ToolOutput
         """
-        tool_name = sys._getframe().f_code.co_name
+        tool_name = "translate"
         start = perf_counter()
 
         try:
@@ -900,7 +899,7 @@ class TheTool:
         Returns:
             ToolOutput
         """
-        tool_name = sys._getframe().f_code.co_name
+        tool_name = "propositionize"
         start = perf_counter()
 
         try:
@@ -961,7 +960,7 @@ class TheTool:
 
         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
@@ -975,13 +974,14 @@ class TheTool:
         Returns:
             ToolOutput
         """
-        tool_name = sys._getframe().f_code.co_name
+        tool_name = "check_fact"
         start = perf_counter()
 
         try:
             operator_output = self._operator.run(
                 # User parameters
                 text=text,
+                source_text=source_text,
                 with_analysis=with_analysis,
                 output_lang=output_lang,
                 user_prompt=user_prompt,
@@ -995,7 +995,6 @@ class TheTool:
                 tool_name=tool_name,
                 output_model=Bool,
                 mode=None,
-                source_text=source_text,
             )
 
             metadata = ToolOutputMetadata(
@@ -1049,7 +1048,7 @@ class TheTool:
         Returns:
             ToolOutput
         """
-        tool_name = sys._getframe().f_code.co_name
+        tool_name = "run_custom"
         start = perf_counter()
 
         try: