@_vrsen/openswarm 0.1.0

package/virtual_assistant/tools/CheckUnreadSlackMessages.py

@@ -0,0 +1,216 @@
+from typing import Literal
+from agency_swarm.tools import BaseTool
+from pydantic import Field
+import json
+from datetime import datetime
+
+from helpers import execute_composio_tool
+
+class CheckUnreadSlackMessages(BaseTool):
+    """
+    Retrieves unread Slack messages using the search API.
+    
+    Efficiently finds unread messages with minimal API calls:
+    1. Searches for recent messages (1 call)
+    2. Checks unread status for top conversations (max 10 calls)
+    
+    Returns sender, message preview, timestamp, permalink, and attachment info.
+    """
+    
+    conversation_types: Literal["dm", "channels", "all"] = Field(
+        default="dm",
+        description=(
+            "'dm' for direct messages only (default), "
+            "'channels' for public/private channels only, "
+            "'all' for both"
+        )
+    )
+    
+    max_messages: int = Field(
+        default=20,
+        ge=1,
+        le=50,
+        description="Maximum number of unread messages to return (1-50). Default is 20."
+    )
+    
+    days_back: int = Field(
+        default=7,
+        ge=1,
+        le=30,
+        description="How many days back to search for messages (1-30). Default is 7."
+    )
+    
+    include_bots: bool = Field(
+        default=True,
+        description="Include messages from bots. Default is True."
+    )
+    
+    def run(self):
+        try:
+            search_results = self._search_recent_messages(execute_composio_tool)
+
+            if not search_results:
+                return json.dumps({
+                    "total_unread": 0,
+                    "messages": [],
+                    "summary": "No recent messages found."
+                }, indent=2)
+
+            unread_messages = self._filter_unread(execute_composio_tool, search_results)
+            
+            # Sort by timestamp (newest first) and limit
+            unread_messages.sort(key=lambda x: x.get("_ts", "0"), reverse=True)
+            unread_messages = unread_messages[:self.max_messages]
+            
+            # Clean up internal fields
+            for msg in unread_messages:
+                msg.pop("_ts", None)
+            
+            # Build summary
+            if not unread_messages:
+                summary = "No unread messages."
+            else:
+                conv_ids = set(msg["conversation_id"] for msg in unread_messages)
+                summary = f"{len(unread_messages)} unread message{'s' if len(unread_messages) > 1 else ''} from {len(conv_ids)} conversation{'s' if len(conv_ids) > 1 else ''}."
+            
+            return json.dumps({
+                "total_unread": len(unread_messages),
+                "messages": unread_messages,
+                "summary": summary
+            }, indent=2)
+            
+        except Exception as e:
+            return f"Error fetching unread Slack messages: {str(e)}"
+    
+    def _search_recent_messages(self, execute_tool) -> list:
+        """Searches for recent messages (1 API call)."""
+        from datetime import timedelta
+        
+        start_date = (datetime.now() - timedelta(days=self.days_back)).strftime("%Y-%m-%d")
+        
+        if self.conversation_types == "dm":
+            query = f"after:{start_date} is:dm"
+        elif self.conversation_types == "channels":
+            query = f"after:{start_date} -is:dm"
+        else:
+            query = f"after:{start_date}"
+        
+        result = execute_tool(
+            tool_name="SLACK_SEARCH_MESSAGES",
+            arguments={
+                "query": query,
+                "sort": "timestamp",
+                "sort_dir": "desc",
+                "count": min(self.max_messages * 2, 100)
+            },
+        )
+        
+        if isinstance(result, dict) and result.get("error"):
+            return []
+        
+        return result.get("data", {}).get("messages", {}).get("matches", [])
+    
+    def _filter_unread(self, execute_tool, messages: list) -> list:
+        """Filters to unread messages only (max 2 API calls for last_read checks)."""
+        # Group messages by channel
+        by_channel = {}
+        for msg in messages:
+            channel = msg.get("channel", {})
+            channel_id = channel.get("id")
+            if not channel_id:
+                continue
+            
+            # Filter bots if needed
+            if not self.include_bots and (msg.get("bot_id") or msg.get("subtype")):
+                continue
+            
+            if channel_id not in by_channel:
+                by_channel[channel_id] = {
+                    "name": self._get_display_name(channel),
+                    "messages": []
+                }
+            by_channel[channel_id]["messages"].append(msg)
+        
+        # Check last_read for top 10 channels (to limit API calls)
+        unread_messages = []
+        channels_checked = 0
+        
+        for channel_id, conv_data in by_channel.items():
+            if channels_checked >= 10:
+                break
+            
+            channels_checked += 1
+            
+            # Get last_read timestamp
+            info_result = execute_tool(
+                tool_name="SLACK_RETRIEVE_CONVERSATION_INFORMATION",
+                arguments={"channel": channel_id},
+            )
+            
+            if isinstance(info_result, dict) and info_result.get("error"):
+                continue
+            
+            last_read = info_result.get("data", {}).get("channel", {}).get("last_read", "0")
+            
+            # Filter to messages after last_read
+            for msg in conv_data["messages"]:
+                ts = msg.get("ts", "0")
+                if ts > last_read:
+                    unread_messages.append(self._format_message(
+                        msg, conv_data["name"], channel_id
+                    ))
+        
+        return unread_messages
+    
+    def _get_display_name(self, channel: dict) -> str:
+        """Gets display name for channel."""
+        if channel.get("is_im"):
+            return channel.get("name", "Direct Message")
+        return f"#{channel.get('name', 'Unknown')}"
+    
+    def _format_message(self, msg: dict, conv_name: str, channel_id: str) -> dict:
+        """Formats a message for output."""
+        files = msg.get("files", [])
+        attachments = [f.get("name") or f.get("title") or "file" for f in files] if files else None
+        
+        text = msg.get("text", "")
+        if len(text) > 200:
+            text = text[:197] + "..."
+        
+        return {
+            "conversation": conv_name,
+            "conversation_id": channel_id,
+            "sender": msg.get("username", "Unknown"),
+            "text": text,
+            "timestamp": self._format_timestamp(msg.get("ts")),
+            "permalink": msg.get("permalink", ""),
+            "has_attachment": len(files) > 0,
+            "attachments": attachments,
+            "_ts": msg.get("ts")
+        }
+    
+    def _format_timestamp(self, ts: str) -> str:
+        """Formats Slack timestamp."""
+        if not ts:
+            return ""
+        try:
+            unix_ts = float(ts.split(".")[0])
+            return datetime.fromtimestamp(unix_ts).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("CheckUnreadSlackMessages Test")
+    print("-" * 40)
+    
+    tool = CheckUnreadSlackMessages(
+        conversation_types="all",
+        max_messages=10,
+        days_back=7
+    )
+    print(tool.run())

package/virtual_assistant/tools/CreateCalendarEvent.py

@@ -0,0 +1,261 @@
+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 CreateCalendarEvent(BaseTool):
+    """
+    Creates a calendar event in Google Calendar or Outlook.
+    
+    The event is automatically accepted for the user after creation.
+    Returns the event ID and a link to view the event.
+    """
+    
+    provider: Literal["google", "outlook"] = Field(
+        ...,
+        description="Calendar provider: 'google' (Google Calendar) or 'outlook'"
+    )
+    
+    title: str = Field(
+        ...,
+        description="Title/subject of the event"
+    )
+    
+    start_datetime: str = Field(
+        ...,
+        description="Start date and time in ISO 8601 format (e.g., '2026-01-15T14:00:00')"
+    )
+    
+    duration_hours: int = Field(
+        default=1,
+        ge=0,
+        description="Duration in hours (default 1). Use with duration_minutes for partial hours."
+    )
+    
+    duration_minutes: int = Field(
+        default=0,
+        ge=0,
+        le=59,
+        description="Duration in minutes (0-59). Combined with duration_hours."
+    )
+    
+    timezone: str = Field(
+        default="UTC",
+        description="Timezone in IANA format (e.g., 'America/New_York', 'Europe/London', 'Asia/Dubai')"
+    )
+    
+    description: Optional[str] = Field(
+        default=None,
+        description="Description/notes for the event"
+    )
+    
+    location: Optional[str] = Field(
+        default=None,
+        description="Location of the event (address or meeting room)"
+    )
+    
+    attendees: Optional[List[str]] = Field(
+        default=None,
+        description="List of attendee email addresses to invite"
+    )
+    
+    create_meeting_link: bool = Field(
+        default=False,
+        description="If True, creates a video meeting link (Google Meet or Teams)"
+    )
+    
+    def run(self):
+        try:
+            if self.provider == "google":
+                return self._create_google_event(execute_composio_tool)
+            else:
+                return self._create_outlook_event(execute_composio_tool)
+                
+        except Exception as e:
+            return f"Error creating calendar event: {str(e)}"
+    
+    def _create_google_event(self, execute_tool) -> str:
+        """Creates a Google Calendar event and accepts it."""
+        arguments = {
+            "calendar_id": "primary",
+            "start_datetime": self.start_datetime,
+            "event_duration_hour": self.duration_hours,
+            "event_duration_minutes": self.duration_minutes,
+            "timezone": self.timezone,
+            "summary": self.title,
+            "create_meeting_room": self.create_meeting_link,
+            "exclude_organizer": False,  # Include organizer as attendee
+            "send_updates": True
+        }
+        
+        if self.description:
+            arguments["description"] = self.description
+        
+        if self.location:
+            arguments["location"] = self.location
+        
+        if self.attendees:
+            arguments["attendees"] = self.attendees
+        
+        result = execute_tool(
+            tool_name="GOOGLECALENDAR_CREATE_EVENT",
+            arguments=arguments,
+        )
+        
+        if isinstance(result, dict) and result.get("error"):
+            return f"Error creating Google Calendar event: {result.get('error')}"
+
+        data = result.get("data", {})
+        if "response_data" in data:
+            data = data["response_data"]
+        event_id = data.get("id")
+
+        if event_id:
+            accept_result = execute_tool(
+                tool_name="GOOGLECALENDAR_PATCH_EVENT",
+                arguments={
+                    "calendar_id": "primary",
+                    "event_id": event_id,
+                    "rsvp_response": "accepted",
+                    "send_updates": "none"
+                },
+            )
+            
+            accepted = not (isinstance(accept_result, dict) and accept_result.get("error"))
+        else:
+            accepted = False
+        
+        meeting_link = None
+        conference_data = data.get("conferenceData", {})
+        entry_points = conference_data.get("entryPoints", [])
+        for entry in entry_points:
+            if entry.get("entryPointType") == "video":
+                meeting_link = entry.get("uri")
+                break
+        
+        return json.dumps({
+            "provider": "google",
+            "success": True,
+            "event_id": event_id,
+            "title": self.title,
+            "start": data.get("start", {}).get("dateTime"),
+            "end": data.get("end", {}).get("dateTime"),
+            "accepted": accepted,
+            "meeting_link": meeting_link,
+            "html_link": data.get("htmlLink", "")
+        }, indent=2)
+    
+    def _create_outlook_event(self, execute_tool) -> str:
+        """Creates an Outlook calendar event."""
+        from datetime import datetime, timedelta
+        
+        try:
+            start_dt = datetime.fromisoformat(self.start_datetime.replace("Z", "+00:00"))
+        except ValueError:
+            start_dt = datetime.fromisoformat(self.start_datetime)
+        
+        duration = timedelta(hours=self.duration_hours, minutes=self.duration_minutes)
+        end_dt = start_dt + duration
+        end_datetime = end_dt.strftime("%Y-%m-%dT%H:%M:%S")
+        
+        arguments = {
+            "user_id": "me",
+            "subject": self.title,
+            "start_datetime": self.start_datetime,
+            "end_datetime": end_datetime,
+            "time_zone": self.timezone,
+            "is_html": False
+        }
+        
+        if self.description:
+            arguments["body"] = self.description
+        
+        if self.location:
+            arguments["location"] = self.location
+        
+        if self.attendees:
+            arguments["attendees_info"] = [{"email": email} for email in self.attendees]
+        
+        if self.create_meeting_link:
+            arguments["is_online_meeting"] = True
+            arguments["online_meeting_provider"] = "teamsForBusiness"
+        
+        result = execute_tool(
+            tool_name="OUTLOOK_CALENDAR_CREATE_EVENT",
+            arguments=arguments,
+        )
+        
+        if isinstance(result, dict) and result.get("error"):
+            return f"Error creating Outlook event: {result.get('error')}"
+
+        data = result.get("data", {})
+        
+        # Extract meeting link if created
+        meeting_link = None
+        online_meeting = data.get("onlineMeeting", {})
+        if online_meeting:
+            meeting_link = online_meeting.get("joinUrl")
+        
+        return json.dumps({
+            "provider": "outlook",
+            "success": True,
+            "event_id": data.get("id"),
+            "title": self.title,
+            "start": data.get("start", {}).get("dateTime"),
+            "end": data.get("end", {}).get("dateTime"),
+            "accepted": True,  # Organizer is automatically accepted
+            "meeting_link": meeting_link,
+            "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("CreateCalendarEvent Test Suite")
+    print("=" * 60)
+    print()
+    
+    # Test 1: Create Google Calendar event
+    print("Test 1: Create Google Calendar event")
+    print("-" * 60)
+    tool = CreateCalendarEvent(
+        provider="google",
+        title="Test Event from Virtual Assistant",
+        start_datetime="2026-01-08T15:00:00",
+        duration_hours=0,
+        duration_minutes=30,
+        timezone="Asia/Dubai",
+        description="This is a test event created by the Virtual Assistant tool.",
+        create_meeting_link=False
+    )
+    result = tool.run()
+    print(result)
+    print()
+    
+    # Test 2: Create Outlook event
+    print("Test 2: Create Outlook Calendar event")
+    print("-" * 60)
+    tool = CreateCalendarEvent(
+        provider="outlook",
+        title="Test Outlook Event",
+        start_datetime="2026-01-08T16:00:00",
+        duration_hours=1,
+        duration_minutes=0,
+        timezone="UTC",
+        description="This is a test Outlook event."
+    )
+    result = tool.run()
+    print(result)
+    print()
+    
+    print("=" * 60)
+    print("Tests completed! Remember to delete test events from calendars.")
+    print("=" * 60)
+

package/virtual_assistant/tools/DeleteCalendarEvent.py

@@ -0,0 +1,137 @@
+from typing import Literal
+from agency_swarm.tools import BaseTool
+from pydantic import Field
+
+from helpers import execute_composio_tool
+import json
+
+
+class DeleteCalendarEvent(BaseTool):
+    """
+    Deletes a calendar event.
+    
+    Supports both Google Calendar and Outlook.
+    Use CheckEventsForDate first to get the event_id of the event to delete.
+    
+    WARNING: This action is irreversible. The event will be permanently deleted.
+    """
+    
+    provider: Literal["google", "outlook"] = Field(
+        ...,
+        description="Calendar provider: 'google' or 'outlook'"
+    )
+    
+    event_id: str = Field(
+        ...,
+        description="The unique ID of the event to delete (from CheckEventsForDate)"
+    )
+    
+    send_notifications: bool = Field(
+        default=True,
+        description="Whether to send cancellation notifications to attendees"
+    )
+    
+    def run(self):
+        try:
+            if self.provider == "google":
+                return self._delete_google_event(execute_composio_tool)
+            else:
+                return self._delete_outlook_event(execute_composio_tool)
+                
+        except Exception as e:
+            return f"Error deleting event: {str(e)}"
+    
+    def _delete_google_event(self, execute_tool) -> str:
+        """Deletes a Google Calendar event."""
+        result = execute_tool(
+            tool_name="GOOGLECALENDAR_DELETE_EVENT",
+            arguments={
+                "calendar_id": "primary",
+                "event_id": self.event_id
+            },
+        )
+        
+        if isinstance(result, dict) and result.get("error"):
+            return f"Error deleting Google Calendar event: {result.get('error')}"
+        
+        return json.dumps({
+            "provider": "google",
+            "success": True,
+            "event_id": self.event_id,
+            "message": "Event deleted successfully"
+        }, indent=2)
+    
+    def _delete_outlook_event(self, execute_tool) -> str:
+        """Deletes an Outlook calendar event."""
+        result = execute_tool(
+            tool_name="OUTLOOK_DELETE_EVENT",
+            arguments={
+                "user_id": "me",
+                "event_id": self.event_id,
+                "send_notifications": self.send_notifications
+            },
+        )
+        
+        if isinstance(result, dict) and result.get("error"):
+            return f"Error deleting Outlook event: {result.get('error')}"
+        
+        return json.dumps({
+            "provider": "outlook",
+            "success": True,
+            "event_id": self.event_id,
+            "message": "Event deleted successfully",
+            "notifications_sent": self.send_notifications
+        }, 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("DeleteCalendarEvent Test Suite")
+    print("=" * 60)
+    print()
+    
+    # First, list events to find a test event
+    from virtual_assistant.tools.CheckEventsForDate import CheckEventsForDate
+    
+    print("=== Getting events for tomorrow ===")
+    from datetime import datetime, timedelta
+    tomorrow = (datetime.now() + timedelta(days=1)).strftime("%Y-%m-%d")
+    
+    check_tool = CheckEventsForDate(provider="google", date=tomorrow)
+    result = check_tool.run()
+    
+    import json
+    data = json.loads(result)
+    
+    # Find a test event to delete
+    test_events = [e for e in data.get("events", []) if "Test" in e.get("title", "")]
+    
+    if test_events:
+        event = test_events[0]
+        print(f"Found test event: {event['title']} (ID: {event['event_id']})")
+        print()
+        
+        # Delete it
+        print("=== Deleting test event ===")
+        tool = DeleteCalendarEvent(
+            provider="google",
+            event_id=event["event_id"],
+            send_notifications=False
+        )
+        result = tool.run()
+        print(result)
+    else:
+        print("No test events found to delete")
+        print("Available events:")
+        for e in data.get("events", [])[:5]:
+            print(f"  - {e['title']}")
+    
+    print()
+    print("=" * 60)
+    print("Test completed!")
+    print("=" * 60)
+