solace-agent-mesh 0.0.1__py3-none-any.whl → 0.1.1__py3-none-any.whl

solace_agent_mesh/gateway/components/gateway_input.py

@@ -0,0 +1,265 @@
+from typing import Dict, Any
+import base64
+import json
+from uuid import uuid4
+
+from solace_ai_connector.common.message import Message
+from solace_ai_connector.common.log import log
+from ...services.file_service import FileService
+from ...common.constants import DEFAULT_IDENTITY_KEY_FIELD
+from .gateway_base import GatewayBase
+
+info = {
+    "class_name": "GatewayInput",
+    "description": (
+        "This component handles requests from users and forms the "
+        "appropriate prompt for the next component in the flow."
+    ),
+    "config_parameters": [
+        {
+            "name": "gateway_config",
+            "type": "object",
+            "properties": {
+                "gateway_id": {"type": "string"},
+                "system_purpose": {"type": "string"},
+                "interaction_type": {"type": "string"},
+                "history_class": {"type": "string"},
+                "history_config": {"type": "object"},
+                "identity_key_field": {"type": "string", "default": DEFAULT_IDENTITY_KEY_FIELD},
+                "identity": {
+                    "type": "object",
+                    "properties": {
+                        "type": {"type": "string"},
+                        "module": {"type": "string"},
+                        "configuration": {"type": "object"},
+                    },
+                    "description": "Identity component configuration including module and class names.",
+                },
+            },
+            "description": "Gateway configuration including originators and their configurations.",
+        },
+    ],
+    "input_schema": {
+        "type": "object",
+        "properties": {
+            "event": {
+                "type": "object",
+                "properties": {
+                    "text": {"type": "string"},
+                    "files": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "name": {
+                                    "type": "string",
+                                },
+                                "content": {
+                                    "type": "string",
+                                },
+                                "mime_type": {"type": "string"},
+                                "url": {
+                                    "type": "string",
+                                },
+                                "size": {
+                                    "type": "number",
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        "required": ["event"],
+    },
+    "output_schema": {
+        "type": "object",
+        "properties": {
+            "files": {
+                "type": "array",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "name": {
+                            "type": "string",
+                        },
+                        "content": {
+                            "type": "string",
+                        },
+                        "mime_type": {
+                            "type": "string",
+                        },
+                        "url": {
+                            "type": "string",
+                        },
+                        "file_size": {
+                            "type": "number",
+                        },
+                    },
+                },
+            },
+            "text": {"type": "string"},
+            "interface_properties": {"type": "object"},
+            "history": {
+                "type": "array",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "role": {"type": "string"},
+                        "content": {"type": "string"},
+                    },
+                },
+            },
+        },
+        "required": ["session_id", "clear_history", "messages"],
+    },
+}
+
+DEFAULT_SYSTEM_PURPOSE = "You are participating in the chat bot framework."
+DEFAULT_INTERACTION_TYPE = "interactive"  # vs "autonomous"
+
+
+class GatewayInput(GatewayBase):
+    """This component handles incoming stimuli and prepares the context for processing."""
+
+    def __init__(self, **kwargs):
+        super().__init__(info, **kwargs)
+        self.system_purpose = self.get_config("system_purpose", DEFAULT_SYSTEM_PURPOSE)
+        self.interaction_type = self.get_config(
+            "interaction_type", DEFAULT_INTERACTION_TYPE
+        )
+        self.identity_component = self._initialize_identity_component()
+
+    def _authenticate_user(self, _user_properties: Dict[str, Any]) -> bool:
+        # Implement actual authentication logic here
+        return True
+
+    def invoke(self, message: Message, data: Dict[str, Any]) -> Dict[str, Any]:
+        user_properties = message.get_user_properties() or {}
+        copied_data = data.copy()
+
+        errors = []
+        available_files = []
+
+        try:
+            if not self._authenticate_user(user_properties):
+                log.error("User authentication failed")
+                raise PermissionError("User authentication failed")
+
+            # Get identity info
+            identity_field = self.identity_component.get_identity_field()
+            identity_value = user_properties.get(identity_field)
+            if not identity_value:
+                log.error("Identity field '%s' not found", identity_field)
+                raise ValueError(f"Identity field '{identity_field}' not found")
+
+            user_info = self.identity_component.get_user_info(identity_value)
+
+            session_id = user_properties.get("session_id")
+
+            # De-clutter the data and user_properties by moving some properties to a nested sub-object
+            top_level_data_properties = {"text", "files"}
+            self.demote_interface_properties(copied_data, top_level_data_properties)
+
+            top_level_user_properties = {
+                "input_type",
+                "session_id",
+                "response_format_prompt",
+            }
+            self.demote_interface_properties(user_properties, top_level_user_properties)
+
+            prompt = data.get("text", "")
+            files = data.get("files", [])
+
+            attached_files = []
+            if len(files) > 0:
+                file_service = FileService()
+                for file in files:
+                    content = file["content"]
+                    if type(content) == str:
+                        try:
+                            byte_buffer = base64.b64decode(content)
+                        except Exception as e:
+                            byte_buffer = content.encode("utf-8")
+                    elif type(content) == bytes:
+                        byte_buffer = content
+                    else:
+                        log.error(
+                            "Invalid content type for file %s: %s",
+                            file["name"],
+                            type(content),
+                        )
+                        continue
+
+                    file_metadata = file_service.upload_from_buffer(
+                        byte_buffer,
+                        file["name"],
+                        session_id,
+                        file_size=file["size"],
+                        data_source=f"User provided file - {self.gateway_id} Gateway",
+                    )
+                    attached_files.append(file_metadata)
+            copied_data["files"] = attached_files
+
+            copied_data["history"] = []
+            if self.use_history:
+                prompt = data.get("text", "")
+                self.history_instance.store_history(session_id, "user", prompt)
+
+                for file in attached_files:
+                    self.history_instance.store_file(session_id, file)
+
+                # retrieve all files for the session
+                available_files = self.history_instance.get_files(session_id)
+
+                # Add history to the data
+                copied_data["history"] = self.history_instance.get_history(session_id)
+
+            available_files = json.dumps(available_files)
+        except Exception as e:
+            log.error("Error processing input: %s", e)
+            errors.append(str(e))
+
+        stimulus_uuid = self.gateway_id + str(uuid4())
+
+        user_properties.update(
+            {
+                "gateway_id": self.gateway_id,
+                "system_purpose": self.system_purpose,
+                "interaction_type": self.interaction_type,
+                "available_files": available_files,
+                "stimulus_uuid": stimulus_uuid,
+                "user_info": user_info,
+                "identity": identity_value,
+            }
+        )
+        copied_data["user_info"] = user_info
+        copied_data["errors"] = errors
+        message.set_user_properties(user_properties)
+        message.set_payload(copied_data)
+
+        return copied_data
+
+    def demote_interface_properties(
+        self, dict_properties: Dict[str, Any], top_level_properties: set
+    ):
+        """
+        Demotes specified properties from the top level of a dictionary to a nested dictionary under the key 'interface_properties'.
+
+        Args:
+            dict_properties (Dict[str, Any]): The dictionary containing the properties.
+            top_level_properties (set): A set of property names that should remain at the top level.
+
+        Modifies:
+            dict_properties: Adds a new key 'interface_properties' containing the properties that are not in top_level_properties.
+                             Removes the demoted properties from the top level of dict_properties.
+        """
+
+        interface_properties = {
+            k: v for k, v in dict_properties.items() if k not in top_level_properties
+        }
+        dict_properties["interface_properties"] = interface_properties
+
+        # Remove keys from user_properties that are in interface_user_properties
+        for key in interface_properties:
+            dict_properties.pop(key, None)

solace_agent_mesh/gateway/components/gateway_output.py

@@ -0,0 +1,289 @@
+import base64
+from solace_ai_connector.common.message import Message
+from solace_ai_connector.common.log import log
+
+from .gateway_base import GatewayBase
+from ...services.file_service import FileService
+from ...common.utils import files_to_block_text
+
+
+info = {
+    "class_name": "GatewayOutput",
+    "description": (
+        "This component handles stimuli from users and forms the "
+        "appropriate prompt for the next component in the flow."
+    ),
+    "config_parameters": [
+        {
+            "name": "gateway_config",
+            "type": "object",
+            "properties": {
+                "gateway_id": {"type": "string"},
+                "system_purpose": {"type": "string"},
+                "interaction_type": {"type": "string"},
+                "default_originator_scopes": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                },
+            },
+            "description": "Gateway configuration including originators and their configurations.",
+        },
+    ],
+    "input_schema": {
+        "type": "object",
+        "properties": {
+            "event": {
+                "type": "object",
+                "properties": {
+                    "text": {
+                        "type": "string",
+                    },
+                    "files": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "name": {
+                                    "type": "string",
+                                },
+                                "data": {
+                                    "type": "string",
+                                },
+                                "mime_type": {
+                                    "type": "string",
+                                },
+                                "url": {
+                                    "type": "string",
+                                },
+                                "file_size": {
+                                    "type": "number",
+                                },
+                            },
+                        },
+                    },
+                    "first_chunk": {
+                        "type": "boolean",
+                    },
+                    "last_chunk": {
+                        "type": "boolean",
+                    },
+                    "uuid": {
+                        "type": "string",
+                    },
+                    "chunk": {
+                        "type": "text",
+                    },
+                    "status_update": {
+                        "type": "boolean",
+                    },
+                },
+            },
+        },
+    },
+    "output_schema": {
+        "type": "object",
+        "properties": {
+            "event": {
+                "type": "object",
+                "properties": {
+                    "text": {
+                        "type": "string",
+                    },
+                    "files": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "name": {
+                                    "type": "string",
+                                },
+                                "data": {
+                                    "type": "string",
+                                },
+                                "mime_type": {
+                                    "type": "string",
+                                },
+                                "url": {
+                                    "type": "string",
+                                },
+                                "file_size": {
+                                    "type": "number",
+                                },
+                            },
+                        },
+                    },
+                    "first_chunk": {
+                        "type": "boolean",
+                    },
+                    "last_chunk": {
+                        "type": "boolean",
+                    },
+                    "uuid": {
+                        "type": "string",
+                    },
+                    "chunk": {
+                        "type": "text",
+                    },
+                    "status_update": {
+                        "type": "boolean",
+                    },
+                },
+            },
+        },
+    },
+}
+
+
+class GatewayOutput(GatewayBase):
+    """This is the component that handles incoming stimuli"""
+
+    def __init__(self, **kwargs):
+        super().__init__(info, **kwargs)
+        self.default_agent_scopes = self.get_config("default_agent_scopes", [])
+        self.originators = self.get_config("originators", [])
+
+    def _resolve_text_content(self, data: dict, session_id: str) -> None:
+        """
+        Resolve all AMFS URLs in text and chunk fields of the data dictionary.
+
+        Args:
+            data (dict): The data dictionary containing text and chunk fields
+            session_id (str): The session ID for file service operations
+
+        Returns:
+            None: Modifies the data dictionary in place
+        """
+        try:
+            file_service = FileService()
+            text_output_response = data.get("text", "") or ""
+            data["text"] = file_service.resolve_all_resolvable_urls(
+                text_output_response, session_id
+            )
+            chunk_output_response = data.get("chunk", "") or ""
+            data["chunk"] = file_service.resolve_all_resolvable_urls(
+                chunk_output_response, session_id
+            )
+        except Exception as e:
+            log.error(f"Failed to resolve URLs in text: {e}")
+
+    def invoke(self, message: Message, data) -> Message:
+        file_service = FileService()
+        user_properties = message.get_user_properties()
+        session_id = user_properties.get("session_id")
+        files = data.get("files", [])
+
+        # Extract the interface queue ID
+        interface_properties = user_properties.get("interface_properties", [])
+        server_input_id = (
+            interface_properties and interface_properties.get("server_input_id", "")
+            if interface_properties
+            else ""
+        )
+
+        if self.use_history and session_id:
+            topic = message.get_topic()
+            content = data.get("text") or ""
+
+            file_text_blocks = files_to_block_text(files)
+            if file_text_blocks:
+                content += file_text_blocks
+
+            if (
+                "/streamingResponse/" in topic
+                and data.get("last_chunk")
+                and "text" in data
+            ):
+                if content:
+                    self.history_instance.store_history(
+                        session_id, "assistant", content
+                    )
+
+            for file in files:
+                self.history_instance.store_history(
+                    session_id, "assistant", f'\n[Returned file: {{name: {file.get("name")}, url: {file.get("url")}}}]\n'
+                )
+                self.history_instance.store_file(session_id, file)
+
+            clear_history_tuple = user_properties.get("clear_gateway_history", [])
+            if clear_history_tuple and clear_history_tuple[0]:
+                keep_depth = clear_history_tuple[1]
+                self.history_instance.clear_history(session_id, keep_depth)
+
+        if files:
+            downloaded_files = []
+            for file in files:
+                output_file = {
+                    "name": file.get("name"),
+                }
+                # inline file
+                if file.get("data"):
+                    data_content = file_service.resolve_all_resolvable_urls(
+                        file.get("data"), session_id
+                    )
+                    inline_data = base64.b64encode(data_content.encode()).decode()
+                    output_file["content"] = inline_data
+                    output_file["mime_type"] = file.get("mime_type", "text/plain")
+                elif file.get("url"):
+                    url = file.get("url")
+                    try:
+                        resolved_content = file_service.resolve_url(url, session_id)
+                        buffer_content = (
+                            resolved_content
+                            if type(resolved_content) == bytes
+                            else resolved_content.encode()
+                        )
+                        output_file["content"] = base64.b64encode(
+                            buffer_content
+                        ).decode("utf-8")
+
+                        # If the file name or mime type is not provided, try to get it from the resolved URL
+                        if not output_file.get("name") or not output_file.get(
+                            "mime_type"
+                        ):
+                            metadata = file_service.get_metadata(url)
+                            output_file["name"] = output_file.get(
+                                "name"
+                            ) or metadata.get("name")
+                            output_file["mime_type"] = output_file.get(
+                                "mime_type"
+                            ) or metadata.get("mime_type")
+                    except Exception as e:
+                        log.error(f"Failed to download file {file.get('name')}: {e}")
+                        continue
+                else:
+                    log.error(f"No file content found for {file.get('name')}")
+                    continue
+                downloaded_files.append(output_file)
+
+            data["files"] = downloaded_files
+        data["server_input_id"] = server_input_id
+
+        # Promote the interface properties back to the top level of the user_properties
+        self.promote_interface_properties(user_properties)
+        message.set_user_properties(user_properties)
+
+        # Resolve inline URLs in text and chunk fields
+        self._resolve_text_content(data, session_id)
+
+        message.set_payload(data)
+        return {"payload": data}
+
+    def promote_interface_properties(self, user_properties):
+        """
+        Updates the user_properties with the values from the
+        "interface_properties" sub-object, if it exists.
+
+        Args:
+            user_properties (dict): A dictionary that may contain an
+                                    "interface_properties" key with a sub-dictionary
+                                    of properties to be merged into the main dictionary.
+
+        Returns:
+            None: The function modifies the user_properties dictionary in place.
+        """
+        interface_properties = user_properties.get("interface_properties", {})
+        if isinstance(interface_properties, dict):
+            for key, value in interface_properties.items():
+                user_properties[key] = value
+
+        user_properties.pop("interface_properties", None)

solace_agent_mesh/gateway/identity/bamboohr_identity.py

@@ -0,0 +1,18 @@
+import re
+from .identity_base import IdentityBase
+from ...services.bamboo_hr_service.bamboo_hr import BambooHR
+
+class BambooHRIdentity(IdentityBase):
+    def __init__(self, config: dict):
+        super().__init__(config)
+        self.bamboo_hr_service = BambooHR(config)
+
+    def get_user_info(self, identity: str) -> dict:
+        if not re.match(r"[^@]+@[^@]+\.[^@]+", identity):
+            raise ValueError("Invalid email address")
+
+        employee_summary = self.bamboo_hr_service.get_employee_summary(identity)
+        if employee_summary:
+            return employee_summary
+
+        return {"identity": identity}

solace_agent_mesh/gateway/identity/identity_base.py

@@ -0,0 +1,10 @@
+from abc import ABC, abstractmethod
+
+class IdentityBase(ABC):
+    def __init__(self, config: dict):
+        self.config = config
+
+    @abstractmethod
+    def get_user_info(self, identity: str) -> dict:
+        """Get user information for a given identity."""
+        pass

solace_agent_mesh/gateway/identity/identity_provider.py

@@ -0,0 +1,60 @@
+import importlib
+
+from ...gateway.identity.passthru_identity import PassthruIdentity
+from ...gateway.identity.bamboohr_identity import BambooHRIdentity
+from ...gateway.identity.no_identity import NoIdentity
+from ...gateway.identity.identity_base import IdentityBase
+from ...common.constants import DEFAULT_IDENTITY_KEY_FIELD
+
+IDENTITY_PROVIDERS = {
+    "passthru": PassthruIdentity,
+    "bamboohr": BambooHRIdentity,
+    "none": NoIdentity,
+}
+
+DEFAULT_PROVIDER = "none"
+
+class IdentityProvider:
+    identity_provider: IdentityBase
+
+    def __init__(self, config=None):
+        self.config = config or {}
+        self.provider_type = self.config.get("type", DEFAULT_PROVIDER)
+        self.identity_field = self.config.get("key_field", DEFAULT_IDENTITY_KEY_FIELD)
+        if self.provider_type not in IDENTITY_PROVIDERS and not self.config.get("module_path"):
+            raise ValueError(
+                f"Unsupported identity provider type: {self.provider_type}. No module_path provided."
+            )
+
+        provider_configuration = self.config.get("configuration", {})
+
+        if self.provider_type in IDENTITY_PROVIDERS:
+            # Load built-in identity provider
+            self.identity_provider = IDENTITY_PROVIDERS[self.provider_type](provider_configuration)
+        else:
+            try:
+                # Load the provider from the module path
+                module_name = self.provider_type
+                module_path = self.config.get("module_path")
+                module = importlib.import_module(module_path, package=__package__)
+                identity_class = getattr(module, module_name)
+                if not issubclass(identity_class, IdentityBase):
+                    raise ValueError(
+                        f"Identity provider class {identity_class} does not inherit from IdentityBase"
+                    )
+                self.identity_provider = identity_class(provider_configuration)
+            except Exception as e:
+                raise ImportError("Unable to load component: " + str(e)) from e
+
+    def get_identity_field(self) -> str:
+        """Returns the configured field name to use for identity lookup"""
+        return self.identity_field
+
+    def get_user_info(self, identity: str) -> dict:
+        """
+        Get user information using the configured identity provider.
+
+        :param identity: The user identity string (usually email)
+        :return: Dictionary containing user information
+        """
+        return self.identity_provider.get_user_info(identity)

solace_agent_mesh/gateway/identity/no_identity.py

@@ -0,0 +1,9 @@
+
+from .identity_base import IdentityBase
+
+class NoIdentity(IdentityBase):
+    def __init__(self, config: dict):
+        super().__init__(config)
+
+    def get_user_info(self, identity: str) -> dict:
+        return {}

solace_agent_mesh/gateway/identity/passthru_identity.py

@@ -0,0 +1,9 @@
+
+from .identity_base import IdentityBase
+
+class PassthruIdentity(IdentityBase):
+    def __init__(self, config: dict):
+        super().__init__(config)
+
+    def get_user_info(self, identity: str) -> dict:
+        return {"identity": identity}