composio-openai-agents 0.7.17__py3-none-any.whl → 1.0.0rc1__py3-none-any.whl

composio_openai_agents/__init__.py

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

composio_openai_agents/provider.py

@@ -0,0 +1,141 @@
+import json
+import asyncio
+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.core.provider.agentic import AgenticProviderExecuteFn
+from composio.types import Tool
+from composio.core.provider import AgenticProvider
+from composio.utils.pydantic import parse_pydantic_error
+
+
+# Recursively remove 'examples' keys from the schema properties
+def _remove_examples_from_schema(schema_obj: t.Dict[str, t.Any]) -> None:
+    """
+    Remove 'examples', 'pattern', and 'default' keys from all properties in the
+    schema, including nested ones. Also ensure that any 'items' object has a 'type' key.
+    """
+    # Handle properties directly
+    if "properties" in schema_obj and isinstance(
+        schema_obj["properties"], dict
+    ):
+        for _, prop_value in schema_obj["properties"].items():
+            if isinstance(prop_value, dict):
+                # Remove examples, pattern, and default from this property
+                if "examples" in prop_value:
+                    del prop_value["examples"]
+                if "pattern" in prop_value:
+                    del prop_value["pattern"]
+                if "default" in prop_value:
+                    del prop_value["default"]
+
+                # Ensure 'items' has a 'type' key
+                if "items" in prop_value and isinstance(
+                    prop_value["items"], dict
+                ):
+                    if "type" not in prop_value["items"]:
+                        # Default to string type for items if not specified
+                        prop_value["items"]["type"] = "string"
+
+                # Recursively process nested properties
+                _remove_examples_from_schema(prop_value)
+
+    # Handle array items
+    if "items" in schema_obj and isinstance(schema_obj["items"], dict):
+        if "examples" in schema_obj["items"]:
+            del schema_obj["items"]["examples"]
+        if "pattern" in schema_obj["items"]:
+            del schema_obj["items"]["pattern"]
+        if "default" in schema_obj["items"]:
+            del schema_obj["items"]["default"]
+        # Ensure items has a type
+        if "type" not in schema_obj["items"]:
+            schema_obj["items"]["type"] = "string"
+        _remove_examples_from_schema(schema_obj["items"])
+
+    # Handle any other nested object properties
+    for _, value in schema_obj.items():
+        if isinstance(value, dict):
+            _remove_examples_from_schema(value)
+        elif isinstance(value, list):
+            for item in value:
+                if isinstance(item, dict):
+                    _remove_examples_from_schema(item)
+
+class OpenAIAgentsProvider(
+    AgenticProvider[FunctionTool, list[FunctionTool]],
+    name="openai_agents",
+):
+    """
+    Composio toolset for OpenAI Agents framework.
+    """
+
+    def wrap_tool(
+        self,
+        tool: Tool,
+        execute_tool: AgenticProviderExecuteFn,
+    ) -> FunctionTool:
+        """Wrap a tool as a FunctionTool."""
+        # Create a function that accepts explicit JSON string for parameters
+        # This avoids the issue with **kwargs in schema validation
+        async def execute_tool_wrapper(_ctx, payload):
+            """Execute Composio action with the given arguments."""
+            try:
+                return json.dumps(
+                    obj=(
+                        await asyncio.to_thread(  # Running a thread since `execute_tool` is not async
+                            execute_tool,
+                            slug=tool.slug,
+                            arguments=json.loads(payload) if payload else {},
+                        )
+                    )
+                )
+            except pydantic.ValidationError as e:
+                return json.dumps(
+                    {
+                        "successful": False,
+                        "error": parse_pydantic_error(e),
+                        "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 = tool.input_parameters.copy()
+        modified_schema["additionalProperties"] = False
+
+        # Apply the example removal function. This is done to optimize the
+        # schema as much as possible for Responses API
+        _remove_examples_from_schema(modified_schema)
+
+        # Create a custom FunctionTool with the appropriate schema
+        return FunctionTool(
+            name=tool.slug,
+            description=tool.description,
+            params_json_schema=modified_schema,
+            on_invoke_tool=execute_tool_wrapper,
+            # To avoid schema errors due to required flags. Composio tools
+            # already process to have optimal schemas.
+            strict_json_schema=False,
+        )
+
+    def wrap_tools(
+        self,
+        tools: t.Sequence[Tool],
+        execute_tool: AgenticProviderExecuteFn,
+    ) -> list[FunctionTool]:
+        """Wrap a list of tools as a list of FunctionTools."""
+        return [self.wrap_tool(tool, execute_tool) for tool in tools]

{composio_openai_agents-0.7.17.dist-info → composio_openai_agents-1.0.0rc1.dist-info}/METADATA

@@ -1,19 +1,16 @@
 Metadata-Version: 2.4
 Name: composio_openai_agents
-Version: 0.7.17
+Version: 1.0.0rc1
 Summary: Use Composio to get array of strongly typed tools for OpenAI Agents
 Home-page: https://github.com/ComposioHQ/composio
-Author: Siddharth
+Author: Composio
 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

composio_openai_agents-1.0.0rc1.dist-info/RECORD

@@ -0,0 +1,6 @@
+composio_openai_agents/__init__.py,sha256=9AhhdbI4L3skTl1i9t8_enhpmh2OYitDnfAxP0R9il4,110
+composio_openai_agents/provider.py,sha256=ylijMtq-Q5iK4_7FVNUZ0yteqTr-X7VC0nJGi3XguSc,5412
+composio_openai_agents-1.0.0rc1.dist-info/METADATA,sha256=dgVtCwRuePx8qBP6Vzl6OyCSwsgFrUrmcloOHbsK6_o,2104
+composio_openai_agents-1.0.0rc1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+composio_openai_agents-1.0.0rc1.dist-info/top_level.txt,sha256=_YKpUJOoiq4jzAZX0LC2SfaYhsCOcyNcoK9lbK5uWQw,23
+composio_openai_agents-1.0.0rc1.dist-info/RECORD,,

composio_openai_agents/toolset.py

@@ -1,267 +0,0 @@
-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
-
-        # Recursively remove 'examples' keys from the schema properties
-        def remove_examples_from_schema(schema_obj: t.Dict[str, t.Any]) -> None:
-            """Remove 'examples', 'pattern', and 'default' keys from all properties in the schema, including nested ones.
-            Also ensure that any 'items' object has a 'type' key."""
-            # Handle properties directly
-            if "properties" in schema_obj and isinstance(
-                schema_obj["properties"], dict
-            ):
-                for _, prop_value in schema_obj["properties"].items():
-                    if isinstance(prop_value, dict):
-                        # Remove examples, pattern, and default from this property
-                        if "examples" in prop_value:
-                            del prop_value["examples"]
-                        if "pattern" in prop_value:
-                            del prop_value["pattern"]
-                        if "default" in prop_value:
-                            del prop_value["default"]
-
-                        # Ensure 'items' has a 'type' key
-                        if "items" in prop_value and isinstance(
-                            prop_value["items"], dict
-                        ):
-                            if "type" not in prop_value["items"]:
-                                # Default to string type for items if not specified
-                                prop_value["items"]["type"] = "string"
-
-                        # Recursively process nested properties
-                        remove_examples_from_schema(prop_value)
-
-            # Handle array items
-            if "items" in schema_obj and isinstance(schema_obj["items"], dict):
-                if "examples" in schema_obj["items"]:
-                    del schema_obj["items"]["examples"]
-                if "pattern" in schema_obj["items"]:
-                    del schema_obj["items"]["pattern"]
-                if "default" in schema_obj["items"]:
-                    del schema_obj["items"]["default"]
-                # Ensure items has a type
-                if "type" not in schema_obj["items"]:
-                    schema_obj["items"]["type"] = "string"
-                remove_examples_from_schema(schema_obj["items"])
-
-            # Handle any other nested object properties
-            for _, value in schema_obj.items():
-                if isinstance(value, dict):
-                    remove_examples_from_schema(value)
-                elif isinstance(value, list):
-                    for item in value:
-                        if isinstance(item, dict):
-                            remove_examples_from_schema(item)
-
-        # Apply the example removal function. This is done to optimize the schema as much as possible for Responses API
-        remove_examples_from_schema(modified_schema)
-
-        # 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=False,  # To avoid schema errors due to required flags. Composio tools already process to have optimal schemas.
-        )
-
-        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.17.dist-info/RECORD

@@ -1,6 +0,0 @@
-composio_openai_agents/__init__.py,sha256=E_-3XZ6yN4oM-yHfu3rJ0gHuLnfdDujYxT2XuZAcq1U,255
-composio_openai_agents/toolset.py,sha256=Jz9f1JvHO0dFT26HqPpqfeRr6Q9GG7rNj8UUNzUgVxg,9852
-composio_openai_agents-0.7.17.dist-info/METADATA,sha256=5KfPseCMRdIjQEHVbOHJwiPugUmbmpwiV_Q1Z2KNRvM,2217
-composio_openai_agents-0.7.17.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-composio_openai_agents-0.7.17.dist-info/top_level.txt,sha256=_YKpUJOoiq4jzAZX0LC2SfaYhsCOcyNcoK9lbK5uWQw,23
-composio_openai_agents-0.7.17.dist-info/RECORD,,