@_vrsen/openswarm 0.1.0

package/virtual_assistant/tools/RescheduleCalendarEvent.py

@@ -0,0 +1,227 @@
+from typing import Literal, Optional
+from agency_swarm.tools import BaseTool
+from pydantic import Field
+import json
+
+from helpers import execute_composio_tool
+
+
+class RescheduleCalendarEvent(BaseTool):
+    """
+    Reschedules an existing calendar event to a new date/time.
+    
+    Supports both Google Calendar and Outlook. Can update:
+    - Start and end times
+    - Event title
+    - Location
+    - Description
+    
+    Use CheckEventsForDate first to get the event_id of the event to reschedule.
+    """
+    
+    provider: Literal["google", "outlook"] = Field(
+        ...,
+        description="Calendar provider: 'google' or 'outlook'"
+    )
+    
+    event_id: str = Field(
+        ...,
+        description="The unique ID of the event to reschedule (from CheckEventsForDate)"
+    )
+    
+    new_start_datetime: Optional[str] = Field(
+        default=None,
+        description="New start date/time in ISO format (e.g., '2026-01-10T14:00:00'). Required for rescheduling."
+    )
+    
+    new_end_datetime: Optional[str] = Field(
+        default=None,
+        description="New end date/time in ISO format. If not provided, will be calculated based on original duration."
+    )
+    
+    timezone: Optional[str] = Field(
+        default=None,
+        description="IANA timezone (e.g., 'America/New_York', 'Asia/Dubai'). Uses event's current timezone if not specified."
+    )
+    
+    new_title: Optional[str] = Field(
+        default=None,
+        description="New title/subject for the event. Leave empty to keep current title."
+    )
+    
+    new_location: Optional[str] = Field(
+        default=None,
+        description="New location for the event. Leave empty to keep current location."
+    )
+    
+    new_description: Optional[str] = Field(
+        default=None,
+        description="New description for the event. Leave empty to keep current description."
+    )
+    
+    send_updates: Literal["all", "externalOnly", "none"] = Field(
+        default="all",
+        description="Who to notify about the change: 'all', 'externalOnly', or 'none'"
+    )
+    
+    def run(self):
+        try:
+            if self.provider == "google":
+                return self._reschedule_google_event(execute_composio_tool)
+            else:
+                return self._reschedule_outlook_event(execute_composio_tool)
+                
+        except Exception as e:
+            return f"Error rescheduling event: {str(e)}"
+    
+    def _reschedule_google_event(self, execute_tool) -> str:
+        """Reschedules a Google Calendar event."""
+        # Build arguments - only include fields that are being updated
+        arguments = {
+            "calendar_id": "primary",
+            "event_id": self.event_id
+        }
+        
+        if self.new_start_datetime:
+            arguments["start_time"] = self.new_start_datetime
+        
+        if self.new_end_datetime:
+            arguments["end_time"] = self.new_end_datetime
+        
+        if self.timezone:
+            arguments["timezone"] = self.timezone
+        
+        if self.new_title:
+            arguments["summary"] = self.new_title
+        
+        if self.new_location:
+            arguments["location"] = self.new_location
+        
+        if self.new_description:
+            arguments["description"] = self.new_description
+        
+        arguments["send_updates"] = self.send_updates
+        
+        # Execute the patch
+        result = execute_tool(
+            tool_name="GOOGLECALENDAR_PATCH_EVENT",
+            arguments=arguments,
+        )
+        
+        if isinstance(result, dict) and result.get("error"):
+            return f"Error rescheduling Google Calendar event: {result.get('error')}"
+        
+        data = result.get("data", {})
+        
+        # Extract updated event details
+        start = data.get("start", {})
+        end = data.get("end", {})
+        
+        return json.dumps({
+            "provider": "google",
+            "success": True,
+            "event_id": data.get("id"),
+            "title": data.get("summary", "(No title)"),
+            "new_start": start.get("dateTime") or start.get("date"),
+            "new_end": end.get("dateTime") or end.get("date"),
+            "location": data.get("location", ""),
+            "html_link": data.get("htmlLink", ""),
+            "updates_sent_to": self.send_updates
+        }, indent=2)
+    
+    def _reschedule_outlook_event(self, execute_tool) -> str:
+        """Reschedules an Outlook calendar event."""
+        # Build arguments - only include fields that are being updated
+        arguments = {
+            "user_id": "me",
+            "event_id": self.event_id
+        }
+        
+        if self.new_start_datetime:
+            arguments["start_datetime"] = self.new_start_datetime
+        
+        if self.new_end_datetime:
+            arguments["end_datetime"] = self.new_end_datetime
+        
+        if self.timezone:
+            arguments["time_zone"] = self.timezone
+        
+        if self.new_title:
+            arguments["subject"] = self.new_title
+        
+        if self.new_location:
+            arguments["location"] = self.new_location
+        
+        if self.new_description:
+            arguments["body"] = {
+                "contentType": "Text",
+                "content": self.new_description
+            }
+        
+        # Execute the update
+        result = execute_tool(
+            tool_name="OUTLOOK_UPDATE_CALENDAR_EVENT",
+            arguments=arguments,
+        )
+        
+        if isinstance(result, dict) and result.get("error"):
+            return f"Error rescheduling Outlook event: {result.get('error')}"
+        
+        data = result.get("data", {})
+        
+        # Extract updated event details
+        start = data.get("start", {})
+        end = data.get("end", {})
+        
+        return json.dumps({
+            "provider": "outlook",
+            "success": True,
+            "event_id": data.get("id"),
+            "title": data.get("subject", "(No title)"),
+            "new_start": start.get("dateTime"),
+            "new_end": end.get("dateTime"),
+            "location": data.get("location", {}).get("displayName", ""),
+            "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("RescheduleCalendarEvent Test Suite")
+    print("=" * 60)
+    print()
+    
+    # First, get an event to reschedule
+    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()
+    print(result)
+    print()
+    
+    import json
+    try:
+        data = json.loads(result)
+        if data.get("events"):
+            event = data["events"][0]
+            event_id = event["event_id"]
+            print(f"Found event: {event['title']} (ID: {event_id})")
+        else:
+            print("No events found for tomorrow to test with")
+    except json.JSONDecodeError:
+        print(f"Result: {result}")
+    
+    print()
+    print("=" * 60)
+    print("Test completed!")
+    print("=" * 60)
+
+

package/virtual_assistant/tools/ScholarSearch.py

@@ -0,0 +1,216 @@
+from typing import Optional
+from agency_swarm.tools import BaseTool
+from pydantic import Field
+import json
+
+import os
+
+
+class ScholarSearch(BaseTool):
+    """
+    Searches for scholarly literature on Google Scholar.
+    
+    Returns academic papers, articles, theses, books, and conference papers.
+    Includes links to PDFs and full-text resources when available.
+    
+    RATE LIMIT: This tool can only be called ONCE per each user request (message) to save API costs.
+    Make sure to request enough results in a single call.
+    """
+
+    query: str = Field(
+        ...,
+        description="Search query for scholarly articles (e.g., 'machine learning', 'climate change effects', 'quantum computing')"
+    )
+    
+    year_from: Optional[int] = Field(
+        default=None,
+        description="Filter results from this year onwards (e.g., 2020)"
+    )
+    
+    year_to: Optional[int] = Field(
+        default=None,
+        description="Filter results up to this year (e.g., 2024)"
+    )
+    
+    num_results: int = Field(
+        default=10,
+        ge=1,
+        le=20,
+        description="Number of results to return (1-20)"
+    )
+    
+    page: int = Field(
+        default=1,
+        ge=1,
+        description="Page number for pagination"
+    )
+    
+    def run(self):
+        try:
+            import requests
+            
+            # Rate limiting: Check if already called in this session
+            if self.context and self.context.get("scholar_search_called", False):
+                return "Error: ScholarSearch can only be called once per user request to save API costs. Use the results from the previous search or web search tool."
+            
+            api_key = os.getenv("SEARCH_API_KEY")
+            if not api_key:
+                raise ValueError("SEARCH_API_KEY is not set. Add it to your .env to use ScholarSearch.")
+            
+            # Build request parameters
+            params = {
+                "engine": "google_scholar",
+                "api_key": api_key,
+                "q": self.query,
+                "num": self.num_results,
+                "page": self.page
+            }
+            
+            # Add year filters
+            if self.year_from:
+                params["as_ylo"] = self.year_from
+            
+            if self.year_to:
+                params["as_yhi"] = self.year_to
+            
+            # Make API request
+            response = requests.get(
+                "https://www.searchapi.io/api/v1/search",
+                params=params,
+                timeout=30
+            )
+            
+            if response.status_code != 200:
+                return f"Error: API returned status {response.status_code}: {response.text}"
+            
+            data = response.json()
+            
+            # Check for API errors
+            if "error" in data:
+                return f"Error from API: {data['error']}"
+            
+            # Extract results
+            organic_results = data.get("organic_results", [])
+            profiles = data.get("profiles", [])
+            search_info = data.get("search_information", {})
+            
+            # Format articles
+            articles = []
+            for result in organic_results:
+                # Extract authors
+                authors = []
+                for author in result.get("authors", []):
+                    authors.append(author.get("name", "Unknown"))
+                
+                # Extract citation info
+                inline_links = result.get("inline_links", {})
+                cited_by = inline_links.get("cited_by", {})
+                versions = inline_links.get("versions", {})
+                
+                # Extract resource (PDF, etc.)
+                resource = result.get("resource", {})
+                
+                article = {
+                    "title": result.get("title"),
+                    "link": result.get("link"),
+                    "publication": result.get("publication"),
+                    "snippet": result.get("snippet"),
+                    "authors": authors,
+                    "citations": cited_by.get("total"),
+                    "cites_id": cited_by.get("cites_id"),
+                    "versions_count": versions.get("total"),
+                    "cluster_id": versions.get("cluster_id")
+                }
+                
+                # Add resource link (PDF, etc.) - important for reading full papers
+                if resource:
+                    article["resource"] = {
+                        "name": resource.get("name"),
+                        "format": resource.get("format"),
+                        "link": resource.get("link")
+                    }
+                
+                # Add related links
+                if inline_links.get("related_articles_link"):
+                    article["related_articles_link"] = inline_links.get("related_articles_link")
+                
+                articles.append(article)
+            
+            # Format author profiles if any
+            author_profiles = []
+            for profile in profiles:
+                author_profiles.append({
+                    "name": profile.get("name"),
+                    "affiliations": profile.get("affiliations"),
+                    "email_domain": profile.get("email"),
+                    "total_citations": profile.get("cited_by", {}).get("total"),
+                    "profile_link": profile.get("link"),
+                    "author_id": profile.get("author_id")
+                })
+            
+            # Mark as called in shared state (rate limiting)
+            if self.context:
+                self.context.set("scholar_search_called", True)
+
+            result = {
+                "query": self.query,
+                "filters": {
+                    "year_from": self.year_from,
+                    "year_to": self.year_to
+                },
+                "total_results": search_info.get("total_results"),
+                "page": self.page,
+                "articles_count": len(articles),
+                "articles": articles
+            }
+            
+            if author_profiles:
+                result["author_profiles"] = author_profiles
+            
+            return json.dumps(result, indent=2)
+            
+        except Exception as e:
+            return f"Error searching scholar: {str(e)}"
+
+
+
+if __name__ == "__main__":
+    import sys
+    import os
+    sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")))
+    
+    print("=" * 60)
+    print("ScholarSearch Test Suite")
+    print("=" * 60)
+    print()
+    
+    # Test 1: Basic search
+    print("Test 1: Basic scholarly search")
+    print("-" * 60)
+    tool = ScholarSearch(
+        query="transformer architecture deep learning",
+        num_results=5
+    )
+    result = tool.run()
+    
+    try:
+        data = json.loads(result)
+        print(f"Query: {data['query']}")
+        print(f"Total results: {data.get('total_results', 'N/A')}")
+        print(f"Articles returned: {data['articles_count']}")
+        print()
+        
+        for i, article in enumerate(data['articles'][:3], 1):
+            print(f"{i}. {article['title']}")
+            print(f"   Authors: {', '.join(article['authors'][:3])}...")
+            print(f"   Citations: {article.get('citations', 'N/A')}")
+            if article.get('resource'):
+                print(f"   PDF: {article['resource'].get('link', 'N/A')}")
+            print()
+    except json.JSONDecodeError:
+        print(result)
+    
+    print("=" * 60)
+    print("Tests completed!")
+    print("=" * 60)
+

package/virtual_assistant/tools/SendDraft.py

@@ -0,0 +1,101 @@
+from typing import Literal
+from agency_swarm.tools import BaseTool
+from pydantic import Field, field_validator
+import json
+
+from helpers import execute_composio_tool
+
+
+class SendDraft(BaseTool):
+    """
+    Sends an existing email draft by its ID.
+    
+    Use this after creating a draft with DraftEmail and getting user approval.
+    The draft must have at least one recipient (to, cc, or bcc) to be sent.
+    """
+    
+    provider: Literal["gmail", "outlook"] = Field(
+        ...,
+        description="Email provider: 'gmail' or 'outlook'"
+    )
+    
+    draft_id: str = Field(
+        ...,
+        description="The draft ID to send (obtained from DraftEmail tool)"
+    )
+
+    @field_validator("draft_id")
+    @classmethod
+    def validate_draft_id(cls, v: str) -> str:
+        if "noop" in v.lower():
+            raise ValueError("This tool should used to send an existing EMAIL draft. REVIEW YOUR INSTRUCTIONS AND USE THE APPROPRIATE TOOLS TO COMPLETE YOUR TASKS.")
+        return v
+    
+    def run(self):
+        try:
+            if self.provider == "gmail":
+                return self._send_gmail_draft(execute_composio_tool)
+            else:
+                return self._send_outlook_draft(execute_composio_tool)
+                
+        except Exception as e:
+            return f"Error sending draft: {str(e)}"
+    
+    def _send_gmail_draft(self, execute_tool) -> str:
+        """Sends a Gmail draft."""
+        result = execute_tool(
+            tool_name="GMAIL_SEND_DRAFT",
+            arguments={"user_id": "me", "draft_id": self.draft_id},
+        )
+
+        if isinstance(result, dict) and result.get("error"):
+            return f"Error sending Gmail draft: {result.get('error')}"
+
+        data = result.get("data", {})
+        
+        return json.dumps({
+            "provider": "gmail",
+            "success": True,
+            "message": "Email sent successfully",
+            "message_id": data.get("id"),
+            "thread_id": data.get("threadId"),
+            "labels": data.get("labelIds", [])
+        }, indent=2)
+    
+    def _send_outlook_draft(self, execute_tool) -> str:
+        """Sends an Outlook draft."""
+        result = execute_tool(
+            tool_name="OUTLOOK_SEND_DRAFT",
+            arguments={"user_id": "me", "message_id": self.draft_id},
+        )
+
+        if isinstance(result, dict) and result.get("error"):
+            return f"Error sending Outlook draft: {result.get('error')}"
+
+        # Outlook send returns HTTP 202 with no body
+        return json.dumps({
+            "provider": "outlook",
+            "success": True,
+            "message": "Email sent 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("SendDraft Test Suite")
+    print("=" * 60)
+    print()
+    print("To test SendDraft, first create a draft using DraftEmail,")
+    print("then use the draft_id to send it.")
+    print()
+    print("Example:")
+    print("  tool = SendDraft(provider='gmail', draft_id='r12345...')")
+    print("  result = tool.run()")
+    print()
+    print("=" * 60)
+

package/virtual_assistant/tools/SendSlackMessage.py

@@ -0,0 +1,148 @@
+from typing import Optional
+from agency_swarm.tools import BaseTool
+from pydantic import Field
+import json
+
+from helpers import execute_composio_tool
+
+
+class SendSlackMessage(BaseTool):
+    """
+    Sends a message to a Slack channel or DM. Supports threaded replies.
+    Use channel ID or name. For replies, provide the parent message timestamp.
+    """
+    
+    channel: str = Field(
+        ...,
+        description="Channel ID or name (e.g., 'C06NX4Q1ACE', '#general', or '@username')"
+    )
+    
+    text: str = Field(
+        ...,
+        description="Message text to send. Use Slack formatting."
+    )
+    
+    thread_ts: Optional[str] = Field(
+        default=None,
+        description="Parent message timestamp to reply in thread. Leave empty for new message."
+    )
+    
+    def run(self):
+        try:
+            # Resolve channel
+            channel_id = self._resolve_channel(execute_composio_tool, self.channel)
+            if channel_id.startswith("Error"):
+                return channel_id
+            
+            # Send message
+            args = {
+                "channel": channel_id,
+                "text": self.text
+            }
+            
+            if self.thread_ts:
+                args["thread_ts"] = self.thread_ts
+            
+            result = execute_composio_tool(
+                tool_name="SLACK_SEND_MESSAGE",
+                arguments=args,
+            )
+            
+            if result.get("error"):
+                return f"Error sending message: {result.get('error')}"
+            
+            data = result.get("data", {})
+            msg = data.get("message", {})
+            
+            return json.dumps({
+                "success": True,
+                "channel_id": channel_id,
+                "ts": msg.get("ts"),
+                "thread_ts": self.thread_ts,
+                "permalink": self._build_permalink(data, channel_id, msg.get("ts"))
+            }, indent=2)
+            
+        except Exception as e:
+            return f"Error: {str(e)}"
+    
+    def _resolve_channel(self, execute_tool, channel: str) -> str:
+        """Resolves channel/user name to ID."""
+        # Already an ID
+        if channel.startswith(("C", "D", "G")):
+            return channel
+        
+        # Handle @username for DMs
+        if channel.startswith("@"):
+            return self._find_user_dm(execute_tool, channel[1:])
+        
+        # Remove # prefix and find channel
+        name = channel.lstrip("#")
+        
+        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 _find_user_dm(self, execute_tool, username: str) -> str:
+        """Finds DM channel for a user."""
+        # Find user
+        result = execute_tool(
+            tool_name="SLACK_FIND_USERS",
+            arguments={"query": username},
+        )
+        
+        if result.get("error"):
+            return f"Error: Could not find user '{username}'"
+        
+        members = result.get("data", {}).get("members", [])
+        target_user = None
+        
+        for member in members:
+            name = member.get("name", "").lower()
+            display = member.get("profile", {}).get("display_name", "").lower()
+            real = member.get("profile", {}).get("real_name", "").lower()
+            
+            if username.lower() in [name, display, real]:
+                target_user = member.get("id")
+                break
+        
+        if not target_user:
+            return f"Error: User '{username}' not found"
+        
+        # Find existing DM or it will be created when sending
+        # For now, return a marker that we need to send to user
+        # Slack's SEND_MESSAGE can accept user IDs for DMs
+        return target_user
+    
+    def _build_permalink(self, data: dict, channel_id: str, ts: str) -> str:
+        """Builds message permalink if available."""
+        # Some responses include permalink directly
+        if "permalink" in data:
+            return data["permalink"]
+        
+        # Otherwise return empty - would need workspace URL
+        return ""
+
+
+if __name__ == "__main__":
+    import sys
+    import os
+    sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")))
+    
+    print("SendSlackMessage Test")
+    print("-" * 40)
+    print("Skipping actual send to avoid spam")
+    print("Example usage:")
+    print('  SendSlackMessage(channel="#random", text="Hello!")')
+    print('  SendSlackMessage(channel="C123", text="Reply", thread_ts="1234.5678")')
+