support for stateless txns and clean up

Change-Id: If8efb709923d8cfe261e2317a222a3fd172ade13

Author: kthota-g

examples/demo/__main__.py

@@ -0,0 +1,38 @@
+from agent_executor import HelloWorldAgentExecutor
+
+from a2a.server import A2AServer, DefaultA2ARequestHandler
+from a2a.types import (
+    AgentAuthentication,
+    AgentCapabilities,
+    AgentCard,
+    AgentSkill,
+)
+
+
+if __name__ == '__main__':
+    skill = AgentSkill(
+        id='hello_world',
+        name='Returns hello world',
+        description='just returns hello world',
+        tags=['hello world'],
+        examples=['hi', 'hello world'],
+    )
+
+    agent_card = AgentCard(
+        name='Hello World Agent',
+        description='Just a hello world agent',
+        url='http://localhost:9999/',
+        version='1.0.0',
+        defaultInputModes=['text'],
+        defaultOutputModes=['text'],
+        capabilities=AgentCapabilities(),
+        skills=[skill],
+        authentication=AgentAuthentication(schemes=['public']),
+    )
+
+    request_handler = DefaultA2ARequestHandler(
+        agent_executor=HelloWorldAgentExecutor()
+    )
+
+    server = A2AServer(agent_card=agent_card, request_handler=request_handler)
+    server.start(host='0.0.0.0', port=9999)

examples/demo/agent_proxy.py

@@ -0,0 +1,93 @@
+import asyncio
+
+from collections.abc import AsyncGenerator
+from typing import Any
+from uuid import uuid4
+
+from a2a.server import AgentExecutor
+from a2a.types import (
+    CancelTaskRequest,
+    CancelTaskResponse,
+    JSONRPCErrorResponse,
+    Message,
+    Part,
+    Role,
+    SendMessageRequest,
+    SendMessageResponse,
+    SendMessageStreamingRequest,
+    SendMessageStreamingResponse,
+    SendMessageStreamingSuccessResponse,
+    SendMessageSuccessResponse,
+    Task,
+    TaskResubscriptionRequest,
+    TextPart,
+    UnsupportedOperationError,
+)
+
+
+class HelloWorldAgent:
+    """Hello World Agent."""
+
+    async def invoke(self):
+        return 'Hello World'
+
+    async def stream(self) -> AsyncGenerator[dict[str, Any], None]:
+        yield {'content': 'Hello ', 'done': False}
+        await asyncio.sleep(2)
+        yield {'content': 'World', 'done': True}
+
+
+class HelloWorldAgentExecutor(AgentExecutor):
+    """Test AgentProxy Implementation."""
+
+    def __init__(self):
+        self.agent = HelloWorldAgent()
+
+    async def on_message_send(
+        self, request: SendMessageRequest, task: Task | None
+    ) -> SendMessageResponse:
+        result = await self.agent.invoke()
+
+        message: Message = Message(
+            role=Role.agent,
+            parts=[Part(root=TextPart(text=result))],
+            messageId=str(uuid4()),
+        )
+
+        return SendMessageResponse(
+            root=SendMessageSuccessResponse(id=request.id, result=message)
+        )
+
+    async def on_message_stream(  # type: ignore
+        self, request: SendMessageStreamingRequest, task: Task | None
+    ) -> AsyncGenerator[SendMessageStreamingResponse, None]:
+        async for chunk in self.agent.stream():
+            message: Message = Message(
+                role=Role.agent,
+                parts=[Part(root=TextPart(text=chunk['content']))],
+                messageId=str(uuid4()),
+                final=chunk['done'],
+            )
+            yield SendMessageStreamingResponse(
+                root=SendMessageStreamingSuccessResponse(
+                    id=request.id, result=message
+                )
+            )
+
+    async def on_cancel(
+        self, request: CancelTaskRequest, task: Task
+    ) -> CancelTaskResponse:
+        return CancelTaskResponse(
+            root=JSONRPCErrorResponse(
+                id=request.id, error=UnsupportedOperationError()
+            )
+        )
+
+    async def on_resubscribe(  # type: ignore
+        self, request: TaskResubscriptionRequest, task: Task
+    ) -> AsyncGenerator[SendMessageStreamingResponse, None]:
+        yield SendMessageStreamingResponse(
+            root=JSONRPCErrorResponse(
+                id=request.id, error=UnsupportedOperationError()
+            )
+        )

examples/demo/test_client.py

@@ -0,0 +1,54 @@
+from a2a.client import A2AClient
+from typing import Any
+import httpx
+from uuid import uuid4
+from a2a.types import SendMessageSuccessResponse, Task
+
+
+async def main() -> None:
+    async with httpx.AsyncClient() as httpx_client:
+        client = await A2AClient.get_client_from_agent_card_url(
+            httpx_client, 'http://localhost:9999'
+        )
+        send_message_payload: dict[str, Any] = {
+            'message': {
+                'role': 'user',
+                'parts': [
+                    {'type': 'text', 'text': 'how much is 10 USD in INR?'}
+                ],
+                'messageId': uuid4().hex,
+            },
+        }
+
+        response = await client.send_message(payload=send_message_payload)
+        print(response.model_dump(mode='json', exclude_none=True))
+
+        if isinstance(response.root, SendMessageSuccessResponse) and isinstance(
+            response.root.result, Task
+        ):
+            task_id: str = response.root.result.id
+            get_task_payload = {'id': task_id}
+            get_response = await client.get_task(payload=get_task_payload)
+            print(get_response.model_dump(mode='json', exclude_none=True))
+
+            cancel_task_payload = {'id': task_id}
+            cancel_response = await client.cancel_task(
+                payload=cancel_task_payload
+            )
+            print(cancel_response.model_dump(mode='json', exclude_none=True))
+        else:
+            print(
+                'Received an instance of Message, getTask and cancelTask are not applicable for invocation'
+            )
+
+        stream_response = client.send_message_streaming(
+            payload=send_message_payload
+        )
+        async for chunk in stream_response:
+            print(chunk.model_dump(mode='json', exclude_none=True))
+
+
+if __name__ == '__main__':
+    import asyncio
+
+    asyncio.run(main())