smarta2a 0.2.4__tar.gz → 0.3.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smarta2a
-Version: 0.2.4
+Version: 0.3.0
 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.3.0}/pyproject.toml

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

{smarta2a-0.2.4 → smarta2a-0.3.0}/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.3.0/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.3.0}/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 (
@@ -181,87 +182,120 @@ class A2AClient:
                         raise A2AClientHTTPError(400, str(e)) from e
     
 
-    def list_tools(self) -> list[dict[str, Any]]:
-        """Return metadata for all available tools."""
+    async def list_tools(self) -> list[dict[str, Any]]:
+        """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
             
+            input_schema = {
+                "title": f"{name}_Arguments",
+                "type": "object",
+                "properties": properties,
+                "required": required,
+            }
+
             tools.append({
-                'name': name,
-                'description': description,
-                'input_schema': schema
+                "name": name,
+                "description": description,
+                "inputSchema": input_schema
             })
+
         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-0.2.4/smarta2a/archive → smarta2a-0.3.0/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.3.0}/smarta2a/client/tools_manager.py

@@ -3,9 +3,9 @@ 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
+from smarta2a.utils.types import AgentCard, Tool
 
 class ToolsManager:
     """
@@ -14,21 +14,24 @@ 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_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
+                self.clients[tool.name] = a2a_client
 
     def get_tools(self) -> List[Any]:
         return self.tools_list
@@ -37,15 +40,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.3.0}/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.3.0/smarta2a/examples/openai_delegator_agent/main.py

@@ -0,0 +1,41 @@
+# 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-0.3.0/smarta2a/examples/openai_weather_agent/main.py

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

{smarta2a-0.2.4 → smarta2a-0.3.0}/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:
@@ -130,16 +133,16 @@ class OpenAIProvider(BaseLLMProvider):
         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.3.0}/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.3.0}/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
 
@@ -482,3 +482,8 @@ class StateData(BaseModel):
     sessionId: str
     history: List[Message]
     metadata: Dict[str, Any]
+
+class Tool(BaseModel):
+    name: str
+    description: str
+    inputSchema: Dict[str, Any]

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.
-"""