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

solace_agent_mesh/agents/global/actions/plantuml_diagram.py

@@ -1,163 +0,0 @@
-"""PlantUML diagram"""
-
-import platform
-import os
-import tempfile
-import uuid
-import shutil
-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 all diagrams:
-- Always include @startuml at the beginning and @enduml at the end
-- Use simple quotes for names, not double quotes
-- Avoid using <<stereotype>> syntax in state diagrams unless absolutely necessary
-- For state diagrams, use simple state names without spaces (like LoginScreen instead of "Login Screen")
-- If you need descriptive names, use the 'as' keyword (e.g., [*] --> LoginScreen as "Login Screen")
-- Don't use variables if they are not declared
-- Never skip lines
-- For notes in all diagrams:
-    - Use the simple syntax: `note over Participant: Text` without any positioning numbers
-    - Do not use positioning numbers (like `at 25`) in note commands
-    - Never combine multiple participants in a single note
-
-Rules for sequence diagrams:
-- 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
-
-Rules for activity diagrams:
-- Do not use the `backward:` keyword for loops or returning to previous steps
-- Instead, use the label and goto pattern:
-  1. Add a label to the target activity: `label label_name`
-  2. Use goto to reference that label: `goto label_name`
-- Always place labels immediately after the activity they refer to
-- Labels should use lowercase with underscores for readability (e.g., `label browse_products`)
-
-Rules for state diagrams:
-- Use simple state names without spaces and without quotes
-- When stereotypes are absolutely necessary, use the correct syntax:
-  - For existing states: `state StateName <<stereotype>>`
-  - For new states with descriptions: `state "Description" as StateName <<stereotype>>`
-- Always place stereotypes after the state name, not before
-- If using skinparam for stereotype styling, ensure it's properly defined: `skinparam state \{ BackgroundColor<<stereotype>> Color\}
-- For notes in state diagrams:
-  - Do NOT use `note over StateName` syntax (this is for sequence diagrams)
-  - Instead use directional positioning: `note left of StateName`, `note right of StateName`, `note top of StateName`, or `note bottom of StateName`
-  - Example: `note left of OrderCreated : Initial customer order`
-
-Rules for timing diagrams:
-- Never include notes
-- For 'robust' participants, use named states instead of symbolic states
-   - CORRECT: `PS is "ON"` or `PS is ON`
-   - INCORRECT: `PS is {+}` or `PS is {-}`
-- For 'concise' participants, use numeric values (e.g., `BP is 10`)
-"""
-
-
-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()
-        try:
-            response = agent.do_llm_service_request(messages=messages)
-            expression = response.get("content")
-        except TimeoutError as e:
-            log.error("LLM request timed out: %s", str(e))
-            return ActionResponse(message="LLM request timed out")
-        except Exception as e:
-            log.error("Failed to process content with LLM: %s", str(e))
-            return ActionResponse(message="Failed to process content with LLM")
-
-        # 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)
-        files = []
-
-        try:
-            temp_dir = tempfile.mkdtemp()
-            # Create a unique filename with .puml extension
-            diagram_id = str(uuid.uuid4())
-            puml_filename = f"diagram_{diagram_id}.puml"
-            puml_path = os.path.join(temp_dir, puml_filename)
-            png_path = os.path.join(temp_dir, f"diagram_{diagram_id}.png")
-
-            # Write PlantUML content to input file
-            with open(puml_path, 'w', encoding='utf-8') as f:
-                f.write(expression)
-
-            # Run PlantUML
-            subprocess.run(
-                ["plantuml", "-tpng", puml_path, "-o", temp_dir],
-                shell=platform.system() == "Windows",
-                check=True,
-                capture_output=True,
-                text=True,
-            )
-
-            # Upload the generated image
-            file_service = FileService()
-            file_meta = file_service.upload_from_file(
-                png_path,
-                meta.get("session_id"),
-                data_source="Global Agent - PlantUML Action",
-            )
-            files.append(file_meta)
-
-        except FileNotFoundError as e:
-            log.error("PlantUML executable not found: %s", str(e))
-            return ActionResponse(
-                message="PlantUML executable not found. Please ensure PlantUML is installed and available in PATH.",
-            )
-        except subprocess.CalledProcessError as e:
-            log.error("Subprocess failed with stderr: %s", str(e))
-            return ActionResponse(
-                message=f"Failed to create diagram: {str(e)}",
-            )
-        finally:
-            if 'temp_dir' in locals() and os.path.exists(temp_dir):
-                try:
-                    shutil.rmtree(temp_dir)  # Remove directory and all contents
-                except:
-                    pass
-
-        return ActionResponse(
-            message=f"diagram created with the plantUML: \n```\n{expression}\n```",
-            files=files,
-        )

solace_agent_mesh/agents/global/actions/plotly_graph.py

@@ -1,152 +0,0 @@
-"""Plotly graph generation"""
-
-import platform
-import os
-import random
-import tempfile
-import json
-import yaml
-from importlib.metadata import version
-from io import BytesIO
-from packaging.version import parse
-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": [
-                    {
-                        "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.",
-                        "tag_prefix_placeholder": "{tp}",
-                        "starting_id": "12",
-                        "user_input": "Please generate a random bar graph for me",
-                        "metadata": [
-                            "local_time: 2024-09-04 15:59:02 EDT-0400 (Wednesday)"
-                        ],
-                        "reasoning": [
-                            "- user has requested a random bar graph",
-                            "- invoke the plotly action from the global agent to generate a bar graph with random data",
-                        ],
-                        "response_text": "Certainly! I'd be happy to generate a random bar graph for you.",
-                        "status_update": "I'll use our plotting tool to create this for you right away.",
-                        "action": {
-                            "agent": "global",
-                            "name": "plotly",
-                            "parameter_name": "plotly_figure_config",
-                            "parameters": {
-                                "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"}',
-                                    "    }",
-                                    "}",
-                                ]
-                            },
-                        },
-                    }
-                ],
-            },
-            **kwargs,
-        )
-
-    def invoke(self, params, meta={}) -> ActionResponse:
-        if platform.system() == "Windows":
-            kaleido_version = version("kaleido")
-            min_version = parse("0.1.0.post1")
-            max_version = parse("0.2.0")
-            if (
-                parse(kaleido_version) < min_version
-                or parse(kaleido_version) >= max_version
-            ):
-                return ActionResponse(
-                    message="For Windows users, the plotting functionality requires a specific version of Kaleido. Please refer to the documentation."
-                )
-        obj = params["plotly_figure_config"]
-        if isinstance(obj, str):
-            # First remove any leading/trailing whitespace
-            obj = obj.strip()
-
-            # Next remove ```yaml or ```json
-            if obj.startswith("```yaml") or obj.startswith("```json"):
-                obj = obj[7:]
-            elif obj.startswith("```"):
-                obj = obj[3:]
-            # Remove any trailing ``` characters
-            if obj.endswith("```"):
-                obj = obj[:-3]
-            # Remove any leading/trailing whitespace again
-            obj = obj.strip()
-
-            # If the string starts with a quote and ends with that same quote, remove them
-            if obj.startswith("'") and obj.endswith("'"):
-                obj = obj[1:-1]
-            elif obj.startswith('"') and obj.endswith('"'):
-                obj = obj[1:-1]
-
-            # 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

@@ -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."""