smarta2a 0.2.2__py3-none-any.whl → 0.2.3__py3-none-any.whl

smarta2a/__init__.py

@@ -3,7 +3,7 @@ py_a2a - A Python package for implementing an A2A server
 """
 
 from .server.server import SmartA2A
-from .common.types import *
+from .utils.types import *
 
 __version__ = "0.1.0"
 

smarta2a/agent/a2a_agent.py

@@ -0,0 +1,38 @@
+# Library imports
+
+
+# Local imports
+from smarta2a.server import SmartA2A
+from smarta2a.model_providers.base_llm_provider import BaseLLMProvider
+from smarta2a.history_update_strategies.history_update_strategy import HistoryUpdateStrategy
+from smarta2a.state_stores.base_state_store import BaseStateStore
+from smarta2a.utils.types import StateData, SendTaskRequest
+
+class A2AAgent:
+    def __init__(
+            self,
+            name: str,
+            model_provider: BaseLLMProvider,
+            history_update_strategy: HistoryUpdateStrategy,
+            state_storage: BaseStateStore,
+        ):
+        self.model_provider = model_provider
+        self.app = SmartA2A(
+            name=name,
+            history_update_strategy=history_update_strategy,
+            state_storage=state_storage
+        )
+        self.__register_handlers()
+
+    def __register_handlers(self):
+        @self.app.on_send_task()
+        async def on_send_task(request: SendTaskRequest, state: StateData):
+            response = self.model_provider.generate(state.history)
+            return response
+
+    def start(self, **kwargs):
+        self.app.configure(**kwargs)
+        self.app.run()
+
+    
+    

smarta2a/agent/a2a_mcp_server.py

@@ -0,0 +1,37 @@
+# Library imports
+from mcp.server.fastmcp import FastMCP, Context
+
+class A2AMCPServer:
+    def __init__(self):
+        self.mcp = FastMCP("A2AMCPServer")
+        self._register_handlers()
+
+    def _register_handlers(self):
+
+        @self.mcp.middleware
+        async def extract_session_id(request, call_next):
+            # Extract 'x-session-id' from headers
+            session_id = request.headers.get("x-session-id")
+            # Store it in the request state for later access
+            request.state.session_id = session_id
+            # Proceed with the request processing
+            response = await call_next(request)
+            return response
+        
+        @self.mcp.tool()
+        def send_task(ctx: Context, url: str, message: str):
+            session_id = ctx.request.state.session_id
+            pass
+
+        @self.mcp.tool()
+        def get_task():
+            pass
+
+        @self.mcp.tool()
+        def cancel_task():
+            pass
+        
+        
+
+    def start(self):
+        pass

smarta2a/archive/mcp_client.py

@@ -0,0 +1,86 @@
+# Library imports
+import re
+from contextlib import AsyncExitStack
+from mcp.client import ClientSession, sse_client, stdio_client, StdioServerParameters
+
+
+class MCPClient:
+    def __init__(self):
+        self.session = None
+        self.exit_stack = AsyncExitStack()
+        self._connect_to_server()
+
+    async def _connect_to_sse_server(self, server_url: str):
+        """Connect to an SSE MCP server."""
+        self._streams_context = sse_client(url=server_url)
+        streams = await self._streams_context.__aenter__()
+
+        self._session_context = ClientSession(*streams)
+        self.session = await self._session_context.__aenter__()
+
+        # Initialize
+        await self.session.initialize()
+
+    async def _connect_to_stdio_server(self, server_script_path: str):
+        """Connect to a stdio MCP server."""
+        is_python = False
+        is_javascript = False
+        command = None
+        args = [server_script_path]
+        
+        # Determine if the server is a file path or npm package
+        if server_script_path.startswith("@") or "/" not in server_script_path:
+            # Assume it's an npm package
+            is_javascript = True
+            command = "npx"
+        else:
+            # It's a file path
+            is_python = server_script_path.endswith(".py")
+            is_javascript = server_script_path.endswith(".js")
+            if not (is_python or is_javascript):
+                raise ValueError("Server script must be a .py, .js file or npm package.")
+        
+            command = "python" if is_python else "node"
+            
+        server_params = StdioServerParameters(
+            command=command,
+            args=args,
+            env=None
+        )
+
+        # Start the server
+        stdio_transport = await self.exit_stack.enter_async_context(stdio_client(server_params))
+        self.stdio, self.writer = stdio_transport
+        self.session = await self.exit_stack.enter_async_context(ClientSession(self.stdio, self.writer))
+
+        await self.session.initialize()
+
+    async def _connect_to_server(self, server_path_or_url: str):
+        """Connect to an MCP server (either stdio or SSE)."""
+        # Check if the input is a URL (for SSE server)
+        url_pattern = re.compile(r'^https?://')
+        
+        if url_pattern.match(server_path_or_url):
+            # It's a URL, connect to SSE server
+            await self._connect_to_sse_server(server_path_or_url)
+        else:
+            # It's a script path, connect to stdio server
+            await self._connect_to_stdio_server(server_path_or_url)
+    
+    async def list_tools(self):
+        """List available tools."""
+        response = await self.session.list_tools()
+        return response.tools
+    
+    async def call_tool(self, tool_name: str, **tool_args):
+        """Call a tool."""
+        response = await self.session.call_tool(tool_name, **tool_args)
+        return response.content
+
+    async def cleanup(self):
+        """Clean up resources."""
+        await self.exit_stack.aclose()
+        if hasattr(self, '_session_context') and self._session_context:
+            await self._session_context.__aexit__(None, None, None)
+        if hasattr(self, '_streams_context') and self._streams_context:
+            await self._streams_context.__aexit__(None, None, None)

smarta2a/client/a2a_client.py

@@ -1,11 +1,13 @@
 # Library imports
-from typing import Any, Literal, AsyncIterable
+from typing import Any, Literal, AsyncIterable, get_origin, get_args
 import httpx
 import json
 from httpx_sse import connect_sse
+from inspect import signature, Parameter, iscoroutinefunction
+from pydantic import create_model, Field, BaseModel
 
 # Local imports
-from smarta2a.common.types import (
+from smarta2a.utils.types import (
     PushNotificationConfig,
     SendTaskStreamingResponse,
     SendTaskResponse,
@@ -21,7 +23,7 @@ from smarta2a.common.types import (
     SetTaskPushNotificationResponse,
     GetTaskPushNotificationResponse,
 )
-from smarta2a.common.task_request_builder import TaskRequestBuilder
+from smarta2a.utils.task_request_builder import TaskRequestBuilder
 
 
 class A2AClient:
@@ -47,6 +49,7 @@ class A2AClient:
         history_length: int | None = None,
         metadata: dict[str, Any] | None = None,
     ):
+        """Send a task to another Agent"""
         params = TaskRequestBuilder.build_send_task_request(
             id=id,
             role=role,
@@ -76,6 +79,7 @@ class A2AClient:
         history_length: int | None = None,
         metadata: dict[str, Any] | None = None,
     ):
+        """Send to another Agent and receive a stream of responses"""
         params = TaskRequestBuilder.build_send_task_request(
             id=id,
             role=role,
@@ -108,6 +112,7 @@ class A2AClient:
         history_length: int | None = None,
         metadata: dict[str, Any] | None = None,
     ) -> GetTaskResponse:
+        """Get a task from another Agent"""
         req = TaskRequestBuilder.get_task(id, history_length, metadata)
         raw = await self._send_request(req)
         return GetTaskResponse(**raw)
@@ -118,6 +123,7 @@ class A2AClient:
         id: str,
         metadata: dict[str, Any] | None = None,
     ) -> CancelTaskResponse:
+        """Cancel a task from another Agent"""
         req = TaskRequestBuilder.cancel_task(id, metadata)
         raw = await self._send_request(req)
         return CancelTaskResponse(**raw)
@@ -130,6 +136,7 @@ class A2AClient:
         token: str | None = None,
         authentication: AuthenticationInfo | dict[str, Any] | None = None,
     ) -> SetTaskPushNotificationResponse:
+        """Set a push notification for a task"""
         req = TaskRequestBuilder.set_push_notification(id, url, token, authentication)
         raw = await self._send_request(req)
         return SetTaskPushNotificationResponse(**raw)
@@ -140,6 +147,7 @@ class A2AClient:
         id: str,
         metadata: dict[str, Any] | None = None,
     ) -> GetTaskPushNotificationResponse:
+        """Get a push notification for a task"""
         req = TaskRequestBuilder.get_push_notification(id, metadata)
         raw = await self._send_request(req)
         return GetTaskPushNotificationResponse(**raw)
@@ -171,3 +179,89 @@ class A2AClient:
                         raise A2AClientJSONError(str(e)) from e
                     except httpx.RequestError as e:
                         raise A2AClientHTTPError(400, str(e)) from e
+    
+
+    def list_tools(self) -> list[dict[str, Any]]:
+        """Return metadata for all available tools."""
+        tools = []
+        tool_names = [
+            'send'
+        ]
+        for name in tool_names:
+            method = getattr(self, name)
+            doc = method.__doc__ or ""
+            description = doc.strip().split('\n')[0] if doc else ""
+            
+            # Generate input schema
+            sig = signature(method)
+            parameters = sig.parameters
+            
+            fields = {}
+            required = []
+            for param_name, param in parameters.items():
+                if param_name == 'self':
+                    continue
+                annotation = param.annotation
+                if annotation is Parameter.empty:
+                    annotation = Any
+                # Handle Literal types
+                if get_origin(annotation) is Literal:
+                    enum_values = get_args(annotation)
+                    annotation = Literal.__getitem__(enum_values)
+                # Handle default
+                default = param.default
+                if default is Parameter.empty:
+                    required.append(param_name)
+                    field = Field(...)
+                else:
+                    field = Field(default=default)
+                fields[param_name] = (annotation, field)
+            
+            # Create dynamic Pydantic model
+            model = create_model(f"{name}_Input", **fields)
+            schema = model.schema()
+            
+            tools.append({
+                'name': name,
+                'description': description,
+                'input_schema': schema
+            })
+        return tools
+
+    async def call_tool(self, tool_name: str, arguments: dict[str, Any]) -> Any:
+        """Call a tool by name with validated arguments."""
+        if not hasattr(self, tool_name):
+            raise ValueError(f"Tool {tool_name} not found")
+        method = getattr(self, tool_name)
+        
+        # Validate arguments using the same schema as list_tools
+        sig = signature(method)
+        parameters = sig.parameters
+        
+        fields = {}
+        for param_name, param in parameters.items():
+            if param_name == 'self':
+                continue
+            annotation = param.annotation
+            if annotation is Parameter.empty:
+                annotation = Any
+            # Handle Literal
+            if get_origin(annotation) is Literal:
+                enum_values = get_args(annotation)
+                annotation = Literal.__getitem__(enum_values)
+            default = param.default
+            if default is Parameter.empty:
+                fields[param_name] = (annotation, Field(...))
+            else:
+                fields[param_name] = (annotation, Field(default=default))
+        
+        # Create validation model
+        model = create_model(f"{tool_name}_ValidationModel", **fields)
+        validated_args = model(**arguments).dict()
+        
+        # Call the method
+        if iscoroutinefunction(method):
+            return await method(**validated_args)
+        else:
+            # Note: Synchronous methods (like subscribe) will block the event loop
+            return method(**validated_args)

smarta2a/client/smart_mcp_client.py

@@ -0,0 +1,60 @@
+from mcp.client import Client
+from typing import Optional, Dict, Any
+
+class SmartMCPClient:
+    def __init__(self, base_url: str):
+        """
+        Initialize with the server URL. Headers are provided per request, not globally.
+        """
+        self.base_url = base_url
+
+    async def list_tools(self, session_id: Optional[str] = None) -> Any:
+        """
+        List tools with optional session_id header.
+        """
+        async with Client(self.base_url, headers=self._build_headers(session_id)) as client:
+            return await client.list_tools()
+
+    async def call_tool(self, tool_name: str, arguments: Dict[str, Any], session_id: Optional[str] = None) -> Any:
+        """
+        Call a tool with dynamic session_id.
+        """
+        async with Client(self.base_url, headers=self._build_headers(session_id)) as client:
+            return await client.call_tool(tool_name, arguments)
+
+    async def list_resources(self, session_id: Optional[str] = None) -> Any:
+        """
+        List resources with optional session_id.
+        """
+        async with Client(self.base_url, headers=self._build_headers(session_id)) as client:
+            return await client.list_resources()
+
+    async def read_resource(self, resource_uri: str, session_id: Optional[str] = None) -> Any:
+        """
+        Read a resource with dynamic session_id.
+        """
+        async with Client(self.base_url, headers=self._build_headers(session_id)) as client:
+            return await client.read_resource(resource_uri)
+
+    async def get_prompt(self, prompt_name: str, arguments: Dict[str, Any], session_id: Optional[str] = None) -> Any:
+        """
+        Fetch a prompt with optional session_id.
+        """
+        async with Client(self.base_url, headers=self._build_headers(session_id)) as client:
+            return await client.get_prompt(prompt_name, arguments)
+
+    async def ping(self, session_id: Optional[str] = None) -> Any:
+        """
+        Ping server with optional session_id.
+        """
+        async with Client(self.base_url, headers=self._build_headers(session_id)) as client:
+            return await client.ping()
+
+    def _build_headers(self, session_id: Optional[str]) -> Dict[str, str]:
+        """
+        Internal helper to build headers dynamically.
+        """
+        headers = {}
+        if session_id:
+            headers["x-session-id"] = session_id
+        return headers

smarta2a/client/tools_manager.py

@@ -0,0 +1,58 @@
+# Library imports
+import json
+from typing import List, Dict, Any, Union, Literal
+
+# Local imports
+from smarta2a.client.smart_mcp_client import SmartMCPClient
+from smarta2a.client.a2a_client import A2AClient
+from smarta2a.utils.types import AgentCard
+
+class ToolsManager:
+    """
+    Manages loading, describing, and invoking tools from various providers.
+    Acts as a wrapper around the MCP and A2A clients.
+    """
+    def __init__(self):
+        self.tools_list: List[Any] = []
+        self.clients: Dict[str, Union[SmartMCPClient, A2AClient]] = {}
+
+    def load_mcp_tools(self, urls_or_paths: List[str]) -> None:
+        for url in urls_or_paths:
+            mcp_client = SmartMCPClient(url)
+            for tool in mcp_client.list_tools():
+                self.tools_list.append(tool)
+                self.clients[tool.name] = mcp_client
+
+    def load_a2a_tools(self, agent_cards: List[AgentCard]) -> None:
+        for agent_card in agent_cards:
+            a2a_client = A2AClient(agent_card)
+            for tool in a2a_client.list_tools():
+                self.tools_list.append(tool)
+            self.clients[tool.name] = a2a_client
+
+    def get_tools(self) -> List[Any]:
+        return self.tools_list
+
+
+    def describe_tools(self, client_type: Literal["mcp", "a2a"]) -> str:
+        lines = []
+        for tool in self.tools_list:
+            if client_type == "mcp" and isinstance(tool, SmartMCPClient):
+                schema = json.dumps(tool.input_schema, indent=2)
+                lines.append(
+                    f"- **{tool.name}**: {tool.description}\n  Parameters schema:\n  ```json\n{schema}\n```"
+                )
+            elif client_type == "a2a" and isinstance(tool, A2AClient):
+                lines.append(
+                    f"- **{tool.name}**: {tool.description} Parameters schema:\n  ```json\n{schema}\n```"
+                )
+        return "\n".join(lines)
+
+    def get_client(self, tool_name: str) -> Any:
+        return self.clients.get(tool_name)
+
+    async def call_tool(self, tool_name: str, args: Dict[str, Any]) -> Any:
+        client = self.get_client(tool_name)
+        if not client:
+            raise ValueError(f"Tool not found: {tool_name}")
+        return await client.call_tool(tool_name, args)

smarta2a/history_update_strategies/__init__.py

@@ -0,0 +1,8 @@
+"""
+Strategies for updating conversation history.
+"""
+
+from .history_update_strategy import HistoryUpdateStrategy
+from .append_strategy import AppendStrategy
+
+__all__ = ['HistoryUpdateStrategy', 'AppendStrategy'] 

smarta2a/history_update_strategies/append_strategy.py

@@ -0,0 +1,10 @@
+# Library imports
+from typing import List
+
+# Local imports
+from smarta2a.utils.types import Message
+
+class AppendStrategy:
+    """Default append behavior"""
+    def update_history(self, existing_history: List[Message], new_messages: List[Message]) -> List[Message]:
+        return existing_history + new_messages

smarta2a/history_update_strategies/history_update_strategy.py

@@ -0,0 +1,15 @@
+# Library imports
+from typing import Protocol, List
+from typing import List
+
+# Local imports
+from smarta2a.utils.types import Message
+
+class HistoryUpdateStrategy(Protocol):
+    def update_history(
+        self,
+        existing_history: List[Message],
+        new_messages: List[Message]
+    ) -> List[Message]:
+        """Process history with new messages"""
+        pass

smarta2a/model_providers/__init__.py

@@ -0,0 +1,5 @@
+"""
+Model provider implementations for different AI models.
+"""
+
+# This package is currently empty but will contain model provider implementations 

smarta2a/model_providers/base_llm_provider.py

@@ -0,0 +1,15 @@
+# Library imports
+from abc import ABC, abstractmethod
+from typing import AsyncGenerator, List
+
+# Local imports
+from smarta2a.utils.types import Message
+
+class BaseLLMProvider(ABC):
+    @abstractmethod
+    async def generate(self, messages: List[Message], **kwargs) -> str:
+        pass
+    
+    @abstractmethod
+    async def generate_stream(self, messages: List[Message], **kwargs) -> AsyncGenerator[str, None]:
+        pass