hamtaa-texttools 2.0.0__py3-none-any.whl → 2.2.0__py3-none-any.whl

{hamtaa_texttools-2.0.0.dist-info → hamtaa_texttools-2.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hamtaa-texttools
-Version: 2.0.0
+Version: 2.2.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>
@@ -14,6 +14,7 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: dotenv>=0.9.9
 Requires-Dist: openai>=1.97.1
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: pyyaml>=6.0
@@ -28,7 +29,10 @@ Dynamic: license-file
 
 **TextTools** is a high-level **NLP toolkit** built on top of **LLMs**.  
 
-It provides both **sync (`TheTool`)** and **async (`AsyncTheTool`)** APIs for maximum flexibility.
+It provides three API styles for maximum flexibility:
+- Sync API (`TheTool`) - Simple, sequential operations
+- Async API (`AsyncTheTool`) - High-performance async operations
+- Batch API (`BatchTheTool`) - Process multiple texts in parallel with built-in concurrency control
 
 It provides ready-to-use utilities for **translation, question detection, categorization, NER extraction, and more** - designed to help you integrate AI-powered text processing into your applications with minimal effort.
 
@@ -68,8 +72,8 @@ pip install -U hamtaa-texttools
 
 | Status | Meaning | Tools | Safe for Production? |
 |--------|---------|----------|-------------------|
-| **✅ Production** | Evaluated and tested. | `categorize()` (list mode), `extract_keywords()`, `extract_entities()`, `is_question()`, `to_question()`, `merge_questions()`, `augment()`, `summarize()`, `run_custom()` | **Yes** - ready for reliable use. |
-| **🧪 Experimental** | Added to the package but **not fully evaluated**. | `categorize()` (tree mode), `translate()`, `propositionize()`, `is_fact()` | **Use with caution** |
+| **✅ Production** | Evaluated and tested. | `categorize()`, `extract_keywords()`, `extract_entities()`, `is_question()`, `to_question()`, `merge_questions()`, `augment()`, `summarize()`, `run_custom()` | **Yes** - ready for reliable use. |
+| **🧪 Experimental** | Added to the package but **not fully evaluated**. |  `translate()`, `propositionize()`, `is_fact()` | **Use with caution** |
 
 ---
 
@@ -95,6 +99,9 @@ pip install -U hamtaa-texttools
 - **`timeout: float`** → Maximum time in seconds to wait for the response before raising a timeout error.  
 **Note:** This feature is only available in `AsyncTheTool`.
 
+- **`raise_on_error: bool`** → (`TheTool/AsyncTheTool`) Raise errors (True) or return them in output (False). Default is True.
+
+- **`max_concurrency: int`** → (`BatchTheTool` only) Maximum number of concurrent API calls. Default is 5.
 
 ---
 
@@ -114,13 +121,16 @@ Every tool of `TextTools` returns a `ToolOutput` object which is a BaseModel wit
 - Verify operation success with the `is_successful()` method.
 - Convert output to a dictionary with the `to_dict()` method.
 
+**Note:** For BatchTheTool: Each method returns a list[ToolOutput] containing results for all input texts.
+
 ---
 
-## 🧨 Sync vs Async
-| Tool         | Style   | Use case                                    |
-|--------------|---------|---------------------------------------------|
-| `TheTool`    | Sync    | Simple scripts, sequential workflows        |
-| `AsyncTheTool` | Async | High-throughput apps, APIs, concurrent tasks |
+## 🧨 Sync vs Async vs Batch
+| Tool | Style | Use Case | Best For |
+|------|-------|----------|----------|
+| `TheTool` | **Sync** | Simple scripts, sequential workflows | • Quick prototyping<br>• Simple scripts<br>• Sequential processing<br>• Debugging |
+| `AsyncTheTool` | **Async** | High-throughput applications, APIs, concurrent tasks | • Web APIs<br>• Concurrent operations<br>• High-performance apps<br>• Real-time processing |
+| `BatchTheTool` | **Batch** | Process multiple texts efficiently with controlled concurrency | • Bulk processing<br>• Large datasets<br>• Parallel execution<br>• Resource optimization |
 
 ---
 
@@ -165,6 +175,35 @@ async def main():
 asyncio.run(main())
 ```
 
+## ⚡ Quick Start (Batch)
+
+```python
+import asyncio
+from openai import AsyncOpenAI
+from texttools import BatchTheTool
+
+async def main():
+    async_client = AsyncOpenAI(base_url="your_url", api_key="your_api_key")
+    model = "model_name"
+    
+    batch_the_tool = BatchTheTool(client=async_client, model=model, max_concurrency=3)
+    
+    categories = await batch_tool.categorize(
+        texts=[
+            "Climate change impacts on agriculture",
+            "Artificial intelligence in healthcare",
+            "Economic effects of remote work",
+            "Advancements in quantum computing",
+        ],
+        categories=["Science", "Technology", "Economics", "Environment"],
+    )
+    
+    for i, result in enumerate(categories):
+        print(f"Text {i+1}: {result.result}")
+
+asyncio.run(main())
+```
+
 ---
 
 ## ✅ Use Cases
@@ -173,11 +212,20 @@ Use **TextTools** when you need to:
 
 - 🔍 **Classify** large datasets quickly without model training   
 - 🧩 **Integrate** LLMs into production pipelines (structured outputs)  
-- 📊 **Analyze** large text collections using embeddings and categorization  
+- 📊 **Analyze** large text collections using embeddings and categorization
+
+---
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
 
 ---
 
 ## 🤝 Contributing
 
-Contributions are welcome!  
-Feel free to **open issues, suggest new features, or submit pull requests**.  
+We welcome contributions from the community! - see the [CONTRIBUTING](CONTRIBUTING.md) file for details.
+
+## 📚 Documentation
+
+For detailed documentation, architecture overview, and implementation details, please visit the [docs](docs) directory.

{hamtaa_texttools-2.0.0.dist-info → hamtaa_texttools-2.2.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
-hamtaa_texttools-2.0.0.dist-info/licenses/LICENSE,sha256=gqxbR8wqI3utd__l3Yn6_dQ3Pou1a17W4KmydbvZGok,1084
-texttools/__init__.py,sha256=AHpTq1BbL3sWCaFiIjlSkqNfNqweq-qm2EIOSmUZRJ0,175
+hamtaa_texttools-2.2.0.dist-info/licenses/LICENSE,sha256=gqxbR8wqI3utd__l3Yn6_dQ3Pou1a17W4KmydbvZGok,1084
+texttools/__init__.py,sha256=2bIFP0BdsDeOC7aQNTQjSX6OBmWQEweltUPRowwrhmg,236
 texttools/models.py,sha256=CQnO1zkKHFyqeMWrYGA4IyXQ7YYLVc3Xz1WaXbXzDLw,4634
 texttools/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 texttools/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -9,7 +9,7 @@ texttools/core/utils.py,sha256=jqXHXU1DWDKWhK0HHSjnjq4_TLg3FMcnRzrwTF1eqqc,9744
 texttools/core/operators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 texttools/core/operators/async_operator.py,sha256=HOi9gUwIffJUtyp8WLNbMpxI8jnafNDrbtLl6vyPcUs,6221
 texttools/core/operators/sync_operator.py,sha256=yM14fsku-4Nf60lPUVePaB9Lu8HbGKb4ubwoizVWuYQ,6126
-texttools/prompts/augment.yaml,sha256=O-LMVyrihr0GQ8hp2Lx6uIR8Jh83bUDS9UZ-dvYOP7k,5453
+texttools/prompts/augment.yaml,sha256=uJnnP-uEafiATdBx74LiOQWX6spvwcC0J-yfhySfoAM,5423
 texttools/prompts/categorize.yaml,sha256=kN4uRPOC7q6A13bdCIox60vZZ8sgRiTtquv-kqIvTsk,1133
 texttools/prompts/extract_entities.yaml,sha256=-qe1eEvN-8nJ2_GLjeoFAPVORCPYUzsIt7UGXD485bE,648
 texttools/prompts/extract_keywords.yaml,sha256=jP74HFa4Dka01d1COStEBbdzW5onqwocwyyVsmNpECs,3276
@@ -22,9 +22,10 @@ texttools/prompts/summarize.yaml,sha256=0aKYFRDxODqOOEhSexi-hn3twLwkMFVmi7rtAifn
 texttools/prompts/to_question.yaml,sha256=n8Bn28QjvSHwPHQLwRYpZ2IsaaBsq4pK9Dp_i0xk8eg,2210
 texttools/prompts/translate.yaml,sha256=omtC-TlFYMidy8WqRe7idUtKNiK4g3IhEl-iyufOwjk,649
 texttools/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-texttools/tools/async_tools.py,sha256=4-SwsjFqT_mGTK7reCqV-4VXxkyYkyuY3WYJcwkRMJs,44788
-texttools/tools/sync_tools.py,sha256=trmWBf4lvF9h_cB1DelOC4MFWDaQuQ0FDcdc-gCMVxo,40534
-hamtaa_texttools-2.0.0.dist-info/METADATA,sha256=NJYJ6K5HolttdX8_2rCq_w62N6k22mqu0hqO5Qhhy8I,6968
-hamtaa_texttools-2.0.0.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-hamtaa_texttools-2.0.0.dist-info/top_level.txt,sha256=5Mh0jIxxZ5rOXHGJ6Mp-JPKviywwN0MYuH0xk5bEWqE,10
-hamtaa_texttools-2.0.0.dist-info/RECORD,,
+texttools/tools/async_tools.py,sha256=_Dr5bo7RFp4f6eGNgNr549YIv5VoVpUq_ex_R5vsD2M,46087
+texttools/tools/batch_tools.py,sha256=hwWutcSWc2k79vZX5Urft1arTgHpDnnxztHZba54xtg,29899
+texttools/tools/sync_tools.py,sha256=UxXKUhnALoTCw2wpzfoBZVmhOZIGi6qv8tZAVXGIqFI,41833
+hamtaa_texttools-2.2.0.dist-info/METADATA,sha256=qnmDDJ24KJ6BI-kJ31vxaigEET0-gVM0DBBnOlL9B-M,8928
+hamtaa_texttools-2.2.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+hamtaa_texttools-2.2.0.dist-info/top_level.txt,sha256=5Mh0jIxxZ5rOXHGJ6Mp-JPKviywwN0MYuH0xk5bEWqE,10
+hamtaa_texttools-2.2.0.dist-info/RECORD,,

{hamtaa_texttools-2.0.0.dist-info → hamtaa_texttools-2.2.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.1)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

texttools/__init__.py

@@ -1,5 +1,6 @@
 from .models import CategoryTree
 from .tools.async_tools import AsyncTheTool
+from .tools.batch_tools import BatchTheTool
 from .tools.sync_tools import TheTool
 
-__all__ = ["CategoryTree", "AsyncTheTool", "TheTool"]
+__all__ = ["CategoryTree", "AsyncTheTool", "TheTool", "BatchTheTool"]

texttools/prompts/augment.yaml

@@ -38,25 +38,25 @@ main_template:
     "{text}"
 
   hard_negative: |
-      You are an AI assistant designed to generate high-quality training data for semantic text embedding models.
-      Your task is to create a hard-negative sample for a given "Anchor" text.
+    You are an AI assistant designed to generate high-quality training data for semantic text embedding models.
+    Your task is to create a hard-negative sample for a given "Anchor" text.
 
-      A high-quality hard-negative sample is a sentence that is topically related but semantically distinct from the Anchor.
-      It should share some context (e.g., same domain, same entities) but differ in a crucial piece of information, action, conclusion, or specific detail.
+    A high-quality hard-negative sample is a sentence that is topically related but semantically distinct from the Anchor.
+    It should share some context (e.g., same domain, same entities) but differ in a crucial piece of information, action, conclusion, or specific detail.
 
-      Instructions:
-      - Stay in General Domain: Remain in the same broad domain (e.g., religious topics), but choose a completely different subject matter.
-      - Maintain Topical Overlap: Keep the same domain, subject, or entities (e.g., people, products, concepts) as the Anchor.
-      - Alter a Key Semantic Element: Reverse a key word or condition or place or proper name that completely reverses the meaning of the sentence.
-      - Avoid Being a Paraphrase: The sentence must NOT be semantically equivalent. The core factual claim or intent must be different.
-      - Make it Challenging: The difference should be subtle enough that it requires a deep understanding of the text to identify, not just a simple keyword mismatch.
-      - Maintain Similar Length: The generated sentence should be of roughly the same length and level of detail as the Anchor.
+    Instructions:
+    - Stay in General Domain: Remain in the same broad domain (e.g., religious topics), but choose a completely different subject matter.
+    - Maintain Topical Overlap: Keep the same domain, subject, or entities (e.g., people, products, concepts) as the Anchor.
+    - Alter a Key Semantic Element: Reverse a key word or condition or place or proper name that completely reverses the meaning of the sentence.
+    - Avoid Being a Paraphrase: The sentence must NOT be semantically equivalent. The core factual claim or intent must be different.
+    - Make it Challenging: The difference should be subtle enough that it requires a deep understanding of the text to identify, not just a simple keyword mismatch.
+    - Maintain Similar Length: The generated sentence should be of roughly the same length and level of detail as the Anchor.
 
-      Respond only in JSON format:
-      {{"result": "rewriteen_text"}}
+    Respond only in JSON format:
+    {{"result": "rewriteen_text"}}
 
-      Anchor Text:
-      "{text}"
+    Anchor Text:
+    "{text}"
 
 
 analyze_template:

texttools/tools/async_tools.py

@@ -1,3 +1,4 @@
+import logging
 from collections.abc import Callable
 from time import perf_counter
 from typing import Any, Literal
@@ -23,8 +24,11 @@ class AsyncTheTool:
         self,
         client: AsyncOpenAI,
         model: str,
+        raise_on_error: bool = True,
     ):
         self._operator = AsyncOperator(client=client, model=model)
+        self.logger = logging.getLogger(self.__class__.__name__)
+        self.raise_on_error = raise_on_error
 
     async def categorize(
         self,
@@ -43,8 +47,6 @@ class AsyncTheTool:
         """
         Classify text into given categories
 
-        Important Note: category_tree mode is EXPERIMENTAL, you can use it but it isn't reliable.
-
         Arguments:
             text: The input text
             categories: The category list / category tree
@@ -60,7 +62,6 @@ class AsyncTheTool:
 
         Returns:
             ToolOutput
-
         """
         tool_name = "categorize"
         start = perf_counter()
@@ -160,6 +161,11 @@ class AsyncTheTool:
                 )
 
         except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            self.logger.error(str(e))
+
+            if self.raise_on_error:
+                raise
+
             metadata = ToolOutputMetadata(tool_name=tool_name)
             tool_output = ToolOutput(
                 errors=[f"{type(e).__name__}: {e}"], metadata=metadata
@@ -241,6 +247,11 @@ class AsyncTheTool:
             )
 
         except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            self.logger.error(str(e))
+
+            if self.raise_on_error:
+                raise
+
             metadata = ToolOutputMetadata(tool_name=tool_name)
             tool_output = ToolOutput(
                 errors=[f"{type(e).__name__}: {e}"], metadata=metadata
@@ -320,6 +331,11 @@ class AsyncTheTool:
             )
 
         except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            self.logger.error(str(e))
+
+            if self.raise_on_error:
+                raise
+
             metadata = ToolOutputMetadata(tool_name=tool_name)
             tool_output = ToolOutput(
                 errors=[f"{type(e).__name__}: {e}"], metadata=metadata
@@ -394,6 +410,11 @@ class AsyncTheTool:
             )
 
         except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            self.logger.error(str(e))
+
+            if self.raise_on_error:
+                raise
+
             metadata = ToolOutputMetadata(tool_name=tool_name)
             tool_output = ToolOutput(
                 errors=[f"{type(e).__name__}: {e}"], metadata=metadata
@@ -475,6 +496,11 @@ class AsyncTheTool:
             )
 
         except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            self.logger.error(str(e))
+
+            if self.raise_on_error:
+                raise
+
             metadata = ToolOutputMetadata(tool_name=tool_name)
             tool_output = ToolOutput(
                 errors=[f"{type(e).__name__}: {e}"], metadata=metadata
@@ -554,6 +580,11 @@ class AsyncTheTool:
             )
 
         except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            self.logger.error(str(e))
+
+            if self.raise_on_error:
+                raise
+
             metadata = ToolOutputMetadata(tool_name=tool_name)
             tool_output = ToolOutput(
                 errors=[f"{type(e).__name__}: {e}"], metadata=metadata
@@ -632,6 +663,11 @@ class AsyncTheTool:
             )
 
         except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            self.logger.error(str(e))
+
+            if self.raise_on_error:
+                raise
+
             metadata = ToolOutputMetadata(tool_name=tool_name)
             tool_output = ToolOutput(
                 errors=[f"{type(e).__name__}: {e}"], metadata=metadata
@@ -708,6 +744,11 @@ class AsyncTheTool:
             )
 
         except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            self.logger.error(str(e))
+
+            if self.raise_on_error:
+                raise
+
             metadata = ToolOutputMetadata(tool_name=tool_name)
             tool_output = ToolOutput(
                 errors=[f"{type(e).__name__}: {e}"], metadata=metadata
@@ -836,6 +877,11 @@ class AsyncTheTool:
                 )
 
         except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            self.logger.error(str(e))
+
+            if self.raise_on_error:
+                raise
+
             metadata = ToolOutputMetadata(tool_name=tool_name)
             tool_output = ToolOutput(
                 errors=[f"{type(e).__name__}: {e}"], metadata=metadata
@@ -914,6 +960,11 @@ class AsyncTheTool:
             )
 
         except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            self.logger.error(str(e))
+
+            if self.raise_on_error:
+                raise
+
             metadata = ToolOutputMetadata(tool_name=tool_name)
             tool_output = ToolOutput(
                 errors=[f"{type(e).__name__}: {e}"], metadata=metadata
@@ -995,6 +1046,11 @@ class AsyncTheTool:
             )
 
         except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            self.logger.error(str(e))
+
+            if self.raise_on_error:
+                raise
+
             metadata = ToolOutputMetadata(tool_name=tool_name)
             tool_output = ToolOutput(
                 errors=[f"{type(e).__name__}: {e}"], metadata=metadata
@@ -1075,6 +1131,11 @@ class AsyncTheTool:
             )
 
         except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            self.logger.error(str(e))
+
+            if self.raise_on_error:
+                raise
+
             metadata = ToolOutputMetadata(tool_name=tool_name)
             tool_output = ToolOutput(
                 errors=[f"{type(e).__name__}: {e}"], metadata=metadata

texttools/tools/batch_tools.py

@@ -0,0 +1,688 @@
+import asyncio
+from typing import Any, Callable, Literal
+
+from openai import AsyncOpenAI
+
+from ..models import CategoryTree, ToolOutput
+from .async_tools import AsyncTheTool
+
+
+class BatchTheTool:
+    def __init__(
+        self,
+        client: AsyncOpenAI,
+        model: str,
+        raise_on_error: bool = True,
+        max_concurrency: int = 5,
+    ):
+        self.tool = AsyncTheTool(client, model, raise_on_error)
+        self.semaphore = asyncio.Semaphore(max_concurrency)
+
+    async def categorize(
+        self,
+        texts: list[str],
+        categories: list[str] | CategoryTree,
+        with_analysis: bool = False,
+        user_prompt: str | None = None,
+        temperature: float | None = 0.0,
+        logprobs: bool = False,
+        top_logprobs: int = 3,
+        validator: Callable[[Any], bool] | None = None,
+        max_validation_retries: int | None = None,
+        priority: int | None = None,
+        timeout: float | None = None,
+    ) -> list[ToolOutput]:
+        """
+        Classify texts into given categories
+
+        Arguments:
+            texts: The input texts
+            categories: The category list / category tree
+            with_analysis: Adds a reasoning step before generating the final output. Note: This doubles token usage per call
+            user_prompt: Additional instructions
+            temperature: Controls randomness
+            logprobs: Whether to return token probability information
+            top_logprobs: Number of top token alternatives to return if logprobs enabled
+            validator: Custom validation function to validate the output
+            max_validation_retries: Maximum number of retry attempts if validation fails
+            priority: Task execution priority (if enabled by vLLM and the model)
+            timeout: Maximum time in seconds to wait for the response before raising a timeout error
+
+        Returns:
+            list[ToolOutput]
+        """
+
+        async def _throttled_task(text: str) -> ToolOutput:
+            async with self.semaphore:
+                return await self.tool.categorize(
+                    text=text,
+                    categories=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,
+                    timeout=timeout,
+                )
+
+        tasks = [_throttled_task(t) for t in texts]
+        return await asyncio.gather(*tasks)
+
+    async def extract_keywords(
+        self,
+        texts: list[str],
+        mode: Literal["auto", "threshold", "count"],
+        number_of_keywords: int | None = None,
+        with_analysis: bool = False,
+        output_lang: str | None = None,
+        user_prompt: str | None = None,
+        temperature: float | None = 0.0,
+        logprobs: bool = False,
+        top_logprobs: int = 3,
+        validator: Callable[[Any], bool] | None = None,
+        max_validation_retries: int | None = None,
+        priority: int | None = None,
+        timeout: float | None = None,
+    ) -> list[ToolOutput]:
+        """
+        Extract keywords from the texts
+
+        Arguments:
+            texts: The input texts
+            mode: auto -> decide n of keywords automatically, threshold -> decide n of keywords by a threshold, count -> takes number of keywords as the parameter
+            number_of_keywords: Must be set only when using "count" mode
+            with_analysis: Adds a reasoning step before generating the final output. Note: This doubles token usage per call
+            output_lang: Forces the model to respond in a specific language
+            user_prompt: Additional instructions
+            temperature: Controls randomness
+            logprobs: Whether to return token probability information
+            top_logprobs: Number of top token alternatives to return if logprobs enabled
+            validator: Custom validation function to validate the output
+            max_validation_retries: Maximum number of retry attempts if validation fails
+            priority: Task execution priority (if enabled by vLLM and the model)
+            timeout: Maximum time in seconds to wait for the response before raising a timeout error
+
+        Returns:
+            list[ToolOutput]
+        """
+
+        async def _throttled_task(text: str) -> ToolOutput:
+            async with self.semaphore:
+                return await self.tool.extract_keywords(
+                    text=text,
+                    mode=mode,
+                    number_of_keywords=number_of_keywords,
+                    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,
+                    timeout=timeout,
+                )
+
+        tasks = [_throttled_task(t) for t in texts]
+        return await asyncio.gather(*tasks)
+
+    async def extract_entities(
+        self,
+        texts: list[str],
+        entities: list[str] = ["all named entities"],
+        with_analysis: bool = False,
+        output_lang: str | None = None,
+        user_prompt: str | None = None,
+        temperature: float | None = 0.0,
+        logprobs: bool = False,
+        top_logprobs: int = 3,
+        validator: Callable[[Any], bool] | None = None,
+        max_validation_retries: int | None = None,
+        priority: int | None = None,
+        timeout: float | None = None,
+    ) -> list[ToolOutput]:
+        """
+        Perform Named Entity Recognition (NER) on texts
+
+        Arguments:
+            texts: The input texts
+            entities: List of entities
+            with_analysis: Adds a reasoning step before generating the final output. Note: This doubles token usage per call
+            output_lang: Forces the model to respond in a specific language
+            user_prompt: Additional instructions
+            temperature: Controls randomness
+            logprobs: Whether to return token probability information
+            top_logprobs: Number of top token alternatives to return if logprobs enabled
+            validator: Custom validation function to validate the output
+            max_validation_retries: Maximum number of retry attempts if validation fails
+            priority: Task execution priority (if enabled by vLLM and the model)
+            timeout: Maximum time in seconds to wait for the response before raising a timeout error
+
+        Returns:
+            list[ToolOutput]
+        """
+
+        async def _throttled_task(text: str) -> ToolOutput:
+            async with self.semaphore:
+                return await self.tool.extract_entities(
+                    text=text,
+                    entities=entities,
+                    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,
+                    timeout=timeout,
+                )
+
+        tasks = [_throttled_task(t) for t in texts]
+        return await asyncio.gather(*tasks)
+
+    async def is_question(
+        self,
+        texts: list[str],
+        with_analysis: bool = False,
+        user_prompt: str | None = None,
+        temperature: float | None = 0.0,
+        logprobs: bool = False,
+        top_logprobs: int = 3,
+        validator: Callable[[Any], bool] | None = None,
+        max_validation_retries: int | None = None,
+        priority: int | None = None,
+        timeout: float | None = None,
+    ) -> list[ToolOutput]:
+        """
+        Detect if the inputs are phrased as questions.
+
+        Arguments:
+            texts: The input texts
+            with_analysis: Adds a reasoning step before generating the final output. Note: This doubles token usage per call
+            user_prompt: Additional instructions
+            temperature: Controls randomness
+            logprobs: Whether to return token probability information
+            top_logprobs: Number of top token alternatives to return if logprobs enabled
+            validator: Custom validation function to validate the output
+            max_validation_retries: Maximum number of retry attempts if validation fails
+            priority: Task execution priority (if enabled by vLLM and the model)
+            timeout: Maximum time in seconds to wait for the response before raising a timeout error
+
+        Returns:
+            list[ToolOutput]
+        """
+
+        async def _throttled_task(text: str) -> ToolOutput:
+            async with self.semaphore:
+                return await self.tool.is_question(
+                    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,
+                    timeout=timeout,
+                )
+
+        tasks = [_throttled_task(t) for t in texts]
+        return await asyncio.gather(*tasks)
+
+    async def to_question(
+        self,
+        texts: list[str],
+        number_of_questions: int,
+        mode: Literal["from_text", "from_subject"],
+        with_analysis: bool = False,
+        output_lang: str | None = None,
+        user_prompt: str | None = None,
+        temperature: float | None = 0.0,
+        logprobs: bool = False,
+        top_logprobs: int = 3,
+        validator: Callable[[Any], bool] | None = None,
+        max_validation_retries: int | None = None,
+        priority: int | None = None,
+        timeout: float | None = None,
+    ) -> list[ToolOutput]:
+        """
+        Generate questions from the given texts / subjects
+
+        Arguments:
+            texts: The input texts
+            mode: from_text -> generate questions from an answer, from_subject -> generate questions from a subject
+            number_of_questions: Number of questions to generate
+            with_analysis: Adds a reasoning step before generating the final output. Note: This doubles token usage per call
+            output_lang: Forces the model to respond in a specific language
+            user_prompt: Additional instructions
+            temperature: Controls randomness
+            logprobs: Whether to return token probability information
+            top_logprobs: Number of top token alternatives to return if logprobs enabled
+            validator: Custom validation function to validate the output
+            max_validation_retries: Maximum number of retry attempts if validation fails
+            priority: Task execution priority (if enabled by vLLM and the model)
+            timeout: Maximum time in seconds to wait for the response before raising a timeout error
+
+        Returns:
+            list[ToolOutput]
+        """
+
+        async def _throttled_task(text: str) -> ToolOutput:
+            async with self.semaphore:
+                return await self.tool.to_question(
+                    text=text,
+                    number_of_questions=number_of_questions,
+                    mode=mode,
+                    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,
+                    timeout=timeout,
+                )
+
+        tasks = [_throttled_task(t) for t in texts]
+        return await asyncio.gather(*tasks)
+
+    async def merge_questions(
+        self,
+        texts_list: list[list[str]],
+        mode: Literal["simple", "stepwise"],
+        with_analysis: bool = False,
+        output_lang: str | None = None,
+        user_prompt: str | None = None,
+        temperature: float | None = 0.0,
+        logprobs: bool = False,
+        top_logprobs: int = 3,
+        validator: Callable[[Any], bool] | None = None,
+        max_validation_retries: int | None = None,
+        priority: int | None = None,
+        timeout: float | None = None,
+    ) -> list[ToolOutput]:
+        """
+        Merge multiple questions into a single unified question for each group
+
+        Arguments:
+            texts_list: List of groups of questions to merge
+            mode: simple -> regular question merging, stepwise -> merge questions in two steps
+            with_analysis: Adds a reasoning step before generating the final output. Note: This doubles token usage per call
+            output_lang: Forces the model to respond in a specific language
+            user_prompt: Additional instructions
+            temperature: Controls randomness
+            logprobs: Whether to return token probability information
+            top_logprobs: Number of top token alternatives to return if logprobs enabled
+            validator: Custom validation function to validate the output
+            max_validation_retries: Maximum number of retry attempts if validation fails
+            priority: Task execution priority (if enabled by vLLM and the model)
+            timeout: Maximum time in seconds to wait for the response before raising a timeout error
+
+        Returns:
+            list[ToolOutput]
+        """
+
+        async def _throttled_task(texts: list[str]) -> ToolOutput:
+            async with self.semaphore:
+                return await self.tool.merge_questions(
+                    text=texts,
+                    mode=mode,
+                    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,
+                    timeout=timeout,
+                )
+
+        tasks = [_throttled_task(t) for t in texts_list]
+        return await asyncio.gather(*tasks)
+
+    async def augment(
+        self,
+        texts: list[str],
+        mode: Literal["positive", "negative", "hard_negative"],
+        with_analysis: bool = False,
+        output_lang: str | None = None,
+        user_prompt: str | None = None,
+        temperature: float | None = 0.0,
+        logprobs: bool = False,
+        top_logprobs: int = 3,
+        validator: Callable[[Any], bool] | None = None,
+        max_validation_retries: int | None = None,
+        priority: int | None = None,
+        timeout: float | None = None,
+    ) -> list[ToolOutput]:
+        """
+        Rewrite texts in different augmentations
+
+        Arguments:
+            texts: The input texts
+            mode: positive -> positive augmentation, negative -> negative augmentation, hard_negative -> hard negative augmentation
+            with_analysis: Adds a reasoning step before generating the final output. Note: This doubles token usage per call
+            output_lang: Forces the model to respond in a specific language
+            user_prompt: Additional instructions
+            temperature: Controls randomness
+            logprobs: Whether to return token probability information
+            top_logprobs: Number of top token alternatives to return if logprobs enabled
+            validator: Custom validation function to validate the output
+            max_validation_retries: Maximum number of retry attempts if validation fails
+            priority: Task execution priority (if enabled by vLLM and the model)
+            timeout: Maximum time in seconds to wait for the response before raising a timeout error
+
+        Returns:
+            list[ToolOutput]
+        """
+
+        async def _throttled_task(text: str) -> ToolOutput:
+            async with self.semaphore:
+                return await self.tool.augment(
+                    text=text,
+                    mode=mode,
+                    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,
+                    timeout=timeout,
+                )
+
+        tasks = [_throttled_task(t) for t in texts]
+        return await asyncio.gather(*tasks)
+
+    async def summarize(
+        self,
+        texts: list[str],
+        with_analysis: bool = False,
+        output_lang: str | None = None,
+        user_prompt: str | None = None,
+        temperature: float | None = 0.0,
+        logprobs: bool = False,
+        top_logprobs: int = 3,
+        validator: Callable[[Any], bool] | None = None,
+        max_validation_retries: int | None = None,
+        priority: int | None = None,
+        timeout: float | None = None,
+    ) -> list[ToolOutput]:
+        """
+        Summarize the given texts
+
+        Arguments:
+            texts: The input texts
+            with_analysis: Adds a reasoning step before generating the final output. Note: This doubles token usage per call
+            output_lang: Forces the model to respond in a specific language
+            user_prompt: Additional instructions
+            temperature: Controls randomness
+            logprobs: Whether to return token probability information
+            top_logprobs: Number of top token alternatives to return if logprobs enabled
+            validator: Custom validation function to validate the output
+            max_validation_retries: Maximum number of retry attempts if validation fails
+            priority: Task execution priority (if enabled by vLLM and the model)
+            timeout: Maximum time in seconds to wait for the response before raising a timeout error
+
+        Returns:
+            list[ToolOutput]
+        """
+
+        async def _throttled_task(text: str) -> ToolOutput:
+            async with self.semaphore:
+                return await self.tool.summarize(
+                    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,
+                    timeout=timeout,
+                )
+
+        tasks = [_throttled_task(t) for t in texts]
+        return await asyncio.gather(*tasks)
+
+    async def translate(
+        self,
+        texts: list[str],
+        target_lang: str,
+        use_chunker: bool = True,
+        with_analysis: bool = False,
+        user_prompt: str | None = None,
+        temperature: float | None = 0.0,
+        logprobs: bool = False,
+        top_logprobs: int = 3,
+        validator: Callable[[Any], bool] | None = None,
+        max_validation_retries: int | None = None,
+        priority: int | None = None,
+        timeout: float | None = None,
+    ) -> list[ToolOutput]:
+        """
+        Translate texts between languages
+
+        Important Note: This tool is EXPERIMENTAL, you can use it but it isn't reliable.
+
+        Arguments:
+            texts: The input texts
+            target_lang: The target language for translation
+            use_chunker: Whether to use text chunker for large texts
+            with_analysis: Adds a reasoning step before generating the final output. Note: This doubles token usage per call
+            user_prompt: Additional instructions
+            temperature: Controls randomness
+            logprobs: Whether to return token probability information
+            top_logprobs: Number of top token alternatives to return if logprobs enabled
+            validator: Custom validation function to validate the output
+            max_validation_retries: Maximum number of retry attempts if validation fails
+            priority: Task execution priority (if enabled by vLLM and the model)
+            timeout: Maximum time in seconds to wait for the response before raising a timeout error
+
+        Returns:
+            list[ToolOutput]
+        """
+
+        async def _throttled_task(text: str) -> ToolOutput:
+            async with self.semaphore:
+                return await self.tool.translate(
+                    text=text,
+                    target_lang=target_lang,
+                    use_chunker=use_chunker,
+                    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,
+                    timeout=timeout,
+                )
+
+        tasks = [_throttled_task(t) for t in texts]
+        return await asyncio.gather(*tasks)
+
+    async def propositionize(
+        self,
+        texts: list[str],
+        with_analysis: bool = False,
+        output_lang: str | None = None,
+        user_prompt: str | None = None,
+        temperature: float | None = 0.0,
+        logprobs: bool = False,
+        top_logprobs: int = 3,
+        validator: Callable[[Any], bool] | None = None,
+        max_validation_retries: int | None = None,
+        priority: int | None = None,
+        timeout: float | None = None,
+    ) -> list[ToolOutput]:
+        """
+        Convert texts into atomic, independent, meaningful sentences
+
+        Important Note: This tool is EXPERIMENTAL, you can use it but it isn't reliable.
+
+        Arguments:
+            texts: The input texts
+            with_analysis: Adds a reasoning step before generating the final output. Note: This doubles token usage per call
+            output_lang: Forces the model to respond in a specific language
+            user_prompt: Additional instructions
+            temperature: Controls randomness
+            logprobs: Whether to return token probability information
+            top_logprobs: Number of top token alternatives to return if logprobs enabled
+            validator: Custom validation function to validate the output
+            max_validation_retries: Maximum number of retry attempts if validation fails
+            priority: Task execution priority (if enabled by vLLM and the model)
+            timeout: Maximum time in seconds to wait for the response before raising a timeout error
+
+        Returns:
+            list[ToolOutput]
+        """
+
+        async def _throttled_task(text: str) -> ToolOutput:
+            async with self.semaphore:
+                return await self.tool.propositionize(
+                    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,
+                    timeout=timeout,
+                )
+
+        tasks = [_throttled_task(t) for t in texts]
+        return await asyncio.gather(*tasks)
+
+    async def is_fact(
+        self,
+        texts: list[str],
+        source_texts: list[str],
+        with_analysis: bool = False,
+        output_lang: str | None = None,
+        user_prompt: str | None = None,
+        temperature: float | None = 0.0,
+        logprobs: bool = False,
+        top_logprobs: int = 3,
+        validator: Callable[[Any], bool] | None = None,
+        max_validation_retries: int | None = None,
+        priority: int | None = None,
+        timeout: float | None = None,
+    ) -> list[ToolOutput]:
+        """
+        Check whether statements are facts based on source texts
+
+        Important Note: This tool is EXPERIMENTAL, you can use it but it isn't reliable.
+
+        Arguments:
+            texts: The input texts (statements to check)
+            source_texts: The source texts
+            with_analysis: Adds a reasoning step before generating the final output. Note: This doubles token usage per call
+            output_lang: Forces the model to respond in a specific language
+            user_prompt: Additional instructions
+            temperature: Controls randomness
+            logprobs: Whether to return token probability information
+            top_logprobs: Number of top token alternatives to return if logprobs enabled
+            validator: Custom validation function to validate the output
+            max_validation_retries: Maximum number of retry attempts if validation fails
+            priority: Task execution priority (if enabled by vLLM and the model)
+            timeout: Maximum time in seconds to wait for the response before raising a timeout error
+
+        Returns:
+            list[ToolOutput]
+        """
+
+        async def _throttled_task(text: str, source_text: str) -> ToolOutput:
+            async with self.semaphore:
+                return await self.tool.is_fact(
+                    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,
+                    timeout=timeout,
+                )
+
+        tasks = [_throttled_task(t, s) for t, s in zip(texts, source_texts)]
+        return await asyncio.gather(*tasks)
+
+    async def run_custom(
+        self,
+        prompts: list[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,
+        top_logprobs: int = 3,
+        validator: Callable[[Any], bool] | None = None,
+        max_validation_retries: int | None = None,
+        priority: int | None = None,
+        timeout: float | None = None,
+    ) -> list[ToolOutput]:
+        """
+        Custom tool that can do almost anything for multiple prompts
+
+        Arguments:
+            prompts: The user prompts
+            output_model: Pydantic BaseModel used for structured output
+            with_analysis: Adds a reasoning step before generating the final output. Note: This doubles token usage per call
+            analyze_template: The analyze template used for reasoning analysis
+            output_lang: Forces the model to respond in a specific language
+            temperature: Controls randomness
+            logprobs: Whether to return token probability information
+            top_logprobs: Number of top token alternatives to return if logprobs enabled
+            validator: Custom validation function to validate the output
+            max_validation_retries: Maximum number of retry attempts if validation fails
+            priority: Task execution priority (if enabled by vLLM and the model)
+            timeout: Maximum time in seconds to wait for the response before raising a timeout error
+
+        Returns:
+            list[ToolOutput]
+        """
+
+        async def _throttled_task(prompt: str) -> ToolOutput:
+            async with self.semaphore:
+                return await self.tool.run_custom(
+                    prompt=prompt,
+                    output_model=output_model,
+                    with_analysis=with_analysis,
+                    analyze_template=analyze_template,
+                    output_lang=output_lang,
+                    temperature=temperature,
+                    logprobs=logprobs,
+                    top_logprobs=top_logprobs,
+                    validator=validator,
+                    max_validation_retries=max_validation_retries,
+                    priority=priority,
+                    timeout=timeout,
+                )
+
+        tasks = [_throttled_task(p) for p in prompts]
+        return await asyncio.gather(*tasks)

texttools/tools/sync_tools.py

@@ -1,3 +1,4 @@
+import logging
 from collections.abc import Callable
 from time import perf_counter
 from typing import Any, Literal
@@ -23,8 +24,11 @@ class TheTool:
         self,
         client: OpenAI,
         model: str,
+        raise_on_error: bool = True,
     ):
         self._operator = Operator(client=client, model=model)
+        self.logger = logging.getLogger(self.__class__.__name__)
+        self.raise_on_error = raise_on_error
 
     def categorize(
         self,
@@ -42,8 +46,6 @@ class TheTool:
         """
         Classify text into given categories
 
-        Important Note: category_tree mode is EXPERIMENTAL, you can use it but it isn't reliable.
-
         Arguments:
             text: The input text
             categories: The category list / category tree
@@ -58,7 +60,6 @@ class TheTool:
 
         Returns:
             ToolOutput
-
         """
         tool_name = "categorize"
         start = perf_counter()
@@ -152,6 +153,11 @@ class TheTool:
                 )
 
         except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            self.logger.error(str(e))
+
+            if self.raise_on_error:
+                raise
+
             metadata = ToolOutputMetadata(tool_name=tool_name)
             tool_output = ToolOutput(
                 errors=[f"{type(e).__name__}: {e}"], metadata=metadata
@@ -228,6 +234,11 @@ class TheTool:
             )
 
         except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            self.logger.error(str(e))
+
+            if self.raise_on_error:
+                raise
+
             metadata = ToolOutputMetadata(tool_name=tool_name)
             tool_output = ToolOutput(
                 errors=[f"{type(e).__name__}: {e}"], metadata=metadata
@@ -302,6 +313,11 @@ class TheTool:
             )
 
         except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            self.logger.error(str(e))
+
+            if self.raise_on_error:
+                raise
+
             metadata = ToolOutputMetadata(tool_name=tool_name)
             tool_output = ToolOutput(
                 errors=[f"{type(e).__name__}: {e}"], metadata=metadata
@@ -371,6 +387,11 @@ class TheTool:
             )
 
         except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            self.logger.error(str(e))
+
+            if self.raise_on_error:
+                raise
+
             metadata = ToolOutputMetadata(tool_name=tool_name)
             tool_output = ToolOutput(
                 errors=[f"{type(e).__name__}: {e}"], metadata=metadata
@@ -447,6 +468,11 @@ class TheTool:
             )
 
         except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            self.logger.error(str(e))
+
+            if self.raise_on_error:
+                raise
+
             metadata = ToolOutputMetadata(tool_name=tool_name)
             tool_output = ToolOutput(
                 errors=[f"{type(e).__name__}: {e}"], metadata=metadata
@@ -521,6 +547,11 @@ class TheTool:
             )
 
         except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            self.logger.error(str(e))
+
+            if self.raise_on_error:
+                raise
+
             metadata = ToolOutputMetadata(tool_name=tool_name)
             tool_output = ToolOutput(
                 errors=[f"{type(e).__name__}: {e}"], metadata=metadata
@@ -594,6 +625,11 @@ class TheTool:
             )
 
         except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            self.logger.error(str(e))
+
+            if self.raise_on_error:
+                raise
+
             metadata = ToolOutputMetadata(tool_name=tool_name)
             tool_output = ToolOutput(
                 errors=[f"{type(e).__name__}: {e}"], metadata=metadata
@@ -665,6 +701,11 @@ class TheTool:
             )
 
         except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            self.logger.error(str(e))
+
+            if self.raise_on_error:
+                raise
+
             metadata = ToolOutputMetadata(tool_name=tool_name)
             tool_output = ToolOutput(
                 errors=[f"{type(e).__name__}: {e}"], metadata=metadata
@@ -785,6 +826,11 @@ class TheTool:
                 )
 
         except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            self.logger.error(str(e))
+
+            if self.raise_on_error:
+                raise
+
             metadata = ToolOutputMetadata(tool_name=tool_name)
             tool_output = ToolOutput(
                 errors=[f"{type(e).__name__}: {e}"], metadata=metadata
@@ -858,6 +904,11 @@ class TheTool:
             )
 
         except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            self.logger.error(str(e))
+
+            if self.raise_on_error:
+                raise
+
             metadata = ToolOutputMetadata(tool_name=tool_name)
             tool_output = ToolOutput(
                 errors=[f"{type(e).__name__}: {e}"], metadata=metadata
@@ -934,6 +985,11 @@ class TheTool:
             )
 
         except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            self.logger.error(str(e))
+
+            if self.raise_on_error:
+                raise
+
             metadata = ToolOutputMetadata(tool_name=tool_name)
             tool_output = ToolOutput(
                 errors=[f"{type(e).__name__}: {e}"], metadata=metadata
@@ -1009,6 +1065,11 @@ class TheTool:
             )
 
         except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
+            self.logger.error(str(e))
+
+            if self.raise_on_error:
+                raise
+
             metadata = ToolOutputMetadata(tool_name=tool_name)
             tool_output = ToolOutput(
                 errors=[f"{type(e).__name__}: {e}"], metadata=metadata