smarta2a 0.2.4__tar.gz → 0.2.5__tar.gz

{smarta2a-0.2.4 → smarta2a-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smarta2a
-Version: 0.2.4
+Version: 0.2.5
 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

{smarta2a-0.2.4 → smarta2a-0.2.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "smarta2a"
-version = "0.2.4"
+version = "0.2.5"
 authors = [
     { name = "Siddharth Ambegaonkar", email = "siddharthsma@gmail.com" },
 ]

{smarta2a-0.2.4 → smarta2a-0.2.5}/smarta2a/agent/a2a_agent.py

@@ -5,7 +5,9 @@
 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.history_update_strategies.append_strategy import AppendStrategy
 from smarta2a.state_stores.base_state_store import BaseStateStore
+from smarta2a.state_stores.inmemory_state_store import InMemoryStateStore
 from smarta2a.utils.types import StateData, SendTaskRequest
 
 class A2AAgent:
@@ -13,26 +15,32 @@ class A2AAgent:
             self,
             name: str,
             model_provider: BaseLLMProvider,
-            history_update_strategy: HistoryUpdateStrategy,
-            state_storage: BaseStateStore,
+            history_update_strategy: HistoryUpdateStrategy = None,
+            state_store: BaseStateStore = None,
         ):
         self.model_provider = model_provider
+        self.history_update_strategy = history_update_strategy or AppendStrategy()
+        self.state_store = state_store or InMemoryStateStore()
         self.app = SmartA2A(
             name=name,
-            history_update_strategy=history_update_strategy,
-            state_storage=state_storage
+            history_update_strategy=self.history_update_strategy,
+            state_store=self.state_store
         )
         self.__register_handlers()
 
     def __register_handlers(self):
+        @self.app.on_event("startup")
+        async def on_startup():
+            await self.model_provider.load()
+
         @self.app.on_send_task()
         async def on_send_task(request: SendTaskRequest, state: StateData):
-            response = self.model_provider.generate(state.history)
+            response = await self.model_provider.generate(state.history)
             return response
+        
+    def get_app(self):
+        return self.app
 
-    def start(self, **kwargs):
-        self.app.configure(**kwargs)
-        self.app.run()
 
     
     

{smarta2a-0.2.4/smarta2a/client → smarta2a-0.2.5/smarta2a/archive}/smart_mcp_client.py

@@ -1,4 +1,4 @@
-from mcp.client import Client
+from mcp.client import ClientSession, sse_client, stdio_client, StdioServerParameters
 from typing import Optional, Dict, Any
 
 class SmartMCPClient:
@@ -7,6 +7,9 @@ class SmartMCPClient:
         Initialize with the server URL. Headers are provided per request, not globally.
         """
         self.base_url = base_url
+        self.session = None
+        self.exit_stack = AsyncExitStack()
+        self._connect_to_server()
 
     async def list_tools(self, session_id: Optional[str] = None) -> Any:
         """

{smarta2a-0.2.4 → smarta2a-0.2.5}/smarta2a/client/a2a_client.py

@@ -181,7 +181,7 @@ class A2AClient:
                         raise A2AClientHTTPError(400, str(e)) from e
     
 
-    def list_tools(self) -> list[dict[str, Any]]:
+    async def list_tools(self) -> list[dict[str, Any]]:
         """Return metadata for all available tools."""
         tools = []
         tool_names = [
@@ -224,7 +224,7 @@ class A2AClient:
             tools.append({
                 'name': name,
                 'description': description,
-                'input_schema': schema
+                'inputSchema': schema
             })
         return tools
 

{smarta2a-0.2.4/smarta2a/archive → smarta2a-0.2.5/smarta2a/client}/mcp_client.py

@@ -1,14 +1,22 @@
 # Library imports
 import re
+from typing import Dict, Any
 from contextlib import AsyncExitStack
-from mcp.client import ClientSession, sse_client, stdio_client, StdioServerParameters
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+from mcp.client.sse import sse_client
 
 
 class MCPClient:
     def __init__(self):
         self.session = None
         self.exit_stack = AsyncExitStack()
-        self._connect_to_server()
+
+    @classmethod
+    async def create(cls, server_path_or_url: str):
+        client = cls()
+        await client._connect_to_server(server_path_or_url)
+        return client
 
     async def _connect_to_sse_server(self, server_url: str):
         """Connect to an SSE MCP server."""
@@ -72,9 +80,9 @@ class MCPClient:
         response = await self.session.list_tools()
         return response.tools
     
-    async def call_tool(self, tool_name: str, **tool_args):
+    async def call_tool(self, tool_name: str, tool_args: Dict[str, Any]):
         """Call a tool."""
-        response = await self.session.call_tool(tool_name, **tool_args)
+        response = await self.session.call_tool(tool_name, tool_args)
         return response.content
 
     async def cleanup(self):

{smarta2a-0.2.4 → smarta2a-0.2.5}/smarta2a/client/tools_manager.py

@@ -3,7 +3,7 @@ import json
 from typing import List, Dict, Any, Union, Literal
 
 # Local imports
-from smarta2a.client.smart_mcp_client import SmartMCPClient
+from smarta2a.client.mcp_client import MCPClient
 from smarta2a.client.a2a_client import A2AClient
 from smarta2a.utils.types import AgentCard
 
@@ -14,21 +14,23 @@ class ToolsManager:
     """
     def __init__(self):
         self.tools_list: List[Any] = []
-        self.clients: Dict[str, Union[SmartMCPClient, A2AClient]] = {}
+        self.clients: Dict[str, Union[MCPClient, A2AClient]] = {}
 
-    def load_mcp_tools(self, urls_or_paths: List[str]) -> None:
+    async 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():
+            mcp_client = await MCPClient.create(url)
+            tools = await mcp_client.list_tools()
+            for tool in tools:
                 self.tools_list.append(tool)
                 self.clients[tool.name] = mcp_client
 
-    def load_a2a_tools(self, agent_cards: List[AgentCard]) -> None:
+    async 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():
+            tools = await a2a_client.list_tools()
+            for tool in tools:
                 self.tools_list.append(tool)
-            self.clients[tool.name] = a2a_client
+                self.clients[tool.name] = a2a_client
 
     def get_tools(self) -> List[Any]:
         return self.tools_list
@@ -37,15 +39,16 @@ class ToolsManager:
     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)
+            schema = json.dumps(tool.inputSchema, indent=2)  # Fix: use inputSchema
+            if client_type == "mcp":
                 lines.append(
                     f"- **{tool.name}**: {tool.description}\n  Parameters schema:\n  ```json\n{schema}\n```"
                 )
-            elif client_type == "a2a" and isinstance(tool, A2AClient):
+            elif client_type == "a2a":
                 lines.append(
-                    f"- **{tool.name}**: {tool.description} Parameters schema:\n  ```json\n{schema}\n```"
+                    f"- **{tool.name}**: {tool.description}\n  Parameters schema:\n  ```json\n{schema}\n```"
                 )
+
         return "\n".join(lines)
 
     def get_client(self, tool_name: str) -> Any:

{smarta2a-0.2.4 → smarta2a-0.2.5}/smarta2a/examples/echo_server/main.py

@@ -1,10 +1,12 @@
 from smarta2a.server import SmartA2A
 from smarta2a.utils.types import A2AResponse, TaskStatus, TaskState, TextPart, FileContent, FilePart
+from smarta2a.state_stores.inmemory_state_store import InMemoryStateStore
 
-app = SmartA2A("EchoServer")
+state_store = InMemoryStateStore()
+app = SmartA2A("EchoServer", state_store=state_store)
 
 @app.on_send_task()
-def handle_task(request):
+async def handle_task(request, state):
     """Echo the input text back as a completed task"""
     input_text = request.content[0].text
     #return f"Response to task: {input_text}"
@@ -14,7 +16,7 @@ def handle_task(request):
     )
 
 @app.on_send_subscribe_task()
-async def handle_subscribe_task(request):
+async def handle_subscribe_task(request, state):
     """Subscribe to the task"""
     input_text = request.content[0].text
     yield f"First response to the task: {input_text}"

smarta2a-0.2.5/smarta2a/examples/openai_agent/main.py

@@ -0,0 +1,32 @@
+# Imports
+from dotenv import load_dotenv
+import os
+import uvicorn
+import asyncio
+from smarta2a.agent.a2a_agent import A2AAgent
+from smarta2a.model_providers.openai_provider import OpenAIProvider
+
+
+
+# Load environment variables from the .env file
+load_dotenv()
+
+# Fetch the value using os.getenv
+api_key = os.getenv("OPENAI_API_KEY")
+
+
+openai_provider = OpenAIProvider(
+    api_key=api_key,
+    model="gpt-4o-mini",
+    mcp_server_urls_or_paths=["/Users/apple/Desktop/Code/weather/weather.py"],
+)
+
+# Create the agent
+agent = A2AAgent(
+    name="openai_agent",
+    model_provider=openai_provider,
+)
+
+# Entry point
+if __name__ == "__main__":
+    uvicorn.run(agent.get_app(), host="0.0.0.0", port=8000)

{smarta2a-0.2.4 → smarta2a-0.2.5}/smarta2a/model_providers/openai_provider.py

@@ -28,13 +28,17 @@ class OpenAIProvider(BaseLLMProvider):
         self.supported_media_types = [
             "image/png", "image/jpeg", "image/gif", "image/webp"
         ]
-        # Initialize ToolsManager and load MCP tools if given
+        # Initialize ToolsManager 
         self.tools_manager = ToolsManager()
-        if mcp_server_urls_or_paths:
-            self.tools_manager.load_mcp_tools(mcp_server_urls_or_paths)
         
-        if agent_cards:
-            self.tools_manager.load_a2a_tools(agent_cards)
+    
+    async def load(self):
+        if self.mcp_server_urls_or_paths:
+            await self.tools_manager.load_mcp_tools(self.mcp_server_urls_or_paths)
+        
+        if self.agent_cards:
+            await self.tools_manager.load_a2a_tools(self.agent_cards)
+    
 
     def _build_system_prompt(self) -> str:
         """Get the system prompt with tool descriptions."""
@@ -80,12 +84,11 @@ class OpenAIProvider(BaseLLMProvider):
         """Convert messages to OpenAI format with system prompt"""
         openai_messages = []
         
-        # Add system prompt if provided
-        if self.system_prompt:
-            openai_messages.append({
-                "role": "system",
-                "content": self._build_system_prompt()
-            })
+        # Add system prompt
+        openai_messages.append({
+            "role": "system",
+            "content": self._build_system_prompt()
+        })
         
         # Process user-provided messages
         for msg in messages:
@@ -124,22 +127,22 @@ class OpenAIProvider(BaseLLMProvider):
                 "function": {
                     "name": tool.name,
                     "description": tool.description,
-                    "parameters": tool.input_schema
+                    "parameters": tool.inputSchema
                 }
             })
         return openai_tools
 
 
-    async def generate(self, messages: List[Message], **kwargs) -> str:
+    async def generate(self, messages: List[Dict[str, Any]], **kwargs) -> str:
         """
         Generate a complete response, invoking tools as needed.
         """
-        # Convert incoming messages with dynamic system prompt
+        # Ensure messages are Message objects
+        messages = [msg if isinstance(msg, Message) else Message(**msg) for msg in messages]
         converted_messages = self._convert_messages(messages)
         max_iterations = 10
 
-        for _ in range(max_iterations):
-            # Call OpenAI chat completion with available tools
+        for iteration in range(max_iterations):
             response = await self.client.chat.completions.create(
                 model=self.model,
                 messages=converted_messages,
@@ -148,47 +151,51 @@ class OpenAIProvider(BaseLLMProvider):
             )
             message = response.choices[0].message
 
-            # If the assistant didn't call a tool, return its content
-            if not hasattr(message, 'tool_calls') or not message.tool_calls:
+            # Detect and extract the tool/function call
+            if getattr(message, 'function_call', None):
+                name = message.function_call.name
+                args_raw = message.function_call.arguments
+            elif getattr(message, 'tool_calls', None):
+                tc = message.tool_calls[0]
+                name = tc.function.name
+                args_raw = tc.function.arguments
+            else:
                 return message.content
 
-            # Append assistant's tool call to the conversation
+            # Append the assistant's intent
             converted_messages.append({
                 "role": "assistant",
-                "content": message.content,
-                "tool_calls": [
-                    {"id": tc.id,
-                     "type": "function",
-                     "function": {"name": tc.function.name,
-                                   "arguments": tc.function.arguments}
-                    }
-                    for tc in message.tool_calls
-                ]
+                "content": None,
+                "function_call": {"name": name, "arguments": args_raw}
             })
 
-            # Process each tool call sequentially
-            for tc in message.tool_calls:
-                tool_name = tc.function.name
-                # Parse arguments
-                try:
-                    tool_args = json.loads(tc.function.arguments)
-                except json.JSONDecodeError:
-                    tool_args = {}
+            # Parse arguments safely
+            try:
+                args = json.loads(args_raw or '{}')
+            except json.JSONDecodeError:
+                args = {}
 
-                # Execute the tool via the ToolsManager
-                try:
-                    result = await self.tools_manager.call_tool(tool_name, tool_args)
-                    result_content = result.content
-                except Exception as e:
-                    result_content = f"Error executing {tool_name}: {e}"
+            # Call the tool manager with name and parsed args
+            try:
+                tool_result = await self.tools_manager.call_tool(name, args)
+            except Exception as e:
+                tool_result = {"content": f"Error calling {name}: {e}"}
+
+            # Extract content
+            if hasattr(tool_result, 'content'):
+                result_content = tool_result.content
+            elif isinstance(tool_result, dict) and 'content' in tool_result:
+                result_content = tool_result['content']
+            else:
+                result_content = str(tool_result)
+
+            # Append the function/tool's response
+            converted_messages.append({
+                "role": "function",
+                "name": name,
+                "content": result_content
+            })
 
-                # Append the tool response into the conversation
-                converted_messages.append({
-                    "role": "tool",
-                    "content": result_content,
-                    "tool_call_id": tc.id
-                })
-        # If max iterations reached without a final response
         raise RuntimeError("Max tool iteration depth reached in generate().")
 
 

{smarta2a-0.2.4 → smarta2a-0.2.5}/smarta2a/server/server.py

@@ -83,6 +83,9 @@ class SmartA2A:
     # Add this method to delegate ASGI calls
     async def __call__(self, scope, receive, send):
         return await self.app(scope, receive, send)
+    
+    def on_event(self, event_name: str):
+        return self.app.on_event(event_name) 
         
     def on_send_task(self):
         def decorator(func: Callable[[SendTaskRequest, Optional[StateData]], Any]) -> Callable:
@@ -150,9 +153,9 @@ class SmartA2A:
             if method == "tasks/send":
                 state_data = self.state_mgr.init_or_get(params.get("sessionId"), params.get("message"), params.get("metadata") or {})
                 if state_store:
-                    return self._handle_send_task(request, state_data)
+                    return await self._handle_send_task(request, state_data)
                 else:
-                    return self._handle_send_task(request)
+                    return await self._handle_send_task(request)
             elif method == "tasks/sendSubscribe":
                 state_data = self.state_mgr.init_or_get(params.get("sessionId"), params.get("message"), params.get("metadata") or {})
                 if state_store:
@@ -176,7 +179,7 @@ class SmartA2A:
             return JSONRPCResponse(id=request.id, error=err).model_dump()
 
 
-    def _handle_send_task(self, request_data: JSONRPCRequest, state_data: Optional[StateData] = None) -> SendTaskResponse:
+    async def _handle_send_task(self, request_data: JSONRPCRequest, state_data: Optional[StateData] = None) -> SendTaskResponse:
         try:
             # Validate request format
             request = SendTaskRequest.model_validate(request_data.model_dump())
@@ -203,9 +206,9 @@ class SmartA2A:
             try:
 
                 if state_data:
-                    raw_result = handler(request, state_data)
+                    raw_result = await handler(request, state_data)
                 else:
-                    raw_result = handler(request)
+                    raw_result = await handler(request)
 
                 # Handle direct SendTaskResponse returns
                 if isinstance(raw_result, SendTaskResponse):
@@ -513,7 +516,6 @@ class SmartA2A:
                         task_id=request.params.id,
                         metadata=getattr(raw_result, "metadata", {}) or {}
                     )
-                    print(task)
 
                 # Final validation and packaging
                 return self._finalize_cancel_response(request, task)

{smarta2a-0.2.4 → smarta2a-0.2.5}/smarta2a/utils/types.py

@@ -57,7 +57,7 @@ Part = Annotated[Union[TextPart, FilePart, DataPart], Field(discriminator="type"
 
 
 class Message(BaseModel):
-    role: Literal["user", "agent", "system"] # Added system role for system messages
+    role: Literal["user", "agent", "system", "tool"] # Added system role for system messages
     parts: List[Part]
     metadata: dict[str, Any] | None = None
 

smarta2a-0.2.4/examples/__init__.py

@@ -1,3 +0,0 @@
-"""
-Example implementations using the SmartA2A framework.
-""" 

smarta2a-0.2.4/examples/agents/__init__.py

@@ -1,3 +0,0 @@
-"""
-Example agent implementations.
-"""