@_vrsen/openswarm 0.1.0

package/shared_tools/ExecuteTool.py

@@ -0,0 +1,184 @@
+from typing import Optional, List
+from agency_swarm.tools import BaseTool
+from pydantic import Field
+import json
+
+from helpers import execute_composio_tool
+
+
+class ExecuteTool(BaseTool):
+    """
+    Executes a single Composio tool call and returns the result.
+    
+    Use this tool for simple, single-action tasks where you need to:
+    - Execute one tool
+    - Get the result
+    - No data transformation needed
+    
+    Examples:
+    - Creating a single calendar event
+    - Submitting a support ticket
+    - Sending a simple notification
+    - Fetching specific data
+    
+    For complex workflows requiring multiple tool calls or data transformation,
+    use IPythonInterpreter instead.
+    """
+    
+    tool_name: str = Field(
+        ..., 
+        description="The exact name of the Composio tool to execute (e.g., 'GMAIL_SEND_EMAIL', 'JIRA_CREATE_ISSUE')"
+    )
+    
+    arguments: dict = Field(
+        ...,
+        description="Dictionary of arguments to pass to the tool. Keys are parameter names, values are parameter values.",
+        # Workaround to avoid the agents SDK from stripping dynamic dictionary inputs:
+        json_schema_extra={"type":"object","additionalProperties": True, "properties": {}}
+    )
+    
+    return_fields: Optional[List[str]] = Field(
+        None,
+        description="Optional list of field names to extract from the tool's response. If provided, only these fields will be returned. If not provided or the field doesn't exist, the full response is returned."
+    )
+    class ToolConfig:
+        strict: bool = False
+    
+    def run(self):
+        try:
+            result = execute_composio_tool(
+                tool_name=self.tool_name,
+                arguments=self.arguments,
+            )
+
+            if isinstance(result, dict) and result.get("error"):
+                return f"Error executing {self.tool_name}: {result.get('error')}"
+
+            if self.return_fields:
+                filtered_result = {}
+                
+                # Handle both dict and object-like results
+                if isinstance(result, dict):
+                    for field in self.return_fields:
+                        # Support nested field access with dot notation (e.g., "data.id")
+                        if "." in field:
+                            parts = field.split(".")
+                            value = result
+                            try:
+                                for part in parts:
+                                    if isinstance(value, dict):
+                                        value = value.get(part)
+                                    else:
+                                        value = getattr(value, part, None)
+                                    if value is None:
+                                        break
+                                if value is not None:
+                                    filtered_result[field] = value
+                            except (KeyError, AttributeError, TypeError):
+                                # Field doesn't exist, skip it
+                                continue
+                        else:
+                            # Simple field access
+                            if field in result:
+                                filtered_result[field] = result[field]
+                else:
+                    # Try to access as object attributes
+                    for field in self.return_fields:
+                        try:
+                            if "." in field:
+                                parts = field.split(".")
+                                value = result
+                                for part in parts:
+                                    value = getattr(value, part, None)
+                                    if value is None:
+                                        break
+                                if value is not None:
+                                    filtered_result[field] = value
+                            else:
+                                value = getattr(result, field, None)
+                                if value is not None:
+                                    filtered_result[field] = value
+                        except (AttributeError, TypeError):
+                            # Field doesn't exist, skip it
+                            continue
+                
+                # Return filtered result if we got any fields, otherwise return full result
+                if filtered_result:
+                    return json.dumps(filtered_result, indent=2, default=str)
+                else:
+                    # No fields were found, return full result as fallback
+                    return json.dumps(result, indent=2, default=str)
+            
+            return json.dumps(result, indent=2, default=str)
+            
+        except Exception as e:
+            return f"Error executing tool {self.tool_name}: {str(e)}"
+
+
+if __name__ == "__main__":
+    import sys
+    import os
+    # Add parent directory to path for helpers import
+    sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")))
+    
+    print("=" * 60)
+    print("ExecuteTool Test Suite")
+    print("=" * 60)
+    print()
+    
+    # Test case 1: Simple execution without field filtering
+    print("Test 1: Execute GMAIL_LIST_LABELS without filtering")
+    print("-" * 60)
+    tool = ExecuteTool(
+        tool_name="GMAIL_LIST_LABELS",
+        arguments={"user_id": "me"}
+    )
+    result = tool.run()
+    print(f"Result length: {len(result)} characters")
+    print(f"Contains 'data': {'data' in result}")
+    print(f"Contains 'successful': {'successful' in result}")
+    print()
+    
+    # Test case 2: Execute tool with simple field filtering
+    print("Test 2: Execute with simple field filtering")
+    print("-" * 60)
+    tool = ExecuteTool(
+        tool_name="GMAIL_LIST_LABELS",
+        arguments={"user_id": "me"},
+        return_fields=["successful", "error"]
+    )
+    result = tool.run()
+    print("Filtered result:")
+    print(result)
+    print()
+    
+    # Test case 3: Execute tool with nested field access
+    print("Test 3: Execute with nested field filtering (dot notation)")
+    print("-" * 60)
+    tool = ExecuteTool(
+        tool_name="GMAIL_LIST_LABELS",
+        arguments={"user_id": "me"},
+        return_fields=["data.labels", "successful"]
+    )
+    result = tool.run()
+    print(f"Result length: {len(result)} characters")
+    print(f"Contains 'data.labels': {'data.labels' in result}")
+    print()
+    
+    # Test case 4: Non-existent fields fallback
+    print("Test 4: Non-existent fields (should return full result)")
+    print("-" * 60)
+    tool = ExecuteTool(
+        tool_name="GMAIL_LIST_LABELS",
+        arguments={"user_id": "me"},
+        return_fields=["nonexistent_field1", "nonexistent_field2"]
+    )
+    result = tool.run()
+    print(f"Result length: {len(result)} characters")
+    print(f"Fallback to full result: {len(result) > 1000}")
+    print()
+    
+    print("=" * 60)
+    print("All tests completed successfully!")
+    print("=" * 60)
+

package/shared_tools/FindTools.py

@@ -0,0 +1,101 @@
+from agency_swarm.tools import BaseTool
+from pydantic import Field
+
+from helpers import get_composio_tools
+
+
+class FindTools(BaseTool):
+    """
+    Finds available Composio tools by toolkit names, specific tool names, or OAuth scopes.
+    Use this when you know the toolkit or exact tool name you're looking for.
+    For discovering tools by description, use SearchTools instead.
+    If you already have the schema and the tool you need, DO NOT use this tool.
+    """
+    toolkits: list[str] = Field(
+        default=[],
+        description="List of toolkit names (e.g., ['GITHUB', 'GMAIL', 'SLACK']). "
+                    "Required if tool_names is not provided."
+    )
+    tool_names: list[str] = Field(
+        default=[],
+        description="List of specific tool names (e.g., ['GITHUB_CREATE_ISSUE', 'GMAIL_SEND_EMAIL']). "
+                    "Required if toolkits is not provided."
+    )
+    scopes: list[str] = Field(
+        default=[],
+        description="OAuth scopes to filter by permission level (e.g., ['write:org']). "
+                    "Only works with a single toolkit."
+    )
+    limit: int = Field(
+        default=10,
+        description="Maximum number of tools to return. Default is 10."
+    )
+    include_args: bool = Field(
+        default=False,
+        description="If True, includes the arguments/parameters for each tool in the output. "
+                    "Use ONLY when you are about to execute a specific tool. Do not set to true if you are still searching for the right tool."
+    )
+
+    def run(self):
+        """Fetches and formats Composio tools based on the provided filters."""
+        if self.tool_names:
+            tools = get_composio_tools(tools=self.tool_names)
+        elif self.toolkits:
+            kwargs = {
+                "toolkits": self.toolkits,
+                "limit": self.limit,
+            }
+            if self.scopes:
+                kwargs["scopes"] = self.scopes
+            tools = get_composio_tools(**kwargs)
+        else:
+            return "Error: Provide either 'toolkits' or 'tool_names'."
+
+        if isinstance(tools, dict) and tools.get("error"):
+            return f"Error: {tools.get('error')}"
+
+        return self._format_tools(tools)
+    
+    def _format_tools(self, tools: list) -> str:
+        """Formats tools into a concise, token-efficient string."""
+        if not tools:
+            return "No tools found matching the criteria."
+        
+        formatted_lines = [f"Found {len(tools)} tool(s):\n"]
+        
+        for tool in tools:
+            name = getattr(tool, 'name', 'Unknown')
+            description = getattr(tool, 'description', 'No description')
+            formatted_lines.append(f"• {name}: {description}")
+            
+            if self.include_args:
+                args = self._extract_args(tool)
+                if args:
+                    formatted_lines.append(f"  Args: {args}")
+        
+        return "\n".join(formatted_lines)
+    
+    def _extract_args(self, tool) -> str:
+        """Extracts and formats tool arguments as JSON."""
+        import json
+        try:
+            params = getattr(tool, 'params_json_schema', None)
+            if params and isinstance(params, dict) and 'properties' in params:
+                return json.dumps(params, indent=2)
+        except Exception:
+            pass
+        return ""
+
+
+if __name__ == "__main__":
+    # Test 1: Search by toolkit
+    print("=== Test: Search by toolkit (GITHUB) ===")
+    tool = FindTools(toolkits=["GITHUB"], limit=2)
+    print(tool.run())
+    print()
+    
+    # Test 2: Search by toolkit with args
+    print("=== Test: Search by toolkit with arguments ===")
+    tool = FindTools(toolkits=["GITHUB"], limit=2, include_args=True)
+    print(tool.run())
+

package/shared_tools/ManageConnections.py

@@ -0,0 +1,43 @@
+from agency_swarm.tools import BaseTool
+from pydantic import Field
+
+from helpers import execute_composio_tool
+
+
+class ManageConnections(BaseTool):
+    """
+    Check and manage Composio app connections for the current user.
+
+    Use this first when a task needs an external system (Gmail, Slack, Notion, etc.).
+    """
+
+    toolkits: list[str] = Field(
+        default=[],
+        description=(
+            "Optional list of toolkits to check/connect (e.g., ['gmail', 'slack', 'notion']). "
+            "If omitted, Composio decides based on context."
+        ),
+    )
+    reinitiate_all: bool = Field(
+        default=False,
+        description="If true, force reconnection for the specified toolkits.",
+    )
+    session_id: str | None = Field(
+        default=None,
+        description="Optional session id from a previous SearchTools response.",
+    )
+
+    def run(self):
+        arguments: dict = {}
+        if self.toolkits:
+            arguments["toolkits"] = self.toolkits
+        if self.reinitiate_all:
+            arguments["reinitiate_all"] = self.reinitiate_all
+        if self.session_id:
+            arguments["session_id"] = self.session_id
+
+        result = execute_composio_tool(
+            tool_name="COMPOSIO_MANAGE_CONNECTIONS",
+            arguments=arguments,
+        )
+        return str(result)

package/shared_tools/SearchTools.py

@@ -0,0 +1,44 @@
+from agency_swarm.tools import BaseTool
+from pydantic import Field
+
+from helpers import execute_composio_tool
+
+
+class SearchTools(BaseTool):
+    """
+    Search Composio tools for a task and return recommended tools + schemas.
+
+    Use this when you need to discover tools for a new external workflow.
+    """
+
+    queries: list[dict] = Field(
+        ...,
+        description=(
+            "List of query objects for COMPOSIO_SEARCH_TOOLS. "
+            "Each item should usually include at least a 'use_case' key."
+        ),
+    )
+    session: dict | None = Field(
+        default=None,
+        description=(
+            "Optional Composio search session payload. "
+            "Example: {'generate_id': true} or {'id': 'existing-session-id'}."
+        ),
+    )
+    model: str | None = Field(
+        default=None,
+        description="Optional model hint to pass through to COMPOSIO_SEARCH_TOOLS.",
+    )
+
+    def run(self):
+        arguments: dict = {"queries": self.queries}
+        if self.session is not None:
+            arguments["session"] = self.session
+        if self.model:
+            arguments["model"] = self.model
+
+        result = execute_composio_tool(
+            tool_name="COMPOSIO_SEARCH_TOOLS",
+            arguments=arguments,
+        )
+        return str(result)

package/shared_tools/__init__.py

@@ -0,0 +1,7 @@
+from shared_tools.CopyFile import CopyFile
+from shared_tools.ExecuteTool import ExecuteTool
+from shared_tools.FindTools import FindTools
+from shared_tools.ManageConnections import ManageConnections
+from shared_tools.SearchTools import SearchTools
+
+__all__ = ["CopyFile", "ExecuteTool", "FindTools", "ManageConnections", "SearchTools"]

package/slides_agent/.cursor/rules/slides-agent-workflow.mdc

@@ -0,0 +1,9 @@
+---
+alwaysApply: true
+---
+
+# Slides Agent Workflow Rules
+
+- Always run the integration test after any change:
+  `python -m unittest slides_agent.tests.test_claude_cowork_prompt`
+- Ask use for feedback on presentation after its implemented.

package/slides_agent/__init__.py

@@ -0,0 +1 @@
+from .slides_agent import create_slides_agent