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

solace_agent_mesh/gateway/base/component.py

@@ -160,7 +160,7 @@ class BaseGatewayComponent(SamComponentBase):
         )
 
         log.info(
-            "%s Base Gateway Component initialized successfully.", self.log_identifier
+            "%s Initialized Base Gateway Component.", self.log_identifier
         )
 
     async def authenticate_and_enrich_user(
@@ -208,6 +208,8 @@ class BaseGatewayComponent(SamComponentBase):
         user_identity: Any,
         is_streaming: bool = True,
         api_version: str = "v2",
+        task_id_override: str | None = None,
+        metadata: dict[str, Any] | None = None,
     ) -> str:
         log_id_prefix = f"{self.log_identifier}[SubmitA2ATask]"
         log.info(
@@ -241,7 +243,7 @@ class BaseGatewayComponent(SamComponentBase):
             user_config = await config_resolver.resolve_user_config(
                 user_identity, gateway_context, {}
             )
-            log.info(
+            log.debug(
                 "%s Resolved user configuration for user_identity '%s': %s",
                 log_id_prefix,
                 user_identity.get("id"),
@@ -307,9 +309,15 @@ class BaseGatewayComponent(SamComponentBase):
                 log_id_prefix,
                 len(invoked_artifacts),
             )
+        
+        if metadata:
+            a2a_metadata.update(metadata)
 
         # This correlation ID is used by the gateway to track the task
-        task_id = f"gdk-task-{uuid.uuid4().hex}"
+        if task_id_override:
+            task_id = task_id_override
+        else:
+            task_id = f"gdk-task-{uuid.uuid4().hex}"
 
         prepared_a2a_parts = await self._prepare_parts_for_publishing(
             parts=a2a_parts,
@@ -343,6 +351,37 @@ class BaseGatewayComponent(SamComponentBase):
         if user_config:
             user_properties["a2aUserConfig"] = user_config
 
+        # Enterprise feature: Add signed user claims if trust manager available
+        if hasattr(self, "trust_manager") and self.trust_manager:
+            log.debug(
+                "%s Attempting to sign user claims for task %s",
+                log_id_prefix,
+                task_id,
+            )
+            try:
+                auth_token = self.trust_manager.sign_user_claims(
+                    user_info=user_identity, task_id=task_id
+                )
+                user_properties["authToken"] = auth_token
+                log.debug(
+                    "%s Successfully signed user claims for task %s",
+                    log_id_prefix,
+                    task_id,
+                )
+            except Exception as e:
+                log.error(
+                    "%s Failed to sign user claims for task %s: %s",
+                    log_id_prefix,
+                    task_id,
+                    e,
+                )
+                # Continue without token - enterprise feature is optional
+        else:
+            log.debug(
+                "%s Trust Manager not available, proceeding without authentication token",
+                log_id_prefix,
+            )
+
         user_properties["replyTo"] = a2a.get_gateway_response_topic(
             self.namespace, self.gateway_id, task_id
         )
@@ -366,49 +405,55 @@ class BaseGatewayComponent(SamComponentBase):
         )
         return task_id
 
-    def process_event(self, event: Event):
-        if event.event_type == EventType.MESSAGE:
-            original_broker_message: Optional[SolaceMessage] = event.data
-            if not original_broker_message:
-                log.warning(
-                    "%s Received MESSAGE event with no data. Ignoring.",
-                    self.log_identifier,
-                )
-                return
+    def _handle_message(self, message: SolaceMessage, topic: str) -> None:
+        """
+        Override to use queue-based pattern instead of direct async.
 
-            log.debug(
-                "%s Received SolaceMessage on topic: %s. Bridging to internal queue.",
+        Gateway uses an internal queue for message processing to ensure
+        strict ordering and backpressure handling.
+
+        Args:
+            message: The Solace message
+            topic: The topic the message was received on
+        """
+        log.debug(
+            "%s Received SolaceMessage on topic: %s. Bridging to internal queue.",
+            self.log_identifier,
+            topic,
+        )
+
+        try:
+            msg_data_for_processor = {
+                "topic": topic,
+                "payload": message.get_payload(),
+                "user_properties": message.get_user_properties(),
+                "_original_broker_message": message,
+            }
+            self.internal_event_queue.put_nowait(msg_data_for_processor)
+        except queue.Full:
+            log.error(
+                "%s Internal event queue full. Cannot bridge message.",
                 self.log_identifier,
-                original_broker_message.get_topic(),
             )
-            try:
-                msg_data_for_processor = {
-                    "topic": original_broker_message.get_topic(),
-                    "payload": original_broker_message.get_payload(),
-                    "user_properties": original_broker_message.get_user_properties(),
-                    "_original_broker_message": original_broker_message,
-                }
-                self.internal_event_queue.put_nowait(msg_data_for_processor)
-            except queue.Full:
-                log.error(
-                    "%s Internal event queue full. Cannot bridge message. NACKing.",
-                    self.log_identifier,
-                )
-                original_broker_message.call_negative_acknowledgements()
-            except Exception as e:
-                log.exception(
-                    "%s Error bridging message to internal queue: %s. NACKing.",
-                    self.log_identifier,
-                    e,
-                )
-                original_broker_message.call_negative_acknowledgements()
-        else:
-            log.debug(
-                "%s Received non-MESSAGE event type: %s. Passing to super.",
+            raise
+        except Exception as e:
+            log.exception(
+                "%s Error bridging message to internal queue: %s",
                 self.log_identifier,
-                event.event_type,
+                e,
             )
-            super().process_event(event)
+            raise
+
+    async def _handle_message_async(self, message, topic: str) -> None:
+        """
+        Not used by gateway - we override _handle_message() instead.
+
+        This is here to satisfy the abstract method requirement, but the
+        gateway uses the queue-based pattern via _handle_message() override.
+        """
+        raise NotImplementedError(
+            "Gateway uses queue-based message handling via _handle_message() override"
+        )
 
     async def _handle_resolved_signals(
         self,
@@ -1120,20 +1165,30 @@ class BaseGatewayComponent(SamComponentBase):
 
     async def _async_setup_and_run(self) -> None:
         """Main async logic for the gateway component."""
+        # Call base class to initialize Trust Manager
+        await super()._async_setup_and_run()
+
         log.info(
             "%s Starting _start_listener() to initiate external platform connection.",
             self.log_identifier,
         )
         self._start_listener()
 
-        log.info(
-            "%s Starting _message_processor_loop as an asyncio task.",
-            self.log_identifier,
-        )
         await self._message_processor_loop()
 
     def _pre_async_cleanup(self) -> None:
         """Pre-cleanup actions for the gateway component."""
+        # Cleanup Trust Manager if present (ENTERPRISE FEATURE)
+        if self.trust_manager:
+            try:
+                log.info("%s Cleaning up Trust Manager...", self.log_identifier)
+                self.trust_manager.cleanup(self.cancel_timer)
+                log.info("%s Trust Manager cleanup complete", self.log_identifier)
+            except Exception as e:
+                log.error(
+                    "%s Error during Trust Manager cleanup: %s", self.log_identifier, e
+                )
+
         log.info("%s Calling _stop_listener()...", self.log_identifier)
         self._stop_listener()
 
@@ -1146,7 +1201,7 @@ class BaseGatewayComponent(SamComponentBase):
             self.internal_event_queue.put(None)
 
     async def _message_processor_loop(self):
-        log.info("%s Starting message processor loop...", self.log_identifier)
+        log.debug("%s Starting message processor loop as an asyncio task...", self.log_identifier)
         loop = self.get_async_loop()
 
         while not self.stop_signal.is_set():
@@ -1184,6 +1239,13 @@ class BaseGatewayComponent(SamComponentBase):
                     processed_successfully = await self._handle_discovery_message(
                         payload
                     )
+                elif (
+                    hasattr(self, "trust_manager")
+                    and self.trust_manager
+                    and self.trust_manager.is_trust_card_topic(topic)
+                ):
+                    await self.trust_manager.handle_trust_card_message(payload, topic)
+                    processed_successfully = True
                 elif a2a.topic_matches_subscription(
                     topic,
                     a2a.get_gateway_response_subscription_topic(
@@ -1328,6 +1390,14 @@ class BaseGatewayComponent(SamComponentBase):
     ) -> None:
         pass
 
+    def _get_component_id(self) -> str:
+        """Returns the gateway ID as the component identifier."""
+        return self.gateway_id
+
+    def _get_component_type(self) -> str:
+        """Returns 'gateway' as the component type."""
+        return "gateway"
+
     def invoke(self, message, data):
         if isinstance(message, SolaceMessage):
             message.call_acknowledgements()

solace_agent_mesh/gateway/http_sse/app.py

@@ -89,6 +89,13 @@ class WebUIBackendApp(BaseGatewayApp):
             "default": "",
             "description": "General guidelines on how agent responses should be structured, to be optionally used by agents.",
         },
+        {
+            "name": "model",
+            "required": False,
+            "type": "dict",
+            "default": None,
+            "description": "The model to use for the WebUI gateway.",
+        },
         {
             "name": "frontend_welcome_message",
             "required": False,

solace_agent_mesh/gateway/http_sse/component.py

@@ -115,6 +115,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
             self.ssl_keyfile = self.get_config("ssl_keyfile", "")
             self.ssl_certfile = self.get_config("ssl_certfile", "")
             self.ssl_keyfile_password = self.get_config("ssl_keyfile_password", "")
+            self.model_config = self.get_config("model", None)
 
             log.info(
                 "%s WebUI-specific configuration retrieved (Host: %s, Port: %d).",
@@ -437,7 +438,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
                     raise RuntimeError(
                         "Visualization flow setup error: BrokerInput not found."
                     )
-                log.info(
+                log.debug(
                     "%s Obtained reference to internal BrokerInput component.",
                     log_id_prefix,
                 )
@@ -883,7 +884,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
         Manages global subscription reference counts.
         """
         log_id_prefix = f"{self.log_identifier}[AddVizSub:{stream_id}]"
-        log.info(
+        log.debug(
             "%s Attempting to add subscription to topic: %s", log_id_prefix, topic_str
         )
 
@@ -1207,7 +1208,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
             self.task_logger_service = TaskLoggerService(
                 session_factory=session_factory, config=task_logging_config
             )
-            log.info(
+            log.debug(
                 "%s Services dependent on database session factory have been initialized.",
                 self.log_identifier,
             )
@@ -1222,7 +1223,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
                 app=self.fastapi_app,
                 host=self.fastapi_host,
                 port=port,
-                log_level="info",
+                log_level="warning",
                 lifespan="on",
                 ssl_keyfile=self.ssl_keyfile,
                 ssl_certfile=self.ssl_certfile,
@@ -1238,14 +1239,14 @@ class WebUIBackendComponent(BaseGatewayComponent):
                 )
                 try:
                     self.fastapi_event_loop = asyncio.get_running_loop()
-                    log.info(
+                    log.debug(
                         "%s [_start_listener] Captured FastAPI event loop via startup event: %s",
                         self.log_identifier,
                         self.fastapi_event_loop,
                     )
 
                     if self.fastapi_event_loop:
-                        log.info(
+                        log.debug(
                             "%s Ensuring visualization flow is running...",
                             self.log_identifier,
                         )
@@ -1255,7 +1256,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
                             self._visualization_processor_task is None
                             or self._visualization_processor_task.done()
                         ):
-                            log.info(
+                            log.debug(
                                 "%s Starting visualization message processor task.",
                                 self.log_identifier,
                             )
@@ -1265,7 +1266,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
                                 )
                             )
                         else:
-                            log.info(
+                            log.debug(
                                 "%s Visualization message processor task already running.",
                                 self.log_identifier,
                             )
@@ -1812,7 +1813,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
         for agent_name in agents_to_deregister:
             self._deregister_agent(agent_name)
             
-        log.info(
+        log.debug(
             "%s Agent health check completed. Total agents: %d, De-registered: %d",
             self.log_identifier,
             total_agents,
@@ -2052,6 +2053,13 @@ class WebUIBackendComponent(BaseGatewayComponent):
             )
             return
 
+        try:
+            from solace_agent_mesh_enterprise.auth.input_required import handle_input_required_request
+            event_data = handle_input_required_request(event_data, sse_task_id, self)
+        except ImportError:
+            pass
+
+
         log.debug(
             "%s Sending update for A2A Task ID %s to SSE Task ID %s. Final chunk: %s",
             log_id_prefix,
@@ -2073,7 +2081,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
             await self.sse_manager.send_event(
                 task_id=sse_task_id, event_data=sse_payload, event_type=sse_event_type
             )
-            log.info(
+            log.debug(
                 "%s Successfully sent %s via SSE for A2A Task ID %s.",
                 log_id_prefix,
                 sse_event_type,