solace-agent-mesh 0.2.4__py3-none-any.whl → 1.0.1__py3-none-any.whl

solace_agent_mesh/gateway/components/gateway_input.py

@@ -1,278 +0,0 @@
-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, HISTORY_USER_ROLE
-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.",
-        },
-        {
-            "name": "response_format_prompt",
-            "type": "string",
-            "description": "Format instructions for the response that will be passed to the model",
-            "default": ""
-        }
-    ],
-    "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.system_purpose_prompt_suffix
-        self.interaction_type = self.get_config(
-            "interaction_type", DEFAULT_INTERACTION_TYPE
-        )
-        self.identity_component = self._initialize_identity_component()
-        self.response_format_prompt = self.get_config("response_format_prompt", "")
-
-    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",
-            }
-            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:
-                other_history_props = {
-                    "identity": identity_value,
-                }
-                prompt = data.get("text", "")
-                self.history_instance.store_history(session_id, HISTORY_USER_ROLE, prompt, other_history_props)
-
-                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, other_history_props)
-
-            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())
-
-        # Add response format prompt from config if available
-        if self.response_format_prompt:
-            user_properties["response_format_prompt"] = self.response_format_prompt
-
-        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

@@ -1,298 +0,0 @@
-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
-from ...common.constants import HISTORY_ASSISTANT_ROLE
-
-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")
-        identity_value = user_properties.get("identity")
-        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:
-            other_history_props = {
-                "identity": identity_value,
-            }
-
-            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
-            ):
-                actions_called = user_properties.get("actions_called", [])
-                if actions_called:
-                    self.history_instance.store_actions(session_id, actions_called)
-                
-                if content:
-                    self.history_instance.store_history(
-                        session_id, HISTORY_ASSISTANT_ROLE, content, other_history_props
-                    )
-
-            for file in files:
-                self.history_instance.store_history(
-                    session_id, HISTORY_ASSISTANT_ROLE, f'\n[Returned file: {{name: {file.get("name")}, url: {file.get("url")}}}]\n', other_history_props
-                )
-                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

@@ -1,18 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

@@ -1,9 +0,0 @@
-
-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

@@ -1,9 +0,0 @@
-
-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}