smarta2a 0.2.0__tar.gz → 0.2.2__tar.gz

{smarta2a-0.2.0 → smarta2a-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smarta2a
-Version: 0.2.0
+Version: 0.2.2
 Summary: A Python package for creating servers and clients following Google's Agent2Agent protocol
 Project-URL: Homepage, https://github.com/siddharthsma/smarta2a
 Project-URL: Bug Tracker, https://github.com/siddharthsma/smarta2a/issues
@@ -45,7 +45,7 @@ pip install smarta2a
 ## Simple Echo Server Implementation
 
 ```python
-from smarta2a import SmartA2A
+from smarta2a.server import SmartA2A
 
 app = SmartA2A("EchoServer")
 

{smarta2a-0.2.0 → smarta2a-0.2.2}/README.md

@@ -27,7 +27,7 @@ pip install smarta2a
 ## Simple Echo Server Implementation
 
 ```python
-from smarta2a import SmartA2A
+from smarta2a.server import SmartA2A
 
 app = SmartA2A("EchoServer")
 

{smarta2a-0.2.0 → smarta2a-0.2.2}/pyproject.toml

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

smarta2a-0.2.2/smarta2a/__init__.py

@@ -0,0 +1,10 @@
+"""
+py_a2a - A Python package for implementing an A2A server
+"""
+
+from .server.server import SmartA2A
+from .common.types import *
+
+__version__ = "0.1.0"
+
+__all__ = ["SmartA2A"]

smarta2a-0.2.2/smarta2a/client/a2a_client.py

@@ -0,0 +1,173 @@
+# Library imports
+from typing import Any, Literal, AsyncIterable
+import httpx
+import json
+from httpx_sse import connect_sse
+
+# Local imports
+from smarta2a.common.types import (
+    PushNotificationConfig,
+    SendTaskStreamingResponse,
+    SendTaskResponse,
+    SendTaskStreamingRequest,
+    SendTaskRequest,
+    JSONRPCRequest,
+    A2AClientJSONError,
+    A2AClientHTTPError,
+    AgentCard,
+    AuthenticationInfo,
+    GetTaskResponse,
+    CancelTaskResponse,
+    SetTaskPushNotificationResponse,
+    GetTaskPushNotificationResponse,
+)
+from smarta2a.common.task_request_builder import TaskRequestBuilder
+
+
+class A2AClient:
+    def __init__(self, agent_card: AgentCard = None, url: str = None):
+        if agent_card:
+            self.url = agent_card.url
+        elif url:
+            self.url = url
+        else:
+            raise ValueError("Must provide either agent_card or url")
+
+    async def send(
+        self,
+        *,
+        id: str,
+        role: Literal["user", "agent"] = "user",
+        text: str | None = None,
+        data: dict[str, Any] | None = None,
+        file_uri: str | None = None,
+        session_id: str | None = None,
+        accepted_output_modes: list[str] | None = None,
+        push_notification: PushNotificationConfig | None = None,
+        history_length: int | None = None,
+        metadata: dict[str, Any] | None = None,
+    ):
+        params = TaskRequestBuilder.build_send_task_request(
+            id=id,
+            role=role,
+            text=text,
+            data=data,
+            file_uri=file_uri,
+            session_id=session_id,
+            accepted_output_modes=accepted_output_modes,
+            push_notification=push_notification,
+            history_length=history_length,
+            metadata=metadata,
+        )
+        request = SendTaskRequest(params=params)
+        return SendTaskResponse(**await self._send_request(request))
+
+    def subscribe(
+        self,
+        *,
+        id: str,
+        role: Literal["user", "agent"] = "user",
+        text: str | None = None,
+        data: dict[str, Any] | None = None,
+        file_uri: str | None = None,
+        session_id: str | None = None,
+        accepted_output_modes: list[str] | None = None,
+        push_notification: PushNotificationConfig | None = None,
+        history_length: int | None = None,
+        metadata: dict[str, Any] | None = None,
+    ):
+        params = TaskRequestBuilder.build_send_task_request(
+            id=id,
+            role=role,
+            text=text,
+            data=data,
+            file_uri=file_uri,
+            session_id=session_id,
+            accepted_output_modes=accepted_output_modes,
+            push_notification=push_notification,
+            history_length=history_length,
+            metadata=metadata,
+        )
+        request = SendTaskStreamingRequest(params=params)
+        with httpx.Client(timeout=None) as client:
+            with connect_sse(
+                client, "POST", self.url, json=request.model_dump()
+            ) as event_source:
+                try:
+                    for sse in event_source.iter_sse():
+                        yield SendTaskStreamingResponse(**json.loads(sse.data))
+                except json.JSONDecodeError as e:
+                    raise A2AClientJSONError(str(e)) from e
+                except httpx.RequestError as e:
+                    raise A2AClientHTTPError(400, str(e)) from e
+
+    async def get_task(
+        self,
+        *,
+        id: str,
+        history_length: int | None = None,
+        metadata: dict[str, Any] | None = None,
+    ) -> GetTaskResponse:
+        req = TaskRequestBuilder.get_task(id, history_length, metadata)
+        raw = await self._send_request(req)
+        return GetTaskResponse(**raw)
+
+    async def cancel_task(
+        self,
+        *,
+        id: str,
+        metadata: dict[str, Any] | None = None,
+    ) -> CancelTaskResponse:
+        req = TaskRequestBuilder.cancel_task(id, metadata)
+        raw = await self._send_request(req)
+        return CancelTaskResponse(**raw)
+
+    async def set_push_notification(
+        self,
+        *,
+        id: str,
+        url: str,
+        token: str | None = None,
+        authentication: AuthenticationInfo | dict[str, Any] | None = None,
+    ) -> SetTaskPushNotificationResponse:
+        req = TaskRequestBuilder.set_push_notification(id, url, token, authentication)
+        raw = await self._send_request(req)
+        return SetTaskPushNotificationResponse(**raw)
+
+    async def get_push_notification(
+        self,
+        *,
+        id: str,
+        metadata: dict[str, Any] | None = None,
+    ) -> GetTaskPushNotificationResponse:
+        req = TaskRequestBuilder.get_push_notification(id, metadata)
+        raw = await self._send_request(req)
+        return GetTaskPushNotificationResponse(**raw)
+        
+            
+    async def _send_request(self, request: JSONRPCRequest) -> dict[str, Any]:
+        async with httpx.AsyncClient() as client:
+            try:
+                # Image generation could take time, adding timeout
+                response = await client.post(
+                    self.url, json=request.model_dump(), timeout=30
+                )
+                response.raise_for_status()
+                return response.json()
+            except httpx.HTTPStatusError as e:
+                raise A2AClientHTTPError(e.response.status_code, str(e)) from e
+            except json.JSONDecodeError as e:
+                raise A2AClientJSONError(str(e)) from e
+            
+    async def _send_streaming_request(self, request: JSONRPCRequest) -> AsyncIterable[SendTaskStreamingResponse]:
+        with httpx.Client(timeout=None) as client:
+                with connect_sse(
+                    client, "POST", self.url, json=request.model_dump()
+                ) as event_source:
+                    try:
+                        for sse in event_source.iter_sse():
+                            yield SendTaskStreamingResponse(**json.loads(sse.data))
+                    except json.JSONDecodeError as e:
+                        raise A2AClientJSONError(str(e)) from e
+                    except httpx.RequestError as e:
+                        raise A2AClientHTTPError(400, str(e)) from e

smarta2a-0.2.2/smarta2a/common/__init__.py

@@ -0,0 +1,32 @@
+from .types import *
+
+__all__ = [
+    "TaskSendParams",
+    "SendTaskRequest",
+    "GetTaskRequest",
+    "CancelTaskRequest",
+    "CancelTaskResponse",
+    "Task",
+    "TaskStatus",
+    "TaskState",
+    "Artifact",
+    "TextPart",
+    "FilePart",
+    "FileContent",
+    "A2AResponse",
+    "A2ARequest",
+    "TaskQueryParams",
+    "TaskStatusUpdateEvent",
+    "TaskArtifactUpdateEvent",
+    "A2AStatus",
+    "A2AStreamResponse",
+    "SendTaskResponse",
+    "Message",
+    "InternalError",
+    "TaskNotFoundError",
+    "SetTaskPushNotificationRequest",
+    "GetTaskPushNotificationRequest",
+    "SetTaskPushNotificationResponse",
+    "GetTaskPushNotificationResponse",
+    "TaskPushNotificationConfig"
+]

smarta2a-0.2.2/smarta2a/common/task_request_builder.py

@@ -0,0 +1,114 @@
+# Library imports
+from typing import Any, Literal
+from uuid import uuid4
+
+# Local imports
+from smarta2a.common.types import (
+    TaskPushNotificationConfig,
+    PushNotificationConfig,
+    TaskSendParams,
+    TextPart,
+    DataPart,
+    FilePart,
+    FileContent,
+    Message,
+    Part,
+    TaskQueryParams,
+    TaskIdParams,
+    GetTaskRequest,
+    CancelTaskRequest,
+    SetTaskPushNotificationRequest,
+    GetTaskPushNotificationRequest,
+    AuthenticationInfo,
+)
+
+class TaskRequestBuilder:
+    @staticmethod
+    def build_send_task_request(
+        *,
+        id: str,
+        role: Literal["user", "agent"] = "user",
+        text: str | None = None,
+        data: dict[str, Any] | None = None,
+        file_uri: str | None = None,
+        session_id: str | None = None,
+        accepted_output_modes: list[str] | None = None,
+        push_notification: PushNotificationConfig | None = None,
+        history_length: int | None = None,
+        metadata: dict[str, Any] | None = None,
+    ) -> TaskSendParams:
+        parts: list[Part] = []
+
+        if text is not None:
+            parts.append(TextPart(text=text))
+
+        if data is not None:
+            parts.append(DataPart(data=data))
+
+        if file_uri is not None:
+            file_content = FileContent(uri=file_uri)
+            parts.append(FilePart(file=file_content))
+
+        message = Message(role=role, parts=parts)
+
+        return TaskSendParams(
+            id=id,
+            sessionId=session_id or uuid4().hex,
+            message=message,
+            acceptedOutputModes=accepted_output_modes,
+            pushNotification=push_notification,
+            historyLength=history_length,
+            metadata=metadata,
+        )
+    
+    @staticmethod
+    def get_task(
+        id: str,
+        history_length: int | None = None,
+        metadata: dict[str, Any] | None = None,
+    ) -> GetTaskRequest:
+        params = TaskQueryParams(
+            id=id,
+            historyLength=history_length,
+            metadata=metadata,
+        )
+        return GetTaskRequest(params=params)
+
+    @staticmethod
+    def cancel_task(
+        id: str,
+        metadata: dict[str, Any] | None = None,
+    ) -> CancelTaskRequest:
+        params = TaskIdParams(id=id, metadata=metadata)
+        return CancelTaskRequest(params=params)
+
+    @staticmethod
+    def set_push_notification(
+        id: str,
+        url: str,
+        token: str | None = None,
+        authentication: AuthenticationInfo | dict[str, Any] | None = None,
+    ) -> SetTaskPushNotificationRequest:
+        # allow passing AuthenticationInfo _or_ raw dict
+        auth = (
+            authentication
+            if isinstance(authentication, AuthenticationInfo)
+            else (AuthenticationInfo(**authentication) if authentication else None)
+        )
+        push_cfg = TaskPushNotificationConfig(
+            id=id,
+            pushNotificationConfig=PushNotificationConfig(
+                url=url,
+                token=token,
+                authentication=auth,
+            )
+        )
+        return SetTaskPushNotificationRequest(params=push_cfg)
+
+    @staticmethod
+    def get_push_notification(
+        id: str,
+        metadata: dict[str, Any] | None = None,
+    ) -> GetTaskPushNotificationRequest:
+        params = TaskIdParams(id=id, metadata=metadata)
+        return GetTaskPushNotificationRequest(params=params)

smarta2a-0.2.2/smarta2a/server/__init__.py

@@ -0,0 +1,3 @@
+from .server import SmartA2A
+
+__all__ = ["SmartA2A"]

{smarta2a-0.2.0/smarta2a → smarta2a-0.2.2/smarta2a/server}/server.py

@@ -1,6 +1,5 @@
 from typing import Callable, Any, Optional, Dict, Union, List, AsyncGenerator
 import json
-import inspect
 from datetime import datetime
 from collections import defaultdict
 from fastapi import FastAPI, Request, HTTPException, APIRouter
@@ -11,8 +10,7 @@ import uvicorn
 from fastapi.responses import StreamingResponse
 from uuid import uuid4
 
-
-from .types import (
+from smarta2a.common.types import (
     JSONRPCResponse,
     Task,
     Artifact,
@@ -39,7 +37,6 @@ from .types import (
     JSONParseError,
     InvalidRequestError,
     MethodNotFoundError,
-    ContentTypeNotSupportedError,
     InternalError,
     UnsupportedOperationError,
     TaskNotFoundError,
@@ -48,6 +45,11 @@ from .types import (
     A2AStatus,
     A2AStreamResponse,
     TaskSendParams,
+    SetTaskPushNotificationRequest,
+    GetTaskPushNotificationRequest,
+    SetTaskPushNotificationResponse,
+    GetTaskPushNotificationResponse,
+    TaskPushNotificationConfig,
 )
 
 class SmartA2A:
@@ -129,6 +131,18 @@ class SmartA2A:
             self._register_handler("tasks/cancel", func, "task_cancel", "handler")
             return func
         return decorator
+    
+    def set_notification(self):
+        def decorator(func: Callable[[SetTaskPushNotificationRequest], None]) -> Callable:
+            self._register_handler("tasks/pushNotification/set", func, "set_notification", "handler")
+            return func
+        return decorator
+    
+    def get_notification(self):
+        def decorator(func: Callable[[GetTaskPushNotificationRequest], Union[TaskPushNotificationConfig, GetTaskPushNotificationResponse]]):
+            self._register_handler("tasks/pushNotification/get", func, "get_notification", "handler")
+            return func
+        return decorator
 
     async def process_request(self, request_data: dict) -> JSONRPCResponse:
         try:
@@ -141,6 +155,10 @@ class SmartA2A:
                 return self._handle_get_task(request_data)
             elif method == "tasks/cancel":
                 return self._handle_cancel_task(request_data)
+            elif method == "tasks/pushNotification/set":
+                return self._handle_set_notification(request_data)
+            elif method == "tasks/pushNotification/get":
+                return self._handle_get_notification(request_data)
             else:
                 return self._error_response(
                     request_data.get("id"),
@@ -422,6 +440,102 @@ class SmartA2A:
                 error=InternalError(data=str(e))
             )
 
+    def _handle_set_notification(self, request_data: dict) -> SetTaskPushNotificationResponse:
+        try:
+            request = SetTaskPushNotificationRequest.model_validate(request_data)
+            handler = self.handlers.get("tasks/pushNotification/set")
+            
+            if not handler:
+                return SetTaskPushNotificationResponse(
+                    id=request.id,
+                    error=MethodNotFoundError()
+                )
+
+            try:
+                # Execute handler (may or may not return something)
+                raw_result = handler(request)
+                
+                # If handler returns nothing - build success response from request params
+                if raw_result is None:
+                    return SetTaskPushNotificationResponse(
+                        id=request.id,
+                        result=request.params
+                    )
+                
+                # If handler returns a full response object
+                if isinstance(raw_result, SetTaskPushNotificationResponse):
+                    return raw_result
+                    
+
+            except Exception as e:
+                if isinstance(e, JSONRPCError):
+                    return SetTaskPushNotificationResponse(
+                        id=request.id,
+                        error=e
+                    )
+                return SetTaskPushNotificationResponse(
+                    id=request.id,
+                    error=InternalError(data=str(e))
+                )
+
+        except ValidationError as e:
+            return SetTaskPushNotificationResponse(
+                id=request_data.get("id"),
+                error=InvalidRequestError(data=e.errors())
+            )
+                      
+
+    def _handle_get_notification(self, request_data: dict) -> GetTaskPushNotificationResponse:
+        try:
+            request = GetTaskPushNotificationRequest.model_validate(request_data)
+            handler = self.handlers.get("tasks/pushNotification/get")
+            
+            if not handler:
+                return GetTaskPushNotificationResponse(
+                    id=request.id,
+                    error=MethodNotFoundError()
+                )
+            
+            try:
+                raw_result = handler(request)
+                
+                if isinstance(raw_result, GetTaskPushNotificationResponse):
+                    return raw_result
+                else:
+                    # Validate raw_result as TaskPushNotificationConfig
+                    config = TaskPushNotificationConfig.model_validate(raw_result)
+                    return GetTaskPushNotificationResponse(
+                        id=request.id,
+                        result=config
+                    )
+            except ValidationError as e:
+                return GetTaskPushNotificationResponse(
+                    id=request.id,
+                    error=InvalidParamsError(data=e.errors())
+                )
+            except Exception as e:
+                if isinstance(e, JSONRPCError):
+                    return GetTaskPushNotificationResponse(
+                        id=request.id,
+                        error=e
+                    )
+                return GetTaskPushNotificationResponse(
+                    id=request.id,
+                    error=InternalError(data=str(e))
+                )
+
+        except ValidationError as e:
+            return GetTaskPushNotificationResponse(
+                id=request_data.get("id"),
+                error=InvalidRequestError(data=e.errors())
+            )
+        except json.JSONDecodeError as e:
+            return GetTaskPushNotificationResponse(
+                id=request_data.get("id"),
+                error=JSONParseError(data=str(e))
+            )
+
+
     def _normalize_artifacts(self, content: Any) -> List[Artifact]:
         """Handle both A2AResponse content and regular returns"""
         if isinstance(content, Artifact):

{smarta2a-0.2.0 → smarta2a-0.2.2}/tests/test_server.py

@@ -2,8 +2,8 @@ import pytest
 import json
 import requests
 from fastapi.testclient import TestClient
-from smarta2a import SmartA2A
-from smarta2a.types import (
+from smarta2a.server import SmartA2A
+from smarta2a.common.types import (
     TaskSendParams,
     SendTaskRequest,
     GetTaskRequest,
@@ -18,13 +18,18 @@ from smarta2a.types import (
     FileContent,
     A2AResponse,
     A2ARequest,
-    TaskQueryParams,
     TaskStatusUpdateEvent,
     TaskArtifactUpdateEvent,
     A2AStatus,
     A2AStreamResponse,
     SendTaskResponse,  
-    Message
+    Message,
+    InternalError,
+    SetTaskPushNotificationRequest,
+    GetTaskPushNotificationRequest,
+    SetTaskPushNotificationResponse,
+    GetTaskPushNotificationResponse,
+    TaskPushNotificationConfig
 )
 
 @pytest.fixture
@@ -500,4 +505,145 @@ def test_send_task_content_access():
     assert request.content == request.params.message.parts
 
 
+def test_set_notification_success(a2a_server, client):
+    # Test basic success case with no return value
+    @a2a_server.set_notification()
+    def handle_set(req: SetTaskPushNotificationRequest):
+        # No return needed - just validate request
+        assert req.params.id == "test123"
+    
+    request_data = {
+        "jsonrpc": "2.0",
+        "id": 1,
+        "method": "tasks/pushNotification/set",
+        "params": {
+            "id": "test123",
+            "pushNotificationConfig": {
+                "url": "https://example.com/callback",
+                "authentication": {
+                    "schemes": ["jwt"]
+                }
+            }
+        }
+    }
+    
+    response = client.post("/", json=request_data).json()
+    
+    assert response["result"]["id"] == "test123"
+    assert response["result"]["pushNotificationConfig"]["url"] == request_data["params"]["pushNotificationConfig"]["url"]
+    assert response["result"]["pushNotificationConfig"]["authentication"]["schemes"] == ["jwt"]
+
+def test_set_notification_custom_response(a2a_server, client):
+    # Test handler returning custom response
+    @a2a_server.set_notification()
+    def handle_set(req):
+        return SetTaskPushNotificationResponse(
+            id=req.id,
+            result=TaskPushNotificationConfig(
+                id="test123",
+                pushNotificationConfig={
+                    "url": "custom-url",
+                    "token": "secret"
+                }
+            )
+        )
+    
+    response = client.post("/", json={
+        "jsonrpc": "2.0",
+        "id": 2,
+        "method": "tasks/pushNotification/set",
+        "params": {
+            "id": "test123",
+            "pushNotificationConfig": {"url": "https://example.com"}
+        }
+    }).json()
+    
+    assert response["result"]["pushNotificationConfig"]["url"] == "custom-url"
+    assert "secret" in response["result"]["pushNotificationConfig"]["token"]
+
+
+# --- Get Notification Tests ---
+
+def test_get_notification_success(a2a_server, client):
+    # Test successful config retrieval
+    @a2a_server.get_notification()
+    def handle_get(req: GetTaskPushNotificationRequest):
+        return TaskPushNotificationConfig(
+            id=req.params.id,
+            pushNotificationConfig={
+                "url": "https://test.com",
+                "token": "abc123"
+            }
+        )
+    
+    request_data = {
+        "jsonrpc": "2.0",
+        "id": 4,
+        "method": "tasks/pushNotification/get",
+        "params": {"id": "test456"}
+    }
+    
+    response = client.post("/", json=request_data).json()
+    
+    assert response["result"]["id"] == "test456"
+    assert response["result"]["pushNotificationConfig"]["url"] == "https://test.com"
+
+def test_get_notification_direct_response(a2a_server, client):
+    # Test handler returning full response object
+    @a2a_server.get_notification()
+    def handle_get(req):
+        return GetTaskPushNotificationResponse(
+            id=req.id,
+            result=TaskPushNotificationConfig(
+                id=req.params.id,
+                pushNotificationConfig={
+                    "url": "direct-response.example",
+                    "authentication": {"schemes": ["basic"]}
+                }
+            )
+        )
+    
+    response = client.post("/", json={
+        "jsonrpc": "2.0",
+        "id": 5,
+        "method": "tasks/pushNotification/get",
+        "params": {"id": "test789"}
+    }).json()
+    
+    assert "direct-response" in response["result"]["pushNotificationConfig"]["url"]
+    assert "basic" in response["result"]["pushNotificationConfig"]["authentication"]["schemes"]
+
+def test_get_notification_validation_error(a2a_server, client):
+    # Test invalid response from handler
+    @a2a_server.get_notification()
+    def handle_get(req):
+        return {"invalid": "config"}
+    
+    response = client.post("/", json={
+        "jsonrpc": "2.0",
+        "id": 6,
+        "method": "tasks/pushNotification/get",
+        "params": {"id": "test999"}
+    }).json()
+    
+    assert response["error"]["code"] == -32602  # Invalid params
+    
+
+def test_get_notification_error_propagation(a2a_server, client):
+    # Test exception handling
+    @a2a_server.get_notification()
+    def handle_get(req):
+        raise InternalError(message="Storage failure")
+    
+    response = client.post("/", json={
+        "jsonrpc": "2.0",
+        "id": 7,
+        "method": "tasks/pushNotification/get",
+        "params": {"id": "test-error"}
+    }).json()
+    
+    assert response["error"]["code"] == -32603  # Internal error code
+    
+
+
 

smarta2a-0.2.2/tests/test_task_request_builder.py

@@ -0,0 +1,130 @@
+import pytest
+from uuid import UUID
+from smarta2a.common.types import (
+    TaskSendParams,
+    Message,
+    TextPart,
+    DataPart,
+    FilePart,
+    GetTaskRequest,
+    TaskQueryParams,
+    CancelTaskRequest,
+    TaskIdParams,
+    SetTaskPushNotificationRequest,
+    PushNotificationConfig,
+    AuthenticationInfo,
+    GetTaskPushNotificationRequest,
+)
+from smarta2a.common.task_request_builder import TaskRequestBuilder
+
+class TestTaskRequestBuilder:
+    def test_build_send_task_request_with_text(self):
+        # Test with text part
+        request = TaskRequestBuilder.build_send_task_request(
+            id="task123",
+            text="Hello world",
+            role="agent",
+            session_id="session_456",
+            metadata={"key": "value"},
+        )
+        
+        assert isinstance(request, TaskSendParams)
+        assert request.id == "task123"
+        assert request.sessionId == "session_456"
+        assert request.metadata == {"key": "value"}
+        assert isinstance(request.message, Message)
+        assert request.message.role == "agent"
+        assert len(request.message.parts) == 1
+        assert isinstance(request.message.parts[0], TextPart)
+        assert request.message.parts[0].text == "Hello world"
+
+    def test_build_send_task_request_with_all_parts(self):
+        # Test with text, data, and file parts
+        request = TaskRequestBuilder.build_send_task_request(
+            id="task123",
+            text="Hello",
+            data={"key": "value"},
+            file_uri="file:///data.csv",
+        )
+        
+        parts = request.message.parts
+        assert len(parts) == 3
+        assert any(isinstance(p, TextPart) for p in parts)
+        assert any(isinstance(p, DataPart) and p.data == {"key": "value"} for p in parts)
+        assert any(isinstance(p, FilePart) and p.file.uri == "file:///data.csv" for p in parts)
+
+    def test_build_send_task_request_default_session_id(self):
+        # Ensure sessionId is a UUID hex string when not provided
+        request = TaskRequestBuilder.build_send_task_request(id="task123", text="Hi")
+        assert len(request.sessionId) == 32
+        try:
+            UUID(request.sessionId, version=4)
+        except ValueError:
+            pytest.fail("sessionId is not a valid UUID4 hex string")
+
+    def test_get_task(self):
+        request = TaskRequestBuilder.get_task(
+            id="task123",
+            history_length=5,
+            metadata={"key": "value"},
+        )
+        
+        assert isinstance(request, GetTaskRequest)
+        assert isinstance(request.params, TaskQueryParams)
+        assert request.params.id == "task123"
+        assert request.params.historyLength == 5
+        assert request.params.metadata == {"key": "value"}
+
+    def test_cancel_task(self):
+        request = TaskRequestBuilder.cancel_task(
+            id="task123",
+            metadata={"key": "value"},
+        )
+        
+        assert isinstance(request, CancelTaskRequest)
+        assert isinstance(request.params, TaskIdParams)
+        assert request.params.id == "task123"
+        assert request.params.metadata == {"key": "value"}
+
+    def test_set_push_notification_with_authentication_info(self):
+        # Test with AuthenticationInfo instance (include REQUIRED 'schemes' field)
+        auth_info = AuthenticationInfo(
+            schemes=["https", "bearer"],  # Required field
+            credentials="token123"         # Optional field
+        )
+        request = TaskRequestBuilder.set_push_notification(
+            id="task123",
+            url="https://example.com",
+            token="auth_token",
+            authentication=auth_info,
+        )
+        
+        assert isinstance(request.params.pushNotificationConfig.authentication, AuthenticationInfo)
+        assert request.params.pushNotificationConfig.authentication.schemes == ["https", "bearer"]
+        assert request.params.pushNotificationConfig.authentication.credentials == "token123"
+
+    def test_set_push_notification_with_dict(self):
+        # Test with authentication dict (MUST include 'schemes')
+        auth_dict = {
+            "schemes": ["basic"],  # Required field
+            "credentials": "user:pass"  # Optional field
+        }
+        request = TaskRequestBuilder.set_push_notification(
+            id="task123",
+            url="https://example.com",
+            authentication=auth_dict,
+        )
+        
+        assert request.params.pushNotificationConfig.authentication.schemes == ["basic"]
+        assert request.params.pushNotificationConfig.authentication.credentials == "user:pass"
+
+    def test_get_push_notification(self):
+        request = TaskRequestBuilder.get_push_notification(
+            id="task123",
+            metadata={"key": "value"},
+        )
+        
+        assert isinstance(request, GetTaskPushNotificationRequest)
+        assert isinstance(request.params, TaskIdParams)
+        assert request.params.id == "task123"
+        assert request.params.metadata == {"key": "value"}

smarta2a-0.2.0/smarta2a/__init__.py

@@ -1,10 +0,0 @@
-"""
-py_a2a - A Python package for implementing an A2A server
-"""
-
-__version__ = "0.1.0" 
-
-from .server import SmartA2A
-from . import types as models
-
-__all__ = ["SmartA2A", "models"]