@_vrsen/openswarm 0.1.0

package/virtual_assistant/tools/ReadEmail.py

@@ -0,0 +1,251 @@
+from typing import Literal
+from agency_swarm.tools import BaseTool
+from pydantic import Field
+import json
+import re
+
+from helpers import execute_composio_tool
+
+
+def strip_html(html_content: str) -> str:
+    """Converts HTML to plain text by removing tags and decoding entities."""
+    if not html_content:
+        return ""
+    
+    # Remove style and script tags with their content
+    text = re.sub(r'<style[^>]*>.*?</style>', '', html_content, flags=re.DOTALL | re.IGNORECASE)
+    text = re.sub(r'<script[^>]*>.*?</script>', '', text, flags=re.DOTALL | re.IGNORECASE)
+    
+    # Replace common block elements with newlines
+    text = re.sub(r'<br\s*/?>', '\n', text, flags=re.IGNORECASE)
+    text = re.sub(r'</(p|div|tr|li|h[1-6])>', '\n', text, flags=re.IGNORECASE)
+    text = re.sub(r'</td>', '\t', text, flags=re.IGNORECASE)
+    
+    # Remove all remaining HTML tags
+    text = re.sub(r'<[^>]+>', '', text)
+    
+    # Decode common HTML entities
+    text = text.replace('&nbsp;', ' ')
+    text = text.replace('&amp;', '&')
+    text = text.replace('&lt;', '<')
+    text = text.replace('&gt;', '>')
+    text = text.replace('&quot;', '"')
+    text = text.replace('&#39;', "'")
+    text = text.replace('&apos;', "'")
+    
+    # Clean up whitespace
+    text = re.sub(r'\n\s*\n', '\n\n', text)  # Collapse multiple newlines
+    text = re.sub(r'[ \t]+', ' ', text)  # Collapse multiple spaces
+    text = '\n'.join(line.strip() for line in text.split('\n'))  # Strip each line
+    text = text.strip()
+    
+    return text
+
+
+class ReadEmail(BaseTool):
+    """
+    Reads the full content of a specific email by its message ID.
+    
+    Use this after CheckUnreadEmails to fetch the complete email content
+    when you need to read the full message body.
+    """
+    
+    provider: Literal["gmail", "outlook"] = Field(
+        ...,
+        description="Email provider: 'gmail' or 'outlook'"
+    )
+    
+    message_id: str = Field(
+        ...,
+        description="The message ID to fetch (obtained from CheckUnreadEmails)"
+    )
+    
+    body_format: Literal["text", "html"] = Field(
+        default="text",
+        description="Format for the email body: 'text' (plain text, default) or 'html' (raw HTML). Keep the default to save tokens."
+    )
+    
+    def run(self):
+        try:
+            if self.provider == "gmail":
+                return self._read_gmail_message(execute_composio_tool)
+            else:
+                return self._read_outlook_message(execute_composio_tool)
+                
+        except Exception as e:
+            return f"Error reading email: {str(e)}"
+    
+    def _read_gmail_message(self, execute_tool) -> str:
+        """Reads a Gmail message by ID."""
+        result = execute_tool(
+            tool_name="GMAIL_FETCH_MESSAGE_BY_MESSAGE_ID",
+            arguments={
+                "user_id": "me",
+                "message_id": self.message_id,
+                "format": "full"
+            },
+        )
+        
+        if isinstance(result, dict) and result.get("error"):
+            return f"Error reading Gmail message: {result.get('error')}"
+
+        data = result.get("data", {})
+
+        if not data:
+            return f"Message not found: {self.message_id}"
+
+        if self.body_format == "text":
+            # Use preview body (clean plain text) if available, fallback to stripping HTML
+            preview = data.get("preview", {})
+            body_content = preview.get("body", "")
+            if not body_content:
+                body_content = strip_html(data.get("messageText", ""))
+        else:
+            body_content = data.get("messageText", "")
+        
+        return json.dumps({
+            "provider": "gmail",
+            "message_id": data.get("messageId"),
+            "thread_id": data.get("threadId"),
+            "subject": data.get("subject", "(No subject)"),
+            "from": data.get("sender", "Unknown"),
+            "to": data.get("to", ""),
+            "received_at": data.get("messageTimestamp"),
+            "labels": data.get("labelIds", []),
+            "body": body_content,
+            "has_attachments": len(data.get("attachmentList", [])) > 0,
+            "attachments": [
+                {"filename": att.get("filename"), "size": att.get("size")}
+                for att in data.get("attachmentList", [])
+            ]
+        }, indent=2)
+    
+    def _read_outlook_message(self, execute_tool) -> str:
+        """Reads an Outlook message by ID."""
+        result = execute_tool(
+            tool_name="OUTLOOK_GET_MESSAGE",
+            arguments={
+                "user_id": "me",
+                "message_id": self.message_id,
+                "select": [
+                    "id", "subject", "from", "toRecipients", "ccRecipients",
+                    "receivedDateTime", "body", "hasAttachments", "webLink",
+                    "isRead", "importance", "conversationId"
+                ]
+            },
+        )
+        
+        if isinstance(result, dict) and result.get("error"):
+            return f"Error reading Outlook message: {result.get('error')}"
+
+        data = result.get("data", {})
+
+        if not data:
+            return f"Message not found: {self.message_id}"
+
+        from_info = data.get("from", {}).get("emailAddress", {})
+        from_str = f"{from_info.get('name', '')} <{from_info.get('address', 'Unknown')}>"
+
+        to_recipients = []
+        for recipient in data.get("toRecipients", []):
+            email_addr = recipient.get("emailAddress", {})
+            to_recipients.append(f"{email_addr.get('name', '')} <{email_addr.get('address', '')}>")
+        
+        cc_recipients = []
+        for recipient in data.get("ccRecipients", []):
+            email_addr = recipient.get("emailAddress", {})
+            cc_recipients.append(f"{email_addr.get('name', '')} <{email_addr.get('address', '')}>")
+        
+        body_data = data.get("body", {})
+        body_content = body_data.get("content", "")
+        body_type = body_data.get("contentType", "text")
+
+        if self.body_format == "text" and body_type.lower() == "html" and body_content:
+            body_content = strip_html(body_content)
+
+        return json.dumps({
+            "provider": "outlook",
+            "message_id": data.get("id"),
+            "conversation_id": data.get("conversationId"),
+            "subject": data.get("subject", "(No subject)"),
+            "from": from_str,
+            "to": to_recipients,
+            "cc": cc_recipients,
+            "received_at": data.get("receivedDateTime"),
+            "is_read": data.get("isRead"),
+            "importance": data.get("importance"),
+            "body": body_content,
+            "has_attachments": data.get("hasAttachments", False),
+            "web_link": data.get("webLink", "")
+        }, 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("ReadEmail Test Suite")
+    print("=" * 60)
+    print()
+    
+    # Get a message ID from CheckUnreadEmails
+    from virtual_assistant.tools.CheckUnreadEmails import CheckUnreadEmails
+    check_tool = CheckUnreadEmails(provider="gmail", limit=1)
+    result = check_tool.run()
+    
+    import json
+    try:
+        data = json.loads(result)
+        if data.get("emails"):
+            message_id = data["emails"][0]["message_id"]
+            
+            # Test 1: Read Gmail message as plain text (default)
+            print("Test 1: Gmail - Plain text (default)")
+            print("-" * 60)
+            tool = ReadEmail(provider="gmail", message_id=message_id, body_format="text")
+            result = tool.run()
+            result_data = json.loads(result)
+            if result_data.get("body") and len(result_data["body"]) > 500:
+                result_data["body"] = result_data["body"][:500] + "... [truncated]"
+            print(json.dumps(result_data, indent=2))
+            print()
+            
+            # Test 2: Read Gmail message as HTML
+            print("Test 2: Gmail - HTML format")
+            print("-" * 60)
+            tool = ReadEmail(provider="gmail", message_id=message_id, body_format="html")
+            result = tool.run()
+            result_data = json.loads(result)
+            if result_data.get("body") and len(result_data["body"]) > 300:
+                result_data["body"] = result_data["body"][:300] + "... [truncated]"
+            print(json.dumps(result_data, indent=2))
+            print()
+        else:
+            print("No unread emails to test with")
+    except json.JSONDecodeError:
+        print(f"Error parsing result: {result}")
+    
+    # Test 3: Read an Outlook message
+    print("Test 3: Outlook - Plain text")
+    print("-" * 60)
+    check_tool = CheckUnreadEmails(provider="outlook", limit=1)
+    result = check_tool.run()
+    try:
+        data = json.loads(result)
+        if data.get("emails"):
+            message_id = data["emails"][0]["message_id"]
+            tool = ReadEmail(provider="outlook", message_id=message_id, body_format="text")
+            result = tool.run()
+            print(result[:1500])
+        else:
+            print("No unread Outlook emails to test with")
+    except json.JSONDecodeError:
+        print(f"Result: {result}")
+    print()
+    
+    print("=" * 60)
+    print("All tests completed!")
+    print("=" * 60)
+

package/virtual_assistant/tools/ReadFile.py

@@ -0,0 +1,108 @@
+import mimetypes
+import os
+from typing import Optional
+
+from agency_swarm.tools import BaseTool
+from pydantic import Field
+
+
+class ReadFile(BaseTool):
+    """
+    Reads a file from the local filesystem.
+    Use this tool to read file contents before editing or to understand existing code.
+
+    Usage:
+    - The file_path parameter must be an absolute path
+    - By default, it reads up to 2000 lines starting from the beginning
+    - You can optionally specify a line offset and limit for long files
+    - Results are returned with line numbers in cat -n format
+    """
+
+    file_path: str = Field(..., description="The absolute path to the file to read")
+    offset: Optional[int] = Field(
+        None,
+        description="The line number to start reading from. Only provide if the file is too large to read at once",
+    )
+    limit: Optional[int] = Field(
+        None,
+        description="The number of lines to read. Only provide if the file is too large to read at once.",
+    )
+
+    def run(self):
+        try:
+            abs_path = os.path.abspath(self.file_path)
+            try:
+                if hasattr(self, '_context') and self._context is not None:
+                    read_files = self._context.get("read_files", set())
+                    read_files.add(abs_path)
+                    self._context.set("read_files", read_files)
+            except (AttributeError, TypeError):
+                # Context not available in standalone test mode
+                pass
+
+            if not os.path.exists(self.file_path):
+                return f"Error: File does not exist: {self.file_path}"
+
+            if not os.path.isfile(self.file_path):
+                return f"Error: Path is not a file: {self.file_path}"
+
+            mime_type, _ = mimetypes.guess_type(self.file_path)
+            if mime_type and mime_type.startswith("image/"):
+                return f"[IMAGE FILE: {self.file_path}]\nThis is an image file ({mime_type}). In a multimodal environment, the image content would be displayed visually."
+
+            if self.file_path.endswith(".ipynb"):
+                return "Error: This is a Jupyter notebook file. Please use a notebook-specific tool instead."
+
+            try:
+                with open(self.file_path, "r", encoding="utf-8") as file:
+                    lines = file.readlines()
+            except UnicodeDecodeError:
+                try:
+                    with open(self.file_path, "r", encoding="latin-1") as file:
+                        lines = file.readlines()
+                except UnicodeDecodeError:
+                    return f"Error: Unable to decode file {self.file_path}. It may be a binary file."
+
+            if not lines:
+                return f"Warning: File exists but has empty contents: {self.file_path}"
+
+            start_line = (self.offset - 1) if self.offset else 0
+            start_line = max(0, start_line)
+
+            if self.limit:
+                end_line = start_line + self.limit
+                selected_lines = lines[start_line:end_line]
+            else:
+                selected_lines = lines[start_line : start_line + 2000]
+
+            result_lines = []
+            for i, line in enumerate(selected_lines, start=start_line + 1):
+                if len(line) > 2000:
+                    line = line[:1997] + "...\n"
+                result_lines.append(f"{i:>6}\t{line.rstrip()}\n")
+            result = "".join(result_lines)
+
+            total_lines = len(lines)
+            lines_shown = len(selected_lines)
+
+            if lines_shown < total_lines:
+                if self.offset or self.limit:
+                    result += f"\n[Truncated: showing lines {start_line + 1}-{start_line + lines_shown} of {total_lines} total lines]"
+                else:
+                    result += f"\n[Truncated: showing first {lines_shown} of {total_lines} total lines]"
+
+            return result.rstrip()
+
+        except PermissionError:
+            return f"Error: Permission denied reading file: {self.file_path}"
+        except Exception as e:
+            return f"Error reading file: {str(e)}"
+
+
+if __name__ == "__main__":
+    # Test the tool with its own file
+    current_file = __file__
+    tool = ReadFile(file_path=current_file, limit=10)
+    print("Reading first 10 lines:")
+    print(tool.run())
+

package/virtual_assistant/tools/ReadSlackMessages.py

@@ -0,0 +1,191 @@
+from typing import Optional
+from agency_swarm.tools import BaseTool
+from pydantic import Field
+import json
+from datetime import datetime
+
+from helpers import execute_composio_tool
+
+
+class ReadSlackMessages(BaseTool):
+    """
+    Reads messages from a Slack channel or DM. Use channel ID (e.g., C06NX4Q1ACE) 
+    or channel name (e.g., #general). For threads, provide the parent message timestamp.
+    """
+    
+    channel: str = Field(
+        ...,
+        description="Channel ID or name (e.g., 'C06NX4Q1ACE' or '#general')"
+    )
+    
+    limit: int = Field(
+        default=10,
+        ge=1,
+        le=50,
+        description="Number of messages to fetch (1-50). Default: 10"
+    )
+    
+    thread_ts: Optional[str] = Field(
+        default=None,
+        description="Thread parent timestamp to read replies. Leave empty for main channel."
+    )
+    
+    include_replies: bool = Field(
+        default=False,
+        description="Include thread replies for messages that have them. Default: False"
+    )
+    
+    def run(self):
+        try:
+            # Resolve channel name to ID if needed
+            channel_id = self._resolve_channel(execute_composio_tool, self.channel)
+            if channel_id.startswith("Error"):
+                return channel_id
+            
+            # Fetch messages
+            if self.thread_ts:
+                messages = self._fetch_thread(execute_composio_tool, channel_id)
+            else:
+                messages = self._fetch_channel(execute_composio_tool, channel_id)
+            
+            if not messages:
+                return json.dumps({"count": 0, "messages": []}, indent=2)
+            
+            # Format output
+            formatted = []
+            for msg in messages[:self.limit]:
+                formatted_msg = self._format_message(msg)
+                
+                # Fetch thread replies if requested and message has replies
+                if self.include_replies and msg.get("reply_count", 0) > 0:
+                    replies = self._fetch_thread_replies(execute_composio_tool, channel_id, msg.get("ts"))
+                    if replies:
+                        formatted_msg["thread"] = [self._format_message(r) for r in replies]
+                
+                formatted.append(formatted_msg)
+            
+            return json.dumps({
+                "count": len(formatted),
+                "channel_id": channel_id,
+                "messages": formatted
+            }, indent=2)
+            
+        except Exception as e:
+            return f"Error: {str(e)}"
+    
+    def _resolve_channel(self, execute_tool, channel: str) -> str:
+        """Resolves channel name to ID."""
+        # Already an ID
+        if channel.startswith(("C", "D", "G")):
+            return channel
+        
+        # Remove # prefix
+        name = channel.lstrip("#")
+        
+        # Search for channel
+        result = execute_tool(
+            tool_name="SLACK_FIND_CHANNELS",
+            arguments={"query": name},
+        )
+        
+        if result.get("error"):
+            return f"Error: Could not find channel '{name}'"
+        
+        channels = result.get("data", {}).get("channels", [])
+        for ch in channels:
+            if ch.get("name") == name:
+                return ch.get("id")
+        
+        return f"Error: Channel '{name}' not found"
+    
+    def _fetch_channel(self, execute_tool, channel_id: str) -> list:
+        """Fetches messages from channel."""
+        result = execute_tool(
+            tool_name="SLACK_FETCH_CONVERSATION_HISTORY",
+            arguments={
+                "channel": channel_id,
+                "limit": self.limit
+            },
+        )
+        
+        if result.get("error"):
+            return []
+        
+        return result.get("data", {}).get("messages", [])
+    
+    def _fetch_thread(self, execute_tool, channel_id: str) -> list:
+        """Fetches thread replies for thread_ts parameter."""
+        result = execute_tool(
+            tool_name="SLACK_FETCH_MESSAGE_THREAD_FROM_A_CONVERSATION",
+            arguments={
+                "channel": channel_id,
+                "ts": self.thread_ts,
+                "limit": self.limit
+            },
+        )
+        
+        if result.get("error"):
+            return []
+        
+        return result.get("data", {}).get("messages", [])
+    
+    def _fetch_thread_replies(self, execute_tool, channel_id: str, parent_ts: str) -> list:
+        """Fetches thread replies for a specific message."""
+        result = execute_tool(
+            tool_name="SLACK_FETCH_MESSAGE_THREAD_FROM_A_CONVERSATION",
+            arguments={
+                "channel": channel_id,
+                "ts": parent_ts,
+                "limit": 20
+            },
+        )
+        
+        if result.get("error"):
+            return []
+        
+        messages = result.get("data", {}).get("messages", [])
+        # Skip the parent message (first one), return only replies
+        return messages[1:] if len(messages) > 1 else []
+    
+    def _format_message(self, msg: dict) -> dict:
+        """Formats message for output."""
+        files = msg.get("files", [])
+        attachments = [f.get("name") or "file" for f in files] if files else None
+        
+        formatted = {
+            "sender": msg.get("user", msg.get("bot_id", "unknown")),
+            "text": msg.get("text", ""),
+            "ts": msg.get("ts"),
+            "time": self._format_ts(msg.get("ts"))
+        }
+        
+        if msg.get("reply_count"):
+            formatted["replies"] = msg.get("reply_count")
+        
+        if attachments:
+            formatted["attachments"] = attachments
+        
+        return formatted
+    
+    def _format_ts(self, ts: str) -> str:
+        """Formats timestamp."""
+        if not ts:
+            return ""
+        try:
+            return datetime.fromtimestamp(float(ts.split(".")[0])).strftime("%Y-%m-%d %H:%M")
+        except (ValueError, TypeError):
+            return ts
+
+
+if __name__ == "__main__":
+    import sys
+    import os
+    sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")))
+    
+    print("ReadSlackMessages Test")
+    print("-" * 40)
+    
+    # Test reading from aaas-gains-ai with replies
+    tool = ReadSlackMessages(channel="#aaas-gains-ai", limit=3, include_replies=True)
+    print(tool.run())
+

package/virtual_assistant/tools/RemoveLabelFromEmail.py

@@ -0,0 +1,137 @@
+from typing import Literal, List
+from agency_swarm.tools import BaseTool
+from pydantic import Field
+import json
+
+from helpers import execute_composio_tool
+
+
+class RemoveLabelFromEmail(BaseTool):
+    """
+    Removes labels from a specific email message.
+    
+    For Gmail: Use label IDs. Common operations:
+    - Remove 'UNREAD' to mark as read
+    - Remove 'INBOX' to archive
+    - Remove 'STARRED' to unstar
+    
+    For Outlook: Remove category names from the message.
+    """
+    
+    provider: Literal["gmail", "outlook"] = Field(
+        ...,
+        description="Email provider: 'gmail' or 'outlook'"
+    )
+    
+    message_id: str = Field(
+        ...,
+        description="The message ID to remove labels from (obtained from CheckUnreadEmails)"
+    )
+    
+    label_ids: List[str] = Field(
+        ...,
+        description="List of label IDs to remove. Gmail: 'UNREAD', 'INBOX', 'STARRED', 'Label_123'. Outlook: category names."
+    )
+    
+    def run(self):
+        try:
+            if self.provider == "gmail":
+                return self._remove_gmail_labels(execute_composio_tool)
+            else:
+                return self._remove_outlook_categories(execute_composio_tool)
+                
+        except Exception as e:
+            return f"Error removing labels: {str(e)}"
+    
+    def _remove_gmail_labels(self, execute_tool) -> str:
+        """Removes labels from a Gmail message."""
+        result = execute_tool(
+            tool_name="GMAIL_ADD_LABEL_TO_EMAIL",
+            arguments={
+                "user_id": "me",
+                "message_id": self.message_id,
+                "remove_label_ids": self.label_ids
+            },
+        )
+        
+        if isinstance(result, dict) and result.get("error"):
+            return f"Error removing Gmail labels: {result.get('error')}"
+        
+        data = result.get("data", {})
+        
+        return json.dumps({
+            "provider": "gmail",
+            "success": True,
+            "message_id": self.message_id,
+            "labels_removed": self.label_ids,
+            "current_labels": data.get("labelIds", [])
+        }, indent=2)
+    
+    def _remove_outlook_categories(self, execute_tool) -> str:
+        """Removes categories from an Outlook message."""
+        # Get current categories
+        get_result = execute_tool(
+            tool_name="OUTLOOK_GET_MESSAGE",
+            arguments={
+                "user_id": "me",
+                "message_id": self.message_id,
+                "select": ["id", "categories"]
+            },
+        )
+        
+        if isinstance(get_result, dict) and get_result.get("error"):
+            return f"Error getting Outlook message: {get_result.get('error')}"
+        
+        current_categories = get_result.get("data", {}).get("categories", [])
+        
+        # Calculate remaining categories
+        remaining_categories = [c for c in current_categories if c not in self.label_ids]
+        
+        return json.dumps({
+            "provider": "outlook",
+            "success": True,
+            "message_id": self.message_id,
+            "categories_removed": self.label_ids,
+            "remaining_categories": remaining_categories,
+            "note": "Outlook category update requires OUTLOOK_UPDATE_MESSAGE which may not be available"
+        }, 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("RemoveLabelFromEmail Test Suite")
+    print("=" * 60)
+    print()
+    
+    # Get a message ID first
+    from virtual_assistant.tools.FindEmails import FindEmails
+    check_tool = FindEmails(provider="gmail", query="is:unread", limit=1)
+    result = check_tool.run()
+    
+    import json
+    data = json.loads(result)
+    if data.get("emails"):
+        message_id = data["emails"][0]["message_id"]
+        
+        # Test: Mark as read by removing UNREAD label
+        print("Test: Mark email as read (remove UNREAD label)")
+        print("-" * 60)
+        tool = RemoveLabelFromEmail(
+            provider="gmail",
+            message_id=message_id,
+            label_ids=["UNREAD"]
+        )
+        result = tool.run()
+        print(result)
+    else:
+        print("No emails to test with")
+    
+    print()
+    print("=" * 60)
+    print("Tests completed!")
+    print("=" * 60)
+