smarta2a 0.2.1__tar.gz → 0.2.3__tar.gz

{smarta2a-0.2.1 → smarta2a-0.2.3}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: smarta2a
-Version: 0.2.1
-Summary: A Python package for creating servers and clients following Google's Agent2Agent protocol
+Version: 0.2.3
+Summary: A simple Python framework (built on top of FastAPI) for creating Agents following Google's Agent2Agent protocol
 Project-URL: Homepage, https://github.com/siddharthsma/smarta2a
 Project-URL: Bug Tracker, https://github.com/siddharthsma/smarta2a/issues
 Author-email: Siddharth Ambegaonkar <siddharthsma@gmail.com>
@@ -10,10 +10,16 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.8
-Requires-Dist: fastapi
-Requires-Dist: pydantic
-Requires-Dist: sse-starlette
-Requires-Dist: uvicorn
+Requires-Dist: anyio>=4.9.0
+Requires-Dist: fastapi>=0.115.12
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: mcp>=0.1.0
+Requires-Dist: openai>=1.0.0
+Requires-Dist: pydantic>=2.11.3
+Requires-Dist: sse-starlette>=2.2.1
+Requires-Dist: starlette>=0.46.2
+Requires-Dist: typing-extensions>=4.13.2
+Requires-Dist: uvicorn>=0.34.1
 Description-Content-Type: text/markdown
 
 # SmartA2A
@@ -45,7 +51,7 @@ pip install smarta2a
 ## Simple Echo Server Implementation
 
 ```python
-from smarta2a import SmartA2A
+from smarta2a.server import SmartA2A
 
 app = SmartA2A("EchoServer")
 

{smarta2a-0.2.1 → smarta2a-0.2.3}/README.md

@@ -27,7 +27,7 @@ pip install smarta2a
 ## Simple Echo Server Implementation
 
 ```python
-from smarta2a import SmartA2A
+from smarta2a.server import SmartA2A
 
 app = SmartA2A("EchoServer")
 

{smarta2a-0.2.1 → smarta2a-0.2.3}/pyproject.toml

@@ -4,11 +4,11 @@ build-backend = "hatchling.build"
 
 [project]
 name = "smarta2a"
-version = "0.2.1"
+version = "0.2.3"
 authors = [
     { name = "Siddharth Ambegaonkar", email = "siddharthsma@gmail.com" },
 ]
-description = "A Python package for creating servers and clients following Google's Agent2Agent protocol"
+description = "A simple Python framework (built on top of FastAPI) for creating Agents following Google's Agent2Agent protocol"
 readme = "README.md"
 requires-python = ">=3.8"
 classifiers = [
@@ -17,10 +17,16 @@ classifiers = [
     "Operating System :: OS Independent",
 ]
 dependencies = [
-    "fastapi",
-    "pydantic",
-    "uvicorn",
-    "sse-starlette",
+    "fastapi>=0.115.12",
+    "pydantic>=2.11.3",
+    "uvicorn>=0.34.1",
+    "sse-starlette>=2.2.1",
+    "openai>=1.0.0",
+    "mcp>=0.1.0",
+    "httpx>=0.28.1",
+    "starlette>=0.46.2",
+    "typing-extensions>=4.13.2",
+    "anyio>=4.9.0"
 ]
 
 [project.urls]

{smarta2a-0.2.1 → smarta2a-0.2.3}/requirements.txt

@@ -24,3 +24,5 @@ typing-inspection==0.4.0
 typing_extensions==4.13.2
 urllib3==2.4.0
 uvicorn==0.34.1
+openai>=1.0.0
+mcp>=0.1.0

smarta2a-0.2.3/smarta2a/__init__.py

@@ -0,0 +1,10 @@
+"""
+py_a2a - A Python package for implementing an A2A server
+"""
+
+from .server.server import SmartA2A
+from .utils.types import *
+
+__version__ = "0.1.0"
+
+__all__ = ["SmartA2A"]

smarta2a-0.2.3/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-0.2.3/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-0.2.3/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-0.2.3/smarta2a/client/a2a_client.py

@@ -0,0 +1,267 @@
+# Library imports
+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.utils.types import (
+    PushNotificationConfig,
+    SendTaskStreamingResponse,
+    SendTaskResponse,
+    SendTaskStreamingRequest,
+    SendTaskRequest,
+    JSONRPCRequest,
+    A2AClientJSONError,
+    A2AClientHTTPError,
+    AgentCard,
+    AuthenticationInfo,
+    GetTaskResponse,
+    CancelTaskResponse,
+    SetTaskPushNotificationResponse,
+    GetTaskPushNotificationResponse,
+)
+from smarta2a.utils.task_request_builder import TaskRequestBuilder
+
+
+class A2AClient:
+    def __init__(self, agent_card: AgentCard = None, url: str = None):
+        if agent_card:
+            self.url = agent_card.url
+        elif url:
+            self.url = url
+        else:
+            raise ValueError("Must provide either agent_card or url")
+
+    async def send(
+        self,
+        *,
+        id: str,
+        role: Literal["user", "agent"] = "user",
+        text: str | None = None,
+        data: dict[str, Any] | None = None,
+        file_uri: str | None = None,
+        session_id: str | None = None,
+        accepted_output_modes: list[str] | None = None,
+        push_notification: PushNotificationConfig | None = None,
+        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,
+            text=text,
+            data=data,
+            file_uri=file_uri,
+            session_id=session_id,
+            accepted_output_modes=accepted_output_modes,
+            push_notification=push_notification,
+            history_length=history_length,
+            metadata=metadata,
+        )
+        request = SendTaskRequest(params=params)
+        return SendTaskResponse(**await self._send_request(request))
+
+    def subscribe(
+        self,
+        *,
+        id: str,
+        role: Literal["user", "agent"] = "user",
+        text: str | None = None,
+        data: dict[str, Any] | None = None,
+        file_uri: str | None = None,
+        session_id: str | None = None,
+        accepted_output_modes: list[str] | None = None,
+        push_notification: PushNotificationConfig | None = None,
+        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,
+            text=text,
+            data=data,
+            file_uri=file_uri,
+            session_id=session_id,
+            accepted_output_modes=accepted_output_modes,
+            push_notification=push_notification,
+            history_length=history_length,
+            metadata=metadata,
+        )
+        request = SendTaskStreamingRequest(params=params)
+        with httpx.Client(timeout=None) as client:
+            with connect_sse(
+                client, "POST", self.url, json=request.model_dump()
+            ) as event_source:
+                try:
+                    for sse in event_source.iter_sse():
+                        yield SendTaskStreamingResponse(**json.loads(sse.data))
+                except json.JSONDecodeError as e:
+                    raise A2AClientJSONError(str(e)) from e
+                except httpx.RequestError as e:
+                    raise A2AClientHTTPError(400, str(e)) from e
+
+    async def get_task(
+        self,
+        *,
+        id: str,
+        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)
+
+    async def cancel_task(
+        self,
+        *,
+        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)
+
+    async def set_push_notification(
+        self,
+        *,
+        id: str,
+        url: str,
+        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)
+
+    async def get_push_notification(
+        self,
+        *,
+        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)
+        
+            
+    async def _send_request(self, request: JSONRPCRequest) -> dict[str, Any]:
+        async with httpx.AsyncClient() as client:
+            try:
+                # Image generation could take time, adding timeout
+                response = await client.post(
+                    self.url, json=request.model_dump(), timeout=30
+                )
+                response.raise_for_status()
+                return response.json()
+            except httpx.HTTPStatusError as e:
+                raise A2AClientHTTPError(e.response.status_code, str(e)) from e
+            except json.JSONDecodeError as e:
+                raise A2AClientJSONError(str(e)) from e
+            
+    async def _send_streaming_request(self, request: JSONRPCRequest) -> AsyncIterable[SendTaskStreamingResponse]:
+        with httpx.Client(timeout=None) as client:
+                with connect_sse(
+                    client, "POST", self.url, json=request.model_dump()
+                ) as event_source:
+                    try:
+                        for sse in event_source.iter_sse():
+                            yield SendTaskStreamingResponse(**json.loads(sse.data))
+                    except json.JSONDecodeError as e:
+                        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-0.2.3/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-0.2.3/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-0.2.3/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-0.2.3/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