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

solace_agent_mesh/agents/global/actions/agent_state_change.py

@@ -1,54 +0,0 @@
-"""Agent state change action"""
-
-from solace_ai_connector.common.log import log
-from ....common.action import Action
-from ....common.action_response import (
-    ActionResponse,
-    AgentStateChange,
-    ErrorInfo,
-)
-
-
-class AgentStateChangeAction(Action):
-
-    def __init__(self, **kwargs):
-        super().__init__(
-            {
-                "name": "change_agent_status",
-                "prompt_directive": "Handle agent state change",
-                "params": [
-                    {
-                        "name": "agent_name",
-                        "desc": "Name of the agent",
-                        "type": "string",
-                    },
-                    {
-                        "name": "new_state",
-                        "desc": "New state of the agent: open or closed",
-                        "type": "string",
-                    },
-                ],
-                "required_scopes": ["*:*:*"],
-            },
-            **kwargs,
-        )
-
-    def invoke(self, params, meta={}) -> ActionResponse:
-        agent_name = params["agent_name"]
-        new_state = params["new_state"]
-        log.debug("Handling agent state change: %s -> %s", agent_name, new_state)
-
-        if new_state == "open":
-            return ActionResponse(
-                message=f"_Opening agent {agent_name}..._",
-                agent_state_change=AgentStateChange(agent_name, "open"),
-            )
-        elif new_state == "closed":
-            return ActionResponse(
-                agent_state_change=AgentStateChange(agent_name, "closed"),
-            )
-        else:
-            log.error("Invalid agent state: %s", new_state)
-            return ActionResponse(
-                error_info=ErrorInfo(error_message=f"Invalid agent state for {agent_name}: {new_state}"),
-            )

solace_agent_mesh/agents/global/actions/clear_history.py

@@ -1,32 +0,0 @@
-"""Clear history action"""
-
-from solace_ai_connector.common.log import log
-from ....common.action import Action
-from ....common.action_response import ActionResponse
-
-
-class ClearHistory(Action):
-    def __init__(self, **kwargs):
-        super().__init__(
-            {
-                "name": "clear_history",
-                "prompt_directive": "Clear the chat history",
-                "params": [
-                    {
-                        "name": "depth_to_keep",
-                        "desc": "The number of messages to keep in the chat history. If 0, clear all history. ",
-                        "type": "integer",
-                    }
-                ],
-                "required_scopes": ["*:*:*"],
-            },
-            **kwargs,
-        )
-
-    def invoke(self, params, meta={}) -> ActionResponse:
-        log.debug("Clearing chat history")
-        depth_to_keep = params.get("depth_to_keep", 0)
-        return ActionResponse(
-            clear_history=True,
-            history_depth_to_keep=depth_to_keep,
-        )

solace_agent_mesh/agents/global/actions/convert_file_to_markdown.py

@@ -1,160 +0,0 @@
-"""Action description"""
-
-from solace_ai_connector.common.log import log
-from markitdown import MarkItDown
-from markitdown import UnsupportedFormatException
-import json
-import os
-import mimetypes
-import tempfile
-from ....common.action import Action
-from ....common.action_response import ActionResponse
-from ....services.file_service import FS_PROTOCOL, FileService
-
-STRIP_LENGTH = len(FS_PROTOCOL) + len("://") + 36 + 1  # 36 is uuid, 1 is underscore
-
-
-class ConvertFileToMarkdown(Action):
-
-    def __init__(self, **kwargs):
-        super().__init__(
-            {
-                "name": "convert_file_to_markdown",
-                "prompt_directive": (
-                    "Convert various file formats to Markdown using the MarkItDown utility. "
-                    "Supported file types include PDF, Word, Excel, HTML, CSV and PPTX "
-                    "and ZIP files. Files are provided in "
-                    + f"{FS_PROTOCOL}://"
-                    + " format. "
-                    "JSON and XML files are not supported. "
-                    "This action will return Markdown files."
-                ),
-                "params": [
-                    {
-                        "name": "files",
-                        "desc": (
-                            f"List of {FS_PROTOCOL}:// URLs to the files to convert to Markdown. "
-                            f"For example: ['{FS_PROTOCOL}://file1.pdf', '{FS_PROTOCOL}://file2.docx']"
-                        ),
-                        "type": "array",
-                    }
-                ],
-                "required_scopes": ["global:markitdown:execute"],
-            },
-            **kwargs,
-        )
-
-    def invoke(self, params, meta={}) -> ActionResponse:
-        files = params.get("files", [])
-        session_id = meta.get("session_id")
-        log.debug("Doing markitdown convert action: %s", params["files"])
-
-        if isinstance(files, str):
-            try:
-                files = json.loads(files)
-            except json.JSONDecodeError:
-                log.error("Failed to decode files string as JSON")
-                return ActionResponse(message="Error: File URL list is not valid.")
-
-        return self.do_action(files, session_id)
-
-    def extract_file_format(self, file_path: str) -> str:
-        """
-        Extracts the file format from a file path or guesses it using mimetypes if not present.
-        """
-        file_extension = os.path.splitext(file_path)[1]
-        if file_extension:
-            return file_extension.lower()
-
-        mime_type, _ = mimetypes.guess_type(file_path)
-        if mime_type:
-            guessed_extension = mimetypes.guess_extension(mime_type)
-            if guessed_extension:
-                return guessed_extension.lower()
-
-        raise ValueError(f"Unable to determine file format for path: {file_path}")
-
-    def do_action(self, files, session_id) -> ActionResponse:
-        markitdown_client = MarkItDown()
-        file_service = FileService()
-
-        response_messages = []
-        uploaded_files = []
-
-        # Iterate over each file URL
-        for file_url in files:
-            try:
-                file_buffer = file_service.download_to_buffer(file_url, session_id)
-            except Exception as e:
-                log.error(
-                    "Failed to download file from the url %s: %s", file_url, str(e)
-                )
-                response_messages.append(
-                    f"Failed to download file from the url {file_url}"
-                )
-                continue
-
-            # Find the file extension
-            try:
-                file_extension = self.extract_file_format(file_url)
-            except ValueError:
-                response_messages.append(
-                    f"Could not determine file format for: {file_url}"
-                )
-                continue
-
-            # strip first {STRIP LENGTH} characters of the url to get the original name
-            original_name = file_url[STRIP_LENGTH:]
-
-            with tempfile.NamedTemporaryFile(
-                delete=True, suffix=file_extension
-            ) as temporary_file:
-                try:
-                    # Write to temp file
-                    temporary_file.write(file_buffer)
-                    temporary_file.flush()
-
-                    # Convert the file to Markdown
-                    try:
-                        conversion_result = markitdown_client.convert(
-                            temporary_file.name
-                        )
-                        # Empty content
-                        if not conversion_result.text_content:
-                            log.error("Error converting file %s: Conversion resulted in empty content", file_url)
-                            response_messages.append(f"Could not convert file: {file_url} - conversion resulted in empty content")
-                            continue
-                    except UnsupportedFormatException as e:
-                        log.error("Error converting file %s: %s", file_url, str(e))
-                        response_messages.append(
-                            f"Could not convert file: {file_url} as this format is not supported: {str(e)}"
-                        )
-                        continue
-
-                    # Use the original file name + "_converted" affix + .md extension
-                    converted_filename = f"{original_name}_converted.md"
-
-                    # Upload the converted content
-                    file_obj = file_service.upload_from_buffer(
-                        conversion_result.text_content.encode("utf-8"),
-                        converted_filename,
-                        session_id,
-                        data_source="Global Agent - MarkItDown Action",
-                    )
-
-                    filename = file_obj["name"]
-                    uploaded_files.append(file_obj)
-                    response_messages.append(f"File converted successfully: {filename}")
-
-                except Exception as e:
-                    log.error(
-                        "Failed to upload file %s: %s", converted_filename, str(e)
-                    )
-                    response_messages.append(
-                        f"Failed to upload file {converted_filename}"
-                    )
-                    continue
-
-        return ActionResponse(
-            message="\n".join(response_messages), files=uploaded_files
-        )

solace_agent_mesh/agents/global/actions/create_file.py

@@ -1,70 +0,0 @@
-"""Create a new file in file service"""
-
-from solace_ai_connector.common.log import log
-from ....common.action import Action
-from ....common.action_response import ActionResponse
-from ....services.file_service import FS_PROTOCOL, FileService
-from ....services.file_service.file_utils import starts_with_fs_url
-
-
-class CreateFile(Action):
-    """Action to create a new file in file service"""
-
-    def __init__(self, **kwargs):
-
-        super().__init__(
-            {
-                "name": "create_file",
-                "prompt_directive": f"Creates a new persisted file and returns the file block with {FS_PROTOCOL} URL",
-                "params": [
-                    {
-                        "name": "name",
-                        "desc": "File name (required) - must have an extension. Eg: file.csv",
-                        "type": "string",
-                    },
-                    {
-                        "name": "content",
-                        "desc": "Content of the file (required)",
-                        "type": "string",
-                    },
-                ],
-                "required_scopes": ["global:create_file:write"],
-            },
-            **kwargs,
-        )
-
-    def invoke(self, params, meta={}) -> ActionResponse:
-        name: str = params.get("name")
-        content: str = params.get("content")
-        session_id: str = meta.get("session_id")
-
-        if not name or not content:
-            return ActionResponse(message="Error: name and content are required.")
-
-        try:
-            # Upload the file
-            file_service = FileService()
-
-            updated_content = content
-            if starts_with_fs_url(updated_content):
-                updated_content = file_service.resolve_url(updated_content, session_id)
-            else:
-                updated_content = file_service.resolve_all_resolvable_urls(updated_content, session_id)
-
-            if isinstance(updated_content, str):
-                updated_content = updated_content.encode("utf-8")
-
-            file_meta = file_service.upload_from_buffer(
-                updated_content,
-                name,
-                session_id,
-                data_source="Global Agent - Create File Action",
-            )
-        except Exception as e:
-            log.error("Failed to upload file %s: %s", name, str(e))
-            return ActionResponse(message=f"Failed to upload the file: {name}")
-
-        file_block = file_service.get_file_block_by_metadata(file_meta)
-        return ActionResponse(
-            message=f"Following file has been created:\n\n{file_block}",
-        )

solace_agent_mesh/agents/global/actions/error_action.py

@@ -1,45 +0,0 @@
-"""Action to handle errors from the system"""
-
-from solace_ai_connector.common.log import log
-
-from ....common.action import Action
-from ....common.action_response import (
-    ActionResponse,
-    ErrorInfo,
-    WithContextQuery,
-)
-
-
-class ErrorAction(Action):
-    def __init__(self, **kwargs):
-        super().__init__(
-            {
-                "name": "error_action",
-                "prompt_directive": "Raise an error message",
-                "params": [
-                    {
-                        "name": "error_message",
-                        "desc": "The error to send to the user",
-                        "type": "string",
-                    }
-                ],
-                "required_scopes": ["*:*:*"],
-            },
-            **kwargs,
-        )
-
-    def invoke(self, params, meta={}) -> ActionResponse:
-        error_message = params.get("error_message")
-        if error_message:
-            log.error("Raising error: %s", error_message)
-            # If the error_message contains "Failed to parse response",
-            # then return a response requesting a redo from the LLM
-            if "Failed to parse response" in error_message:
-                return ActionResponse(
-                    context_query=WithContextQuery(
-                        context_type="statement",
-                        context="Your response was not correctly formated and parsing failed. Please try again but don't comment on the parsing problem in your response.",
-                        query="",
-                    )
-                )
-            return ActionResponse(error_info=ErrorInfo(error_message=error_message))

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)