solace-agent-mesh 1.0.8__py3-none-any.whl → 1.1.0__py3-none-any.whl

solace_agent_mesh/gateway/http_sse/component.py

@@ -30,22 +30,17 @@ from ...common.agent_registry import AgentRegistry
 from ...core_a2a.service import CoreA2AService
 from google.adk.artifacts import BaseArtifactService
 
-from ...common.types import (
+from ...common.a2a.types import ContentPart
+from a2a.types import (
+    A2ARequest,
     AgentCard,
-    Part as A2APart,
-    Task,
-    TaskStatusUpdateEvent,
-    TaskArtifactUpdateEvent,
     JSONRPCError,
     JSONRPCResponse,
-    TextPart,
-    FilePart,
-    FileContent,
-)
-from ...common.a2a_protocol import (
-    _topic_matches_subscription,
+    Task,
+    TaskArtifactUpdateEvent,
+    TaskStatusUpdateEvent,
 )
-
+from ...common import a2a
 from ...agent.utils.artifact_helpers import save_artifact_with_metadata
 from ...common.middleware.config_resolver import ConfigResolver
 
@@ -82,7 +77,11 @@ class WebUIBackendComponent(BaseGatewayComponent):
         """
         Initializes the WebUIBackendComponent, inheriting from BaseGatewayComponent.
         """
-        super().__init__(**kwargs)
+        component_config = kwargs.get("component_config", {})
+        app_config = component_config.get("app_config", {})
+        resolve_uris = app_config.get("resolve_artifact_uris_in_gateway", True)
+
+        super().__init__(resolve_artifact_uris_in_gateway=resolve_uris, **kwargs)
         log.info("%s Initializing Web UI Backend Component...", self.log_identifier)
 
         try:
@@ -97,9 +96,6 @@ class WebUIBackendComponent(BaseGatewayComponent):
             self.fastapi_https_port = self.get_config("fastapi_https_port", 8443)
             self.session_secret_key = self.get_config("session_secret_key")
             self.cors_allowed_origins = self.get_config("cors_allowed_origins", ["*"])
-            self.resolve_artifact_uris_in_gateway = self.get_config(
-                "resolve_artifact_uris_in_gateway", True
-            )
             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", "")
@@ -427,7 +423,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
                                     "solace_topics", set()
                                 )
                                 if any(
-                                    _topic_matches_subscription(topic, pattern)
+                                    a2a.topic_matches_subscription(topic, pattern)
                                     for pattern in subscribed_topics_for_stream
                                 ):
                                     is_permitted = True
@@ -449,6 +445,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
                                 "task_id": event_details["task_id"],
                                 "payload_summary": event_details["payload_summary"],
                                 "full_payload": payload_dict,
+                                "debug_type": event_details["debug_type"],
                             }
 
                             try:
@@ -838,7 +835,11 @@ class WebUIBackendComponent(BaseGatewayComponent):
 
             setup_dependencies(self)
 
-            port = self.fastapi_https_port if self.ssl_keyfile and self.ssl_certfile else self.fastapi_port
+            port = (
+                self.fastapi_https_port
+                if self.ssl_keyfile and self.ssl_certfile
+                else self.fastapi_port
+            )
 
             config = uvicorn.Config(
                 app=self.fastapi_app,
@@ -997,11 +998,13 @@ class WebUIBackendComponent(BaseGatewayComponent):
     ) -> Dict[str, Any]:
         """
         Infers details for the visualization SSE payload from the Solace topic and A2A message.
+        This version is updated to parse the official A2A SDK message formats.
         """
         details = {
             "direction": "unknown",
             "source_entity": "unknown",
             "target_entity": "unknown",
+            "debug_type": "unknown",
             "message_id": payload.get("id"),
             "task_id": None,
             "payload_summary": {
@@ -1010,125 +1013,131 @@ class WebUIBackendComponent(BaseGatewayComponent):
             },
         }
 
-        topic_parts = topic.split("/")
-
+        # --- Phase 1: Parse the payload to extract core info ---
         try:
-            a2a_base_index = topic_parts.index("a2a")
-            domain_index = a2a_base_index + 2
-            action_type_index = a2a_base_index + 3
-            entity_name_index = a2a_base_index + 4
-            task_id_from_topic_index = a2a_base_index + 5
-
-            domain = (
-                topic_parts[domain_index] if len(topic_parts) > domain_index else None
-            )
-            action_type = (
-                topic_parts[action_type_index]
-                if len(topic_parts) > action_type_index
-                else None
-            )
-            entity_name = (
-                topic_parts[entity_name_index]
-                if len(topic_parts) > entity_name_index
-                else None
-            )
-
-            if domain == "agent":
-                if action_type == "request":
-                    details["direction"] = "request"
-                    details["target_entity"] = entity_name
-                    user_props = (
-                        payload.get("params", {})
-                        .get("metadata", {})
-                        .get("solaceUserProperties", {})
-                    )
-                    details["source_entity"] = (
-                        user_props.get("clientId")
-                        or user_props.get("delegating_agent_name")
-                        or self.gateway_id
-                    )
-                elif action_type == "response":
-                    details["direction"] = "response"
-                    details["source_entity"] = entity_name
-                    details["target_entity"] = (
-                        payload.get("result", {}).get("metadata", {}).get("clientId")
-                    )
-                elif action_type == "status":
-                    details["direction"] = "status_update"
-                    details["source_entity"] = entity_name
-                    details["target_entity"] = (
-                        payload.get("result", {}).get("metadata", {}).get("clientId")
+            # Try to parse as a JSON-RPC response first
+            if "result" in payload or "error" in payload:
+                rpc_response = JSONRPCResponse.model_validate(payload)
+                result = a2a.get_response_result(rpc_response)
+                error = a2a.get_response_error(rpc_response)
+                details["message_id"] = a2a.get_response_id(rpc_response)
+
+                if result:
+                    kind = getattr(result, "kind", None)
+                    details["direction"] = kind or "response"
+                    details["task_id"] = getattr(result, "task_id", None) or getattr(
+                        result, "id", None
                     )
-            elif domain == "gateway":
-                if action_type == "response":
-                    details["direction"] = "response"
-                    details["source_entity"] = (
-                        payload.get("result", {})
-                        .get("status", {})
-                        .get("message", {})
-                        .get("metadata", {})
-                        .get("agent_name", "unknown_agent")
+
+                    if isinstance(result, TaskStatusUpdateEvent):
+                        details["source_entity"] = (
+                            result.metadata.get("agent_name")
+                            if result.metadata
+                            else None
+                        )
+                        message = a2a.get_message_from_status_update(result)
+                        if message:
+                            if not details["source_entity"]:
+                                details["source_entity"] = (
+                                    message.metadata.get("agent_name")
+                                    if message.metadata
+                                    else None
+                                )
+                            data_parts = a2a.get_data_parts_from_message(message)
+                            if data_parts:
+                                details["debug_type"] = data_parts[0].data.get(
+                                    "type", "unknown"
+                                )
+                            elif a2a.get_text_from_message(message):
+                                details["debug_type"] = "streaming_text"
+                    elif isinstance(result, Task):
+                        details["source_entity"] = (
+                            result.metadata.get("agent_name")
+                            if result.metadata
+                            else None
+                        )
+                    elif isinstance(result, TaskArtifactUpdateEvent):
+                        artifact = a2a.get_artifact_from_artifact_update(result)
+                        if artifact:
+                            details["source_entity"] = (
+                                artifact.metadata.get("agent_name")
+                                if artifact.metadata
+                                else None
+                            )
+                elif error:
+                    details["direction"] = "error_response"
+                    details["task_id"] = (
+                        error.data.get("taskId")
+                        if isinstance(error.data, dict)
+                        else None
                     )
-                    details["target_entity"] = entity_name
-                elif action_type == "status":
-                    details["direction"] = "status_update"
-                    details["source_entity"] = (
-                        payload.get("result", {})
-                        .get("status", {})
-                        .get("message", {})
-                        .get("metadata", {})
-                        .get("agent_name", "unknown_agent")
+                    details["debug_type"] = "error"
+
+            # Try to parse as a JSON-RPC request
+            elif "method" in payload:
+                rpc_request = A2ARequest.model_validate(payload)
+                method = a2a.get_request_method(rpc_request)
+                details["direction"] = "request"
+                details["payload_summary"]["method"] = method
+                details["message_id"] = a2a.get_request_id(rpc_request)
+
+                if method in ["message/send", "message/stream"]:
+                    details["debug_type"] = method
+                    message = a2a.get_message_from_send_request(rpc_request)
+                    details["task_id"] = a2a.get_request_id(rpc_request)
+                    if message:
+                        details["target_entity"] = (
+                            message.metadata.get("agent_name")
+                            if message.metadata
+                            else None
+                        )
+                elif method == "tasks/cancel":
+                    details["task_id"] = a2a.get_task_id_from_cancel_request(
+                        rpc_request
                     )
-                    details["target_entity"] = entity_name
-            elif domain == "discovery" and action_type == "agentcards":
+
+            # Handle Discovery messages (which are not JSON-RPC)
+            elif "/a2a/v1/discovery/" in topic:
+                agent_card = AgentCard.model_validate(payload)
                 details["direction"] = "discovery"
-                details["source_entity"] = payload.get("name", "unknown_agent")
+                details["source_entity"] = agent_card.name
                 details["target_entity"] = "broadcast"
+                details["message_id"] = None  # Discovery has no ID
 
-            if payload.get("method") in [
-                "tasks/send",
-                "tasks/sendSubscribe",
-                "tasks/cancel",
-            ]:
-                details["task_id"] = payload.get("params", {}).get("id")
-            elif "result" in payload and isinstance(payload["result"], dict):
-                details["task_id"] = payload["result"].get("id")
-            elif len(topic_parts) > task_id_from_topic_index and (
-                action_type == "status" or action_type == "response"
-            ):
-                details["task_id"] = topic_parts[task_id_from_topic_index]
-
-        except (ValueError, IndexError):
-            log.debug(
-                "%s Could not parse A2A structure from topic: %s",
+        except Exception as e:
+            log.warning(
+                "[%s] Failed to parse A2A payload for visualization details: %s",
                 self.log_identifier,
-                topic,
+                e,
             )
+
+        # --- Phase 2: Refine details using topic information as a fallback ---
+        if details["direction"] == "unknown":
             if "request" in topic:
                 details["direction"] = "request"
             elif "response" in topic:
                 details["direction"] = "response"
             elif "status" in topic:
                 details["direction"] = "status_update"
-            elif "discovery" in topic:
-                details["direction"] = "discovery"
+                # TEMP - add debug_type based on the type in the data
+                details["debug_type"] = "unknown"
 
-        if "params" in payload:
-            params_str = json.dumps(payload["params"])
-            details["payload_summary"]["params_preview"] = (
-                (params_str[:100] + "...") if len(params_str) > 100 else params_str
-            )
-        elif "result" in payload:
-            result_str = json.dumps(payload["result"])
-            details["payload_summary"]["params_preview"] = (
-                (result_str[:100] + "...") if len(result_str) > 100 else result_str
+        # --- Phase 3: Create a payload summary ---
+        try:
+            summary_source = (
+                payload.get("result")
+                or payload.get("params")
+                or payload.get("error")
+                or payload
             )
-        elif "error" in payload:
-            details["payload_summary"]["method"] = "JSONRPCError"
-            error_str = json.dumps(payload["error"])
+            summary_str = json.dumps(summary_source)
             details["payload_summary"]["params_preview"] = (
-                (error_str[:100] + "...") if len(error_str) > 100 else error_str
+                (summary_str[:100] + "...") if len(summary_str) > 100 else summary_str
             )
+        except Exception:
+            details["payload_summary"][
+                "params_preview"
+            ] = "[Could not serialize payload]"
 
         return details
 
@@ -1309,7 +1318,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
 
     async def _translate_external_input(
         self, external_event_data: Dict[str, Any]
-    ) -> Tuple[str, List[A2APart], Dict[str, Any]]:
+    ) -> Tuple[str, List[ContentPart], Dict[str, Any]]:
         """
         Translates raw HTTP request data (from FastAPI form) into A2A task parameters.
 
@@ -1321,7 +1330,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
         Returns:
             A tuple containing:
             - target_agent_name (str): The name of the A2A agent to target.
-            - a2a_parts (List[A2APart]): A list of A2A Part objects for the message.
+            - a2a_parts (List[ContentPart]): A list of unwrapped A2A Part objects.
             - external_request_context (Dict[str, Any]): Context for TaskContextManager.
         """
         log_id_prefix = f"{self.log_identifier}[TranslateInput]"
@@ -1344,10 +1353,9 @@ class WebUIBackendComponent(BaseGatewayComponent):
                 "Client ID or A2A Session ID is missing in external_event_data."
             )
 
-        a2a_parts: List[A2APart] = []
+        a2a_parts: List[ContentPart] = []
 
-        if files and self.shared_artifact_service:
-            file_metadata_summary_parts = []
+        if files:
             for upload_file in files:
                 try:
                     content_bytes = await upload_file.read()
@@ -1358,52 +1366,21 @@ class WebUIBackendComponent(BaseGatewayComponent):
                             upload_file.filename,
                         )
                         continue
-                    save_result = await save_artifact_with_metadata(
-                        artifact_service=self.shared_artifact_service,
-                        app_name=self.gateway_id,
-                        user_id=client_id,
-                        session_id=a2a_session_id,
-                        filename=upload_file.filename,
+
+                    # The BaseGatewayComponent will handle normalization based on policy.
+                    # Here, we just create the FilePart with inline bytes.
+                    file_part = a2a.create_file_part_from_bytes(
                         content_bytes=content_bytes,
-                        mime_type=upload_file.content_type
-                        or "application/octet-stream",
-                        metadata_dict={
-                            "source": "webui_gateway_upload",
-                            "original_filename": upload_file.filename,
-                            "upload_timestamp_utc": datetime.now(
-                                timezone.utc
-                            ).isoformat(),
-                            "gateway_id": self.gateway_id,
-                            "web_client_id": client_id,
-                            "a2a_session_id": a2a_session_id,
-                        },
-                        timestamp=datetime.now(timezone.utc),
+                        name=upload_file.filename,
+                        mime_type=upload_file.content_type,
+                    )
+                    a2a_parts.append(file_part)
+                    log.info(
+                        "%s Created inline FilePart for uploaded file: %s (%d bytes)",
+                        log_id_prefix,
+                        upload_file.filename,
+                        len(content_bytes),
                     )
-
-                    if save_result["status"] in ["success", "partial_success"]:
-                        data_version = save_result.get("data_version", 0)
-                        artifact_uri = f"artifact://{self.gateway_id}/{client_id}/{a2a_session_id}/{upload_file.filename}?version={data_version}"
-                        file_content = FileContent(
-                            name=upload_file.filename,
-                            mimeType=upload_file.content_type,
-                            uri=artifact_uri,
-                        )
-                        a2a_parts.append(FilePart(file=file_content))
-                        file_metadata_summary_parts.append(
-                            f"- {upload_file.filename} ({upload_file.content_type}, {len(content_bytes)} bytes, URI: {artifact_uri})"
-                        )
-                        log.info(
-                            "%s Processed and created URI for uploaded file: %s",
-                            log_id_prefix,
-                            artifact_uri,
-                        )
-                    else:
-                        log.error(
-                            "%s Failed to save artifact %s: %s",
-                            log_id_prefix,
-                            upload_file.filename,
-                            save_result.get("message"),
-                        )
 
                 except Exception as e:
                     log.exception(
@@ -1415,15 +1392,8 @@ class WebUIBackendComponent(BaseGatewayComponent):
                 finally:
                     await upload_file.close()
 
-            if file_metadata_summary_parts:
-                user_message = (
-                    "The user uploaded the following file(s):\n"
-                    + "\n".join(file_metadata_summary_parts)
-                    + f"\n\nUser message: {user_message}"
-                )
-
         if user_message:
-            a2a_parts.append(TextPart(text=user_message))
+            a2a_parts.append(a2a.create_text_part(text=user_message))
 
         external_request_context = {
             "app_name_for_artifacts": self.gateway_id,
@@ -1453,7 +1423,7 @@ class WebUIBackendComponent(BaseGatewayComponent):
         """
         log_id_prefix = f"{self.log_identifier}[SendUpdate]"
         sse_task_id = external_request_context.get("a2a_task_id_for_event")
-        a2a_task_id = event_data.id
+        a2a_task_id = event_data.task_id
 
         if not sse_task_id:
             log.error(
@@ -1474,9 +1444,10 @@ class WebUIBackendComponent(BaseGatewayComponent):
         if isinstance(event_data, TaskArtifactUpdateEvent):
             sse_event_type = "artifact_update"
 
-        sse_payload = JSONRPCResponse(id=a2a_task_id, result=event_data).model_dump(
-            exclude_none=True
+        sse_payload_model = a2a.create_success_response(
+            result=event_data, request_id=a2a_task_id
         )
+        sse_payload = sse_payload_model.model_dump(by_alias=True, exclude_none=True)
 
         try:
             await self.sse_manager.send_event(
@@ -1521,9 +1492,10 @@ class WebUIBackendComponent(BaseGatewayComponent):
             sse_task_id,
         )
 
-        sse_payload = JSONRPCResponse(id=a2a_task_id, result=task_data).model_dump(
-            exclude_none=True
+        sse_payload_model = a2a.create_success_response(
+            result=task_data, request_id=a2a_task_id
         )
+        sse_payload = sse_payload_model.model_dump(by_alias=True, exclude_none=True)
 
         try:
             await self.sse_manager.send_event(
@@ -1572,10 +1544,11 @@ class WebUIBackendComponent(BaseGatewayComponent):
             error_data,
         )
 
-        sse_payload = JSONRPCResponse(
-            id=external_request_context.get("original_rpc_id", sse_task_id),
+        sse_payload_model = a2a.create_error_response(
             error=error_data,
-        ).model_dump(exclude_none=True)
+            request_id=external_request_context.get("original_rpc_id", sse_task_id),
+        )
+        sse_payload = sse_payload_model.model_dump(by_alias=True, exclude_none=True)
 
         try:
             await self.sse_manager.send_event(

solace_agent_mesh/gateway/http_sse/components/components_llm.txt

@@ -1,65 +1,65 @@
+# DEVELOPER GUIDE: components
+
 ## Quick Summary
 This directory contains components for the HTTP SSE (Server-Sent Events) gateway, designed to work within the Solace AI Connector (SAC) framework. The primary component forwards messages received from the Solace broker to an internal queue, enabling real-time visualization in a web-based user interface.
 
 ## Files Overview
-- `__init__.py`: Makes the `VisualizationForwarderComponent` class directly importable from the `components` package.
-- `visualization_forwarder_component.py`: Defines a component that forwards messages from a broker input to a Python `queue.Queue` for visualization.
+- `__init__.py` - Makes the `VisualizationForwarderComponent` class directly importable from the `components` package
+- `visualization_forwarder_component.py` - Defines a SAC component that forwards messages from a broker input to a Python `queue.Queue` for visualization
 
 ## Developer API Reference
 
 ### __init__.py
-**Purpose:** Exposes the public components of this directory for easy importing.
-**Import:** `from gateway.http_sse.components import VisualizationForwarderComponent`
+**Purpose:** Exposes the public components of this directory for easy importing
+**Import:** `from solace_agent_mesh.gateway.http_sse.components import VisualizationForwarderComponent`
 
 **Exports:**
-- `VisualizationForwarderComponent`: The main component class for forwarding messages to a visualization queue.
-
----
+- `VisualizationForwarderComponent` - The main component class for forwarding messages to a visualization queue
 
 ### visualization_forwarder_component.py
-**Purpose:** A Solace AI Connector (SAC) component that listens for messages from a `BrokerInput` and forwards them to a specified Python `queue.Queue`. This is primarily used to send data to the Web UI for real-time display.
-**Import:** `from gateway.http_sse.components.visualization_forwarder_component import VisualizationForwarderComponent`
+**Purpose:** A Solace AI Connector (SAC) component that listens for messages from a `BrokerInput` and forwards them to a specified Python `queue.Queue` for real-time visualization
+**Import:** `from solace_agent_mesh.gateway.http_sse.components.visualization_forwarder_component import VisualizationForwarderComponent`
 
 **Classes:**
-- `VisualizationForwarderComponent(**kwargs: Any)` - A component that forwards messages to a target queue. It is initialized with configuration parameters, most importantly `target_queue_ref`.
-  - `invoke(self, message: SolaceMessage, data: Dict[str, Any]) -> None` - The core method called by the SAC framework for each incoming message. It formats the data and places it onto the target queue. This method should not be called directly by developers; the framework handles its execution.
+- `VisualizationForwarderComponent(**kwargs: Any)` - A component that forwards messages to a target queue, initialized with configuration parameters including `target_queue_ref`
+  - `invoke(message: SolaceMessage, data: Dict[str, Any]) -> None` - Core method called by SAC framework for each incoming message; formats data and places it onto the target queue
+  - `target_queue: queue.Queue` - The queue instance where messages are forwarded
 
 **Constants/Variables:**
-- `info: Dict` - A metadata dictionary required by the SAC framework. It describes the component's configuration parameters, input schema, and purpose. This is for framework use and not for direct interaction.
+- `info: Dict` - Metadata dictionary required by SAC framework describing component configuration, input schema, and purpose
 
 **Usage Examples:**
 ```python
 import queue
-from gateway.http_sse.components import VisualizationForwarderComponent
+from solace_agent_mesh.gateway.http_sse.components import VisualizationForwarderComponent
 from solace_ai_connector.common.message import Message as SolaceMessage
 
-# 1. Create a target queue that will receive the forwarded messages.
-#    This queue is typically managed by another component, like a Web UI backend.
+# 1. Create a target queue that will receive the forwarded messages
 visualization_queue = queue.Queue()
 
-# 2. Instantiate the component, providing a reference to the target queue.
-#    This is usually done within a SAC flow configuration file.
+# 2. Instantiate the component with target queue reference
 forwarder = VisualizationForwarderComponent(
     name="my_forwarder",
     target_queue_ref=visualization_queue
 )
 
-# 3. The `invoke` method is called automatically by the SAC framework when a message
-#    arrives from a connected BrokerInput component.
+# 3. The invoke method is called automatically by SAC framework
+# when messages arrive from connected BrokerInput component
 
-# Example of what the consuming component would get from the queue:
-# A dictionary containing the message topic, payload, and other details.
-#
-# if not visualization_queue.empty():
-#     forwarded_data = visualization_queue.get()
-#     print(f"Received topic: {forwarded_data['topic']}")
-#     print(f"Received payload: {forwarded_data['payload']}")
-#
-# Expected structure of `forwarded_data`:
+# 4. Consume forwarded messages from the queue
+if not visualization_queue.empty():
+    forwarded_data = visualization_queue.get()
+    print(f"Topic: {forwarded_data['topic']}")
+    print(f"Payload: {forwarded_data['payload']}")
+    print(f"User Properties: {forwarded_data['user_properties']}")
+    
+# Expected structure of forwarded_data:
 # {
 #     "topic": "some/broker/topic",
 #     "payload": {"key": "value"},
 #     "user_properties": {"prop1": "value1"},
 #     "_original_broker_message": <SolaceMessage object>
 # }
-```
+```
+
+# content_hash: cee7f7b4ea7e87ab3f94f7e24d463f22fa045e50d54991c61b84fe95e8a7f77d