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

solace_agent_mesh/agents/base_agent_component.py

@@ -1,256 +0,0 @@
-"""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 ..common.constants import ORCHESTRATOR_COMPONENT_NAME
-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 _handle_action_validation(self, action_name, data):
-        if not action_name:
-            log.error("Action name not provided. Data: %s", json.dumps(data))
-            return ActionResponse(
-                message="Internal error: Action name not provided. Please try again",
-            )
-        action = self.action_list.get_action(action_name)
-        if not action:
-            log.error(
-                "Action not found: %s. Data: %s", action_name, json.dumps(data)
-            )
-            return ActionResponse(
-                message="Internal error: Action not found. Please try again",
-            )
-        return action
-
-    def _resolve_action_parameters(self, params, session_id, data, file_service):
-        try:
-            resolved_params = recursive_file_resolver(
-                params,
-                resolver=file_service.resolve_all_resolvable_urls,
-                session_id=session_id,
-            )
-            return resolved_params, None
-        except Exception as e:
-            log.error(
-                "Error resolving file service URLs: %s. Data: %s",
-                str(e),
-                json.dumps(data),
-                exc_info=True,
-            )
-            return params, ActionResponse(
-                message=f"Error resolving file URLs. Details: {str(e)}",
-            )
-
-    def _execute_action(self, action, resolved_params, user_properties, action_name, data):
-        session_id = user_properties.get("session_id")
-        identity = user_properties.get("identity")
-        middleware_service = MiddlewareService()
-
-        if not middleware_service.get("base_agent_filter")(user_properties, action):
-            log.warning(
-                "Unauthorized access attempt for action %s. Data: %s",
-                action_name,
-                json.dumps(data),
-            )
-            return ActionResponse(
-                message="Unauthorized: You don't have permission to perform this action.",
-            )
-        try:
-            meta = {
-                "session_id": session_id,
-                "identity": identity,
-            }
-            return 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)
-            return ActionResponse(
-                message=f"Internal error: {type(e).__name__} - Error invoking action. Details: {str(e)}",
-                error_info=ErrorInfo(
-                    error_message=error_message,
-                ),
-            )
-
-    def _prepare_response_payload(self, action_response, action_name, data):
-        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", {})
-        action_response.originator = data.get("originator", ORCHESTRATOR_COMPONENT_NAME)
-        try:
-            return 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,
-            )
-            return {
-                "message": "Internal error: Error converting action response to dict",
-            }
-
-    def invoke(self, message, data):
-        """Invoke the component"""
-        action_name = data.get("action_name")
-        file_service = FileService()
-
-        validation_result = self._handle_action_validation(action_name, data)
-        if isinstance(validation_result, ActionResponse):
-            action_response_dict = self._prepare_response_payload(validation_result, action_name, data)
-            response_topic = f"{os.getenv('SOLACE_AGENT_MESH_NAMESPACE')}solace-agent-mesh/v1/actionResponse/agent/{self.info['agent_name']}/{action_name or 'unknown'}"
-            return {"payload": action_response_dict, "topic": response_topic}
-        
-        action = validation_result
-        
-        resolved_params = data.get("action_params", {}).copy()
-        user_properties = message.get_user_properties() or {}
-        session_id = user_properties.get("session_id")
-
-        resolved_params, file_error_response = self._resolve_action_parameters(
-            resolved_params, session_id, data, file_service
-        )
-        if file_error_response:
-            action_response_dict = self._prepare_response_payload(file_error_response, action_name, data)
-            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}
-
-        action_response = self._execute_action(
-            action, resolved_params, user_properties, action_name, data
-        )
-
-        action_response_dict = self._prepare_response_payload(action_response, action_name, data)
-        
-        # 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

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

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

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

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

@@ -1,45 +0,0 @@
-"""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))