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

solace_agent_mesh/agent/proxies/base/config.py

@@ -0,0 +1,85 @@
+"""
+Pydantic configuration models for proxy applications.
+"""
+
+from typing import List, Literal, Optional
+
+from pydantic import Field, model_validator
+
+from ....common.utils.pydantic_utils import SamConfigBase
+
+
+class ArtifactServiceConfig(SamConfigBase):
+    """Configuration for the shared Artifact Service."""
+
+    type: str = Field(
+        ..., description="Service type (e.g., 'memory', 'gcs', 'filesystem')."
+    )
+    base_path: Optional[str] = Field(
+        default=None,
+        description="Base directory path (required for type 'filesystem').",
+    )
+    bucket_name: Optional[str] = Field(
+        default=None, description="GCS bucket name (required for type 'gcs')."
+    )
+    artifact_scope: Literal["namespace", "app", "custom"] = Field(
+        default="namespace", description="Process-wide scope for all artifact services."
+    )
+    artifact_scope_value: Optional[str] = Field(
+        default=None,
+        description="Custom identifier for artifact scope (required if artifact_scope is 'custom').",
+    )
+
+    @model_validator(mode="after")
+    def check_artifact_scope(self) -> "ArtifactServiceConfig":
+        if self.artifact_scope == "custom" and not self.artifact_scope_value:
+            raise ValueError(
+                "'artifact_scope_value' is required when 'artifact_scope' is 'custom'."
+            )
+        if self.artifact_scope != "custom" and self.artifact_scope_value:
+            from solace_ai_connector.common.log import log
+            log.warning(
+                "Configuration Warning: 'artifact_scope_value' is ignored when 'artifact_scope' is not 'custom'."
+            )
+        return self
+
+
+class ProxiedAgentConfig(SamConfigBase):
+    """Base configuration for a proxied agent."""
+
+    name: str = Field(
+        ...,
+        description="The name the agent will have on the Solace mesh.",
+    )
+    request_timeout_seconds: Optional[int] = Field(
+        default=None,
+        description="Optional timeout override for this specific agent.",
+    )
+
+
+class BaseProxyAppConfig(SamConfigBase):
+    """Base configuration for all proxy applications."""
+
+    namespace: str = Field(
+        ...,
+        description="Absolute topic prefix for A2A communication (e.g., 'myorg/dev').",
+    )
+    proxied_agents: List[ProxiedAgentConfig] = Field(
+        ...,
+        min_length=1,
+        description="A list of downstream agents to be proxied.",
+    )
+    artifact_service: ArtifactServiceConfig = Field(
+        default_factory=lambda: ArtifactServiceConfig(type="memory"),
+        description="Configuration for the shared Artifact Service.",
+    )
+    discovery_interval_seconds: int = Field(
+        default=60,
+        ge=0,
+        description="Interval (seconds) to re-fetch agent cards. <= 0 disables periodic discovery.",
+    )
+    default_request_timeout_seconds: int = Field(
+        default=300,
+        gt=0,
+        description="Default timeout in seconds for requests to downstream agents.",
+    )

solace_agent_mesh/agent/proxies/base/proxy_task_context.py

@@ -0,0 +1,17 @@
+"""
+Encapsulates the runtime state for a single, in-flight proxied agent task.
+"""
+
+from typing import Any, Dict
+from dataclasses import dataclass
+
+
+@dataclass
+class ProxyTaskContext:
+    """
+    A class to hold all runtime state and control mechanisms for a single proxied agent task.
+    This object is created when a task is initiated and destroyed when it completes.
+    """
+
+    task_id: str
+    a2a_context: Dict[str, Any]

solace_agent_mesh/agent/sac/app.py

@@ -23,7 +23,13 @@ from ...common.a2a import (
     get_agent_status_subscription_topic,
     get_sam_events_subscription_topic,
 )
-from ...common.constants import DEFAULT_COMMUNICATION_TIMEOUT, TEXT_ARTIFACT_CONTEXT_MAX_LENGTH_CAPACITY, TEXT_ARTIFACT_CONTEXT_DEFAULT_LENGTH
+from ...common.constants import (
+    DEFAULT_COMMUNICATION_TIMEOUT,
+    TEXT_ARTIFACT_CONTEXT_MAX_LENGTH_CAPACITY,
+    TEXT_ARTIFACT_CONTEXT_DEFAULT_LENGTH,
+    HEALTH_CHECK_TTL_SECONDS,
+    HEALTH_CHECK_INTERVAL_SECONDS,
+)
 from ...agent.sac.component import SamAgentComponent
 from ...agent.utils.artifact_helpers import DEFAULT_SCHEMA_MAX_KEYS
 from ...common.utils.pydantic_utils import SamConfigBase
@@ -31,6 +37,14 @@ from ..tools.tool_config_types import AnyToolConfig
 
 log = logging.getLogger(__name__)
 
+# Try to import TrustManagerConfig from enterprise repo
+try:
+    from solace_agent_mesh_enterprise.common.trust.config import TrustManagerConfig
+
+except ImportError:
+    # Enterprise features not available - create a placeholder type
+    TrustManagerConfig = Dict[str, Any]  # type: ignore
+
 info = {
     "class_name": "SamAgentApp",
     "description": "Custom App class for SAM Agent Host with namespace prefixing and automatic subscription generation.",
@@ -79,6 +93,14 @@ class AgentDiscoveryConfig(SamConfigBase):
     enabled: bool = Field(
         default=True, description="Enable discovery and instruction injection."
     )
+    health_check_ttl_seconds: int = Field(
+        default=HEALTH_CHECK_TTL_SECONDS,
+        description="Time-to-live in seconds after which an unresponsive agent is de-registered.",
+    )
+    health_check_interval_seconds: int = Field(
+        default=HEALTH_CHECK_INTERVAL_SECONDS,
+        description="Interval in seconds between health checks.",
+    )
 
 
 class InterAgentCommunicationConfig(SamConfigBase):
@@ -212,7 +234,9 @@ class ArtifactServiceConfig(SamConfigBase):
 class SessionServiceConfig(SamConfigBase):
     """Configuration for the ADK Session Service."""
 
-    type: str = Field(..., description="Service type (e.g., 'memory', 'sql', 'vertex_rag').")
+    type: str = Field(
+        ..., description="Service type (e.g., 'memory', 'sql', 'vertex_rag')."
+    )
     default_behavior: Literal["PERSISTENT", "RUN_BASED"] = Field(
         default="PERSISTENT", description="Default behavior for session service."
     )
@@ -229,10 +253,21 @@ class SamAgentAppConfig(SamConfigBase):
         description="Absolute topic prefix for A2A communication (e.g., 'myorg/dev').",
     )
     agent_name: str = Field(..., description="Unique name for this ADK agent instance.")
-    display_name: str = Field(default=None, description="Human-friendly display name for this ADK agent instance.")
+    display_name: str = Field(
+        default=None,
+        description="Human-friendly display name for this ADK agent instance.",
+    )
+    deployment: Optional[Dict[str, Any]] = Field(
+        default=None,
+        description="Deployment tracking information for rolling updates and version control.",
+    )
     model: Union[str, Dict[str, Any]] = Field(
         ..., description="ADK model name (string) or BaseLlm config dict."
     )
+    trust_manager: Optional[Union[TrustManagerConfig, Dict[str, Any]]] = Field(
+        default=None,
+        description="Configuration for the Trust Manager (enterprise feature)",
+    )
     instruction: Any = Field(
         default="",
         description="User-provided instructions for the ADK agent (string or invoke block).",
@@ -423,6 +458,20 @@ class SamAgentApp(App):
             get_agent_status_subscription_topic(namespace, agent_name),
             get_sam_events_subscription_topic(namespace, "session"),
         ]
+
+        # Add trust card subscription if trust manager is enabled
+        trust_config = app_config.get("trust_manager")
+        if trust_config and trust_config.get("enabled", False):
+            from ...common.a2a.protocol import get_trust_card_subscription_topic
+
+            trust_card_topic = get_trust_card_subscription_topic(namespace)
+            required_topics.append(trust_card_topic)
+            log.info(
+                "Trust Manager enabled for agent '%s', added trust card subscription: %s",
+                agent_name,
+                trust_card_topic,
+            )
+
         generated_subs = [{"topic": topic} for topic in required_topics]
         log.info(
             "Automatically generated subscriptions for Agent '%s': %s",
@@ -452,8 +501,12 @@ class SamAgentApp(App):
         broker_config["queue_name"] = generated_queue_name
         log.debug("Injected generated broker.queue_name: %s", generated_queue_name)
 
-        broker_config["temporary_queue"] = True
-        log.debug("Set broker_config.temporary_queue = True")
+        broker_config["temporary_queue"] = app_info.get("broker", {}).get(
+            "temporary_queue", True
+        )
+        log.debug(
+            "Set broker_config.temporary_queue = %s", broker_config["temporary_queue"]
+        )
 
         super().__init__(app_info, **kwargs)
         log.debug("%s Agent initialization complete.", agent_name)

solace_agent_mesh/agent/sac/component.py

@@ -8,10 +8,8 @@ import asyncio
 import functools
 import threading
 import concurrent.futures
-import uuid
 import fnmatch
-import base64
-from datetime import datetime, timezone
+import time
 import json
 from solace_ai_connector.common.message import (
     Message as SolaceMessage,
@@ -73,9 +71,10 @@ from ...agent.tools.peer_agent_tool import (
     PEER_TOOL_PREFIX,
 )
 from ...common.middleware.registry import MiddlewareRegistry
-from ...common.constants import DEFAULT_COMMUNICATION_TIMEOUT
+from ...common.constants import DEFAULT_COMMUNICATION_TIMEOUT, HEALTH_CHECK_TTL_SECONDS, HEALTH_CHECK_INTERVAL_SECONDS
 from ...agent.tools.registry import tool_registry
 from ...common.sac.sam_component_base import SamComponentBase
+from ...common.agent_registry import AgentRegistry
 
 log = logging.getLogger(__name__)
 
@@ -113,6 +112,7 @@ class SamAgentComponent(SamComponentBase):
 
     CORRELATION_DATA_PREFIX = CORRELATION_DATA_PREFIX
     HOST_COMPONENT_VERSION = "1.0.0-alpha"
+    HEALTH_CHECK_TIMER_ID = "agent_health_check"
 
     def __init__(self, **kwargs):
         """
@@ -129,6 +129,9 @@ class SamAgentComponent(SamComponentBase):
         super().__init__(info, **kwargs)
         self.agent_name = self.get_config("agent_name")
         log.info("%s Initializing A2A ADK Host Component...", self.log_identifier)
+        
+        # Initialize the agent registry for health tracking
+        self.agent_registry = AgentRegistry()
         try:
             self.namespace = self.get_config("namespace")
             if not self.namespace:
@@ -237,7 +240,7 @@ class SamAgentComponent(SamComponentBase):
         self.adk_agent: LlmAgent = None
         self.runner: Runner = None
         self.agent_card_tool_manifest: List[Dict[str, Any]] = []
-        self.peer_agents: Dict[str, Any] = {}
+        self.peer_agents: Dict[str, Any] = {}  # Keep for backward compatibility
         self._card_publish_timer_id: str = f"publish_card_{self.agent_name}"
         self._async_init_future = None
         self.peer_response_queues: Dict[str, asyncio.Queue] = {}
@@ -276,8 +279,13 @@ class SamAgentComponent(SamComponentBase):
                     f"Failed to initialize synchronous ADK services: {service_err}"
                 ) from service_err
 
-            from .app import AgentInitCleanupConfig # delayed import to avoid circular dependency
-            if init_func_details and isinstance(init_func_details, AgentInitCleanupConfig):
+            from .app import (
+                AgentInitCleanupConfig,
+            )  # delayed import to avoid circular dependency
+
+            if init_func_details and isinstance(
+                init_func_details, AgentInitCleanupConfig
+            ):
                 module_name = init_func_details.get("module")
                 func_name = init_func_details.get("name")
                 base_path = init_func_details.get("base_path")
@@ -404,16 +412,39 @@ class SamAgentComponent(SamComponentBase):
                     self.log_identifier,
                     publish_interval_sec,
                 )
+                # Register timer with callback
                 self.add_timer(
                     delay_ms=1000,
                     timer_id=self._card_publish_timer_id,
                     interval_ms=publish_interval_sec * 1000,
+                    callback=lambda timer_data: publish_agent_card(self),
                 )
             else:
                 log.warning(
                     "%s Agent card publishing interval not configured or invalid, card will not be published periodically.",
                     self.log_identifier,
                 )
+                
+            # Set up health check timer if enabled
+            health_check_interval_seconds = self.agent_discovery_config.get("health_check_interval_seconds", HEALTH_CHECK_INTERVAL_SECONDS)
+            if health_check_interval_seconds > 0:
+                log.info(
+                    "%s Scheduling agent health check every %d seconds.",
+                    self.log_identifier,
+                    health_check_interval_seconds,
+                )
+                self.add_timer(
+                    delay_ms=health_check_interval_seconds * 1000,
+                    timer_id=self.HEALTH_CHECK_TIMER_ID,
+                    interval_ms=health_check_interval_seconds * 1000,
+                    callback=lambda timer_data: self._check_agent_health(),
+                )
+            else:
+                log.warning(
+                    "%s Agent health check interval not configured or invalid, health checks will not run periodically.",
+                    self.log_identifier,
+                )
+                
             log.info(
                 "%s Initialization complete for agent: %s",
                 self.log_identifier,
@@ -423,75 +454,35 @@ class SamAgentComponent(SamComponentBase):
             log.exception("%s Initialization failed: %s", self.log_identifier, e)
             raise
 
+    def _get_component_id(self) -> str:
+        """Returns the agent name as the component identifier."""
+        return self.agent_name
+
+    def _get_component_type(self) -> str:
+        """Returns 'agent' as the component type."""
+        return "agent"
+
     def invoke(self, message: SolaceMessage, data: dict) -> dict:
-        """Placeholder invoke method. Primary logic resides in process_event."""
+        """Placeholder invoke method. Primary logic resides in _handle_message."""
         log.warning(
-            "%s 'invoke' method called, but primary logic resides in 'process_event'. This should not happen in normal operation.",
+            "%s 'invoke' method called, but primary logic resides in '_handle_message'. This should not happen in normal operation.",
             self.log_identifier,
         )
         return None
 
-    def process_event(self, event: Event):
-        """Processes incoming events (Messages, Timers, etc.)."""
-        try:
-            loop = self.get_async_loop()
-            is_loop_running = loop.is_running() if loop else False
-            if loop and is_loop_running:
-                coro = process_event(self, event)
-                future = asyncio.run_coroutine_threadsafe(coro, loop)
-                future.add_done_callback(
-                    functools.partial(
-                        self._handle_scheduled_task_completion,
-                        event_type_for_log=event.event_type,
-                    )
-                )
-            else:
-                log.error(
-                    "%s Async loop not available or not running (loop is %s, is_running: %s). Cannot process event: %s",
-                    self.log_identifier,
-                    "present" if loop else "None",
-                    is_loop_running,
-                    event.event_type,
-                )
-                if event.event_type == EventType.MESSAGE:
-                    try:
-                        event.data.call_negative_acknowledgements()
-                        log.warning(
-                            "%s NACKed message due to unavailable async loop for event processing.",
-                            self.log_identifier,
-                        )
-                    except Exception as nack_e:
-                        log.error(
-                            "%s Failed to NACK message after async loop issue: %s",
-                            self.log_identifier,
-                            nack_e,
-                        )
-        except Exception as e:
-            log.error(
-                "%s Error processing event: %s. Exception: %s",
-                self.log_identifier,
-                event.event_type,
-                e,
-            )
-            if event.event_type == EventType.MESSAGE:
-                try:
-                    event.data.call_negative_acknowledgements()
-                    log.warning(
-                        "%s NACKed message due to error in event processing.",
-                        self.log_identifier,
-                    )
-                except Exception as nack_e:
-                    log.error(
-                        "%s Failed to NACK message after error in event processing: %s",
-                        self.log_identifier,
-                        nack_e,
-                    )
+    async def _handle_message_async(self, message: SolaceMessage, topic: str) -> None:
+        """
+        Async handler for incoming messages.
+
+        Routes the message to the async event handler.
 
-    def handle_timer_event(self, timer_data: Dict[str, Any]):
-        """Handles timer events, specifically for agent card publishing."""
-        log.debug("%s Received timer event: %s", self.log_identifier, timer_data)
-        if timer_data.get("timer_id") == self._card_publish_timer_id:
-            publish_agent_card(self)
+        Args:
+            message: The Solace message
+            topic: The topic the message was received on
+        """
+        # Create event and process asynchronously
+        event = Event(EventType.MESSAGE, message)
+        await process_event(self, event)
 
     async def handle_cache_expiry_event(self, cache_data: Dict[str, Any]):
         """
@@ -866,7 +857,8 @@ class SamAgentComponent(SamComponentBase):
         peer_tools_to_add = []
         allowed_peer_descriptions = []
 
-        for peer_name, agent_card in self.peer_agents.items():
+        # Sort peer agents alphabetically to ensure consistent tool ordering for prompt caching
+        for peer_name, agent_card in sorted(self.peer_agents.items()):
             if not isinstance(agent_card, AgentCard) or peer_name == self_name:
                 continue
 
@@ -1140,7 +1132,11 @@ class SamAgentComponent(SamComponentBase):
         """
         if hasattr(tool, "origin") and tool.origin is not None:
             return tool.origin
-        elif hasattr(tool, "func") and hasattr(tool.func, "origin") and tool.func.origin is not None:
+        elif (
+            hasattr(tool, "func")
+            and hasattr(tool.func, "origin")
+            and tool.func.origin is not None
+        ):
             return tool.func.origin
         else:
             return getattr(tool, "origin", "unknown")
@@ -2078,7 +2074,7 @@ class SamAgentComponent(SamComponentBase):
                     self.log_identifier,
                     len(task_context.produced_artifacts),
                 )
-            
+
             # Add token usage summary
             if task_context:
                 token_summary = task_context.get_token_usage_summary()
@@ -2833,6 +2829,35 @@ class SamAgentComponent(SamComponentBase):
         if isinstance(user_config, dict):
             user_properties["a2aUserConfig"] = user_config
 
+        # Retrieve and propagate authentication token from parent task context
+        parent_task_id = a2a_message.metadata.get("parentTaskId")
+        if parent_task_id:
+            with self.active_tasks_lock:
+                parent_task_context = self.active_tasks.get(parent_task_id)
+
+            if parent_task_context:
+                auth_token = parent_task_context.get_security_data("auth_token")
+                if auth_token:
+                    user_properties["authToken"] = auth_token
+                    log.debug(
+                        "%s Propagating authentication token to peer agent %s for sub-task %s",
+                        log_identifier_helper,
+                        target_agent_name,
+                        sub_task_id,
+                    )
+                else:
+                    log.debug(
+                        "%s No authentication token found in parent task context for sub-task %s",
+                        log_identifier_helper,
+                        sub_task_id,
+                    )
+            else:
+                log.warning(
+                    "%s Parent task context not found for task %s, cannot propagate authentication token",
+                    log_identifier_helper,
+                    parent_task_id,
+                )
+
         self.publish_a2a_message(
             payload=a2a_request.model_dump(by_alias=True, exclude_none=True),
             topic=peer_request_topic,
@@ -2991,11 +3016,15 @@ class SamAgentComponent(SamComponentBase):
         """Clean up resources on component shutdown."""
         log.info("%s Cleaning up A2A ADK Host Component.", self.log_identifier)
         self.cancel_timer(self._card_publish_timer_id)
+        self.cancel_timer(self.HEALTH_CHECK_TIMER_ID)
 
         cleanup_func_details = self.get_config("agent_cleanup_function")
 
-        from .app import AgentInitCleanupConfig # Avoid circular import
-        if cleanup_func_details and isinstance(cleanup_func_details, AgentInitCleanupConfig):
+        from .app import AgentInitCleanupConfig  # Avoid circular import
+
+        if cleanup_func_details and isinstance(
+            cleanup_func_details, AgentInitCleanupConfig
+        ):
             module_name = cleanup_func_details.get("module")
             func_name = cleanup_func_details.get("name")
             base_path = cleanup_func_details.get("base_path")
@@ -3151,6 +3180,129 @@ class SamAgentComponent(SamComponentBase):
         For now, using the agent name, but could be made more robust (e.g., hostname + agent name).
         """
         return self.agent_name
+        
+    def _check_agent_health(self):
+        """
+        Checks the health of peer agents and de-registers unresponsive ones.
+        This is called periodically by the health check timer.
+        Uses TTL-based expiration to determine if an agent is unresponsive.
+        """
+            
+        log.debug("%s Performing agent health check...", self.log_identifier)
+        
+        ttl_seconds = self.agent_discovery_config.get("health_check_ttl_seconds", HEALTH_CHECK_TTL_SECONDS)
+        health_check_interval = self.agent_discovery_config.get("health_check_interval_seconds", HEALTH_CHECK_INTERVAL_SECONDS)
+        
+        log.debug(
+            "%s Health check configuration: interval=%d seconds, TTL=%d seconds",
+            self.log_identifier,
+            health_check_interval,
+            ttl_seconds
+        )
+
+        # Validate configuration values
+        if ttl_seconds <= 0 or health_check_interval <= 0 or ttl_seconds < health_check_interval:
+            log.error(
+                "%s agent_health_check_ttl_seconds (%d) and agent_health_check_interval_seconds (%d) must be positive and TTL must be greater than interval.",
+                self.log_identifier,
+                ttl_seconds,
+                health_check_interval
+            )
+            raise ValueError(f"Invalid health check configuration. agent_health_check_ttl_seconds ({ttl_seconds}) and agent_health_check_interval_seconds ({health_check_interval}) must be positive and TTL must be greater than interval.")
+        
+        # Get all agent names from the registry
+        agent_names = self.agent_registry.get_agent_names()
+        total_agents = len(agent_names)
+        agents_to_deregister = []
+        
+        log.debug("%s Checking health of %d peer agents", self.log_identifier, total_agents)
+        
+        for agent_name in agent_names:
+            # Skip our own agent
+            if agent_name == self.agent_name:
+                continue
+                
+            # Check if the agent's TTL has expired
+            is_expired, time_since_last_seen = self.agent_registry.check_ttl_expired(agent_name, ttl_seconds)
+            
+            if is_expired:
+                log.warning(
+                    "%s Agent '%s' TTL has expired. De-registering. Time since last seen: %d seconds (TTL: %d seconds)",
+                    self.log_identifier,
+                    agent_name,
+                    time_since_last_seen,
+                    ttl_seconds
+                )
+                agents_to_deregister.append(agent_name)
+            
+        # De-register unresponsive agents
+        for agent_name in agents_to_deregister:
+            self._deregister_agent(agent_name)
+            
+        log.debug(
+            "%s Agent health check completed. Total agents: %d, De-registered: %d",
+            self.log_identifier,
+            total_agents,
+            len(agents_to_deregister)
+        )
+        
+    def _deregister_agent(self, agent_name: str):
+        """
+        De-registers an agent from the registry and publishes a de-registration event.
+        """
+        # Remove from registry
+        registry_removed = self.agent_registry.remove_agent(agent_name)
+        
+        # Always remove from peer_agents regardless of registry result
+        peer_removed = False
+        if agent_name in self.peer_agents:
+            del self.peer_agents[agent_name]
+            peer_removed = True
+            log.info(
+                "%s Removed agent '%s' from peer_agents dictionary",
+                self.log_identifier,
+                agent_name
+            )
+        
+        # Publish de-registration event if agent was in either data structure
+        if registry_removed or peer_removed:
+            try:
+                # Create a de-registration event topic
+                namespace = self.get_config("namespace")
+                deregistration_topic = f"{namespace}/a2a/events/agent/deregistered"
+                
+                current_time = time.time()
+                
+                # Create the payload
+                deregistration_payload = {
+                    "event_type": "agent.deregistered",
+                    "agent_name": agent_name,
+                    "reason": "health_check_failure",
+                    "metadata": {
+                        "timestamp": current_time,
+                        "deregistered_by": self.agent_name
+                    }
+                }
+                
+                # Publish the event
+                self.publish_a2a_message(
+                    payload=deregistration_payload,
+                    topic=deregistration_topic
+                )
+                
+                log.info(
+                    "%s Published de-registration event for agent '%s' to topic '%s'",
+                    self.log_identifier,
+                    agent_name,
+                    deregistration_topic
+                )
+            except Exception as e:
+                log.error(
+                    "%s Failed to publish de-registration event for agent '%s': %s",
+                    self.log_identifier,
+                    agent_name,
+                    e
+                )
 
     async def _resolve_early_embeds_and_handle_signals(
         self, raw_text: str, a2a_context: Dict
@@ -3240,6 +3392,10 @@ class SamAgentComponent(SamComponentBase):
         Main async logic for the agent component.
         This is called by the base class's `_run_async_operations`.
         """
+        # Call base class to initialize Trust Manager
+        await super()._async_setup_and_run()
+
+        # Perform agent-specific async initialization
         await self._perform_async_init()
 
     def _pre_async_cleanup(self) -> None:
@@ -3247,4 +3403,11 @@ class SamAgentComponent(SamComponentBase):
         Pre-cleanup actions for the agent component.
         Called by the base class before stopping the async loop.
         """
-        pass
+        # Cleanup Trust Manager if present (ENTERPRISE FEATURE)
+        if self.trust_manager:
+            try:
+                self.trust_manager.cleanup(self.cancel_timer)
+            except Exception as e:
+                log.error(
+                    "%s Error during Trust Manager cleanup: %s", self.log_identifier, e
+                )