rasa-pro 3.14.0.dev7__py3-none-any.whl → 3.14.0.dev9__py3-none-any.whl

rasa/agents/protocol/a2a/a2a_agent.py

@@ -1,50 +1,49 @@
 import asyncio
 import json
 import os
+import time
 import uuid
-from typing import Any, Dict, List, Optional
+from typing import Any, ClassVar, Dict, List, Optional
 from urllib.parse import urlparse
 
 import httpx
 import structlog
 from a2a.client import (
     A2ACardResolver,
-    A2AClient,
     A2AClientError,
     A2AClientHTTPError,
     A2AClientJSONError,
+    Client,
+    ClientConfig,
+    ClientEvent,
+    ClientFactory,
 )
+from a2a.client.errors import A2AClientJSONRPCError
 from a2a.types import (
-    AgentCapabilities,
     AgentCard,
-    AgentSkill,
+    Artifact,
     DataPart,
     FilePart,
     FileWithUri,
     InternalError,
     InvalidAgentResponseError,
-    JSONRPCErrorResponse,
     Message,
-    MessageSendConfiguration,
-    MessageSendParams,
     Part,
     Role,
-    SendStreamingMessageRequest,
-    SendStreamingMessageResponse,
     Task,
-    TaskArtifactUpdateEvent,
+    TaskQueryParams,
     TaskState,
-    TaskStatus,
-    TaskStatusUpdateEvent,
     TextPart,
+    TransportProtocol,
 )
+from pydantic import ValidationError
 
 from rasa.agents.constants import (
     A2A_AGENT_CONTEXT_ID_KEY,
     A2A_AGENT_TASK_ID_KEY,
     AGENT_DEFAULT_MAX_RETRIES,
     AGENT_DEFAULT_TIMEOUT_SECONDS,
-    AGENT_METADATA_TOOL_RESULTS_KEY,
+    AGENT_METADATA_STRUCTURED_RESULTS_KEY,
     MAX_AGENT_RETRY_DELAY_SECONDS,
 )
 from rasa.agents.core.agent_protocol import AgentProtocol
@@ -57,12 +56,21 @@ from rasa.shared.exceptions import (
     RasaException,
 )
 
+A2A_TASK_POOLING_INITIAL_DELAY = 0.5
+A2A_TASK_POOLING_MAX_WAIT = 60
+
 structlogger = structlog.get_logger()
 
 
 class A2AAgent(AgentProtocol):
     """A2A client implementation"""
 
+    __SUPPORTED_OUTPUT_MODES: ClassVar[list[str]] = [
+        "text",
+        "text/plain",
+        "application/json",
+    ]
+
     def __init__(
         self,
         name: str,
@@ -78,7 +86,7 @@ class A2AAgent(AgentProtocol):
         self._max_retries = max_retries
 
         self.agent_card: Optional[AgentCard] = None
-        self._client: Optional[A2AClient] = None
+        self._client: Optional[Client] = None
 
     @classmethod
     def from_config(cls, config: AgentConfig) -> AgentProtocol:
@@ -132,15 +140,12 @@ class A2AAgent(AgentProtocol):
         )
 
         try:
-            self._client = A2AClient(
-                httpx.AsyncClient(timeout=self._timeout), agent_card=self.agent_card
-            )
+            self._client = self._init_client()
             structlogger.debug(
-                "a2a_agent.connect.success",
-                event_info=f"Connected to A2A server '{self._name}' "
-                f"at {self.agent_card.url}",
+                "a2a_agent.connect.agent_client_initialized",
+                event_info=f"Initialized A2A client for agent '{self._name}'. "
+                f"Performing health check using the URL {self.agent_card.url}",
             )
-            # TODO: Make a test request to /tasks to verify the connection
         except Exception as exception:
             structlogger.error(
                 "a2a_agent.connect.error",
@@ -153,6 +158,13 @@ class A2AAgent(AgentProtocol):
                 f"'{self._name}': {exception}"
             ) from exception
 
+        await self._perform_health_check()
+        structlogger.debug(
+            "a2a_agent.connect.success",
+            event_info=f"Connected to A2A server '{self._name}' "
+            f"at {self.agent_card.url}",
+        )
+
     async def disconnect(self) -> None:
         """We don't need to explicitly disconnect the A2A client"""
         return
@@ -167,7 +179,7 @@ class A2AAgent(AgentProtocol):
         if not self._client or not self.agent_card:
             structlogger.error(
                 "a2a_agent.run.error",
-                event_info="A2A client is not initialized. " "Call connect() first.",
+                event_info="A2A client is not initialized. Call connect() first.",
             )
             return AgentOutput(
                 id=agent_input.id,
@@ -175,121 +187,129 @@ class A2AAgent(AgentProtocol):
                 error_message="Client not initialized",
             )
 
-        if self.agent_card.capabilities.streaming:
-            structlogger.info(
-                "a2a_agent.run.streaming",
-                event_info="Running A2A agent in streaming mode",
-                agent_name=self._name,
-            )
-            return await self._run_streaming_agent(agent_input)
-        else:
-            # we dont support non-streaming mode yet
+        structlogger.info(
+            "a2a_agent.run.start",
+            event_info="Running A2A agent",
+            agent_name=self._name,
+        )
+        message = self._prepare_message(agent_input)
+
+        task_id: Optional[str] = None
+        events_received = 0
+        try:
+            async for event in self._client.send_message(message):
+                events_received += 1
+                agent_output = self._handle_send_message_response(agent_input, event)
+                if agent_output is not None:
+                    return agent_output
+                else:
+                    # Not a terminal response, save taskID (in case that's the only
+                    # event, and we need to pool) and continue waiting for next events
+                    if (
+                        isinstance(event, tuple)
+                        and len(event) == 2
+                        and isinstance(event[0], Task)
+                    ):
+                        task_id = event[0].id
+                    continue
+        except A2AClientJSONRPCError as e:
+            return self._handle_json_rpc_error_response(agent_input, e.error)
+        except A2AClientError as exception:
             structlogger.error(
-                "a2a_agent.run.error",
-                event_info="Non-streaming mode is currently not supported",
+                "a2a_agent.run.send_message.error",
+                event_info="Error during sending message to A2A agent",
                 agent_name=self._name,
+                error=str(exception),
             )
             return AgentOutput(
                 id=agent_input.id,
                 status=AgentStatus.FATAL_ERROR,
-                error_message="Non-streaming mode is not supported",
+                error_message=f"Send message error: {exception!s}",
             )
 
-    async def process_output(self, output: AgentOutput) -> AgentOutput:
-        """Post-process the output before returning it to Rasa."""
-        # A2A-specific output processing logic
-        return output
-
-    async def _run_streaming_agent(self, agent_input: AgentInput) -> AgentOutput:
-        if not self._client:
+        # The stream has ended, but we didn't get a terminal response.
+        # Check if we received any events at all.
+        if events_received == 0:
             structlogger.error(
-                "a2a_agent.run_streaming_agent.error",
-                event_info="A2A client is not initialized. Call connect() first.",
+                "a2a_agent.run.no_events_received",
+                event_info="No events received from A2A agent after sending message",
+                agent_name=self._name,
             )
             return AgentOutput(
                 id=agent_input.id,
-                status=AgentStatus.FATAL_ERROR,
-                error_message="Client not initialized",
+                status=AgentStatus.RECOVERABLE_ERROR,
+                error_message="No events received from A2A agent",
             )
-        message_send_params = self._prepare_message_send_params(agent_input)
-
-        try:
-            async for response in self._client.send_message_streaming(
-                SendStreamingMessageRequest(
-                    id=str(uuid.uuid4()), params=message_send_params
-                )
-            ):
-                agent_output = self._handle_streaming_response(agent_input, response)
-                if agent_output is not None:
-                    return agent_output
-                else:
-                    # Not a terminal response, continue waiting for next responses
-                    continue
 
-        except A2AClientError as exception:
+        # Now we need to poll the task until it reaches a terminal state.
+        if not task_id:
             structlogger.error(
-                "a2a_agent.run_streaming_agent.error",
-                event_info="Error during streaming message to A2A server",
+                "a2a_agent.run.pooling.missing_id",
+                event_info="Missing task_id for polling",
                 agent_name=self._name,
-                error=str(exception),
+                task_id=task_id,
             )
             return AgentOutput(
                 id=agent_input.id,
                 status=AgentStatus.FATAL_ERROR,
-                error_message=f"Streaming error: {exception!s}",
+                error_message="Missing task_id for polling",
             )
-
-        # In case we didn't receive any response or the stream ended unexpectedly
-        structlogger.error(
-            "a2a_agent.run_streaming_agent.unexpected_end",
-            event_info="Unexpected end of streaming response from A2A server",
-            agent_name=self._name,
-        )
-        return AgentOutput(
-            id=agent_input.id,
-            status=AgentStatus.FATAL_ERROR,
-            error_message="Unexpected end of streaming response",
+        return await self._pool_task_until_terminal(
+            agent_input=agent_input,
+            task_id=task_id,
+            max_wait=A2A_TASK_POOLING_MAX_WAIT,
+            initial_delay=A2A_TASK_POOLING_INITIAL_DELAY,
+            max_delay=MAX_AGENT_RETRY_DELAY_SECONDS,
         )
 
-    def _handle_streaming_response(
-        self, agent_input: AgentInput, response: SendStreamingMessageResponse
+    async def process_output(self, output: AgentOutput) -> AgentOutput:
+        """Post-process the output before returning it to Rasa."""
+        # A2A-specific output processing logic
+        return output
+
+    def _handle_send_message_response(
+        self, agent_input: AgentInput, response: ClientEvent | Message
     ) -> Optional[AgentOutput]:
-        """If the agent response is terminal (i.e., completed, failed, etc.),
+        """Handle possible response types from the A2A client:
+
+        In case of streaming, the response can be either exactly *one* Message,
+        or a *series* of tuples of (Task, Optional[TaskUpdateEvent]).
+
+        In case of pooling, the response can be either exactly *one* Message,
+        or exactly *one* tuple of (Task, None).
+
+        If the agent response is terminal (i.e., completed, failed, etc.),
         this method will return an AgentOutput.
         Otherwise, the task is still in progress (i.e., submitted, working), so this
         method will return None, so that the streaming or pooling agent can continue
         to wait for updates.
         """
-        if isinstance(response.root, JSONRPCErrorResponse):
-            return self._handle_json_rpc_error_response(agent_input, response.root)
-
-        response_result = response.root.result
-        if isinstance(response_result, Task):
-            return self._handle_task_response(agent_input, response_result)
-        elif isinstance(response_result, Message):
-            return self._handle_message_response(response_result)
-        elif isinstance(response_result, TaskStatusUpdateEvent):
-            return self._handle_task_status_update_event(agent_input, response_result)
-        elif isinstance(response_result, TaskArtifactUpdateEvent):
-            return self._handle_task_artifact_update_event(agent_input, response_result)
+        if isinstance(response, Message):
+            return self._handle_message_response(agent_input, response)
+        elif (
+            isinstance(response, tuple)
+            and len(response) == 2
+            and isinstance(response[0], Task)
+        ):
+            return self._handle_client_event(agent_input, response)
         else:
             # Currently, no other response types exist, so this branch is
             # unreachable. It is kept as a safeguard against future changes
             # to the A2A protocol: if new response types are introduced,
             # the agent will log an error instead of crashing.
-            return self._handle_unexpected_response_type(agent_input, response_result)
+            return self._handle_unexpected_response_type(agent_input, response)
 
     def _handle_json_rpc_error_response(
-        self, agent_input: AgentInput, response: JSONRPCErrorResponse
+        self, agent_input: AgentInput, error: Any
     ) -> AgentOutput:
         structlogger.error(
-            "a2a_agent.run_streaming_agent.error",
-            event_info="Received error response from A2A server during streaming",
+            "a2a_agent.run.error",
+            event_info="Received JSON-RPC error response from A2A agent",
             agent_name=self._name,
-            error=str(response.error),
+            error=str(error),
         )
         if isinstance(
-            response.error,
+            error,
             (
                 InternalError,
                 InvalidAgentResponseError,
@@ -298,85 +318,53 @@ class A2AAgent(AgentProtocol):
             return AgentOutput(
                 id=agent_input.id,
                 status=AgentStatus.RECOVERABLE_ERROR,
-                error_message=str(response.error),
+                error_message=str(error),
             )
         else:
             return AgentOutput(
                 id=agent_input.id,
                 status=AgentStatus.FATAL_ERROR,
-                error_message=str(response.error),
+                error_message=str(error),
             )
 
-    def _handle_task_response(
-        self, agent_input: AgentInput, task: Task
+    def _handle_client_event(
+        self, agent_input: AgentInput, client_event: ClientEvent
     ) -> Optional[AgentOutput]:
+        task = client_event[0]
+        update_event = client_event[1]
         structlogger.debug(
-            "a2a_agent.run_streaming_agent.task_received",
-            event_info="Received task from A2A",
-            agent_name=self._name,
+            "a2a_agent.run.client_event_received",
+            event_info="Received client event from A2A",
             task=task,
+            update_event=update_event,
         )
-        agent_output = self._handle_task_status(
-            agent_input=agent_input,
-            context_id=task.context_id,
-            task_id=task.id,
-            task_status=task.status,
-        )
-        return agent_output
 
-    def _handle_message_response(self, message: Message) -> Optional[AgentOutput]:
-        # Message represents an intermediate conversational update,
-        # we need to continue waiting for task updates
-        structlogger.debug(
-            "a2a_agent.run_streaming_agent.message_received",
-            event_info="Received message from A2A",
-            agent_name=self._name,
-            message=message,
-        )
-        return None
+        return self._handle_task(agent_input=agent_input, task=task)
 
-    def _handle_task_status_update_event(
-        self, agent_input: AgentInput, event: TaskStatusUpdateEvent
+    def _handle_message_response(
+        self, agent_input: AgentInput, message: Message
     ) -> Optional[AgentOutput]:
         structlogger.debug(
-            "a2a_agent.run_streaming_agent.task_status_update_received",
-            event_info="Received task status update from A2A",
+            "a2a_agent.run.message_received",
+            event_info="Received message from A2A",
             agent_name=self._name,
-            task_status_update_event=event,
-        )
-        agent_output = self._handle_task_status(
-            agent_input=agent_input,
-            context_id=event.context_id,
-            task_id=event.task_id,
-            task_status=event.status,
+            message=message,
         )
-        return agent_output
+        metadata = agent_input.metadata or {}
+        metadata[A2A_AGENT_CONTEXT_ID_KEY] = message.context_id
 
-    def _handle_task_artifact_update_event(
-        self, agent_input: AgentInput, event: TaskArtifactUpdateEvent
-    ) -> AgentOutput:
-        structlogger.debug(
-            "a2a_agent.run_streaming_agent.task_artifact_update_received",
-            event_info="Received task artifact update from A2A",
-            agent_name=self._name,
-            task_artifact_update_event=event,
-        )
         return AgentOutput(
             id=agent_input.id,
-            status=AgentStatus.COMPLETED,
-            response_message=self._generate_response_message_from_parts(
-                event.artifact.parts
-            ),
-            tool_results=self._generate_tool_results_from_parts(
-                agent_input, event.artifact.parts
-            ),
+            status=AgentStatus.INPUT_REQUIRED,
+            response_message=self._generate_response_message_from_parts(message.parts),
+            metadata=metadata,
         )
 
     def _handle_unexpected_response_type(
         self, agent_input: AgentInput, response_result: Any
     ) -> AgentOutput:
         structlogger.error(
-            "a2a_agent.run_streaming_agent.unexpected_response_type",
+            "a2a_agent.run.unexpected_response_type",
             event_info="Received unexpected response type from A2A server "
             "during streaming",
             agent_name=self._name,
@@ -388,29 +376,26 @@ class A2AAgent(AgentProtocol):
             error_message=f"Unexpected response type: {type(response_result)}",
         )
 
-    def _handle_task_status(
+    def _handle_task(
         self,
         agent_input: AgentInput,
-        context_id: str,
-        task_id: str,
-        task_status: TaskStatus,
-        metadata: Optional[Dict[str, Any]] = None,
+        task: Task,
     ) -> Optional[AgentOutput]:
         """If the task status is terminal (i.e., completed, failed, etc.),
         return an AgentOutput.
         If the task is still in progress (i.e., submitted, working), return None,
         so that the streaming or pooling agent can continue to wait for updates.
         """
-        state = task_status.state
+        state = task.status.state
 
-        metadata = metadata or {}
-        metadata[A2A_AGENT_CONTEXT_ID_KEY] = context_id
-        metadata[A2A_AGENT_TASK_ID_KEY] = task_id
+        metadata = agent_input.metadata or {}
+        metadata[A2A_AGENT_CONTEXT_ID_KEY] = task.context_id
+        metadata[A2A_AGENT_TASK_ID_KEY] = task.id
 
         if state == TaskState.input_required:
             response_message = (
-                self._generate_response_message_from_parts(task_status.message.parts)
-                if task_status.message
+                self._generate_response_message_from_parts(task.status.message.parts)
+                if task.status.message
                 else ""
             )  # This should not happen, but as type of message property
             # is optional, so we need to handle it
@@ -421,16 +406,19 @@ class A2AAgent(AgentProtocol):
                 metadata=metadata,
             )
         elif state == TaskState.completed:
-            response_message = (
-                self._generate_response_message_from_parts(task_status.message.parts)
-                if task_status.message
-                else ""
-            )  # This should not happen, but as type of message property
-            # is optional, so we need to handle it
+            response_message = self._generate_completed_response_message(task)
+            structured_results = (
+                self._generate_structured_results_from_artifacts(
+                    agent_input, task.artifacts
+                )
+                if task.artifacts
+                else None
+            )
             return AgentOutput(
                 id=agent_input.id,
                 status=AgentStatus.COMPLETED,
                 response_message=response_message,
+                structured_results=structured_results,
                 metadata=metadata,
             )
         elif (
@@ -469,7 +457,7 @@ class A2AAgent(AgentProtocol):
             )
 
     @staticmethod
-    def _prepare_message_send_params(agent_input: AgentInput) -> MessageSendParams:
+    def _prepare_message(agent_input: AgentInput) -> Message:
         parts: List[Part] = []
         if agent_input.metadata and A2A_AGENT_CONTEXT_ID_KEY in agent_input.metadata:
             # Agent knows the conversation history already, send the last
@@ -497,17 +485,94 @@ class A2AAgent(AgentProtocol):
             task_id=agent_input.metadata.get(A2A_AGENT_TASK_ID_KEY, None),
         )
         structlogger.debug(
-            "a2a_agent._prepare_message_send_params",
+            "a2a_agent.prepare_message",
             event_info="Prepared message to send to A2A server",
             agent_name=agent_input.id,
             message=agent_message,
         )
-        return MessageSendParams(
-            message=agent_message,
-            configuration=MessageSendConfiguration(
-                accepted_output_modes=["text", "text/plain", "application/json"],
-            ),
+        return agent_message
+
+    async def _pool_task_until_terminal(
+        self,
+        agent_input: AgentInput,
+        task_id: str,
+        max_wait: int,
+        initial_delay: float,
+        max_delay: int,
+    ) -> AgentOutput:
+        """Poll the task status until it reaches a terminal state or times out."""
+        if not self._client:
+            structlogger.error(
+                "a2a_agent.pool_task_until_terminal.error",
+                event_info="A2A client is not initialized. Call connect() first.",
+            )
+            return AgentOutput(
+                id=agent_input.id,
+                status=AgentStatus.FATAL_ERROR,
+                error_message="Client not initialized",
+            )
+
+        structlogger.debug(
+            "a2a_agent.pool_task_until_terminal.start",
+            event_info="Start polling task from A2A server",
+            agent_name=self._name,
+            task_id=task_id,
+            max_wait=max_wait,
+            initial_delay=initial_delay,
+            max_delay=max_delay,
         )
+        start_time = time.monotonic()
+        delay = initial_delay
+
+        while True:
+            try:
+                task = await self._client.get_task(TaskQueryParams(id=task_id))
+                agent_output = self._handle_task(agent_input=agent_input, task=task)
+                if agent_output is not None:
+                    # Reached a terminal state, return the output
+                    return agent_output
+
+                elapsed = time.monotonic() - start_time
+                if elapsed >= max_wait:
+                    structlogger.debug(
+                        "a2a_agent.pool_task_until_terminal.timeout",
+                        event_info="Polling task from A2A server timed out",
+                        agent_name=self._name,
+                        task_id=task_id,
+                        elapsed=elapsed,
+                        max_wait=max_wait,
+                    )
+                    return AgentOutput(
+                        id=agent_input.id,
+                        status=AgentStatus.FATAL_ERROR,
+                        error_message="Polling timed out",
+                    )
+
+                structlogger.error(
+                    "a2a_agent.pool_task_until_terminal.waiting",
+                    event_info="Task not in terminal state yet, waiting to poll again",
+                    delay=delay,
+                    agent_name=self._name,
+                    task_id=task_id,
+                    elapsed=elapsed,
+                    max_wait=max_wait,
+                )
+                await asyncio.sleep(delay)
+                # Exponential backoff with cap
+                delay = min(delay * 2, max_delay)
+
+            except A2AClientError as exception:
+                structlogger.error(
+                    "a2a_agent.pool_task_until_terminal.error",
+                    event_info="Error during polling task from A2A server",
+                    agent_name=self._name,
+                    error=str(exception),
+                )
+                return AgentOutput(
+                    id=agent_input.id,
+                    status=AgentStatus.FATAL_ERROR,
+                    error_message=f"Polling error: {exception!s}",
+                )
 
     @staticmethod
     def _generate_response_message_from_parts(parts: Optional[List[Part]]) -> str:
@@ -519,7 +584,7 @@ class A2AAgent(AgentProtocol):
             if isinstance(part.root, TextPart):
                 result += part.root.text + "\n"
             elif isinstance(part.root, DataPart):
-                # DataPart results will be returned as a pert of the tool results,
+                # DataPart results will be returned as a part of the structured results,
                 # we don't need to include it in the response message
                 continue
             elif isinstance(part.root, FilePart) and isinstance(
@@ -536,29 +601,66 @@ class A2AAgent(AgentProtocol):
         return result.strip()
 
     @staticmethod
-    def _generate_tool_results_from_parts(
-        agent_input: AgentInput, parts: List[Part]
-    ) -> Optional[List[List[Dict[str, Any]]]]:
-        tool_results_of_current_iteration: List[Dict[str, Any]] = []
-        for i, part in enumerate(parts):
-            if (
-                isinstance(part.root, DataPart)
-                and part.root.data
-                and len(part.root.data) > 0
-            ):
-                # There might be multiple DataParts in the response,
-                # we will treat each of them as a separate tool result.
-                # The tool name will be the agent ID + index of the part.
-                tool_results_of_current_iteration.append(
-                    {"tool_name": f"{agent_input.id}_{i}", "result": part.root.data}
+    def _generate_completed_response_message(task: Task) -> str:
+        """Generate a response message for a completed task.
+        In case of completed tasks, the final message might be in
+        the task status message or in the artifacts (or both).
+        """
+        result = ""
+        if task.status.message:
+            result += (
+                A2AAgent._generate_response_message_from_parts(
+                    task.status.message.parts
+                )
+                + "\n"
+            )
+        if task.artifacts:
+            for artifact in task.artifacts:
+                result += (
+                    A2AAgent._generate_response_message_from_parts(artifact.parts)
+                    + "\n"
                 )
+        return result.strip()
 
-        previous_tool_results: List[List[Dict[str, Any]]] = (
-            agent_input.metadata.get(AGENT_METADATA_TOOL_RESULTS_KEY, []) or []
+    @staticmethod
+    def _generate_structured_results_from_artifacts(
+        agent_input: AgentInput, artifacts: List[Artifact]
+    ) -> Optional[List[List[Dict[str, Any]]]]:
+        structured_results_of_current_iteration: List[Dict[str, Any]] = []
+        # There might be multiple artifacts in the response, each of them might
+        # contain multiple parts. We will treat each DataPart in each artifact
+        # as a separate tool result. The tool name will be the agent ID + index
+        # of the artifact + index of the part.
+        # E.g., foo_0_1, foo_0_2, foo_1_0, etc.
+        for artifact_index, artifact in enumerate(artifacts):
+            for part_index, part in enumerate(artifact.parts):
+                if isinstance(part.root, DataPart) and len(part.root.data) > 0:
+                    structured_result = {
+                        "name": f"{agent_input.id}_{artifact_index}_{part_index}",
+                        "type": "data",
+                        "result": part.root.data,
+                    }
+                    structured_results_of_current_iteration.append(structured_result)
+                elif isinstance(part.root, FilePart) and isinstance(
+                    part.root.file, FileWithUri
+                ):
+                    structured_result = {
+                        "name": f"{agent_input.id}_{artifact_index}_{part_index}",
+                        "type": "file",
+                        "result ": {
+                            "uri": part.root.file.uri,
+                            "name": part.root.file.name,
+                            "mime_type": part.root.file.mime_type,
+                        },
+                    }
+                    structured_results_of_current_iteration.append(structured_result)
+
+        previous_structured_results: List[List[Dict[str, Any]]] = (
+            agent_input.metadata.get(AGENT_METADATA_STRUCTURED_RESULTS_KEY, []) or []
         )
-        previous_tool_results.append(tool_results_of_current_iteration)
+        previous_structured_results.append(structured_results_of_current_iteration)
 
-        return previous_tool_results
+        return previous_structured_results
 
     @staticmethod
     def _load_agent_card_from_file(agent_card_path: str) -> AgentCard:
@@ -566,42 +668,24 @@ class A2AAgent(AgentProtocol):
         try:
             with open(os.path.abspath(agent_card_path), "r") as f:
                 card_data = json.load(f)
+            return AgentCard.model_validate(card_data)
 
-            skills = [
-                AgentSkill(
-                    id=skill_data["id"],
-                    name=skill_data["name"],
-                    description=skill_data["description"],
-                    tags=skill_data.get("tags", []),
-                    examples=skill_data.get("examples", []),
-                )
-                for skill_data in card_data.get("skills", [])
-            ]
-
-            return AgentCard(
-                name=card_data["name"],
-                description=card_data["description"],
-                url=card_data["url"],
-                version=card_data.get("version", "1.0.0"),
-                default_input_modes=card_data.get(
-                    "defaultInputModes", ["text", "text/plain"]
-                ),
-                default_output_modes=card_data.get(
-                    "defaultOutputModes", ["text", "text/plain", "application/json"]
-                ),
-                capabilities=AgentCapabilities(
-                    streaming=card_data.get("capabilities", {}).get("streaming", True)
-                ),
-                skills=skills,
-            )
-        except FileNotFoundError:
-            raise FileNotFoundError(f"Agent card file not found: {agent_card_path}")
+        except FileNotFoundError as e:
+            raise AgentInitializationException(
+                f"Agent card file not found: {agent_card_path}"
+            ) from e
+        except (IOError, PermissionError) as e:
+            raise AgentInitializationException(
+                f"Error reading agent card file {agent_card_path}: {e}"
+            ) from e
         except json.JSONDecodeError as e:
-            raise ValueError(f"Invalid JSON in agent card file {agent_card_path}: {e}")
-        except KeyError as e:
-            raise ValueError(
-                f"Missing required field in agent card {agent_card_path}: {e}"
-            )
+            raise AgentInitializationException(
+                f"Invalid JSON in agent card file {agent_card_path}: {e}"
+            ) from e
+        except ValidationError as e:
+            raise AgentInitializationException(
+                f"Failed to load agent card from {agent_card_path}: {e}"
+            ) from e
 
     @staticmethod
     async def _resolve_agent_card_with_retry(
@@ -660,3 +744,77 @@ class A2AAgent(AgentProtocol):
             f"Failed to resolve agent card from {agent_card_path} after "
             f"{max_retries} attempts."
         )
+
+    def _init_client(self) -> Client:
+        factory = ClientFactory(
+            config=ClientConfig(
+                httpx_client=httpx.AsyncClient(timeout=self._timeout),
+                streaming=True,
+                supported_transports=[
+                    TransportProtocol.jsonrpc,
+                    TransportProtocol.http_json,
+                    TransportProtocol.grpc,
+                ],
+                accepted_output_modes=self.__SUPPORTED_OUTPUT_MODES,
+            )
+        )
+        return factory.create(self.agent_card)
+
+    async def _perform_health_check(self) -> None:
+        if not self._client or not self.agent_card:
+            structlogger.error(
+                "a2a_agent.health_check.error",
+                event_info="A2A client is not initialized. Call connect() first.",
+            )
+            raise AgentInitializationException("Client not initialized")
+
+        try:
+            test_message = Message(
+                role=Role.user,
+                parts=[Part(root=TextPart(text="hello"))],
+                message_id=str(uuid.uuid4()),
+            )
+            async for event in self._client.send_message(test_message):
+                if (
+                    isinstance(event, Message)
+                    or isinstance(event, tuple)
+                    and len(event) == 2
+                    and isinstance(event[0], Task)
+                ):
+                    # We got a valid response, health check succeeded
+                    return
+
+                event_info = "Unexpected response type during health check"
+                structlogger.error(
+                    "a2a_agent.health_check.unexpected_response",
+                    event_info=event_info,
+                    agent_name=self._name,
+                    response=event,
+                    url=str(self.agent_card.url),
+                )
+                raise AgentInitializationException(f"{event_info}: {event}")
+            # If the loop completes with no return, no events were received
+            event_info = (
+                f"Health check failed for A2A agent '{self._name}' "
+                f"at {self.agent_card.url}: no events received"
+            )
+            structlogger.error(
+                "a2a_agent.health_check.no_events",
+                event_info=event_info,
+                agent_name=self._name,
+                url=str(self.agent_card.url),
+            )
+            raise AgentInitializationException(event_info)
+        except Exception as exception:
+            event_info = (
+                f"Health check failed for A2A agent '{self._name}' at "
+                f"{self.agent_card.url}: {exception!s}"
+            )
+            structlogger.error(
+                "a2a_agent.health_check.failed",
+                event_info=event_info,
+                agent_name=self._name,
+                error=str(exception),
+                url=str(self.agent_card.url),
+            )
+            raise AgentInitializationException(event_info) from exception