composio-openai-agents 0.7.7__py3-none-any.whl

composio_openai_agents/__init__.py

@@ -0,0 +1,14 @@
+from composio_openai_agents.toolset import ComposioToolSet
+
+from composio import Action, App, Tag, Trigger, WorkspaceType, action
+
+
+__all__ = (
+    "Action",
+    "App",
+    "Tag",
+    "Trigger",
+    "WorkspaceType",
+    "action",
+    "ComposioToolSet",
+)

composio_openai_agents/toolset.py

@@ -0,0 +1,213 @@
+import json
+import types
+import typing as t
+from inspect import Signature
+from typing import List, cast
+
+import pydantic
+import pydantic.error_wrappers
+from agents import FunctionTool, Tool
+
+from composio import ActionType, AppType, TagType
+from composio.tools import ComposioToolSet as BaseComposioToolSet
+from composio.tools.toolset import ProcessorsType
+from composio.utils.pydantic import parse_pydantic_error
+from composio.utils.shared import get_signature_format_from_schema_params
+
+
+class ComposioToolSet(
+    BaseComposioToolSet,
+    runtime="openai_agents",
+    description_char_limit=1024,
+    action_name_char_limit=64,
+):
+    """
+    Composio toolset for OpenAI Agents framework.
+
+    Example:
+    ```python
+    import os
+    import asyncio
+    import dotenv
+    from agents import Agent, Runner
+
+    from composio_openai_agents import App, ComposioToolSet
+
+    # Load environment variables from .env
+    dotenv.load_dotenv()
+
+    # Initialize Composio toolset
+    composio_toolset = ComposioToolSet()
+
+    # Get all the tools
+    tools = composio_toolset.get_tools(apps=[App.GITHUB])
+
+    # Create an agent with the tools
+    agent = Agent(
+        name="GitHub Agent",
+        instructions="You are a helpful assistant that helps users with GitHub tasks.",
+        tools=tools,
+    )
+
+    # Run the agent
+    async def main():
+        result = await Runner.run(agent, "Star the repository composiohq/composio on GitHub")
+        print(result.final_output)
+
+    asyncio.run(main())
+    ```
+    """
+
+    def _wrap_action(
+        self,
+        action: str,
+        description: str,
+        schema_params: t.Dict,
+        entity_id: t.Optional[str] = None,
+    ):
+        def function(**kwargs: t.Any) -> t.Dict:
+            """Wrapper function for composio action."""
+            self.logger.debug(f"Executing action: {action} with params: {kwargs}")
+            return self.execute_action(
+                action=action,
+                params=kwargs,
+                entity_id=entity_id or self.entity_id,
+                _check_requested_actions=True,
+            )
+
+        action_func = types.FunctionType(
+            function.__code__,
+            globals=globals(),
+            name=action,
+            closure=function.__closure__,
+        )
+        # Using setattr to avoid type checking errors
+        setattr(
+            action_func,
+            "__signature__",
+            Signature(
+                parameters=get_signature_format_from_schema_params(
+                    schema_params=schema_params
+                )
+            ),
+        )
+
+        # Using setattr to avoid type checking errors
+        setattr(action_func, "__doc__", description)
+
+        return action_func
+
+    def _wrap_tool(
+        self,
+        schema: t.Dict[str, t.Any],
+        entity_id: t.Optional[str] = None,
+    ) -> FunctionTool:
+        """Wraps composio tool as OpenAI Agents FunctionTool object."""
+        action = schema["name"]
+        description = schema["description"]
+        schema_params = schema["parameters"]
+
+        # Create a function that accepts explicit JSON string for parameters
+        # This avoids the issue with **kwargs in schema validation
+        async def execute_action_wrapper(_ctx, args_json):
+            """Execute Composio action with the given arguments."""
+            try:
+                kwargs = json.loads(args_json) if args_json else {}
+
+                result = self.execute_action(
+                    action=action,
+                    params=kwargs,
+                    entity_id=entity_id or self.entity_id,
+                    _check_requested_actions=True,
+                )
+
+                # Serialize the result to JSON string
+                # The OpenAI API expects strings for tool outputs
+                if not isinstance(result, dict):
+                    result_dict = {"result": result}
+                else:
+                    result_dict = result
+
+                # Convert to JSON string
+                return json.dumps(result_dict)
+
+            except pydantic.ValidationError as e:
+                error_msg = parse_pydantic_error(e)
+                return json.dumps(
+                    {
+                        "successful": False,
+                        "error": error_msg,
+                        "data": None,
+                    }
+                )
+            except Exception as e:
+                return json.dumps(
+                    {
+                        "successful": False,
+                        "error": str(e),
+                        "data": None,
+                    }
+                )
+
+        # Ensure the schema has additionalProperties set to false
+        # This is required by OpenAI's function validation
+        modified_schema = schema_params.copy()
+        modified_schema["additionalProperties"] = False
+
+        # Create a custom FunctionTool with the appropriate schema
+        tool = FunctionTool(
+            name=action,
+            description=description,
+            params_json_schema=modified_schema,
+            on_invoke_tool=execute_action_wrapper,
+            strict_json_schema=True,
+        )
+
+        return tool
+
+    def get_tools(
+        self,
+        actions: t.Optional[t.Sequence[ActionType]] = None,
+        apps: t.Optional[t.Sequence[AppType]] = None,
+        tags: t.Optional[t.List[TagType]] = None,
+        entity_id: t.Optional[str] = None,
+        *,
+        processors: t.Optional[ProcessorsType] = None,
+        check_connected_accounts: bool = True,
+    ) -> List[Tool]:
+        """
+        Get composio tools wrapped as OpenAI Agents FunctionTool objects.
+
+        :param actions: List of actions to wrap
+        :param apps: List of apps to wrap
+        :param tags: Filter the apps by given tags
+        :param entity_id: Entity ID for the function wrapper
+        :param processors: Optional request/response processors
+        :param check_connected_accounts: Whether to check connected accounts
+
+        :return: Composio tools wrapped as `FunctionTool` objects
+        """
+        self.validate_tools(apps=apps, actions=actions, tags=tags)
+        if processors is not None:
+            self._processor_helpers.merge_processors(processors)
+
+        # Create the tools as FunctionTools
+        function_tools = [
+            self._wrap_tool(
+                schema=tool.model_dump(
+                    exclude_none=True,
+                ),
+                entity_id=entity_id or self.entity_id,
+            )
+            for tool in self.get_action_schemas(
+                actions=actions,
+                apps=apps,
+                tags=tags,
+                check_connected_accounts=check_connected_accounts,
+                _populate_requested=True,
+            )
+        ]
+
+        # Cast the list to List[Tool] to satisfy type checking
+        # Since FunctionTool is a subclass of Tool, this is type-safe
+        return cast(List[Tool], function_tools)

composio_openai_agents-0.7.7.dist-info/METADATA

@@ -0,0 +1,86 @@
+Metadata-Version: 2.2
+Name: composio_openai_agents
+Version: 0.7.7
+Summary: Use Composio to get array of strongly typed tools for OpenAI Agents
+Home-page: https://github.com/ComposioHQ/composio
+Author: Siddharth
+Author-email: tech@composio.dev
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9,<4
+Description-Content-Type: text/markdown
+Requires-Dist: composio_core<0.8.0,>=0.7.0
+Requires-Dist: openai-agents>=0.0.3
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: typing-extensions>=4.0.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Composio Integration for OpenAI Agents
+
+This package integrates the OpenAI Agents framework with Composio, allowing you to use Composio's rich set of tools with the OpenAI Agents framework.
+
+## Installation
+
+```bash
+pip install composio_openai_agents
+```
+
+## Usage
+
+```python
+import asyncio
+import dotenv
+from agents import Agent, Runner
+
+from composio_openai_agents import Action, ComposioToolSet
+
+# Load environment variables from .env
+dotenv.load_dotenv()
+
+# Initialize Composio toolset
+composio_toolset = ComposioToolSet()
+
+# Get all the tools
+tools = composio_toolset.get_tools(actions=[Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER])
+
+# Create an agent with the tools
+agent = Agent(
+    name="GitHub Agent",
+    instructions="You are a helpful assistant that helps users with GitHub tasks.",
+    tools=tools,
+)
+
+# Run the agent
+async def main():
+    result = await Runner.run(agent, "Star the repository composiohq/composio on GitHub")
+    print(result.final_output)
+
+asyncio.run(main())
+```
+
+## Features
+
+- Seamlessly integrate Composio's tools with OpenAI Agents
+- Access hundreds of pre-built API integrations
+- Maintain consistent schema formats between frameworks
+- Error handling for validation issues
+- Proper type annotations that work with mypy and pylance
+
+## Requirements
+
+- Python 3.9+
+- OpenAI Agents framework
+- Composio (with valid API key)
+
+## License
+
+Apache 2.0

composio_openai_agents-0.7.7.dist-info/RECORD

@@ -0,0 +1,6 @@
+composio_openai_agents/__init__.py,sha256=E_-3XZ6yN4oM-yHfu3rJ0gHuLnfdDujYxT2XuZAcq1U,255
+composio_openai_agents/toolset.py,sha256=MYDv0uika_e7SfZCNb4FQQiCSYjEVyw5vmoRfz-PNVs,6922
+composio_openai_agents-0.7.7.dist-info/METADATA,sha256=07gA4lBRAhOLxNXwkkpKMBHtx7asqaWCI6oO3MXvizk,2216
+composio_openai_agents-0.7.7.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+composio_openai_agents-0.7.7.dist-info/top_level.txt,sha256=_YKpUJOoiq4jzAZX0LC2SfaYhsCOcyNcoK9lbK5uWQw,23
+composio_openai_agents-0.7.7.dist-info/RECORD,,

composio_openai_agents-0.7.7.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (76.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

composio_openai_agents-0.7.7.dist-info/top_level.txt

@@ -0,0 +1 @@
+composio_openai_agents