hamtaa-texttools 1.1.16__tar.gz → 1.1.17__tar.gz

{hamtaa_texttools-1.1.16/hamtaa_texttools.egg-info → hamtaa_texttools-1.1.17}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: hamtaa-texttools
-Version: 1.1.16
+Version: 1.1.17
 Summary: A high-level NLP toolkit built on top of modern LLMs.
-Author-email: Tohidi <the.mohammad.tohidi@gmail.com>, Montazer <montazerh82@gmail.com>, Givechi <mohamad.m.givechi@gmail.com>, MoosaviNejad <erfanmoosavi84@gmail.com>
+Author-email: Tohidi <the.mohammad.tohidi@gmail.com>, Montazer <montazerh82@gmail.com>, Givechi <mohamad.m.givechi@gmail.com>, MoosaviNejad <erfanmoosavi84@gmail.com>, Zareshahi <a.zareshahi1377@gmail.com>
 License: MIT License
         
         Copyright (c) 2025 Hamtaa
@@ -60,6 +60,7 @@ Each tool is designed to work with structured outputs (JSON / Pydantic).
 - **`subject_to_question()`** - Generates questions about a specific subject
 - **`summarize()`** - Text summarization
 - **`translate()`** - Text translation between languages
+- **`propositionize()`** - Convert text to atomic independence meaningful sentences 
 - **`run_custom()`** - Allows users to define a custom tool with an arbitrary BaseModel
 
 ---

{hamtaa_texttools-1.1.16 → hamtaa_texttools-1.1.17}/README.md

@@ -25,6 +25,7 @@ Each tool is designed to work with structured outputs (JSON / Pydantic).
 - **`subject_to_question()`** - Generates questions about a specific subject
 - **`summarize()`** - Text summarization
 - **`translate()`** - Text translation between languages
+- **`propositionize()`** - Convert text to atomic independence meaningful sentences 
 - **`run_custom()`** - Allows users to define a custom tool with an arbitrary BaseModel
 
 ---

{hamtaa_texttools-1.1.16 → hamtaa_texttools-1.1.17/hamtaa_texttools.egg-info}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: hamtaa-texttools
-Version: 1.1.16
+Version: 1.1.17
 Summary: A high-level NLP toolkit built on top of modern LLMs.
-Author-email: Tohidi <the.mohammad.tohidi@gmail.com>, Montazer <montazerh82@gmail.com>, Givechi <mohamad.m.givechi@gmail.com>, MoosaviNejad <erfanmoosavi84@gmail.com>
+Author-email: Tohidi <the.mohammad.tohidi@gmail.com>, Montazer <montazerh82@gmail.com>, Givechi <mohamad.m.givechi@gmail.com>, MoosaviNejad <erfanmoosavi84@gmail.com>, Zareshahi <a.zareshahi1377@gmail.com>
 License: MIT License
         
         Copyright (c) 2025 Hamtaa
@@ -60,6 +60,7 @@ Each tool is designed to work with structured outputs (JSON / Pydantic).
 - **`subject_to_question()`** - Generates questions about a specific subject
 - **`summarize()`** - Text summarization
 - **`translate()`** - Text translation between languages
+- **`propositionize()`** - Convert text to atomic independence meaningful sentences 
 - **`run_custom()`** - Allows users to define a custom tool with an arbitrary BaseModel
 
 ---

{hamtaa_texttools-1.1.16 → hamtaa_texttools-1.1.17}/hamtaa_texttools.egg-info/SOURCES.txt

@@ -22,6 +22,7 @@ texttools/prompts/extract_entities.yaml
 texttools/prompts/extract_keywords.yaml
 texttools/prompts/is_question.yaml
 texttools/prompts/merge_questions.yaml
+texttools/prompts/propositionize.yaml
 texttools/prompts/rewrite.yaml
 texttools/prompts/run_custom.yaml
 texttools/prompts/subject_to_question.yaml

{hamtaa_texttools-1.1.16 → hamtaa_texttools-1.1.17}/pyproject.toml

@@ -4,12 +4,13 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hamtaa-texttools"
-version = "1.1.16"
+version = "1.1.17"
 authors = [
   { name = "Tohidi", email = "the.mohammad.tohidi@gmail.com" },
   { name = "Montazer", email = "montazerh82@gmail.com" },
   { name = "Givechi", email = "mohamad.m.givechi@gmail.com" },
   { name = "MoosaviNejad", email = "erfanmoosavi84@gmail.com" },
+  { name = "Zareshahi", email = "a.zareshahi1377@gmail.com" },
 ]
 description = "A high-level NLP toolkit built on top of modern LLMs."
 readme = "README.md"

{hamtaa_texttools-1.1.16 → hamtaa_texttools-1.1.17}/tests/test_all_async_tools.py

@@ -40,6 +40,7 @@ async def main():
     questions_task = t.subject_to_question("Friendship", 3)
     summary_task = t.summarize("Tomorrow, we will be dead by the car crash")
     translation_task = t.translate("سلام حالت چطوره؟", target_language="English")
+    propositionize_task = t.propositionize("جنگ جهانی دوم در سال ۱۹۳۹ آغاز شد و آلمان به لهستان حمله کرد.", output_lang="Persian")
     (
         category,
         keywords,
@@ -51,6 +52,7 @@ async def main():
         questions,
         summary,
         translation,
+        propositionize,
     ) = await asyncio.gather(
         category_task,
         keywords_task,
@@ -62,6 +64,7 @@ async def main():
         questions_task,
         summary_task,
         translation_task,
+        propositionize_task,
     )
 
     for tool_output in (
@@ -75,6 +78,7 @@ async def main():
         questions,
         summary,
         translation,
+        propositionize,
     ):
         print(repr(tool_output))
 

{hamtaa_texttools-1.1.16 → hamtaa_texttools-1.1.17}/tests/test_all_tools.py

@@ -84,6 +84,9 @@ print(repr(summary))
 translation = t.translate("سلام حالت چطوره؟", target_language="English")
 print(repr(translation))
 
+# propositionize
+propositionize = t.propositionize("جنگ جهانی دوم در سال ۱۹۳۹ آغاز شد و آلمان به لهستان حمله کرد.", output_lang="Persian")
+print(repr(propositionize))
 
 # Custom tool
 class Student(BaseModel):

hamtaa_texttools-1.1.17/texttools/prompts/propositionize.yaml

@@ -0,0 +1,15 @@
+main_template: |
+  You are an expert in breaking down text into atomic propositions in that language.
+  An atomic proposition is a single, self-contained fact that is concise, verifiable,
+  and does not rely on external context.
+  Each proposition must stand alone.
+  Rewrite sentences if needed to keep the context saved in each sentence.
+  Extract the atomic propositions of this text:
+  {input}
+
+analyze_template: |
+  We want to analyze this text snippet and think about where we can split sentence to atomic meaningful propositions.
+  An atomic proposition is a single, self-contained fact that is concise,
+  verifiable, and does not rely on external context.
+  You just have to think around the possible propositions in the text and how a proposition can be made.
+  {input}

{hamtaa_texttools-1.1.16 → hamtaa_texttools-1.1.17}/texttools/tools/async_tools.py

@@ -62,6 +62,9 @@ class AsyncTheTool:
                 - result (str): The assigned category
                 - logprobs (list | None): Probability data if logprobs enabled
                 - analysis (str | None): Detailed reasoning if with_analysis enabled
+                - process (str | None): Description of the process used
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -75,8 +78,8 @@ class AsyncTheTool:
 
             for _ in range(levels):
                 # Get child nodes for current parent
-                parent_node = categories.find_node(parent_id)
-                children = categories.find_children(parent_node)
+                parent_node = categories.get_node(parent_id)
+                children = categories.get_children(parent_node)
 
                 # Check if child nodes exist
                 if not children:
@@ -124,7 +127,7 @@ class AsyncTheTool:
                 chosen_category = level_output.result
 
                 # Find the corresponding node
-                parent_node = categories.find_node(chosen_category)
+                parent_node = categories.get_node(chosen_category)
                 if parent_node is None:
                     output.errors.append(
                         f"Category '{chosen_category}' not found in tree after selection"
@@ -203,6 +206,9 @@ class AsyncTheTool:
                 - result (list[str]): List of extracted keywords
                 - logprobs (list | None): Probability data if logprobs enabled
                 - analysis (str | None): Detailed reasoning if with_analysis enabled
+                - process (str | None): Description of the process used
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -261,6 +267,9 @@ class AsyncTheTool:
                 - result (list[dict]): List of entities with 'text' and 'type' keys
                 - logprobs (list | None): Probability data if logprobs enabled
                 - analysis (str | None): Detailed reasoning if with_analysis enabled
+                - process (str | None): Description of the process used
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -316,6 +325,9 @@ class AsyncTheTool:
                 - result (bool): True if text is a question, False otherwise
                 - logprobs (list | None): Probability data if logprobs enabled
                 - analysis (str | None): Detailed reasoning if with_analysis enabled
+                - process (str | None): Description of the process used
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -373,6 +385,9 @@ class AsyncTheTool:
                 - result (str): The generated question
                 - logprobs (list | None): Probability data if logprobs enabled
                 - analysis (str | None): Detailed reasoning if with_analysis enabled
+                - process (str | None): Description of the process used
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -432,6 +447,9 @@ class AsyncTheTool:
                 - result (str): The merged question
                 - logprobs (list | None): Probability data if logprobs enabled
                 - analysis (str | None): Detailed reasoning if with_analysis enabled
+                - process (str | None): Description of the process used
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -492,6 +510,9 @@ class AsyncTheTool:
                 - result (str): The rewritten text
                 - logprobs (list | None): Probability data if logprobs enabled
                 - analysis (str | None): Detailed reasoning if with_analysis enabled
+                - process (str | None): Description of the process used
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -551,6 +572,9 @@ class AsyncTheTool:
                 - result (list[str]): List of generated questions
                 - logprobs (list | None): Probability data if logprobs enabled
                 - analysis (str | None): Detailed reasoning if with_analysis enabled
+                - process (str | None): Description of the process used
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -609,6 +633,9 @@ class AsyncTheTool:
                 - result (str): The summary text
                 - logprobs (list | None): Probability data if logprobs enabled
                 - analysis (str | None): Detailed reasoning if with_analysis enabled
+                - process (str | None): Description of the process used
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -666,6 +693,9 @@ class AsyncTheTool:
                 - result (str): The translated text
                 - logprobs (list | None): Probability data if logprobs enabled
                 - analysis (str | None): Detailed reasoning if with_analysis enabled
+                - process (str | None): Description of the process used
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -724,6 +754,9 @@ class AsyncTheTool:
                 - result (list[Entity]): The entities
                 - logprobs (list | None): Probability data if logprobs enabled
                 - analysis (str | None): Detailed reasoning if with_analysis enabled
+                - process (str | None): Description of the process used
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -748,6 +781,66 @@ class AsyncTheTool:
         output.execution_time = (end - start).total_seconds()
         return output
 
+    async def propositionize(
+        self,
+        text: 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 | None = None,
+        validator: Callable[[Any], bool] | None = None,
+        max_validation_retries: int | None = None,
+        priority: int | None = 0,
+    ) -> Models.ToolOutput:
+        """
+        Proposition input text to meaningful sentences.
+
+        Arguments:
+            text: The input text
+            with_analysis: Whether to include detailed reasoning analysis
+            output_lang: Language for the output summary
+            user_prompt: Additional instructions for summarization
+            temperature: Controls randomness (0.0 = deterministic, 1.0 = creative)
+            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 model)
+
+        Returns:
+            ToolOutput: Object containing:
+                - result (list[str]): The propositions
+                - logprobs (list | None): Probability data if logprobs enabled
+                - analysis (str | None): Detailed reasoning if with_analysis enabled
+                - process (str | None): Description of the process used
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
+                - errors (list(str) | None): Errors occured during tool call
+        """
+        start = datetime.now()
+        output = await self._operator.run(
+            # User parameters
+            text=text,
+            with_analysis=with_analysis,
+            output_lang=output_lang,
+            user_prompt=user_prompt,
+            temperature=temperature,
+            logprobs=logprobs,
+            top_logprobs=top_logprobs,
+            validator=validator,
+            max_validation_retries=max_validation_retries,
+            priority=priority,
+            # Internal parameters
+            prompt_file="propositionize.yaml",
+            output_model=Models.ListStrOutput,
+            mode=None,
+        )
+        end = datetime.now()
+        output.execution_time = (end - start).total_seconds()
+        return output
+
     async def run_custom(
         self,
         prompt: str,
@@ -778,6 +871,9 @@ class AsyncTheTool:
                 - result (str): The translated text
                 - logprobs (list | None): Probability data if logprobs enabled
                 - analysis (str | None): Detailed reasoning if with_analysis enabled
+                - process (str | None): Description of the process used
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()

{hamtaa_texttools-1.1.16 → hamtaa_texttools-1.1.17}/texttools/tools/internals/models.py

@@ -6,19 +6,24 @@ from pydantic import BaseModel, Field, create_model
 
 class ToolOutput(BaseModel):
     result: Any = None
-    analysis: str = ""
     logprobs: list[dict[str, Any]] = []
+    analysis: str = ""
     process: str = ""
     processed_at: datetime = datetime.now()
     execution_time: float = -1.0
     errors: list[str] = []
 
     def __repr__(self) -> str:
-        return f"ToolOutput(process='{self.process}', result_type='{type(self.result)}', result='{self.result}', analysis='{self.analysis}', logprobs='{self.logprobs}', errors='{self.errors}', processed_at='{self.processed_at}', execution_time='{self.execution_time}'"
+        return f"""
+        ToolOutput(process='{self.process}', result_type='{type(self.result)}', 
+        result='{self.result}', analysis='{self.analysis}', 
+        logprobs='{self.logprobs}', errors='{self.errors}', 
+        processed_at='{self.processed_at}', execution_time='{self.execution_time}'
+        """
 
 
 class StrOutput(BaseModel):
-    result: str = Field(..., description="The output string")
+    result: str = Field(..., description="The output string", example="text")
 
 
 class BoolOutput(BaseModel):
@@ -37,13 +42,15 @@ class ListDictStrStrOutput(BaseModel):
     result: list[dict[str, str]] = Field(
         ...,
         description="List of dictionaries containing string key-value pairs",
-        example=[{"text": "Mohammad", "type": "PER"}],
+        example=[{"text": "Mohammad", "type": "PER"}, {"text": "Iran", "type": "LOC"}],
     )
 
 
 class ReasonListStrOutput(BaseModel):
     reason: str = Field(..., description="Thinking process that led to the output")
-    result: list[str] = Field(..., description="The output list of strings")
+    result: list[str] = Field(
+        ..., description="The output list of strings", example=["text_1", "text_2"]
+    )
 
 
 class Node(BaseModel):
@@ -51,14 +58,44 @@ class Node(BaseModel):
     name: str
     level: int
     parent_id: int | None
-    description: str = "No description provided"
+    description: str
 
 
 class CategoryTree:
     def __init__(self, tree_name):
-        self.root = Node(node_id=0, name=tree_name, level=0, parent_id=None)
-        self.all_nodes: list[Node] = [self.root]
-        self.new_id = 1
+        self._root = Node(
+            node_id=0, name=tree_name, level=0, parent_id=None, description="Root node"
+        )
+        self._all_nodes: list[Node] = [self._root]
+        self._new_id = 1
+
+    def get_all_nodes(self) -> list[Node]:
+        return self._all_nodes
+
+    def get_level_count(self) -> int:
+        return max([item.level for item in self._all_nodes])
+
+    def get_node(self, identifier: int | str) -> Node | None:
+        if isinstance(identifier, str):
+            for node in self.get_all_nodes():
+                if node.name == identifier:
+                    return node
+            return None
+        elif isinstance(identifier, int):
+            for node in self.get_all_nodes():
+                if node.node_id == identifier:
+                    return node
+            return None
+        else:
+            return None
+
+    def get_children(self, parent_node: Node) -> list[Node] | None:
+        children = [
+            node
+            for node in self.get_all_nodes()
+            if parent_node.node_id == node.parent_id
+        ]
+        return children if children else None
 
     def add_node(
         self,
@@ -66,12 +103,12 @@ class CategoryTree:
         parent_name: str | None = None,
         description: str | None = None,
     ) -> None:
-        if self.find_node(node_name):
+        if self.get_node(node_name):
             raise ValueError(f"{node_name} has been chosen for another category before")
 
         if parent_name:
-            parent_node = self.find_node(parent_name)
-            if parent_node is None:
+            parent_node = self.get_node(parent_name)
+            if not parent_node:
                 raise ValueError(f"Parent category '{parent_name}' not found")
             parent_id = parent_node.node_id
             level = parent_node.level + 1
@@ -80,61 +117,31 @@ class CategoryTree:
             parent_id = 0
 
         node_data = {
-            "node_id": self.new_id,
+            "node_id": self._new_id,
             "name": node_name,
             "level": level,
             "parent_id": parent_id,
+            "description": description if description else "No description provided",
         }
 
-        if description is not None:
-            node_data["description"] = description
-
-        self.all_nodes.append(Node(**node_data))
-        self.new_id += 1
-
-    def get_nodes(self) -> list[Node]:
-        return self.all_nodes
-
-    def get_level_count(self) -> int:
-        return max([item.level for item in self.all_nodes])
-
-    def find_node(self, identifier: int | str) -> Node | None:
-        if isinstance(identifier, str):
-            for node in self.get_nodes():
-                if node.name == identifier:
-                    return node
-            return None
-        elif isinstance(identifier, int):
-            for node in self.get_nodes():
-                if node.node_id == identifier:
-                    return node
-            return None
-        else:
-            return None
-
-    def find_children(self, parent_node: Node) -> list[Node] | None:
-        children = [
-            node for node in self.get_nodes() if parent_node.node_id == node.parent_id
-        ]
-        return children if children else None
+        self._all_nodes.append(Node(**node_data))
+        self._new_id += 1
 
     def remove_node(self, identifier: int | str) -> None:
-        node = self.find_node(identifier)
+        node = self.get_node(identifier)
 
-        if node is not None:
+        if node:
             # Remove node's children recursively
-            children = self.find_children(node)
+            children = self.get_children(node)
 
-            # Ending condition
-            if children is None:
-                self.all_nodes.remove(node)
+            if not children:
+                self._all_nodes.remove(node)
                 return
 
             for child in children:
                 self.remove_node(child.name)
 
-            # Remove the node from tree
-            self.all_nodes.remove(node)
+            self._all_nodes.remove(node)
         else:
             raise ValueError(f"Node with identifier: '{identifier}' not found.")
 
@@ -142,7 +149,7 @@ class CategoryTree:
         def build_dict(node: Node) -> dict:
             children = [
                 build_dict(child)
-                for child in self.all_nodes
+                for child in self._all_nodes
                 if child.parent_id == node.node_id
             ]
             return {
@@ -153,7 +160,7 @@ class CategoryTree:
                 "children": children,
             }
 
-        return {"category_tree": build_dict(self.root)["children"]}
+        return {"category_tree": build_dict(self._root)["children"]}
 
 
 # This function is needed to create CategorizerOutput with dynamic categories

{hamtaa_texttools-1.1.16 → hamtaa_texttools-1.1.17}/texttools/tools/sync_tools.py

@@ -60,7 +60,11 @@ class TheTool:
                 - result (str): The assigned category
                 - logprobs (list | None): Probability data if logprobs enabled
                 - analysis (str | None): Detailed reasoning if with_analysis enabled
+                - process (str | None): Description of the process used
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
+
         """
         start = datetime.now()
 
@@ -73,8 +77,8 @@ class TheTool:
 
             for _ in range(levels):
                 # Get child nodes for current parent
-                parent_node = categories.find_node(parent_id)
-                children = categories.find_children(parent_node)
+                parent_node = categories.get_node(parent_id)
+                children = categories.get_children(parent_node)
 
                 # Check if child nodes exist
                 if not children:
@@ -123,7 +127,7 @@ class TheTool:
                 chosen_category = level_output.result
 
                 # Find the corresponding node
-                parent_node = categories.find_node(chosen_category)
+                parent_node = categories.get_node(chosen_category)
                 if parent_node is None:
                     output.errors.append(
                         f"Category '{chosen_category}' not found in tree after selection"
@@ -203,6 +207,9 @@ class TheTool:
                 - result (list[str]): List of extracted keywords
                 - logprobs (list | None): Probability data if logprobs enabled
                 - analysis (str | None): Detailed reasoning if with_analysis enabled
+                - process (str | None): Description of the process used
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -261,6 +268,9 @@ class TheTool:
                 - result (list[dict]): List of entities with 'text' and 'type' keys
                 - logprobs (list | None): Probability data if logprobs enabled
                 - analysis (str | None): Detailed reasoning if with_analysis enabled
+                - process (str | None): Description of the process used
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -316,6 +326,9 @@ class TheTool:
                 - result (bool): True if text is a question, False otherwise
                 - logprobs (list | None): Probability data if logprobs enabled
                 - analysis (str | None): Detailed reasoning if with_analysis enabled
+                - process (str | None): Description of the process used
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -373,6 +386,9 @@ class TheTool:
                 - result (str): The generated question
                 - logprobs (list | None): Probability data if logprobs enabled
                 - analysis (str | None): Detailed reasoning if with_analysis enabled
+                - process (str | None): Description of the process used
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -432,6 +448,9 @@ class TheTool:
                 - result (str): The merged question
                 - logprobs (list | None): Probability data if logprobs enabled
                 - analysis (str | None): Detailed reasoning if with_analysis enabled
+                - process (str | None): Description of the process used
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -492,6 +511,9 @@ class TheTool:
                 - result (str): The rewritten text
                 - logprobs (list | None): Probability data if logprobs enabled
                 - analysis (str | None): Detailed reasoning if with_analysis enabled
+                - process (str | None): Description of the process used
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -551,6 +573,9 @@ class TheTool:
                 - result (list[str]): List of generated questions
                 - logprobs (list | None): Probability data if logprobs enabled
                 - analysis (str | None): Detailed reasoning if with_analysis enabled
+                - process (str | None): Description of the process used
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -609,6 +634,9 @@ class TheTool:
                 - result (str): The summary text
                 - logprobs (list | None): Probability data if logprobs enabled
                 - analysis (str | None): Detailed reasoning if with_analysis enabled
+                - process (str | None): Description of the process used
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -666,6 +694,9 @@ class TheTool:
                 - result (str): The translated text
                 - logprobs (list | None): Probability data if logprobs enabled
                 - analysis (str | None): Detailed reasoning if with_analysis enabled
+                - process (str | None): Description of the process used
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -724,6 +755,9 @@ class TheTool:
                 - result (list[Entity]): The entities
                 - logprobs (list | None): Probability data if logprobs enabled
                 - analysis (str | None): Detailed reasoning if with_analysis enabled
+                - process (str | None): Description of the process used
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -748,6 +782,66 @@ class TheTool:
         output.execution_time = (end - start).total_seconds()
         return output
 
+    def propositionize(
+        self,
+        text: 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 | None = None,
+        validator: Callable[[Any], bool] | None = None,
+        max_validation_retries: int | None = None,
+        priority: int | None = 0,
+    ) -> Models.ToolOutput:
+        """
+        Proposition input text to meaningful sentences.
+
+        Arguments:
+            text: The input text
+            with_analysis: Whether to include detailed reasoning analysis
+            output_lang: Language for the output summary
+            user_prompt: Additional instructions for summarization
+            temperature: Controls randomness (0.0 = deterministic, 1.0 = creative)
+            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 model)
+
+        Returns:
+            ToolOutput: Object containing:
+                - result (list[str]): The propositions
+                - logprobs (list | None): Probability data if logprobs enabled
+                - analysis (str | None): Detailed reasoning if with_analysis enabled
+                - process (str | None): Description of the process used
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
+                - errors (list(str) | None): Errors occured during tool call
+        """
+        start = datetime.now()
+        output = self._operator.run(
+            # User parameters
+            text=text,
+            with_analysis=with_analysis,
+            output_lang=output_lang,
+            user_prompt=user_prompt,
+            temperature=temperature,
+            logprobs=logprobs,
+            top_logprobs=top_logprobs,
+            validator=validator,
+            max_validation_retries=max_validation_retries,
+            priority=priority,
+            # Internal parameters
+            prompt_file="propositionize.yaml",
+            output_model=Models.ListStrOutput,
+            mode=None,
+        )
+        end = datetime.now()
+        output.execution_time = (end - start).total_seconds()
+        return output
+
     def run_custom(
         self,
         prompt: str,
@@ -778,6 +872,9 @@ class TheTool:
                 - result (str): The translated text
                 - logprobs (list | None): Probability data if logprobs enabled
                 - analysis (str | None): Detailed reasoning if with_analysis enabled
+                - process (str | None): Description of the process used
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()