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

solace_agent_mesh/agents/global/actions/plantuml_diagram.py

@@ -0,0 +1,93 @@
+"""PlantUML diagram"""
+
+import os
+import tempfile
+import subprocess
+
+from solace_ai_connector.common.log import log
+from ....common.action import Action
+from ....common.action_response import ActionResponse
+from ....services.file_service import FileService
+
+PLANTUML_PROMPT = """Generate a PlantUML markup language for the given description by the user. Supports sequence diagrams, class diagrams, use case diagrams, activity diagrams, component diagrams, state diagrams, and timing diagrams. Newlines must be escaped with a backslash and put quotes around participants names. Respond only with PlantUML markup, do not include any other text, symbols or quotes.
+Rules to follow for sequence diagrams:
+    - Do not use variables if they are not declared as participants.
+    - Only use notes to cover one or two participants per line.
+    - Do not use the `activate` or `deactivate` commands directly after a delay notation (`...`), whether directly or with a note in between.
+    - Do not use the `activate` or `deactivate` commands twice in a row, whether directly or with a note in between.
+"""
+
+
+class PlantUmlDiagram(Action):
+
+    def __init__(self, **kwargs):
+        super().__init__(
+            {
+                "name": "plantuml",
+                "prompt_directive": (
+                    "Generate PlantUML diagrams using description. Supports sequence diagrams, class diagrams, "
+                    "use case diagrams, activity diagrams, component diagrams, state diagrams, and timing diagrams."
+                ),
+                "params": [
+                    {
+                        "name": "diagram_description",
+                        "desc": "The detailed description of the diagram to be generated in natural English language.",
+                        "type": "string",
+                    }
+                ],
+                "required_scopes": ["global:plantuml:read"],
+            },
+            **kwargs,
+        )
+
+    def invoke(self, params, meta={}) -> ActionResponse:
+        # Do a local command to run plantuml -tpng
+        description = params.get("diagram_description")
+        agent = self.get_agent()
+        messages = [
+            {"role": "system", "content": PLANTUML_PROMPT},
+            {"role": "user", "content": description},
+        ]
+        agent = self.get_agent()
+        response = agent.do_llm_service_request(messages=messages)
+        expression = response.get("content")
+
+        # Surround expression with @startuml and @enduml if missing
+        if not expression.startswith("@startuml"):
+            expression = f"@startuml\n{expression}"
+        if not expression.endswith("@enduml"):
+            expression = f"{expression}\n@enduml"
+        log.debug("PlantUML expression: %s", expression)
+        img_path = None
+        files = []
+        with tempfile.NamedTemporaryFile(delete=True) as temp:
+            temp.write(expression.encode())
+            temp.flush()
+            dir_path = os.path.dirname(temp.name)
+            img_path = f"{dir_path}/{os.path.basename(temp.name)}.png"
+
+            try:
+                subprocess.run(
+                    ["plantuml", "-tpng", temp.name, "-o", dir_path],
+                    check=True,
+                    capture_output=True,
+                    text=True,
+                )
+                file_service = FileService()
+                file_meta = file_service.upload_from_file(
+                    img_path,
+                    meta.get("session_id"),
+                    data_source="Global Agent - PlantUML Action",
+                )
+                files.append(file_meta)
+
+            except subprocess.CalledProcessError as e:
+                log.error("Subprocess failed with stderr: %s", e.stderr)
+                return ActionResponse(
+                    message=f"Failed to create diagram: {e.stderr}",
+                )
+
+        return ActionResponse(
+            message=f"diagram created with the plantUML: \n```\n{expression}\n```",
+            files=files,
+        )

solace_agent_mesh/agents/global/actions/plotly_graph.py

@@ -0,0 +1,117 @@
+"""Plotly graph generation"""
+
+import os
+import random
+import tempfile
+import json
+import yaml
+from io import BytesIO
+from solace_ai_connector.common.log import log
+
+import plotly.graph_objects as go
+import plotly.io as pio
+
+from ....common.action import Action
+from ....common.action_response import ActionResponse
+from ....services.file_service import FileService
+
+
+class PlotlyGraph(Action):
+
+    def __init__(self, **kwargs):
+        super().__init__(
+            {
+                "name": "plotly",
+                "prompt_directive": (
+                    "Create a plotly graph from the given plotly figure configuration. Note that this will be rendered as a static image that can't be interacted with."
+                ),
+                "params": [
+                    {
+                        "name": "plotly_figure_config",
+                        "desc": "The plotly figure configuration as a yaml object (do not give python code, just the yaml object)",
+                        "type": "object",
+                    }
+                ],
+                "required_scopes": ["global:plotly:read"],
+                "examples": [
+                    """    <example>
+        <example_docstring>
+            This is an example of a user asking for a bar graph. The plotly action from the global agent is invoked to generate the graph.
+        </example_docstring>
+        <example_stimulus>
+            <{tp}stimulus starting_id="12">
+            Please generate a random bar graph for me
+            </{tp}stimulus>
+            <{tp}stimulus_metadata>
+            local_time: 2024-09-04 15:59:02 EDT-0400 (Wednesday)
+            </{tp}stimulus_metadata>
+        </example_stimulus>
+        <example_response>
+            <{tp}reasoning>
+            - user has requested a random bar graph
+            - invoke the plotly action from the global agent to generate a bar graph with random data
+            </{tp}reasoning>
+            Certainly! I'd be happy to generate a random bar graph for you.
+            <{tp}status_update>I'll use our plotting tool to create this for you right away.</{tp}status_update>
+            <{tp}invoke_action agent="global" action="plotly">
+            <{tp}parameter name="plotly_figure_config">
+            {{
+                "data": [
+                {{
+                    "x": ["A", "B", "C", "D", "E"],
+                    "y": [23, 45, 56, 78, 90],
+                    "type": "bar"
+                }}
+                ],
+                "layout": {{
+                "title": "Random Bar Graph",
+                "xaxis": {{"title": "Categories"}},
+                "yaxis": {{"title": "Values"}}
+                }}
+            }}
+            </{tp}parameter>
+            </{tp}invoke_action>
+        </example_response>
+    </example>
+"""
+                ],
+            },
+            **kwargs,
+        )
+
+    def invoke(self, params, meta={}) -> ActionResponse:
+        obj = params["plotly_figure_config"]
+        if isinstance(obj, str):
+            # Remove any leading/trailing quote characters
+            obj = obj.strip("'\" ")
+            try:
+                obj = json.loads(obj)
+            except:  # pylint: disable=bare-except
+                try:
+                    obj = yaml.safe_load(obj)
+                except Exception:  # pylint: disable=broad-except
+                    return ActionResponse(
+                        message=f"Could not parse plotly figure configuration: {obj}\n\nNOTE that this action expects a config object, not code.",
+                    )
+
+        files = []
+        try:
+            fig = go.Figure(obj)
+            byte_io = BytesIO()
+            pio.write_image(fig, byte_io)
+            byte_io.seek(0)
+            file_service = FileService()
+            image_name = "generated_graph_" + str(random.randint(100000, 999999)) + ".png"
+            image_meta = file_service.upload_from_buffer(
+                byte_io.read(),
+                image_name,
+                meta.get("session_id"),
+                data_source="Global Agent - PlotlyGraph Action",
+            )
+            files.append(image_meta)
+        except Exception as e:
+            return ActionResponse(
+                message="Could not create plotly graph. Please check the plotly figure configuration. plotly error: " + str(e),
+            )
+
+        return ActionResponse(files=files)

solace_agent_mesh/agents/global/actions/retrieve_file.py

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

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

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

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

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

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

solace_agent_mesh/agents/slack/actions/__init__.py

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