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

mojentic/llm/tools/ephemeral_task_manager/insert_task_after_tool.py

@@ -0,0 +1,84 @@
+"""
+Tool for inserting a new task after an existing task in the ephemeral task manager list.
+"""
+
+from typing import Dict
+
+from mojentic.llm.tools.llm_tool import LLMTool
+from mojentic.llm.tools.ephemeral_task_manager.ephemeral_task_list import EphemeralTaskList
+
+
+class InsertTaskAfterTool(LLMTool):
+    """
+    Tool for inserting a new task after an existing task in the ephemeral task manager list.
+    """
+
+    def __init__(self, task_list: EphemeralTaskList):
+        """
+        Initialize the tool with a shared task list.
+
+        Args:
+            task_list: The shared task list to use
+        """
+        self._task_list = task_list
+
+    def run(self, existing_task_id: int, description: str) -> Dict[str, str]:
+        """
+        Insert a new task after an existing task.
+
+        Args:
+            existing_task_id: The ID of the existing task after which to insert the new task
+            description: The description of the new task
+
+        Returns:
+            A dictionary with the result of the operation
+
+        Raises:
+            ValueError: If no task with the given ID exists
+        """
+        try:
+            # Convert existing_task_id to int if it's a string
+            task_id = int(existing_task_id) if isinstance(existing_task_id, str) else existing_task_id
+            task = self._task_list.insert_task_after(existing_task_id=task_id, description=description)
+            return {
+                "id": task.id,
+                "description": task.description,
+                "status": task.status.value,
+                "summary": f"Task '{task.id}' inserted after task '{existing_task_id}' successfully"
+            }
+        except ValueError as e:
+            return {
+                "error": str(e),
+                "summary": f"Failed to insert task: {str(e)}"
+            }
+
+    @property
+    def descriptor(self):
+        """
+        Get the descriptor for the tool.
+
+        Returns:
+            The descriptor dictionary
+        """
+        return {
+            "type": "function",
+            "function": {
+                "name": "insert_task_after",
+                "description": "Insert a new task after an existing task in the task list. The task will start with 'pending' status.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "existing_task_id": {
+                            "type": "integer",
+                            "description": "The ID of the existing task after which to insert the new task"
+                        },
+                        "description": {
+                            "type": "string",
+                            "description": "The description of the new task"
+                        }
+                    },
+                    "required": ["existing_task_id", "description"],
+                    "additionalProperties": False
+                }
+            }
+        }

mojentic/llm/tools/ephemeral_task_manager/insert_task_after_tool_spec.py

@@ -0,0 +1,42 @@
+from unittest.mock import Mock
+
+import pytest
+
+from mojentic.llm.tools.ephemeral_task_manager.ephemeral_task_list import EphemeralTaskList, Task, TaskStatus
+from mojentic.llm.tools.ephemeral_task_manager.insert_task_after_tool import InsertTaskAfterTool
+
+
+@pytest.fixture
+def mock_task_list():
+    mock = Mock(spec=EphemeralTaskList)
+    return mock
+
+
+@pytest.fixture
+def insert_task_after_tool(mock_task_list):
+    return InsertTaskAfterTool(task_list=mock_task_list)
+
+
+class DescribeInsertTaskAfterTool:
+    def should_call_insert_task_after_with_correct_parameters(self, insert_task_after_tool, mock_task_list):
+        mock_task = Task(id=2, description="Test task", status=TaskStatus.PENDING)
+        mock_task_list.insert_task_after.return_value = mock_task
+
+        insert_task_after_tool.run(existing_task_id=1, description="Test task")
+
+        mock_task_list.insert_task_after.assert_called_once_with(existing_task_id=1, description="Test task")
+
+    def should_convert_string_task_id_to_int(self, insert_task_after_tool, mock_task_list):
+        mock_task = Task(id=2, description="Test task", status=TaskStatus.PENDING)
+        mock_task_list.insert_task_after.return_value = mock_task
+
+        insert_task_after_tool.run(existing_task_id="1", description="Test task")
+
+        mock_task_list.insert_task_after.assert_called_once_with(existing_task_id=1, description="Test task")
+
+    def should_handle_error_when_insert_task_after_fails(self, insert_task_after_tool, mock_task_list):
+        mock_task_list.insert_task_after.side_effect = ValueError("No task with ID '999' exists")
+
+        insert_task_after_tool.run(existing_task_id=999, description="Test task")
+
+        mock_task_list.insert_task_after.assert_called_once_with(existing_task_id=999, description="Test task")

mojentic/llm/tools/ephemeral_task_manager/list_tasks_tool.py

@@ -0,0 +1,80 @@
+"""
+Tool for listing all tasks in the ephemeral task manager.
+"""
+
+from typing import Dict, List
+
+from mojentic.llm.tools.ephemeral_task_manager.ephemeral_task_list import EphemeralTaskList, Task
+from mojentic.llm.tools.llm_tool import LLMTool
+
+
+class ListTasksTool(LLMTool):
+    """
+    Tool for listing all tasks in the ephemeral task manager.
+    """
+
+    def __init__(self, task_list: EphemeralTaskList):
+        """
+        Initialize the tool with a shared task list.
+
+        Args:
+            task_list: The shared task list to use
+        """
+        self._task_list = task_list
+
+    def run(self) -> Dict[str, str]:
+        """
+        Get all tasks in the list.
+
+        Returns:
+            A dictionary with the result of the operation
+        """
+        tasks = self._task_list.list_tasks()
+
+        # Format tasks as a string for the summary
+        task_list_str = self._format_tasks(tasks)
+
+        return {
+            "count": str(len(tasks)),
+            "tasks": task_list_str,
+            "summary": f"Found {len(tasks)} tasks\n\n{task_list_str}"
+        }
+
+    def _format_tasks(self, tasks: List[Task]) -> str:
+        """
+        Format a list of tasks as a string.
+
+        Args:
+            tasks: The list of tasks to format
+
+        Returns:
+            A formatted string representation of the tasks
+        """
+        if not tasks:
+            return "No tasks found."
+
+        result = [f"{task.id}. {task.description} ({task.status.value})"
+                  for i, task in enumerate(tasks)]
+
+        return "\n".join(result)
+
+    @property
+    def descriptor(self):
+        """
+        Get the descriptor for the tool.
+
+        Returns:
+            The descriptor dictionary
+        """
+        return {
+            "type": "function",
+            "function": {
+                "name": "list_tasks",
+                "description": "List all tasks in the task list.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {},
+                    "additionalProperties": False
+                }
+            }
+        }

mojentic/llm/tools/ephemeral_task_manager/list_tasks_tool_spec.py

@@ -0,0 +1,38 @@
+from unittest.mock import Mock
+
+import pytest
+
+from mojentic.llm.tools.ephemeral_task_manager.ephemeral_task_list import EphemeralTaskList, Task, TaskStatus
+from mojentic.llm.tools.ephemeral_task_manager.list_tasks_tool import ListTasksTool
+
+
+@pytest.fixture
+def mock_task_list():
+    mock = Mock(spec=EphemeralTaskList)
+    return mock
+
+
+@pytest.fixture
+def list_tasks_tool(mock_task_list):
+    return ListTasksTool(task_list=mock_task_list)
+
+
+class DescribeListTasksTool:
+    def should_call_list_tasks(self, list_tasks_tool, mock_task_list):
+        mock_tasks = [
+            Task(id=1, description="Task 1", status=TaskStatus.PENDING),
+            Task(id=2, description="Task 2", status=TaskStatus.IN_PROGRESS),
+            Task(id=3, description="Task 3", status=TaskStatus.COMPLETED)
+        ]
+        mock_task_list.list_tasks.return_value = mock_tasks
+
+        list_tasks_tool.run()
+
+        mock_task_list.list_tasks.assert_called_once()
+
+    def should_handle_empty_list(self, list_tasks_tool, mock_task_list):
+        mock_task_list.list_tasks.return_value = []
+
+        list_tasks_tool.run()
+
+        mock_task_list.list_tasks.assert_called_once()

mojentic/llm/tools/ephemeral_task_manager/prepend_task_tool.py

@@ -0,0 +1,77 @@
+"""
+Tool for prepending a new task to the beginning of the ephemeral task manager list.
+"""
+
+from typing import Dict
+
+from mojentic.llm.tools.llm_tool import LLMTool
+from mojentic.llm.tools.ephemeral_task_manager.ephemeral_task_list import EphemeralTaskList
+
+
+class PrependTaskTool(LLMTool):
+    """
+    Tool for prepending a new task to the beginning of the ephemeral task manager list.
+    """
+
+    def __init__(self, task_list: EphemeralTaskList):
+        """
+        Initialize the tool with a shared task list.
+
+        Args:
+            task_list: The shared task list to use
+        """
+        self._task_list = task_list
+
+    def run(self, description: str) -> Dict[str, str]:
+        """
+        Prepend a new task to the beginning of the list.
+
+        Args:
+            description: The description of the task
+
+        Returns:
+            A dictionary with the result of the operation
+
+        Raises:
+            ValueError: If there's an error adding the task
+        """
+        try:
+            task = self._task_list.prepend_task(description=description)
+            return {
+                "id": task.id,
+                "description": task.description,
+                "status": task.status.value,
+                "summary": f"Task '{task.id}' prepended successfully"
+            }
+        except ValueError as e:
+            return {
+                "error": str(e),
+                "summary": f"Failed to prepend task: {str(e)}"
+            }
+
+    @property
+    def descriptor(self):
+        """
+        Get the descriptor for the tool.
+
+        Returns:
+            The descriptor dictionary
+        """
+        return {
+            "type": "function",
+            "function": {
+                "name": "prepend_task",
+                "description": "Prepend a new task to the beginning of the task list with a description. The task will start with 'pending' status.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "description": {
+                            "type": "string",
+                            "description": "The description of the task"
+                        }
+                    },
+                    "required": ["description"],
+                    "additionalProperties": False
+                }
+            }
+        }

mojentic/llm/tools/ephemeral_task_manager/prepend_task_tool_spec.py

@@ -0,0 +1,34 @@
+from unittest.mock import Mock
+
+import pytest
+
+from mojentic.llm.tools.ephemeral_task_manager.ephemeral_task_list import EphemeralTaskList, Task, TaskStatus
+from mojentic.llm.tools.ephemeral_task_manager.prepend_task_tool import PrependTaskTool
+
+
+@pytest.fixture
+def mock_task_list():
+    mock = Mock(spec=EphemeralTaskList)
+    return mock
+
+
+@pytest.fixture
+def prepend_task_tool(mock_task_list):
+    return PrependTaskTool(task_list=mock_task_list)
+
+
+class DescribePrependTaskTool:
+    def should_call_prepend_task_with_description(self, prepend_task_tool, mock_task_list):
+        mock_task = Task(id=1, description="Test task", status=TaskStatus.PENDING)
+        mock_task_list.prepend_task.return_value = mock_task
+
+        prepend_task_tool.run(description="Test task")
+
+        mock_task_list.prepend_task.assert_called_once_with(description="Test task")
+
+    def should_handle_error_when_prepend_task_fails(self, prepend_task_tool, mock_task_list):
+        mock_task_list.prepend_task.side_effect = ValueError("Test error")
+
+        prepend_task_tool.run(description="Test task")
+
+        mock_task_list.prepend_task.assert_called_once_with(description="Test task")

mojentic/llm/tools/ephemeral_task_manager/start_task_tool.py

@@ -0,0 +1,81 @@
+"""
+Tool for starting a task in the ephemeral task manager.
+"""
+
+from typing import Dict
+
+from mojentic.llm.tools.llm_tool import LLMTool
+from mojentic.llm.tools.ephemeral_task_manager.ephemeral_task_list import EphemeralTaskList
+
+
+class StartTaskTool(LLMTool):
+    """
+    Tool for starting a task in the ephemeral task manager.
+
+    This tool changes a task's status from PENDING to IN_PROGRESS.
+    """
+
+    def __init__(self, task_list: EphemeralTaskList):
+        """
+        Initialize the tool with a shared task list.
+
+        Args:
+            task_list: The shared task list to use
+        """
+        self._task_list = task_list
+
+    def run(self, id: int) -> Dict[str, str]:
+        """
+        Start a task by changing its status from PENDING to IN_PROGRESS.
+
+        Args:
+            id: The ID of the task to start
+
+        Returns:
+            A dictionary with the result of the operation
+
+        Raises:
+            ValueError: If no task with the given ID exists or if the task is not in PENDING status
+        """
+        try:
+            # Convert id to int if it's a string
+            task_id = int(id) if isinstance(id, str) else id
+            task = self._task_list.start_task(id=task_id)
+            return {
+                "id": task.id,
+                "description": task.description,
+                "status": task.status.value,
+                "summary": f"Task '{id}' started successfully"
+            }
+        except ValueError as e:
+            return {
+                "error": str(e),
+                "summary": f"Failed to start task: {str(e)}"
+            }
+
+    @property
+    def descriptor(self):
+        """
+        Get the descriptor for the tool.
+
+        Returns:
+            The descriptor dictionary
+        """
+        return {
+            "type": "function",
+            "function": {
+                "name": "start_task",
+                "description": "Start a task by changing its status from PENDING to IN_PROGRESS.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "id": {
+                            "type": "integer",
+                            "description": "The ID of the task to start"
+                        }
+                    },
+                    "required": ["id"],
+                    "additionalProperties": False
+                }
+            }
+        }

mojentic/llm/tools/ephemeral_task_manager/start_task_tool_spec.py

@@ -0,0 +1,43 @@
+from unittest.mock import Mock
+
+import pytest
+
+from mojentic.llm.tools.ephemeral_task_manager.ephemeral_task_list import EphemeralTaskList, Task, TaskStatus
+from mojentic.llm.tools.ephemeral_task_manager.start_task_tool import StartTaskTool
+
+
+@pytest.fixture
+def mock_task_list():
+    mock = Mock(spec=EphemeralTaskList)
+    return mock
+
+
+@pytest.fixture
+def start_task_tool(mock_task_list):
+    return StartTaskTool(task_list=mock_task_list)
+
+
+class DescribeStartTaskTool:
+    def should_call_start_task_with_correct_id(self, start_task_tool, mock_task_list):
+        mock_task = Task(id=1, description="Test task", status=TaskStatus.IN_PROGRESS)
+        mock_task_list.start_task.return_value = mock_task
+
+        start_task_tool.run(id=1)
+
+        mock_task_list.start_task.assert_called_once_with(id=1)
+
+    def should_convert_string_id_to_int(self, start_task_tool, mock_task_list):
+        mock_task = Task(id=1, description="Test task", status=TaskStatus.IN_PROGRESS)
+        mock_task_list.start_task.return_value = mock_task
+
+        start_task_tool.run(id="1")
+
+        mock_task_list.start_task.assert_called_once_with(id=1)
+
+    def should_handle_error_when_start_task_fails(self, start_task_tool, mock_task_list):
+        error_message = "Task '1' cannot be started because it is not in PENDING status"
+        mock_task_list.start_task.side_effect = ValueError(error_message)
+
+        start_task_tool.run(id=1)
+
+        mock_task_list.start_task.assert_called_once_with(id=1)

mojentic/llm/tools/organic_web_search.py

@@ -0,0 +1,37 @@
+import json
+import os
+
+import serpapi
+
+from mojentic.llm.tools.llm_tool import LLMTool
+
+
+class OrganicWebSearchTool(LLMTool):
+    def __init__(self, api_key: str = None):
+        self.api_key = api_key or os.getenv("SERPAPI_API_KEY")
+
+    def run(self, query: str, engine: str = "google", location: str = None, hl: str = "en", gl="ca") -> str:
+        results = serpapi.search(q=query, engine=engine, location=location, hl=hl, gl=gl, api_key=self.api_key)
+        # Limiting this to the organic results cuts this from 60K to 3K tokens
+        return json.dumps(results['organic_results'], indent=2)
+
+    @property
+    def descriptor(self):
+        return {
+            "type": "function",
+            "function": {
+                "name": "organic_web_search",
+                "description":
+                    "Search the Internet for information matching the given query and return the organic search results.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "query": {
+                            "type": "string",
+                            "description": "The search query."
+                        },
+                    },
+                    "required": ["query"]
+                },
+            },
+        }

mojentic/llm/tools/tell_user_tool.py

@@ -0,0 +1,27 @@
+from mojentic.llm.tools.llm_tool import LLMTool
+
+
+class TellUserTool(LLMTool):
+    def run(self, message: str) -> str:
+        print(f"\n\n\nMESSAGE FROM ASSISTANT:\n{message}")
+        return "Message delivered to user."
+
+    @property
+    def descriptor(self):
+        return {
+            "type": "function",
+            "function": {
+                "name": "tell_user",
+                "description": "Display a message to the user without expecting a response. Use this to send important intermediate information to the user as you work on completing their request.",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "message": {
+                            "type": "string",
+                            "description": "The important message you want to display to the user."
+                        }
+                    },
+                    "required": ["message"]
+                },
+            },
+        }

{mojentic-0.5.3.dist-info → mojentic-0.5.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mojentic
-Version: 0.5.3
+Version: 0.5.5
 Summary: Mojentic is an agentic framework that aims to provide a simple and flexible way to assemble teams of agents to solve complex problems.
 Author-email: Stacey Vetzal <stacey@vetzal.com>
 Project-URL: Homepage, https://github.com/mojility/mojentic
@@ -13,6 +13,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE.md
 Requires-Dist: pydantic
 Requires-Dist: structlog
+Requires-Dist: numpy
 Requires-Dist: ollama
 Requires-Dist: openai
 Requires-Dist: anthropic