mojentic 0.5.3__py3-none-any.whl → 0.5.5__py3-none-any.whl

_examples/broker_examples.py

@@ -1,6 +1,9 @@
 import logging
 import os
 
+from mojentic.llm import LLMBroker
+from mojentic.llm.gateways import OpenAIGateway
+
 logging.basicConfig(level=logging.WARN)
 
 from pathlib import Path
@@ -8,8 +11,6 @@ from pathlib import Path
 from pydantic import BaseModel, Field
 
 from mojentic.llm.gateways.models import LLMMessage
-from mojentic.llm.gateways.openai import OpenAIGateway
-from mojentic.llm.llm_broker import LLMBroker
 from mojentic.llm.tools.date_resolver import ResolveDateTool
 
 
@@ -43,6 +44,7 @@ def check_tool_use(llm):
                           tools=[ResolveDateTool()])
     print(result)
 
+
 def check_image_analysis(llm, image_path: Path = None):
     if image_path is None:
         image_path = Path.cwd() / 'images' / 'flash_rom.jpg'
@@ -52,25 +54,13 @@ def check_image_analysis(llm, image_path: Path = None):
     ])
     print(result)
 
-models = ["gpt-4o", "gpt-4.1", "o3", "gpt-4.5-preview", "o4-mini"]
-images = [
-    Path.cwd() / 'images' / 'flash_rom.jpg',
-    Path.cwd() / 'images' / 'screen_cap.png',
-    Path.cwd() / 'images' / 'xbox-one.jpg',
-]
-
-for image in images:
-    for model in models:
-        print(f"Checking {model} with {str(image)}")
-        check_image_analysis(openai_llm(model=model), image)
-
 
-# check_simple_textgen(openai_llm(model="o4-mini"))
-# check_structured_output(openai_llm(model="o4-mini"))
-# check_tool_use(openai_llm(model="o4-mini"))
-# check_image_analysis(openai_llm(model="gpt-4o"))
+check_simple_textgen(openai_llm(model="o4-mini"))
+check_structured_output(openai_llm(model="o4-mini"))
+check_tool_use(openai_llm(model="o4-mini"))
+check_image_analysis(openai_llm(model="gpt-4o"))
 
-# check_simple_textgen(ollama_llm())
-# check_structured_output(ollama_llm())
-# check_tool_use(ollama_llm())
-# check_image_analysis(ollama_llm(model="gemma3:27b"))
+check_simple_textgen(ollama_llm())
+check_structured_output(ollama_llm())
+check_tool_use(ollama_llm(model="qwen3:32b"))
+check_image_analysis(ollama_llm(model="gemma3:27b"))

_examples/broker_image_examples.py

@@ -0,0 +1,41 @@
+import os
+from pathlib import Path
+
+from mojentic.llm import LLMBroker
+from mojentic.llm.gateways import OpenAIGateway
+from mojentic.llm.gateways.models import LLMMessage
+
+
+def openai_llm(model="gpt-4o"):
+    api_key = os.getenv("OPENAI_API_KEY")
+    gateway = OpenAIGateway(api_key)
+    llm = LLMBroker(model=model, gateway=gateway)
+    return llm
+
+
+def ollama_llm(model="llama3.3-70b-32k"):
+    llm = LLMBroker(model=model)
+    return llm
+
+
+def check_image_analysis(llm, image_path: Path = None):
+    if image_path is None:
+        image_path = Path.cwd() / 'images' / 'flash_rom.jpg'
+    result = llm.generate(messages=[
+        (LLMMessage(content='What is in this image?',
+                    image_paths=[str(image_path)]))
+    ])
+    print(result)
+
+
+models = ["gpt-4o", "gpt-4.1", "o3", "gpt-4.5-preview", "o4-mini"]
+images = [
+    Path.cwd() / 'images' / 'flash_rom.jpg',
+    Path.cwd() / 'images' / 'screen_cap.png',
+    Path.cwd() / 'images' / 'xbox-one.jpg',
+]
+
+for image in images:
+    for model in models:
+        print(f"Checking {model} with {str(image)}")
+        check_image_analysis(openai_llm(model=model), image)

_examples/ephemeral_task_manager_example.py

@@ -0,0 +1,48 @@
+"""
+Example script demonstrating the usage of the ephemeral task manager tools.
+"""
+import logging
+import os
+
+from mojentic.llm.gateways import OpenAIGateway
+
+logging.basicConfig(
+    level=logging.WARN
+)
+
+from mojentic.llm import LLMBroker
+from mojentic.llm.gateways.models import LLMMessage
+from mojentic.llm.tools.ephemeral_task_manager import (
+    EphemeralTaskList,
+    AppendTaskTool,
+    PrependTaskTool,
+    InsertTaskAfterTool,
+    StartTaskTool,
+    CompleteTaskTool,
+    ListTasksTool,
+    ClearTasksTool
+)
+from mojentic.llm.tools.tell_user_tool import TellUserTool
+
+# llm = LLMBroker(model="qwen3:30b-a3b-q4_K_M")
+# llm = LLMBroker(model="qwen3:32b")
+llm = LLMBroker(model="qwen2.5:7b")
+# llm = LLMBroker(model="qwen2.5:72b")
+# llm = LLMBroker(model="o4-mini", gateway=OpenAIGateway(os.environ["OPENAI_API_KEY"]))
+message = LLMMessage(
+    content="I want you to count from 1 to 10. Break that request down into individual tasks, track them using available tools, and perform them one by one until you're finished. Interrupt me to tell the user as you complete every task.")
+task_list = EphemeralTaskList()
+tools = [
+    AppendTaskTool(task_list),
+    PrependTaskTool(task_list),
+    InsertTaskAfterTool(task_list),
+    StartTaskTool(task_list),
+    CompleteTaskTool(task_list),
+    ListTasksTool(task_list),
+    ClearTasksTool(task_list),
+    TellUserTool(),
+]
+
+result = llm.generate(messages=[message], tools=tools, temperature=0.0)
+print(result)
+print(task_list.list_tasks())

_examples/oversized_embeddings.py

@@ -0,0 +1,9 @@
+import os
+
+from mojentic.llm.gateways import OllamaGateway, OpenAIGateway
+
+ollama = OllamaGateway()
+print(len(ollama.calculate_embeddings("Hello, world! " * 5000)))
+
+openai = OpenAIGateway(os.environ["OPENAI_API_KEY"])
+print(len(openai.calculate_embeddings("Hello, world! " * 5000)))

_examples/streaming.py

@@ -16,7 +16,7 @@ def main():
     date_tool = ResolveDateTool()
     
     stream = ollama.complete_stream(
-        model="MFDoom/deepseek-r1-tool-calling:70b",
+        model="qwen2.5:7b",
         messages=[
             LLMMessage(content="Tell me a story about a dragon. In your story, reference several dates relative to today, "
                               "like 'three days from now' or 'last week'.")

_examples/tell_user_example.py

@@ -0,0 +1,43 @@
+"""
+Example script demonstrating how to use the TellUserTool.
+
+This script shows how to create and run an IterativeProblemSolver with the TellUserTool
+to display messages to the user without expecting a response.
+"""
+
+import logging
+
+logging.basicConfig(level=logging.WARN)
+
+from mojentic.agents.iterative_problem_solver import IterativeProblemSolver
+from mojentic.llm.tools.tell_user_tool import TellUserTool
+from mojentic.llm import LLMBroker
+
+
+def main():
+    # Initialize the LLM broker with your preferred model
+    # Uncomment one of the following lines or modify as needed:
+    # llm = LLMBroker(model="llama3.3-70b-32k")  # Ollama model
+    # llm = LLMBroker(model="gpt-4o")  # OpenAI model
+    llm = LLMBroker(model="qwq")  # Default model for example
+
+    # Define a simple user request
+    user_request = "Tell me about the benefits of exercise."
+
+    # Create the problem solver with necessary tools
+    solver = IterativeProblemSolver(
+        llm=llm,
+        available_tools=[TellUserTool()],
+        max_iterations=3
+    )
+
+    # Run the solver and get the result
+    result = solver.solve(user_request)
+
+    # Display the results
+    print(f"User Request:\n{user_request}\n")
+    print(f"Agent Response:\n{result}\n")
+
+
+if __name__ == "__main__":
+    main()

mojentic/agents/iterative_problem_solver.py

@@ -26,7 +26,8 @@ class IterativeProblemSolver:
     max_iterations: int
     chat: ChatSession
 
-    def __init__(self, llm: LLMBroker, available_tools: Optional[List[LLMTool]] = None, max_iterations: int = 3):
+    def __init__(self, llm: LLMBroker, available_tools: Optional[List[LLMTool]] = None, max_iterations: int = 3,
+                 system_prompt: Optional[str] = None):
         """Initialize the IterativeProblemSolver.
 
         Parameters
@@ -42,7 +43,9 @@ class IterativeProblemSolver:
         self.available_tools = available_tools or []
         self.chat = ChatSession(
             llm=llm,
-            system_prompt="You are a helpful assistant, working on behalf of the user on a specific user request.",
+            system_prompt=system_prompt or "You are a problem-solving assistant that can solve complex problems step by step. "
+                                           "You analyze problems, break them down into smaller parts, and solve them systematically. "
+                                           "If you cannot solve a problem completely in one step, you make progress and identify what to do next.",
             tools=self.available_tools,
         )
 

mojentic/agents/simple_recursive_agent.py

@@ -140,7 +140,7 @@ class SimpleRecursiveAgent:
     emitter: EventEmitter
     chat: ChatSession
 
-    def __init__(self, llm: LLMBroker, available_tools: Optional[List[LLMTool]] = None, max_iterations: int = 5):
+    def __init__(self, llm: LLMBroker, available_tools: Optional[List[LLMTool]] = None, max_iterations: int = 5, system_prompt: Optional[str] = None):
         """
         Initialize the SimpleRecursiveAgent.
 
@@ -161,7 +161,7 @@ class SimpleRecursiveAgent:
         # Initialize the chat session
         self.chat = ChatSession(
             llm=llm,
-            system_prompt="You are a problem-solving assistant that can solve complex problems step by step. "
+            system_prompt=system_prompt or "You are a problem-solving assistant that can solve complex problems step by step. "
                          "You analyze problems, break them down into smaller parts, and solve them systematically. "
                          "If you cannot solve a problem completely in one step, you make progress and identify what to do next.",
             tools=self.available_tools

mojentic/llm/gateways/openai.py

@@ -1,12 +1,15 @@
 import json
-from typing import Type, List
+from itertools import islice
+from typing import Type, List, Iterable
 
+import numpy as np
 import structlog
 from openai import OpenAI
 
 from mojentic.llm.gateways.llm_gateway import LLMGateway
 from mojentic.llm.gateways.models import LLMToolCall, LLMGatewayResponse
 from mojentic.llm.gateways.openai_messages_adapter import adapt_messages_to_openai
+from mojentic.llm.gateways.tokenizer_gateway import TokenizerGateway
 
 logger = structlog.get_logger()
 
@@ -121,8 +124,28 @@ class OpenAIGateway(LLMGateway):
             The embeddings for the text.
         """
         logger.debug("calculate_embeddings", text=text, model=model)
-        response = self.client.embeddings.create(
-            model=model,
-            input=text
-        )
-        return response.data[0].embedding
+
+        embeddings = [self.client.embeddings.create(model=model, input=chunk).data[0].embedding
+                      for chunk in self._chunked_tokens(text, 8191)]
+        lengths = [len(embedding) for embedding in embeddings]
+
+        average = np.average(embeddings, axis=0, weights=lengths)
+        average = average / np.linalg.norm(average)
+        average = average.tolist()
+
+        return average
+
+    def _batched(self, iterable: Iterable, n: int):
+        """Batch data into tuples of length n. The last batch may be shorter."""
+        # batched('ABCDEFG', 3) --> ABC DEF G
+        if n < 1:
+            raise ValueError('n must be at least one')
+        it = iter(iterable)
+        while batch := tuple(islice(it, n)):
+            yield batch
+
+    def _chunked_tokens(self, text, chunk_length):
+        tokenizer = TokenizerGateway()
+        tokens = tokenizer.encode(text)
+        chunks_iterator = self._batched(tokens, chunk_length)
+        yield from chunks_iterator

mojentic/llm/llm_broker_spec.py

@@ -32,22 +32,10 @@ def llm_broker(mock_gateway):
 
 
 class DescribeLLMBroker:
-    """
-    Specification for the LLMBroker class which handles interactions with Language Learning Models.
-    """
 
     class DescribeMessageGeneration:
-        """
-        Specifications for generating messages through the LLM broker
-        """
 
         def should_generate_simple_response_for_user_message(self, llm_broker, mock_gateway):
-            """
-            Given a simple user message
-            When generating a response
-            Then it should return the LLM's response content
-            """
-            # Given
             test_response_content = "I am fine, thank you!"
             messages = [LLMMessage(role=MessageRole.User, content="Hello, how are you?")]
             mock_gateway.complete.return_value = LLMGatewayResponse(
@@ -56,20 +44,12 @@ class DescribeLLMBroker:
                 tool_calls=[]
             )
 
-            # When
             result = llm_broker.generate(messages)
 
-            # Then
             assert result == test_response_content
             mock_gateway.complete.assert_called_once()
 
         def should_handle_tool_calls_during_generation(self, llm_broker, mock_gateway, mocker):
-            """
-            Given a message that requires tool usage
-            When generating a response
-            Then it should properly handle tool calls and return final response
-            """
-            # Given
             messages = [LLMMessage(role=MessageRole.User, content="What is the date on Friday?")]
             tool_call = mocker.create_autospec(LLMToolCall, instance=True)
             tool_call.name = "resolve_date"
@@ -84,26 +64,15 @@ class DescribeLLMBroker:
             mock_tool.matches.return_value = True
             mock_tool.run.return_value = {"resolved_date": "Friday"}
 
-            # When
             result = llm_broker.generate(messages, tools=[mock_tool])
 
-            # Then
             assert result == "The date is Friday."
             assert mock_gateway.complete.call_count == 2
             mock_tool.run.assert_called_once_with(date="Friday")
 
     class DescribeObjectGeneration:
-        """
-        Specifications for generating structured objects through the LLM broker
-        """
 
         def should_generate_simple_model(self, llm_broker, mock_gateway):
-            """
-            Given messages requiring a simple structured output
-            When generating an object with SimpleModel
-            Then it should return the validated SimpleModel object
-            """
-            # Given
             messages = [LLMMessage(role=MessageRole.User, content="Generate a simple object")]
             mock_object = SimpleModel(text="test", number=42)
             mock_gateway.complete.return_value = LLMGatewayResponse(
@@ -112,22 +81,14 @@ class DescribeLLMBroker:
                 tool_calls=[]
             )
 
-            # When
             result = llm_broker.generate_object(messages, object_model=SimpleModel)
 
-            # Then
             assert isinstance(result, SimpleModel)
             assert result.text == "test"
             assert result.number == 42
             mock_gateway.complete.assert_called_once()
 
         def should_generate_nested_model(self, llm_broker, mock_gateway):
-            """
-            Given messages requiring a nested structured output
-            When generating an object with NestedModel
-            Then it should return the validated NestedModel object
-            """
-            # Given
             messages = [LLMMessage(role=MessageRole.User, content="Generate a nested object")]
             mock_object = NestedModel(
                 title="main",
@@ -139,10 +100,8 @@ class DescribeLLMBroker:
                 tool_calls=[]
             )
 
-            # When
             result = llm_broker.generate_object(messages, object_model=NestedModel)
 
-            # Then
             assert isinstance(result, NestedModel)
             assert result.title == "main"
             assert isinstance(result.details, SimpleModel)
@@ -151,12 +110,6 @@ class DescribeLLMBroker:
             mock_gateway.complete.assert_called_once()
 
         def should_generate_complex_model(self, llm_broker, mock_gateway):
-            """
-            Given messages requiring a complex structured output
-            When generating an object with ComplexModel
-            Then it should return the validated ComplexModel object
-            """
-            # Given
             messages = [LLMMessage(role=MessageRole.User, content="Generate a complex object")]
             mock_object = ComplexModel(
                 name="test",
@@ -172,10 +125,8 @@ class DescribeLLMBroker:
                 tool_calls=[]
             )
 
-            # When
             result = llm_broker.generate_object(messages, object_model=ComplexModel)
 
-            # Then
             assert isinstance(result, ComplexModel)
             assert result.name == "test"
             assert len(result.items) == 2

mojentic/llm/message_composers_spec.py

@@ -61,11 +61,6 @@ class DescribeMessageBuilder:
         """
 
         def should_build_message_with_content(self, message_builder):
-            """
-            Given a MessageBuilder with content
-            When build is called
-            Then it should return a message with that content
-            """
             message_builder.content = "Test content"
 
             message = message_builder.build()
@@ -76,11 +71,6 @@ class DescribeMessageBuilder:
             assert message.image_paths == []
 
         def should_build_message_with_role(self, message_builder):
-            """
-            Given a MessageBuilder with a specific role
-            When build is called
-            Then it should return a message with that role
-            """
             message_builder.role = MessageRole.Assistant
 
             message = message_builder.build()
@@ -88,11 +78,6 @@ class DescribeMessageBuilder:
             assert message.role == MessageRole.Assistant
 
         def should_build_message_with_image_paths(self, message_builder):
-            """
-            Given a MessageBuilder with image paths
-            When build is called
-            Then it should return a message with those image paths
-            """
             message_builder.image_paths = [Path("/path/to/image1.jpg"), Path("/path/to/image2.jpg")]
 
             message = message_builder.build()
@@ -100,11 +85,6 @@ class DescribeMessageBuilder:
             assert message.image_paths == ["/path/to/image1.jpg", "/path/to/image2.jpg"]
 
         def should_build_message_with_file_content(self, message_builder, file_gateway):
-            """
-            Given a MessageBuilder with file paths
-            When build is called
-            Then it should return a message with the file contents
-            """
             file_path = Path("/path/to/file.txt")
             message_builder.file_paths = [file_path]
 
@@ -115,11 +95,6 @@ class DescribeMessageBuilder:
             assert "File: /path/to/file.txt" in message.content
 
         def should_build_message_with_multiple_file_contents(self, message_builder, file_gateway):
-            """
-            Given a MessageBuilder with multiple file paths
-            When build is called
-            Then it should return a message with all file contents
-            """
             file_path1 = Path("/path/to/file1.txt")
             file_path2 = Path("/path/to/file2.txt")
             message_builder.file_paths = [file_path1, file_path2]
@@ -136,11 +111,6 @@ class DescribeMessageBuilder:
         """
 
         def should_format_file_content_with_language(self, message_builder, file_gateway, mocker):
-            """
-            Given a MessageBuilder
-            When _file_content_partial is called
-            Then it should format the file content with the correct language
-            """
             file_path = Path("/path/to/file.py")
             mocker.patch.object(message_builder.type_sensor, 'get_language', return_value='python')
 
@@ -153,11 +123,6 @@ class DescribeMessageBuilder:
             assert "```" in result
 
         def should_strip_whitespace_from_file_content(self, message_builder, file_gateway, file_path, whitespace_file_content, mocker):
-            """
-            Given a MessageBuilder
-            When _file_content_partial is called with content that has whitespace above and below
-            Then it should strip the whitespace when putting it in code fences
-            """
             # Use the fixtures instead of creating file path and content directly
             file_gateway.read.return_value = whitespace_file_content
             mocker.patch.object(message_builder.type_sensor, 'get_language', return_value='text')
@@ -182,11 +147,6 @@ class DescribeMessageBuilder:
         """
 
         def should_add_image_path_to_list(self, message_builder):
-            """
-            Given a MessageBuilder
-            When add_image is called with a path
-            Then it should add the path to the image_paths list
-            """
             image_path = Path("/path/to/image.jpg")
 
             result = message_builder.add_image(image_path)
@@ -195,11 +155,6 @@ class DescribeMessageBuilder:
             assert result is message_builder  # Returns self for method chaining
 
         def should_convert_string_path_to_path_object(self, message_builder):
-            """
-            Given a MessageBuilder
-            When add_image is called with a string path
-            Then it should convert the string to a Path object
-            """
             image_path_str = "/path/to/image.jpg"
 
             message_builder.add_image(image_path_str)
@@ -212,11 +167,6 @@ class DescribeMessageBuilder:
         """
 
         def should_add_multiple_specific_images(self, message_builder):
-            """
-            Given a MessageBuilder
-            When add_images is called with multiple specific image paths
-            Then it should add all paths to the image_paths list
-            """
             image_path1 = Path("/path/to/image1.jpg")
             image_path2 = Path("/path/to/image2.jpg")
 
@@ -227,11 +177,6 @@ class DescribeMessageBuilder:
             assert result is message_builder  # Returns self for method chaining
 
         def should_add_all_jpg_images_from_directory(self, message_builder, mocker):
-            """
-            Given a MessageBuilder
-            When add_images is called with a directory path
-            Then it should add all JPG images in that directory
-            """
             dir_path = Path("/path/to/images")
             jpg_files = [Path("/path/to/images/image1.jpg"), Path("/path/to/images/image2.jpg")]
 
@@ -246,11 +191,6 @@ class DescribeMessageBuilder:
             assert jpg_files[1] in message_builder.image_paths
 
         def should_add_images_matching_glob_pattern(self, message_builder, mocker):
-            """
-            Given a MessageBuilder
-            When add_images is called with a path containing a wildcard
-            Then it should add all matching files
-            """
             pattern_path = Path("/path/to/*.jpg")
             matching_files = [Path("/path/to/image1.jpg"), Path("/path/to/image2.jpg")]
 
@@ -276,11 +216,6 @@ class DescribeMessageBuilder:
         """
 
         def should_load_content_from_file(self, message_builder, file_gateway, file_path):
-            """
-            Given a MessageBuilder
-            When load_content is called with a file path
-            Then it should load the content from the file and set it as the content
-            """
             result = message_builder.load_content(file_path)
 
             file_gateway.read.assert_called_once_with(file_path)
@@ -288,11 +223,6 @@ class DescribeMessageBuilder:
             assert result is message_builder  # Returns self for method chaining
 
         def should_convert_string_path_to_path_object(self, message_builder, file_gateway):
-            """
-            Given a MessageBuilder
-            When load_content is called with a string path
-            Then it should convert the string to a Path object
-            """
             file_path_str = "/path/to/file.txt"
 
             message_builder.load_content(file_path_str)
@@ -300,22 +230,12 @@ class DescribeMessageBuilder:
             file_gateway.read.assert_called_once_with(Path(file_path_str))
 
         def should_raise_error_if_file_not_found(self, message_builder, file_gateway, file_path):
-            """
-            Given a MessageBuilder
-            When load_content is called with a non-existent file
-            Then it should raise a FileNotFoundError
-            """
             file_gateway.exists.return_value = False
 
             with pytest.raises(FileNotFoundError):
                 message_builder.load_content(file_path)
 
         def should_replace_placeholders_with_template_values(self, message_builder, file_gateway, file_path):
-            """
-            Given a MessageBuilder
-            When load_content is called with a file path and template values
-            Then it should replace placeholders in the content with the corresponding values
-            """
             # Set up the file content with placeholders
             file_gateway.read.return_value = "Hello, {name}! Today is {day}."
 

mojentic/llm/tools/ask_user_tool.py

@@ -12,7 +12,7 @@ class AskUserTool(LLMTool):
             "type": "function",
             "function": {
                 "name": "ask_user",
-                "description": "If you do not know how to proceed, ask the user a question, or ask them to do something for you.",
+                "description": "If you do not know how to proceed, ask the user a question, or ask them for help or to do something for you.",
                 "parameters": {
                     "type": "object",
                     "properties": {

mojentic/llm/tools/ephemeral_task_manager/__init__.py

@@ -0,0 +1,27 @@
+"""
+Ephemeral Task Manager tools for managing a list of tasks.
+
+This module provides tools for appending, prepending, inserting, starting, completing, and listing tasks.
+Tasks follow a state machine that transitions from PENDING through IN_PROGRESS to COMPLETED.
+"""
+
+from mojentic.llm.tools.ephemeral_task_manager.append_task_tool import AppendTaskTool
+from mojentic.llm.tools.ephemeral_task_manager.clear_tasks_tool import ClearTasksTool
+from mojentic.llm.tools.ephemeral_task_manager.complete_task_tool import CompleteTaskTool
+from mojentic.llm.tools.ephemeral_task_manager.insert_task_after_tool import InsertTaskAfterTool
+from mojentic.llm.tools.ephemeral_task_manager.list_tasks_tool import ListTasksTool
+from mojentic.llm.tools.ephemeral_task_manager.prepend_task_tool import PrependTaskTool
+from mojentic.llm.tools.ephemeral_task_manager.start_task_tool import StartTaskTool
+from mojentic.llm.tools.ephemeral_task_manager.ephemeral_task_list import EphemeralTaskList, Task
+
+__all__ = [
+    "EphemeralTaskList",
+    "Task",
+    "AppendTaskTool",
+    "PrependTaskTool",
+    "InsertTaskAfterTool",
+    "StartTaskTool",
+    "CompleteTaskTool",
+    "ListTasksTool",
+    "ClearTasksTool",
+]