Merge branch 'main' into fix/a2a-inbound-role-mapping

Author: rohityan

src/google/adk/a2a/converters/from_adk_event.py

@@ -218,6 +218,23 @@ def convert_event_to_a2a_events(
               ),
           )
       )
+    elif _serialize_value(event.actions) is not None:
+      a2a_events.append(
+          TaskStatusUpdateEvent(
+              task_id=task_id,
+              context_id=context_id,
+              status=TaskStatus(
+                  state=TaskState.working,
+                  message=Message(
+                      message_id=str(uuid.uuid4()),
+                      role=Role.agent,
+                      parts=[],
+                  ),
+                  timestamp=datetime.now(timezone.utc).isoformat(),
+              ),
+              final=False,
+          )
+      )
 
     a2a_events = _add_event_metadata(event, a2a_events)
     return a2a_events
@@ -280,7 +297,10 @@ def _add_event_metadata(
       metadata[_get_adk_metadata_key(field_name)] = value
 
   for a2a_event in a2a_events:
-    if isinstance(a2a_event, TaskStatusUpdateEvent):
+    if (
+        isinstance(a2a_event, TaskStatusUpdateEvent)
+        and a2a_event.status.message
+    ):
       a2a_event.status.message.metadata = metadata.copy()
     elif isinstance(a2a_event, TaskArtifactUpdateEvent):
       a2a_event.artifact.metadata = metadata.copy()

src/google/adk/a2a/executor/a2a_agent_executor.py

@@ -260,17 +260,15 @@ async def _handle_request(
             context.context_id,
             self._config.gen_ai_part_converter,
         ):
-          a2a_event = await execute_after_event_interceptors(
+          a2a_events = await execute_after_event_interceptors(
               a2a_event,
               executor_context,
               adk_event,
               self._config.execute_interceptors,
           )
-          if a2a_event is None:
-            continue
-
-          task_result_aggregator.process_event(a2a_event)
-          await event_queue.enqueue_event(a2a_event)
+          for e in a2a_events:
+            task_result_aggregator.process_event(e)
+            await event_queue.enqueue_event(e)
 
     # publish the task result event - this is final
     if (

src/google/adk/a2a/executor/a2a_agent_executor_impl.py

@@ -49,6 +49,7 @@
 from ..experimental import a2a_experimental
 from .config import A2aAgentExecutorConfig
 from .executor_context import ExecutorContext
+from .interceptors.include_artifacts_in_a2a_event import include_artifacts_in_a2a_event_interceptor
 from .utils import execute_after_agent_interceptors
 from .utils import execute_after_event_interceptors
 from .utils import execute_before_agent_interceptors
@@ -221,15 +222,14 @@ async def _handle_request(
             self._config.gen_ai_part_converter,
         ):
           a2a_event.metadata = self._get_invocation_metadata(executor_context)
-          a2a_event = await execute_after_event_interceptors(
+          a2a_events = await execute_after_event_interceptors(
               a2a_event,
               executor_context,
               adk_event,
               self._config.execute_interceptors,
           )
-          if not a2a_event:
-            continue
-          await event_queue.enqueue_event(a2a_event)
+          for e in a2a_events:
+            await event_queue.enqueue_event(e)
 
     if error_event:
       final_event = error_event

src/google/adk/a2a/executor/config.py

@@ -57,7 +57,7 @@ class ExecuteInterceptor:
   after_event: Optional[
       Callable[
           [ExecutorContext, A2AEvent, Event],
-          Awaitable[Union[A2AEvent, None]],
+          Awaitable[Union[A2AEvent, list[A2AEvent], None]],
       ]
   ] = None
   """Hook executed after an ADK event is converted to an A2A event.

src/google/adk/a2a/executor/interceptors/__init__.py

@@ -0,0 +1,19 @@
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .include_artifacts_in_a2a_event import include_artifacts_in_a2a_event_interceptor
+
+__all__ = [
+    "include_artifacts_in_a2a_event_interceptor",
+]

src/google/adk/a2a/executor/interceptors/include_artifacts_in_a2a_event.py

@@ -0,0 +1,73 @@
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from __future__ import annotations
+
+from typing import Union
+
+from a2a.server.events import Event as A2AEvent
+from a2a.types import Artifact
+from a2a.types import TaskArtifactUpdateEvent
+from a2a.types import TaskStatusUpdateEvent
+from google.adk.a2a.executor.config import ExecuteInterceptor
+from google.adk.a2a.executor.config import ExecutorContext
+
+from ....events.event import Event
+from ...converters.part_converter import convert_genai_part_to_a2a_part
+
+
+async def _after_agent(
+    ctx: ExecutorContext, a2a_event: A2AEvent, adk_event: Event
+) -> Union[A2AEvent, list[A2AEvent]]:
+  """After agent interceptor that includes artifacts in A2A events."""
+  if isinstance(a2a_event, (TaskStatusUpdateEvent, TaskArtifactUpdateEvent)):
+    artifact_service = ctx.runner.artifact_service
+    if artifact_service and adk_event.actions.artifact_delta:
+      new_events = []
+      for filename, version in adk_event.actions.artifact_delta.items():
+        genai_part = await artifact_service.load_artifact(
+            app_name=ctx.app_name,
+            user_id=ctx.user_id,
+            session_id=ctx.session_id,
+            filename=filename,
+            version=version,
+        )
+        if genai_part:
+          a2a_part = convert_genai_part_to_a2a_part(genai_part)
+          if a2a_part:
+            a2a_artifact = Artifact(
+                artifact_id=f"{filename}_{version}",
+                name=filename,
+                parts=[a2a_part],
+            )
+            new_event = TaskArtifactUpdateEvent(
+                task_id=a2a_event.task_id,
+                context_id=a2a_event.context_id,
+                artifact=a2a_artifact,
+                metadata=a2a_event.metadata,
+                append=False,
+                last_chunk=True,
+            )
+            new_events.append(new_event)
+
+      adk_event.actions.artifact_delta = {}
+
+      if new_events:
+        return [a2a_event] + new_events
+
+  return a2a_event
+
+
+include_artifacts_in_a2a_event_interceptor = ExecuteInterceptor(
+    after_event=_after_agent
+)

src/google/adk/a2a/executor/utils.py

@@ -41,16 +41,24 @@ async def execute_after_event_interceptors(
     executor_context: ExecutorContext,
     adk_event: Event,
     execute_interceptors: Optional[list[ExecuteInterceptor]],
-) -> Optional[A2AEvent]:
+) -> list[A2AEvent]:
+  events = [a2a_event]
   if execute_interceptors:
     for interceptor in execute_interceptors:
       if interceptor.after_event:
-        a2a_event = await interceptor.after_event(
-            executor_context, a2a_event, adk_event
-        )
-        if a2a_event is None:
-          return None
-  return a2a_event
+        next_events = []
+        for e in events:
+          res = await interceptor.after_event(executor_context, e, adk_event)
+          if res is None:
+            continue
+          if isinstance(res, list):
+            next_events.extend(res)
+          else:
+            next_events.append(res)
+        events = next_events
+        if not events:
+          return []
+  return events
 
 
 async def execute_after_agent_interceptors(

src/google/adk/cli/adk_web_server.py

@@ -706,14 +706,10 @@ async def get_runner_async(self, app_name: str) -> Runner:
         if plugins_config and isinstance(plugins_config, dict):
           bq_analytics_config = plugins_config.get("bigquery_agent_analytics")
 
-    # Determine if the agent was loaded from YAML based on the agent loader info
-    is_visual_builder = False
-    detailed_agents = self.agent_loader.list_agents_detailed()
-    for agent_info in detailed_agents:
-      if agent_info.get("name") == app_name:
-        if agent_info.get("language") == "yaml":
-          is_visual_builder = True
-        break
+    # All YAML agents are treated as visual builder agents.
+    is_visual_builder_agent = os.path.exists(
+        os.path.join(self.agents_dir, app_name, "root_agent.yaml")
+    )
 
     if isinstance(agent_or_app, BaseAgent):
       plugins = extra_plugins_instances
@@ -746,7 +742,7 @@ async def get_runner_async(self, app_name: str) -> Runner:
       agentic_app = agent_or_app
 
     # If the root agent was loaded from YAML, we treat it as being from Visual Builder
-    if is_visual_builder:
+    if is_visual_builder_agent:
       object.__setattr__(agentic_app, "_is_visual_builder_app", True)
 
     runner = self._create_runner(agentic_app)

tests/unittests/a2a/integration/server.py

@@ -14,6 +14,7 @@
 
 """A2A Server for integration tests."""
 
+from unittest.mock import AsyncMock
 from unittest.mock import Mock
 
 from a2a.server.apps.jsonrpc.fastapi_app import A2AFastAPIApplication
@@ -23,9 +24,12 @@
 from a2a.types import AgentCard
 from a2a.types import AgentSkill
 from google.adk.a2a.executor.a2a_agent_executor import A2aAgentExecutor
+from google.adk.a2a.executor.config import A2aAgentExecutorConfig
+from google.adk.a2a.executor.interceptors.include_artifacts_in_a2a_event import include_artifacts_in_a2a_event_interceptor
 from google.adk.agents.base_agent import BaseAgent
 from google.adk.runners import Runner
 from google.adk.sessions.in_memory_session_service import InMemorySessionService
+from google.genai import types
 
 
 class FakeRunner(Runner):
@@ -43,6 +47,12 @@ def __init__(self, run_async_fn):
     )
     self.run_async_fn = run_async_fn
 
+    mock_artifact_service = Mock()
+    mock_artifact_service.load_artifact = AsyncMock(
+        return_value=types.Part(text="artifact content")
+    )
+    self.artifact_service = mock_artifact_service
+
   async def run_async(self, **kwargs):
     async for event in self.run_async_fn(**kwargs):
       yield event
@@ -63,18 +73,21 @@ async def run_async(self, **kwargs):
 )
 
 
-def create_server_app(run_async_fn):
+def create_server_app(
+    run_async_fn=None, config: A2aAgentExecutorConfig | None = None
+):
   """Creates an A2A FastAPI application with a mocked runner.
 
   Args:
     run_async_fn: A generator function that takes **kwargs and yields Event
       objects.
+    include_artifacts: Whether to include artifacts in A2A events.
 
   Returns:
     A FastAPI application instance.
   """
   runner = FakeRunner(run_async_fn)
-  executor = A2aAgentExecutor(runner=runner)
+  executor = A2aAgentExecutor(runner=runner, config=config)
   task_store = InMemoryTaskStore()
   handler = DefaultRequestHandler(
       agent_executor=executor, task_store=task_store