solace-agent-mesh 1.6.0__py3-none-any.whl → 1.6.2__py3-none-any.whl

solace_agent_mesh/agent/proxies/a2a/app.py

@@ -43,8 +43,9 @@ class A2AProxyApp(BaseProxyApp):
             app_info["app_config"] = app_config
             log.debug("A2A proxy configuration validated successfully.")
         except ValidationError as e:
-            log.error("A2A proxy configuration validation failed:\n%s", e)
-            raise ValueError(f"Invalid A2A proxy configuration: {e}") from e
+            message = A2AProxyAppConfig.format_validation_error_message(e, app_info['name'])
+            log.error("Invalid A2A Proxy configuration:\n%s", message)
+            raise
         
         super().__init__(app_info, **kwargs)
 

solace_agent_mesh/agent/proxies/base/app.py

@@ -43,8 +43,9 @@ class BaseProxyApp(App, ABC):
             # Overwrite the raw dict with the validated object for downstream use
             app_info["app_config"] = app_config
         except ValidationError as e:
-            log.error("Proxy configuration validation failed:\n%s", e)
-            raise ValueError(f"Invalid proxy configuration: {e}") from e
+            message = BaseProxyAppConfig.format_validation_error_message(e, app_info['name'])
+            log.error("Invalid Proxy configuration:\n%s", message)
+            raise
 
         namespace = app_config.get("namespace")
         proxied_agents = app_config.get("proxied_agents", [])

solace_agent_mesh/agent/proxies/base/component.py

@@ -140,12 +140,23 @@ class BaseProxyComponent(ComponentBase, ABC):
         future = asyncio.run_coroutine_threadsafe(
             self._process_event_async(event), self._async_loop
         )
-        future.add_done_callback(self._handle_scheduled_task_completion)
+        # Pass the event to the completion handler so it can NACK on failure
+        future.add_done_callback(
+            lambda f: self._handle_scheduled_task_completion(f, event)
+        )
 
     async def _process_event_async(self, event: Event):
         """Asynchronous event processing logic."""
         if event.event_type == EventType.MESSAGE:
-            await self._handle_a2a_request(event.data)
+            message_handled = False
+            try:
+                await self._handle_a2a_request(event.data)
+                message_handled = True
+            finally:
+                # Mark that we attempted to handle the message
+                # (success/failure ack/nack is done inside _handle_a2a_request)
+                if not hasattr(event, "_proxy_message_handled"):
+                    event._proxy_message_handled = message_handled
         elif event.event_type == EventType.TIMER:
             if event.data.get("timer_id") == self._discovery_timer_id:
                 await self._discover_and_publish_agents()
@@ -510,8 +521,10 @@ class BaseProxyComponent(ComponentBase, ABC):
                     self._async_init_future.set_exception, e
                 )
 
-    def _handle_scheduled_task_completion(self, future: concurrent.futures.Future):
-        """Callback to log exceptions from tasks scheduled on the async loop."""
+    def _handle_scheduled_task_completion(
+        self, future: concurrent.futures.Future, event: Event
+    ):
+        """Callback to log exceptions from tasks scheduled on the async loop and NACK messages on failure."""
         if future.done() and future.exception():
             log.error(
                 "%s Coroutine scheduled on async loop failed: %s",
@@ -519,6 +532,24 @@ class BaseProxyComponent(ComponentBase, ABC):
                 future.exception(),
                 exc_info=future.exception(),
             )
+            # NACK the message if this was a MESSAGE event that failed before being handled
+            # The _proxy_message_handled flag is set in _process_event_async to track
+            # whether _handle_a2a_request was entered (where ack/nack is normally done)
+            if event.event_type == EventType.MESSAGE:
+                message_handled = getattr(event, "_proxy_message_handled", False)
+                if not message_handled:
+                    try:
+                        event.data.call_negative_acknowledgements()
+                        log.warning(
+                            "%s NACKed message due to async processing failure before entering request handler.",
+                            self.log_identifier,
+                        )
+                    except Exception as nack_e:
+                        log.error(
+                            "%s Failed to NACK message after async processing failure: %s",
+                            self.log_identifier,
+                            nack_e,
+                        )
 
     def _publish_discovered_cards(self):
         """Publishes all agent cards currently in the registry."""

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, HEALTH_CHECK_TTL_SECONDS, HEALTH_CHECK_INTERVAL_SECONDS
+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.",
@@ -80,10 +94,12 @@ class AgentDiscoveryConfig(SamConfigBase):
         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."
+        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."
+        default=HEALTH_CHECK_INTERVAL_SECONDS,
+        description="Interval in seconds between health checks.",
     )
 
 
@@ -214,11 +230,39 @@ class ArtifactServiceConfig(SamConfigBase):
             )
         return self
 
+class AgentIdentityConfig(SamConfigBase):
+    """Configuration for agent identity and key management."""
+    key_mode: Literal["auto", "manual"] = Field(
+        default="auto",
+        description="Key mode for agent identity: 'auto' for automatic generation, 'manual' for user-provided."
+    )
+    key_identity: Optional[str] = Field(
+        default=None,
+        description="Actual key value when key_mode is 'manual'."
+    )
+    key_persistence: Optional[str] = Field(
+        default=None,
+        description="Path to the key file, e.g. '/path/to/keys/agent_{name}.key'."
+    )
+
+    @model_validator(mode="after")
+    def check_key_mode_and_identity(self) -> "AgentIdentityConfig":
+        if self.key_mode == "manual" and not self.key_identity:
+            raise ValueError(
+                "'key_identity' is required when 'key_mode' is 'manual'."
+            )
+        if self.key_mode == "auto" and self.key_identity:
+            log.warning(
+                "Configuration Warning: 'key_identity' is ignored when 'key_mode' is 'auto'."
+            )
+        return self
 
 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."
     )
@@ -227,6 +271,12 @@ class SessionServiceConfig(SamConfigBase):
     )
 
 
+class CredentialServiceConfig(SamConfigBase):
+    """Configuration for the ADK Credential Service."""
+
+    type: str = Field(..., description="Service type (e.g., 'memory').")
+
+
 class SamAgentAppConfig(SamConfigBase):
     """Pydantic model for the complete agent application configuration."""
 
@@ -235,10 +285,25 @@ 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."
     )
+    agent_identity: Optional[AgentIdentityConfig] = Field(
+        default_factory=lambda: AgentIdentityConfig(key_mode="auto"),
+        description="Configuration for agent identity and key management."
+    )
+    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).",
@@ -277,6 +342,10 @@ class SamAgentAppConfig(SamConfigBase):
         default={"type": "memory"},
         description="Configuration for ADK Memory Service (defaults to memory).",
     )
+    credential_service: Optional[CredentialServiceConfig] = Field(
+        default=None,
+        description="Configuration for ADK Credential Service (optional).",
+    )
     multi_session_request_response: Dict[str, Any] = Field(
         default_factory=lambda: {"enabled": True},
         description="Enables multi-session request/response capabilities for the agent, required for peer delegation.",
@@ -407,8 +476,9 @@ class SamAgentApp(App):
             # Overwrite the raw dict with the validated object for downstream use
             app_info["app_config"] = app_config
         except ValidationError as e:
-            log.error("Agent configuration validation failed:\n%s", e)
-            raise ValueError(f"Invalid agent configuration: {e}") from e
+            message = SamAgentAppConfig.format_validation_error_message(e, app_info['name'], app_config_dict.get('agent_name'))
+            log.error("Invalid Agent configuration:\n%s", message)
+            raise
 
         # The rest of the method can now safely use .get() on the app_config object,
         # ensuring full backward compatibility.
@@ -429,6 +499,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",
@@ -458,8 +542,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"] = app_info.get("broker", {}).get("temporary_queue", True)
-        log.debug("Set broker_config.temporary_queue = %s", broker_config["temporary_queue"])
+        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)