smarta2a 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

smarta2a-0.4.0.dist-info/METADATA

@@ -0,0 +1,402 @@
+Metadata-Version: 2.4
+Name: smarta2a
+Version: 0.4.0
+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 an A2A compliant server. If you're using another Agent framework like LangGraph you can easily use it in 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 responses (btw also handles files!)
+- 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 weather agent:
+```bash
+python path/to/airbnb_agent/main.py
+```
+
+
+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.4.0.dist-info/RECORD

@@ -0,0 +1,41 @@
+smarta2a/__init__.py,sha256=T_EECYqWrxshix0FbgUv22zlKRX22HFU-HKXcYTOb3w,175
+smarta2a/nats-server.conf,sha256=4Nm2NdijEXxRU0c7jlFE0g8KGMsBDMB4gDC0kdUDt_o,295
+smarta2a/agent/a2a_agent.py,sha256=EurcxpV14e3OPWCMutYL0EXMHb5ZKQqAHEGZZF6pNgg,1892
+smarta2a/agent/a2a_human.py,sha256=tXrEtl0OqZEXZfmPTLnbbAiREMTmlqA42XIf7KocqMU,1850
+smarta2a/agent/a2a_mcp_server.py,sha256=X_mxkgYgCA_dSNtCvs0rSlOoWYc-8d3Qyxv0e-a7NKY,1015
+smarta2a/archive/smart_mcp_client.py,sha256=0s2OWFKWSv-_UF7rb9fOrsh1OIYsYOsGukkXXp_E1cU,4158
+smarta2a/archive/subscription_service.py,sha256=vftmZD94HbdjPFa_1UBvsBm-WkW-s3ZCVq60fF7OCgA,4109
+smarta2a/archive/task_service.py,sha256=ptf-oMHy98Rw4XSxyK1-lpqc1JtkCkEEHTmwAaunet4,8199
+smarta2a/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+smarta2a/client/a2a_client.py,sha256=apDkKFtq61T79LpkbkzVTKWA0mSjR_eTNdGPUYozyvk,12100
+smarta2a/client/mcp_client.py,sha256=PM4D1CgOycxK5kJEJTGpKq0eXFjZ69-2720TuRUkyGc,3627
+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/history_update_strategies/rolling_window_strategy.py,sha256=7Ch042JWt4TM_r1-sFKlSIxHj8VX1P3ZoqjCvIdeSqA,540
+smarta2a/model_providers/__init__.py,sha256=hJj0w00JjqTiBgJmHmOWwL6MU_hwmro9xTiX3XYf6ts,148
+smarta2a/model_providers/base_llm_provider.py,sha256=iQUqjnypl0f2M929iU0WhHoxAE4ek-NUFJPbEnNQ8-4,412
+smarta2a/model_providers/openai_provider.py,sha256=YGHF6IIsBBE-Otiq9q9hSd49sh5unxqINRh9q3nKPQI,12088
+smarta2a/server/__init__.py,sha256=f2X454Ll4vJc02V4JLJHTN-h8u0TBm4d_FkiO4t686U,53
+smarta2a/server/handler_registry.py,sha256=OVRG5dTvxB7qUNXgsqWxVNxIyRljUShSYxb1gtbi5XM,820
+smarta2a/server/json_rpc_request_processor.py,sha256=qRB3sfj_n9ImkIOCdaUKMsDmKcO7CiMhaZ4VdQS7Mb4,6993
+smarta2a/server/nats_client.py,sha256=akyNg1hLd9XYoLSH_qQVs8uoiTQerztgvqu_3TifSgE,1617
+smarta2a/server/request_handler.py,sha256=5KMtfpHQX6bOgk1DJbhs1fUCQ5tSvMYXWzheT3IW2Bo,26374
+smarta2a/server/send_task_handler.py,sha256=fiBeCCHCu9c2H4EJOUc0t3EZgpHVFJy4B_6qZOC140s,6336
+smarta2a/server/server.py,sha256=grE2n-MAyaBR5rUro2ZJ0kI6sBFplHvRFL5MMe1DsPs,7094
+smarta2a/server/state_manager.py,sha256=-AgnhtAnrugSxncGgqskXJnQnAOjwNUg7xuyDvQ7V4s,6668
+smarta2a/server/webhook_request_processor.py,sha256=_0XoUDmueSl9CvFQE-1zgKRSts-EW8QxbmolPTfFER8,5306
+smarta2a/state_stores/__init__.py,sha256=vafxAqpwvag_cYFH2XKGk3DPmJIWJr4Ioey30yLFkVQ,220
+smarta2a/state_stores/base_state_store.py,sha256=_3LInM-qepKwwdypJTDNs9-DozBNrKVycwPwUm7bYdU,512
+smarta2a/state_stores/inmemory_state_store.py,sha256=nEBBUiiqhEluP2MYJjFUImcjIwLJEvL8BWwMbLCb8Fw,1268
+smarta2a/utils/__init__.py,sha256=5db5VgDGgbMUGEF-xuyaC3qrgRQkUE9WAITkFSiNqSA,702
+smarta2a/utils/agent_discovery_manager.py,sha256=6KpRSQH_EDUOZbF4wFRsZneZGIPLXFP4VjWPN4Ydv-A,4172
+smarta2a/utils/prompt_helpers.py,sha256=M3UUjFQEspEAnNm54Dip0-D7mMFFZLrP_s_89ZPe6fs,1438
+smarta2a/utils/task_builder.py,sha256=wqSyfVHNTaXuGESu09dhlaDi7D007gcN3-8tH-nPQ40,5159
+smarta2a/utils/task_request_builder.py,sha256=6cOGOqj2Rg43xWM03GRJQzlIZHBptsMCJRp7oD-TDAQ,3362
+smarta2a/utils/tools_manager.py,sha256=yOiJ6tyxfKDJDM2C0FoVuqh3nNNee75iRw_M7LmZdzA,4319
+smarta2a/utils/types.py,sha256=kzA6Vv5xXfu1sJuxhEXrglI9e9S6eZVIljMnsrQVyN0,13650
+smarta2a-0.4.0.dist-info/METADATA,sha256=lCSXmNz7iNptUspp9o0I1teAFLcSSUr5iufmwHh5jhk,12987
+smarta2a-0.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+smarta2a-0.4.0.dist-info/licenses/LICENSE,sha256=lDbqrxVnzDMY5KJ8JS1WhvkWE8TJaw-O-CHDy-ecsJA,2095
+smarta2a-0.4.0.dist-info/RECORD,,

smarta2a-0.4.0.dist-info/licenses/LICENSE

@@ -0,0 +1,35 @@
+MIT License
+
+Copyright (c) 2025 Siddharth Sameer Ambegaonkar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the “Software”), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+**Commons Clause License Condition v1.0**
+
+The Software is provided under the MIT License, as supplemented by the following condition:
+
+The grant of rights under the MIT License does not include, and the following condition is added to the MIT License:
+
+*Notwithstanding any other provision of the License, the License does not grant the right to Sell the Software.*
+
+For purposes of the foregoing, “Sell” means practicing any or all of the rights granted to you under the License to provide to third parties, for a fee or other consideration (including without limitation fees for hosting or consulting/support services related to the Software), a product or service whose value derives, entirely or substantially, from the functionality of the Software. Any licensee who provides any such product or service is deemed to be in violation of this condition and may not exercise any of the rights granted under the License.
+
+This condition is intended to supplement, not replace, the License.

smarta2a/client/tools_manager.py

@@ -1,62 +0,0 @@
-# Library imports
-import json
-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, Tool
-
-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[MCPClient, A2AClient]] = {}
-
-    async def load_mcp_tools(self, urls_or_paths: List[str]) -> None:
-        for url in urls_or_paths:
-            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
-
-    async def load_a2a_tools(self, agent_cards: List[AgentCard]) -> None:
-        for agent_card in agent_cards:
-            a2a_client = A2AClient(agent_card)
-            tools_list = await a2a_client.list_tools()
-            tools = [Tool(**tool_dict) for tool_dict in tools_list]
-            for tool in 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:
-            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":
-                lines.append(
-                    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:
-        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/examples/echo_server/curl.txt

@@ -1 +0,0 @@
-curl -X POST -H "Content-Type: application/json" -d '{ "jsonrpc": "2.0", "id": 1, "method": “tasks/send”, "params": {"id": "test-task-1","message": {"role": "user","parts": [{"type": "text", "text": "Test message"}]}} }' http://localhost:8000/

smarta2a/examples/echo_server/main.py

@@ -1,39 +0,0 @@
-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
-
-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"""
-    input_text = request.content[0].text
-    #return f"Response to task: {input_text}"
-    return A2AResponse(
-        content=[TextPart(type="text", text="Response to task: " + input_text), FilePart(type="file", file=FileContent(name="test.txt", bytes="test"))],
-        status="working"
-    )
-
-@app.on_send_subscribe_task()
-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}"
-    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"""
-    return f"Task: {request.id}"
-
-@app.task_cancel()
-def handle_cancel_task(request):
-    """Cancel the task"""
-    return f"Task cancelled: {request.id}"
-
-
-
-
-   

smarta2a/examples/openai_delegator_agent/main.py

@@ -1,41 +0,0 @@
-# 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")]
-)
-
-
-openai_provider = OpenAIProvider(
-    api_key=api_key,
-    model="gpt-4o-mini",
-    agent_cards=[weather_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=8080)

smarta2a/examples/openai_weather_agent/main.py

@@ -1,32 +0,0 @@
-# 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 weather related queries",
-    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)