smarta2a 0.2.5__tar.gz → 0.3.0__tar.gz

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

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

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

{smarta2a-0.2.5 → 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 (
@@ -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
             
+            input_schema = {
+                "title": f"{name}_Arguments",
+                "type": "object",
+                "properties": properties,
+                "required": required,
+            }
+
             tools.append({
-                'name': name,
-                'description': description,
-                'inputSchema': 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.5 → smarta2a-0.3.0}/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:
     """
@@ -27,7 +27,8 @@ class ToolsManager:
     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()
+            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

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.2.5/smarta2a/examples/openai_agent → smarta2a-0.3.0/smarta2a/examples/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-0.2.5 → smarta2a-0.3.0}/smarta2a/model_providers/openai_provider.py

@@ -127,7 +127,7 @@ class OpenAIProvider(BaseLLMProvider):
                 "function": {
                     "name": tool.name,
                     "description": tool.description,
-                    "parameters": tool.inputSchema
+                    "parameters": tool.input_schema
                 }
             })
         return openai_tools

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

@@ -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]