composio-smol 0.7.1__py3-none-any.whl

composio_smol/__init__.py

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

composio_smol/toolset.py

@@ -0,0 +1,171 @@
+import types
+import typing as t
+from inspect import Signature
+from typing import Callable, Dict
+
+import pydantic
+import pydantic.error_wrappers
+from smolagents.tools import 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 StructuredTool(Tool):
+    def __init__(
+        self,
+        name: str,
+        description: str,
+        params: Dict[str, Dict[str, str | type | bool]],
+        output_type: str,
+        function: Callable,
+    ):
+        self.name = name
+        self.description = description
+        self.inputs = params
+        self.output_type = output_type
+        self.forward = function
+        self.is_initialized = True
+
+    def run(self, *args, **kwargs):
+        try:
+            return self.forward(*args, **kwargs)
+        except pydantic.ValidationError as e:
+            return {"successful": False, "error": parse_pydantic_error(e), "data": None}
+
+
+class ComposioToolSet(
+    BaseComposioToolSet,
+    runtime="smol",
+    description_char_limit=1024,
+    action_name_char_limit=64,
+):
+    """
+    Composio toolset for Smolagents framework.
+
+    Example:
+    ```python
+    from dotenv import load_dotenv
+    from composio import Action
+    from composio_smol import ComposioToolSet
+    from smolagents import HfApiModel, CodeAgent
+
+    load_dotenv()
+    # Initialize toolset
+    composio_toolset = ComposioToolSet()
+
+    tools = composio_toolset.get_tools(
+        actions=[Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER],
+    )
+    # Create agent with Composio tools
+    agent = CodeAgent(
+        tools=list(tools),
+        model=HfApiModel()
+    )
+
+    agent.run("Star the composiohq/composio repo")
+
+    ```
+    """
+
+    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__,
+        )
+        action_func.__signature__ = Signature(  # type: ignore
+            parameters=get_signature_format_from_schema_params(
+                schema_params=schema_params
+            )
+        )
+
+        action_func.__doc__ = description
+
+        return action_func
+
+    def _wrap_tool(
+        self,
+        schema: t.Dict[str, t.Any],
+        entity_id: t.Optional[str] = None,
+    ) -> StructuredTool:
+        """Wraps composio tool as StructuredTool object."""
+        action = schema["name"]
+        description = schema["description"]
+        schema_params = schema["parameters"]
+        action_func = self._wrap_action(
+            action=action,
+            description=description,
+            schema_params=schema_params,
+            entity_id=entity_id,
+        )
+        # Flatten and format the parameters structure
+        params = schema_params["properties"]
+        tool = StructuredTool(
+            name=action,
+            description=description,
+            params=params,
+            output_type="object",
+            function=action_func,
+        )
+        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,
+    ) -> t.Sequence[StructuredTool]:
+        """
+        Get composio tools wrapped as StructuredTool 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 processors to apply to the tools
+        :param check_connected_accounts: Whether to check for connected accounts
+        :return: Composio tools wrapped as `StructuredTool` objects
+        """
+        self.validate_tools(apps=apps, actions=actions, tags=tags)
+        if processors is not None:
+            self._processor_helpers.merge_processors(processors)
+        return [
+            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,
+            )
+        ]

composio_smol-0.7.1.dist-info/METADATA

@@ -0,0 +1,125 @@
+Metadata-Version: 2.2
+Name: composio_smol
+Version: 0.7.1
+Summary: Use Composio to get array of strongly typed tools for Smol Agents
+Home-page: https://github.com/ComposioHQ/composio
+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: smolagents
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+## 🚀🔗 Leveraging Smol Agents with Composio
+
+Integrate Smol Agents with Composio to enable direct interaction with external applications, enhancing their capabilities through strongly-typed, validated tools.
+
+### Objective
+
+- **Automate GitHub operations** using type-safe instructions via Smol Agent's Tool system.
+- Demonstrate how to use Composio's tools with Smol Agent's CodeAgent.
+
+### Installation and Setup
+
+Install the necessary packages and connect your GitHub account to enable agent interactions with GitHub:
+
+```bash
+# Install Composio Smol Agents package
+pip install composio-smol
+
+# Connect your GitHub account
+composio add github
+
+# View available applications you can connect with
+composio apps
+```
+
+### Usage Steps
+
+#### 1. Import Required Packages
+
+Set up your environment by importing the necessary components from Composio & Smol Agents:
+
+```python
+from dotenv import load_dotenv
+import os
+
+from composio import Action
+from composio_smol import ComposioToolSet
+from smolagents import HfApiModel, CodeAgent
+```
+
+#### 2. Initialize Tools with Composio
+
+Configure and fetch GitHub tools provided by Composio:
+
+```python
+# Initialize toolset
+composio_toolset = ComposioToolSet()
+
+# Get GitHub tools with retry configuration
+tools = composio_toolset.get_tools(
+    actions=[Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER],
+)
+```
+
+#### 3. Set Up the Smol Agent
+
+Create and configure a Smol agent with the Composio tools:
+
+```python
+# Create an agent with the tools
+agent = CodeAgent(
+    tools=tools,
+    model=HfApiModel()
+)
+```
+
+#### 4. Execute Tasks
+
+Run your agent with specific tasks:
+
+```python
+# Define task
+agent.run("Star the composiohq/composio repo")
+```
+
+### Advanced Usage
+
+The integration supports more complex scenarios:
+
+```python
+# Using multiple tools
+tools = composio_toolset.get_tools(
+    actions=[
+        Action.GITHUB_STAR_A_REPOSITORY_FOR_THE_AUTHENTICATED_USER,
+        Action.GITHUB_CREATE_REPOSITORY
+    ],
+)
+
+# Using app-specific tools
+tools = composio_toolset.get_tools(
+    apps=[App.GITHUB],
+)
+```
+
+### Best Practices
+
+1. Always use proper type hints in your code
+2. Handle validation errors appropriately
+3. Use the latest version of both Smol Agent and Composio
+4. Leverage async operations for better performance
+5. Keep your API keys secure using environment variables
+6. Configure retries based on the specific needs of each tool

composio_smol-0.7.1.dist-info/RECORD

@@ -0,0 +1,6 @@
+composio_smol/__init__.py,sha256=vhykKuh6fZ6F21wGUvm3A6NTaeCnPwOMBwq4u5opBKE,246
+composio_smol/toolset.py,sha256=Q5aBVlLX9A4euB9RRuWt4lpvDbNdPlsOTFxFevBx890,5309
+composio_smol-0.7.1.dist-info/METADATA,sha256=rt7QClLbYeZV6Sq9mcbPt4w9RUFIynnhIoO1Xckf7XI,3121
+composio_smol-0.7.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+composio_smol-0.7.1.dist-info/top_level.txt,sha256=QWxT62bXOYLbM34nE31Y8_cdXufUB-ZFgcjnxMd5tLc,14
+composio_smol-0.7.1.dist-info/RECORD,,

composio_smol-0.7.1.dist-info/WHEEL

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

composio_smol-0.7.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+composio_smol