@_vrsen/openswarm 0.1.0

package/virtual_assistant/tools/ListSkills.py

@@ -0,0 +1,94 @@
+import os
+
+from agency_swarm.tools import BaseTool
+
+
+class ListSkills(BaseTool):
+    """
+    Lists all skills currently available to you.
+    """
+
+    def run(self):
+        try:
+            skills_path = os.path.join(os.getcwd(), "mnt/skills")
+
+            if not os.path.exists(skills_path):
+                return f"Error: Skills folder does not exist: {skills_path}"
+
+            if not os.path.isdir(skills_path):
+                return f"Error: Skills path is not a directory: {skills_path}"
+
+            skills = []
+            try:
+                entries = os.listdir(skills_path)
+            except PermissionError:
+                return f"Error: Permission denied accessing skills folder: {skills_path}"
+
+            for entry in sorted(entries):
+                entry_path = os.path.join(skills_path, entry)
+
+                if not os.path.isdir(entry_path):
+                    continue
+
+                skill_file = None
+                if os.path.exists(os.path.join(entry_path, "SKILL.md")):
+                    skill_file = os.path.join(entry_path, "SKILL.md")
+                elif os.path.exists(os.path.join(entry_path, "skill.md")):
+                    skill_file = os.path.join(entry_path, "skill.md")
+
+                if not skill_file:
+                    continue
+
+                try:
+                    with open(skill_file, "r", encoding="utf-8") as f:
+                        lines = f.readlines()
+
+                    name = None
+                    description = None
+
+                    # Parse frontmatter: lines 2 and 3 carry "name:" and "description:"
+                    if len(lines) > 1:
+                        line2 = lines[1].strip()
+                        if line2.startswith("name:"):
+                            name = line2.split("name:", 1)[1].strip()
+
+                    if len(lines) > 2:
+                        line3 = lines[2].strip()
+                        if line3.startswith("description:"):
+                            description = line3.split("description:", 1)[1].strip()
+
+                    skills.append({
+                        "name": name or entry,
+                        "description": description or "No description available",
+                        "relative_path": os.path.relpath(skill_file, os.getcwd()),
+                    })
+
+                except Exception as e:
+                    skills.append({
+                        "name": entry,
+                        "description": f"Error reading skill file: {str(e)}",
+                        "relative_path": os.path.relpath(skill_file, os.getcwd()),
+                    })
+
+            if not skills:
+                return f"No skills found in {skills_path}"
+
+            output = [f"Found {len(skills)} skill(s) in {skills_path}:\n"]
+
+            for i, skill in enumerate(skills, 1):
+                output.append(f"\n{i}. {skill['name']}")
+                output.append(f"   Description: {skill['description']}")
+                output.append(f"   Path: {skill['relative_path']}")
+
+            return "\n".join(output)
+
+        except Exception as e:
+            return f"Error listing skills: {str(e)}"
+
+
+if __name__ == "__main__":
+    # Test the tool
+    tool = ListSkills()
+    result = tool.run()
+    print(result)
+

package/virtual_assistant/tools/ManageLabels.py

@@ -0,0 +1,295 @@
+from typing import Literal, Optional
+from agency_swarm.tools import BaseTool
+from pydantic import Field
+import json
+
+from helpers import execute_composio_tool
+
+
+class ManageLabels(BaseTool):
+    """
+    Manages email labels (Gmail) or categories (Outlook).
+    
+    Actions:
+    - list: List all labels/categories
+    - create: Create a new label/category
+    - update: Rename or update a label (Gmail only)
+    - delete: Delete a label/category
+    """
+    
+    provider: Literal["gmail", "outlook"] = Field(
+        ...,
+        description="Email provider: 'gmail' or 'outlook'"
+    )
+    
+    action: Literal["list", "create", "update", "delete"] = Field(
+        ...,
+        description="Action to perform: 'list', 'create', 'update', or 'delete'"
+    )
+    
+    label_name: Optional[str] = Field(
+        default=None,
+        description="Name of the label/category (required for create, update)"
+    )
+    
+    label_id: Optional[str] = Field(
+        default=None,
+        description="ID of the label/category (required for update, delete). For Gmail, use format 'Label_123'"
+    )
+    
+    new_name: Optional[str] = Field(
+        default=None,
+        description="New name when updating a label (Gmail only)"
+    )
+    
+    color: Optional[str] = Field(
+        default=None,
+        description="Color for the label. Gmail: hex color like '#fb4c2f'. Outlook: 'preset0' through 'preset24'"
+    )
+    
+    def run(self):
+        try:
+            if self.provider == "gmail":
+                return self._manage_gmail_labels(execute_composio_tool)
+            else:
+                return self._manage_outlook_categories(execute_composio_tool)
+                
+        except Exception as e:
+            return f"Error managing labels: {str(e)}"
+    
+    def _manage_gmail_labels(self, execute_tool) -> str:
+        """Manages Gmail labels."""
+        if self.action == "list":
+            return self._list_gmail_labels(execute_tool)
+        elif self.action == "create":
+            return self._create_gmail_label(execute_tool)
+        elif self.action == "update":
+            return self._update_gmail_label(execute_tool)
+        elif self.action == "delete":
+            return self._delete_gmail_label(execute_tool)
+        else:
+            return f"Unknown action: {self.action}"
+    
+    def _list_gmail_labels(self, execute_tool) -> str:
+        """Lists all Gmail labels."""
+        result = execute_tool(
+            tool_name="GMAIL_LIST_LABELS",
+            arguments={"user_id": "me"},
+        )
+        
+        if isinstance(result, dict) and result.get("error"):
+            return f"Error listing Gmail labels: {result.get('error')}"
+        
+        labels = result.get("data", {}).get("labels", [])
+        
+        formatted_labels = []
+        for label in labels:
+            formatted_labels.append({
+                "id": label.get("id"),
+                "name": label.get("name"),
+                "type": label.get("type"),  # system or user
+            })
+        
+        return json.dumps({
+            "provider": "gmail",
+            "count": len(formatted_labels),
+            "labels": formatted_labels
+        }, indent=2)
+    
+    def _create_gmail_label(self, execute_tool) -> str:
+        """Creates a Gmail label."""
+        if not self.label_name:
+            return "Error: label_name is required for create action"
+        
+        arguments = {
+            "user_id": "me",
+            "label_name": self.label_name
+        }
+        
+        if self.color:
+            arguments["background_color"] = self.color
+        
+        result = execute_tool(
+            tool_name="GMAIL_CREATE_LABEL",
+            arguments=arguments,
+        )
+        
+        if isinstance(result, dict) and result.get("error"):
+            return f"Error creating Gmail label: {result.get('error')}"
+        
+        data = result.get("data", {})
+        
+        return json.dumps({
+            "provider": "gmail",
+            "success": True,
+            "action": "create",
+            "label_id": data.get("id"),
+            "label_name": data.get("name")
+        }, indent=2)
+    
+    def _update_gmail_label(self, execute_tool) -> str:
+        """Updates a Gmail label."""
+        if not self.label_id:
+            return "Error: label_id is required for update action"
+        
+        arguments = {
+            "userId": "me",
+            "id": self.label_id
+        }
+        
+        if self.new_name:
+            arguments["name"] = self.new_name
+        
+        if self.color:
+            arguments["color"] = {
+                "backgroundColor": self.color,
+                "textColor": "#ffffff"
+            }
+        
+        if not self.new_name and not self.color:
+            return "Error: new_name or color is required for update action"
+        
+        result = execute_tool(
+            tool_name="GMAIL_PATCH_LABEL",
+            arguments=arguments,
+        )
+        
+        if isinstance(result, dict) and result.get("error"):
+            return f"Error updating Gmail label: {result.get('error')}"
+        
+        data = result.get("data", {})
+        
+        return json.dumps({
+            "provider": "gmail",
+            "success": True,
+            "action": "update",
+            "label_id": data.get("id"),
+            "label_name": data.get("name")
+        }, indent=2)
+    
+    def _delete_gmail_label(self, execute_tool) -> str:
+        """Deletes a Gmail label."""
+        if not self.label_id:
+            return "Error: label_id is required for delete action"
+        
+        result = execute_tool(
+            tool_name="GMAIL_DELETE_LABEL",
+            arguments={
+                "user_id": "me",
+                "label_id": self.label_id
+            },
+        )
+        
+        if isinstance(result, dict) and result.get("error"):
+            return f"Error deleting Gmail label: {result.get('error')}"
+        
+        return json.dumps({
+            "provider": "gmail",
+            "success": True,
+            "action": "delete",
+            "label_id": self.label_id
+        }, indent=2)
+    
+    def _manage_outlook_categories(self, execute_tool) -> str:
+        """Manages Outlook categories."""
+        if self.action == "list":
+            return self._list_outlook_categories(execute_tool)
+        elif self.action == "create":
+            return self._create_outlook_category(execute_tool)
+        elif self.action == "update":
+            return "Error: Outlook categories cannot be renamed via API. Delete and recreate instead."
+        elif self.action == "delete":
+            return "Error: Outlook category deletion not available. Categories can only be managed in Outlook settings."
+        else:
+            return f"Unknown action: {self.action}"
+    
+    def _list_outlook_categories(self, execute_tool) -> str:
+        """Lists all Outlook categories."""
+        result = execute_tool(
+            tool_name="OUTLOOK_GET_MASTER_CATEGORIES",
+            arguments={"user_id": "me"},
+        )
+        
+        if isinstance(result, dict) and result.get("error"):
+            return f"Error listing Outlook categories: {result.get('error')}"
+        
+        categories = result.get("data", {}).get("value", [])
+        
+        formatted_categories = []
+        for cat in categories:
+            formatted_categories.append({
+                "id": cat.get("id"),
+                "name": cat.get("displayName"),
+                "color": cat.get("color")
+            })
+        
+        return json.dumps({
+            "provider": "outlook",
+            "count": len(formatted_categories),
+            "categories": formatted_categories
+        }, indent=2)
+    
+    def _create_outlook_category(self, execute_tool) -> str:
+        """Creates an Outlook category."""
+        if not self.label_name:
+            return "Error: label_name is required for create action"
+        
+        arguments = {"displayName": self.label_name}
+        
+        if self.color:
+            arguments["color"] = self.color
+        
+        result = execute_tool(
+            tool_name="OUTLOOK_CREATE_MASTER_CATEGORY",
+            arguments=arguments,
+        )
+        
+        if isinstance(result, dict) and result.get("error"):
+            return f"Error creating Outlook category: {result.get('error')}"
+        
+        data = result.get("data", {})
+        
+        return json.dumps({
+            "provider": "outlook",
+            "success": True,
+            "action": "create",
+            "category_id": data.get("id"),
+            "category_name": data.get("displayName"),
+            "color": data.get("color")
+        }, 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("ManageLabels Test Suite")
+    print("=" * 60)
+    print()
+    
+    # Test 1: List Gmail labels
+    print("Test 1: List Gmail labels")
+    print("-" * 60)
+    tool = ManageLabels(provider="gmail", action="list")
+    result = tool.run()
+    # Just show first few labels
+    import json
+    data = json.loads(result)
+    data["labels"] = data["labels"][:5]
+    print(json.dumps(data, indent=2))
+    print()
+    
+    # Test 2: List Outlook categories
+    print("Test 2: List Outlook categories")
+    print("-" * 60)
+    tool = ManageLabels(provider="outlook", action="list")
+    result = tool.run()
+    print(result)
+    print()
+    
+    print("=" * 60)
+    print("Tests completed!")
+    print("=" * 60)
+

package/virtual_assistant/tools/ProductSearch.py

@@ -0,0 +1,254 @@
+from typing import Literal, Optional
+from agency_swarm.tools import BaseTool
+from pydantic import Field
+import json
+
+import os
+
+
+class ProductSearch(BaseTool):
+    """
+    Searches for products on Google Shopping.
+    
+    Returns product listings with prices, ratings, sellers, and availability.
+    Useful for price comparisons, finding deals, and product research.
+    
+    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 products (e.g., 'iPhone 15 Pro', 'running shoes', 'wireless headphones')"
+    )
+    
+    location: Optional[str] = Field(
+        default=None,
+        description="Location for the search (e.g., 'United States', 'New York', 'London'). Affects pricing and availability."
+    )
+    
+    country: Optional[str] = Field(
+        default="us",
+        description="Country code (e.g., 'us', 'gb', 'de', 'fr', 'jp')"
+    )
+    
+    language: Optional[str] = Field(
+        default="en",
+        description="Interface language (e.g., 'en', 'es', 'fr', 'de')"
+    )
+    
+    sort_by: Optional[Literal["relevance", "review_score", "price_low_to_high", "price_high_to_low"]] = Field(
+        default="relevance",
+        description="Sort results by: 'relevance', 'review_score', 'price_low_to_high', or 'price_high_to_low'"
+    )
+    
+    price_min: Optional[float] = Field(
+        default=None,
+        description="Minimum price filter"
+    )
+    
+    price_max: Optional[float] = Field(
+        default=None,
+        description="Maximum price filter"
+    )
+    
+    condition: Optional[Literal["new", "used"]] = Field(
+        default=None,
+        description="Filter by product condition: 'new' or 'used'"
+    )
+    
+    num_results: int = Field(
+        default=10,
+        ge=1,
+        le=60,
+        description="Number of results to return (1-60)"
+    )
+    
+    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("product_search_called", False):
+                return "Error: ProductSearch 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 ProductSearch.")
+            
+            # Build request parameters
+            params = {
+                "engine": "google_shopping",
+                "api_key": api_key,
+                "q": self.query,
+                "num": self.num_results,
+                "page": self.page
+            }
+            
+            # Add optional parameters
+            if self.location:
+                params["location"] = self.location
+            
+            if self.country:
+                params["gl"] = self.country
+            
+            if self.language:
+                params["hl"] = self.language
+            
+            if self.sort_by and self.sort_by != "relevance":
+                params["sort_by"] = self.sort_by
+            
+            if self.price_min is not None:
+                params["price_min"] = str(self.price_min)
+            
+            if self.price_max is not None:
+                params["price_max"] = str(self.price_max)
+            
+            if self.condition:
+                params["condition"] = self.condition
+            
+            # 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 and format results
+            shopping_results = data.get("shopping_results", [])
+            shopping_ads = data.get("shopping_ads", [])
+            
+            # Combine results (ads first, then organic)
+            all_products = []
+            
+            # Process shopping ads
+            for ad in shopping_ads[:5]:  # Limit ads to 5
+                all_products.append({
+                    "type": "sponsored",
+                    "title": ad.get("title"),
+                    "price": ad.get("price"),
+                    "extracted_price": ad.get("extracted_price"),
+                    "original_price": ad.get("original_price"),
+                    "seller": ad.get("seller"),
+                    "rating": ad.get("rating"),
+                    "reviews": ad.get("reviews"),
+                    "condition": ad.get("condition"),
+                    "delivery": ad.get("delivery"),
+                    "link": ad.get("link"),
+                    "image": ad.get("image")
+                })
+            
+            # Process organic shopping results
+            for result in shopping_results:
+                all_products.append({
+                    "type": "organic",
+                    "title": result.get("title"),
+                    "price": result.get("price"),
+                    "extracted_price": result.get("extracted_price"),
+                    "original_price": result.get("original_price"),
+                    "seller": result.get("seller"),
+                    "rating": result.get("rating"),
+                    "reviews": result.get("reviews"),
+                    "condition": result.get("condition"),
+                    "delivery": result.get("delivery"),
+                    "offers": result.get("offers"),
+                    "product_id": result.get("product_id") or result.get("prds"),
+                    "product_link": result.get("product_link"),
+                    "thumbnail": result.get("thumbnail")
+                })
+            
+            # Mark as called in shared state (rate limiting)
+            if self.context:
+                self.context.set("product_search_called", True)
+
+            return json.dumps({
+                "query": self.query,
+                "location": self.location,
+                "sort_by": self.sort_by,
+                "filters": {
+                    "price_min": self.price_min,
+                    "price_max": self.price_max,
+                    "condition": self.condition
+                },
+                "total_results": len(all_products),
+                "page": self.page,
+                "products": all_products
+            }, indent=2)
+            
+        except Exception as e:
+            return f"Error searching products: {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("ProductSearch Test Suite")
+    print("=" * 60)
+    print()
+    
+    # Test 1: Basic search
+    print("Test 1: Basic product search")
+    print("-" * 60)
+    tool = ProductSearch(
+        query="wireless headphones",
+        num_results=5
+    )
+    result = tool.run()
+    
+    try:
+        data = json.loads(result)
+        print(f"Query: {data['query']}")
+        print(f"Total results: {data['total_results']}")
+        if data['products']:
+            print(f"First product: {data['products'][0]['title']}")
+            print(f"  Price: {data['products'][0]['price']}")
+            print(f"  Seller: {data['products'][0]['seller']}")
+    except json.JSONDecodeError:
+        print(result)
+    print()
+    
+    # Test 2: Search with price filter
+    print("Test 2: Search with price filter")
+    print("-" * 60)
+    tool = ProductSearch(
+        query="running shoes",
+        price_min=50,
+        price_max=150,
+        sort_by="price_low_to_high",
+        num_results=3
+    )
+    result = tool.run()
+    
+    try:
+        data = json.loads(result)
+        print(f"Query: {data['query']}")
+        print(f"Filters: {data['filters']}")
+        print(f"Sort: {data['sort_by']}")
+        print(f"Results: {data['total_results']}")
+    except json.JSONDecodeError:
+        print(result)
+    print()
+    
+    print("=" * 60)
+    print("Tests completed!")
+    print("=" * 60)
+