smarta2a 0.2.5__py3-none-any.whl → 0.3.1__py3-none-any.whl

smarta2a/client/a2a_client.py

@@ -4,7 +4,8 @@ import httpx
 import json
 from httpx_sse import connect_sse
 from inspect import signature, Parameter, iscoroutinefunction
-from pydantic import create_model, Field, BaseModel
+from pydantic import create_model, Field, BaseModel, ValidationError
+from typing import Optional, Union
 
 # Local imports
 from smarta2a.utils.types import (
@@ -182,86 +183,119 @@ class A2AClient:
     
 
     async def list_tools(self) -> list[dict[str, Any]]:
-        """Return metadata for all available tools."""
+        """Return metadata for all available tools with minimal inputSchema."""
         tools = []
-        tool_names = [
-            'send'
-        ]
+        tool_names = ['send']  # add other tool names here
         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():
+            properties: dict[str, Any] = {}
+            required: list[str] = []
+            for param_name, param in sig.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
+                
+                ann = param.annotation
                 default = param.default
+                
+                # Handle Literal types
+                if get_origin(ann) is Literal:
+                    enum_vals = list(get_args(ann))
+                    schema_field: dict[str, Any] = {
+                        "title": param_name.replace('_', ' ').title(),
+                        "enum": enum_vals
+                    }
+                    # For Literals we'd typically not mark required if there's a default
+                else:
+                    # map basic Python types to JSON Schema types
+                    type_map = {
+                        str: "string",
+                        int: "integer",
+                        float: "number",
+                        bool: "boolean",
+                        dict: "object",
+                        list: "array",
+                        Any: None
+                    }
+                    json_type = type_map.get(ann, None)
+                    schema_field = {"title": param_name.replace('_', ' ').title()}
+                    if json_type:
+                        schema_field["type"] = json_type
+                
+                # default vs required
                 if default is Parameter.empty:
                     required.append(param_name)
-                    field = Field(...)
+                    # no default key
                 else:
-                    field = Field(default=default)
-                fields[param_name] = (annotation, field)
-            
-            # Create dynamic Pydantic model
-            model = create_model(f"{name}_Input", **fields)
-            schema = model.schema()
+                    schema_field["default"] = default
+                
+                properties[param_name] = schema_field
             
+            inputSchema = {
+                "title": f"{name}_Arguments",
+                "type": "object",
+                "properties": properties,
+                "required": required,
+            }
+
             tools.append({
-                'name': name,
-                'description': description,
-                'inputSchema': schema
+                "name": name,
+                "description": description,
+                "inputSchema": inputSchema
             })
+
         return tools
 
     async def call_tool(self, tool_name: str, arguments: dict[str, Any]) -> Any:
         """Call a tool by name with validated arguments."""
+        # 1) lookup
         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
+
+        # 2) build a minimal pydantic model for validation
         sig = signature(method)
-        parameters = sig.parameters
-        
-        fields = {}
-        for param_name, param in parameters.items():
+        model_fields: dict[str, tuple] = {}
+
+        for param_name, param in sig.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)
+
+            # annotation
+            ann = param.annotation
+            if ann is Parameter.empty:
+                ann = Any
+
+            # default
             default = param.default
             if default is Parameter.empty:
-                fields[param_name] = (annotation, Field(...))
+                # required field
+                model_fields[param_name] = (ann, 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
+                # optional field: if default is None, widen annotation
+                if default is None and get_origin(ann) is not Union:
+                    ann = Optional[ann]
+                model_fields[param_name] = (ann, Field(default=default))
+
+        ValidationModel = create_model(
+            f"{tool_name}_ValidationModel",
+            **model_fields
+        )
+
+        # 3) validate (will raise ValidationError on bad args)
+        try:
+            validated = ValidationModel(**arguments)
+        except ValidationError as e:
+            # re-raise or wrap as you like
+            raise ValueError(f"Invalid arguments for tool {tool_name}: {e}") from e
+
+        validated_args = validated.dict()
+
+        # 4) call
         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/mcp_client.py

@@ -1,5 +1,6 @@
 # Library imports
 import re
+import shlex
 from typing import Dict, Any
 from contextlib import AsyncExitStack
 from mcp import ClientSession, StdioServerParameters
@@ -40,6 +41,7 @@ class MCPClient:
         if server_script_path.startswith("@") or "/" not in server_script_path:
             # Assume it's an npm package
             is_javascript = True
+            args = shlex.split(server_script_path)
             command = "npx"
         else:
             # It's a file path
@@ -55,6 +57,7 @@ class MCPClient:
             args=args,
             env=None
         )
+        print(server_params)
 
         # Start the server
         stdio_transport = await self.exit_stack.enter_async_context(stdio_client(server_params))

smarta2a/client/tools_manager.py

@@ -5,7 +5,7 @@ from typing import List, Dict, Any, Union, Literal
 # Local imports
 from smarta2a.client.mcp_client import MCPClient
 from smarta2a.client.a2a_client import A2AClient
-from smarta2a.utils.types import AgentCard
+from smarta2a.utils.types import AgentCard, Tool
 
 class ToolsManager:
     """
@@ -21,16 +21,28 @@ class ToolsManager:
             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
+                # Generate key and ensure Tool type with key
+                key = f"mcp---{tool.name}"
+                validated_tool = Tool(
+                    key=key,
+                    **tool.model_dump()  # Pydantic 2.x syntax (use .dict() for Pydantic 1.x)
+                )
+                self.tools_list.append(validated_tool)
+                self.clients[key] = mcp_client
 
     async def load_a2a_tools(self, agent_cards: List[AgentCard]) -> None:
         for agent_card in agent_cards:
             a2a_client = A2AClient(agent_card)
-            tools = await a2a_client.list_tools()
-            for tool in tools:
-                self.tools_list.append(tool)
-                self.clients[tool.name] = a2a_client
+            tools_list = await a2a_client.list_tools()
+            for tool_dict in tools_list:
+                # Generate key from agent URL and tool name
+                key = f"{agent_card.name}---{tool_dict['name']}"
+                validated_tool = Tool(
+                    key=key,
+                    **tool_dict
+                )
+                self.tools_list.append(validated_tool)
+                self.clients[key] = a2a_client
 
     def get_tools(self) -> List[Any]:
         return self.tools_list
@@ -42,20 +54,24 @@ class ToolsManager:
             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```"
+                    f"- **{tool.key}**: {tool.description}\n  Parameters schema:\n  ```json\n{schema}\n```"
                 )
             elif client_type == "a2a":
                 lines.append(
-                    f"- **{tool.name}**: {tool.description}\n  Parameters schema:\n  ```json\n{schema}\n```"
+                    f"- **{tool.key}**: {tool.description}\n  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)
+    def get_client(self, tool_key: str) -> Any:
+        return self.clients.get(tool_key)
 
-    async def call_tool(self, tool_name: str, args: Dict[str, Any]) -> Any:
-        client = self.get_client(tool_name)
+    async def call_tool(self, tool_key: str, args: Dict[str, Any]) -> Any:
+        client = self.get_client(tool_key)
+        tool_name = self._get_tool_name(tool_key)
         if not client:
             raise ValueError(f"Tool not found: {tool_name}")
-        return await client.call_tool(tool_name, args)
+        return await client.call_tool(tool_name, args)
+    
+    def _get_tool_name(self, tool_key: str) -> str:
+        return tool_key.split("---")[1]

smarta2a/examples/openai_airbnb_agent/main.py

@@ -0,0 +1,33 @@
+# Imports
+from dotenv import load_dotenv
+import os
+import uvicorn
+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",
+    base_system_prompt="You are a cheerful assistant that specialises in helping with airbnb related queries",
+    mcp_server_urls_or_paths=["@openbnb/mcp-server-airbnb --ignore-robots-txt"]
+)
+# /Users/apple/.npm/_npx/1629930a2e066932/node_modules/@openbnb/mcp-server-airbnb/dist/index.js
+
+# 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=8002)

smarta2a/examples/openai_delegator_agent/main.py

@@ -0,0 +1,51 @@
+# Imports
+from dotenv import load_dotenv
+import os
+import uvicorn
+from smarta2a.agent.a2a_agent import A2AAgent
+from smarta2a.model_providers.openai_provider import OpenAIProvider
+from smarta2a.utils.types import AgentCard, AgentCapabilities, AgentSkill
+
+
+# Load environment variables from the .env file
+load_dotenv()
+
+# Fetch the value using os.getenv
+api_key = os.getenv("OPENAI_API_KEY")
+
+weather_agent_card = AgentCard(
+    name="weather_agent",
+    description="A weather agent that can help with weather related queries",
+    version="0.1.0",
+    url="http://localhost:8000",
+    capabilities=AgentCapabilities(),
+    skills=[AgentSkill(id="weather_forecasting", name="Weather Forecasting", description="Can get weather forecast for a given latitude and longitude"),
+            AgentSkill(id="weather_alerts", name="Weather Alerts", description="Can get weather alerts for a US state")]
+)
+
+airbnb_agent_card = AgentCard(
+    name="airbnb_agent",
+    description="An airbnb agent that can help with airbnb related queries",
+    version="0.1.0",
+    url="http://localhost:8002",
+    capabilities=AgentCapabilities(),
+    skills=[AgentSkill(id="search_listings", name="Search listings", description="Search for Airbnb listings by location, dates, guests, and more"),
+            AgentSkill(id="get_listing_details", name="Get listing details", description="Get detailed information about a specific Airbnb listing by listing id, dates, guests, and more")]
+)
+
+
+openai_provider = OpenAIProvider(
+    api_key=api_key,
+    model="gpt-4o-mini",
+    agent_cards=[weather_agent_card, airbnb_agent_card]
+)
+
+# 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=8001)

smarta2a/examples/{openai_agent → openai_weather_agent}/main.py

@@ -2,7 +2,6 @@
 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
 
@@ -18,6 +17,7 @@ api_key = os.getenv("OPENAI_API_KEY")
 openai_provider = OpenAIProvider(
     api_key=api_key,
     model="gpt-4o-mini",
+    base_system_prompt="You are a cheerful assistant that specialises in helping with weather related queries",
     mcp_server_urls_or_paths=["/Users/apple/Desktop/Code/weather/weather.py"],
 )
 

smarta2a/model_providers/openai_provider.py

@@ -125,7 +125,7 @@ class OpenAIProvider(BaseLLMProvider):
             openai_tools.append({
                 "type": "function",
                 "function": {
-                    "name": tool.name,
+                    "name": tool.key,
                     "description": tool.description,
                     "parameters": tool.inputSchema
                 }
@@ -140,7 +140,7 @@ class OpenAIProvider(BaseLLMProvider):
         # 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
+        max_iterations = 30
 
         for iteration in range(max_iterations):
             response = await self.client.chat.completions.create(
@@ -161,7 +161,7 @@ class OpenAIProvider(BaseLLMProvider):
                 args_raw = tc.function.arguments
             else:
                 return message.content
-
+            print(message)
             # Append the assistant's intent
             converted_messages.append({
                 "role": "assistant",

smarta2a/utils/types.py

@@ -482,3 +482,9 @@ class StateData(BaseModel):
     sessionId: str
     history: List[Message]
     metadata: Dict[str, Any]
+
+class Tool(BaseModel):
+    key: str
+    name: str
+    description: str
+    inputSchema: Dict[str, Any]

smarta2a-0.3.1.dist-info/METADATA

@@ -0,0 +1,399 @@
+Metadata-Version: 2.4
+Name: smarta2a
+Version: 0.3.1
+Summary: a Python framework that helps you build servers and AI agents that communicate using the A2A 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>
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+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
+
+<picture>
+  <img alt="SmartA2A Logo" src="documentation/smarta2a_docs/smarta2a_small_banner.png" width="100%">
+</picture>
+
+<div>
+<br>
+</div>
+
+![PyPI](https://img.shields.io/pypi/v/Smarta2a.svg)
+![Downloads](https://static.pepy.tech/badge/Smarta2a)
+![GitHub Repo stars](https://img.shields.io/github/stars/siddharthsma/smarta2a?style=social)
+
+**SmartA2A** is a Python framework that helps you build servers and AI agents that communicate using the [A2A (Agent2Agent) protocol](https://developers.googleblog.com/en/a2a-a-new-era-of-agent-interoperability/). A2A defines a common language that enables agents to exchange information and collaborate effectively across systems.
+
+SmartA2A abstracts the complexities of the protocol, so you can focus on what matters—your agent's logic and behavior. It supports two primary use cases:
+
+### ✅ 1. Build A2A-Compliant Servers
+
+Use SmartA2A to expose key A2A methods through a simple decorator-based API. This allows you to:
+
+- Build compliant server endpoints quickly
+- Integrate your own agent logic using any framework (e.g., LangGraph, Google ADK, or custom code)
+- Stay fully aligned with the A2A spec without boilerplate
+
+### 🤖 2. Create Full-Fledged Agents with Minimal Code
+
+SmartA2A can also be used to create standalone agents that:
+
+- Speak the A2A protocol out of the box
+- Collaborate with other agents seamlessly
+- Connect to any MCP server you choose
+- Require only a few lines of setup
+
+SmartA2A makes it easy to build interoperable, communication-ready AI systems—whether you're extending existing frameworks or starting from scratch.
+
+---
+
+## Installation
+
+```bash
+pip install -U smarta2a
+```
+
+## Examples
+
+There are 3 cool examples for you to try out - eacher cooler than the next! 
+
+1. The first is a simple Echo server implementation that demonstrates the FastAPI'esk style in which you can create a A2A compliant server. If you're using another Agent framework like LangGraph you can easily use it it tandem with this server.  
+
+2. This is where things start to get real interesting - you can easily create an LLM and MCP powered Agent in just a few lines of code. In this case a US weather agent.
+
+3. If you get here, this is where things things start to get really awesome. You will create a multi-agent system where a delegator agent delelgates tasks to the weather agent you created before and to an Airbnb agent. You can now plan your stay based on the weather!
+
+Note that you can find all the examples in the examples folder.
+
+### Simple Echo Server Implementation
+
+Here's a simple example of an echo server that demonstrates the core features of SmartA2A:
+
+```python
+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
+
+# Initialize the server with an in-memory state store
+state_store = InMemoryStateStore()
+app = SmartA2A("EchoServer", state_store=state_store)
+
+@app.on_send_task()
+async def handle_task(request, state):
+    """Echo the input text back as a completed task. If you were using something like LangGraph you could call your graph.invoke method here """
+    input_text = request.content[0].text
+    return f"Response to task: {input_text}"
+
+@app.on_send_subscribe_task()
+async def handle_subscribe_task(request, state):
+    """Subscribe to the task and stream multiple responses"""
+    input_text = request.content[0].text
+    yield f"First response to the task: {input_text}"
+    yield f"Second response to the task: {input_text}"
+    yield f"Third response to the task: {input_text}"
+
+@app.task_get()
+def handle_get_task(request):
+    """Get the task status"""
+    return f"Task: {request.id}"
+
+@app.task_cancel()
+def handle_cancel_task(request):
+    """Cancel the task"""
+    return f"Task cancelled: {request.id}"
+```
+
+This example shows:
+- Setting up a basic A2A server with state management
+- Handling synchronous task requests with text and file responses
+- Implementing streaming responses for subscription tasks
+- Basic task management (get and cancel operations)
+
+To run the echo server:
+```bash
+uvicorn path.to.echo_server.main.py:app
+```
+
+You can test the echo server using curl commands:
+
+```bash
+# Test sending a task
+curl -X POST http://localhost:8000/ \
+  -H "Content-Type: application/json" \
+  -d '{
+    "jsonrpc": "2.0",
+    "id": "1",
+    "method": "tasks/send",
+    "params": {
+      "id": "task1",
+      "message": {
+        "role": "user",
+        "parts": [{"type": "text", "text": "Hello, echo server!"}]
+      }
+    }
+  }'
+
+# Test subscribing to a task
+curl -X POST http://localhost:8000/ \
+  -H "Content-Type: application/json" \
+  -d '{
+    "jsonrpc": "2.0",
+    "id": "2",
+    "method": "tasks/sendSubscribe",
+    "params": {
+      "id": "task2",
+      "message": {
+        "role": "user",
+        "parts": [{"type": "text", "text": "Hello, streaming echo!"}]
+      }
+    }
+  }'
+```
+
+### Weather Agent Example
+
+Here's an example of a weather agent that uses OpenAI's GPT model to handle weather-related queries. Note that you will need to setup the weather MCP server as a pre-requisite as specified by the [MCP Quick-start server tutorial](https://modelcontextprotocol.io/quickstart/server). You will also need to add your OpenAI API key to the .env file.
+
+```python
+from dotenv import load_dotenv
+import os
+import uvicorn
+from smarta2a.agent.a2a_agent import A2AAgent
+from smarta2a.model_providers.openai_provider import OpenAIProvider
+
+# Load environment variables from the .env file
+load_dotenv()
+
+# Initialize OpenAI provider with weather-specific configuration
+openai_provider = OpenAIProvider(
+    api_key=os.getenv("OPENAI_API_KEY"),
+    model="gpt-4o-mini",
+    base_system_prompt="You are a cheerful assistant that specialises in helping with weather related queries",
+    mcp_server_urls_or_paths=["/path/to/weather.py"],  # Path to your weather service
+)
+
+# Create and run the agent
+agent = A2AAgent(
+    name="openai_agent",
+    model_provider=openai_provider,
+)
+
+if __name__ == "__main__":
+    uvicorn.run(agent.get_app(), host="0.0.0.0", port=8000)
+```
+
+This example demonstrates:
+- Setting up an AI agent with OpenAI integration
+- Configuring a specialized system prompt for weather queries
+- Connecting to external weather services via MCP
+- Running the agent as a standalone server
+
+To run the weather agent:
+```bash
+python path/to/weather_agent/main.py
+```
+
+To test the weather agent, ensure:
+1. Your weather MCP server is running
+2. Your OpenAI API key is set in the .env file
+3. The agent is running as shown above
+
+Then test it with curl:
+
+```bash
+# Test weather query
+curl -X POST http://localhost:8000/ \
+  -H "Content-Type: application/json" \
+  -d '{
+    "jsonrpc": "2.0",
+    "id": "1",
+    "method": "tasks/send",
+    "params": {
+      "id": "weather1",
+      "message": {
+        "role": "user",
+        "parts": [{"type": "text", "text": "What is the weather in New York?"}]
+      }
+    }
+  }'
+```
+
+### Multi-agent Weather-Aware Stay Planner
+
+This example demonstrates how to create a multi-agent system where a delegator agent coordinates between a weather agent and an Airbnb agent to help plan stays based on weather conditions. You'll need to run three agents:
+
+1. The weather agent (from the previous example)
+2. An Airbnb agent that connects to the Airbnb MCP server
+3. A delegator agent that coordinates between them
+
+First, let's create the Airbnb agent:
+
+```python
+from dotenv import load_dotenv
+import os
+import uvicorn
+from smarta2a.agent.a2a_agent import A2AAgent
+from smarta2a.model_providers.openai_provider import OpenAIProvider
+
+# Load environment variables
+load_dotenv()
+
+# Initialize OpenAI provider with Airbnb-specific configuration
+openai_provider = OpenAIProvider(
+    api_key=os.getenv("OPENAI_API_KEY"),
+    model="gpt-4o-mini",
+    base_system_prompt="You are a cheerful assistant that specialises in helping with Airbnb related queries",
+    mcp_server_urls_or_paths=["@openbnb/mcp-server-airbnb --ignore-robots-txt"]
+)
+
+# Create and run the Airbnb agent
+agent = A2AAgent(
+    name="airbnb_agent",
+    model_provider=openai_provider,
+)
+
+if __name__ == "__main__":
+    uvicorn.run(agent.get_app(), host="0.0.0.0", port=8002)
+```
+
+Now, let's create the delegator agent that coordinates between the weather and Airbnb agents:
+
+```python
+from dotenv import load_dotenv
+import os
+import uvicorn
+from smarta2a.agent.a2a_agent import A2AAgent
+from smarta2a.model_providers.openai_provider import OpenAIProvider
+from smarta2a.utils.types import AgentCard, AgentCapabilities, AgentSkill
+
+# Load environment variables
+load_dotenv()
+
+# Define the weather agent's capabilities
+weather_agent_card = AgentCard(
+    name="weather_agent",
+    description="A weather agent that can help with weather related queries",
+    version="0.1.0",
+    url="http://localhost:8000",
+    capabilities=AgentCapabilities(),
+    skills=[
+        AgentSkill(
+            id="weather_forecasting",
+            name="Weather Forecasting",
+            description="Can get weather forecast for a given location"
+        ),
+        AgentSkill(
+            id="weather_alerts",
+            name="Weather Alerts",
+            description="Can get weather alerts for a US state"
+        )
+    ]
+)
+
+# Define the Airbnb agent's capabilities
+airbnb_agent_card = AgentCard(
+    name="airbnb_agent",
+    description="An Airbnb agent that can help with accommodation queries",
+    version="0.1.0",
+    url="http://localhost:8002",
+    capabilities=AgentCapabilities(),
+    skills=[
+        AgentSkill(
+            id="search_listings",
+            name="Search Listings",
+            description="Search for Airbnb listings by location, dates, and guests"
+        ),
+        AgentSkill(
+            id="get_listing_details",
+            name="Get Listing Details",
+            description="Get detailed information about specific Airbnb listings"
+        )
+    ]
+)
+
+# Initialize OpenAI provider with both agent cards
+openai_provider = OpenAIProvider(
+    api_key=os.getenv("OPENAI_API_KEY"),
+    model="gpt-4o-mini",
+    agent_cards=[weather_agent_card, airbnb_agent_card]
+)
+
+# Create and run the delegator agent
+agent = A2AAgent(
+    name="delegator_agent",
+    model_provider=openai_provider,
+)
+
+if __name__ == "__main__":
+    uvicorn.run(agent.get_app(), host="0.0.0.0", port=8001)
+```
+
+To run the multi-agent system:
+
+1. Start the weather agent:
+```bash
+python path/to/weather_agent/main.py
+```
+
+2. Start the Airbnb agent: No need to do anything - just ensure that node and npx are installed on your machine
+
+
+3. Start the delegator agent:
+```bash
+python path/to/delegator_agent/main.py
+```
+
+You can then test the system with a curl command:
+
+```bash
+# Test multi-agent planning
+curl -X POST http://localhost:8001/ \
+  -H "Content-Type: application/json" \
+  -d '{
+    "jsonrpc": "2.0",
+    "id": "1",
+    "method": "tasks/send",
+    "params": {
+      "id": "plan1",
+      "message": {
+        "role": "user",
+        "parts": [{"type": "text", "text": "I want to go someplace sunny in California. Just me and my wife. Can you check the weather forecast in the major cities and give me some airbnb recommendations that are appropriate. I want to stay from the 7th of May and checking out on the 10th of May. I'm not fussed about the budget."}]
+      }
+    }
+  }'
+```
+
+This example demonstrates:
+- Creating specialized agents for different domains (weather and Airbnb)
+- Defining agent capabilities and skills using AgentCard
+- Setting up a delegator agent that can coordinate between multiple agents
+- Running multiple agents on different ports
+- Making complex queries that require coordination between agents
+
+---
+
+## Roadmap
+
+There's still a lot more to come ...
+
+- Documentation site with tutorials, explanation of concepts, blog and a contribution guide
+- Support for more LLM providers
+- Support for more memory types
+- Authorization and observability framework built-in
+- Many more !
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details. 

{smarta2a-0.2.5.dist-info → smarta2a-0.3.1.dist-info}/RECORD

@@ -3,21 +3,25 @@ smarta2a/agent/a2a_agent.py,sha256=zk6ZZtq4HrnKMDuZKnQPeKploV1IGXSZ1WmVPdIZAeY,1
 smarta2a/agent/a2a_mcp_server.py,sha256=X_mxkgYgCA_dSNtCvs0rSlOoWYc-8d3Qyxv0e-a7NKY,1015
 smarta2a/archive/smart_mcp_client.py,sha256=NjyMR8xvrhy0-iFamj2XQnKp5qzkkFya7EQY4Kzl5dw,2574
 smarta2a/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-smarta2a/client/a2a_client.py,sha256=Ulrfl_vaGsig5UmPrkPfKJs-I7f0m8Bs5U7g0kkvhMM,9895
-smarta2a/client/mcp_client.py,sha256=ANjEzQFXEhKGQtNC9AjLI_IFtjv5twCCQhcB0TrwUpc,3534
-smarta2a/client/tools_manager.py,sha256=IvkjNoa2vSUP3l2Bz87EGH9My30zErpD2HE-KPyThVI,2273
+smarta2a/client/a2a_client.py,sha256=5WIincf_6Nqh61_x3f0NYUSLXlGztlnzUpo0m6ch_j0,11038
+smarta2a/client/mcp_client.py,sha256=PM4D1CgOycxK5kJEJTGpKq0eXFjZ69-2720TuRUkyGc,3627
+smarta2a/client/tools_manager.py,sha256=JDD2lqcDe70JVHlPoRU5oHzUYcZUkH5QzjtEkWYfrrA,2970
 smarta2a/examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 smarta2a/examples/echo_server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 smarta2a/examples/echo_server/curl.txt,sha256=MYBbAgrU3PeCsksrrBc0xgaTD5Dro7xiTsCUz8Ocvt8,247
 smarta2a/examples/echo_server/main.py,sha256=i_XLQbRAv6XxkJX0vLV3CxHNANG41yAxgP-V-b4Iysc,1261
-smarta2a/examples/openai_agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-smarta2a/examples/openai_agent/main.py,sha256=TCKqm2YSAdXtuFBhHNbqC-JKllXEJazVhmibqPZZ3FY,699
+smarta2a/examples/openai_airbnb_agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+smarta2a/examples/openai_airbnb_agent/main.py,sha256=CaIYi-LQD32Rm_BsXI7sLfFqx_kMpl0k8zCayFB4068,892
+smarta2a/examples/openai_delegator_agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+smarta2a/examples/openai_delegator_agent/main.py,sha256=zP6YOMxTBLfMtrZOPwPLQhSVodULbDkCCAy4pB4ltto,1805
+smarta2a/examples/openai_weather_agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+smarta2a/examples/openai_weather_agent/main.py,sha256=o8QqLu9JC3zRXRPGWhYdd7mVl3ooys5UwkPCPv2JHmQ,796
 smarta2a/history_update_strategies/__init__.py,sha256=x5WtiE9rG5ze8d8hA6E6wJOciBhWHa_ZgGgoIAZcXEQ,213
 smarta2a/history_update_strategies/append_strategy.py,sha256=j7Qbhs69Wwr-HBLB8GJ3-mEPaBSHiBV2xz9ZZi86k2w,312
 smarta2a/history_update_strategies/history_update_strategy.py,sha256=n2sfIGu8ztKI7gJTwRX26m4tZr28B8Xdhrk6RlBFlI8,373
 smarta2a/model_providers/__init__.py,sha256=2FhblAUiwG9Xv27yEpuuz0VrnIZ-rlpgIuPwm-UIX5U,147
 smarta2a/model_providers/base_llm_provider.py,sha256=6QjTUjYEnvHZji4_VWZz6CvLYKLyutxRUfIeH3seQg4,424
-smarta2a/model_providers/openai_provider.py,sha256=Xk2d5L9PbOs4NRjWMxDVdTNqy88YTeeMpW6Wox_Rffw,10845
+smarta2a/model_providers/openai_provider.py,sha256=yTiBVJfEFOTSQsVj8mNx5qVZWvOvslYvw7TQ0tLLf7U,10870
 smarta2a/server/__init__.py,sha256=f2X454Ll4vJc02V4JLJHTN-h8u0TBm4d_FkiO4t686U,53
 smarta2a/server/handler_registry.py,sha256=OVRG5dTvxB7qUNXgsqWxVNxIyRljUShSYxb1gtbi5XM,820
 smarta2a/server/server.py,sha256=WJGQVOprF2Hh_036eW4GJrRr3fLC0S_B3dAfONCgZrs,32180
@@ -31,8 +35,8 @@ smarta2a/utils/__init__.py,sha256=5db5VgDGgbMUGEF-xuyaC3qrgRQkUE9WAITkFSiNqSA,70
 smarta2a/utils/prompt_helpers.py,sha256=jLETieoeBJLQXcGzwFeoKT5b2pS4tJ5770lPLImtKLo,1439
 smarta2a/utils/task_builder.py,sha256=wqSyfVHNTaXuGESu09dhlaDi7D007gcN3-8tH-nPQ40,5159
 smarta2a/utils/task_request_builder.py,sha256=6cOGOqj2Rg43xWM03GRJQzlIZHBptsMCJRp7oD-TDAQ,3362
-smarta2a/utils/types.py,sha256=ASHXmgJ634s2Qy65YSATEe7lqweyWMHarcXMDOIx4sY,13086
-smarta2a-0.2.5.dist-info/METADATA,sha256=ECE4bZ4faHmvA_VKeavBvNp8MumUltkclMN1NATyP8k,2726
-smarta2a-0.2.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-smarta2a-0.2.5.dist-info/licenses/LICENSE,sha256=ECMEVHuFkvpEmH-_A9HSxs_UnnsUqpCkiAYNHPCf2z0,1078
-smarta2a-0.2.5.dist-info/RECORD,,
+smarta2a/utils/types.py,sha256=h4bQw_RmeJCDq022aEd9XJZhNpJOydhV40tqERvLeQE,13190
+smarta2a-0.3.1.dist-info/METADATA,sha256=Z2Z6w1tr9o6bkmxplJ4OeG5CZ7RAk9RIjkf1CYnuwfY,13005
+smarta2a-0.3.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+smarta2a-0.3.1.dist-info/licenses/LICENSE,sha256=ECMEVHuFkvpEmH-_A9HSxs_UnnsUqpCkiAYNHPCf2z0,1078
+smarta2a-0.3.1.dist-info/RECORD,,

smarta2a-0.2.5.dist-info/METADATA

@@ -1,103 +0,0 @@
-Metadata-Version: 2.4
-Name: smarta2a
-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
-Author-email: Siddharth Ambegaonkar <siddharthsma@gmail.com>
-License-File: LICENSE
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.8
-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
-
-A Python package for creating a server following Google's Agent2Agent protocol
-
-## Features
-
-✅ **Full A2A Protocol Compliance** - Implements all required endpoints and response formats
-
-⚡ **Decorator-Driven Development** - Rapid endpoint configuration with type safety
-
-🧩 **Automatic Protocol Conversion** - Simple returns become valid A2A responses 
-
-🔀 **Flexible Response Handling** - Support for Tasks, Artifacts, Streaming, and raw protocol types if needed!
-
-🛡️ **Built-in Validation** - Automatic Pydantic validation of A2A schemas  
-
-⚡ **Single File Setup** - Get compliant in <10 lines of code
-
-🌍 **Production Ready** - CORS, async support, and error handling included
-
-## Installation
-
-```bash
-pip install smarta2a
-```
-
-## Simple Echo Server Implementation
-
-```python
-from smarta2a.server import SmartA2A
-
-app = SmartA2A("EchoServer")
-
-@app.on_send_task()
-def handle_task(request):
-    """Echo the input text back as a completed task"""
-    input_text = request.content[0].text
-    return f"Echo: {input_text}"
-
-if __name__ == "__main__":
-    app.run()
-```
-
-Automatically contructs the response:
-
-```json
-{
-  "jsonrpc": "2.0",
-  "id": "test",
-  "result": {
-    "id": "echo-task",
-    "status": {"state": "completed"},
-    "artifacts": [{
-      "parts": [{"type": "text", "text": "Echo: Hello!"}]
-    }]
-  }
-}
-```
-
-## Development
-
-To set up the development environment:
-
-```bash
-# Clone the repository
-git clone https://github.com/siddharthsma/smarta2a.git
-cd smarta2a
-
-# Create and activate virtual environment
-python -m venv venv
-source venv/bin/activate  # On Windows: venv\Scripts\activate
-
-# Install development dependencies
-pip install -e ".[dev]"
-```
-
-## License
-
-This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.