@_vrsen/openswarm 0.1.0

package/virtual_assistant/tools/DeleteDraft.py

@@ -0,0 +1,95 @@
+from typing import Literal
+from agency_swarm.tools import BaseTool
+from pydantic import Field
+
+from helpers import execute_composio_tool
+import json
+
+
+class DeleteDraft(BaseTool):
+    """
+    Permanently deletes an email draft by its ID.
+    
+    Use this to clean up drafts that are no longer needed.
+    This action cannot be undone.
+    """
+    
+    provider: Literal["gmail", "outlook"] = Field(
+        ...,
+        description="Email provider: 'gmail' or 'outlook'"
+    )
+    
+    draft_id: str = Field(
+        ...,
+        description="The draft ID to delete (obtained from DraftEmail tool)"
+    )
+    
+    def run(self):
+        try:
+            if self.provider == "gmail":
+                return self._delete_gmail_draft(execute_composio_tool)
+            else:
+                return self._delete_outlook_draft(execute_composio_tool)
+                
+        except Exception as e:
+            return f"Error deleting draft: {str(e)}"
+    
+    def _delete_gmail_draft(self, execute_tool) -> str:
+        """Deletes a Gmail draft."""
+        result = execute_tool(
+            tool_name="GMAIL_DELETE_DRAFT",
+            arguments={
+                "user_id": "me",
+                "draft_id": self.draft_id
+            },
+        )
+
+        if isinstance(result, dict) and result.get("error"):
+            return f"Error deleting Gmail draft: {result.get('error')}"
+
+        return json.dumps({
+            "provider": "gmail",
+            "success": True,
+            "message": "Draft deleted successfully",
+            "draft_id": self.draft_id
+        }, indent=2)
+    
+    def _delete_outlook_draft(self, execute_tool) -> str:
+        """Deletes an Outlook draft."""
+        result = execute_tool(
+            tool_name="OUTLOOK_DELETE_MESSAGE",
+            arguments={
+                "user_id": "me",
+                "message_id": self.draft_id
+            },
+        )
+
+        if isinstance(result, dict) and result.get("error"):
+            return f"Error deleting Outlook draft: {result.get('error')}"
+
+        return json.dumps({
+            "provider": "outlook",
+            "success": True,
+            "message": "Draft deleted successfully",
+            "draft_id": self.draft_id
+        }, 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("DeleteDraft Test Suite")
+    print("=" * 60)
+    print()
+    print("To test DeleteDraft, first create a draft using DraftEmail,")
+    print("then use the draft_id to delete it.")
+    print()
+    print("Example:")
+    print("  tool = DeleteDraft(provider='gmail', draft_id='r12345...')")
+    print("  result = tool.run()")
+    print()
+    print("=" * 60)
+

package/virtual_assistant/tools/DraftEmail.py

@@ -0,0 +1,239 @@
+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 DraftEmail(BaseTool):
+    """
+    Creates an email draft in the user's mailbox (Gmail or Outlook).
+    
+    The draft can be reviewed, edited, and sent later using SendDraft.
+    Returns the draft ID which is needed to send or delete the draft.
+    
+    Supports creating replies within existing threads:
+    - Gmail: Use thread_id to reply in a thread
+    - Outlook: Use reply_to_message_id to reply to a specific message
+    """
+    
+    provider: Literal["gmail", "outlook"] = Field(
+        ...,
+        description="Email provider: 'gmail' or 'outlook'"
+    )
+    
+    to: Optional[List[str]] = Field(
+        default=None,
+        description="List of recipient email addresses (e.g., ['user@example.com']). Optional for drafts."
+    )
+    
+    subject: Optional[str] = Field(
+        default=None,
+        description="Email subject line. Leave empty when replying to stay in the same thread."
+    )
+    
+    body: str = Field(
+        ...,
+        description="Email body content (plain text)"
+    )
+    
+    cc: Optional[List[str]] = Field(
+        default=None,
+        description="List of CC recipient email addresses"
+    )
+    
+    bcc: Optional[List[str]] = Field(
+        default=None,
+        description="List of BCC recipient email addresses"
+    )
+    
+    is_html: bool = Field(
+        default=False,
+        description="Set to True if body contains HTML formatting"
+    )
+    
+    thread_id: Optional[str] = Field(
+        default=None,
+        description="Gmail only: Thread ID to reply to. Leave subject empty to stay in the same thread."
+    )
+    
+    reply_to_message_id: Optional[str] = Field(
+        default=None,
+        description="Outlook only: Message ID to reply to. Creates a draft reply to that message."
+    )
+    
+    def run(self):
+        try:
+            if self.provider == "gmail":
+                return self._create_gmail_draft(execute_composio_tool)
+            else:
+                return self._create_outlook_draft(execute_composio_tool)
+                
+        except Exception as e:
+            return f"Error creating draft: {str(e)}"
+    
+    def _create_gmail_draft(self, execute_tool) -> str:
+        """Creates a Gmail draft."""
+        arguments = {
+            "user_id": "me",
+            "body": self.body,
+            "is_html": self.is_html
+        }
+        
+        # Add subject (leave empty for thread replies to stay in same thread)
+        if self.subject:
+            arguments["subject"] = self.subject
+        
+        if self.to:
+            arguments["recipient_email"] = self.to[0]
+            if len(self.to) > 1:
+                arguments["extra_recipients"] = self.to[1:]
+        
+        if self.cc:
+            arguments["cc"] = self.cc
+        
+        if self.bcc:
+            arguments["bcc"] = self.bcc
+        
+        # Add thread_id for replies
+        if self.thread_id:
+            arguments["thread_id"] = self.thread_id
+        
+        result = execute_tool(
+            tool_name="GMAIL_CREATE_EMAIL_DRAFT",
+            arguments=arguments,
+        )
+        
+        if isinstance(result, dict) and result.get("error"):
+            return f"Error creating Gmail draft: {result.get('error')}"
+
+        data = result.get("data", {})
+
+        return json.dumps({
+            "provider": "gmail",
+            "success": True,
+            "draft_id": data.get("id"),
+            "message_id": data.get("message", {}).get("id"),
+            "thread_id": data.get("message", {}).get("threadId"),
+            "subject": self.subject,
+            "to": self.to,
+            "is_reply": self.thread_id is not None
+        }, indent=2)
+    
+    def _create_outlook_draft(self, execute_tool) -> str:
+        """Creates an Outlook draft."""
+        # Check if this is a reply to an existing message
+        if self.reply_to_message_id:
+            return self._create_outlook_reply_draft(execute_tool)
+        
+        arguments = {
+            "body": self.body,
+            "is_html": self.is_html
+        }
+        
+        if self.subject:
+            arguments["subject"] = self.subject
+        else:
+            arguments["subject"] = "(No subject)"
+        
+        if self.to:
+            arguments["to_recipients"] = self.to
+        
+        if self.cc:
+            arguments["cc_recipients"] = self.cc
+        
+        if self.bcc:
+            arguments["bcc_recipients"] = self.bcc
+        
+        result = execute_tool(
+            tool_name="OUTLOOK_CREATE_DRAFT",
+            arguments=arguments,
+        )
+        
+        if isinstance(result, dict) and result.get("error"):
+            return f"Error creating Outlook draft: {result.get('error')}"
+
+        data = result.get("data", {})
+
+        return json.dumps({
+            "provider": "outlook",
+            "success": True,
+            "draft_id": data.get("id"),
+            "subject": self.subject,
+            "to": self.to,
+            "web_link": data.get("webLink", ""),
+            "is_reply": False
+        }, indent=2)
+    
+    def _create_outlook_reply_draft(self, execute_tool) -> str:
+        """Creates an Outlook draft reply to an existing message."""
+        arguments = {
+            "user_id": "me",
+            "message_id": self.reply_to_message_id,
+            "comment": self.body
+        }
+        
+        if self.cc:
+            arguments["cc_emails"] = self.cc
+        
+        if self.bcc:
+            arguments["bcc_emails"] = self.bcc
+        
+        result = execute_tool(
+            tool_name="OUTLOOK_CREATE_DRAFT_REPLY",
+            arguments=arguments,
+        )
+        
+        if isinstance(result, dict) and result.get("error"):
+            return f"Error creating Outlook reply draft: {result.get('error')}"
+
+        data = result.get("data", {})
+        
+        return json.dumps({
+            "provider": "outlook",
+            "success": True,
+            "draft_id": data.get("id"),
+            "reply_to_message_id": self.reply_to_message_id,
+            "conversation_id": data.get("conversationId"),
+            "web_link": data.get("webLink", ""),
+            "is_reply": True
+        }, 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("DraftEmail Test Suite")
+    print("=" * 60)
+    print()
+    
+    # Test 1: Create Gmail draft
+    print("Test 1: Create Gmail draft")
+    print("-" * 60)
+    tool = DraftEmail(
+        provider="gmail",
+        to=["arseny9795@gmail.com"],
+        subject="Test Draft from Virtual Assistant",
+        body="This is a test draft created by the Virtual Assistant tool.\n\nPlease ignore this message."
+    )
+    result = tool.run()
+    print(result)
+    
+    # Save draft_id for cleanup
+    import json
+    try:
+        data = json.loads(result)
+        gmail_draft_id = data.get("draft_id")
+        print(f"\nDraft ID saved for cleanup: {gmail_draft_id}")
+    except json.JSONDecodeError:
+        gmail_draft_id = None
+    print()
+    
+    print("=" * 60)
+    print("Test completed! Remember to delete the draft.")
+    print("=" * 60)
+

package/virtual_assistant/tools/EditFile.py

@@ -0,0 +1,113 @@
+import os
+from typing import Optional
+
+from agency_swarm.tools import BaseTool
+from pydantic import Field
+
+
+class EditFile(BaseTool):
+    """
+    Performs exact string replacements in files.
+
+    Usage:
+    - You must use ReadFile tool at least once in the conversation before editing.
+    - When editing text, preserve the exact indentation (tabs/spaces) as it appears in the file.
+    - The edit will FAIL if old_string is not unique in the file. Provide more context to make it unique or use replace_all.
+    - Use replace_all for replacing and renaming strings across the file.
+    """
+
+    file_path: str = Field(..., description="The absolute path to the file to modify")
+    old_string: str = Field(..., description="The text to replace")
+    new_string: str = Field(
+        ...,
+        description="The text to replace it with (must be different from old_string)",
+    )
+    replace_all: Optional[bool] = Field(
+        False, description="Replace all occurrences of old_string (default false)"
+    )
+
+    def run(self):
+        try:
+            if self.old_string == self.new_string:
+                return "Error: old_string and new_string must be different"
+
+            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}"
+
+            try:
+                with open(self.file_path, "r", encoding="utf-8") as file:
+                    content = file.read()
+            except UnicodeDecodeError:
+                return f"Error: Unable to decode file {self.file_path}. It may be a binary file."
+
+            if self.old_string not in content:
+                return f"Error: String to replace not found in file.\nString: {repr(self.old_string)}"
+
+            occurrences = content.count(self.old_string)
+
+            if occurrences > 1 and not self.replace_all:
+                previews = []
+                start_idx = 0
+                for _ in range(2):
+                    idx = content.find(self.old_string, start_idx)
+                    if idx == -1:
+                        break
+                    a = max(0, idx - 30)
+                    b = min(len(content), idx + len(self.old_string) + 30)
+                    previews.append("..." + content[a:b] + "...")
+                    start_idx = idx + len(self.old_string)
+                preview_block = "\n".join(previews)
+                return (
+                    f"Error: String appears {occurrences} times in file. Either provide a larger string with more "
+                    f"surrounding context to make it unique or use replace_all=True to change every instance.\n"
+                    f"First matches:\n{preview_block}"
+                )
+
+            if self.replace_all:
+                new_content = content.replace(self.old_string, self.new_string)
+                replacement_count = occurrences
+            else:
+                new_content = content.replace(self.old_string, self.new_string, 1)
+                replacement_count = 1
+
+            try:
+                with open(self.file_path, "w", encoding="utf-8") as file:
+                    file.write(new_content)
+                return f"Successfully replaced {replacement_count} occurrence(s) in {self.file_path}"
+            except PermissionError:
+                return f"Error: Permission denied writing to file: {self.file_path}"
+            except Exception as e:
+                return f"Error writing to file: {str(e)}"
+
+        except Exception as e:
+            return f"Error during edit operation: {str(e)}"
+
+
+if __name__ == "__main__":
+    # Test the tool
+    test_file_path = "/tmp/test_edit_tool.txt"
+    test_content = """This is a test file.
+Line 2 has some text.
+Line 3 has the same text.
+Final line."""
+
+    # Create test file
+    with open(test_file_path, "w") as f:
+        f.write(test_content)
+
+    print("Original content:")
+    print(test_content)
+    print("\n" + "=" * 50 + "\n")
+
+    tool = EditFile(
+        file_path=test_file_path, old_string="some text", new_string="REPLACED TEXT"
+    )
+    result = tool.run()
+    print(result)
+
+    # Cleanup
+    os.remove(test_file_path)
+