solace-agent-mesh 1.11.2__py3-none-any.whl

solace_agent_mesh/templates/agent_template.yaml

@@ -0,0 +1,53 @@
+# Solace Agent Mesh Agent Configuration
+
+log:
+  stdout_log_level: INFO
+  log_file_level: DEBUG
+  log_file: a2a_agent.log
+
+!include ../shared_config.yaml
+
+apps:
+  - name: "__AGENT_NAME____app"
+    app_base_path: .
+    app_module: solace_agent_mesh.agent.sac.app
+    broker:
+      <<: *broker_connection
+
+    app_config:
+      namespace: "__NAMESPACE__"
+      supports_streaming: __SUPPORTS_STREAMING__
+      agent_name: "__AGENT_NAME__"
+      display_name: "__AGENT_SPACED_NAME__ Agent"
+      model: __MODEL_ALIAS__ 
+
+      instruction: |
+        __INSTRUCTION__
+      
+      tools: __TOOLS_CONFIG__
+
+      session_service: __SESSION_SERVICE__
+      artifact_service: __ARTIFACT_SERVICE__
+      
+      artifact_handling_mode: "__ARTIFACT_HANDLING_MODE__"
+      enable_embed_resolution: __ENABLE_EMBED_RESOLUTION__
+      enable_artifact_content_instruction: __ENABLE_ARTIFACT_CONTENT_INSTRUCTION__
+      data_tools_config: *default_data_tools_config
+
+      # Agent Card Definition
+      agent_card:
+        description: |
+          __AGENT_CARD_DESCRIPTION__
+        defaultInputModes: __DEFAULT_INPUT_MODES__ 
+        defaultOutputModes: __DEFAULT_OUTPUT_MODES__ 
+        skills: __AGENT_CARD_SKILLS__
+      
+      # Discovery & Communication
+      agent_card_publishing: 
+        interval_seconds: __AGENT_CARD_PUBLISHING_INTERVAL__
+      agent_discovery: 
+        enabled: __AGENT_DISCOVERY_ENABLED__
+      inter_agent_communication:
+        allow_list: __INTER_AGENT_COMMUNICATION_ALLOW_LIST__ 
+        deny_list: __INTER_AGENT_COMMUNICATION_DENY_LIST__ 
+        request_timeout_seconds: __INTER_AGENT_COMMUNICATION_TIMEOUT__

solace_agent_mesh/templates/eval_backend_template.yaml

@@ -0,0 +1,54 @@
+# Solace AI Connector Configuration for Evaluation Backend
+
+log:
+  stdout_log_level: INFO
+  log_file_level: DEBUG
+  log_file: eval_backend.log
+
+# Shared SAM config
+!include ./shared_config.yaml
+
+apps:
+  - name: a2a_eval_backend_app
+    app_base_path: .
+    app_module: sam_rest_gateway.app
+
+    broker:
+      <<: *broker_connection
+
+    app_config:
+      namespace: ${NAMESPACE}
+      session_secret_key: ${SESSION_SECRET_KEY, please_change_me_in_production}
+      
+      artifact_service:
+        type: "filesystem"
+        base_path: "/tmp/samv2"
+        artifact_scope: namespace
+
+      enforce_authentication: false
+      default_user_identity: "eval-user"
+      sync_mode_timeout_seconds: 300
+      rest_api_server_host: ${REST_API_HOST, 0.0.0.0}
+      rest_api_server_port: ${REST_API_PORT, 8080}
+      cors_allowed_origins:
+        - "http://localhost:3000"
+        - "http://127.0.0.1:3000"
+
+      enable_embed_resolution: ${ENABLE_EMBED_RESOLUTION, true}
+      gateway_artifact_content_limit_bytes: ${GATEWAY_ARTIFACT_LIMIT_BYTES, 10000000}
+
+      system_purpose: >
+            The system is an AI Chatbot with agentic capabilities.
+            It will use the agents available to provide information,
+            reasoning and general assistance for the users in this system.
+            **Always return useful artifacts and files that you create to the user.**
+            Provide a status update before each tool call.
+            Your external name is Agent Mesh.    
+
+      response_format: >
+            Responses should be clear, concise, and professionally toned. 
+            Format responses to the user in Markdown using appropriate formatting.
+
+      frontend_welcome_message: ${FRONTEND_WELCOME_MESSAGE, ""}
+      frontend_bot_name: ${FRONTEND_BOT_NAME, "Solace Agent Mesh"}
+      frontend_collect_feedback: ${FRONTEND_COLLECT_FEEDBACK, false}

solace_agent_mesh/templates/gateway_app_template.py

@@ -0,0 +1,75 @@
+"""
+Solace Agent Mesh App class for the __GATEWAY_NAME_PASCAL_CASE__ Gateway.
+"""
+
+import logging
+from typing import Any, Dict, List, Type
+
+from solace_agent_mesh.gateway.base.app import BaseGatewayApp
+from solace_agent_mesh.gateway.base.component import BaseGatewayComponent
+
+from .component import __GATEWAY_NAME_PASCAL_CASE__GatewayComponent
+
+log = logging.getLogger(__name__)
+
+info = {
+    "class_name": "__GATEWAY_NAME_PASCAL_CASE__GatewayApp",
+    "description": "Custom App class for the A2A __GATEWAY_NAME_PASCAL_CASE__ Gateway.",
+}
+
+class __GATEWAY_NAME_PASCAL_CASE__GatewayApp(BaseGatewayApp):
+    """
+    App class for the A2A __GATEWAY_NAME_PASCAL_CASE__ Gateway.
+    - Extends BaseGatewayApp for common gateway functionalities.
+    - Defines __GATEWAY_NAME_PASCAL_CASE__-specific configuration parameters below.
+    """
+
+    # Define __GATEWAY_NAME_PASCAL_CASE__-specific parameters
+    # This list will be automatically merged with BaseGatewayApp's schema.
+    # These parameters will be configurable in the yaml config file
+    # under the 'app_config' section.
+    SPECIFIC_APP_SCHEMA_PARAMS: List[Dict[str, Any]] = [
+        # --- Example Required Parameter ---
+        # {
+        #     "name": "api_endpoint_url",
+        #     "required": True,
+        #     "type": "string",
+        #     "description": "The API endpoint URL for the __GATEWAY_NAME_SNAKE_CASE__ service.",
+        # },
+        # --- Example Optional Parameter with Default ---
+        # {
+        #     "name": "connection_timeout_seconds",
+        #     "required": False,
+        #     "type": "integer",
+        #     "default": 30,
+        #     "description": "Timeout in seconds for connecting to the __GATEWAY_NAME_SNAKE_CASE__ service.",
+        # },
+        # --- Example List Parameter ---
+        # {
+        #     "name": "processing_rules",
+        #     "required": False,
+        #     "type": "list",
+        #     "default": [],
+        #     "description": "List of processing rules for the gateway.",
+        #     "items": { # Schema for each item in the list
+        #         "type": "object",
+        #         "properties": {
+        #             "rule_name": {"type": "string", "required": True},
+        #             "action_type": {"type": "string", "enum": ["process", "ignore"]},
+        #             # ... other rule-specific schema fields
+        #         }
+        #     }
+        # }
+    ]
+
+    def __init__(self, app_info: Dict[str, Any], **kwargs):
+        log_prefix = app_info.get("name", "__GATEWAY_NAME_PASCAL_CASE__GatewayApp")
+        log.debug("[%s] Initializing __GATEWAY_NAME_PASCAL_CASE__GatewayApp...", log_prefix)
+        super().__init__(app_info=app_info, **kwargs)
+        log.debug("[%s] __GATEWAY_NAME_PASCAL_CASE__GatewayApp initialization complete.", self.name)
+
+    def _get_gateway_component_class(self) -> Type[BaseGatewayComponent]:
+        """
+        Returns the specific gateway component class for this app.
+        """
+        return __GATEWAY_NAME_PASCAL_CASE__GatewayComponent

solace_agent_mesh/templates/gateway_component_template.py

@@ -0,0 +1,484 @@
+"""
+Solace Agent Mesh Component class for the __GATEWAY_NAME_PASCAL_CASE__ Gateway.
+"""
+
+import logging
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from solace_agent_mesh.gateway.base.component import BaseGatewayComponent
+from a2a.types import (
+    TextPart,
+    FilePart,  # If handling files
+    DataPart,  # If handling structured data
+    Task,
+    TaskStatusUpdateEvent,
+    TaskArtifactUpdateEvent,
+    JSONRPCError,
+)
+from ...common import a2a
+from ...common.a2a import ContentPart
+
+log = logging.getLogger(__name__)
+
+info = {
+    "class_name": "__GATEWAY_NAME_PASCAL_CASE__GatewayComponent",
+    "description": (
+        "Implements the A2A __GATEWAY_NAME_PASCAL_CASE__ Gateway, inheriting from BaseGatewayComponent. "
+        "Handles communication between the __GATEWAY_NAME_SNAKE_CASE__ system and the A2A agent ecosystem."
+    ),
+    "config_parameters": [],  # Defined by __GATEWAY_NAME_PASCAL_CASE__GatewayApp
+    # Not needed for gateway components
+    "input_schema": {},
+    "output_schema": {},
+}
+
+
+class __GATEWAY_NAME_PASCAL_CASE__GatewayComponent(BaseGatewayComponent):
+    """
+    Solace Agent Mesh Component implementing the A2A __GATEWAY_NAME_PASCAL_CASE__ Gateway.
+    """
+
+    def __init__(self, **kwargs: Any):
+        super().__init__(**kwargs)
+        log.info(
+            "%s Initializing __GATEWAY_NAME_PASCAL_CASE__ Gateway Component (Post-Base)...",
+            self.log_identifier,
+        )
+
+        # --- Retrieve Gateway-Specific Configurations ---
+        # Example: self.api_endpoint_url = self.get_config("api_endpoint_url")
+        # Example: self.connection_timeout = self.get_config("connection_timeout_seconds")
+        # Example: self.processing_rules = self.get_config("processing_rules")
+
+        # --- Initialize External System Client/SDK ---
+        # Example: self.external_client = SomeApiClient(api_key=self.service_api_key, endpoint=self.api_endpoint_url)
+        # Ensure any client initialization is robust and handles potential errors.
+
+        log.info(
+            "%s __GATEWAY_NAME_PASCAL_CASE__ Gateway Component initialization complete.",
+            self.log_identifier,
+        )
+
+    def _start_listener(self) -> None:
+        """
+        GDK Hook: Start listening for events/requests from the external __GATEWAY_NAME_SNAKE_CASE__ system.
+        This method is called by BaseGatewayComponent.run() within self.async_loop.
+        - For polling: Start a polling loop (e.g., in a new thread or asyncio task).
+        - For webhooks: If embedding a server (like FastAPI in WebhookGateway), start it here.
+        - For SDKs with callbacks: Register your callbacks here.
+        """
+        log_id_prefix = f"{self.log_identifier}[StartListener]"
+        log.info(
+            "%s Starting listener for __GATEWAY_NAME_SNAKE_CASE__ system...",
+            log_id_prefix,
+        )
+
+        # Example for a polling mechanism (adapt as needed):
+        # if self.async_loop and self.async_loop.is_running():
+        #     self.async_loop.create_task(self._poll_external_system())
+        # else:
+        #     log.error("%s Async loop not available or not running. Cannot start polling.", log_id_prefix)
+        #     self.stop_signal.set() # Signal component to stop if listener cannot start
+
+        # If your external system uses an SDK that runs its own event loop or requires
+        # a blocking call to start, manage that appropriately (e.g., in a separate thread
+        # that communicates back to the async_loop via asyncio.run_coroutine_threadsafe).
+
+        log.info(
+            "%s __GATEWAY_NAME_SNAKE_CASE__ listener startup initiated.", log_id_prefix
+        )
+
+    # async def _poll_external_system(self): # Example polling loop
+    #     log_id_prefix = f"{self.log_identifier}[PollLoop]"
+    #     log.info("%s Starting __GATEWAY_NAME_SNAKE_CASE__ polling loop...", log_id_prefix)
+    #     while not self.stop_signal.is_set():
+    #         try:
+    #             # new_events = await self.external_client.get_new_events() # Or sync equivalent
+    #             # for event_data in new_events:
+    #             #     # 1. Authenticate the user and enrich their profile.
+    #             #     user_identity = await self.authenticate_and_enrich_user(event_data)
+    #             #     if not user_identity:
+    #             #         log.warning("%s Authentication failed for event, skipping.", log_id_prefix)
+    #             #         continue
+    #             #
+    #             #     # 2. Translate the external event into an A2A task.
+    #             #     try:
+    #             #         target_agent, parts, context = await self._translate_external_input(event_data)
+    #             #     except ValueError as e:
+    #             #         log.error("%s Translation failed for event: %s", log_id_prefix, e)
+    #             #         # Optionally, send an error back to the user in the external system here.
+    #             #         continue
+    #             #
+    #             #     # 3. Submit the A2A task.
+    #             #     if target_agent and parts:
+    #             #         await self.submit_a2a_task(
+    #             #             target_agent_name=target_agent,
+    #             #             a2a_parts=parts,
+    #             #             external_request_context=context,
+    #             #             user_identity=user_identity,
+    #             #             is_streaming=True # Or False, depending on gateway needs
+    #             #         )
+    #             #
+    #             # await asyncio.sleep(self.get_config("polling_interval_seconds", 60))
+    #             pass # Placeholder
+    #         except asyncio.CancelledError:
+    #             log.info("%s Polling loop cancelled.", log_id_prefix)
+    #             break
+    #         except Exception as e:
+    #             log.exception("%s Error in polling loop: %s", log_id_prefix, e)
+    #             await asyncio.sleep(60) # Wait before retrying on error
+    #     log.info("%s __GATEWAY_NAME_SNAKE_CASE__ polling loop stopped.", log_id_prefix)
+
+    def _stop_listener(self) -> None:
+        """
+        GDK Hook: Stop listening for events/requests and clean up resources.
+        This method is called by BaseGatewayComponent.cleanup().
+        - For polling: Signal the polling loop to stop.
+        - For webhooks: Gracefully shut down the embedded server.
+        - For SDKs: Unregister callbacks, close connections.
+        """
+        log_id_prefix = f"{self.log_identifier}[StopListener]"
+        log.info(
+            "%s Stopping listener for __GATEWAY_NAME_SNAKE_CASE__ system...",
+            log_id_prefix,
+        )
+
+        # self.stop_signal is already set by BaseGatewayComponent before calling this.
+        # Ensure your _start_listener logic (e.g., polling loop) respects self.stop_signal.
+
+        # Example: If you started a thread for a blocking SDK client:
+        # if hasattr(self, "sdk_thread") and self.sdk_thread.is_alive():
+        #     # Signal SDK to shutdown if possible, then join thread
+        #     # self.external_client.shutdown()
+        #     self.sdk_thread.join(timeout=10)
+
+        # Example: If an asyncio task was created for polling:
+        # if hasattr(self, "polling_task") and not self.polling_task.done():
+        #     self.polling_task.cancel()
+        #     # Optionally await it if _stop_listener can be async, or manage in cleanup
+
+        log.info(
+            "%s __GATEWAY_NAME_SNAKE_CASE__ listener shutdown initiated.", log_id_prefix
+        )
+
+    async def _extract_initial_claims(
+        self, external_event_data: Any
+    ) -> Optional[Dict[str, Any]]:
+        """
+        GDK Hook: Extracts the primary identity claims from a platform-specific event.
+        This method MUST be implemented by derived gateway components.
+
+        The base class's `authenticate_and_enrich_user` method will call this,
+        and then (if configured) pass the result to an Identity Service for enrichment.
+
+        Args:
+            external_event_data: Raw event data from the external platform
+                                 (e.g., FastAPIRequest, Slack event dictionary).
+
+        Returns:
+            A dictionary of initial claims, which MUST include an 'id' key.
+            Example: {"id": "user@example.com", "source": "api_key"}
+            Return None if authentication fails.
+        """
+        log_id_prefix = f"{self.log_identifier}[ExtractClaims]"
+        # log.debug("%s Extracting initial claims from external event: %s", log_id_prefix, external_event_data)
+
+        # --- Implement Claims Extraction Logic Here ---
+        # Example: Check an API key from headers or payload
+        # provided_key = external_event_data.get("headers", {}).get("X-API-Key")
+        # if provided_key and provided_key == self.get_config("service_api_key"):
+        #     user_id = external_event_data.get("user_id_field", "default_system_user")
+        #     log.info("%s Authentication successful for user: %s", log_id_prefix, user_id)
+        #     return {"id": user_id, "source": "api_key"}
+        # else:
+        #     log.warning("%s Authentication failed: API key mismatch or missing.", log_id_prefix)
+        #     return None
+
+        # If no authentication is needed for this gateway, you can use a default identity
+        # from the configuration. The base class handles this logic if `force_user_identity`
+        # or `default_user_identity` are set, but you can implement it here if needed.
+        # return {"id": "anonymous___GATEWAY_NAME_SNAKE_CASE___user", "source": "anonymous"}
+
+        log.warning("%s _extract_initial_claims not fully implemented.", log_id_prefix)
+        return {
+            "id": "placeholder_user_identity",
+            "source": "placeholder",
+        }  # Replace with actual logic
+
+    async def _translate_external_input(
+        self, external_event_data: Any
+    ) -> Tuple[str, List[ContentPart], Dict[str, Any]]:
+        """
+        GDK Hook: Translates the incoming external event/request into A2A task parameters.
+        This method is called *after* `authenticate_and_enrich_user`. The gateway's
+        event processing logic (e.g., a polling loop or request handler) is responsible
+        for calling `authenticate_and_enrich_user` first, and then passing the raw
+        event data to this method.
+
+        Args:
+            external_event_data: The raw data from the external system.
+
+        Returns:
+            A tuple:
+            - `target_agent_name` (str): Name of the A2A agent to route the task to.
+            - `a2a_parts` (List[ContentPart]): List of A2A Parts for the task.
+            - `external_request_context` (Dict[str, Any]): Dictionary to store any context
+              needed later (e.g., for _send_final_response_to_external).
+
+        Raises:
+            ValueError: If translation fails (e.g., target agent cannot be determined).
+        """
+        log_id_prefix = f"{self.log_identifier}[TranslateInput]"
+        # log.debug("%s Translating external event: %s", log_id_prefix, external_event_data)
+
+        a2a_parts: List[ContentPart] = []
+        target_agent_name: Optional[str] = (
+            None  # Determine this based on event data or config
+        )
+        # This context is stored and passed back to the `_send_*_to_external` methods.
+        # It should contain any information needed to route the response back to the
+        # original requester in the external system.
+        external_request_context: Dict[str, Any] = {
+            "a2a_session_id": f"__GATEWAY_NAME_SNAKE_CASE__-session-{self.generate_uuid()}",  # Example session ID
+            # "original_request_id": external_event_data.get("id"),
+        }
+
+        # --- Implement Translation Logic Here ---
+        # 1. Determine Target Agent:
+        #    - Statically from config: target_agent_name = self.get_config("default_target_agent")
+        #    - Dynamically from event_data: target_agent_name = external_event_data.get("target_agent_field")
+        #    - Based on processing_rules:
+        #      for rule in self.processing_rules:
+        #          if rule.matches(external_event_data):
+        #              target_agent_name = rule.get_agent_name()
+        #              break
+        target_agent_name = "OrchestratorAgent"  # Placeholder
+
+        # 2. Construct A2A Parts:
+        #    - Extract text:
+        #      text_content = external_event_data.get("message_text", "")
+        #      if text_content:
+        #          a2a_parts.append(a2a.create_text_part(text=text_content))
+        #    - Handle files (if any): Download, save to artifact service, create FilePart with URI.
+        #      (Requires self.shared_artifact_service to be configured and available).
+        #      The `user_identity` dict is available in the calling context (e.g., polling loop).
+        #      # if "file_url" in external_event_data and self.shared_artifact_service:
+        #      #     file_bytes = await download_file(external_event_data["file_url"])
+        #      #     file_name = external_event_data.get("file_name", "attachment.dat")
+        #      #     mime_type = external_event_data.get("mime_type", "application/octet-stream")
+        #      #     artifact_uri = await self.save_to_artifact_service(
+        #      #         file_bytes, file_name, mime_type,
+        #      #         user_identity, external_request_context["a2a_session_id"]
+        #      #     )
+        #      #     if artifact_uri:
+        #      #         a2a_parts.append(a2a.create_file_part_from_uri(uri=artifact_uri, name=file_name, mime_type=mime_type))
+        #    - Handle structured data:
+        #      # structured_data = external_event_data.get("data_payload")
+        #      # if structured_data:
+        #      #    a2a_parts.append(a2a.create_data_part(data=structured_data, metadata={"source": "__GATEWAY_NAME_SNAKE_CASE__"}))
+
+        # Example: Simple text passthrough
+        raw_text = str(
+            external_event_data.get(
+                "text_input_field", "Default text from __GATEWAY_NAME_SNAKE_CASE__"
+            )
+        )
+        a2a_parts.append(a2a.create_text_part(text=raw_text))
+
+        if not target_agent_name:
+            log.error("%s Could not determine target_agent_name.", log_id_prefix)
+            raise ValueError("Could not determine target agent for the request.")
+
+        if not a2a_parts:
+            log.warning(
+                "%s No A2A parts created from external event. Task might be empty.",
+                log_id_prefix,
+            )
+            # Depending on requirements, you might want to raise ValueError here too.
+
+        log.info(
+            "%s Translation complete. Target: %s, Parts: %d",
+            log_id_prefix,
+            target_agent_name,
+            len(a2a_parts),
+        )
+        return target_agent_name, a2a_parts, external_request_context
+
+    async def _send_final_response_to_external(
+        self, external_request_context: Dict[str, Any], task_data: Task
+    ) -> None:
+        """
+        GDK Hook: Sends the final A2A Task result back to the external __GATEWAY_NAME_SNAKE_CASE__ system.
+        - `external_request_context`: The context dictionary returned by _translate_external_input.
+        - `task_data`: The final A2A Task object (contains status, results, etc.).
+        """
+        log_id_prefix = f"{self.log_identifier}[SendFinalResponse]"
+        task_id = a2a.get_task_id(task_data)
+        # log.debug("%s Sending final response for task %s. Context: %s", log_id_prefix, task_id, external_request_context)
+
+        # --- Implement Logic to Send Response to External System ---
+        # 1. Extract relevant information from task_data using the `a2a` facade:
+        #    from a2a.types import TaskState
+        #    task_status = a2a.get_task_status(task_data) # e.g., TaskState.completed
+        #    artifacts = a2a.get_task_artifacts(task_data)
+        #    response_text = a2a.get_text_from_message(task_data.status.message) if task_data.status and task_data.status.message else ""
+
+        # 2. Format the response according to the external system's requirements.
+        #    if task_status == TaskState.failed:
+        #        final_message = f"Task failed: {response_text}"
+        #    elif task_status == TaskState.canceled:
+        #        final_message = "Task was canceled."
+        #    else:
+        #        final_message = response_text
+
+        # 3. Use information from external_request_context to send the response
+        #    (e.g., reply-to address, original request ID).
+        #    # original_request_id = external_request_context.get("original_request_id")
+        #    # await self.external_client.send_reply(original_request_id, final_message)
+
+        log.warning(
+            "%s _send_final_response_to_external not fully implemented for task %s.",
+            log_id_prefix,
+            task_id,
+        )
+
+    async def _send_error_to_external(
+        self, external_request_context: Dict[str, Any], error_data: JSONRPCError
+    ) -> None:
+        """
+        GDK Hook: Sends an A2A error back to the external __GATEWAY_NAME_SNAKE_CASE__ system.
+        This is called if an error occurs within the A2A GDK processing (e.g., task submission failure,
+        authorization failure after initial authentication).
+        - `external_request_context`: Context from _translate_external_input.
+        - `error_data`: A JSONRPCError object.
+        """
+        log_id_prefix = f"{self.log_identifier}[SendError]"
+        error_message = a2a.get_error_message(error_data)
+        error_code = a2a.get_error_code(error_data)
+        # log.warning("%s Sending error to external system. Error: %s. Context: %s", log_id_prefix, error_message, external_request_context)
+
+        # --- Implement Logic to Send Error to External System ---
+        # error_message_to_send = f"A2A Error: {error_message} (Code: {error_code})"
+        # # original_request_id = external_request_context.get("original_request_id")
+        # # await self.external_client.send_error_reply(original_request_id, error_message_to_send)
+
+        log.warning(
+            "%s _send_error_to_external not fully implemented. Error: %s",
+            log_id_prefix,
+            error_message,
+        )
+
+    async def _send_update_to_external(
+        self,
+        external_request_context: Dict[str, Any],
+        event_data: Union[TaskStatusUpdateEvent, TaskArtifactUpdateEvent],
+        is_final_chunk_of_update: bool,
+    ) -> None:
+        """
+        GDK Hook: Sends intermediate A2A task updates (status or artifacts) to the external system.
+        - This is optional. If your gateway doesn't support streaming intermediate updates,
+        - you can leave this method as a no-op (just log).
+        - `is_final_chunk_of_update`: True if this is the last part of a streamed TextPart from TaskStatusUpdateEvent.
+        """
+        log_id_prefix = f"{self.log_identifier}[SendUpdate]"
+        task_id = event_data.task_id
+        # log.debug("%s Received A2A update for task %s. Type: %s. FinalChunk: %s",
+        #           log_id_prefix, task_id, type(event_data).__name__, is_final_chunk_of_update)
+
+        # --- Implement Logic to Send Intermediate Update (if supported) ---
+        # if isinstance(event_data, TaskStatusUpdateEvent):
+        #     message = a2a.get_message_from_status_update(event_data)
+        #     if message:
+        #         # Get text content
+        #         text_content = a2a.get_text_from_message(message)
+        #         if text_content:
+        #             # Send text_content to external system
+        #             pass
+        #
+        #         # Check for specific status signals (DataParts)
+        #         data_parts = a2a.get_data_parts_from_message(message)
+        #         for part in data_parts:
+        #             data = a2a.get_data_from_data_part(part)
+        #             if data.get("type") == "agent_progress_update":
+        #                 status_text = data.get("status_text")
+        #                 # Send status_text to external system
+        #                 pass
+        #
+        # elif isinstance(event_data, TaskArtifactUpdateEvent):
+        #     artifact = a2a.get_artifact_from_artifact_update(event_data)
+        #     if artifact:
+        #         # Handle artifact updates (e.g., notify external system of new artifact URI)
+        #         pass
+
+        # Default: Log that this gateway does not handle intermediate updates.
+        log.debug(
+            "%s __GATEWAY_NAME_PASCAL_CASE__ Gateway does not process intermediate updates. Update for task %s ignored.",
+            log_id_prefix,
+            task_id,
+        )
+        pass  # No-op by default
+
+    # --- Optional: Helper methods for your gateway ---
+    def generate_uuid(self) -> str:  # Made this a method of the class
+        import uuid
+
+        return str(uuid.uuid4())
+
+    # async def save_to_artifact_service(self, content_bytes: bytes, filename: str, mime_type: str, user_identity: Dict[str, Any], session_id: str) -> Optional[str]:
+    #     """Helper to save content to the shared artifact service."""
+    #     if not self.shared_artifact_service:
+    #         log.error("%s Artifact service not available. Cannot save file: %s", self.log_identifier, filename)
+    #         return None
+    #     try:
+    #         from ...agent.utils.artifact_helpers import save_artifact_with_metadata # Adjust import
+    #         from datetime import datetime, timezone
+
+    #         user_id = user_identity.get("id")
+    #         if not user_id:
+    #             log.error("%s Cannot save artifact, user_id not found in user_identity.", self.log_identifier)
+    #             return None
+
+    #         save_result = await save_artifact_with_metadata(
+    #             artifact_service=self.shared_artifact_service,
+    #             app_name=self.gateway_id, # from BaseGatewayComponent
+    #             user_id=user_id,
+    #             session_id=session_id,
+    #             filename=filename,
+    #             content_bytes=content_bytes,
+    #             mime_type=mime_type,
+    #             metadata_dict={
+    #                 "source": "__GATEWAY_NAME_SNAKE_CASE___upload",
+    #                 "original_filename": filename,
+    #                 "upload_timestamp_utc": datetime.now(timezone.utc).isoformat(),
+    #             },
+    #             timestamp=datetime.now(timezone.utc)
+    #         )
+    #         if save_result["status"] in ["success", "partial_success"]:
+    #             data_version = save_result.get("data_version", 0)
+    #             artifact_uri = f"artifact://{self.gateway_id}/{user_id}/{session_id}/{filename}?version={data_version}"
+    #             log.info("%s Saved artifact: %s", self.log_identifier, artifact_uri)
+    #             return artifact_uri
+    #         else:
+    #             log.error("%s Failed to save artifact %s: %s", self.log_identifier, filename, save_result.get("message"))
+    #             return None
+    #     except Exception as e:
+    #         log.exception("%s Error saving artifact %s: %s", self.log_identifier, filename, e)
+    #         return None
+
+    def cleanup(self):
+        """
+        GDK Hook: Called before the component is fully stopped.
+        Perform any final cleanup specific to this component beyond _stop_listener.
+        """
+        log.info(
+            "%s Cleaning up __GATEWAY_NAME_PASCAL_CASE__ Gateway Component (Pre-Base)...",
+            self.log_identifier,
+        )
+        # Example: Close any persistent connections not handled in _stop_listener
+        # if hasattr(self, "persistent_connection") and self.persistent_connection.is_open():
+        #     self.persistent_connection.close()
+        super().cleanup()  # Important to call super().cleanup()
+        log.info(
+            "%s __GATEWAY_NAME_PASCAL_CASE__ Gateway Component cleanup finished.",
+            self.log_identifier,
+        )