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

solace_agent_mesh/agents/slack/actions/post_message.py

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

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

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

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

solace_agent_mesh/agents/web_request/actions/do_suggestion_search.py

@@ -0,0 +1,34 @@
+"""Web Request action"""
+
+from duckduckgo_search import DDGS
+
+from ....common.action import Action
+from ....common.action_response import ActionResponse
+
+
+class DoSuggestionSearch(Action):
+
+    def __init__(self, **kwargs):
+        super().__init__(
+            {
+                "name": "do_suggestion_search",
+                "prompt_directive": "Browse the web and get suggestions for the search query especially on new or unfamiliar topics.",
+                "params": [
+                    {
+                        "name": "query",
+                        "desc": "The search query to use",
+                        "type": "string",
+                    }
+                ],
+                "required_scopes": ["web_request:do_suggestion_search:read"],
+            },
+            **kwargs,
+        )
+
+    def invoke(self, params, meta={}) -> ActionResponse:
+        query = params.get("query")
+        if not query:
+            return ActionResponse(message="ERROR: Query not found!")
+        content = DDGS().suggestions(query)
+
+        return ActionResponse(message=content)

solace_agent_mesh/agents/web_request/actions/do_web_request.py

@@ -0,0 +1,134 @@
+"""Web Request action"""
+
+from solace_ai_connector.common.log import log
+import requests
+from bs4 import BeautifulSoup
+import html2text
+
+
+from ....common.action import Action
+from ....common.action_response import ActionResponse
+
+
+class DoWebRequest(Action):
+
+    def __init__(self, **kwargs):
+        super().__init__(
+            {
+                "name": "do_web_request",
+                "prompt_directive": "Fetch content from a URL and process it according to a specified LLM prompt. Returns processed content from a single web request. For comprehensive data gathering, multiple requests may be needed to follow relevant links.",
+                "params": [
+                    {
+                        "name": "url",
+                        "desc": "URL to fetch",
+                        "type": "string",
+                    },
+                    {
+                        "name": "llm_prompt",
+                        "desc": "Text prompt to direct the LLM on how to process the fetched content. If this parameter is not provided, the fetched content will be returned as is.",
+                        "type": "string",
+                    },
+                ],
+                "required_scopes": ["web_request:do_web_request:read"],
+                "examples": [
+                    """    <example>
+        <example_docstring>
+            This is an example of a user requesting to fetch information from the web. The web_request agent is open so invoke the do_web_request action to fetch the content from the url and process the information according to the llm_prompt.
+        </example_docstring>
+        <example_stimulus>
+            <{tp}stimulus starting_id="10"/>
+            What is the weather in Ottawa?
+            </{tp}stimulus>
+            <{tp}stimulus_metadata>
+            local_time: 2024-11-06 12:33:12 EST-0500 (Wednesday)
+            </{tp}stimulus_metadata>
+        </example_stimulus>
+        <example_response>
+            <{tp}reasoning>
+            - User is asking for current weather information in Ottawa
+            - We need to fetch up-to-date weather data
+            - Use the web_request agent to get the latest weather information
+            - Plan to use the Environment Canada website for accurate local weather data
+            </{tp}reasoning>
+
+            Certainly! I\'ll fetch the current weather information for Ottawa for you right away.
+
+            <{tp}invoke_action agent="web_request" action="do_web_request">
+            <{tp}parameter name="url">https://weather.gc.ca/city/pages/on-118_metric_e.html</{tp}parameter>
+            <{tp}parameter name="llm_prompt">Extract the current temperature, weather conditions, and any important weather alerts or warnings for Ottawa from the webpage. Format the response as a bulleted list with emoji where appropriate.</{tp}parameter>
+            </{tp}invoke_action>
+
+            <{tp}status_update>Retrieving the latest weather data for Ottawa...</{tp}status_update>'
+        </example_response>
+    </example>
+"""
+                ],
+            },
+            **kwargs,
+        )
+
+    def get_system_prompt(self):
+        return """
+        The assistant is a professional web researcher. It will take the URL and request below and 
+        will diligently extract the requested information from that URL. Sometimes the page does
+        not have the information requested, but it might be on a different page that is linked to
+        from this page. In that case the assistant will indicate the page doesn't have the information
+        but it will provide other links to try for the information.
+        
+        The assistant will also include a section of 'interesting links' that it found on the page
+        that might be useful for further research. These links must be from the page and not from
+        the assistant's own knowledge.
+        
+        The assistant will respond in markdown format.
+        """
+
+    def get_user_prompt(self, url, content, prompt):
+        return f"""
+        <page_url>{url}</page_url>
+        <research_request>
+        {prompt}
+        </research_request>
+        <page_content_markdown>
+        {content}
+        </page_content_markdown>
+        """
+
+    def invoke(self, params, meta={}) -> ActionResponse:
+        url = params.get("url")
+        prompt = params.get("llm_prompt")
+
+        if not url:
+            return ActionResponse(message="URL is required")
+
+        # Fetch the content from the URL
+        try:
+            response = requests.get(url, timeout=30)
+            response.raise_for_status()
+        except Exception as e:
+            return ActionResponse(message=f"Failed to fetch content from URL: {e}")
+
+        # Use beautiful soup to extract the text content from the HTML
+        soup = BeautifulSoup(response.content, "html.parser")
+
+        # Convert the HTML content to Markdown using html2text
+        h = html2text.HTML2Text()
+        h.ignore_links = False  # Ensure that links are preserved
+        h.ignore_images = False  # Ignore images
+        content = h.handle(str(soup))
+
+        # If a prompt is provided, send the content to an LLM model
+        if prompt:
+            system_prompt = self.get_system_prompt()
+            user_prompt = self.get_user_prompt(url, content, prompt)
+
+            messages = [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt},
+            ]
+
+            agent = self.get_agent()
+            response = agent.do_llm_service_request(messages=messages)
+            content = response.get("content")
+
+        # Code to create the image using the provided content
+        return ActionResponse(message=content)

solace_agent_mesh/agents/web_request/actions/download_file.py

@@ -0,0 +1,69 @@
+"""File Request action"""
+
+from solace_ai_connector.common.log import log
+import requests
+from io import BytesIO
+
+
+from ....common.action import Action
+from ....common.action_response import ActionResponse
+from ....services.file_service import FileService, FS_PROTOCOL
+
+
+class DownloadFile(Action):
+
+    def __init__(self, **kwargs):
+        super().__init__(
+            {
+                "name": "download_external_file",
+                "prompt_directive": f"Given a http/https external URL of a file (image, video, etc.), fetch the content from the URL and add the file to the {FS_PROTOCOL} file service so it can be used in the system.",
+                "params": [
+                    {
+                        "name": "url",
+                        "desc": "URL of file",
+                        "type": "string",
+                    },
+                    {
+                        "name": "local_file_name",
+                        "desc": "Local file name to use for the file - make sure it has the correct extension",
+                        "type": "string",
+                    },
+                ],
+                "required_scopes": ["web_request:download_file:write"],
+            },
+            **kwargs,
+        )
+
+    def invoke(self, params, meta={}) -> ActionResponse:
+        url = params.get("url")
+        local_file_name = params.get("local_file_name")
+
+        if not url:
+            return ActionResponse(message="URL is required")
+
+        headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:128.0) Gecko/20100101 Firefox/128.0"}
+
+        # Fetch the file from the URL and write it in chunks
+        files = []
+        try:
+            with requests.get(url, headers=headers, stream=True, timeout=30) as file_response:
+                file_response.raise_for_status()
+                byte_io = BytesIO()
+                for chunk in file_response.iter_content(chunk_size=8192):
+                    if chunk:  # Filter out keep-alive new chunks
+                        byte_io.write(chunk)
+                byte_io.seek(0)
+                file_service = FileService()
+                meta = file_service.upload_from_buffer(
+                    byte_io.read(),
+                    local_file_name,
+                    meta.get("session_id"),
+                    data_source="Web Request Agent - Download File Action",
+                )
+                files.append(meta)
+        except requests.exceptions.HTTPError as e:
+            return ActionResponse(message=f"Failed to fetch file from URL: {e}")
+        except Exception as e:
+            return ActionResponse(message=f"An error occurred: {e}")
+
+        return ActionResponse(files=files)

solace_agent_mesh/agents/web_request/web_request_agent_component.py

@@ -0,0 +1,33 @@
+"""Responsible for processing the actions from the Web Request Agent"""
+
+import copy
+
+from ..base_agent_component import (
+    agent_info,
+    BaseAgentComponent,
+)
+
+from .actions.do_web_request import DoWebRequest
+from .actions.download_file import DownloadFile
+from .actions.do_image_search import DoImageSearch
+from .actions.do_news_search import DoNewsSearch
+from .actions.do_suggestion_search import DoSuggestionSearch
+
+info = copy.deepcopy(agent_info)
+info["agent_name"] = "web_request"
+info["class_name"] = "WebRequestAgentComponent"
+info["description"] = (
+    "Web request agent that is able to download and retrieve info from urls. ",
+    "It can also search the web for news, images and suggestion results with the DuckDuckGo search engine.",
+)
+
+
+class WebRequestAgentComponent(BaseAgentComponent):
+    info = info
+    actions = [
+        DoWebRequest,
+        DownloadFile,
+        DoImageSearch,
+        DoNewsSearch,
+        DoSuggestionSearch,
+    ]