smarta2a 0.2.1__tar.gz → 0.2.2__tar.gz

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

@@ -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.1 → 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.1 → smarta2a-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "smarta2a"
-version = "0.2.1"
+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.1/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,

{smarta2a-0.2.1 → 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,7 +18,6 @@ from smarta2a.types import (
     FileContent,
     A2AResponse,
     A2ARequest,
-    TaskQueryParams,
     TaskStatusUpdateEvent,
     TaskArtifactUpdateEvent,
     A2AStatus,
@@ -26,7 +25,6 @@ from smarta2a.types import (
     SendTaskResponse,  
     Message,
     InternalError,
-    TaskNotFoundError,
     SetTaskPushNotificationRequest,
     GetTaskPushNotificationRequest,
     SetTaskPushNotificationResponse,

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.1/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"]