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

solace_agent_mesh/__init__.py

@@ -1,3 +0,0 @@
-# Internal components that are dynamically loaded by the AI Connector
-# Listing them here allows for them to use relative imports
-__version__ = "0.0.1"

solace_agent_mesh/agents/base_agent_component.py

@@ -0,0 +1,224 @@
+"""This is the base class for all custom agent components"""
+
+import json
+import traceback
+
+import os
+from abc import ABC
+from solace_ai_connector.common.log import log
+from solace_ai_connector.common.message import Message
+from solace_ai_connector.common.utils import ensure_slash_on_end
+
+from ..services.llm_service.components.llm_service_component_base import LLMServiceComponentBase
+from ..common.action_list import ActionList
+from ..common.action_response import ActionResponse, ErrorInfo
+from ..services.file_service import FileService
+from ..services.file_service.file_utils import recursive_file_resolver
+from ..services.middleware_service.middleware_service import MiddlewareService
+
+agent_info = {
+    "class_name": "BaseAgentComponent",
+    "description": "This component handles action requests",
+    "config_parameters": [
+        {
+            "name": "llm_service_topic",
+            "required": False,
+            "description": "The topic to use for the LLM service",
+        },
+        {
+            "name": "embedding_service_topic",
+            "required": False,
+            "description": "The topic to use for the Embedding service",
+        },
+        {
+            "name": "registration_interval",
+            "required": False,
+            "description": "The interval in seconds for agent registration",
+            "default": 30,
+        },
+    ],
+    "input_schema": {
+        "type": "object",
+        "properties": {
+            "agent_name": {"type": "string"},
+            "action_name": {"type": "string"},
+            "params": {"type": "object", "additionalProperties": True},
+        },
+        "required": ["agent_name", "action_name", "params"],
+    },
+}
+
+
+class BaseAgentComponent(LLMServiceComponentBase, ABC):
+
+    @classmethod
+    def get_actions_list(cls, **kwargs):  
+        return ActionList(cls.actions, **kwargs)
+
+
+    def __init__(self, module_info={}, **kwargs):
+        super().__init__(module_info, **kwargs)
+        self.kwargs = kwargs
+        self.action_config = kwargs.get("action_config", {})
+        self.registration_interval = int(self.get_config("registration_interval", 30))
+
+        self.llm_service_topic = self.get_config("llm_service_topic")
+        if self.llm_service_topic:
+            self.llm_service_topic = ensure_slash_on_end(self.llm_service_topic)
+            # Check that the component's broker request/response is enabled
+            if not self.is_broker_request_response_enabled():
+                raise ValueError(
+                    "LLM service topic is set, but the component does not "
+                    f"have its broker request/response enabled, {self.__class__.__name__}"
+                )
+
+        self.embedding_service_topic = self.get_config("embedding_service_topic")
+        if self.embedding_service_topic:
+            self.embedding_service_topic = ensure_slash_on_end(
+                self.embedding_service_topic
+            )
+            # Check that the component's broker request/response is enabled
+            if not self.is_broker_request_response_enabled():
+                raise ValueError(
+                    "Embedding service topic is set, but the component does not "
+                    f"have its broker request/response enabled, {self.__class__.__name__}"
+                )
+            
+        self.action_list = self.get_actions_list(agent=self, config_fn=self.get_config)
+
+    def run(self):
+        # This is called when the component is started - we will use this to send the first registration message
+        # Only do this for the first of the agent components
+        if self.component_index == 0:
+            # Send the registration message immediately - this will also schedule the timer
+            self.handle_timer_event(None)
+
+        # Call the base class run method
+        super().run()
+
+    def get_actions_summary(self):
+        action_list = self.action_list
+        return action_list.get_prompt_summary(prefix=self.info.get("agent_name"))
+
+    def get_agent_summary(self):
+        return {
+            "agent_name": self.info["agent_name"],
+            "description": self.info["description"],
+            "always_open": self.info.get("always_open", False),
+            "actions": self.get_actions_summary(),
+        }
+
+    def invoke(self, message, data):
+        """Invoke the component"""
+        action_name = data.get("action_name")
+        action_response = None
+        file_service = FileService()
+        if not action_name:
+            log.error("Action name not provided. Data: %s", json.dumps(data))
+            action_response = ActionResponse(
+                message="Internal error: Action name not provided. Please try again",
+            )
+        else:
+            action = self.action_list.get_action(action_name)
+            if not action:
+                log.error(
+                    "Action not found: %s. Data: %s", action_name, json.dumps(data)
+                )
+                action_response = ActionResponse(
+                    message="Internal error: Action not found. Please try again",
+                )
+            else:
+                resolved_params = data.get("action_params", {}).copy()
+                try:
+                    session_id = (message.get_user_properties() or {}).get("session_id")
+                    resolved_params = recursive_file_resolver(
+                        resolved_params,
+                        resolver=file_service.resolve_all_resolvable_urls,
+                        session_id=session_id,
+                    )
+                except Exception as e:
+                    log.error(
+                        "Error resolving file service URLs: %s. Data: %s",
+                        str(e),
+                        json.dumps(data),
+                        exc_info=True,
+                    )
+                    action_response = ActionResponse(
+                        message=f"Error resolving file URLs. Details: {str(e)}",
+                    )
+
+                middleware_service = MiddlewareService()
+                if middleware_service.get("base_agent_filter")(message.user_properties or {}, action):
+                    try:
+                        meta = {
+                            "session_id": session_id,
+                        }
+                        action_response = action.invoke(resolved_params, meta)
+                    except Exception as e:
+
+                        error_message = (
+                            f"Error invoking action {action_name} "
+                            f"in agent {self.info.get('agent_name', 'Unknown')}: \n\n"
+                            f"Exception name: {type(e).__name__}\n"
+                            f"Exception info: {str(e)}\n"
+                            f"Stack trace: {traceback.format_exc()}\n\n"
+                            f"Data: {json.dumps(data)}"
+                        )
+                        log.error(error_message)
+                        action_response = ActionResponse(
+                            message=f"Internal error: {type(e).__name__} - Error invoking action. Details: {str(e)}",
+                            error_info=ErrorInfo(
+                                error_message=error_message,
+                            ),
+                        )
+                else:
+                    log.warning(
+                        "Unauthorized access attempt for action %s. Data: %s",
+                        action_name,
+                        json.dumps(data),
+                    )
+                    action_response = ActionResponse(
+                        message="Unauthorized: You don't have permission to perform this action.",
+                    )
+
+        action_response.action_list_id = data.get("action_list_id")
+        action_response.action_idx = data.get("action_idx")
+        action_response.action_name = action_name
+        action_response.action_params = data.get("action_params", {})
+        try:
+            action_response_dict = action_response.to_dict()
+        except Exception as e:
+            log.error(
+                "Error after action %s in converting action response to dict: %s. Data: %s",
+                action_name,
+                str(e),
+                json.dumps(data),
+                exc_info=True,
+            )
+            action_response_dict = {
+                "message": "Internal error: Error converting action response to dict",
+            }
+
+        # Construct the response topic
+        response_topic = f"{os.getenv('SOLACE_AGENT_MESH_NAMESPACE')}solace-agent-mesh/v1/actionResponse/agent/{self.info['agent_name']}/{action_name}"
+
+        return {"payload": action_response_dict, "topic": response_topic}
+
+    def handle_timer_event(self, timer_data):
+        """Handle the timer event for agent registration."""
+        registration_message = self.get_agent_summary()
+        registration_topic = f"{os.getenv('SOLACE_AGENT_MESH_NAMESPACE')}solace-agent-mesh/v1/register/agent/{self.info['agent_name']}"
+
+        message = Message(
+            topic=registration_topic,
+            payload=registration_message,
+        )
+
+        message.set_previous(
+            {"topic": registration_topic, "payload": registration_message}
+        )
+
+        self.send_message(message)
+
+        # Re-schedule the timer
+        self.add_timer(self.registration_interval * 1000, "agent_registration")

solace_agent_mesh/agents/global/actions/agent_state_change.py

@@ -0,0 +1,54 @@
+"""Agent state change action"""
+
+from solace_ai_connector.common.log import log
+from ....common.action import Action
+from ....common.action_response import (
+    ActionResponse,
+    AgentStateChange,
+    ErrorInfo,
+)
+
+
+class AgentStateChangeAction(Action):
+
+    def __init__(self, **kwargs):
+        super().__init__(
+            {
+                "name": "change_agent_status",
+                "prompt_directive": "Handle agent state change",
+                "params": [
+                    {
+                        "name": "agent_name",
+                        "desc": "Name of the agent",
+                        "type": "string",
+                    },
+                    {
+                        "name": "new_state",
+                        "desc": "New state of the agent: open or closed",
+                        "type": "string",
+                    },
+                ],
+                "required_scopes": ["*:*:*"],
+            },
+            **kwargs,
+        )
+
+    def invoke(self, params, meta={}) -> ActionResponse:
+        agent_name = params["agent_name"]
+        new_state = params["new_state"]
+        log.debug("Handling agent state change: %s -> %s", agent_name, new_state)
+
+        if new_state == "open":
+            return ActionResponse(
+                message=f"_Opening agent {agent_name}..._",
+                agent_state_change=AgentStateChange(agent_name, "open"),
+            )
+        elif new_state == "closed":
+            return ActionResponse(
+                agent_state_change=AgentStateChange(agent_name, "closed"),
+            )
+        else:
+            log.error("Invalid agent state: %s", new_state)
+            return ActionResponse(
+                error_info=ErrorInfo(error_message=f"Invalid agent state for {agent_name}: {new_state}"),
+            )

solace_agent_mesh/agents/global/actions/clear_history.py

@@ -0,0 +1,32 @@
+"""Clear history action"""
+
+from solace_ai_connector.common.log import log
+from ....common.action import Action
+from ....common.action_response import ActionResponse
+
+
+class ClearHistory(Action):
+    def __init__(self, **kwargs):
+        super().__init__(
+            {
+                "name": "clear_history",
+                "prompt_directive": "Clear the chat history",
+                "params": [
+                    {
+                        "name": "depth_to_keep",
+                        "desc": "The number of messages to keep in the chat history. If 0, clear all history. ",
+                        "type": "integer",
+                    }
+                ],
+                "required_scopes": ["*:*:*"],
+            },
+            **kwargs,
+        )
+
+    def invoke(self, params, meta={}) -> ActionResponse:
+        log.debug("Clearing chat history")
+        depth_to_keep = params.get("depth_to_keep", 0)
+        return ActionResponse(
+            clear_history=True,
+            history_depth_to_keep=depth_to_keep,
+        )

solace_agent_mesh/agents/global/actions/convert_file_to_markdown.py

@@ -0,0 +1,160 @@
+"""Action description"""
+
+from solace_ai_connector.common.log import log
+from markitdown import MarkItDown
+from markitdown import UnsupportedFormatException
+import json
+import os
+import mimetypes
+import tempfile
+from ....common.action import Action
+from ....common.action_response import ActionResponse
+from ....services.file_service import FS_PROTOCOL, FileService
+
+STRIP_LENGTH = len(FS_PROTOCOL) + len("://") + 36 + 1  # 36 is uuid, 1 is underscore
+
+
+class ConvertFileToMarkdown(Action):
+
+    def __init__(self, **kwargs):
+        super().__init__(
+            {
+                "name": "convert_file_to_markdown",
+                "prompt_directive": (
+                    "Convert various file formats to Markdown using the MarkItDown utility. "
+                    "Supported file types include PDF, Word, Excel, HTML, CSV and PPTX "
+                    "and ZIP files. Files are provided in "
+                    + f"{FS_PROTOCOL}://"
+                    + " format. "
+                    "JSON and XML files are not supported. "
+                    "This action will return Markdown files."
+                ),
+                "params": [
+                    {
+                        "name": "files",
+                        "desc": (
+                            f"List of {FS_PROTOCOL}:// URLs to the files to convert to Markdown. "
+                            f"For example: ['{FS_PROTOCOL}://file1.pdf', '{FS_PROTOCOL}://file2.docx']"
+                        ),
+                        "type": "array",
+                    }
+                ],
+                "required_scopes": ["global:markitdown:execute"],
+            },
+            **kwargs,
+        )
+
+    def invoke(self, params, meta={}) -> ActionResponse:
+        files = params.get("files", [])
+        session_id = meta.get("session_id")
+        log.debug("Doing markitdown convert action: %s", params["files"])
+
+        if isinstance(files, str):
+            try:
+                files = json.loads(files)
+            except json.JSONDecodeError:
+                log.error("Failed to decode files string as JSON")
+                return ActionResponse(message="Error: File URL list is not valid.")
+
+        return self.do_action(files, session_id)
+
+    def extract_file_format(self, file_path: str) -> str:
+        """
+        Extracts the file format from a file path or guesses it using mimetypes if not present.
+        """
+        file_extension = os.path.splitext(file_path)[1]
+        if file_extension:
+            return file_extension.lower()
+
+        mime_type, _ = mimetypes.guess_type(file_path)
+        if mime_type:
+            guessed_extension = mimetypes.guess_extension(mime_type)
+            if guessed_extension:
+                return guessed_extension.lower()
+
+        raise ValueError(f"Unable to determine file format for path: {file_path}")
+
+    def do_action(self, files, session_id) -> ActionResponse:
+        markitdown_client = MarkItDown()
+        file_service = FileService()
+
+        response_messages = []
+        uploaded_files = []
+
+        # Iterate over each file URL
+        for file_url in files:
+            try:
+                file_buffer = file_service.download_to_buffer(file_url, session_id)
+            except Exception as e:
+                log.error(
+                    "Failed to download file from the url %s: %s", file_url, str(e)
+                )
+                response_messages.append(
+                    f"Failed to download file from the url {file_url}"
+                )
+                continue
+
+            # Find the file extension
+            try:
+                file_extension = self.extract_file_format(file_url)
+            except ValueError:
+                response_messages.append(
+                    f"Could not determine file format for: {file_url}"
+                )
+                continue
+
+            # strip first {STRIP LENGTH} characters of the url to get the original name
+            original_name = file_url[STRIP_LENGTH:]
+
+            with tempfile.NamedTemporaryFile(
+                delete=True, suffix=file_extension
+            ) as temporary_file:
+                try:
+                    # Write to temp file
+                    temporary_file.write(file_buffer)
+                    temporary_file.flush()
+
+                    # Convert the file to Markdown
+                    try:
+                        conversion_result = markitdown_client.convert(
+                            temporary_file.name
+                        )
+                        # Empty content
+                        if not conversion_result.text_content:
+                            log.error("Error converting file %s: Conversion resulted in empty content", file_url)
+                            response_messages.append(f"Could not convert file: {file_url} - conversion resulted in empty content")
+                            continue
+                    except UnsupportedFormatException as e:
+                        log.error("Error converting file %s: %s", file_url, str(e))
+                        response_messages.append(
+                            f"Could not convert file: {file_url} as this format is not supported: {str(e)}"
+                        )
+                        continue
+
+                    # Use the original file name + "_converted" affix + .md extension
+                    converted_filename = f"{original_name}_converted.md"
+
+                    # Upload the converted content
+                    file_obj = file_service.upload_from_buffer(
+                        conversion_result.text_content.encode("utf-8"),
+                        converted_filename,
+                        session_id,
+                        data_source="Global Agent - MarkItDown Action",
+                    )
+
+                    filename = file_obj["name"]
+                    uploaded_files.append(file_obj)
+                    response_messages.append(f"File converted successfully: {filename}")
+
+                except Exception as e:
+                    log.error(
+                        "Failed to upload file %s: %s", converted_filename, str(e)
+                    )
+                    response_messages.append(
+                        f"Failed to upload file {converted_filename}"
+                    )
+                    continue
+
+        return ActionResponse(
+            message="\n".join(response_messages), files=uploaded_files
+        )

solace_agent_mesh/agents/global/actions/create_file.py

@@ -0,0 +1,70 @@
+"""Create a new file in file service"""
+
+from solace_ai_connector.common.log import log
+from ....common.action import Action
+from ....common.action_response import ActionResponse
+from ....services.file_service import FS_PROTOCOL, FileService
+from ....services.file_service.file_utils import starts_with_fs_url
+
+
+class CreateFile(Action):
+    """Action to create a new file in file service"""
+
+    def __init__(self, **kwargs):
+
+        super().__init__(
+            {
+                "name": "create_file",
+                "prompt_directive": f"Creates a new persisted file and returns the file block with {FS_PROTOCOL} URL",
+                "params": [
+                    {
+                        "name": "name",
+                        "desc": "File name (required) - must have an extension. Eg: file.csv",
+                        "type": "string",
+                    },
+                    {
+                        "name": "content",
+                        "desc": "Content of the file (required)",
+                        "type": "string",
+                    },
+                ],
+                "required_scopes": ["global:create_file:write"],
+            },
+            **kwargs,
+        )
+
+    def invoke(self, params, meta={}) -> ActionResponse:
+        name: str = params.get("name")
+        content: str = params.get("content")
+        session_id: str = meta.get("session_id")
+
+        if not name or not content:
+            return ActionResponse(message="Error: name and content are required.")
+
+        try:
+            # Upload the file
+            file_service = FileService()
+
+            updated_content = content
+            if starts_with_fs_url(updated_content):
+                updated_content = file_service.resolve_url(updated_content, session_id)
+            else:
+                updated_content = file_service.resolve_all_resolvable_urls(updated_content, session_id)
+
+            if isinstance(updated_content, str):
+                updated_content = updated_content.encode("utf-8")
+
+            file_meta = file_service.upload_from_buffer(
+                updated_content,
+                name,
+                session_id,
+                data_source="Global Agent - Create File Action",
+            )
+        except Exception as e:
+            log.error("Failed to upload file %s: %s", name, str(e))
+            return ActionResponse(message=f"Failed to upload the file: {name}")
+
+        file_block = file_service.get_file_block_by_metadata(file_meta)
+        return ActionResponse(
+            message=f"Following file has been created:\n\n{file_block}",
+        )

solace_agent_mesh/agents/global/actions/error_action.py

@@ -0,0 +1,45 @@
+"""Action to handle errors from the system"""
+
+from solace_ai_connector.common.log import log
+
+from ....common.action import Action
+from ....common.action_response import (
+    ActionResponse,
+    ErrorInfo,
+    WithContextQuery,
+)
+
+
+class ErrorAction(Action):
+    def __init__(self, **kwargs):
+        super().__init__(
+            {
+                "name": "error_action",
+                "prompt_directive": "Raise an error message",
+                "params": [
+                    {
+                        "name": "error_message",
+                        "desc": "The error to send to the user",
+                        "type": "string",
+                    }
+                ],
+                "required_scopes": ["*:*:*"],
+            },
+            **kwargs,
+        )
+
+    def invoke(self, params, meta={}) -> ActionResponse:
+        error_message = params.get("error_message")
+        if error_message:
+            log.error("Raising error: %s", error_message)
+            # If the error_message contains "Failed to parse response",
+            # then return a response requesting a redo from the LLM
+            if "Failed to parse response" in error_message:
+                return ActionResponse(
+                    context_query=WithContextQuery(
+                        context_type="statement",
+                        context="Your response was not correctly formated and parsing failed. Please try again but don't comment on the parsing problem in your response.",
+                        query="",
+                    )
+                )
+            return ActionResponse(error_info=ErrorInfo(error_message=error_message))