@_vrsen/openswarm 0.1.0

package/virtual_assistant/tools/FindEmails.py

@@ -0,0 +1,330 @@
+from typing import Literal, Optional, List
+from agency_swarm.tools import BaseTool
+from pydantic import Field
+import json
+
+from helpers import execute_composio_tool
+
+
+class FindEmails(BaseTool):
+    """
+    Searches and retrieves emails with flexible filtering options.
+    
+    For Gmail: Uses Gmail's powerful query syntax (is:unread, from:, subject:, etc.)
+    For Outlook: Uses structured filters for folder, read status, sender, etc.
+    
+    Common use cases:
+    - Find unread emails: query="is:unread" (Gmail) or is_read=False (Outlook)
+    - Find emails in inbox: query="in:inbox" or label_ids=["INBOX"]
+    - Find starred emails: query="is:starred" or label_ids=["STARRED"]
+    - Find emails from someone: query="from:someone@example.com"
+    - Find emails with attachments: query="has:attachment"
+    - Find emails after date: query="after:2026/01/01"
+    """
+    
+    provider: Literal["gmail", "outlook"] = Field(
+        ...,
+        description="Email provider: 'gmail' or 'outlook'"
+    )
+    
+    # Gmail-specific: flexible query
+    query: Optional[str] = Field(
+        default=None,
+        description="Gmail search query. Examples: 'is:unread', 'from:user@example.com', 'subject:meeting', 'has:attachment', 'after:2026/01/01', 'in:inbox -in:trash'. Can combine with AND/OR."
+    )
+    
+    # Common filters (work for both)
+    label_ids: Optional[List[str]] = Field(
+        default=None,
+        description="Gmail: Label IDs to filter by (e.g., ['INBOX', 'UNREAD', 'STARRED']). Outlook: ignored, use folder instead."
+    )
+    
+    # Outlook-specific filters
+    folder: Optional[str] = Field(
+        default="inbox",
+        description="Outlook folder: 'inbox', 'archive', 'sentitems', 'drafts', 'deleteditems', 'junkemail'. Gmail: ignored."
+    )
+    
+    is_read: Optional[bool] = Field(
+        default=None,
+        description="Outlook: Filter by read status (True=read, False=unread, None=all). Gmail: use query='is:unread' instead."
+    )
+    
+    from_address: Optional[str] = Field(
+        default=None,
+        description="Filter by sender email address. Gmail: use query='from:...' instead."
+    )
+    
+    subject_contains: Optional[str] = Field(
+        default=None,
+        description="Filter by subject containing text. Gmail: use query='subject:...' instead."
+    )
+    
+    has_attachments: Optional[bool] = Field(
+        default=None,
+        description="Filter by attachment presence. Gmail: use query='has:attachment' instead."
+    )
+    
+    received_after: Optional[str] = Field(
+        default=None,
+        description="Filter emails received after date (ISO format: 2026-01-01T00:00:00Z). Gmail: use query='after:2026/01/01' instead."
+    )
+    
+    # Pagination and limits
+    limit: int = Field(
+        default=20,
+        ge=1,
+        le=100,
+        description="Maximum number of emails to return (1-100)"
+    )
+    
+    page_token: Optional[str] = Field(
+        default=None,
+        description="Token for fetching next page of results"
+    )
+    
+    def run(self):
+        try:
+            if self.provider == "gmail":
+                return self._find_gmail_emails(execute_composio_tool)
+            else:
+                return self._find_outlook_emails(execute_composio_tool)
+                
+        except Exception as e:
+            return f"Error finding emails: {str(e)}"
+    
+    def _find_gmail_emails(self, execute_tool) -> str:
+        """Finds emails in Gmail using query syntax."""
+        arguments = {
+            "user_id": "me",
+            "max_results": self.limit,
+            "include_payload": False,
+            "verbose": False
+        }
+        
+        # Add query if provided
+        if self.query:
+            arguments["query"] = self.query
+        
+        # Add label filtering
+        if self.label_ids:
+            arguments["label_ids"] = self.label_ids
+        
+        # Add pagination
+        if self.page_token:
+            arguments["page_token"] = self.page_token
+        
+        # Execute search
+        result = execute_tool(
+            tool_name="GMAIL_FETCH_EMAILS",
+            arguments=arguments,
+        )
+        
+        if isinstance(result, dict) and result.get("error"):
+            return f"Error searching Gmail: {result.get('error')}"
+        
+        data = result.get("data", {})
+        messages = data.get("messages", [])
+        next_page_token = data.get("nextPageToken")
+        
+        if not messages:
+            return json.dumps({
+                "provider": "gmail",
+                "query": self.query,
+                "count": 0,
+                "emails": [],
+                "next_page_token": None
+            }, indent=2)
+        
+        # Sort by timestamp (newest first by default)
+        messages_sorted = sorted(
+            messages, 
+            key=lambda m: m.get("messageTimestamp", ""),
+            reverse=True
+        )
+        
+        # Format output
+        formatted_emails = []
+        for msg in messages_sorted:
+            formatted_emails.append({
+                "subject": msg.get("subject", "(No subject)"),
+                "from": msg.get("sender", "Unknown"),
+                "message_id": msg.get("messageId"),
+                "thread_id": msg.get("threadId"),
+                "received_at": msg.get("messageTimestamp"),
+                "labels": msg.get("labelIds", []),
+                "snippet": msg.get("snippet", "")[:100] if msg.get("snippet") else ""
+            })
+        
+        return json.dumps({
+            "provider": "gmail",
+            "query": self.query,
+            "count": len(formatted_emails),
+            "emails": formatted_emails,
+            "next_page_token": next_page_token
+        }, indent=2)
+    
+    def _find_outlook_emails(self, execute_tool) -> str:
+        """Finds emails in Outlook using structured filters."""
+        arguments = {
+            "user_id": "me",
+            "folder": self.folder or "inbox",
+            "top": self.limit,
+            "orderby": ["receivedDateTime desc"],
+            "select": ["id", "subject", "from", "receivedDateTime", "conversationId", "categories", "isRead", "hasAttachments", "bodyPreview"]
+        }
+        
+        # Apply filters
+        if self.is_read is not None:
+            arguments["is_read"] = self.is_read
+        
+        if self.from_address:
+            arguments["from_address"] = self.from_address
+        
+        if self.subject_contains:
+            arguments["subject_contains"] = self.subject_contains
+        
+        if self.has_attachments is not None:
+            arguments["has_attachments"] = self.has_attachments
+        
+        if self.received_after:
+            arguments["received_date_time_gt"] = self.received_after
+        
+        if self.label_ids:
+            arguments["categories"] = self.label_ids
+        
+        # Add pagination
+        if self.page_token:
+            try:
+                arguments["skip"] = int(self.page_token)
+            except ValueError:
+                return f"Error: Invalid page_token for Outlook. Expected a number."
+        
+        # Execute search
+        result = execute_tool(
+            tool_name="OUTLOOK_LIST_MESSAGES",
+            arguments=arguments,
+        )
+        
+        if isinstance(result, dict) and result.get("error"):
+            return f"Error searching Outlook: {result.get('error')}"
+        
+        data = result.get("data", {})
+        messages = data.get("value", [])
+        
+        # Calculate next page token
+        current_skip = int(self.page_token) if self.page_token else 0
+        next_page_token = None
+        if len(messages) == self.limit:
+            next_page_token = str(current_skip + self.limit)
+        
+        if not messages:
+            return json.dumps({
+                "provider": "outlook",
+                "folder": self.folder,
+                "filters": {
+                    "is_read": self.is_read,
+                    "from_address": self.from_address,
+                    "subject_contains": self.subject_contains,
+                    "has_attachments": self.has_attachments
+                },
+                "count": 0,
+                "emails": [],
+                "next_page_token": None
+            }, indent=2)
+        
+        # Format output
+        formatted_emails = []
+        for msg in messages:
+            from_info = msg.get("from", {}).get("emailAddress", {})
+            formatted_emails.append({
+                "subject": msg.get("subject", "(No subject)"),
+                "from": f"{from_info.get('name', '')} <{from_info.get('address', 'Unknown')}>",
+                "message_id": msg.get("id"),
+                "conversation_id": msg.get("conversationId"),
+                "received_at": msg.get("receivedDateTime"),
+                "categories": msg.get("categories", []),
+                "is_read": msg.get("isRead"),
+                "has_attachments": msg.get("hasAttachments"),
+                "snippet": (msg.get("bodyPreview") or "")[:100]
+            })
+        
+        return json.dumps({
+            "provider": "outlook",
+            "folder": self.folder,
+            "filters": {
+                "is_read": self.is_read,
+                "from_address": self.from_address,
+                "subject_contains": self.subject_contains,
+                "has_attachments": self.has_attachments
+            },
+            "count": len(formatted_emails),
+            "emails": formatted_emails,
+            "next_page_token": next_page_token
+        }, indent=2)
+
+
+if __name__ == "__main__":
+    import sys
+    import os
+    sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")))
+    
+    print("=" * 60)
+    print("FindEmails Test Suite")
+    print("=" * 60)
+    print()
+    
+    # Test 1: Gmail - Find unread emails
+    print("Test 1: Gmail - Find unread emails")
+    print("-" * 60)
+    tool = FindEmails(provider="gmail", query="is:unread", limit=3)
+    result = tool.run()
+    data = json.loads(result)
+    print(f"Query: {data.get('query')}")
+    print(f"Count: {data.get('count')}")
+    if data.get("emails"):
+        print(f"First email: {data['emails'][0]['subject'][:50]}...")
+    print()
+    
+    # Test 2: Gmail - Find starred emails
+    print("Test 2: Gmail - Find starred emails in inbox")
+    print("-" * 60)
+    tool = FindEmails(provider="gmail", query="is:starred in:inbox", limit=3)
+    result = tool.run()
+    data = json.loads(result)
+    print(f"Query: {data.get('query')}")
+    print(f"Count: {data.get('count')}")
+    print()
+    
+    # Test 3: Gmail - Find emails with attachments
+    print("Test 3: Gmail - Find emails with attachments")
+    print("-" * 60)
+    tool = FindEmails(provider="gmail", query="has:attachment", limit=3)
+    result = tool.run()
+    data = json.loads(result)
+    print(f"Query: {data.get('query')}")
+    print(f"Count: {data.get('count')}")
+    print()
+    
+    # Test 4: Gmail - Find emails from specific sender
+    print("Test 4: Gmail - Find emails from specific sender")
+    print("-" * 60)
+    tool = FindEmails(provider="gmail", query="from:noreply", limit=3)
+    result = tool.run()
+    data = json.loads(result)
+    print(f"Query: {data.get('query')}")
+    print(f"Count: {data.get('count')}")
+    print()
+    
+    # Test 5: Outlook - Find unread emails
+    print("Test 5: Outlook - Find unread emails in inbox")
+    print("-" * 60)
+    tool = FindEmails(provider="outlook", folder="inbox", is_read=False, limit=3)
+    result = tool.run()
+    print(result[:500])
+    print()
+    
+    print("=" * 60)
+    print("All tests completed!")
+    print("=" * 60)
+

package/virtual_assistant/tools/GetCurrentTime.py

@@ -0,0 +1,69 @@
+from agency_swarm.tools import BaseTool
+from pydantic import Field
+from datetime import datetime
+import pytz
+
+
+class GetCurrentTime(BaseTool):
+    """
+    Retrieves the current date and time in a specified timezone.
+    Use this when you need to know what time it is, or to provide accurate time-based information.
+    """
+    timezone: str = Field(
+        default="UTC",
+        description="The timezone to retrieve the current time in (e.g., 'UTC', 'US/Eastern', 'Europe/London', 'Asia/Tokyo'). Defaults to UTC."
+    )
+    include_day_of_week: bool = Field(
+        default=True,
+        description="If True, includes the day of the week in the output. Defaults to True."
+    )
+
+    def run(self):
+        """Retrieves the current date and time in the specified timezone."""
+        try:
+            tz = pytz.timezone(self.timezone)
+            current_time = datetime.now(tz)
+
+            if self.include_day_of_week:
+                formatted_time = current_time.strftime("%A, %B %d, %Y - %I:%M:%S %p %Z")
+            else:
+                formatted_time = current_time.strftime("%B %d, %Y - %I:%M:%S %p %Z")
+
+            return f"Current time in {self.timezone}: {formatted_time}"
+        
+        except pytz.exceptions.UnknownTimeZoneError:
+            return f"Error: Unknown timezone '{self.timezone}'. Please provide a valid timezone (e.g., 'UTC', 'US/Eastern', 'Europe/London')."
+        except Exception as e:
+            return f"Error retrieving current time: {str(e)}"
+
+
+if __name__ == "__main__":
+    # Test 1: Current time in UTC
+    print("=== Test 1: Current time in UTC ===")
+    tool = GetCurrentTime(timezone="UTC")
+    print(tool.run())
+    print()
+    
+    # Test 2: Current time in US/Eastern
+    print("=== Test 2: Current time in US/Eastern ===")
+    tool = GetCurrentTime(timezone="US/Eastern")
+    print(tool.run())
+    print()
+    
+    # Test 3: Current time in Europe/London without day of week
+    print("=== Test 3: Current time in Europe/London (without day of week) ===")
+    tool = GetCurrentTime(timezone="Europe/London", include_day_of_week=False)
+    print(tool.run())
+    print()
+    
+    # Test 4: Current time in Asia/Tokyo
+    print("=== Test 4: Current time in Asia/Tokyo ===")
+    tool = GetCurrentTime(timezone="Asia/Tokyo")
+    print(tool.run())
+    print()
+    
+    # Test 5: Invalid timezone
+    print("=== Test 5: Invalid timezone ===")
+    tool = GetCurrentTime(timezone="Invalid/Timezone")
+    print(tool.run())
+

package/virtual_assistant/tools/GetSlackUserInfo.py

@@ -0,0 +1,117 @@
+from agency_swarm.tools import BaseTool
+from pydantic import Field
+import json
+
+from helpers import execute_composio_tool
+
+
+class GetSlackUserInfo(BaseTool):
+    """
+    Gets Slack user details by ID, email, or name. Returns name, email, title, and status.
+    """
+    
+    user: str = Field(
+        ...,
+        description="User ID (U06NF4U24KE), email, or display name to look up"
+    )
+    
+    def run(self):
+        try:
+            # Determine lookup method
+            if self.user.startswith("U") and len(self.user) == 11:
+                return self._get_by_id(execute_composio_tool, self.user)
+            elif "@" in self.user:
+                return self._get_by_email(execute_composio_tool, self.user)
+            else:
+                return self._get_by_name(execute_composio_tool, self.user)
+                
+        except Exception as e:
+            return f"Error: {str(e)}"
+    
+    def _get_by_id(self, execute_tool, slack_user_id: str) -> str:
+        """Gets user by Slack user ID."""
+        result = execute_tool(
+            tool_name="SLACK_GET_USER_INFO",
+            arguments={"user": slack_user_id},
+        )
+        
+        if result.get("error"):
+            return f"Error: User '{slack_user_id}' not found"
+        
+        user_data = result.get("data", {}).get("user", {})
+        return self._format_user(user_data)
+    
+    def _get_by_email(self, execute_tool, email: str) -> str:
+        """Gets user by email address."""
+        result = execute_tool(
+            tool_name="SLACK_FIND_USER_BY_EMAIL_ADDRESS",
+            arguments={"email": email},
+        )
+        
+        if result.get("error"):
+            return f"Error: User with email '{email}' not found"
+        
+        user_data = result.get("data", {}).get("user", {})
+        return self._format_user(user_data)
+    
+    def _get_by_name(self, execute_tool, name: str) -> str:
+        """Gets user by name search."""
+        result = execute_tool(
+            tool_name="SLACK_FIND_USERS",
+            arguments={"query": name},
+        )
+        
+        if result.get("error"):
+            return f"Error: Could not search for user '{name}'"
+        
+        members = result.get("data", {}).get("members", [])
+        
+        # Find best match
+        name_lower = name.lower()
+        for member in members:
+            username = member.get("name", "").lower()
+            display = member.get("profile", {}).get("display_name", "").lower()
+            real = member.get("profile", {}).get("real_name", "").lower()
+            
+            if name_lower in [username, display, real] or name_lower in real:
+                return self._format_user(member)
+        
+        if members:
+            return self._format_user(members[0])
+        
+        return f"Error: User '{name}' not found"
+    
+    def _format_user(self, user: dict) -> str:
+        """Formats user data for output."""
+        profile = user.get("profile", {})
+        
+        info = {
+            "id": user.get("id"),
+            "name": profile.get("real_name") or user.get("name"),
+            "display_name": profile.get("display_name") or None,
+            "email": profile.get("email") or None,
+            "title": profile.get("title") or None,
+            "status": profile.get("status_text") or None,
+            "timezone": user.get("tz_label") or None,
+            "is_bot": user.get("is_bot", False),
+            "is_admin": user.get("is_admin", False)
+        }
+        
+        # Remove None values
+        info = {k: v for k, v in info.items() if v is not None and v != ""}
+        
+        return json.dumps(info, indent=2)
+
+
+if __name__ == "__main__":
+    import sys
+    import os
+    sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")))
+    
+    print("GetSlackUserInfo Test")
+    print("-" * 40)
+    
+    # Test by name
+    tool = GetSlackUserInfo(user="test_user")
+    print(tool.run())
+

package/virtual_assistant/tools/ListDirectory.py

@@ -0,0 +1,113 @@
+import os
+from typing import Optional
+
+from agency_swarm.tools import BaseTool
+from pydantic import Field
+
+
+class ListDirectory(BaseTool):
+    """
+    Lists files and directories in a given path.
+    Use this tool to explore the project structure and understand the codebase layout.
+    """
+
+    directory_path: str = Field(
+        ...,
+        description="The absolute path to the directory to list",
+    )
+    recursive: Optional[bool] = Field(
+        False,
+        description="If True, list files recursively up to 3 levels deep. Default is False.",
+    )
+    max_depth: Optional[int] = Field(
+        3,
+        description="Maximum depth for recursive listing. Default is 3.",
+    )
+
+    def run(self):
+        try:
+            if not os.path.isabs(self.directory_path):
+                return f"Error: directory_path must be an absolute path. Got: {self.directory_path}"
+
+            if not os.path.exists(self.directory_path):
+                return f"Error: Directory does not exist: {self.directory_path}"
+
+            if not os.path.isdir(self.directory_path):
+                return f"Error: Path is not a directory: {self.directory_path}"
+
+            def list_dir_tree(path: str, prefix: str = "", depth: int = 0) -> str:
+                if depth > self.max_depth:
+                    return ""
+
+                result = []
+                try:
+                    entries = sorted(os.listdir(path))
+                except PermissionError:
+                    return f"{prefix}[Permission Denied]\n"
+
+                # Filter out hidden files and common ignore patterns
+                ignore_patterns = {
+                    "__pycache__",
+                    ".git",
+                    ".venv",
+                    "venv",
+                    "node_modules",
+                    ".pytest_cache",
+                    ".mypy_cache",
+                    ".DS_Store",
+                    "*.pyc",
+                }
+
+                filtered_entries = []
+                for entry in entries:
+                    if entry.startswith("."):
+                        continue
+                    if entry in ignore_patterns:
+                        continue
+                    filtered_entries.append(entry)
+
+                for i, entry in enumerate(filtered_entries):
+                    entry_path = os.path.join(path, entry)
+                    is_last = i == len(filtered_entries) - 1
+
+                    if is_last:
+                        connector = "└── "
+                        new_prefix = prefix + "    "
+                    else:
+                        connector = "├── "
+                        new_prefix = prefix + "│   "
+
+                    if os.path.isdir(entry_path):
+                        result.append(f"{prefix}{connector}{entry}/\n")
+                        if self.recursive and depth < self.max_depth:
+                            result.append(
+                                list_dir_tree(entry_path, new_prefix, depth + 1)
+                            )
+                    else:
+                        result.append(f"{prefix}{connector}{entry}\n")
+
+                return "".join(result)
+
+            output = f"{self.directory_path}/\n"
+            output += list_dir_tree(self.directory_path)
+
+            if not output.strip():
+                return f"Directory is empty: {self.directory_path}"
+
+            return output.rstrip()
+
+        except Exception as e:
+            return f"Error listing directory: {str(e)}"
+
+
+if __name__ == "__main__":
+    # Test the tool with current directory
+    import pathlib
+
+    current_dir = str(pathlib.Path(__file__).parent.parent.absolute())
+
+    tool = ListDirectory(directory_path=current_dir, recursive=True)
+    print("Listing directory structure:")
+    print(tool.run())
+
+