maton-agent-toolkit 0.1.0__tar.gz

maton_agent_toolkit-0.1.0/LICENSE

@@ -0,0 +1,23 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Maton
+
+Copyright (c) 2025 Stripe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

maton_agent_toolkit-0.1.0/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: maton-agent-toolkit
+Version: 0.1.0
+Summary: Maton Agent Toolkit
+Author-email: Maton <support@maton.ai>
+License: The MIT License (MIT)
+        
+        Copyright (c) 2026 Maton
+        
+        Copyright (c) 2025 Stripe
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Bug Tracker, https://github.com/maton-ai/maton-agent-toolkit/issues
+Project-URL: Source Code, https://github.com/maton-ai/maton-agent-toolkit
+Project-URL: Documentation, https://maton.ai
+Keywords: maton,api,automation,mcp,agents
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: mcp>=1.0.0
+Provides-Extra: openai
+Requires-Dist: openai>=1.0.0; extra == "openai"
+Requires-Dist: agents>=0.0.84; extra == "openai"
+Provides-Extra: langchain
+Requires-Dist: langchain>=0.1.0; extra == "langchain"
+Provides-Extra: crewai
+Requires-Dist: crewai>=0.1.0; extra == "crewai"
+Provides-Extra: strands
+Requires-Dist: strands-agents>=1.0.0; extra == "strands"
+Provides-Extra: all
+Requires-Dist: maton-agent-toolkit[openai]; extra == "all"
+Requires-Dist: maton-agent-toolkit[langchain]; extra == "all"
+Requires-Dist: maton-agent-toolkit[crewai]; extra == "all"
+Requires-Dist: maton-agent-toolkit[strands]; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: pyright>=1.1.0; extra == "dev"
+Dynamic: license-file
+
+# Maton Agent Toolkit - Python
+
+The Maton Agent Toolkit connects popular agent frameworks — OpenAI's Agents SDK, LangChain, CrewAI, and Strands — to the [Maton MCP server](https://mcp.maton.ai) through function calling. Instead of bundling a fixed set of actions, the toolkit connects to the remote Maton MCP server, discovers the available tools, and exposes them in each framework's native tool format. This lets your agent connect and automate 150+ apps (Google Workspace, Microsoft 365, GitHub, Notion, Slack, HubSpot, and more).
+
+## Installation
+
+You don't need this source code unless you want to modify the package. If you just want to use the package, just run:
+
+```sh
+uv pip install maton-agent-toolkit
+```
+
+### Requirements
+
+-   Python 3.11+
+
+## Usage
+
+The library needs to be configured with your Maton API key. You can create one at [maton.ai](https://maton.ai), or set the `MATON_API_KEY` environment variable. The toolkit connects to `https://mcp.maton.ai` with your key in the `Authorization: Bearer` header.
+
+```python
+from maton_agent_toolkit.openai.toolkit import create_maton_agent_toolkit
+
+async def main():
+    toolkit = await create_maton_agent_toolkit(api_key="YOUR_MATON_API_KEY")
+    tools = toolkit.get_tools()
+    # ... use tools ...
+    await toolkit.close()  # Clean up when done
+```
+
+The toolkit works with OpenAI's Agents SDK, LangChain, CrewAI, and Strands and can be passed as a list of tools. For example:
+
+```python
+from agents import Agent
+
+async def main():
+    toolkit = await create_maton_agent_toolkit(api_key="YOUR_MATON_API_KEY")
+
+    maton_agent = Agent(
+        name="Maton Agent",
+        instructions="You are an expert at automating apps with Maton",
+        tools=toolkit.get_tools()
+    )
+    # ... use agent ...
+    await toolkit.close()
+```
+
+Import from the framework-specific module you need:
+
+- `maton_agent_toolkit.openai.toolkit`
+- `maton_agent_toolkit.langchain.toolkit`
+- `maton_agent_toolkit.crewai.toolkit`
+- `maton_agent_toolkit.strands.toolkit`
+
+### Context
+
+You can provide a default `connection` that all requests route through (sent as the `Maton-Connection` header). If omitted, Maton uses the newest active connection for the target app.
+
+```python
+toolkit = await create_maton_agent_toolkit(
+    api_key="YOUR_MATON_API_KEY",
+    configuration={
+        "context": {
+            "connection": "conn_123"
+        }
+    }
+)
+```
+
+## Development
+
+```
+uv venv --python 3.11
+source .venv/bin/activate
+uv pip install -r requirements.txt
+```

maton_agent_toolkit-0.1.0/README.md

@@ -0,0 +1,76 @@
+# Maton Agent Toolkit - Python
+
+The Maton Agent Toolkit connects popular agent frameworks — OpenAI's Agents SDK, LangChain, CrewAI, and Strands — to the [Maton MCP server](https://mcp.maton.ai) through function calling. Instead of bundling a fixed set of actions, the toolkit connects to the remote Maton MCP server, discovers the available tools, and exposes them in each framework's native tool format. This lets your agent connect and automate 150+ apps (Google Workspace, Microsoft 365, GitHub, Notion, Slack, HubSpot, and more).
+
+## Installation
+
+You don't need this source code unless you want to modify the package. If you just want to use the package, just run:
+
+```sh
+uv pip install maton-agent-toolkit
+```
+
+### Requirements
+
+-   Python 3.11+
+
+## Usage
+
+The library needs to be configured with your Maton API key. You can create one at [maton.ai](https://maton.ai), or set the `MATON_API_KEY` environment variable. The toolkit connects to `https://mcp.maton.ai` with your key in the `Authorization: Bearer` header.
+
+```python
+from maton_agent_toolkit.openai.toolkit import create_maton_agent_toolkit
+
+async def main():
+    toolkit = await create_maton_agent_toolkit(api_key="YOUR_MATON_API_KEY")
+    tools = toolkit.get_tools()
+    # ... use tools ...
+    await toolkit.close()  # Clean up when done
+```
+
+The toolkit works with OpenAI's Agents SDK, LangChain, CrewAI, and Strands and can be passed as a list of tools. For example:
+
+```python
+from agents import Agent
+
+async def main():
+    toolkit = await create_maton_agent_toolkit(api_key="YOUR_MATON_API_KEY")
+
+    maton_agent = Agent(
+        name="Maton Agent",
+        instructions="You are an expert at automating apps with Maton",
+        tools=toolkit.get_tools()
+    )
+    # ... use agent ...
+    await toolkit.close()
+```
+
+Import from the framework-specific module you need:
+
+- `maton_agent_toolkit.openai.toolkit`
+- `maton_agent_toolkit.langchain.toolkit`
+- `maton_agent_toolkit.crewai.toolkit`
+- `maton_agent_toolkit.strands.toolkit`
+
+### Context
+
+You can provide a default `connection` that all requests route through (sent as the `Maton-Connection` header). If omitted, Maton uses the newest active connection for the target app.
+
+```python
+toolkit = await create_maton_agent_toolkit(
+    api_key="YOUR_MATON_API_KEY",
+    configuration={
+        "context": {
+            "connection": "conn_123"
+        }
+    }
+)
+```
+
+## Development
+
+```
+uv venv --python 3.11
+source .venv/bin/activate
+uv pip install -r requirements.txt
+```

maton_agent_toolkit-0.1.0/maton_agent_toolkit/__init__.py

@@ -0,0 +1,7 @@
+"""Maton Agent Toolkit - MCP-based toolkit for AI agent frameworks."""
+
+from .configuration import Configuration, Context
+from .shared.constants import VERSION
+
+__all__ = ["Configuration", "Context", "VERSION"]
+__version__ = VERSION

maton_agent_toolkit-0.1.0/maton_agent_toolkit/configuration.py

@@ -0,0 +1,14 @@
+"""Configuration types for Maton Agent Toolkit."""
+
+from typing_extensions import TypedDict
+
+
+class Context(TypedDict, total=False):
+    """Context for MCP connection."""
+    connection: str | None
+    mode: str | None
+
+
+class Configuration(TypedDict, total=False):
+    """Configuration for Maton Agent Toolkit."""
+    context: Context | None

maton_agent_toolkit-0.1.0/maton_agent_toolkit/crewai/__init__.py

@@ -0,0 +1,5 @@
+"""Maton Agent Toolkit for CrewAI."""
+
+from .toolkit import MatonAgentToolkit, create_maton_agent_toolkit
+
+__all__ = ["MatonAgentToolkit", "create_maton_agent_toolkit"]

maton_agent_toolkit-0.1.0/maton_agent_toolkit/crewai/toolkit.py

@@ -0,0 +1,134 @@
+"""Maton Agent Toolkit for CrewAI."""
+
+import asyncio
+from typing import List, Any, Type, Callable, Awaitable
+
+from pydantic import BaseModel
+from crewai.tools import BaseTool
+
+from ..shared.toolkit_core import ToolkitCore
+from ..shared.mcp_client import McpTool
+from ..shared.schema_utils import json_schema_to_pydantic_model
+from ..configuration import Configuration
+
+
+class MatonTool(BaseTool):
+    """Tool for interacting with Maton via MCP."""
+
+    run_tool: Callable[..., Awaitable[str]]
+    method: str
+    name: str = ""
+    description: str = ""
+    args_schema: Type[BaseModel] | None = None
+
+    def _run(self, **kwargs: Any) -> str:
+        """Synchronous execution - wraps async call."""
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+            # If we're already in an async context, create a new loop
+            import concurrent.futures
+            with concurrent.futures.ThreadPoolExecutor() as pool:
+                future = pool.submit(
+                    asyncio.run,
+                    self.run_tool(self.method, kwargs)
+                )
+                return future.result()
+        else:
+            return loop.run_until_complete(
+                self.run_tool(self.method, kwargs)
+            )
+
+    async def _arun(self, **kwargs: Any) -> str:
+        """Async execution via MCP."""
+        return await self.run_tool(self.method, kwargs)
+
+
+class MatonAgentToolkit(ToolkitCore[List[MatonTool]]):
+    """
+    Maton Agent Toolkit for CrewAI.
+
+    Example:
+        toolkit = await create_maton_agent_toolkit(
+            api_key='YOUR_MATON_API_KEY',
+        )
+        tools = toolkit.get_tools()
+        agent = Agent(role="...", tools=tools)
+        await toolkit.close()
+    """
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        configuration: Configuration | None = None
+    ):
+        super().__init__(api_key, configuration)
+
+    def _empty_tools(self) -> List[MatonTool]:
+        """Return empty list of tools."""
+        return []
+
+    def _convert_tools(
+        self,
+        mcp_tools: List[McpTool]
+    ) -> List[MatonTool]:
+        """Convert MCP tools to CrewAI MatonTool instances."""
+        tools = []
+        for mcp_tool in mcp_tools:
+            # Convert JSON Schema to Pydantic model
+            args_schema = json_schema_to_pydantic_model(
+                mcp_tool.get("inputSchema"),
+                model_name=f"{mcp_tool['name']}_args"
+            )
+
+            tools.append(MatonTool(
+                run_tool=self.run_tool,
+                method=mcp_tool["name"],
+                name=mcp_tool["name"],
+                description=mcp_tool.get("description", mcp_tool["name"]),
+                args_schema=args_schema,
+            ))
+        return tools
+
+    @property
+    def tools(self) -> List[MatonTool]:
+        """
+        The tools available in the toolkit.
+
+        .. deprecated::
+            Access tools via get_tools() after calling initialize().
+        """
+        return self._get_tools_with_warning()
+
+
+async def create_maton_agent_toolkit(
+    api_key: str | None = None,
+    configuration: Configuration | None = None
+) -> MatonAgentToolkit:
+    """
+    Factory function to create and initialize a MatonAgentToolkit.
+
+    This is the recommended way to create a toolkit as it handles
+    async initialization automatically.
+
+    Example:
+        toolkit = await create_maton_agent_toolkit(
+            api_key='YOUR_MATON_API_KEY',
+        )
+        tools = toolkit.get_tools()
+
+        # Use with CrewAI agent
+        agent = Agent(role="Maton Agent", tools=tools)
+
+        # Clean up when done
+        await toolkit.close()
+
+    Args:
+        api_key: Maton API key. Create one at https://maton.ai
+        configuration: Optional configuration for context
+
+    Returns:
+        Initialized MatonAgentToolkit ready to use
+    """
+    toolkit = MatonAgentToolkit(api_key, configuration)
+    await toolkit.initialize()
+    return toolkit

maton_agent_toolkit-0.1.0/maton_agent_toolkit/langchain/__init__.py

@@ -0,0 +1,5 @@
+"""Maton Agent Toolkit for LangChain."""
+
+from .toolkit import MatonAgentToolkit, create_maton_agent_toolkit
+
+__all__ = ["MatonAgentToolkit", "create_maton_agent_toolkit"]

maton_agent_toolkit-0.1.0/maton_agent_toolkit/langchain/toolkit.py

@@ -0,0 +1,134 @@
+"""Maton Agent Toolkit for LangChain."""
+
+import asyncio
+from typing import List, Any, Type, Callable, Awaitable
+
+from pydantic import BaseModel
+from langchain_core.tools import BaseTool
+
+from ..shared.toolkit_core import ToolkitCore
+from ..shared.mcp_client import McpTool
+from ..shared.schema_utils import json_schema_to_pydantic_model
+from ..configuration import Configuration
+
+
+class MatonTool(BaseTool):
+    """Tool for interacting with Maton via MCP."""
+
+    run_tool: Callable[..., Awaitable[str]]
+    method: str
+    name: str = ""
+    description: str = ""
+    args_schema: Type[BaseModel] | None = None
+
+    def _run(self, **kwargs: Any) -> str:
+        """Synchronous execution - wraps async call."""
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+            # If we're already in an async context, create a new loop
+            import concurrent.futures
+            with concurrent.futures.ThreadPoolExecutor() as pool:
+                future = pool.submit(
+                    asyncio.run,
+                    self.run_tool(self.method, kwargs)
+                )
+                return future.result()
+        else:
+            return loop.run_until_complete(
+                self.run_tool(self.method, kwargs)
+            )
+
+    async def _arun(self, **kwargs: Any) -> str:
+        """Async execution via MCP."""
+        return await self.run_tool(self.method, kwargs)
+
+
+class MatonAgentToolkit(ToolkitCore[List[MatonTool]]):
+    """
+    Maton Agent Toolkit for LangChain.
+
+    Example:
+        toolkit = await create_maton_agent_toolkit(
+            api_key='YOUR_MATON_API_KEY',
+        )
+        tools = toolkit.get_tools()
+        agent = create_react_agent(llm, tools, prompt)
+        await toolkit.close()
+    """
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        configuration: Configuration | None = None
+    ):
+        super().__init__(api_key, configuration)
+
+    def _empty_tools(self) -> List[MatonTool]:
+        """Return empty list of tools."""
+        return []
+
+    def _convert_tools(
+        self,
+        mcp_tools: List[McpTool]
+    ) -> List[MatonTool]:
+        """Convert MCP tools to LangChain MatonTool instances."""
+        tools = []
+        for mcp_tool in mcp_tools:
+            # Convert JSON Schema to Pydantic model
+            args_schema = json_schema_to_pydantic_model(
+                mcp_tool.get("inputSchema"),
+                model_name=f"{mcp_tool['name']}_args"
+            )
+
+            tools.append(MatonTool(
+                run_tool=self.run_tool,
+                method=mcp_tool["name"],
+                name=mcp_tool["name"],
+                description=mcp_tool.get("description", mcp_tool["name"]),
+                args_schema=args_schema,
+            ))
+        return tools
+
+    @property
+    def tools(self) -> List[MatonTool]:
+        """
+        The tools available in the toolkit.
+
+        .. deprecated::
+            Access tools via get_tools() after calling initialize().
+        """
+        return self._get_tools_with_warning()
+
+
+async def create_maton_agent_toolkit(
+    api_key: str | None = None,
+    configuration: Configuration | None = None
+) -> MatonAgentToolkit:
+    """
+    Factory function to create and initialize a MatonAgentToolkit.
+
+    This is the recommended way to create a toolkit as it handles
+    async initialization automatically.
+
+    Example:
+        toolkit = await create_maton_agent_toolkit(
+            api_key='YOUR_MATON_API_KEY',
+        )
+        tools = toolkit.get_tools()
+
+        # Use with LangChain agent
+        agent = create_react_agent(llm, tools, prompt)
+
+        # Clean up when done
+        await toolkit.close()
+
+    Args:
+        api_key: Maton API key. Create one at https://maton.ai
+        configuration: Optional configuration for context
+
+    Returns:
+        Initialized MatonAgentToolkit ready to use
+    """
+    toolkit = MatonAgentToolkit(api_key, configuration)
+    await toolkit.initialize()
+    return toolkit

maton_agent_toolkit-0.1.0/maton_agent_toolkit/openai/__init__.py

@@ -0,0 +1,5 @@
+"""Maton Agent Toolkit for OpenAI Agents SDK."""
+
+from .toolkit import MatonAgentToolkit, create_maton_agent_toolkit
+
+__all__ = ["MatonAgentToolkit", "create_maton_agent_toolkit"]

maton_agent_toolkit-0.1.0/maton_agent_toolkit/openai/toolkit.py

@@ -0,0 +1,125 @@
+"""Maton Agent Toolkit for OpenAI Agents SDK."""
+
+import json
+from typing import List, Any
+
+from agents import FunctionTool
+from agents.run_context import RunContextWrapper
+
+from ..shared.toolkit_core import ToolkitCore
+from ..shared.mcp_client import McpTool
+from ..configuration import Configuration
+
+
+class MatonAgentToolkit(ToolkitCore[List[FunctionTool]]):
+    """
+    Maton Agent Toolkit for OpenAI Agents SDK.
+
+    Example:
+        toolkit = await create_maton_agent_toolkit(
+            api_key='YOUR_MATON_API_KEY',
+        )
+        tools = toolkit.get_tools()
+        agent = Agent(name="Maton Agent", tools=tools)
+        await toolkit.close()
+    """
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        configuration: Configuration | None = None
+    ):
+        super().__init__(api_key, configuration)
+
+    def _empty_tools(self) -> List[FunctionTool]:
+        """Return empty list of tools."""
+        return []
+
+    def _convert_tools(
+        self,
+        mcp_tools: List[McpTool]
+    ) -> List[FunctionTool]:
+        """Convert MCP tools to OpenAI FunctionTool instances."""
+        tools = []
+        for mcp_tool in mcp_tools:
+            tools.append(self._create_function_tool(mcp_tool))
+        return tools
+
+    def _create_function_tool(self, mcp_tool: McpTool) -> FunctionTool:
+        """Create a FunctionTool from an MCP tool definition."""
+        toolkit = self
+        tool_name = mcp_tool["name"]
+
+        async def on_invoke_tool(
+            ctx: RunContextWrapper[Any],
+            input_str: str
+        ) -> str:
+            args = json.loads(input_str)
+            return await toolkit.run_tool(tool_name, args)
+
+        # Prepare parameters schema
+        parameters = dict(mcp_tool.get("inputSchema", {}))
+        parameters["additionalProperties"] = False
+        parameters["type"] = "object"
+
+        # Clean up schema - remove fields not needed in OpenAI function schema
+        for key in ["description", "title"]:
+            parameters.pop(key, None)
+
+        if "properties" in parameters:
+            for prop in parameters["properties"].values():
+                for key in ["title", "default"]:
+                    if isinstance(prop, dict):
+                        prop.pop(key, None)
+
+        return FunctionTool(
+            name=tool_name,
+            description=mcp_tool.get("description", tool_name),
+            params_json_schema=parameters,
+            on_invoke_tool=on_invoke_tool,
+            strict_json_schema=False
+        )
+
+    @property
+    def tools(self) -> List[FunctionTool]:
+        """
+        The tools available in the toolkit.
+
+        .. deprecated::
+            Access tools via get_tools() after calling initialize().
+        """
+        return self._get_tools_with_warning()
+
+
+async def create_maton_agent_toolkit(
+    api_key: str | None = None,
+    configuration: Configuration | None = None
+) -> MatonAgentToolkit:
+    """
+    Factory function to create and initialize a MatonAgentToolkit.
+
+    This is the recommended way to create a toolkit as it handles
+    async initialization automatically.
+
+    Example:
+        toolkit = await create_maton_agent_toolkit(
+            api_key='YOUR_MATON_API_KEY',
+        )
+        tools = toolkit.get_tools()
+
+        # Use with agent
+        agent = Agent(name="Maton Agent", tools=tools)
+
+        # Clean up when done
+        await toolkit.close()
+
+    Args:
+        api_key: Maton API key. Create one at https://maton.ai
+        configuration: Optional configuration for context
+
+    Returns:
+        Initialized MatonAgentToolkit ready to use
+    """
+    toolkit = MatonAgentToolkit(api_key, configuration)
+    await toolkit.initialize()
+    return toolkit

maton_agent_toolkit-0.1.0/maton_agent_toolkit/shared/__init__.py

@@ -0,0 +1,21 @@
+"""Shared infrastructure for Maton Agent Toolkit MCP integration."""
+
+from .constants import VERSION, MCP_SERVER_URL, TOOLKIT_HEADER, MCP_HEADER
+from .async_initializer import AsyncInitializer
+from .mcp_client import MatonMcpClient, McpTool, McpToolInputSchema
+from .schema_utils import json_schema_to_pydantic_model, json_schema_to_pydantic_fields
+from .toolkit_core import ToolkitCore
+
+__all__ = [
+    "VERSION",
+    "MCP_SERVER_URL",
+    "TOOLKIT_HEADER",
+    "MCP_HEADER",
+    "AsyncInitializer",
+    "MatonMcpClient",
+    "McpTool",
+    "McpToolInputSchema",
+    "json_schema_to_pydantic_model",
+    "json_schema_to_pydantic_fields",
+    "ToolkitCore",
+]