Upgrade a2a to spec v0.2.3

docs/a2a.md

@@ -32,7 +32,7 @@ The library is designed to be used with any agentic framework, and is **not excl
 Given the nature of the A2A protocol, it's important to understand the design before using it, as a developer
 you'll need to provide some components:
 
-- [`Storage`][fasta2a.Storage]: to save and load tasks
+- [`Storage`][fasta2a.Storage]: to save and load tasks, as well as store context for conversations
 - [`Broker`][fasta2a.Broker]: to schedule tasks
 - [`Worker`][fasta2a.Worker]: to execute tasks
 
@@ -55,6 +55,28 @@ flowchart TB
 
 FastA2A allows you to bring your own [`Storage`][fasta2a.Storage], [`Broker`][fasta2a.Broker] and [`Worker`][fasta2a.Worker].
 
+#### Understanding Tasks and Context
+
+In the A2A protocol:
+
+- **Task**: Represents one complete execution of an agent. When a client sends a message to the agent, a new task is created. The agent runs until completion (or failure), and this entire execution is considered one task. The final output is stored as a task artifact.
+
+- **Context**: Represents a conversation thread that can span multiple tasks. The A2A protocol uses a `context_id` to maintain conversation continuity:
+  - When a new message is sent without a `context_id`, the server generates a new one
+  - Subsequent messages can include the same `context_id` to continue the conversation
+  - All tasks sharing the same `context_id` have access to the complete message history
+
+#### Storage Architecture
+
+The [`Storage`][fasta2a.Storage] component serves two purposes:
+
+1. **Task Storage**: Stores tasks in A2A protocol format, including their status, artifacts, and message history
+2. **Context Storage**: Stores conversation context in a format optimized for the specific agent implementation
+
+This design allows for agents to store rich internal state (e.g., tool calls, reasoning traces) as well as store task-specific A2A-formatted messages and artifacts.
+
+For example, a PydanticAI agent might store its complete internal message format (including tool calls and responses) in the context storage, while storing only the A2A-compliant messages in the task history.
+
 
 ### Installation
 
@@ -94,3 +116,12 @@ uvicorn agent_to_a2a:app --host 0.0.0.0 --port 8000
 ```
 
 Since the goal of `to_a2a` is to be a convenience method, it accepts the same arguments as the [`FastA2A`][fasta2a.FastA2A] constructor.
+
+When using `to_a2a()`, PydanticAI automatically:
+
+- Stores the complete conversation history (including tool calls and responses) in the context storage
+- Ensures that subsequent messages with the same `context_id` have access to the full conversation history
+- Persists agent results as A2A artifacts:
+  - String results become `TextPart` artifacts and also appear in the message history
+  - Structured data (Pydantic models, dataclasses, tuples, etc.) become `DataPart` artifacts with the data wrapped as `{"result": <your_data>}`
+  - Artifacts include metadata with type information and JSON schema when available

fasta2a/fasta2a/applications.py

@@ -116,8 +116,12 @@ async def _agent_run_endpoint(self, request: Request) -> Response:
         data = await request.body()
         a2a_request = a2a_request_ta.validate_json(data)
 
-        if a2a_request['method'] == 'tasks/send':
-            jsonrpc_response = await self.task_manager.send_task(a2a_request)
+        if a2a_request['method'] == 'message/send':
+            jsonrpc_response = await self.task_manager.send_message(a2a_request)
+        elif a2a_request['method'] == 'message/stream':
+            raise NotImplementedError(
+                'message/stream method is not implemented yet. Streaming support will be added in a future update.'
+            )
         elif a2a_request['method'] == 'tasks/get':
             jsonrpc_response = await self.task_manager.get_task(a2a_request)
         elif a2a_request['method'] == 'tasks/cancel':

fasta2a/fasta2a/client.py

@@ -9,14 +9,15 @@
     GetTaskRequest,
     GetTaskResponse,
     Message,
-    PushNotificationConfig,
-    SendTaskRequest,
-    SendTaskResponse,
-    TaskSendParams,
+    MessageSendConfiguration,
+    MessageSendParams,
+    SendMessageRequest,
+    SendMessageResponse,
     a2a_request_ta,
+    send_message_request_ta,
+    send_message_response_ta,
 )
 
-send_task_response_ta = pydantic.TypeAdapter(SendTaskResponse)
 get_task_response_ta = pydantic.TypeAdapter(GetTaskResponse)
 
 try:
@@ -37,26 +38,30 @@ def __init__(self, base_url: str = 'http://localhost:8000', http_client: httpx.A
             self.http_client = http_client
             self.http_client.base_url = base_url
 
-    async def send_task(
+    async def send_message(
         self,
         message: Message,
-        history_length: int | None = None,
-        push_notification: PushNotificationConfig | None = None,
+        *,
         metadata: dict[str, Any] | None = None,
-    ) -> SendTaskResponse:
-        task = TaskSendParams(message=message, id=str(uuid.uuid4()))
-        if history_length is not None:
-            task['history_length'] = history_length
-        if push_notification is not None:
-            task['push_notification'] = push_notification
+        configuration: MessageSendConfiguration | None = None,
+    ) -> SendMessageResponse:
+        """Send a message using the A2A protocol.
+
+        Returns a JSON-RPC response containing either a result (Task | Message) or an error.
+        """
+        params = MessageSendParams(message=message)
         if metadata is not None:
-            task['metadata'] = metadata
+            params['metadata'] = metadata
+        if configuration is not None:
+            params['configuration'] = configuration
 
-        payload = SendTaskRequest(jsonrpc='2.0', id=None, method='tasks/send', params=task)
-        content = a2a_request_ta.dump_json(payload, by_alias=True)
+        request_id = str(uuid.uuid4())
+        payload = SendMessageRequest(jsonrpc='2.0', id=request_id, method='message/send', params=params)
+        content = send_message_request_ta.dump_json(payload, by_alias=True)
         response = await self.http_client.post('/', content=content, headers={'Content-Type': 'application/json'})
         self._raise_for_status(response)
-        return send_task_response_ta.validate_json(response.content)
+
+        return send_message_response_ta.validate_json(response.content)
 
     async def get_task(self, task_id: str) -> GetTaskResponse:
         payload = GetTaskRequest(jsonrpc='2.0', id=None, method='tasks/get', params={'id': task_id})