solace-agent-mesh 1.0.9__py3-none-any.whl → 1.3.0__py3-none-any.whl

solace_agent_mesh/templates/gateway_component_template.py

@@ -2,13 +2,11 @@
 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,
+from a2a.types import (
     TextPart,
     FilePart,  # If handling files
     DataPart,  # If handling structured data
@@ -16,10 +14,9 @@ from solace_agent_mesh.common.types import (
     TaskStatusUpdateEvent,
     TaskArtifactUpdateEvent,
     JSONRPCError,
-    FileContent,  # Added for FilePart example
 )
-
-# from solace_agent_mesh.core_a2a.service import CoreA2AService # If direct interaction needed
+from ...common import a2a
+from ...common.a2a import ContentPart
 
 info = {
     "class_name": "__GATEWAY_NAME_PASCAL_CASE__GatewayComponent",
@@ -28,14 +25,9 @@ info = {
         "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.",
-    },
+    # Not needed for gateway components
+    "input_schema": {},
+    "output_schema": {},
 }
 
 
@@ -101,13 +93,30 @@ class __GATEWAY_NAME_PASCAL_CASE__GatewayComponent(BaseGatewayComponent):
     #         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)
+    #             #     # 1. Authenticate the user and enrich their profile.
+    #             #     user_identity = await self.authenticate_and_enrich_user(event_data)
+    #             #     if not user_identity:
+    #             #         log.warning("%s Authentication failed for event, skipping.", log_id_prefix)
+    #             #         continue
+    #             #
+    #             #     # 2. Translate the external event into an A2A task.
+    #             #     try:
+    #             #         target_agent, parts, context = await self._translate_external_input(event_data)
+    #             #     except ValueError as e:
+    #             #         log.error("%s Translation failed for event: %s", log_id_prefix, e)
+    #             #         # Optionally, send an error back to the user in the external system here.
+    #             #         continue
+    #             #
+    #             #     # 3. Submit the A2A task.
+    #             #     if target_agent and parts:
+    #             #         await self.submit_a2a_task(
+    #             #             target_agent_name=target_agent,
+    #             #             a2a_parts=parts,
+    #             #             external_request_context=context,
+    #             #             user_identity=user_identity,
+    #             #             is_streaming=True # Or False, depending on gateway needs
+    #             #         )
+    #             #
     #             # await asyncio.sleep(self.get_config("polling_interval_seconds", 60))
     #             pass # Placeholder
     #         except asyncio.CancelledError:
@@ -150,65 +159,85 @@ class __GATEWAY_NAME_PASCAL_CASE__GatewayComponent(BaseGatewayComponent):
             "%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]:
+    async def _extract_initial_claims(
+        self, external_event_data: Any
+    ) -> Optional[Dict[str, Any]]:
         """
-        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).
+        GDK Hook: Extracts the primary identity claims from a platform-specific event.
+        This method MUST be implemented by derived gateway components.
+
+        The base class's `authenticate_and_enrich_user` method will call this,
+        and then (if configured) pass the result to an Identity Service for enrichment.
+
+        Args:
+            external_event_data: Raw event data from the external platform
+                                 (e.g., FastAPIRequest, Slack event dictionary).
+
+        Returns:
+            A dictionary of initial claims, which MUST include an 'id' key.
+            Example: {"id": "user@example.com", "source": "api_key"}
+            Return None if authentication fails.
         """
-        log_id_prefix = f"{self.log_identifier}[AuthenticateUser]"
-        # log.debug("%s Authenticating external event: %s", log_id_prefix, external_event_data)
+        log_id_prefix = f"{self.log_identifier}[ExtractClaims]"
+        # log.debug("%s Extracting initial claims from external event: %s", log_id_prefix, external_event_data)
 
-        # --- Implement Authentication Logic Here ---
+        # --- Implement Claims Extraction 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
+        # if provided_key and provided_key == self.get_config("service_api_key"):
+        #     user_id = external_event_data.get("user_id_field", "default_system_user")
+        #     log.info("%s Authentication successful for user: %s", log_id_prefix, user_id)
+        #     return {"id": user_id, "source": "api_key"}
         # 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"
+        # If no authentication is needed for this gateway, you can use a default identity
+        # from the configuration. The base class handles this logic if `force_user_identity`
+        # or `default_user_identity` are set, but you can implement it here if needed.
+        # return {"id": "anonymous___GATEWAY_NAME_SNAKE_CASE___user", "source": "anonymous"}
 
-        log.warning(
-            "%s _authenticate_external_user not fully implemented.", log_id_prefix
-        )
-        return "placeholder_user_identity"  # Replace with actual logic
+        log.warning("%s _extract_initial_claims not fully implemented.", log_id_prefix)
+        return {
+            "id": "placeholder_user_identity",
+            "source": "placeholder",
+        }  # 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]]:
+        self, external_event_data: Any
+    ) -> Tuple[str, List[ContentPart], 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).
+        GDK Hook: Translates the incoming external event/request into A2A task parameters.
+        This method is called *after* `authenticate_and_enrich_user`. The gateway's
+        event processing logic (e.g., a polling loop or request handler) is responsible
+        for calling `authenticate_and_enrich_user` first, and then passing the raw
+        event data to this method.
+
+        Args:
+            external_event_data: The raw data from the external system.
+
+        Returns:
+            A tuple:
+            - `target_agent_name` (str): Name of the A2A agent to route the task to.
+            - `a2a_parts` (List[ContentPart]): List of A2A Parts for the task.
+            - `external_request_context` (Dict[str, Any]): Dictionary to store any context
+              needed later (e.g., for _send_final_response_to_external).
+
+        Raises:
+            ValueError: If translation fails (e.g., target agent cannot be determined).
         """
         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] = []
+        a2a_parts: List[ContentPart] = []
         target_agent_name: Optional[str] = (
             None  # Determine this based on event data or config
         )
+        # This context is stored and passed back to the `_send_*_to_external` methods.
+        # It should contain any information needed to route the response back to the
+        # original requester in the external system.
         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"),
         }
 
@@ -227,23 +256,24 @@ class __GATEWAY_NAME_PASCAL_CASE__GatewayComponent(BaseGatewayComponent):
         #    - Extract text:
         #      text_content = external_event_data.get("message_text", "")
         #      if text_content:
-        #          a2a_parts.append(TextPart(text=text_content))
+        #          a2a_parts.append(a2a.create_text_part(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)
+        #      (Requires self.shared_artifact_service to be configured and available).
+        #      The `user_identity` dict is available in the calling context (e.g., polling loop).
         #      # 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"]
+        #      #         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)))
+        #      #         a2a_parts.append(a2a.create_file_part_from_uri(uri=artifact_uri, name=file_name, mime_type=mime_type))
         #    - 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__"}))
+        #      #    a2a_parts.append(a2a.create_data_part(data=structured_data, metadata={"source": "__GATEWAY_NAME_SNAKE_CASE__"}))
 
         # Example: Simple text passthrough
         raw_text = str(
@@ -251,18 +281,18 @@ class __GATEWAY_NAME_PASCAL_CASE__GatewayComponent(BaseGatewayComponent):
                 "text_input_field", "Default text from __GATEWAY_NAME_SNAKE_CASE__"
             )
         )
-        a2a_parts.append(TextPart(text=raw_text))
+        a2a_parts.append(a2a.create_text_part(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
+            raise ValueError("Could not determine target agent for the request.")
 
         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.
+            # Depending on requirements, you might want to raise ValueError here too.
 
         log.info(
             "%s Translation complete. Target: %s, Parts: %d",
@@ -281,33 +311,33 @@ class __GATEWAY_NAME_PASCAL_CASE__GatewayComponent(BaseGatewayComponent):
         - `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)
+        task_id = a2a.get_task_id(task_data)
+        # log.debug("%s Sending final response for task %s. Context: %s", log_id_prefix, task_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)
+        # 1. Extract relevant information from task_data using the `a2a` facade:
+        #    from a2a.types import TaskState
+        #    task_status = a2a.get_task_status(task_data) # e.g., TaskState.completed
+        #    artifacts = a2a.get_task_artifacts(task_data)
+        #    response_text = a2a.get_text_from_message(task_data.status.message) if task_data.status and task_data.status.message else ""
 
         # 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}"
+        #    if task_status == TaskState.failed:
+        #        final_message = f"Task failed: {response_text}"
+        #    elif task_status == TaskState.canceled:
+        #        final_message = "Task was canceled."
+        #    else:
+        #        final_message = 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)
+        #    # await self.external_client.send_reply(original_request_id, final_message)
 
         log.warning(
             "%s _send_final_response_to_external not fully implemented for task %s.",
             log_id_prefix,
-            task_data.id,
+            task_id,
         )
 
     async def _send_error_to_external(
@@ -321,17 +351,19 @@ class __GATEWAY_NAME_PASCAL_CASE__GatewayComponent(BaseGatewayComponent):
         - `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)
+        error_message = a2a.get_error_message(error_data)
+        error_code = a2a.get_error_code(error_data)
+        # log.warning("%s Sending error to external system. Error: %s. Context: %s", log_id_prefix, error_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})"
+        # error_message_to_send = f"A2A Error: {error_message} (Code: {error_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,
+            error_message,
         )
 
     async def _send_update_to_external(
@@ -347,27 +379,41 @@ class __GATEWAY_NAME_PASCAL_CASE__GatewayComponent(BaseGatewayComponent):
         - `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
+        task_id = event_data.task_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")
+        #     message = a2a.get_message_from_status_update(event_data)
+        #     if message:
+        #         # Get text content
+        #         text_content = a2a.get_text_from_message(message)
+        #         if text_content:
+        #             # Send text_content to external system
+        #             pass
+        #
+        #         # Check for specific status signals (DataParts)
+        #         data_parts = a2a.get_data_parts_from_message(message)
+        #         for part in data_parts:
+        #             data = a2a.get_data_from_data_part(part)
+        #             if data.get("type") == "agent_progress_update":
+        #                 status_text = data.get("status_text")
+        #                 # Send status_text to external system
         #                 pass
+        #
         # elif isinstance(event_data, TaskArtifactUpdateEvent):
-        #     # Handle artifact updates (e.g., notify external system of new artifact URI)
-        #     pass
+        #     artifact = a2a.get_artifact_from_artifact_update(event_data)
+        #     if artifact:
+        #         # 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)
+        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 ---
@@ -376,15 +422,20 @@ class __GATEWAY_NAME_PASCAL_CASE__GatewayComponent(BaseGatewayComponent):
 
         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]:
+    # async def save_to_artifact_service(self, content_bytes: bytes, filename: str, mime_type: str, user_identity: Dict[str, Any], 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 ...agent.utils.artifact_helpers import save_artifact_with_metadata # Adjust import
     #         from datetime import datetime, timezone
 
+    #         user_id = user_identity.get("id")
+    #         if not user_id:
+    #             log.error("%s Cannot save artifact, user_id not found in user_identity.", self.log_identifier)
+    #             return None
+
     #         save_result = await save_artifact_with_metadata(
     #             artifact_service=self.shared_artifact_service,
     #             app_name=self.gateway_id, # from BaseGatewayComponent

solace_agent_mesh/templates/shared_config.yaml

@@ -6,8 +6,7 @@ shared_config:
       broker_password: ${SOLACE_BROKER_PASSWORD, default}
       broker_vpn: ${SOLACE_BROKER_VPN, default}
       temporary_queue: ${USE_TEMPORARY_QUEUES, true}
-      # Ensure high enough limits if many agents are running
-      # max_connection_retries: -1 # Retry forever
+      
 
   - models:
     planning: &planning_model
@@ -57,13 +56,13 @@ shared_config:
   - services:
     # Default session service configuration
     session_service: &default_session_service
-      type: "__DEFAULT_SESSION_SERVICE_TYPE__"
-      default_behavior: "__DEFAULT_SESSION_SERVICE_BEHAVIOR__"
+      type: "memory"
+      default_behavior: "PERSISTENT"
     
     # Default artifact service configuration
     artifact_service: &default_artifact_service
       type: "__DEFAULT_ARTIFACT_SERVICE_TYPE__"
-      __DEFAULT_ARTIFACT_SERVICE_BASE_PATH_LINE__
+      # __DEFAULT_ARTIFACT_SERVICE_BASE_PATH_LINE__
       artifact_scope: __DEFAULT_ARTIFACT_SERVICE_SCOPE__
     
     # Default data tools configuration

solace_agent_mesh/templates/webui.yaml

@@ -1,11 +1,11 @@
-# Solace Agent Mesh WebUI Gateway Configuration
+
 
 log:
   stdout_log_level: INFO
   log_file_level: DEBUG
   log_file: webui_app.log
 
-# Shared SAM config
+
 !include ../shared_config.yaml
 
 apps:
@@ -21,14 +21,13 @@ apps:
       session_secret_key: ${SESSION_SECRET_KEY}
 
       artifact_service: *default_artifact_service
-
+      session_service: __SESSION_SERVICE__
       gateway_id: ${WEBUI_GATEWAY_ID}
       fastapi_host: ${FASTAPI_HOST}
       fastapi_port: ${FASTAPI_PORT}
-      cors_allowed_origins: # List of allowed origins for CORS
-        - "http://localhost:3000" # Example: Allow local React dev server
+      cors_allowed_origins: 
+        - "http://localhost:3000" 
         - "http://127.0.0.1:3000"
-        # Add other origins as needed, or use ["*"] for wide open (less secure)
 
       enable_embed_resolution: ${ENABLE_EMBED_RESOLUTION} # Enable late-stage resolution
       gateway_artifact_content_limit_bytes: ${GATEWAY_ARTIFACT_LIMIT_BYTES, 10000000} # Max size for late-stage embeds
@@ -47,7 +46,6 @@ apps:
             Format responses to the user in Markdown using appropriate formatting.
 
       # --- Frontend Config Passthrough ---
-      frontend_welcome_message: >
-            __FRONTEND_WELCOME_MESSAGE__
-      frontend_bot_name: __FRONTEND_BOT_NAME__
-      frontend_collect_feedback: __FRONTEND_COLLECT_FEEDBACK__
+      frontend_welcome_message: ${FRONTEND_WELCOME_MESSAGE}
+      frontend_bot_name: ${FRONTEND_BOT_NAME}
+      frontend_collect_feedback: ${FRONTEND_COLLECT_FEEDBACK}

{solace_agent_mesh-1.0.9.dist-info → solace_agent_mesh-1.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: solace-agent-mesh
-Version: 1.0.9
+Version: 1.3.0
 Summary: Solace Agent Mesh is an open-source framework for building event-driven, multi-agent AI systems where specialized agents collaborate on complex tasks.
 Project-URL: Homepage, https://github.com/SolaceLabs/solace-agent-mesh
 Project-URL: Repository, https://github.com/SolaceLabs/solace-agent-mesh
@@ -214,6 +214,8 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Requires-Python: >=3.10.16
+Requires-Dist: a2a-sdk[http-server]>=0.3.1
+Requires-Dist: alembic>=1.13.1
 Requires-Dist: asteval>=1.0.6
 Requires-Dist: asteval~=1.0.0
 Requires-Dist: beautifulsoup4>=4.12.0
@@ -249,6 +251,7 @@ Requires-Dist: python-multipart>=0.0.7
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: rouge~=1.0.1
 Requires-Dist: solace-ai-connector~=1.1.8
+Requires-Dist: sqlalchemy>=2.0
 Requires-Dist: sse-starlette>=1.6
 Requires-Dist: toml~=0.10.2
 Requires-Dist: uvicorn[standard]>=0.20
@@ -256,12 +259,12 @@ Provides-Extra: cli
 Requires-Dist: click>=8.0; extra == 'cli'
 Requires-Dist: prompt-toolkit>=3.0; extra == 'cli'
 Requires-Dist: rich>=13.0; extra == 'cli'
-Provides-Extra: database
-Requires-Dist: sqlalchemy>=2.0; extra == 'database'
 Provides-Extra: employee-tools
 Requires-Dist: holidays>=0.24; extra == 'employee-tools'
 Provides-Extra: gcs
 Requires-Dist: google-cloud-storage>=2.0; extra == 'gcs'
+Provides-Extra: postgresql
+Requires-Dist: psycopg2-binary>=2.9.0; extra == 'postgresql'
 Provides-Extra: s3
 Requires-Dist: boto3<2.0,>=1.35.0; extra == 's3'
 Provides-Extra: vertex
@@ -367,7 +370,7 @@ If no previous version exists, install the latest version with:
 ```bash
 pip3 install solace-agent-mesh
 ```
-#### 4. Initialize the new project via a GUI interface
+#### 4. Initialize the new project via a GUI tool
 ```bash
 sam init --gui
 ```
@@ -377,7 +380,7 @@ Note: This initialization UI runs on port 5002
 sam run
 ```
 #### 6. Verify SAM is running
-Open the Web UI at [http://localhost:8000](http://localhost:8000) for the chat inteface and ask a question
+Open the Web UI at [http://localhost:8000](http://localhost:8000) for the chat interface and ask a question
 
 ### 🔧 Customize SAM
 
@@ -424,7 +427,7 @@ Want to go further? Here are some hands-on tutorials to help you get started:
 
 | 🔧 Integration | ⏱️ Est. Time | 📘 Tutorial |
 |----------------|--------------|-------------|
-| 🌤️ **Weather Agent**<br>Learn how to build an agent that gives Solace Agent Mesh  the ability to access real-time weather information.  | **~15 min** | [Weather Agent Plugin](https://solacelabs.github.io/solace-agent-mesh/docs/documentation/tutorials/custom-agent) |
+| 🌤️ **Weather Agent**<br>Learn how to build an agent that gives Solace Agent Mesh the ability to access real-time weather information.  | **~15 min** | [Weather Agent Plugin](https://solacelabs.github.io/solace-agent-mesh/docs/documentation/tutorials/custom-agent) |
 | 🗃️ **SQL Database Integration**<br>Enable Solace Agent Mesh to answer company-specific questions using a sample coffee company database.| **~10–15 min** | [SQL Database Tutorial](https://solacelabs.github.io/solace-agent-mesh/docs/documentation/tutorials/sql-database) |
 | 🧠 **MCP Integration**<br>Integrating a Model Context Protocol (MCP) Servers into Solace Agent Mesh. | **~10–15 min** | [MCP Integration Tutorial](https://solacelabs.github.io/solace-agent-mesh/docs/documentation/tutorials/mcp-integration) |
 | 💬 **Slack Integration**<br>Chat with Solace Agent Mesh directly from Slack. | **~20–30 min** | [Slack Integration Tutorial](https://solacelabs.github.io/solace-agent-mesh/docs/documentation/tutorials/slack-integration) |