solace-agent-mesh 0.2.4__py3-none-any.whl → 1.0.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_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,73 @@
+"""
+Solace Agent Mesh App class for the __GATEWAY_NAME_PASCAL_CASE__ Gateway.
+"""
+
+from typing import Any, Dict, List, Type
+
+from solace_ai_connector.common.log import log
+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
+
+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,431 @@
+"""
+Solace Agent Mesh Component class for the __GATEWAY_NAME_PASCAL_CASE__ Gateway.
+"""
+
+import asyncio  # If needed for async operations with external system
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from solace_ai_connector.common.log import log
+from solace_agent_mesh.gateway.base.component import BaseGatewayComponent
+from solace_agent_mesh.common.types import (
+    Part as A2APart,
+    TextPart,
+    FilePart,  # If handling files
+    DataPart,  # If handling structured data
+    Task,
+    TaskStatusUpdateEvent,
+    TaskArtifactUpdateEvent,
+    JSONRPCError,
+    FileContent,  # Added for FilePart example
+)
+
+# from solace_agent_mesh.core_a2a.service import CoreA2AService # If direct interaction needed
+
+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
+    "input_schema": {
+        "type": "object",
+        "description": "Not typically used directly by GDK; component reacts to external events or A2A control messages.",
+    },
+    "output_schema": {
+        "type": "object",
+        "description": "Not typically used directly by GDK; component publishes results to external system or A2A.",
+    },
+}
+
+
+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:
+    #             #     # Process each event: authenticate, translate, submit A2A task
+    #             #     # This often involves calling other GDK methods or internal helpers
+    #             #     authenticated_user = await self._authenticate_external_user(event_data)
+    #             #     if authenticated_user:
+    #             #         target_agent, parts, context = await self._translate_external_input(event_data, authenticated_user)
+    #             #         if target_agent and parts:
+    #             #             await self.submit_a2a_task(target_agent, parts, context, authenticated_user)
+    #             # 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 _authenticate_external_user(
+        self, external_event_data: Any  # Type hint with actual external event data type
+    ) -> Optional[str]:
+        """
+        GDK Hook: Authenticates the user or system from the external event data.
+        - Implement logic based on your gateway's authentication mechanism (e.g., API key, token, signature).
+        - Use configurations retrieved in __init__ (e.g., self.service_api_key).
+        - Return a unique user/system identifier (string) on success, or None on failure.
+          This identifier will be used for A2A authorization (scope checking).
+        """
+        log_id_prefix = f"{self.log_identifier}[AuthenticateUser]"
+        # log.debug("%s Authenticating external event: %s", log_id_prefix, external_event_data)
+
+        # --- Implement Authentication 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.service_api_key:
+        #     user_identity = external_event_data.get("user_id_field", "default_system_user")
+        #     log.info("%s Authentication successful for user: %s", log_id_prefix, user_identity)
+        #     return user_identity
+        # else:
+        #     log.warning("%s Authentication failed: API key mismatch or missing.", log_id_prefix)
+        #     return None
+
+        # If no authentication is needed for this gateway:
+        # return "anonymous___GATEWAY_NAME_SNAKE_CASE___user"
+
+        log.warning(
+            "%s _authenticate_external_user not fully implemented.", log_id_prefix
+        )
+        return "placeholder_user_identity"  # Replace with actual logic
+
+    async def _translate_external_input(
+        self, external_event_data: Any, authenticated_user_identity: str
+    ) -> Tuple[Optional[str], List[A2APart], Dict[str, Any]]:
+        """
+        GDK Hook: Translates the incoming external event/request into an A2A task.
+        - `external_event_data`: The raw data from the external system.
+        - `authenticated_user_identity`: The identity returned by _authenticate_external_user.
+
+        Returns a tuple:
+        - `target_agent_name` (str | None): Name of the A2A agent to route the task to. None if translation fails.
+        - `a2a_parts` (List[A2APart]): List of A2A Parts (TextPart, FilePart, DataPart) for the task.
+        - `external_request_context` (Dict[str, Any]): Dictionary to store any context needed later
+          (e.g., for _send_final_response_to_external, like original request ID, reply-to address).
+        """
+        log_id_prefix = f"{self.log_identifier}[TranslateInput]"
+        # log.debug("%s Translating external event: %s", log_id_prefix, external_event_data)
+
+        a2a_parts: List[A2APart] = []
+        target_agent_name: Optional[str] = (
+            None  # Determine this based on event data or config
+        )
+        external_request_context: Dict[str, Any] = {
+            "user_id_for_a2a": authenticated_user_identity,
+            "app_name_for_artifacts": self.gateway_id,  # For artifact service context
+            "user_id_for_artifacts": authenticated_user_identity,
+            "a2a_session_id": f"__GATEWAY_NAME_SNAKE_CASE__-session-{self.generate_uuid()}",  # Example session ID
+            # Add any other relevant context from external_event_data needed for response handling
+            # "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(TextPart(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)
+        #      # 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,
+        #      #         authenticated_user_identity, external_request_context["a2a_session_id"]
+        #      #     )
+        #      #     if artifact_uri:
+        #      #         a2a_parts.append(FilePart(file=FileContent(name=file_name, mimeType=mime_type, uri=artifact_uri)))
+        #    - Handle structured data:
+        #      # structured_data = external_event_data.get("data_payload")
+        #      # if structured_data:
+        #      #    a2a_parts.append(DataPart(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(TextPart(text=raw_text))
+
+        if not target_agent_name:
+            log.error("%s Could not determine target_agent_name.", log_id_prefix)
+            return None, [], {}  # Indicate translation failure
+
+        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 return None, [], {} 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]"
+        # log.debug("%s Sending final response for task %s. Context: %s", log_id_prefix, task_data.id, external_request_context)
+
+        # --- Implement Logic to Send Response to External System ---
+        # 1. Extract relevant information from task_data:
+        #    - task_data.status.state (e.g., TaskState.COMPLETED, TaskState.FAILED)
+        #    - task_data.status.message.parts (usually TextPart for final agent response)
+        #    - task_data.artifacts (if agent produced artifacts)
+
+        # 2. Format the response according to the external system's requirements.
+        #    response_text = "Task completed."
+        #    if task_data.status and task_data.status.message and task_data.status.message.parts:
+        #        for part in task_data.status.message.parts:
+        #            if isinstance(part, TextPart):
+        #                response_text = part.text
+        #                break
+        #    if task_data.status and task_data.status.state == TaskState.FAILED:
+        #        response_text = f"Task failed: {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, response_text)
+
+        log.warning(
+            "%s _send_final_response_to_external not fully implemented for task %s.",
+            log_id_prefix,
+            task_data.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]"
+        # log.warning("%s Sending error to external system. Error: %s. Context: %s", log_id_prefix, error_data.message, external_request_context)
+
+        # --- Implement Logic to Send Error to External System ---
+        # error_message_to_send = f"A2A Error: {error_data.message} (Code: {error_data.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_data.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.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):
+        #     if event_data.status and event_data.status.message and event_data.status.message.parts:
+        #         for part in event_data.status.message.parts:
+        #             if isinstance(part, TextPart):
+        #                 # Send part.text to external system
+        #                 pass
+        #             elif isinstance(part, DataPart) and part.data.get("a2a_signal_type") == "agent_status_message":
+        #                 # Send agent status signal text part.data.get("text")
+        #                 pass
+        # elif isinstance(event_data, TaskArtifactUpdateEvent):
+        #     # 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_id: str, 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 src.solace_agent_mesh.agent.utils.artifact_helpers import save_artifact_with_metadata # Adjust import
+    #         from datetime import datetime, timezone
+
+    #         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,
+        )

solace_agent_mesh/templates/gateway_config_template.yaml

@@ -0,0 +1,43 @@
+# Solace Agent Mesh: __GATEWAY_NAME_SNAKE_CASE__ Gateway Configuration
+
+log:
+  stdout_log_level: INFO
+  log_file_level: DEBUG
+  log_file: "__GATEWAY_NAME_SNAKE_CASE___gateway.log"
+
+!include ../shared_config.yaml
+
+apps:
+  - name: __GATEWAY_NAME_SNAKE_CASE___gateway_app
+    app_base_path: .
+    app_module: src.__GATEWAY_NAME_SNAKE_CASE__.app
+
+    broker:
+      <<: *broker_connection
+
+    app_config:
+      namespace: __APP_CONFIG_NAMESPACE__
+      gateway_id: __GATEWAY_ID__
+      
+      artifact_service: __ARTIFACT_SERVICE__
+
+      authorization_service:
+        type: "none" # Or "default_rbac"
+        # role_definitions_path: "config/auth/roles.yaml"
+        # user_assignments_path: "config/auth/users.yaml"
+
+      system_purpose: >
+        __SYSTEM_PURPOSE__
+
+      response_format: >
+        __RESPONSE_FORMAT__
+
+      
+      # enable_embed_resolution: true # Default is true
+      # gateway_artifact_content_limit_bytes: 10485760 # 10MB
+      # gateway_recursive_embed_depth: 3
+
+      # --- __GATEWAY_NAME_PASCAL_CASE__ Specific Parameters (Define schema in src/__GATEWAY_NAME_SNAKE_CASE__/app.py) ---
+      # example_parameter: "default_value"
+      # api_key: "${__GATEWAY_NAME_UPPER_CASE__}_API_KEY" 
+      # endpoint_url: "https://api.example.com/__GATEWAY_NAME_SNAKE_CASE__"