smarta2a 0.2.1__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,

{smarta2a-0.2.1.dist-info → smarta2a-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smarta2a
-Version: 0.2.1
+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.1.dist-info/RECORD

@@ -1,7 +0,0 @@
-smarta2a/__init__.py,sha256=f_RqeaAHiBXO0O8n2kR8EBLGM3ezNwmR-CV-xHeOHLM,182
-smarta2a/server.py,sha256=lFUlAz4TEeEXCs2bgJmMTN7JpZTwYEKXyt4KWEQwS6U,30915
-smarta2a/types.py,sha256=_UuFtOsnHIIqfQ2m_FiIBBp141iYmhpPGgxE0jmHSHg,10807
-smarta2a-0.2.1.dist-info/METADATA,sha256=H4os9rBnBzByJI1FWr7vYW2w8Or8PInU7XtmwsHCIcY,2478
-smarta2a-0.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-smarta2a-0.2.1.dist-info/licenses/LICENSE,sha256=ECMEVHuFkvpEmH-_A9HSxs_UnnsUqpCkiAYNHPCf2z0,1078
-smarta2a-0.2.1.dist-info/RECORD,,