solace-agent-mesh 1.6.3__py3-none-any.whl → 1.7.1__py3-none-any.whl

solace_agent_mesh/gateway/base/component.py

@@ -5,7 +5,7 @@ Base Component class for Gateway implementations in the Solace AI Connector.
 import logging
 import asyncio
 import queue
-import base64
+import re
 import uuid
 from datetime import datetime, timezone
 from typing import Any, Dict, Optional, List, Tuple, Union
@@ -31,19 +31,21 @@ 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,
+)
+from ...common.utils.embeds.types import ResolutionMode
+from ...agent.utils.artifact_helpers import (
+    load_artifact_content_or_metadata,
+    format_artifact_uri,
 )
 from solace_ai_connector.common.message import (
     Message as SolaceMessage,
@@ -97,9 +99,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:
@@ -263,10 +288,12 @@ class BaseGatewayComponent(SamComponentBase):
         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)
@@ -458,7 +485,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,
     ):
@@ -466,7 +493,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
@@ -526,6 +553,245 @@ 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
+
+                        # 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
+                        )
                 else:
                     log.warning(
                         "%s Received unhandled signal type during embed resolution: %s",
@@ -628,6 +894,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],
@@ -636,17 +960,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,
@@ -664,8 +982,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
@@ -673,146 +989,233 @@ 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 is_streaming_status_update:
-                current_buffer = (
-                    self.task_context_manager.get_context(stream_buffer_key) or ""
-                )
+        if not (parts_owner and parts_owner.parts):
+            return False
 
-            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)
+        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 ""
+            )
 
-            for part in parts:
-                if isinstance(part, TextPart) and part.text is not None:
-                    text_to_resolve = part.text
-                    original_part_text = part.text
+        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 += part.text
-                        text_to_resolve = current_buffer
+        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,
+                )
 
-                    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 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)
 
-                    if signals:
-                        await self._handle_resolved_signals(
-                            external_request_context,
-                            signals,
-                            original_rpc_id,
-                            is_finalizing_context,
-                        )
-                        content_modified_or_signal_handled = True
-
-                    if resolved_text is not None:
-                        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'",
-                            log_id_prefix,
-                            text_to_resolve[processed_idx:],
-                        )
-                        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,
+                    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')}'.]"
+                                            )
                                         )
-                                    )
-                                    content_modified_or_signal_handled = True
                                 else:
-                                    new_parts.append(part)
+                                    # 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:
-                                new_parts.append(part)
-                        except Exception as e:
-                            log.warning(
-                                "%s Error during recursive FilePart resolution for %s: %s. Using original.",
+                                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
+                            )
+
+                            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
+
+                            new_parts.append(a2a.create_text_part(text=fragment))
+
+                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 artifact creation progress DataParts for legacy gateways
+                data_type = part.data.get("type") if part.data else None
+                if (
+                    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,
@@ -845,13 +1248,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(
@@ -863,6 +1259,13 @@ 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)
+
             send_this_event_to_external = True
             is_final_chunk_of_status_update = False
 
@@ -933,6 +1336,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,
                         )
@@ -994,12 +1398,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(
@@ -1025,6 +1430,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
                     )