smarta2a 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

smarta2a/__init__.py

@@ -2,9 +2,9 @@
 py_a2a - A Python package for implementing an A2A server
 """
 
-__version__ = "0.1.0" 
+from .server.server import SmartA2A
+from .common.types import *
 
-from .server import SmartA2A
-from . import types as models
+__version__ = "0.1.0"
 
-__all__ = ["SmartA2A", "models"]
+__all__ = ["SmartA2A"]

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/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/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/server/__init__.py

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

smarta2a/{server.py → 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.dist-info → smarta2a-0.2.2.dist-info}/METADATA

@@ -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.2.dist-info/RECORD

@@ -0,0 +1,12 @@
+smarta2a/__init__.py,sha256=V6TtUzRtzqDUV8i5PDU6amAWVeiENdibgMV8btix26Y,176
+smarta2a/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+smarta2a/client/a2a_client.py,sha256=ejWZq8F-G49sse2EMeVKg9ISiLXyWe-ElacQdjkzzfY,6203
+smarta2a/common/__init__.py,sha256=5db5VgDGgbMUGEF-xuyaC3qrgRQkUE9WAITkFSiNqSA,702
+smarta2a/common/task_request_builder.py,sha256=GPa_T8jy_Z5Lj-i5Wvbw-mhRiUsSQUbWGZxQbq834T8,3363
+smarta2a/common/types.py,sha256=_UuFtOsnHIIqfQ2m_FiIBBp141iYmhpPGgxE0jmHSHg,10807
+smarta2a/server/__init__.py,sha256=f2X454Ll4vJc02V4JLJHTN-h8u0TBm4d_FkiO4t686U,53
+smarta2a/server/server.py,sha256=JpRyJMdu4xb76Vye4SXN9Y06BzjVoHLFL2BGK6S9Lxo,30880
+smarta2a-0.2.2.dist-info/METADATA,sha256=R3bU9hf8AFS1GxLAT53C6UMQN1sGM6x2rXWXvt0EHZI,2485
+smarta2a-0.2.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+smarta2a-0.2.2.dist-info/licenses/LICENSE,sha256=ECMEVHuFkvpEmH-_A9HSxs_UnnsUqpCkiAYNHPCf2z0,1078
+smarta2a-0.2.2.dist-info/RECORD,,

smarta2a-0.2.0.dist-info/RECORD

@@ -1,7 +0,0 @@
-smarta2a/__init__.py,sha256=f_RqeaAHiBXO0O8n2kR8EBLGM3ezNwmR-CV-xHeOHLM,182
-smarta2a/server.py,sha256=a5RTtROydJwxHK1nTYzv2nmRJvxhY-SsxuKDqE9_RwY,26117
-smarta2a/types.py,sha256=_UuFtOsnHIIqfQ2m_FiIBBp141iYmhpPGgxE0jmHSHg,10807
-smarta2a-0.2.0.dist-info/METADATA,sha256=4PZH8mK_4YNGnfAH4gbjPwZW0M9lG2yZYdJW8Dq6T3w,2478
-smarta2a-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-smarta2a-0.2.0.dist-info/licenses/LICENSE,sha256=ECMEVHuFkvpEmH-_A9HSxs_UnnsUqpCkiAYNHPCf2z0,1078
-smarta2a-0.2.0.dist-info/RECORD,,