composio-claude-agent-sdk 0.10.5__py3-none-any.whl

composio_claude_agent_sdk/__init__.py

@@ -0,0 +1,3 @@
+from composio_claude_agent_sdk.provider import ClaudeAgentSDKProvider
+
+__all__ = ("ClaudeAgentSDKProvider",)

composio_claude_agent_sdk/provider.py

@@ -0,0 +1,187 @@
+"""
+Claude Agent SDK Provider for Composio
+
+This provider enables integration with Claude Agent SDK,
+allowing Composio tools to be used as MCP tools within Claude agents.
+"""
+
+import asyncio
+import json
+import typing as t
+
+from claude_agent_sdk import (
+    McpSdkServerConfig,
+    SdkMcpTool,
+    create_sdk_mcp_server,
+    tool as sdk_tool,
+)
+
+from composio.core.provider import AgenticProvider
+from composio.core.provider.agentic import AgenticProviderExecuteFn
+from composio.types import Tool
+
+
+class ClaudeAgentSDKProvider(
+    AgenticProvider[SdkMcpTool, list[SdkMcpTool]],
+    name="claude_agent_sdk",
+):
+    """
+    Composio provider for Claude Agent SDK.
+
+    This provider wraps Composio tools as MCP tools that can be used with
+    the Claude Agent SDK's `query()` function via the `mcp_servers` option.
+
+    Example:
+        ```python
+        import asyncio
+        from composio import Composio
+        from composio_claude_agent_sdk import ClaudeAgentSDKProvider
+        from claude_agent_sdk import query, ClaudeAgentOptions
+
+        composio = Composio(provider=ClaudeAgentSDKProvider())
+
+        async def main():
+            tools = composio.tools.get(user_id="default", toolkits=["gmail"])
+            mcp_server = composio.provider.create_mcp_server(tools)
+
+            async for message in query(
+                prompt="Fetch my latest email",
+                options=ClaudeAgentOptions(
+                    mcp_servers={"composio": mcp_server},
+                    permission_mode="bypassPermissions",
+                ),
+            ):
+                print(message)
+
+        asyncio.run(main())
+        ```
+    """
+
+    def __init__(
+        self,
+        server_name: str = "composio",
+        server_version: str = "1.0.0",
+    ) -> None:
+        """
+        Initialize the Claude Agent SDK provider.
+
+        Args:
+            server_name: Name for the MCP server (default: "composio")
+            server_version: Version for the MCP server (default: "1.0.0")
+        """
+        super().__init__()
+        self.server_name = server_name
+        self.server_version = server_version
+
+    def wrap_tool(
+        self,
+        tool: Tool,
+        execute_tool: AgenticProviderExecuteFn,
+    ) -> SdkMcpTool:
+        """
+        Wrap a Composio tool as a Claude Agent SDK MCP tool.
+
+        Args:
+            tool: The Composio tool to wrap
+            execute_tool: Function to execute the tool
+
+        Returns:
+            A Claude Agent SDK MCP tool definition
+        """
+        input_schema = tool.input_parameters or {}
+
+        @sdk_tool(
+            tool.slug,
+            tool.description or f"Execute {tool.slug}",
+            input_schema,
+        )
+        async def tool_handler(args: t.Dict[str, t.Any]) -> t.Dict[str, t.Any]:
+            """Execute the Composio tool with the given arguments."""
+            try:
+                # Run the synchronous execute_tool in a thread
+                result = await asyncio.to_thread(
+                    execute_tool,
+                    tool.slug,
+                    args,
+                )
+                # Format the result for Claude Agent SDK
+                result_text = result if isinstance(result, str) else json.dumps(result)
+                return {
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": result_text,
+                        }
+                    ]
+                }
+            except Exception as e:
+                return {
+                    "content": [
+                        {
+                            "type": "text",
+                            "text": json.dumps(
+                                {
+                                    "successful": False,
+                                    "error": str(e),
+                                    "data": None,
+                                }
+                            ),
+                        }
+                    ]
+                }
+
+        return tool_handler
+
+    def wrap_tools(
+        self,
+        tools: t.Sequence[Tool],
+        execute_tool: AgenticProviderExecuteFn,
+    ) -> list[SdkMcpTool]:
+        """
+        Wrap multiple Composio tools as Claude Agent SDK MCP tools.
+
+        Args:
+            tools: Sequence of Composio tools to wrap
+            execute_tool: Function to execute the tools
+
+        Returns:
+            List of Claude Agent SDK MCP tool definitions
+        """
+        return [self.wrap_tool(tool, execute_tool) for tool in tools]
+
+    def create_mcp_server(
+        self,
+        wrapped_tools: list[SdkMcpTool],
+    ) -> McpSdkServerConfig:
+        """
+        Create an MCP server configuration for use with Claude Agent SDK.
+
+        This is the primary method for integrating Composio tools with Claude agents.
+        The returned configuration can be passed directly to the `mcp_servers` option.
+
+        Args:
+            wrapped_tools: List of wrapped Claude Agent SDK MCP tools
+                          (from composio.tools.get())
+
+        Returns:
+            MCP server configuration for Claude Agent SDK
+
+        Example:
+            ```python
+            tools = composio.tools.get(user_id="default", toolkits=["gmail"])
+            mcp_server = composio.provider.create_mcp_server(tools)
+
+            async for message in query(
+                prompt="Send an email",
+                options=ClaudeAgentOptions(
+                    mcp_servers={"composio": mcp_server},
+                ),
+            ):
+                print(message)
+            ```
+        """
+        return create_sdk_mcp_server(
+            name=self.server_name,
+            version=self.server_version,
+            tools=wrapped_tools,
+        )

composio_claude_agent_sdk-0.10.5.dist-info/METADATA

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: composio-claude-agent-sdk
+Version: 0.10.5
+Summary: Use Composio to get an array of tools with Claude Code Agents SDK.
+Home-page: https://github.com/ComposioHQ/composio
+Author: Composio
+Author-email: Composio <tech@composio.dev>
+Project-URL: Homepage, https://github.com/ComposioHQ/composio
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10,<4
+Description-Content-Type: text/markdown
+Requires-Dist: claude-agent-sdk>=0.1.0
+Requires-Dist: composio
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python
+
+# Composio Claude Code Agents Provider
+
+Use Composio tools with the Claude Code Agents SDK.
+
+## Installation
+
+### Prerequisites
+
+1. **Claude Code CLI**: The Claude Agent SDK requires Claude Code to be installed:
+
+   ```bash
+   # macOS/Linux/WSL
+   curl -fsSL https://claude.ai/install.sh | bash
+
+   # or via Homebrew
+   brew install --cask claude-code
+
+   # or via npm
+   npm install -g @anthropic-ai/claude-code
+   ```
+
+2. **Anthropic API Key**: Set your API key as an environment variable:
+   ```bash
+   export ANTHROPIC_API_KEY="your-api-key"
+   ```
+
+### Install the package
+
+```bash
+pip install composio-claude-agent-sdk
+```
+
+## Usage
+
+```python
+import asyncio
+from composio import Composio
+from composio_claude_agent_sdk import ClaudeAgentSDKProvider
+from claude_agent_sdk import query, ClaudeAgentOptions
+
+# Initialize Composio with the Claude Code Agents provider
+composio = Composio(provider=ClaudeAgentSDKProvider())
+
+async def main():
+    # Get tools from Composio
+    tools = composio.tools.get(
+        user_id="default",
+        toolkits=["gmail"],
+    )
+
+    # Create an MCP server configuration with the tools
+    mcp_server = composio.provider.create_mcp_server(tools)
+
+    # Run a Claude agent with access to Composio tools
+    async for message in query(
+        prompt="Fetch my latest email from Gmail",
+        options=ClaudeAgentOptions(
+            mcp_servers={"composio": mcp_server},
+            permission_mode="bypassPermissions",
+        ),
+    ):
+        if message.type == "assistant":
+            print(message.message)
+
+asyncio.run(main())
+```
+
+## API Reference
+
+### ClaudeCodeAgentsProvider
+
+The main provider class for integrating Composio tools with Claude Code Agents SDK.
+
+#### Constructor Options
+
+```python
+ClaudeCodeAgentsProvider(
+    server_name: str = "composio",  # Name for the MCP server
+    server_version: str = "1.0.0",  # Version for the MCP server
+)
+```
+
+#### Methods
+
+- `wrap_tool(tool, execute_tool)` - Wraps a single Composio tool as a Claude Agent SDK MCP tool
+- `wrap_tools(tools, execute_tool)` - Wraps multiple Composio tools
+- `create_mcp_server(wrapped_tools)` - Creates an MCP server configuration from wrapped tools
+
+## Environment Variables
+
+- `COMPOSIO_API_KEY` - Your Composio API key (get one at https://app.composio.dev)
+- `ANTHROPIC_API_KEY` - Your Anthropic API key (get one at https://console.anthropic.com)
+
+## Links
+
+- [Composio Documentation](https://docs.composio.dev)
+- [Claude Agent SDK Documentation](https://platform.claude.com/docs/en/agent-sdk/python)
+- [GitHub Repository](https://github.com/ComposioHQ/composio)

composio_claude_agent_sdk-0.10.5.dist-info/RECORD

@@ -0,0 +1,9 @@
+composio_claude_agent_sdk/__init__.py,sha256=5jU62AJuNHgNf4b8skPmOBqU53hs-zThc8lhUZtCQzs,109
+composio_claude_agent_sdk/provider.py,sha256=hLYnVVkfILqjVoxvThmVoNABpdjMgWJUz00dtbYbUkY,5741
+composio_claude_agent_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/test_provider.py,sha256=TJXJ9XJhuSR_8GVtKFRuUeRc6Tc6dQJjA799yx5nPPM,10694
+composio_claude_agent_sdk-0.10.5.dist-info/METADATA,sha256=tb5f4nnBQuBHef5gkghotsdJgI1aAPxIz1oUvwxQU54,3262
+composio_claude_agent_sdk-0.10.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+composio_claude_agent_sdk-0.10.5.dist-info/top_level.txt,sha256=J2UB7SfZ_56iY7K_cRyIH1pqTYttMFKrj2AfN9qih48,32
+composio_claude_agent_sdk-0.10.5.dist-info/RECORD,,

composio_claude_agent_sdk-0.10.5.dist-info/WHEEL

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

composio_claude_agent_sdk-0.10.5.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+composio_claude_agent_sdk
+tests

tests/test_provider.py

@@ -0,0 +1,313 @@
+"""
+Tests for Claude Code Agents Provider
+"""
+
+import json
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from composio_claude_agent_sdk.provider import ClaudeAgentSDKProvider
+
+
+@pytest.fixture
+def provider():
+    """Create a ClaudeAgentSDKProvider instance."""
+    return ClaudeAgentSDKProvider()
+
+
+@pytest.fixture
+def custom_provider():
+    """Create a ClaudeAgentSDKProvider with custom options."""
+    return ClaudeAgentSDKProvider(
+        server_name="custom-server",
+        server_version="2.0.0",
+    )
+
+
+@pytest.fixture
+def mock_tool():
+    """Create a mock Composio tool."""
+    return MagicMock(
+        slug="GMAIL_SEND_EMAIL",
+        name="Gmail Send Email",
+        description="Send an email via Gmail",
+        input_parameters={
+            "type": "object",
+            "properties": {
+                "to": {
+                    "type": "string",
+                    "description": "Recipient email address",
+                },
+                "subject": {
+                    "type": "string",
+                    "description": "Email subject",
+                },
+                "body": {
+                    "type": "string",
+                    "description": "Email body content",
+                },
+            },
+            "required": ["to", "subject", "body"],
+        },
+    )
+
+
+@pytest.fixture
+def mock_execute_tool():
+    """Create a mock execute_tool function."""
+    return MagicMock(
+        return_value={
+            "data": {"result": "success"},
+            "error": None,
+            "successful": True,
+        }
+    )
+
+
+class TestClaudeAgentSDKProviderInit:
+    """Tests for provider initialization."""
+
+    def test_default_options(self, provider):
+        """Test provider initializes with default options."""
+        assert provider.server_name == "composio"
+        assert provider.server_version == "1.0.0"
+
+    def test_custom_options(self, custom_provider):
+        """Test provider initializes with custom options."""
+        assert custom_provider.server_name == "custom-server"
+        assert custom_provider.server_version == "2.0.0"
+
+    def test_name_property(self, provider):
+        """Test provider has correct name."""
+        assert provider.name == "claude_agent_sdk"
+
+
+class TestJsonSchemaConversion:
+    """Tests for JSON Schema conversion."""
+
+    def test_simple_schema_passthrough(self, provider):
+        """Test that JSON Schema is passed through unchanged."""
+        schema = {
+            "type": "object",
+            "properties": {
+                "name": {"type": "string"},
+                "count": {"type": "integer"},
+            },
+        }
+        result = provider._json_schema_to_simple_schema(schema)
+        assert result == schema
+
+    def test_empty_schema(self, provider):
+        """Test handling of empty schema."""
+        result = provider._json_schema_to_simple_schema({})
+        assert result == {}
+
+
+class TestWrapTool:
+    """Tests for wrap_tool method."""
+
+    def test_wrap_tool_returns_sdk_mcp_tool(
+        self, provider, mock_tool, mock_execute_tool
+    ):
+        """Test that wrap_tool returns an SdkMcpTool."""
+        with patch("composio_claude_agent_sdk.provider.sdk_tool") as mock_sdk_tool:
+            mock_sdk_tool.return_value = lambda fn: fn
+            provider.wrap_tool(mock_tool, mock_execute_tool)
+
+            # Verify sdk_tool was called with correct arguments
+            mock_sdk_tool.assert_called_once_with(
+                mock_tool.slug,
+                mock_tool.description,
+                mock_tool.input_parameters,
+            )
+
+    def test_wrap_tool_without_description(self, provider, mock_execute_tool):
+        """Test wrapping a tool without description."""
+        tool_without_desc = MagicMock(
+            slug="TEST_TOOL",
+            description=None,
+            input_parameters={"type": "object", "properties": {}},
+        )
+
+        with patch("composio_claude_agent_sdk.provider.sdk_tool") as mock_sdk_tool:
+            mock_sdk_tool.return_value = lambda fn: fn
+            provider.wrap_tool(tool_without_desc, mock_execute_tool)
+
+            # Should use default description
+            mock_sdk_tool.assert_called_once()
+            call_args = mock_sdk_tool.call_args[0]
+            assert call_args[1] == "Execute TEST_TOOL"
+
+    def test_wrap_tool_without_input_parameters(self, provider, mock_execute_tool):
+        """Test wrapping a tool without input parameters."""
+        tool_without_params = MagicMock(
+            slug="TEST_TOOL",
+            description="Test tool",
+            input_parameters=None,
+        )
+
+        with patch("composio_claude_agent_sdk.provider.sdk_tool") as mock_sdk_tool:
+            mock_sdk_tool.return_value = lambda fn: fn
+            provider.wrap_tool(tool_without_params, mock_execute_tool)
+
+            # Should use empty schema
+            mock_sdk_tool.assert_called_once()
+            call_args = mock_sdk_tool.call_args[0]
+            assert call_args[2] == {}
+
+
+class TestWrapTools:
+    """Tests for wrap_tools method."""
+
+    def test_wrap_multiple_tools(self, provider, mock_tool, mock_execute_tool):
+        """Test wrapping multiple tools."""
+        another_tool = MagicMock(
+            slug="SLACK_POST_MESSAGE",
+            description="Post a message to Slack",
+            input_parameters={"type": "object", "properties": {}},
+        )
+        tools = [mock_tool, another_tool]
+
+        with patch("composio_claude_agent_sdk.provider.sdk_tool") as mock_sdk_tool:
+            mock_sdk_tool.return_value = lambda fn: fn
+            wrapped = provider.wrap_tools(tools, mock_execute_tool)
+
+            assert len(wrapped) == 2
+            assert mock_sdk_tool.call_count == 2
+
+    def test_wrap_empty_tools_list(self, provider, mock_execute_tool):
+        """Test wrapping an empty tools list."""
+        wrapped = provider.wrap_tools([], mock_execute_tool)
+        assert wrapped == []
+
+
+class TestCreateMcpServer:
+    """Tests for create_mcp_server method."""
+
+    def test_create_mcp_server_with_default_options(self, provider):
+        """Test creating MCP server with default options."""
+        mock_tools = [MagicMock(), MagicMock()]
+
+        with patch(
+            "composio_claude_agent_sdk.provider.create_sdk_mcp_server"
+        ) as mock_create:
+            mock_create.return_value = {"type": "sdk", "name": "composio"}
+            provider.create_mcp_server(mock_tools)
+
+            mock_create.assert_called_once_with(
+                name="composio",
+                version="1.0.0",
+                tools=mock_tools,
+            )
+
+    def test_create_mcp_server_with_custom_options(self, custom_provider):
+        """Test creating MCP server with custom options."""
+        mock_tools = [MagicMock()]
+
+        with patch(
+            "composio_claude_agent_sdk.provider.create_sdk_mcp_server"
+        ) as mock_create:
+            mock_create.return_value = {"type": "sdk", "name": "custom-server"}
+            custom_provider.create_mcp_server(mock_tools)
+
+            mock_create.assert_called_once_with(
+                name="custom-server",
+                version="2.0.0",
+                tools=mock_tools,
+            )
+
+    def test_create_mcp_server_with_empty_tools(self, provider):
+        """Test creating MCP server with empty tools list."""
+        with patch(
+            "composio_claude_agent_sdk.provider.create_sdk_mcp_server"
+        ) as mock_create:
+            mock_create.return_value = {"type": "sdk", "name": "composio"}
+            provider.create_mcp_server([])
+
+            mock_create.assert_called_once_with(
+                name="composio",
+                version="1.0.0",
+                tools=[],
+            )
+
+
+class TestToolHandlerExecution:
+    """Tests for tool handler execution."""
+
+    @pytest.mark.asyncio
+    async def test_tool_handler_success(self, provider, mock_tool):
+        """Test successful tool execution."""
+        mock_execute = MagicMock(return_value={"data": "success", "successful": True})
+
+        # Create a real wrapped tool to test the handler
+        with patch("composio_claude_agent_sdk.provider.sdk_tool") as mock_sdk_tool:
+            # Capture the decorated function
+            captured_handler = None
+
+            def capture_decorator(name, desc, schema):
+                def decorator(fn):
+                    nonlocal captured_handler
+                    captured_handler = fn
+                    return fn
+
+                return decorator
+
+            mock_sdk_tool.side_effect = capture_decorator
+            provider.wrap_tool(mock_tool, mock_execute)
+
+            # Execute the captured handler
+            result = await captured_handler({"to": "test@example.com"})
+
+            assert result["content"][0]["type"] == "text"
+            assert "success" in result["content"][0]["text"]
+
+    @pytest.mark.asyncio
+    async def test_tool_handler_error(self, provider, mock_tool):
+        """Test tool execution with error."""
+        mock_execute = MagicMock(side_effect=Exception("Test error"))
+
+        with patch("composio_claude_agent_sdk.provider.sdk_tool") as mock_sdk_tool:
+            captured_handler = None
+
+            def capture_decorator(name, desc, schema):
+                def decorator(fn):
+                    nonlocal captured_handler
+                    captured_handler = fn
+                    return fn
+
+                return decorator
+
+            mock_sdk_tool.side_effect = capture_decorator
+            provider.wrap_tool(mock_tool, mock_execute)
+
+            result = await captured_handler({"to": "test@example.com"})
+
+            assert result["content"][0]["type"] == "text"
+            response = json.loads(result["content"][0]["text"])
+            assert response["successful"] is False
+            assert "Test error" in response["error"]
+
+    @pytest.mark.asyncio
+    async def test_tool_handler_string_result(self, provider, mock_tool):
+        """Test tool execution returning string result."""
+        mock_execute = MagicMock(return_value="Simple string result")
+
+        with patch("composio_claude_agent_sdk.provider.sdk_tool") as mock_sdk_tool:
+            captured_handler = None
+
+            def capture_decorator(name, desc, schema):
+                def decorator(fn):
+                    nonlocal captured_handler
+                    captured_handler = fn
+                    return fn
+
+                return decorator
+
+            mock_sdk_tool.side_effect = capture_decorator
+            provider.wrap_tool(mock_tool, mock_execute)
+
+            result = await captured_handler({})
+
+            assert result["content"][0]["type"] == "text"
+            assert result["content"][0]["text"] == "Simple string result"