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

solace_agent_mesh/agents/global/actions/retrieve_file.py

@@ -1,51 +0,0 @@
-"""Retrieve File content action"""
-
-from solace_ai_connector.common.log import log
-import re
-import json
-
-from ....common.action import Action
-from ....common.action_response import ActionResponse, InlineFile
-from ....services.file_service import FS_PROTOCOL, FS_URL_REGEX, FileService
-
-
-class RetrieveFile(Action):
-    def __init__(self, **kwargs):
-        super().__init__(
-            {
-                "name": "retrieve_file",
-                "prompt_directive": f"Retrieve the content of a text based file form a {FS_PROTOCOL} URL",
-                "params": [
-                    {
-                        "name": "url",
-                        "desc": f'The "{FS_PROTOCOL}://" url of the file (Optionally with query parameters - Without "resolve" parameter)',
-                        "type": "string",
-                    }
-                ],
-                "required_scopes": ["global:retrieve_file:read"],
-            },
-            **kwargs,
-        )
-
-    def invoke(self, params, meta={}) -> ActionResponse:
-        # Extract the URL from the text
-        url = params.get("url")
-        # validate the URL
-        if not url or not re.match(FS_URL_REGEX, url):
-            return ActionResponse(message=f"Invalid {FS_PROTOCOL} URL provided.")
-
-        try:
-            # Download the file
-            file_service = FileService()
-            file, _, file_meta = file_service.resolve_url(url, meta.get("session_id"), return_extra=True)
-            file = file.decode("utf-8", errors="ignore") if type(file) == bytes else file
-        except Exception as e:
-            log.error("Failed to download file from the url %s: %s", url, str(e))
-            return ActionResponse(message=f"Failed to download the file from the URL: {url}")
-
-        max_allowed_size = self.get_config("max_allowed_file_retrieve_size", None)
-        if max_allowed_size and len(file) > max_allowed_size:
-            return ActionResponse(message=f"Error: File too large. File size exceeds the maximum allowed size of {max_allowed_size} bytes.")
-
-        inline_file = InlineFile(content=file, name=file_meta.get("name", "unknown.txt"))
-        return ActionResponse(message=f"Returning content of the file {url}.", inline_files=[inline_file])

solace_agent_mesh/agents/global/global_agent_component.py

@@ -1,38 +0,0 @@
-"""The agent component for the global actions"""
-
-import copy
-
-from ..base_agent_component import (
-    agent_info,
-    BaseAgentComponent,
-)
-
-from .actions.agent_state_change import AgentStateChangeAction
-from .actions.clear_history import ClearHistory
-from .actions.error_action import ErrorAction
-from .actions.plantuml_diagram import PlantUmlDiagram
-from .actions.plotly_graph import PlotlyGraph
-from .actions.retrieve_file import RetrieveFile
-from .actions.create_file import CreateFile
-from .actions.convert_file_to_markdown import ConvertFileToMarkdown
-
-
-info = copy.deepcopy(agent_info)
-info["agent_name"] = "global"
-info["class_name"] = "GlobalAgentComponent"
-info["description"] = "Global agent."
-info["always_open"] = True
-
-
-class GlobalAgentComponent(BaseAgentComponent):
-    info = info
-    actions = [
-        AgentStateChangeAction,
-        ClearHistory,
-        ErrorAction,
-        PlantUmlDiagram,
-        PlotlyGraph,
-        RetrieveFile,
-        CreateFile,
-        ConvertFileToMarkdown
-    ]

solace_agent_mesh/agents/image_processing/actions/create_image.py

@@ -1,75 +0,0 @@
-"""Image Creation action"""
-
-from solace_ai_connector.common.log import log
-import random
-import requests
-import base64
-
-from litellm import image_generation
-
-from ....common.action import Action
-from ....common.action_response import ActionResponse
-from ....services.file_service import FileService
-
-
-class ImageCreation(Action):
-
-    def __init__(self, **kwargs):
-        super().__init__(
-            {
-                "name": "create_image",
-                "prompt_directive": "Create an image",
-                "params": [
-                    {
-                        "name": "image_description",
-                        "desc": "The prompt to use to create the image",
-                        "type": "string",
-                    }
-                ],
-                "required_scopes": ["image_processing:create_image:create"],
-            },
-            **kwargs,
-        )
-
-    def _get_image_content(self, image_data):
-        """Helper function to extract image content from response data"""
-        if 'url' in image_data and image_data['url'] is not None:
-            return requests.get(image_data['url'], timeout=10).content
-        elif 'b64_json' in image_data and image_data['b64_json'] is not None:
-            return base64.b64decode(image_data['b64_json'])
-        else:
-            raise ValueError("No valid image data found in response")
-
-    def invoke(self, params, meta={}) -> ActionResponse:
-        prompt = params.get("image_description")
-        if not prompt:
-            return ActionResponse(message="Image description is required")
-        try:
-            response = image_generation(
-                model=self.get_config("image_gen_model") or None,
-                api_base=self.get_config("image_gen_endpoint") or None,
-                api_key=self.get_config("image_gen_api_key") or None,
-                prompt=prompt,
-                n=1,
-                **self.get_config("image_gen_litellm_config", {}),
-            )
-        except Exception as e:
-            log.error(f"Error generating image:", e)
-            return ActionResponse(message=f"Error generating image, {str(e)}")
-
-        try:
-            generated_image = self._get_image_content(response.get("data")[0])
-        except Exception as e:
-            log.error(f"Error retrieving image content:", e)
-            return ActionResponse(message=f"Error retrieving image content: {str(e)}")
-
-        file_service = FileService()
-        image_name = "generated_image_" + str(random.randint(100000, 999999)) + ".png"
-        image_meta = file_service.upload_from_buffer(
-            generated_image,
-            image_name,
-            meta.get("session_id"),
-            data_source="Image Processing Agent - Image Creation Action",
-        )
-
-        return ActionResponse(files=[image_meta])

solace_agent_mesh/agents/image_processing/actions/describe_image.py

@@ -1,115 +0,0 @@
-"""Image Description action"""
-
-from solace_ai_connector.common.log import log
-import re
-import random
-import requests
-from io import BytesIO
-
-
-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 DescribeImage(Action):
-
-    def __init__(self, **kwargs):
-        super().__init__(
-            {
-                "name": "describe_image",
-                "prompt_directive": "Describe an image",
-                "params": [
-                    {
-                        "name": "image_url",
-                        "desc": f'The "{FS_PROTOCOL}://" or "https://" url of the image to describe',
-                        "type": "string",
-                    }
-                ],
-                "required_scopes": ["image_processing:describe_image:create"],
-            },
-            **kwargs,
-        )
-
-    def extract_url_from_text(self, text: str) -> str:
-        """
-        Extracts the first URL from a given text.
-        """
-        url = None
-        # URL Regex pattern
-        # Starts with https:// or http:// or FS_PROTOCOL://
-        # ends with space or newline or end of string
-        url_pattern = r"(https?|{}):\/\/\S+".format(FS_PROTOCOL)
-        match = re.search(url_pattern, text)
-        if match:
-            url = match.group()
-        return url
-
-    def download_image(self, image_url: str, session_id: str) -> str:
-        """
-        Download the image using the provided image URL.
-        """
-        url = image_url
-        if not starts_with_fs_url(url):
-            # Download the image and upload to the file service
-            file_service = FileService()
-            byte_buffer = BytesIO(requests.get(image_url).content)
-            metadata = file_service.upload_from_buffer(
-                byte_buffer.read(),
-                str(random.randint(100000, 999999)) + "_image.png",
-                session_id,
-                data_source="Image Processing Agent - Describe Image Action",
-            )
-            url = metadata.get("url")
-
-        base64_image_url = f"{url}?encoding=datauri&resolve=true"
-        return base64_image_url
-
-    def get_image_description(self, base64_image_url: str) -> str:
-        """
-        Get the description of the image using the provided image URL.
-        """
-        agent = self.get_agent()
-        content = agent.do_llm_service_request(
-            [
-                {
-                    "role": "user",
-                    "content": [
-                        {
-                            "type": "text",
-                            "text": "describe the content of this image in detail",
-                        },
-                        {
-                            "type": "image_url",
-                            "image_url": {"url": base64_image_url},
-                        },
-                    ],
-                }
-            ],
-            resolve_files=True,
-        ).get("content")
-
-        return content
-
-    def invoke(self, params, meta={}) -> ActionResponse:
-        log.debug("Describing image: %s", params.get("image_url"))
-        # Extract the URL from the text
-        url = self.extract_url_from_text(params.get("image_url", ""))
-        if not url:
-            return ActionResponse(message="No image URL found in the query.")
-
-        try:
-            # Download the image
-            image_url = self.download_image(url, meta.get("session_id"))
-        except Exception as e:
-            log.error("Failed to download image from the url %s: %s", url, str(e))
-            return ActionResponse(message=f"Failed to download the image from the URL: {url}")
-
-        try:
-            # Get the image description
-            description = self.get_image_description(image_url)
-            return ActionResponse(message=description)
-        except Exception as e:
-            log.error("Failed to describe image in %s: %s", url, str(e))
-            return ActionResponse(message=f"Failed to describe the image in {url}.")

solace_agent_mesh/agents/image_processing/image_processing_agent_component.py

@@ -1,23 +0,0 @@
-"""Responsible for processing the actions from the Image Processing Agent"""
-
-import copy
-
-from ..base_agent_component import (
-    agent_info,
-    BaseAgentComponent,
-)
-
-from .actions.create_image import ImageCreation
-from .actions.describe_image import DescribeImage
-
-info = copy.deepcopy(agent_info)
-info["agent_name"] = "image_processing"
-info["class_name"] = "ImageProcessingAgentComponent"
-info["description"] = "Image Processing agent. This can generate images from text or describe images to text"
-
-
-class ImageProcessingAgentComponent(
-    BaseAgentComponent
-):
-    info = info
-    actions = [ImageCreation, DescribeImage]

solace_agent_mesh/agents/slack/__init__.py

@@ -1 +0,0 @@
-"""Slack agent package."""

solace_agent_mesh/agents/slack/actions/__init__.py

@@ -1 +0,0 @@
-"""Slack agent actions."""

solace_agent_mesh/agents/slack/actions/post_message.py

@@ -1,177 +0,0 @@
-"""Slack Post Message action."""
-
-from typing import Dict, List, Union
-
-from solace_ai_connector.common.log import log
-from ....common.action import Action
-from ....common.time import FIVE_MINUTES
-from ....common.action_response import ActionResponse
-from ....services.file_service import FileService, FS_PROTOCOL
-
-
-class PostMessage(Action):
-    """Action for posting messages to Slack channels."""
-
-    def __init__(self, **kwargs):
-        """Initialize the action with its configuration."""
-        super().__init__(
-            {
-                "name": "post_message",
-                "prompt_directive": "Post a message to a Slack channel",
-                "params": [
-                    {
-                        "name": "channel",
-                        "desc": "The Slack channel to post to (include # prefix)",
-                        "type": "string",
-                    },
-                    {
-                        "name": "thread_correlation_id",
-                        "desc": "Optional correlation ID to group messages in a thread",
-                        "type": "string",
-                    },
-                    {
-                        "name": "text",
-                        "desc": "Text message to post",
-                        "type": "string",
-                    },
-                    {
-                        "name": "blocks",
-                        "desc": "Slack blocks for formatted message",
-                        "type": "array",
-                    },
-                    {
-                        "name": "files",
-                        "desc": f"Array of file URLs ({FS_PROTOCOL}:// or inline files with <file><data/></file> tags)",
-                        "type": "array",
-                    },
-                    {
-                        "name": "last_post_to_thread",
-                        "desc": "If True, clears the thread correlation cache after posting",
-                        "type": "bool",
-                    },
-                ],
-                "required_scopes": ["slack:post_message:create"],
-            },
-            **kwargs,
-        )
-
-    def _process_files(
-        self, files: List[str], session_id: str
-    ) -> List[Dict[str, Union[str, bytes]]]:
-        """Process file URLs into uploadable content.
-
-        Args:
-            files: List of file URLs to process
-            session_id: Current session ID for file service
-
-        Returns:
-            List of dicts containing file data and titles
-        """
-        if not files:
-            return []
-
-        file_service = FileService()
-        processed_files = []
-
-        for file_url in files:
-            try:
-                # Download file content
-                content = file_service.download_to_buffer(file_url, session_id)
-
-                # Extract filename from URL
-                filename = file_url.split("/")[-1]
-                processed_files.append(
-                    {
-                        "content": content,
-                        "title": filename,
-                    }
-                )
-            except Exception as e:
-                log.error("Failed to process file %s: %s", file_url, str(e))
-
-        return processed_files
-
-    def invoke(self, params: Dict, meta: Dict = {}) -> ActionResponse:
-        """Post message to Slack channel.
-
-        Args:
-            params: Action parameters including channel, message, etc.
-            meta: Additional metadata including session_id
-
-        Returns:
-            ActionResponse with success/error message
-        """
-        try:
-            # Get Slack client from agent
-            slack_client = self.get_agent().slack_client
-
-            channel = params.get("channel", "").strip()
-
-            # Remove the # prefix if present
-            if channel.startswith("#"):
-                channel = channel[1:]
-
-            # Get thread_ts from correlation id if provided
-            thread_correlation_id = params.get("thread_correlation_id")
-            thread_ts = None
-            if thread_correlation_id:
-                cache_key = f"slack_agent:thread_correlation:{thread_correlation_id}"
-                thread_ts = self.get_agent().cache_service.get_data(cache_key)
-
-            # Prepare message arguments
-            msg_args = {
-                "channel": channel,
-                "text": params.get("text", ""),
-                "blocks": params.get("blocks"),
-                "thread_ts": thread_ts,
-            }
-
-            # Send message
-            response = slack_client.chat_postMessage(**msg_args)
-
-            # Handle thread correlation caching
-            if thread_correlation_id:
-                cache_key = f"slack_agent:thread_correlation:{thread_correlation_id}"
-
-                # Clear cache if this is the last post
-                if params.get("last_post_to_thread"):
-                    self.get_agent().cache_service.remove_data(cache_key)
-                # Store thread_ts if this is a new thread
-                elif not thread_ts:
-                    thread_cache_ttl = self.get_agent().get_config("thread_cache_ttl")
-                    self.get_agent().cache_service.add_data(
-                        cache_key,
-                        response["ts"],
-                        expiry=thread_cache_ttl,
-                        component=self.get_agent(),
-                    )
-                    msg_args["thread_ts"] = response["ts"]
-
-            # Process any files
-            files = params.get("files", [])
-            if files:
-                processed_files = self._process_files(files, meta.get("session_id"))
-                for file_data in processed_files:
-                    slack_client.files_upload_v2(
-                        channel=channel,
-                        content=file_data["content"],
-                        title=file_data["title"],
-                        thread_ts=msg_args["thread_ts"],
-                    )
-
-            # Return thread_correlation_id in message for reference
-            return ActionResponse(
-                message=(
-                    f"Successfully posted message to {channel}. "
-                    f"Thread correlation ID: {thread_correlation_id or 'none'}"
-                    + (
-                        f" (thread_ts: {response['ts']})"
-                        if not thread_ts
-                        else f" (replied to existing thread)"
-                    )
-                )
-            )
-
-        except Exception as e:
-            log.error("Failed to post Slack message: %s", str(e))
-            return ActionResponse(message=f"Failed to post message to Slack: {str(e)}")

solace_agent_mesh/agents/slack/slack_agent_component.py

@@ -1,59 +0,0 @@
-"""Slack agent for posting messages to Slack channels."""
-
-import copy
-from slack_sdk import WebClient
-
-from ..base_agent_component import agent_info, BaseAgentComponent
-from .actions.post_message import PostMessage
-from ...common.time import FIVE_MINUTES
-
-info = copy.deepcopy(agent_info)
-info.update(
-    {
-        "agent_name": "slack",
-        "class_name": "SlackAgentComponent",
-        "description": "Slack messaging agent for posting messages and files to channels",
-        "config_parameters": [
-            {
-                "name": "slack_bot_token",
-                "required": True,
-                "description": "Slack bot user OAuth token",
-                "type": "string",
-            },
-            {
-                "name": "thread_cache_ttl",
-                "required": False,
-                "description": f"Time-to-live in seconds for thread correlation cache (default: {FIVE_MINUTES} seconds)",
-                "type": "integer",
-                "default": FIVE_MINUTES,
-            },
-        ],
-    }
-)
-
-
-class SlackAgentComponent(BaseAgentComponent):
-    """Component for handling Slack messaging operations."""
-
-    info = info
-    actions = [PostMessage]
-
-    def __init__(self, module_info={}, **kwargs):
-        """Initialize the Slack agent component.
-
-        Args:
-            module_info: Optional module configuration.
-            **kwargs: Additional keyword arguments.
-
-        Raises:
-            ValueError: If required Slack configuration is missing.
-        """
-        super().__init__(module_info, **kwargs)
-
-        # Get Slack configuration
-        self.slack_bot_token = self.get_config("slack_bot_token")
-        if not self.slack_bot_token:
-            raise ValueError("Slack bot token is required")
-
-        # Initialize Slack client
-        self.slack_client = WebClient(token=self.slack_bot_token)

solace_agent_mesh/agents/web_request/actions/do_image_search.py

@@ -1,84 +0,0 @@
-"""Web Search action"""
-
-from solace_ai_connector.common.log import log
-import requests
-from duckduckgo_search import DDGS
-
-
-from ....common.action import Action
-from ....common.action_response import ActionResponse
-from ....services.file_service import FileService
-
-
-class DoImageSearch(Action):
-    def __init__(self, **kwargs):
-        super().__init__(
-            {
-                "name": "do_image_search",
-                "prompt_directive": "Search the web for images using a search engine.",
-                "params": [
-                    {
-                        "name": "query",
-                        "desc": "The search query to use",
-                        "type": "string",
-                    },
-                    {
-                        "name": "max_results",
-                        "desc": "Maximum number of results to show, defaults to 3 if not present",
-                        "type": "int",
-                    },
-                    {
-                        "name": "size",
-                        "desc": (
-                            "Size of the image to search for. ",
-                            "Can be one of: small, medium, large, wallpaper or None. Defaults to None if not present",
-                        ),
-                        "type": "string",
-                    },
-                ],
-                "required_scopes": ["web_request:do_image_search:read"],
-            },
-            **kwargs,
-        )
-
-    def image_search(self, keyword, size, max_results) -> list:
-        """
-        Returns a list of dictionaries that represent image results
-        """
-        return DDGS().images(
-            keywords=keyword,
-            region="wt-wt",
-            safesearch="off",
-            size=str(size) or None,
-            color=None,
-            type_image=None,
-            layout=None,
-            license_image=None,
-            max_results=int(max_results),
-        )
-
-    def invoke(self, params, meta={}) -> ActionResponse:
-        query = params.get("query")
-        max_results = params.get("max_results", 3)
-        size = params.get("size")
-        results = []
-        if not query:
-            return ActionResponse(message="ERROR: Query not found!")
-        results = self.image_search(query, size, max_results)  # append text results to results
-        file_service = FileService()
-        image_metas = []
-        for result in results:
-            try:
-                received_image = requests.get(result.get("image"), timeout=10).content
-                log.debug(f"Received image: {result.get('image')}")
-                image_metas.append(
-                    file_service.upload_from_buffer(
-                        received_image,
-                        result.get("title"),
-                        meta.get("session_id"),
-                        data_source="Web Request Agent - Image Search Action",
-                    )
-                )
-            except Exception as e:
-                log.error(f"Failed to download image: {result.get('image')} because {e}")
-        return ActionResponse(files=image_metas)

solace_agent_mesh/agents/web_request/actions/do_news_search.py

@@ -1,47 +0,0 @@
-"""Web Search action"""
-
-from duckduckgo_search import DDGS
-
-
-from ....common.action import Action
-from ....common.action_response import ActionResponse
-
-
-class DoNewsSearch(Action):
-    def __init__(self, **kwargs):
-        super().__init__(
-            {
-                "name": "do_news_search",
-                "prompt_directive": "Search the web for news and current events using a search engine.",
-                "params": [
-                    {
-                        "name": "query",
-                        "desc": "The search query to use",
-                        "type": "string",
-                    },
-                    {
-                        "name": "max_results",
-                        "desc": "Maximum number of results to show, defaults to 5 if not present",
-                        "type": "int",
-                    },
-                ],
-                "required_scopes": ["web_request:do_news_search:read"],
-            },
-            **kwargs,
-        )
-
-    def news_search(self, keyword, max_results) -> list:
-        """
-        Returns a list of dictionaries that represent news results
-        """
-        return DDGS().news(keywords=keyword, region="wt-wt", max_results=int(max_results))
-
-    def invoke(self, params, meta={}) -> ActionResponse:
-        query = params.get("query")
-        max_results = params.get("max_results", 5)
-        results = []
-        if not query:
-            return ActionResponse(message="ERROR: Query not found!")
-        results = self.news_search(query, max_results)  # append text results to results
-
-        return ActionResponse(message=results)