solace-agent-mesh 1.6.1__py3-none-any.whl → 1.13.2__py3-none-any.whl

solace_agent_mesh/gateway/base/component.py

@@ -4,8 +4,9 @@ Base Component class for Gateway implementations in the Solace AI Connector.
 
 import logging
 import asyncio
-import queue
 import base64
+import queue
+import re
 import uuid
 from datetime import datetime, timezone
 from typing import Any, Dict, Optional, List, Tuple, Union
@@ -21,7 +22,9 @@ from ...common.services.identity_service import (
     create_identity_service,
 )
 from .task_context import TaskContextManager
+from .auth_interface import AuthHandler
 from ...common.a2a.types import ContentPart
+from ...common.utils.rbac_utils import validate_agent_access
 from a2a.types import (
     Message as A2AMessage,
     AgentCard,
@@ -31,20 +34,25 @@ from a2a.types import (
     TaskArtifactUpdateEvent,
     JSONRPCError,
     TextPart,
+    DataPart,
     FilePart,
     FileWithBytes,
     Artifact as A2AArtifact,
 )
 from ...common import a2a
-from ...common.utils import is_text_based_mime_type
 from ...common.utils.embeds import (
     resolve_embeds_in_string,
-    resolve_embeds_recursively_in_string,
     evaluate_embed,
     LATE_EMBED_TYPES,
     EARLY_EMBED_TYPES,
-    EMBED_DELIMITER_OPEN,
+    resolve_embeds_recursively_in_string,
 )
+from ...common.utils.embeds.types import ResolutionMode
+from ...agent.utils.artifact_helpers import (
+    load_artifact_content_or_metadata,
+    format_artifact_uri,
+)
+from ...common.utils.mime_helpers import is_text_based_mime_type
 from solace_ai_connector.common.message import (
     Message as SolaceMessage,
 )
@@ -97,9 +105,32 @@ class BaseGatewayComponent(SamComponentBase):
 
         return super().get_config(key, default)
 
-    def __init__(self, resolve_artifact_uris_in_gateway: bool = True, **kwargs: Any):
+    def __init__(
+        self,
+        resolve_artifact_uris_in_gateway: bool = True,
+        supports_inline_artifact_resolution: bool = False,
+        filter_tool_data_parts: bool = True,
+        **kwargs: Any
+    ):
+        """
+        Initialize the BaseGatewayComponent.
+
+        Args:
+            resolve_artifact_uris_in_gateway: If True, resolves artifact URIs before sending to external.
+            supports_inline_artifact_resolution: If True, SIGNAL_ARTIFACT_RETURN embeds are converted
+                to FileParts during embed resolution. If False (default), signals are passed through
+                for the gateway to handle manually. Use False for legacy gateways (e.g., Slack),
+                True for modern gateways that support inline artifact rendering (e.g., HTTP SSE).
+            filter_tool_data_parts: If True (default), filters out tool-related DataParts (tool_call,
+                tool_result, etc.) from final Task messages before sending to gateway. Use True for
+                gateways that don't want to display internal tool execution details (e.g., Slack),
+                False for gateways that display all parts (e.g., HTTP SSE Web UI).
+            **kwargs: Additional arguments passed to parent class.
+        """
         super().__init__(info, **kwargs)
         self.resolve_artifact_uris_in_gateway = resolve_artifact_uris_in_gateway
+        self.supports_inline_artifact_resolution = supports_inline_artifact_resolution
+        self.filter_tool_data_parts = filter_tool_data_parts
         log.info("%s Initializing Base Gateway Component...", self.log_identifier)
 
         try:
@@ -139,7 +170,9 @@ class BaseGatewayComponent(SamComponentBase):
 
         self.agent_registry: AgentRegistry = AgentRegistry()
         self.core_a2a_service: CoreA2AService = CoreA2AService(
-            agent_registry=self.agent_registry, namespace=self.namespace
+            agent_registry=self.agent_registry,
+            namespace=self.namespace,
+            component_id="WebUI"
         )
         self.shared_artifact_service: Optional[BaseArtifactService] = (
             initialize_artifact_service(self)
@@ -159,10 +192,65 @@ class BaseGatewayComponent(SamComponentBase):
             self.log_identifier,
         )
 
+        # Authentication handler (optional, enterprise feature)
+        self.auth_handler: Optional[AuthHandler] = None
+
+        # Setup authentication if enabled (subclasses override _setup_auth)
+        self._setup_auth()
+
         log.info(
-            "%s Base Gateway Component initialized successfully.", self.log_identifier
+            "%s Initialized Base Gateway Component.", self.log_identifier
         )
 
+    def _setup_auth(self) -> None:
+        """
+        Setup authentication handler if enabled.
+
+        This method is called during initialization and can be overridden
+        by subclasses to customize auth setup. The default implementation
+        does nothing - subclasses should override to enable auth.
+
+        Example override in subclass:
+            def _setup_auth(self):
+                if self.get_config('enable_auth', False):
+                    from enterprise.auth import SAMOAuth2Handler
+                    self.auth_handler = SAMOAuth2Handler(self.config)
+        """
+        # Base implementation: no auth
+        # Subclasses (like GenericGateway) override to enable auth
+        pass
+
+    async def _inject_auth_headers(self, headers: Dict[str, str]) -> Dict[str, str]:
+        """
+        Inject authentication headers if authenticated.
+
+        This helper method should be called before making outgoing HTTP requests
+        to add authentication headers (e.g., Bearer tokens) to the request.
+
+        Args:
+            headers: Existing headers dictionary
+
+        Returns:
+            Headers dictionary with auth headers added (if authenticated)
+
+        Example:
+            headers = {"Content-Type": "application/json"}
+            headers = await self._inject_auth_headers(headers)
+            # headers now includes Authorization if authenticated
+        """
+        if self.auth_handler:
+            try:
+                auth_headers = await self.auth_handler.get_auth_headers()
+                headers.update(auth_headers)
+            except Exception as e:
+                log.warning(
+                    "%s Failed to get auth headers: %s",
+                    self.log_identifier,
+                    e
+                )
+
+        return headers
+
     async def authenticate_and_enrich_user(
         self, external_event_data: Any
     ) -> Optional[Dict[str, Any]]:
@@ -208,6 +296,8 @@ class BaseGatewayComponent(SamComponentBase):
         user_identity: Any,
         is_streaming: bool = True,
         api_version: str = "v2",
+        task_id_override: str | None = None,
+        metadata: dict[str, Any] | None = None,
     ) -> str:
         log_id_prefix = f"{self.log_identifier}[SubmitA2ATask]"
         log.info(
@@ -241,7 +331,7 @@ class BaseGatewayComponent(SamComponentBase):
             user_config = await config_resolver.resolve_user_config(
                 user_identity, gateway_context, {}
             )
-            log.info(
+            log.debug(
                 "%s Resolved user configuration for user_identity '%s': %s",
                 log_id_prefix,
                 user_identity.get("id"),
@@ -258,13 +348,26 @@ class BaseGatewayComponent(SamComponentBase):
 
         user_config["user_profile"] = user_identity
 
+        # Validate user has permission to access this target agent
+        validate_agent_access(
+            user_config=user_config,
+            target_agent_name=target_agent_name,
+            validation_context={
+                "gateway_id": self.gateway_id,
+                "source": "gateway_request",
+            },
+            log_identifier=log_id_prefix,
+        )
+
         external_request_context["user_identity"] = user_identity
         external_request_context["a2a_user_config"] = user_config
         external_request_context["api_version"] = api_version
+        external_request_context["is_streaming"] = is_streaming
         log.debug(
-            "%s Stored user_identity, configuration, and api_version (%s) in external_request_context.",
+            "%s Stored user_identity, configuration, api_version (%s), and is_streaming (%s) in external_request_context.",
             log_id_prefix,
             api_version,
+            is_streaming,
         )
 
         now = datetime.now(timezone.utc)
@@ -299,6 +402,15 @@ class BaseGatewayComponent(SamComponentBase):
             "system_purpose": system_purpose,
             "response_format": response_format,
         }
+
+        # Add session behavior if provided by adapter
+        session_behavior = external_request_context.get("session_behavior")
+        if session_behavior:
+            a2a_metadata["sessionBehavior"] = session_behavior
+            log.debug(
+                "%s Setting sessionBehavior to: %s", log_id_prefix, session_behavior
+            )
+
         invoked_artifacts = external_request_context.get("invoked_with_artifacts")
         if invoked_artifacts:
             a2a_metadata["invoked_with_artifacts"] = invoked_artifacts
@@ -307,9 +419,15 @@ class BaseGatewayComponent(SamComponentBase):
                 log_id_prefix,
                 len(invoked_artifacts),
             )
+        
+        if metadata:
+            a2a_metadata.update(metadata)
 
         # This correlation ID is used by the gateway to track the task
-        task_id = f"gdk-task-{uuid.uuid4().hex}"
+        if task_id_override:
+            task_id = task_id_override
+        else:
+            task_id = f"gdk-task-{uuid.uuid4().hex}"
 
         prepared_a2a_parts = await self._prepare_parts_for_publishing(
             parts=a2a_parts,
@@ -450,7 +568,7 @@ class BaseGatewayComponent(SamComponentBase):
     async def _handle_resolved_signals(
         self,
         external_request_context: Dict,
-        signals: List[Tuple[int, Any]],
+        signals: List[Tuple[None, str, Any]],
         original_rpc_id: Optional[str],
         is_finalizing_context: bool = False,
     ):
@@ -458,7 +576,7 @@ class BaseGatewayComponent(SamComponentBase):
         if not signals:
             return
 
-        for _, signal_tuple in signals:
+        for signal_tuple in signals:
             if (
                 isinstance(signal_tuple, tuple)
                 and len(signal_tuple) == 3
@@ -518,6 +636,375 @@ class BaseGatewayComponent(SamComponentBase):
                         log.exception(
                             "%s Error sending status signal: %s", log_id_prefix, e
                         )
+                elif signal_type == "SIGNAL_ARTIFACT_RETURN":
+                    # Handle artifact return signal for legacy gateways
+                    # During finalizing context (final Task), suppress this to avoid duplicates
+                    # since the same signal might appear in both streaming and final responses
+                    if is_finalizing_context:
+                        log.debug(
+                            "%s Suppressing SIGNAL_ARTIFACT_RETURN during finalizing context to avoid duplicate: %s",
+                            log_id_prefix,
+                            signal_data,
+                        )
+                        continue
+
+                    log.info(
+                        "%s Handling SIGNAL_ARTIFACT_RETURN for legacy gateway: %s",
+                        log_id_prefix,
+                        signal_data,
+                    )
+                    try:
+                        filename = signal_data.get("filename")
+                        version = signal_data.get("version")
+
+                        if not filename:
+                            log.error(
+                                "%s SIGNAL_ARTIFACT_RETURN missing filename. Skipping.",
+                                log_id_prefix,
+                            )
+                            continue
+
+                        # Load artifact content (not just metadata) for legacy gateways
+                        # Legacy gateways like Slack need the actual bytes to upload files
+                        artifact_data = await load_artifact_content_or_metadata(
+                            self.shared_artifact_service,
+                            app_name=external_request_context.get(
+                                "app_name_for_artifacts", self.gateway_id
+                            ),
+                            user_id=external_request_context.get("user_id_for_artifacts"),
+                            session_id=external_request_context.get("a2a_session_id"),
+                            filename=filename,
+                            version=version,
+                            load_metadata_only=False,  # Load full content for legacy gateways
+                        )
+
+                        if artifact_data.get("status") != "success":
+                            log.error(
+                                "%s Failed to load artifact content for %s v%s",
+                                log_id_prefix,
+                                filename,
+                                version,
+                            )
+                            continue
+
+                        # Get content and ensure it's bytes
+                        content = artifact_data.get("content")
+                        if not content:
+                            log.error(
+                                "%s No content found in artifact %s v%s",
+                                log_id_prefix,
+                                filename,
+                                version,
+                            )
+                            continue
+
+                        # Convert to bytes if it's a string (text-based artifacts)
+                        if isinstance(content, str):
+                            content_bytes = content.encode("utf-8")
+                        elif isinstance(content, bytes):
+                            content_bytes = content
+                        else:
+                            log.error(
+                                "%s Artifact content is neither string nor bytes: %s",
+                                log_id_prefix,
+                                type(content),
+                            )
+                            continue
+
+                        # Resolve any late embeds inside the artifact content before returning.
+                        content_bytes = await self._resolve_embeds_in_artifact_content(
+                            content_bytes=content_bytes,
+                            mime_type=artifact_data.get("metadata", {}).get(
+                                "mime_type"
+                            ),
+                            filename=filename,
+                            external_request_context=external_request_context,
+                            log_id_prefix=log_id_prefix,
+                        )
+
+                        # Create FilePart with bytes for legacy gateway to upload
+                        file_part = a2a.create_file_part_from_bytes(
+                            content_bytes=content_bytes,
+                            name=filename,
+                            mime_type=artifact_data.get("metadata", {}).get(
+                                "mime_type"
+                            ),
+                        )
+
+                        # Create artifact with the file part
+                        # Import Part type for wrapping
+                        from a2a.types import Artifact, Part
+                        artifact = Artifact(
+                            artifact_id=str(uuid.uuid4().hex),
+                            parts=[Part(root=file_part)],
+                            name=filename,
+                            description=f"Artifact: {filename}",
+                        )
+
+                        # Send as TaskArtifactUpdateEvent
+                        a2a_task_id_for_signal = external_request_context.get(
+                            "a2a_task_id_for_event", original_rpc_id
+                        )
+
+                        if not a2a_task_id_for_signal:
+                            log.error(
+                                "%s Cannot determine A2A task ID for artifact signal. Skipping.",
+                                log_id_prefix,
+                            )
+                            continue
+
+                        artifact_event = a2a.create_artifact_update(
+                            task_id=a2a_task_id_for_signal,
+                            context_id=external_request_context.get("a2a_session_id"),
+                            artifact=artifact,
+                        )
+
+                        await self._send_update_to_external(
+                            external_request_context=external_request_context,
+                            event_data=artifact_event,
+                            is_final_chunk_of_update=False,
+                        )
+                        log.info(
+                            "%s Sent artifact signal as TaskArtifactUpdateEvent for %s",
+                            log_id_prefix,
+                            filename,
+                        )
+                    except Exception as e:
+                        log.exception(
+                            "%s Error sending artifact signal: %s", log_id_prefix, e
+                        )
+                elif signal_type == "SIGNAL_ARTIFACT_CREATION_COMPLETE":
+                    # Handle artifact creation completion for legacy gateways
+                    # This is similar to SIGNAL_ARTIFACT_RETURN but for newly created artifacts
+                    log.info(
+                        "%s Handling SIGNAL_ARTIFACT_CREATION_COMPLETE for legacy gateway: %s",
+                        log_id_prefix,
+                        signal_data,
+                    )
+                    try:
+                        filename = signal_data.get("filename")
+                        version = signal_data.get("version")
+
+                        if not filename:
+                            log.error(
+                                "%s SIGNAL_ARTIFACT_CREATION_COMPLETE missing filename. Skipping.",
+                                log_id_prefix,
+                            )
+                            continue
+
+                        # Load artifact content (not just metadata) for legacy gateways
+                        # Legacy gateways like Slack need the actual bytes to upload files
+                        artifact_data = await load_artifact_content_or_metadata(
+                            self.shared_artifact_service,
+                            app_name=external_request_context.get(
+                                "app_name_for_artifacts", self.gateway_id
+                            ),
+                            user_id=external_request_context.get("user_id_for_artifacts"),
+                            session_id=external_request_context.get("a2a_session_id"),
+                            filename=filename,
+                            version=version,
+                            load_metadata_only=False,  # Load full content for legacy gateways
+                        )
+
+                        if artifact_data.get("status") != "success":
+                            log.error(
+                                "%s Failed to load artifact content for %s v%s",
+                                log_id_prefix,
+                                filename,
+                                version,
+                            )
+                            continue
+
+                        # Get content and ensure it's bytes
+                        content = artifact_data.get("content")
+                        if not content:
+                            log.error(
+                                "%s No content found in artifact %s v%s",
+                                log_id_prefix,
+                                filename,
+                                version,
+                            )
+                            continue
+
+                        # Convert to bytes if it's a string (text-based artifacts)
+                        if isinstance(content, str):
+                            content_bytes = content.encode("utf-8")
+                        elif isinstance(content, bytes):
+                            content_bytes = content
+                        else:
+                            log.error(
+                                "%s Artifact content is neither string nor bytes: %s",
+                                log_id_prefix,
+                                type(content),
+                            )
+                            continue
+
+                        # Create FilePart with bytes for legacy gateway to upload
+                        file_part = a2a.create_file_part_from_bytes(
+                            content_bytes=content_bytes,
+                            name=filename,
+                            mime_type=signal_data.get("mime_type") or artifact_data.get("metadata", {}).get("mime_type"),
+                        )
+
+                        # Create artifact with the file part
+                        # Import Part type for wrapping
+                        from a2a.types import Artifact, Part
+                        artifact = Artifact(
+                            artifact_id=str(uuid.uuid4().hex),
+                            parts=[Part(root=file_part)],
+                            name=filename,
+                            description=f"Artifact: {filename}",
+                        )
+
+                        # Send as TaskArtifactUpdateEvent
+                        a2a_task_id_for_signal = external_request_context.get(
+                            "a2a_task_id_for_event", original_rpc_id
+                        )
+
+                        if not a2a_task_id_for_signal:
+                            log.error(
+                                "%s Cannot determine A2A task ID for artifact creation signal. Skipping.",
+                                log_id_prefix,
+                            )
+                            continue
+
+                        artifact_event = a2a.create_artifact_update(
+                            task_id=a2a_task_id_for_signal,
+                            context_id=external_request_context.get("a2a_session_id"),
+                            artifact=artifact,
+                        )
+
+                        await self._send_update_to_external(
+                            external_request_context=external_request_context,
+                            event_data=artifact_event,
+                            is_final_chunk_of_update=False,
+                        )
+                        log.info(
+                            "%s Sent artifact creation completion as TaskArtifactUpdateEvent for %s",
+                            log_id_prefix,
+                            filename,
+                        )
+                    except Exception as e:
+                        log.exception(
+                            "%s Error sending artifact creation completion signal: %s", log_id_prefix, e
+                        )
+                elif signal_type == "SIGNAL_DEEP_RESEARCH_REPORT":
+                    # Handle deep research report signal for legacy gateways
+                    # For legacy gateways, we send the report as a file attachment
+                    if is_finalizing_context:
+                        log.debug(
+                            "%s Suppressing SIGNAL_DEEP_RESEARCH_REPORT during finalizing context to avoid duplicate: %s",
+                            log_id_prefix,
+                            signal_data,
+                        )
+                        continue
+
+                    try:
+                        filename = signal_data.get("filename")
+                        version = signal_data.get("version")
+
+                        if not filename:
+                            log.error(
+                                "%s SIGNAL_DEEP_RESEARCH_REPORT missing filename. Skipping.",
+                                log_id_prefix,
+                            )
+                            continue
+
+                        # Load artifact content for legacy gateways
+                        artifact_data = await load_artifact_content_or_metadata(
+                            self.shared_artifact_service,
+                            app_name=external_request_context.get(
+                                "app_name_for_artifacts", self.gateway_id
+                            ),
+                            user_id=external_request_context.get("user_id_for_artifacts"),
+                            session_id=external_request_context.get("a2a_session_id"),
+                            filename=filename,
+                            version=version,
+                            load_metadata_only=False,
+                        )
+
+                        if artifact_data.get("status") != "success":
+                            log.error(
+                                "%s Failed to load deep research report content for %s v%s",
+                                log_id_prefix,
+                                filename,
+                                version,
+                            )
+                            continue
+
+                        content = artifact_data.get("content")
+                        if not content:
+                            log.error(
+                                "%s No content found in deep research report %s v%s",
+                                log_id_prefix,
+                                filename,
+                                version,
+                            )
+                            continue
+
+                        # Convert to bytes if it's a string
+                        if isinstance(content, str):
+                            content_bytes = content.encode("utf-8")
+                        elif isinstance(content, bytes):
+                            content_bytes = content
+                        else:
+                            log.error(
+                                "%s Deep research report content is neither string nor bytes: %s",
+                                log_id_prefix,
+                                type(content),
+                            )
+                            continue
+
+                        # Create FilePart with bytes for legacy gateway to upload
+                        file_part = a2a.create_file_part_from_bytes(
+                            content_bytes=content_bytes,
+                            name=filename,
+                            mime_type=artifact_data.get("metadata", {}).get(
+                                "mime_type", "text/markdown"
+                            ),
+                        )
+
+                        # Create artifact with the file part
+                        from a2a.types import Artifact, Part
+                        artifact = Artifact(
+                            artifact_id=str(uuid.uuid4().hex),
+                            parts=[Part(root=file_part)],
+                            name=filename,
+                            description=f"Deep Research Report: {filename}",
+                        )
+
+                        # Send as TaskArtifactUpdateEvent
+                        a2a_task_id_for_signal = external_request_context.get(
+                            "a2a_task_id_for_event", original_rpc_id
+                        )
+
+                        if not a2a_task_id_for_signal:
+                            log.error(
+                                "%s Cannot determine A2A task ID for deep research report signal. Skipping.",
+                                log_id_prefix,
+                            )
+                            continue
+
+                        artifact_event = a2a.create_artifact_update(
+                            task_id=a2a_task_id_for_signal,
+                            context_id=external_request_context.get("a2a_session_id"),
+                            artifact=artifact,
+                        )
+
+                        await self._send_update_to_external(
+                            external_request_context=external_request_context,
+                            event_data=artifact_event,
+                            is_final_chunk_of_update=False,
+                        )
+                        log.info(
+                            "%s Sent deep research report as TaskArtifactUpdateEvent for %s",
+                            log_id_prefix,
+                            filename,
+                        )
+                    except Exception as e:
+                        log.exception(
+                            "%s Error sending deep research report signal: %s", log_id_prefix, e
+                        )
                 else:
                     log.warning(
                         "%s Received unhandled signal type during embed resolution: %s",
@@ -525,10 +1012,80 @@ class BaseGatewayComponent(SamComponentBase):
                         signal_type,
                     )
 
-    async def _resolve_uri_in_file_part(self, file_part: FilePart):
+    async def _resolve_embeds_in_artifact_content(
+        self,
+        content_bytes: bytes,
+        mime_type: Optional[str],
+        filename: str,
+        external_request_context: Dict[str, Any],
+        log_id_prefix: str,
+    ) -> bytes:
+        """
+        Checks if content is text-based and, if so, resolves late embeds within it.
+        Returns the (potentially modified) content as bytes.
+        """
+        if is_text_based_mime_type(mime_type):
+            log.info(
+                "%s Artifact '%s' is text-based (%s). Resolving late embeds.",
+                log_id_prefix,
+                filename,
+                mime_type,
+            )
+            try:
+                decoded_content = content_bytes.decode("utf-8")
+
+                # Construct context and config for the resolver
+                embed_eval_context = {
+                    "artifact_service": self.shared_artifact_service,
+                    "session_context": {
+                        "app_name": external_request_context.get(
+                            "app_name_for_artifacts", self.gateway_id
+                        ),
+                        "user_id": external_request_context.get(
+                            "user_id_for_artifacts"
+                        ),
+                        "session_id": external_request_context.get("a2a_session_id"),
+                    },
+                }
+                embed_eval_config = {
+                    "gateway_max_artifact_resolve_size_bytes": self.gateway_max_artifact_resolve_size_bytes,
+                    "gateway_recursive_embed_depth": self.gateway_recursive_embed_depth,
+                }
+
+                resolved_string = await resolve_embeds_recursively_in_string(
+                    text=decoded_content,
+                    context=embed_eval_context,
+                    resolver_func=evaluate_embed,
+                    types_to_resolve=LATE_EMBED_TYPES,
+                    resolution_mode=ResolutionMode.RECURSIVE_ARTIFACT_CONTENT,
+                    log_identifier=f"{log_id_prefix}[RecursiveResolve]",
+                    config=embed_eval_config,
+                    max_depth=self.gateway_recursive_embed_depth,
+                )
+                resolved_bytes = resolved_string.encode("utf-8")
+                log.info(
+                    "%s Successfully resolved embeds in '%s'. New size: %d bytes.",
+                    log_id_prefix,
+                    filename,
+                    len(resolved_bytes),
+                )
+                return resolved_bytes
+            except Exception as resolve_err:
+                log.error(
+                    "%s Failed to resolve embeds within artifact '%s': %s. Returning raw content.",
+                    log_id_prefix,
+                    filename,
+                    resolve_err,
+                )
+        return content_bytes
+
+    async def _resolve_uri_in_file_part(
+        self, file_part: FilePart, external_request_context: Dict[str, Any]
+    ):
         """
         Checks if a FilePart has a resolvable URI and, if so,
         resolves it and mutates the part in-place by calling the common utility.
+        After resolving the URI, it also resolves any late embeds within the content.
         """
         await a2a.resolve_file_part_uri(
             part=file_part,
@@ -536,15 +1093,43 @@ class BaseGatewayComponent(SamComponentBase):
             log_identifier=self.log_identifier,
         )
 
-    async def _resolve_uris_in_parts_list(self, parts: List[ContentPart]):
+        # After resolving the URI to get the content, resolve any late embeds inside it.
+        if file_part.file and isinstance(file_part.file, FileWithBytes):
+            # The content is a base64 encoded string in the `bytes` attribute.
+            # We need to decode it to raw bytes for processing.
+            try:
+                content_bytes = base64.b64decode(file_part.file.bytes)
+            except Exception as e:
+                log.error(
+                    "%s Failed to base64 decode file content for embed resolution: %s",
+                    f"{self.log_identifier}[UriResolve]",
+                    e,
+                )
+                return
+
+            resolved_bytes = await self._resolve_embeds_in_artifact_content(
+                content_bytes=content_bytes,
+                mime_type=file_part.file.mime_type,
+                filename=file_part.file.name,
+                external_request_context=external_request_context,
+                log_id_prefix=f"{self.log_identifier}[UriResolve]",
+            )
+            # Re-encode the resolved content back to a base64 string for the FileWithBytes model.
+            file_part.file.bytes = base64.b64encode(resolved_bytes).decode("utf-8")
+
+    async def _resolve_uris_in_parts_list(
+        self, parts: List[ContentPart], external_request_context: Dict[str, Any]
+    ):
         """Iterates over a list of part objects and resolves any FilePart URIs."""
         if not parts:
             return
         for part in parts:
             if isinstance(part, FilePart):
-                await self._resolve_uri_in_file_part(part)
+                await self._resolve_uri_in_file_part(part, external_request_context)
 
-    async def _resolve_uris_in_payload(self, parsed_event: Any):
+    async def _resolve_uris_in_payload(
+        self, parsed_event: Any, external_request_context: Dict[str, Any]
+    ):
         """
         Dispatcher that calls the appropriate targeted URI resolver based on the
         Pydantic model type of the event.
@@ -568,7 +1153,9 @@ class BaseGatewayComponent(SamComponentBase):
                     parts_to_resolve.extend(a2a.get_parts_from_artifact(artifact))
 
         if parts_to_resolve:
-            await self._resolve_uris_in_parts_list(parts_to_resolve)
+            await self._resolve_uris_in_parts_list(
+                parts_to_resolve, external_request_context
+            )
         else:
             log.debug(
                 "%s Payload type '%s' did not yield any parts for URI resolution. Skipping.",
@@ -620,6 +1207,64 @@ class BaseGatewayComponent(SamComponentBase):
                 processed_parts.append(part)
         return processed_parts
 
+    def _should_include_data_part_in_final_output(self, part: Any) -> bool:
+        """
+        Determines if a DataPart should be included in the final output sent to the gateway.
+
+        This filters out internal/tool-related DataParts that shouldn't be shown to end users.
+        Gateways can override this method for custom filtering logic.
+
+        Args:
+            part: The part to check (expected to be a DataPart)
+
+        Returns:
+            True if the part should be included, False if it should be filtered out
+        """
+        from a2a.types import DataPart
+
+        if not isinstance(part, DataPart):
+            return True
+
+        # Check if this is a tool result by looking at metadata
+        # Tool results have metadata.tool_name set
+        if part.metadata and part.metadata.get("tool_name"):
+            # This is a tool result - filter it out
+            return False
+
+        # Get the type of the data part
+        data_type = part.data.get("type") if part.data else None
+
+        # Filter out tool-related data parts that are internal
+        tool_related_types = {
+            "tool_call",
+            "tool_result",
+            "tool_error",
+            "tool_execution",
+        }
+
+        if data_type in tool_related_types:
+            return False
+
+        # Handle artifact_creation_progress based on gateway capabilities
+        if data_type == "artifact_creation_progress":
+            # For modern gateways (HTTP SSE), keep these to display progress bubbles
+            # For legacy gateways (Slack), filter them out as they'll be converted to FileParts
+            if self.supports_inline_artifact_resolution:
+                return True  # Keep for HTTP SSE
+            else:
+                return False  # Filter for Slack (will be converted to FileParts instead)
+
+        # Keep user-facing data parts like general progress updates
+        user_facing_types = {
+            "agent_progress_update",
+        }
+
+        if data_type in user_facing_types:
+            return True
+
+        # Default: include unknown types (to avoid hiding potentially useful info)
+        return True
+
     async def _resolve_embeds_and_handle_signals(
         self,
         event_with_parts: Union[TaskStatusUpdateEvent, Task, TaskArtifactUpdateEvent],
@@ -628,17 +1273,11 @@ class BaseGatewayComponent(SamComponentBase):
         original_rpc_id: Optional[str],
         is_finalizing_context: bool = False,
     ) -> bool:
-        """
-        Resolves embeds and handles signals for an event containing parts.
-        Modifies event_with_parts in place if text content changes.
-        Manages stream buffer for TaskStatusUpdateEvent.
-        Returns True if the event content was modified or signals were handled, False otherwise.
-        """
         if not self.enable_embed_resolution:
             return False
 
         log_id_prefix = f"{self.log_identifier}[EmbedResolve:{a2a_task_id}]"
-        content_modified_or_signal_handled = False
+        content_modified = False
 
         embed_eval_context = {
             "artifact_service": self.shared_artifact_service,
@@ -656,8 +1295,6 @@ class BaseGatewayComponent(SamComponentBase):
         }
 
         parts_owner: Optional[Union[A2AMessage, A2AArtifact]] = None
-        is_streaming_status_update = isinstance(event_with_parts, TaskStatusUpdateEvent)
-
         if isinstance(event_with_parts, (TaskStatusUpdateEvent, Task)):
             if event_with_parts.status and event_with_parts.status.message:
                 parts_owner = event_with_parts.status.message
@@ -665,146 +1302,359 @@ class BaseGatewayComponent(SamComponentBase):
             if event_with_parts.artifact:
                 parts_owner = event_with_parts.artifact
 
-        if parts_owner and parts_owner.parts:
-            new_parts: List[ContentPart] = []
-            stream_buffer_key = f"{a2a_task_id}_stream_buffer"
-            current_buffer = ""
+        if not (parts_owner and parts_owner.parts):
+            return False
+
+        is_streaming_status_update = isinstance(event_with_parts, TaskStatusUpdateEvent)
+        stream_buffer_key = f"{a2a_task_id}_stream_buffer"
+        current_buffer = ""
+        if is_streaming_status_update:
+            current_buffer = (
+                self.task_context_manager.get_context(stream_buffer_key) or ""
+            )
+
+        original_parts: List[ContentPart] = (
+            a2a.get_parts_from_message(parts_owner)
+            if isinstance(parts_owner, A2AMessage)
+            else a2a.get_parts_from_artifact(parts_owner)
+        )
 
-            if is_streaming_status_update:
-                current_buffer = (
-                    self.task_context_manager.get_context(stream_buffer_key) or ""
+        new_parts: List[ContentPart] = []
+        other_signals = []
+
+        for part in original_parts:
+            if isinstance(part, TextPart) and part.text:
+                text_to_resolve = current_buffer + part.text
+                current_buffer = ""  # Buffer is now being processed
+
+                (
+                    resolved_text,
+                    processed_idx,
+                    signals_with_placeholders,
+                ) = await resolve_embeds_in_string(
+                    text=text_to_resolve,
+                    context=embed_eval_context,
+                    resolver_func=evaluate_embed,
+                    types_to_resolve=LATE_EMBED_TYPES.union({"status_update"}),
+                    resolution_mode=ResolutionMode.A2A_MESSAGE_TO_USER,
+                    log_identifier=log_id_prefix,
+                    config=embed_eval_config,
                 )
 
-            parts: List[ContentPart] = []
-            if isinstance(parts_owner, A2AMessage):
-                parts = a2a.get_parts_from_message(parts_owner)
-            elif isinstance(parts_owner, A2AArtifact):
-                parts = a2a.get_parts_from_artifact(parts_owner)
+                if not signals_with_placeholders:
+                    new_parts.append(a2a.create_text_part(text=resolved_text))
+                else:
+                    placeholder_map = {p: s for _, s, p in signals_with_placeholders}
+                    split_pattern = (
+                        f"({'|'.join(re.escape(p) for p in placeholder_map.keys())})"
+                    )
+                    text_fragments = re.split(split_pattern, resolved_text)
+
+                    for i, fragment in enumerate(text_fragments):
+                        if not fragment:
+                            continue
+                        if fragment in placeholder_map:
+                            signal_tuple = placeholder_map[fragment]
+                            signal_type, signal_data = signal_tuple[1], signal_tuple[2]
+                            if signal_type == "SIGNAL_ARTIFACT_RETURN":
+                                # Only convert to FilePart if gateway supports inline artifact resolution
+                                if self.supports_inline_artifact_resolution:
+                                    try:
+                                        filename, version = (
+                                            signal_data["filename"],
+                                            signal_data["version"],
+                                        )
+                                        artifact_data = (
+                                            await load_artifact_content_or_metadata(
+                                                self.shared_artifact_service,
+                                                **embed_eval_context["session_context"],
+                                                filename=filename,
+                                                version=version,
+                                                load_metadata_only=True,
+                                            )
+                                        )
+                                        if artifact_data.get("status") == "success":
+                                            uri = format_artifact_uri(
+                                                **embed_eval_context["session_context"],
+                                                filename=filename,
+                                                version=artifact_data.get("version"),
+                                            )
+                                            new_parts.append(
+                                                a2a.create_file_part_from_uri(
+                                                    uri,
+                                                    filename,
+                                                    artifact_data.get("metadata", {}).get(
+                                                        "mime_type"
+                                                    ),
+                                                )
+                                            )
+                                        else:
+                                            new_parts.append(
+                                                a2a.create_text_part(
+                                                    f"[Error: Artifact '{filename}' v{version} not found.]"
+                                                )
+                                            )
+                                    except Exception as e:
+                                        log.exception(
+                                            "%s Error handling SIGNAL_ARTIFACT_RETURN: %s",
+                                            log_id_prefix,
+                                            e,
+                                        )
+                                        new_parts.append(
+                                            a2a.create_text_part(
+                                                f"[Error: Could not retrieve artifact '{signal_data.get('filename')}'.]"
+                                            )
+                                        )
+                                else:
+                                    # Legacy gateway mode: pass signal through for gateway to handle
+                                    other_signals.append(signal_tuple)
+                            elif signal_type == "SIGNAL_DEEP_RESEARCH_REPORT":
+                                # Deep research reports should be rendered by the frontend component
+                                # For modern gateways (HTTP SSE), create a DataPart with artifact reference
+                                # For legacy gateways, pass through as signal
+                                if self.supports_inline_artifact_resolution:
+                                    try:
+                                        filename = signal_data["filename"]
+                                        version = signal_data["version"]
+                                        log.info(
+                                            "%s Converting SIGNAL_DEEP_RESEARCH_REPORT to DataPart for frontend rendering: %s v%s",
+                                            log_id_prefix,
+                                            filename,
+                                            version,
+                                        )
+                                        # Create a DataPart that the frontend can use to render DeepResearchReportBubble
+                                        # The frontend will fetch the artifact content separately
+                                        artifact_data = (
+                                            await load_artifact_content_or_metadata(
+                                                self.shared_artifact_service,
+                                                **embed_eval_context["session_context"],
+                                                filename=filename,
+                                                version=version,
+                                                load_metadata_only=True,
+                                            )
+                                        )
+                                        if artifact_data.get("status") == "success":
+                                            uri = format_artifact_uri(
+                                                **embed_eval_context["session_context"],
+                                                filename=filename,
+                                                version=artifact_data.get("version"),
+                                            )
+                                            # Create a DataPart with deep_research_report type
+                                            # This will be rendered by DeepResearchReportBubble in the frontend
+                                            data_part = a2a.create_data_part(
+                                                data={
+                                                    "type": "deep_research_report",
+                                                    "filename": filename,
+                                                    "version": artifact_data.get("version"),
+                                                    "uri": uri,
+                                                },
+                                                metadata={"source": "deep_research_tool"},
+                                            )
+                                            new_parts.append(data_part)
+                                        else:
+                                            new_parts.append(
+                                                a2a.create_text_part(
+                                                    f"[Error: Deep research report '{filename}' v{version} not found.]"
+                                                )
+                                            )
+                                    except Exception as e:
+                                        log.exception(
+                                            "%s Error handling SIGNAL_DEEP_RESEARCH_REPORT: %s",
+                                            log_id_prefix,
+                                            e,
+                                        )
+                                        new_parts.append(
+                                            a2a.create_text_part(
+                                                f"[Error: Could not retrieve deep research report '{signal_data.get('filename')}'.]"
+                                            )
+                                        )
+                                else:
+                                    # Legacy gateway mode: pass signal through for gateway to handle
+                                    other_signals.append(signal_tuple)
+                            elif signal_type == "SIGNAL_INLINE_BINARY_CONTENT":
+                                signal_data["content_bytes"] = signal_data.get("bytes")
+                                del signal_data["bytes"]
+                                new_parts.append(
+                                    a2a.create_file_part_from_bytes(**signal_data)
+                                )
+                            else:
+                                other_signals.append(signal_tuple)
+                        else:
+                            # Check if the non-placeholder fragment is just whitespace
+                            # and is between two placeholders. If so, drop it.
+                            is_just_whitespace = not fragment.strip()
+                            prev_fragment_was_placeholder = (
+                                i > 0 and text_fragments[i - 1] in placeholder_map
+                            )
+                            next_fragment_is_placeholder = (
+                                i < len(text_fragments) - 1
+                                and text_fragments[i + 1] in placeholder_map
+                            )
 
-            for part in parts:
-                if isinstance(part, TextPart) and part.text is not None:
-                    text_to_resolve = part.text
-                    original_part_text = part.text
+                            if (
+                                is_just_whitespace
+                                and prev_fragment_was_placeholder
+                                and next_fragment_is_placeholder
+                            ):
+                                log.debug(
+                                    "%s Dropping whitespace fragment between two file signals.",
+                                    log_id_prefix,
+                                )
+                                continue
 
-                    if is_streaming_status_update:
-                        current_buffer += part.text
-                        text_to_resolve = current_buffer
+                            new_parts.append(a2a.create_text_part(text=fragment))
 
-                    resolved_text, processed_idx, signals = (
-                        await resolve_embeds_in_string(
-                            text=text_to_resolve,
-                            context=embed_eval_context,
-                            resolver_func=evaluate_embed,
-                            types_to_resolve=LATE_EMBED_TYPES.copy(),
-                            log_identifier=log_id_prefix,
-                            config=embed_eval_config,
+                if is_streaming_status_update:
+                    current_buffer = text_to_resolve[processed_idx:]
+
+            elif isinstance(part, FilePart) and part.file:
+                # Handle recursive embeds in text-based FileParts
+                new_parts.append(part)  # Placeholder for now
+            elif isinstance(part, DataPart):
+                # Handle special DataPart types
+                data_type = part.data.get("type") if part.data else None
+
+                if data_type == "template_block":
+                    # Resolve template block and replace with resolved text
+                    try:
+                        from ...common.utils.templates import resolve_template_blocks_in_string
+
+                        # Reconstruct the template block syntax
+                        data_artifact = part.data.get("data_artifact", "")
+                        jsonpath = part.data.get("jsonpath")
+                        limit = part.data.get("limit")
+                        template_content = part.data.get("template_content", "")
+
+                        # Build params string
+                        params_parts = [f'data="{data_artifact}"']
+                        if jsonpath:
+                            params_parts.append(f'jsonpath="{jsonpath}"')
+                        if limit is not None:
+                            params_parts.append(f'limit="{limit}"')
+                        params_str = " ".join(params_parts)
+
+                        # Reconstruct full template block
+                        template_block = f"«««template: {params_str}\n{template_content}\n»»»"
+
+                        log.debug(
+                            "%s Resolving template block inline: data=%s",
+                            log_id_prefix,
+                            data_artifact,
+                        )
+
+                        # Resolve the template
+                        resolved_text = await resolve_template_blocks_in_string(
+                            text=template_block,
+                            artifact_service=self.shared_artifact_service,
+                            session_context={
+                                "app_name": external_request_context.get(
+                                    "app_name_for_artifacts", self.gateway_id
+                                ),
+                                "user_id": external_request_context.get("user_id_for_artifacts"),
+                                "session_id": external_request_context.get("a2a_session_id"),
+                            },
+                            log_identifier=f"{log_id_prefix}[TemplateResolve]",
                         )
-                    )
 
-                    if signals:
-                        await self._handle_resolved_signals(
-                            external_request_context,
-                            signals,
-                            original_rpc_id,
-                            is_finalizing_context,
+                        log.info(
+                            "%s Template resolved successfully. Output length: %d",
+                            log_id_prefix,
+                            len(resolved_text),
                         )
-                        content_modified_or_signal_handled = True
 
-                    if resolved_text is not None:
+                        # Replace the DataPart with a TextPart containing the resolved content
                         new_parts.append(a2a.create_text_part(text=resolved_text))
-                        if is_streaming_status_update:
-                            if resolved_text != text_to_resolve[:processed_idx]:
-                                content_modified_or_signal_handled = True
-                        elif resolved_text != original_part_text:
-                            content_modified_or_signal_handled = True
-
-                    if is_streaming_status_update:
-                        current_buffer = text_to_resolve[processed_idx:]
-                    elif (
-                        processed_idx < len(text_to_resolve)
-                        and not content_modified_or_signal_handled
-                    ):
-                        log.warning(
-                            "%s Unclosed embed in non-streaming TextPart. Remainder: '%s'",
+
+                    except Exception as e:
+                        log.error(
+                            "%s Failed to resolve template block: %s",
                             log_id_prefix,
-                            text_to_resolve[processed_idx:],
+                            e,
+                            exc_info=True,
                         )
-                        content_modified_or_signal_handled = True
-
-                elif isinstance(part, FilePart) and part.file:
-                    if isinstance(part.file, FileWithBytes) and part.file.bytes:
-                        mime_type = part.file.mime_type or ""
-                        is_container = is_text_based_mime_type(mime_type)
-                        try:
-                            decoded_content_for_check = base64.b64decode(
-                                part.file.bytes
-                            ).decode("utf-8", errors="ignore")
-                            if (
-                                is_container
-                                and EMBED_DELIMITER_OPEN in decoded_content_for_check
-                            ):
-                                original_content = decoded_content_for_check
-                                resolved_content = (
-                                    await resolve_embeds_recursively_in_string(
-                                        text=original_content,
-                                        context=embed_eval_context,
-                                        resolver_func=evaluate_embed,
-                                        types_to_resolve=LATE_EMBED_TYPES,
-                                        log_identifier=log_id_prefix,
-                                        config=embed_eval_config,
-                                        max_depth=self.gateway_recursive_embed_depth,
-                                    )
-                                )
-                                if resolved_content != original_content:
-                                    new_file_content = part.file.model_copy()
-                                    new_file_content.bytes = base64.b64encode(
-                                        resolved_content.encode("utf-8")
-                                    ).decode("utf-8")
-                                    new_parts.append(
-                                        FilePart(
-                                            file=new_file_content,
-                                            metadata=part.metadata,
-                                        )
-                                    )
-                                    content_modified_or_signal_handled = True
-                                else:
-                                    new_parts.append(part)
-                            else:
-                                new_parts.append(part)
-                        except Exception as e:
-                            log.warning(
-                                "%s Error during recursive FilePart resolution for %s: %s. Using original.",
+                        # Send error message as TextPart
+                        error_text = f"[Template rendering error: {str(e)}]"
+                        new_parts.append(a2a.create_text_part(text=error_text))
+
+                elif (
+                    data_type == "artifact_creation_progress"
+                    and not self.supports_inline_artifact_resolution
+                ):
+                    # Legacy gateway mode: convert completed artifact creation to FilePart
+                    status = part.data.get("status")
+                    if status == "completed" and not is_finalizing_context:
+                        # Extract artifact info from the DataPart
+                        filename = part.data.get("filename")
+                        version = part.data.get("version")
+                        mime_type = part.data.get("mime_type")
+
+                        if filename and version is not None:
+                            log.info(
+                                "%s Converting artifact creation completion to FilePart for legacy gateway: %s v%s",
                                 log_id_prefix,
-                                part.file.name,
-                                e,
+                                filename,
+                                version,
                             )
+                            # This will be sent as an artifact signal, so don't add to new_parts
+                            # Instead, add to other_signals for processing
+                            signal_tuple = (
+                                None,
+                                "SIGNAL_ARTIFACT_CREATION_COMPLETE",
+                                {
+                                    "filename": filename,
+                                    "version": version,
+                                    "mime_type": mime_type,
+                                },
+                            )
+                            other_signals.append(signal_tuple)
+                        else:
+                            # Missing required info, keep the DataPart as-is
                             new_parts.append(part)
+                    elif status == "completed" and is_finalizing_context:
+                        # Suppress during finalizing to avoid duplicates
+                        log.debug(
+                            "%s Suppressing artifact creation completion during finalizing context for %s",
+                            log_id_prefix,
+                            part.data.get("filename"),
+                        )
+                        continue
                     else:
-                        # This is a FileWithUri or empty FileWithBytes, which we don't process for embeds here.
+                        # Keep in-progress or failed status DataParts
                         new_parts.append(part)
                 else:
+                    # Not an artifact creation DataPart, or modern gateway - keep as-is
                     new_parts.append(part)
+            else:
+                new_parts.append(part)
 
+        if other_signals:
+            await self._handle_resolved_signals(
+                external_request_context,
+                other_signals,
+                original_rpc_id,
+                is_finalizing_context,
+            )
+
+        if new_parts != original_parts:
+            content_modified = True
             if isinstance(parts_owner, A2AMessage):
                 if isinstance(event_with_parts, TaskStatusUpdateEvent):
                     event_with_parts.status.message = a2a.update_message_parts(
-                        message=parts_owner, new_parts=new_parts
+                        parts_owner, new_parts
                     )
                 elif isinstance(event_with_parts, Task):
                     event_with_parts.status.message = a2a.update_message_parts(
-                        message=parts_owner, new_parts=new_parts
+                        parts_owner, new_parts
                     )
             elif isinstance(parts_owner, A2AArtifact):
                 event_with_parts.artifact = a2a.update_artifact_parts(
-                    artifact=parts_owner, new_parts=new_parts
+                    parts_owner, new_parts
                 )
 
-            if is_streaming_status_update:
-                self.task_context_manager.store_context(
-                    stream_buffer_key, current_buffer
-                )
+        if is_streaming_status_update:
+            self.task_context_manager.store_context(stream_buffer_key, current_buffer)
 
-        return content_modified_or_signal_handled
+        return content_modified or bool(other_signals)
 
     async def _process_parsed_a2a_event(
         self,
@@ -837,13 +1687,6 @@ class BaseGatewayComponent(SamComponentBase):
             elif isinstance(parsed_event, Task):
                 is_finalizing_context_for_embeds = True
 
-            if self.resolve_artifact_uris_in_gateway:
-                log.debug(
-                    "%s Resolving artifact URIs before sending to external...",
-                    log_id_prefix,
-                )
-                await self._resolve_uris_in_payload(parsed_event)
-
             if not isinstance(parsed_event, JSONRPCError):
                 content_was_modified_or_signals_handled = (
                     await self._resolve_embeds_and_handle_signals(
@@ -855,6 +1698,15 @@ class BaseGatewayComponent(SamComponentBase):
                     )
                 )
 
+            if self.resolve_artifact_uris_in_gateway:
+                log.debug(
+                    "%s Resolving artifact URIs before sending to external...",
+                    log_id_prefix,
+                )
+                await self._resolve_uris_in_payload(
+                    parsed_event, external_request_context
+                )
+
             send_this_event_to_external = True
             is_final_chunk_of_status_update = False
 
@@ -925,6 +1777,7 @@ class BaseGatewayComponent(SamComponentBase):
                             context=embed_eval_context,
                             resolver_func=evaluate_embed,
                             types_to_resolve=all_embed_types,
+                            resolution_mode=ResolutionMode.A2A_MESSAGE_TO_USER,
                             log_identifier=log_id_prefix,
                             config=embed_eval_config,
                         )
@@ -986,12 +1839,13 @@ class BaseGatewayComponent(SamComponentBase):
                     }
                     resolved_remaining_text, _, signals = (
                         await resolve_embeds_in_string(
-                            remaining_buffer,
-                            embed_eval_context,
-                            evaluate_embed,
-                            LATE_EMBED_TYPES.copy(),
-                            log_id_prefix,
-                            embed_eval_config,
+                            text=remaining_buffer,
+                            context=embed_eval_context,
+                            resolver_func=evaluate_embed,
+                            types_to_resolve=LATE_EMBED_TYPES.copy(),
+                            resolution_mode=ResolutionMode.A2A_MESSAGE_TO_USER,
+                            log_identifier=log_id_prefix,
+                            config=embed_eval_config,
                         )
                     )
                     await self._handle_resolved_signals(
@@ -1017,6 +1871,32 @@ class BaseGatewayComponent(SamComponentBase):
 
             if send_this_event_to_external:
                 if isinstance(parsed_event, Task):
+                    # Filter DataParts from final Task if gateway has filtering enabled
+                    # This prevents tool results and other internal data from appearing in user-facing output
+                    if (
+                        self.filter_tool_data_parts
+                        and parsed_event.status
+                        and parsed_event.status.message
+                        and parsed_event.status.message.parts
+                    ):
+                        original_parts = a2a.get_parts_from_message(
+                            parsed_event.status.message
+                        )
+                        filtered_parts = [
+                            part
+                            for part in original_parts
+                            if self._should_include_data_part_in_final_output(part)
+                        ]
+                        if len(filtered_parts) != len(original_parts):
+                            log.debug(
+                                "%s Filtered %d DataParts from final Task message",
+                                log_id_prefix,
+                                len(original_parts) - len(filtered_parts),
+                            )
+                            parsed_event.status.message = a2a.update_message_parts(
+                                parsed_event.status.message, filtered_parts
+                            )
+
                     await self._send_final_response_to_external(
                         external_request_context, parsed_event
                     )
@@ -1166,10 +2046,6 @@ class BaseGatewayComponent(SamComponentBase):
         )
         self._start_listener()
 
-        log.info(
-            "%s Starting _message_processor_loop as an asyncio task.",
-            self.log_identifier,
-        )
         await self._message_processor_loop()
 
     def _pre_async_cleanup(self) -> None:
@@ -1197,7 +2073,7 @@ class BaseGatewayComponent(SamComponentBase):
             self.internal_event_queue.put(None)
 
     async def _message_processor_loop(self):
-        log.info("%s Starting message processor loop...", self.log_identifier)
+        log.debug("%s Starting message processor loop as an asyncio task...", self.log_identifier)
         loop = self.get_async_loop()
 
         while not self.stop_signal.is_set():