smarta2a 0.1.0__py3-none-any.whl

fasta2a/__init__.py

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

fasta2a/server.py

@@ -0,0 +1,710 @@
+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
+from fastapi.middleware.cors import CORSMiddleware
+from sse_starlette.sse import EventSourceResponse
+from pydantic import ValidationError
+import uvicorn
+from fastapi.responses import StreamingResponse
+from uuid import uuid4
+
+
+from .types import (
+    JSONRPCResponse,
+    Task,
+    Artifact,
+    TextPart,
+    FilePart,
+    FileContent,
+    DataPart,
+    Part,
+    TaskStatus,
+    TaskState,
+    JSONRPCError,
+    SendTaskResponse,
+    JSONRPCRequest,
+    A2AResponse,
+    SendTaskRequest,
+    SendTaskStreamingRequest,
+    SendTaskStreamingResponse,
+    GetTaskRequest,
+    GetTaskResponse,
+    CancelTaskRequest,
+    CancelTaskResponse,
+    TaskStatusUpdateEvent,
+    TaskArtifactUpdateEvent,
+    JSONParseError,
+    InvalidRequestError,
+    MethodNotFoundError,
+    ContentTypeNotSupportedError,
+    InternalError,
+    UnsupportedOperationError,
+    TaskNotFoundError,
+    InvalidParamsError,
+    TaskNotCancelableError,
+    A2AStatus,
+    A2AStreamResponse,
+    TaskSendParams,
+)
+
+class FastA2A:
+    def __init__(self, name: str, **fastapi_kwargs):
+        self.name = name
+        self.handlers: Dict[str, Callable] = {}
+        self.subscriptions: Dict[str, Callable] = {}
+        self.app = FastAPI(title=name, **fastapi_kwargs)
+        self.router = APIRouter()
+        self._registered_decorators = set()
+        self._setup_routes()
+        self.server_config = {
+            "host": "0.0.0.0",
+            "port": 8000,
+            "reload": False
+        }
+        
+
+    def _setup_routes(self):
+        @self.app.post("/")    
+        async def handle_request(request: Request):
+            try:
+                data = await request.json()
+                request_obj = JSONRPCRequest(**data)
+            except Exception as e:
+                return JSONRPCResponse(
+                    id=None,
+                    error=JSONRPCError(
+                        code=-32700,
+                        message="Parse error",
+                        data=str(e)
+                    )
+                ).model_dump()
+            
+            response = await self.process_request(request_obj.model_dump())
+
+            # <-- Accept both SSE‐style responses:
+            if isinstance(response, (EventSourceResponse, StreamingResponse)):
+                return response
+
+            # <-- Everything else is a normal pydantic JSONRPCResponse
+            return response.model_dump()
+
+    def _register_handler(self, method: str, func: Callable, handler_name: str, handler_type: str = "handler"):
+        """Shared registration logic with duplicate checking"""
+        if method in self._registered_decorators:
+            raise RuntimeError(
+                f"@{handler_name} decorator for method '{method}' "
+                f"can only be used once per FastA2A instance"
+            )
+        
+        if handler_type == "handler":
+            self.handlers[method] = func
+        else:
+            self.subscriptions[method] = func
+            
+        self._registered_decorators.add(method)
+
+    def on_send_task(self) -> Callable:
+        def decorator(func: Callable[[SendTaskRequest], Any]) -> Callable:
+            self._register_handler("tasks/send", func, "on_send_task", "handler")
+            return func
+        return decorator
+
+    def on_send_subscribe_task(self) -> Callable:
+        def decorator(func: Callable) -> Callable:
+            self._register_handler("tasks/sendSubscribe", func, "on_send_subscribe_task", "subscription")
+            return func
+        return decorator
+    
+    def task_get(self):
+        def decorator(func: Callable[[GetTaskRequest], Task]):
+            self._register_handler("tasks/get", func, "task_get", "handler")
+            return func
+        return decorator
+    
+    def task_cancel(self):
+        def decorator(func: Callable[[CancelTaskRequest], Task]):
+            self._register_handler("tasks/cancel", func, "task_cancel", "handler")
+            return func
+        return decorator
+
+    async def process_request(self, request_data: dict) -> JSONRPCResponse:
+        try:
+            method = request_data.get("method")
+            if method == "tasks/send":
+                return self._handle_send_task(request_data)
+            elif method == "tasks/sendSubscribe":
+                return await self._handle_subscribe_task(request_data)
+            elif method == "tasks/get":
+                return self._handle_get_task(request_data)
+            elif method == "tasks/cancel":
+                return self._handle_cancel_task(request_data)
+            else:
+                return self._error_response(
+                    request_data.get("id"),
+                    -32601,
+                    "Method not found"
+                )
+        except ValidationError as e:
+            return self._error_response(
+                request_data.get("id"),
+                -32600,
+                "Invalid params",
+                e.errors()
+            )
+
+    def _handle_send_task(self, request_data: dict) -> SendTaskResponse:
+        try:
+            # Validate request format
+            request = SendTaskRequest.model_validate(request_data)
+            handler = self.handlers.get("tasks/send")
+            
+            if not handler:
+                return SendTaskResponse(
+                    id=request.id,
+                    error=MethodNotFoundError()
+                )
+
+            try:
+                raw_result = handler(request)
+            
+                if isinstance(raw_result, SendTaskResponse):
+                    return raw_result
+
+                # Use unified task builder
+                task = self._build_task(
+                    content=raw_result,
+                    task_id=request.params.id,
+                    session_id=request.params.sessionId,
+                    default_status=TaskState.COMPLETED,
+                    metadata=request.params.metadata or {}
+                )
+
+                return SendTaskResponse(
+                    id=request.id,
+                    result=task
+                )
+
+            except Exception as e:
+                # Handle case where handler returns SendTaskResponse with error
+                if isinstance(e, JSONRPCError):
+                    return SendTaskResponse(
+                        id=request.id,
+                        error=e
+                    )
+                return SendTaskResponse(
+                    id=request.id,
+                    error=InternalError(data=str(e))
+                )
+
+        except ValidationError as e:
+            return SendTaskResponse(
+                id=request_data.get("id"),
+                error=InvalidRequestError(data=e.errors())
+            )
+        except json.JSONDecodeError as e:
+            return SendTaskResponse(
+                id=request_data.get("id"),
+                error=JSONParseError(data=str(e))
+            )
+
+        
+    async def _handle_subscribe_task(self, request_data: dict) -> Union[EventSourceResponse, SendTaskStreamingResponse]:
+        try:
+            request = SendTaskStreamingRequest.model_validate(request_data)
+            handler = self.subscriptions.get("tasks/sendSubscribe")
+            
+            if not handler:
+                return SendTaskStreamingResponse(
+                    jsonrpc="2.0",
+                    id=request.id,
+                    error=MethodNotFoundError()
+                )
+
+            async def event_generator():
+                
+                try:
+                    raw_events = handler(request)
+                    normalized_events = self._normalize_subscription_events(request.params, raw_events)
+
+                    async for item in normalized_events:
+                        try:
+                            if isinstance(item, SendTaskStreamingResponse):
+                                yield item.model_dump_json()
+                                continue
+
+                            # Add validation for proper event types
+                            if not isinstance(item, (TaskStatusUpdateEvent, TaskArtifactUpdateEvent)):
+                                raise ValueError(f"Invalid event type: {type(item).__name__}")
+
+                            yield SendTaskStreamingResponse(
+                                jsonrpc="2.0",
+                                id=request.id,
+                                result=item
+                            ).model_dump_json()
+
+                        except Exception as e:
+                            yield SendTaskStreamingResponse(
+                                jsonrpc="2.0",
+                                id=request.id,
+                                error=InternalError(data=str(e))
+                            ).model_dump_json()
+                        
+
+                except Exception as e:
+                    error = InternalError(data=str(e))
+                    if "not found" in str(e).lower():
+                        error = TaskNotFoundError()
+                    yield SendTaskStreamingResponse(
+                        jsonrpc="2.0",
+                        id=request.id,
+                        error=error
+                    ).model_dump_json()
+                    
+            async def sse_stream():
+                async for chunk in event_generator():
+                    # each chunk is already JSON; SSE wants "data: <payload>\n\n"
+                    yield (f"data: {chunk}\n\n").encode("utf-8")
+
+            return StreamingResponse(
+                sse_stream(),
+                media_type="text/event-stream; charset=utf-8"
+            )
+
+
+        except ValidationError as e:
+            return SendTaskStreamingResponse(
+                jsonrpc="2.0",
+                id=request_data.get("id"),
+                error=InvalidRequestError(data=e.errors())
+            )
+        except json.JSONDecodeError as e:
+            return SendTaskStreamingResponse(
+                jsonrpc="2.0",
+                id=request_data.get("id"),
+                error=JSONParseError(data=str(e))
+            )
+        except HTTPException as e:
+            if e.status_code == 405:
+                return SendTaskStreamingResponse(
+                    jsonrpc="2.0",
+                    id=request_data.get("id"),
+                    error=UnsupportedOperationError()
+                )
+            return SendTaskStreamingResponse(
+                jsonrpc="2.0",
+                id=request_data.get("id"),
+                error=InternalError(data=str(e))
+            )
+
+
+    def _handle_get_task(self, request_data: dict) -> GetTaskResponse:
+        try:
+            # Validate request structure
+            request = GetTaskRequest.model_validate(request_data)
+            handler = self.handlers.get("tasks/get")
+            
+            if not handler:
+                return GetTaskResponse(
+                    id=request.id,
+                    error=MethodNotFoundError()
+                )
+
+            try:
+                raw_result = handler(request)
+            
+                if isinstance(raw_result, GetTaskResponse):
+                    return self._validate_response_id(raw_result, request)
+
+                # Use unified task builder with different defaults
+                task = self._build_task(
+                    content=raw_result,
+                    task_id=request.params.id,
+                    default_status=TaskState.COMPLETED,
+                    metadata=request.params.metadata or {}
+                )
+
+                return self._finalize_task_response(request, task)
+
+            except Exception as e:
+                # Handle case where handler returns SendTaskResponse with error
+                if isinstance(e, JSONRPCError):
+                    return GetTaskResponse(
+                        id=request.id,
+                        error=e
+                    )
+                return GetTaskResponse(
+                    id=request.id,
+                    error=InternalError(data=str(e))
+                )
+
+        except ValidationError as e:
+            return GetTaskResponse(
+                id=request_data.get("id"),
+                error=InvalidRequestError(data=e.errors())
+            )
+        except json.JSONDecodeError as e:
+            return GetTaskResponse(
+                id=request_data.get("id"),
+                error=JSONParseError(data=str(e))
+            )
+        
+
+    def _handle_cancel_task(self, request_data: dict) -> CancelTaskResponse:
+        try:
+            # Validate request structure
+            request = CancelTaskRequest.model_validate(request_data)
+            handler = self.handlers.get("tasks/cancel")
+            
+            if not handler:
+                return CancelTaskResponse(
+                    id=request.id,
+                    error=MethodNotFoundError()
+                )
+
+            try:
+                raw_result = handler(request)
+            
+                # Handle direct CancelTaskResponse returns
+                if isinstance(raw_result, CancelTaskResponse):
+                    return self._validate_response_id(raw_result, request)
+
+                # Handle A2AStatus returns
+                if isinstance(raw_result, A2AStatus):
+                    task = self._build_task_from_status(
+                        status=raw_result,
+                        task_id=request.params.id,
+                        metadata=raw_result.metadata or {}
+                    )
+                else:
+                    # Existing processing for other return types
+                    task = self._build_task(
+                        content=raw_result,
+                        task_id=request.params.id,
+                        metadata=raw_result.metadata or {}
+                    )
+
+                # Final validation and packaging
+                return self._finalize_cancel_response(request, task)
+
+            except Exception as e:
+                # Handle case where handler returns SendTaskResponse with error
+                if isinstance(e, JSONRPCError):
+                    return CancelTaskResponse(
+                        id=request.id,
+                        error=e
+                    )
+                return CancelTaskResponse(
+                    id=request.id,
+                    error=InternalError(data=str(e))
+                )
+
+        except ValidationError as e:
+            return CancelTaskResponse(
+                id=request_data.get("id"),
+                error=InvalidRequestError(data=e.errors())
+            )
+        except json.JSONDecodeError as e:
+            return CancelTaskResponse(
+                id=request_data.get("id"),
+                error=JSONParseError(data=str(e))
+            )
+        except HTTPException as e:
+            if e.status_code == 405:
+                return CancelTaskResponse(
+                    id=request_data.get("id"),
+                    error=UnsupportedOperationError()
+                )
+            return CancelTaskResponse(
+                id=request_data.get("id"),
+                error=InternalError(data=str(e))
+            )
+
+    def _normalize_artifacts(self, content: Any) -> List[Artifact]:
+        """Handle both A2AResponse content and regular returns"""
+        if isinstance(content, Artifact):
+            return [content]
+        
+        if isinstance(content, list):
+            # Handle list of artifacts
+            if all(isinstance(item, Artifact) for item in content):
+                return content
+            
+            # Handle mixed parts in list
+            parts = []
+            for item in content:
+                if isinstance(item, Artifact):
+                    parts.extend(item.parts)
+                else:
+                    parts.append(self._create_part(item))
+            return [Artifact(parts=parts)]
+        
+        # Handle single part returns
+        if isinstance(content, (str, Part, dict)):
+            return [Artifact(parts=[self._create_part(content)])]
+        
+        # Handle raw artifact dicts
+        try:
+            return [Artifact.model_validate(content)]
+        except ValidationError:
+            return [Artifact(parts=[TextPart(text=str(content))])]
+
+
+    def _build_task(
+    self,
+    content: Any,
+    task_id: str,
+    session_id: Optional[str] = None,
+    default_status: TaskState = TaskState.COMPLETED,
+    metadata: Optional[dict] = None
+) -> Task:
+        """Universal task construction from various return types."""
+        if isinstance(content, Task):
+            return content
+        
+        # Handle A2AResponse for sendTask case
+        if isinstance(content, A2AResponse):
+            status = content.status if isinstance(content.status, TaskStatus) \
+                else TaskStatus(state=content.status)
+            artifacts = self._normalize_content(content.content)
+            return Task(
+                id=task_id,
+                sessionId=session_id or str(uuid4()),  # Generate if missing
+                status=status,
+                artifacts=artifacts,
+                metadata=metadata or {}
+            )
+
+        try:  # Attempt direct validation for dicts
+            return Task.model_validate(content)
+        except ValidationError:
+            pass
+
+        # Fallback to content normalization
+        artifacts = self._normalize_content(content)
+        return Task(
+            id=task_id,
+            sessionId=session_id,
+            status=TaskStatus(state=default_status),
+            artifacts=artifacts,
+            metadata=metadata or {}
+        )
+    
+    def _build_task_from_status(self, status: A2AStatus, task_id: str, metadata: dict) -> Task:
+        """Convert A2AStatus to a Task with proper cancellation state."""
+        return Task(
+            id=task_id,
+            status=TaskStatus(
+                state=TaskState(status.status),
+                timestamp=datetime.now()
+            ),
+            metadata=metadata,
+            # Include empty/default values for required fields
+            sessionId="",  
+            artifacts=[],
+            history=[]
+        )
+
+
+    def _normalize_content(self, content: Any) -> List[Artifact]:
+        """Handle all content types for both sendTask and getTask cases."""
+        if isinstance(content, Artifact):
+            return [content]
+        
+        if isinstance(content, list):
+            if all(isinstance(item, Artifact) for item in content):
+                return content
+            return [Artifact(parts=self._parts_from_mixed(content))]
+        
+        if isinstance(content, (str, Part, dict)):
+            return [Artifact(parts=[self._create_part(content)])]
+        
+        try:  # Handle raw artifact dicts
+            return [Artifact.model_validate(content)]
+        except ValidationError:
+            return [Artifact(parts=[TextPart(text=str(content))])]
+
+    def _parts_from_mixed(self, items: List[Any]) -> List[Part]:
+        """Extract parts from mixed content lists."""
+        parts = []
+        for item in items:
+            if isinstance(item, Artifact):
+                parts.extend(item.parts)
+            else:
+                parts.append(self._create_part(item))
+        return parts
+
+
+    def _create_part(self, item: Any) -> Part:
+        """Convert primitive types to proper Part models"""
+        if isinstance(item, (TextPart, FilePart, DataPart)):
+            return item
+        
+        if isinstance(item, str):
+            return TextPart(text=item)
+        
+        if isinstance(item, dict):
+            try:
+                return Part.model_validate(item)
+            except ValidationError:
+                return TextPart(text=str(item))
+        
+        return TextPart(text=str(item))
+    
+
+    # Response validation helper
+    def _validate_response_id(self, response: Union[SendTaskResponse, GetTaskResponse], request) -> Union[SendTaskResponse, GetTaskResponse]:
+        if response.result and response.result.id != request.params.id:
+            return type(response)(
+                id=request.id,
+                error=InvalidParamsError(
+                    data=f"Task ID mismatch: {response.result.id} vs {request.params.id}"
+                )
+            )
+        return response
+    
+    # Might refactor this later 
+    def _finalize_task_response(self, request: GetTaskRequest, task: Task) -> GetTaskResponse:
+        """Final validation and processing for getTask responses."""
+        # Validate task ID matches request
+        if task.id != request.params.id:
+            return GetTaskResponse(
+                id=request.id,
+                error=InvalidParamsError(
+                    data=f"Task ID mismatch: {task.id} vs {request.params.id}"
+                )
+            )
+        
+        # Apply history length filtering
+        if request.params.historyLength and task.history:
+            task.history = task.history[-request.params.historyLength:]
+        
+        return GetTaskResponse(
+            id=request.id,
+            result=task
+        )
+    
+    def _finalize_cancel_response(self, request: CancelTaskRequest, task: Task) -> CancelTaskResponse:
+        """Final validation and processing for cancel responses."""
+        if task.id != request.params.id:
+            return CancelTaskResponse(
+                id=request.id,
+                error=InvalidParamsError(
+                    data=f"Task ID mismatch: {task.id} vs {request.params.id}"
+                )
+            )
+        
+        # Ensure cancellation-specific requirements are met
+        if task.status.state not in [TaskState.CANCELED, TaskState.COMPLETED]:
+            return CancelTaskResponse(
+                id=request.id,
+                error=TaskNotCancelableError()
+            )
+        
+        return CancelTaskResponse(
+            id=request.id,
+            result=task
+        )
+    
+    
+    async def _normalize_subscription_events(self, params: TaskSendParams, events: AsyncGenerator) -> AsyncGenerator[Union[SendTaskStreamingResponse, TaskStatusUpdateEvent, TaskArtifactUpdateEvent], None]:
+        artifact_state = defaultdict(lambda: {"index": 0, "last_chunk": False})
+    
+        async for item in events:
+            # Pass through fully formed responses immediately
+            if isinstance(item, SendTaskStreamingResponse):
+                yield item
+                continue
+
+            # Handle protocol status updates
+            if isinstance(item, A2AStatus):
+                yield TaskStatusUpdateEvent(
+                    id=params.id,
+                    status=TaskStatus(
+                        state=TaskState(item.status),
+                        timestamp=datetime.now()
+                    ),
+                    final=item.final or (item.status.lower() == TaskState.COMPLETED),
+                    metadata=item.metadata
+                )
+            
+            # Handle stream content
+            elif isinstance(item, (A2AStreamResponse, str, bytes, TextPart, FilePart, DataPart, Artifact, list)):
+                # Convert to A2AStreamResponse if needed
+                if not isinstance(item, A2AStreamResponse):
+                    item = A2AStreamResponse(content=item)
+
+                # Process content into parts
+                parts = []
+                content = item.content
+                
+                if isinstance(content, str):
+                    parts.append(TextPart(text=content))
+                elif isinstance(content, bytes):
+                    parts.append(FilePart(file=FileContent(bytes=content)))
+                elif isinstance(content, (TextPart, FilePart, DataPart)):
+                    parts.append(content)
+                elif isinstance(content, Artifact):
+                    parts = content.parts
+                elif isinstance(content, list):
+                    for elem in content:
+                        if isinstance(elem, str):
+                            parts.append(TextPart(text=elem))
+                        elif isinstance(elem, (TextPart, FilePart, DataPart)):
+                            parts.append(elem)
+                        elif isinstance(elem, Artifact):
+                            parts.extend(elem.parts)
+
+                # Track artifact state
+                artifact_idx = item.index
+                state = artifact_state[artifact_idx]
+                
+                yield TaskArtifactUpdateEvent(
+                    id=params.id,
+                    artifact=Artifact(
+                        parts=parts,
+                        index=artifact_idx,
+                        append=item.append or state["index"] == artifact_idx,
+                        lastChunk=item.final or state["last_chunk"],
+                        metadata=item.metadata
+                    )
+                )
+                
+                # Update artifact state tracking
+                if item.final:
+                    state["last_chunk"] = True
+                state["index"] += 1
+            
+            # Pass through protocol events directly
+            elif isinstance(item, (TaskStatusUpdateEvent, TaskArtifactUpdateEvent)):
+                yield item
+            
+            # Handle invalid types
+            else:
+                yield SendTaskStreamingResponse(
+                    jsonrpc="2.0",
+                    id=params.id,  # Typically comes from request, but using params.id as fallback
+                    error=InvalidParamsError(
+                        data=f"Unsupported event type: {type(item).__name__}"
+                    )
+                )
+    
+
+    def configure(self, **kwargs):
+        self.server_config.update(kwargs)
+
+    def add_cors_middleware(self, **kwargs):
+        self.app.add_middleware(
+            CORSMiddleware,
+            **{k: v for k, v in kwargs.items() if v is not None}
+        )
+
+    def run(self):
+        uvicorn.run(
+            self.app,
+            host=self.server_config["host"],
+            port=self.server_config["port"],
+            reload=self.server_config["reload"]
+        )

fasta2a/types.py

@@ -0,0 +1,424 @@
+from typing import Union, Any
+from pydantic import BaseModel, Field, TypeAdapter
+from typing import Literal, List, Annotated, Optional
+from datetime import datetime
+from pydantic import model_validator, ConfigDict, field_serializer, field_validator
+from uuid import uuid4
+from enum import Enum
+from typing_extensions import Self
+
+
+class TaskState(str, Enum):
+    SUBMITTED = "submitted"
+    WORKING = "working"
+    INPUT_REQUIRED = "input-required"
+    COMPLETED = "completed"
+    CANCELED = "canceled"
+    FAILED = "failed"
+    UNKNOWN = "unknown"
+
+
+class TextPart(BaseModel):
+    type: Literal["text"] = "text"
+    text: str
+    metadata: dict[str, Any] | None = None
+
+
+class FileContent(BaseModel):
+    name: str | None = None
+    mimeType: str | None = None
+    bytes: str | None = None
+    uri: str | None = None
+
+    @model_validator(mode="after")
+    def check_content(self) -> Self:
+        if not (self.bytes or self.uri):
+            raise ValueError("Either 'bytes' or 'uri' must be present in the file data")
+        if self.bytes and self.uri:
+            raise ValueError(
+                "Only one of 'bytes' or 'uri' can be present in the file data"
+            )
+        return self
+
+
+class FilePart(BaseModel):
+    type: Literal["file"] = "file"
+    file: FileContent
+    metadata: dict[str, Any] | None = None
+
+
+class DataPart(BaseModel):
+    type: Literal["data"] = "data"
+    data: dict[str, Any]
+    metadata: dict[str, Any] | None = None
+
+
+Part = Annotated[Union[TextPart, FilePart, DataPart], Field(discriminator="type")]
+
+
+class Message(BaseModel):
+    role: Literal["user", "agent"]
+    parts: List[Part]
+    metadata: dict[str, Any] | None = None
+
+
+class TaskStatus(BaseModel):
+    state: TaskState
+    message: Message | None = None
+    timestamp: datetime = Field(default_factory=datetime.now)
+
+    @field_serializer("timestamp")
+    def serialize_dt(self, dt: datetime, _info):
+        return dt.isoformat()
+
+
+class Artifact(BaseModel):
+    name: str | None = None
+    description: str | None = None
+    parts: List[Part]
+    metadata: dict[str, Any] | None = None
+    index: int = 0
+    append: bool | None = None
+    lastChunk: bool | None = None
+
+
+class Task(BaseModel):
+    id: str
+    sessionId: str | None = None
+    status: TaskStatus
+    artifacts: List[Artifact] | None = None
+    history: List[Message] | None = None
+    metadata: dict[str, Any] | None = None
+
+
+class TaskStatusUpdateEvent(BaseModel):
+    id: str
+    status: TaskStatus
+    final: bool = False
+    metadata: dict[str, Any] | None = None
+
+
+class TaskArtifactUpdateEvent(BaseModel):
+    id: str
+    artifact: Artifact    
+    metadata: dict[str, Any] | None = None
+
+
+class AuthenticationInfo(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+    schemes: List[str]
+    credentials: str | None = None
+
+
+class PushNotificationConfig(BaseModel):
+    url: str
+    token: str | None = None
+    authentication: AuthenticationInfo | None = None
+
+
+class TaskIdParams(BaseModel):
+    id: str
+    metadata: dict[str, Any] | None = None
+
+
+class TaskQueryParams(TaskIdParams):
+    historyLength: int | None = None
+
+
+class TaskSendParams(BaseModel):
+    id: str
+    sessionId: str = Field(default_factory=lambda: uuid4().hex)
+    message: Message
+    acceptedOutputModes: Optional[List[str]] = None
+    pushNotification: PushNotificationConfig | None = None
+    historyLength: int | None = None
+    metadata: dict[str, Any] | None = None
+
+
+class TaskPushNotificationConfig(BaseModel):
+    id: str
+    pushNotificationConfig: PushNotificationConfig
+
+
+## Custom Mixins
+
+class ContentMixin(BaseModel):
+    @property
+    def content(self) -> Optional[List[Part]]:
+        """Direct access to message parts when available"""
+        try:
+            # Handle different request types that contain messages
+            if hasattr(self.params, 'message'):
+                return self.params.message.parts
+            if hasattr(self, 'message'):
+                return self.message.parts
+        except AttributeError:
+            pass
+        return None
+
+## RPC Messages
+
+
+class JSONRPCMessage(BaseModel):
+    jsonrpc: Literal["2.0"] = "2.0"
+    id: int | str | None = Field(default_factory=lambda: uuid4().hex)
+
+
+class JSONRPCRequest(JSONRPCMessage):
+    method: str
+    params: dict[str, Any] | None = None
+
+
+class JSONRPCError(BaseModel):
+    code: int
+    message: str
+    data: Any | None = None
+
+
+class JSONRPCResponse(JSONRPCMessage):
+    result: Any | None = None
+    error: JSONRPCError | None = None
+
+
+class SendTaskRequest(JSONRPCRequest, ContentMixin):
+    method: Literal["tasks/send"] = "tasks/send"
+    params: TaskSendParams
+
+
+class SendTaskResponse(JSONRPCResponse):
+    result: Task | None = None
+
+
+class SendTaskStreamingRequest(JSONRPCRequest, ContentMixin):
+    method: Literal["tasks/sendSubscribe"] = "tasks/sendSubscribe"
+    params: TaskSendParams
+
+
+class SendTaskStreamingResponse(JSONRPCResponse):
+    result: TaskStatusUpdateEvent | TaskArtifactUpdateEvent | None = None
+
+
+class GetTaskRequest(JSONRPCRequest, ContentMixin):
+    method: Literal["tasks/get"] = "tasks/get"
+    params: TaskQueryParams
+
+
+class GetTaskResponse(JSONRPCResponse):
+    result: Task | None = None
+
+
+class CancelTaskRequest(JSONRPCRequest, ContentMixin):
+    method: Literal["tasks/cancel",] = "tasks/cancel"
+    params: TaskIdParams
+
+
+class CancelTaskResponse(JSONRPCResponse):
+    result: Task | None = None
+
+
+class SetTaskPushNotificationRequest(JSONRPCRequest, ContentMixin):
+    method: Literal["tasks/pushNotification/set",] = "tasks/pushNotification/set"
+    params: TaskPushNotificationConfig
+
+
+class SetTaskPushNotificationResponse(JSONRPCResponse):
+    result: TaskPushNotificationConfig | None = None
+
+
+class GetTaskPushNotificationRequest(JSONRPCRequest, ContentMixin):
+    method: Literal["tasks/pushNotification/get",] = "tasks/pushNotification/get"
+    params: TaskIdParams
+
+
+class GetTaskPushNotificationResponse(JSONRPCResponse):
+    result: TaskPushNotificationConfig | None = None
+
+
+class TaskResubscriptionRequest(JSONRPCRequest, ContentMixin):
+    method: Literal["tasks/resubscribe",] = "tasks/resubscribe"
+    params: TaskIdParams
+
+
+A2ARequest = TypeAdapter(
+    Annotated[
+        Union[
+            SendTaskRequest,
+            GetTaskRequest,
+            CancelTaskRequest,
+            SetTaskPushNotificationRequest,
+            GetTaskPushNotificationRequest,
+            TaskResubscriptionRequest,
+            SendTaskStreamingRequest,
+        ],
+        Field(discriminator="method"),
+    ]
+)
+
+## Error types
+
+
+class JSONParseError(JSONRPCError):
+    code: int = -32700
+    message: str = "Invalid JSON payload"
+    data: Any | None = None
+
+
+class InvalidRequestError(JSONRPCError):
+    code: int = -32600
+    message: str = "Request payload validation error"
+    data: Any | None = None
+
+
+class MethodNotFoundError(JSONRPCError):
+    code: int = -32601
+    message: str = "Method not found"
+    data: None = None
+
+
+class InvalidParamsError(JSONRPCError):
+    code: int = -32602
+    message: str = "Invalid parameters"
+    data: Any | None = None
+
+
+class InternalError(JSONRPCError):
+    code: int = -32603
+    message: str = "Internal error"
+    data: Any | None = None
+
+
+class TaskNotFoundError(JSONRPCError):
+    code: int = -32001
+    message: str = "Task not found"
+    data: None = None
+
+
+class TaskNotCancelableError(JSONRPCError):
+    code: int = -32002
+    message: str = "Task cannot be canceled"
+    data: None = None
+
+
+class PushNotificationNotSupportedError(JSONRPCError):
+    code: int = -32003
+    message: str = "Push Notification is not supported"
+    data: None = None
+
+
+class UnsupportedOperationError(JSONRPCError):
+    code: int = -32004
+    message: str = "This operation is not supported"
+    data: None = None
+
+
+class ContentTypeNotSupportedError(JSONRPCError):
+    code: int = -32005
+    message: str = "Incompatible content types"
+    data: None = None
+
+
+class AgentProvider(BaseModel):
+    organization: str
+    url: str | None = None
+
+
+class AgentCapabilities(BaseModel):
+    streaming: bool = False
+    pushNotifications: bool = False
+    stateTransitionHistory: bool = False
+
+
+class AgentAuthentication(BaseModel):
+    schemes: List[str]
+    credentials: str | None = None
+
+
+class AgentSkill(BaseModel):
+    id: str
+    name: str
+    description: str | None = None
+    tags: List[str] | None = None
+    examples: List[str] | None = None
+    inputModes: List[str] | None = None
+    outputModes: List[str] | None = None
+
+
+class AgentCard(BaseModel):
+    name: str
+    description: str | None = None
+    url: str
+    provider: AgentProvider | None = None
+    version: str
+    documentationUrl: str | None = None
+    capabilities: AgentCapabilities
+    authentication: AgentAuthentication | None = None
+    defaultInputModes: List[str] = ["text"]
+    defaultOutputModes: List[str] = ["text"]
+    skills: List[AgentSkill]
+
+
+class A2AClientError(Exception):
+    pass
+
+
+class A2AClientHTTPError(A2AClientError):
+    def __init__(self, status_code: int, message: str):
+        self.status_code = status_code
+        self.message = message
+        super().__init__(f"HTTP Error {status_code}: {message}")
+
+
+class A2AClientJSONError(A2AClientError):
+    def __init__(self, message: str):
+        self.message = message
+        super().__init__(f"JSON Error: {message}")
+
+
+class MissingAPIKeyError(Exception):
+    """Exception for missing API key."""
+
+    pass
+
+"""
+Beyond this point, the types are not part of the A2A protocol. 
+They are used to help with the implementation of the server.
+"""
+
+class A2AResponse(BaseModel):
+    status: Union[TaskStatus, str]
+    content: Union[str, List[Any], Part, Artifact, List[Part], List[Artifact]]
+    
+    @model_validator(mode="after")
+    def validate_state(self) -> 'A2AResponse':
+        if isinstance(self.status, str):
+            try:
+                self.status = TaskStatus(state=self.status.lower())
+            except ValueError:
+                raise ValueError(f"Invalid state: {self.status}")
+        return self
+    
+class A2AStatus(BaseModel):
+    status: str
+    metadata: dict[str, Any] | None = None
+    final: bool = False
+
+    @field_validator('status')
+    def validate_status(cls, v):
+        valid_states = {e.value for e in TaskState}
+        if v.lower() not in valid_states:
+            raise ValueError(f"Invalid status: {v}. Valid states: {valid_states}")
+        return v.lower()
+
+    @field_validator('final', mode='after')
+    def set_final_for_completed(cls, v, values):
+        if values.data.get('status') == TaskState.COMPLETED:
+            return True
+        return v
+
+class A2AStreamResponse(BaseModel):
+    content: Union[str, Part, List[Union[str, Part]], Artifact]
+    index: int = 0
+    append: bool = False
+    final: bool = False
+    metadata: dict[str, Any] | None = None

smarta2a-0.1.0.dist-info/METADATA

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: smarta2a
+Version: 0.1.0
+Summary: A Python package for creating servers and clients following Google's Agent2Agent protocol
+Project-URL: Homepage, https://github.com/siddharthsma/fasta2a
+Project-URL: Bug Tracker, https://github.com/siddharthsma/fasta2a/issues
+Author-email: Siddharth Ambegaonkar <siddharthsma@gmail.com>
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Requires-Dist: fastapi
+Requires-Dist: pydantic
+Requires-Dist: sse-starlette
+Requires-Dist: uvicorn
+Description-Content-Type: text/markdown
+
+# FastA2A
+
+A Python package for creating a server following Google's Agent2Agent protocol
+
+## Features
+
+✅ **Full A2A Protocol Compliance** - Implements all required endpoints and response formats
+
+⚡ **Decorator-Driven Development** - Rapid endpoint configuration with type safety
+
+🧩 **Automatic Protocol Conversion** - Simple returns become valid A2A responses 
+
+🔀 **Flexible Response Handling** - Support for Tasks, Artifacts, Streaming, and raw protocol types if needed!
+
+🛡️ **Built-in Validation** - Automatic Pydantic validation of A2A schemas  
+
+⚡ **Single File Setup** - Get compliant in <10 lines of code
+
+🌍 **Production Ready** - CORS, async support, and error handling included
+
+## Installation
+
+```bash
+pip install fasta2a
+```
+
+## Simple Echo Server Implementation
+
+```python
+from fasta2a import FastA2A
+
+app = FastA2A("EchoServer")
+
+@app.on_send_task()
+def handle_task(request):
+    """Echo the input text back as a completed task"""
+    input_text = request.content[0].text
+    return f"Echo: {input_text}"
+
+if __name__ == "__main__":
+    app.run()
+```
+
+Automatically contructs the response:
+
+```json
+{
+  "jsonrpc": "2.0",
+  "id": "test",
+  "result": {
+    "id": "echo-task",
+    "status": {"state": "completed"},
+    "artifacts": [{
+      "parts": [{"type": "text", "text": "Echo: Hello!"}]
+    }]
+  }
+}
+```
+
+## Development
+
+To set up the development environment:
+
+```bash
+# Clone the repository
+git clone https://github.com/siddharthsma/fasta2a.git
+cd fasta2a
+
+# Create and activate virtual environment
+python -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+
+# Install development dependencies
+pip install -e ".[dev]"
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details. 

smarta2a-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+fasta2a/__init__.py,sha256=lW8fJ0XHZJVZC4Oy18UxJjxtxuSco878tV6wAKiCzw0,150
+fasta2a/server.py,sha256=Ge0eh6Go8P9LUmQwmFysTx2YSvRoWk3UIkVh7o-mAHU,26115
+fasta2a/types.py,sha256=_UuFtOsnHIIqfQ2m_FiIBBp141iYmhpPGgxE0jmHSHg,10807
+smarta2a-0.1.0.dist-info/METADATA,sha256=a8EA5KXN0YIwnkpoLSOJMh2gi8Vpn0XLes6lWvlYa0Y,2469
+smarta2a-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+smarta2a-0.1.0.dist-info/licenses/LICENSE,sha256=ECMEVHuFkvpEmH-_A9HSxs_UnnsUqpCkiAYNHPCf2z0,1078
+smarta2a-0.1.0.dist-info/RECORD,,

smarta2a-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

smarta2a-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Siddharth Ambegaonkar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.