rusticai-mcp 1.1.0__tar.gz

rusticai_mcp-1.1.0/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: rusticai-mcp
+Version: 1.1.0
+Summary: support for mcps
+License-Expression: Apache-2.0
+Author: Dragonscale Industries Inc.
+Author-email: dev@dragonscale.ai
+Requires-Python: >=3.13,<3.14
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Provides-Extra: test
+Requires-Dist: mcp (>=1.0.0,<2.0.0)
+Requires-Dist: rusticai-core (>=1.1.0,<1.2.0)
+Project-URL: Homepage, https://www.rustic.ai/
+Project-URL: Repository, https://github.com/dragonscale-ai/rustic-ai
+Project-URL: Rustic AI Core, https://pypi.org/project/rusticai-core/
+Description-Content-Type: text/markdown
+
+# mcp
+
+support for mcps
+

rusticai_mcp-1.1.0/README.md

@@ -0,0 +1,3 @@
+# mcp
+
+support for mcps

rusticai_mcp-1.1.0/pyproject.toml

@@ -0,0 +1,75 @@
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+
+[project]
+name = "rusticai-mcp"
+version = "1.1.0"
+description = "support for mcps"
+authors = [{name = "Dragonscale Industries Inc.", email = "dev@dragonscale.ai"}]
+license = "Apache-2.0"
+readme = "README.md"
+requires-python = ">=3.13,<3.14"
+urls = { Homepage = "https://www.rustic.ai/", Repository = "https://github.com/dragonscale-ai/rustic-ai", "Rustic AI Core" = "https://pypi.org/project/rusticai-core/" }
+dynamic = ["dependencies"]
+
+[tool.poetry]
+packages = [{ include = "rustic_ai", from = "src" }]
+
+[tool.poetry.dependencies]
+rusticai-core = {   version = "1.1.0"}
+mcp = "^1.0.0"
+
+[tool.poetry-monorepo.deps]
+
+
+[tool.poetry.group.dev]
+optional = true
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.3.4"
+black = { version = "^24.2.0", extras = ["jupyter"] }
+flake8 = "^7.1.2"
+tox = "^4.24.1"
+isort = "^6.0.0"
+mypy = "^1.15.0"
+flaky = "^3.8.1"
+pytest-asyncio = "^0.26.0"
+rusticai-testing = { version = "1.1.0"}
+
+[tool.poetry.extras]
+test = ["pytest"]
+
+[tool.black]
+line-length = 120
+target-version = ['py313']
+include = '\.pyi?$'
+exclude = '''
+/(
+    \.git
+  | \.mypy_cache
+  | \.tox
+  | \.venv
+  | _build
+  | buck-out
+  | build
+  | dist
+)/
+'''
+
+[tool.mypy]
+python_version = "3.13"
+ignore_missing_imports = true
+check_untyped_defs = true
+plugins = "pydantic.mypy"
+explicit_package_bases = true
+
+
+[tool.isort]
+profile = "black"
+force_sort_within_sections = true # For the sorting order issues
+lines_between_sections = 1 # For the newline issue
+known_third_party = ["pydantic"]
+known_first_party = ["rustic_ai.core"]
+

rusticai_mcp-1.1.0/src/rustic_ai/mcp/agent.py

@@ -0,0 +1,69 @@
+from rustic_ai.core.agents.commons.message_formats import ErrorMessage
+from rustic_ai.core.guild import agent
+from rustic_ai.core.guild.agent import Agent, ProcessContext
+
+from .client import MCPClient
+from .models import (
+    CallToolRequest,
+    MCPAgentConfig,
+    MCPServerConfig,
+)
+
+
+class MCPAgent(Agent[MCPAgentConfig]):
+    """
+    Agent that connects to a single MCP server and exposes its capabilities.
+    """
+
+    def __init__(self):
+        self._mcp_client: MCPClient = MCPClient(self.server_config)
+
+    @property
+    def server_config(self) -> MCPServerConfig:
+        return self.config.server
+
+    def _ensure_client(self):
+        if not self._mcp_client:
+            self._mcp_client = MCPClient(self.server_config)
+
+    @agent.processor(CallToolRequest)
+    async def handle_tool_call(self, ctx: ProcessContext[CallToolRequest]):
+        request = ctx.payload
+
+        # Verify server name matches
+        if request.server_name != self.server_config.name:
+            self.logger.warning(
+                f"Received request for unknown server: {request.server_name}. "
+                f"This agent is connected to: {self.server_config.name}"
+            )
+            ctx.send_error(
+                ErrorMessage(
+                    agent_type=self.get_qualified_class_name(),
+                    error_type="UnsupportedMcpServer",
+                    error_message=f"Unsupported mcp server {request.server_name}. This agent is connected to: {self.server_config.name}",
+                )
+            )
+            return
+
+        self._ensure_client()
+        if not self._mcp_client:
+            ctx.send_error(
+                ErrorMessage(
+                    agent_type=self.get_qualified_class_name(),
+                    error_type="MCPClientNotFound",
+                    error_message="MCP Client not found!",
+                )
+            )
+            return
+
+        response = await self._mcp_client.call_tool(request)
+        if response.is_error:
+            ctx.send_error(
+                ErrorMessage(
+                    agent_type=self.get_qualified_class_name(),
+                    error_type="ErrorProcessingMCPRequest",
+                    error_message=response.error,
+                )
+            )
+        else:
+            ctx.send(response)

rusticai_mcp-1.1.0/src/rustic_ai/mcp/client.py

@@ -0,0 +1,183 @@
+import asyncio
+import logging
+from typing import Optional
+
+import httpx
+
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.sse import sse_client
+from mcp.client.stdio import stdio_client
+
+from .models import (
+    CallToolRequest,
+    CallToolResponse,
+    MCPClientType,
+    MCPServerConfig,
+    ToolResult,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def _extract_error_message(exc: Exception) -> str:
+    """Extract a meaningful error message from an exception."""
+    # Check for HTTPStatusError in exception chain or ExceptionGroup
+    if isinstance(exc, httpx.HTTPStatusError):
+        return f"HTTP {exc.response.status_code} {exc.response.reason_phrase} for {exc.request.url}"
+
+    return str(exc)
+
+
+class MCPClient:
+    """
+    Client for connecting to an MCP server and executing tools.
+    Manages the session in a background task to satisfy anyio/asyncio constraints.
+    """
+
+    def __init__(self, config: MCPServerConfig):
+        self.config = config
+        self._session: Optional[ClientSession] = None
+        self._task: Optional[asyncio.Task] = None
+        # Lazy-initialized asyncio primitives (created in the correct event loop when first accessed)
+        self._shutdown_event: Optional[asyncio.Event] = None
+        self._ready_event: Optional[asyncio.Event] = None
+        self._event_loop: Optional[asyncio.AbstractEventLoop] = None
+        self._last_error: Optional[str] = None
+
+    def _ensure_events(self):
+        """
+        Ensures that asyncio Event objects are created in the current event loop.
+        Recreates them if the event loop has changed since they were last created.
+        """
+        try:
+            current_loop = asyncio.get_running_loop()
+        except RuntimeError:
+            # No event loop running, cannot create events yet
+            return
+
+        # If events don't exist or were created in a different loop, recreate them
+        if self._event_loop is None or self._event_loop != current_loop:
+            self._shutdown_event = asyncio.Event()
+            self._ready_event = asyncio.Event()
+            self._event_loop = current_loop
+            logger.debug(f"Created asyncio Events for MCP client {self.config.name} in event loop {id(current_loop)}")
+
+    @property
+    def shutdown_event(self) -> asyncio.Event:
+        """Lazy property for shutdown event."""
+        self._ensure_events()
+        return self._shutdown_event  # type: ignore[return-value]
+
+    @property
+    def ready_event(self) -> asyncio.Event:
+        """Lazy property for ready event."""
+        self._ensure_events()
+        return self._ready_event  # type: ignore[return-value]
+
+    async def _run_session(self):
+        """Background task to maintain the session."""
+        try:
+            transport_context = None
+            if self.config.type == MCPClientType.STDIO:
+                server_params = StdioServerParameters(
+                    command=self.config.command,
+                    args=self.config.args,
+                    env=self.config.env,
+                )
+                transport_context = stdio_client(server_params)
+            elif self.config.type == MCPClientType.SSE:
+                if not self.config.url:
+                    raise ValueError(f"URL is required for SSE connection: {self.config.name}")
+                transport_context = sse_client(url=self.config.url, headers=self.config.headers)
+            else:
+                logger.warning(f"Unsupported MCP client type: {self.config.type}")
+                return
+
+            client_type = self.config.type
+
+            async with transport_context as (read, write):
+                async with ClientSession(read, write) as session:
+                    await session.initialize()
+
+                    # Verify connection by listing tools
+                    result = await session.list_tools()
+                    tool_names = [tool.name for tool in result.tools]
+                    logger.info(f"Connected to {self.config.name} ({client_type.value}). Available tools: {tool_names}")
+
+                    self._session = session
+                    self.ready_event.set()
+
+                    # Wait until shutdown is requested
+                    await self.shutdown_event.wait()
+
+        except Exception as e:
+            if not self.shutdown_event.is_set():
+                detailed_error = _extract_error_message(e)
+                error_msg = f"MCP session error for {self.config.name}: {detailed_error}"
+                self._last_error = error_msg
+                logger.error(error_msg, exc_info=True)
+        finally:
+            self._session = None
+            if self._ready_event:  # Only clear if event was created
+                self._ready_event.clear()
+
+    async def connect(self) -> Optional[ClientSession]:
+        """Ensures connection to the server exists."""
+        if self._session:
+            return self._session
+
+        if not self._task or self._task.done():
+            # Ensure events are created in the current event loop
+            self._ensure_events()
+            self.shutdown_event.clear()
+            self._last_error = None  # Clear previous errors
+            self._task = asyncio.create_task(self._run_session())
+
+        # Wait for session to be ready
+        try:
+            await asyncio.wait_for(self.ready_event.wait(), timeout=10.0)
+        except asyncio.TimeoutError:
+            error_detail = f" Last error: {self._last_error}" if self._last_error else ""
+            logger.error(f"Timeout waiting for MCP connection to {self.config.name}.{error_detail}")
+            # Cleanup if timeout
+            self.shutdown_event.set()
+            if self._task:
+                try:
+                    await self._task
+                except Exception:
+                    pass
+            return None
+
+        return self._session
+
+    async def call_tool(self, request: CallToolRequest) -> CallToolResponse:
+        session = await self.connect()
+
+        if not session:
+            error_msg = "mcp session not found!"
+            if self._last_error:
+                error_msg += f" Reason: {self._last_error}"
+            return CallToolResponse(results=[], is_error=True, error=error_msg)
+
+        try:
+            result = await session.call_tool(request.tool_name, arguments=request.arguments)
+
+            tool_results = []
+            for content in result.content:
+                if content.type == "text":
+                    tool_results.append(ToolResult(type="text", content=content.text))
+                elif content.type == "image":
+                    tool_results.append(ToolResult(type="image", content=content.data))
+                elif content.type == "resource":
+                    tool_results.append(ToolResult(type="resource", content=content.resource.uri))
+
+            return CallToolResponse(results=tool_results)
+
+        except Exception as e:
+            logger.error(
+                f"Error calling tool {request.tool_name} on {self.config.name}: {e}",
+                exc_info=True,
+            )
+            return CallToolResponse(
+                results=[], is_error=True, error=f"Error calling tool {request.tool_name} on {self.config.name}: {e}"
+            )

rusticai_mcp-1.1.0/src/rustic_ai/mcp/models.py

@@ -0,0 +1,46 @@
+from enum import Enum
+from typing import Dict, List, Literal, Optional, Union
+
+from pydantic import BaseModel, Field
+
+from rustic_ai.core.guild.dsl import BaseAgentProps
+
+
+class MCPClientType(str, Enum):
+    STDIO = "stdio"
+    SSE = "sse"
+
+
+class MCPServerConfig(BaseModel):
+    name: str = Field(description="Name of the MCP server")
+    type: MCPClientType = Field(default=MCPClientType.STDIO, description="Type of connection")
+
+    # Stdio config
+    command: Optional[str] = Field(None, description="Command to execute for stdio")
+    args: List[str] = Field(default_factory=list, description="Arguments for the command")
+    env: Dict[str, str] = Field(default_factory=dict, description="Environment variables")
+
+    # SSE config
+    url: Optional[str] = Field(None, description="URL for SSE connection")
+    headers: Dict[str, str] = Field(default_factory=dict, description="Headers for SSE connection")
+
+
+class MCPAgentConfig(BaseAgentProps):
+    server: MCPServerConfig = Field(description="MCP server configuration")
+
+
+class CallToolRequest(BaseModel):
+    server_name: str
+    tool_name: str
+    arguments: Dict = Field(default_factory=dict)
+
+
+class ToolResult(BaseModel):
+    type: Literal["text", "image", "resource"]
+    content: Union[str, Dict]
+
+
+class CallToolResponse(BaseModel):
+    results: List[ToolResult]
+    is_error: bool = False
+    error: Optional[str] = None