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

solace_agent_mesh/cli/commands/visualizer.py

@@ -1,138 +0,0 @@
-import os
-import http.server
-import socketserver
-import socket
-import click
-import json
-
-from cli.utils import get_cli_root_dir, log_error
-
-
-def get_local_ip():
-    """Get the local IP address of the machine."""
-    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-    try:
-        # Connect to an external address, doesn't send any packets, just determines IP
-        s.connect(("8.8.8.8", 80))
-        ip = s.getsockname()[0]
-    except Exception:
-        ip = "localhost"
-    finally:
-        s.close()
-    return ip
-
-
-def get_wss_url(url: str) -> str:
-    """Get the WSS URL from a WS URL."""
-    if url.startswith("ws://") or url.startswith("wss://"):
-        return url
-    elif url.startswith("tcp://"):
-        url = url.replace("tcp://", "ws://")
-        # Change port to 443
-        if len(url.split(":")) > 1:
-            url = url.split(":")
-            url[-1] = "443"
-            url = ":".join(url)
-    elif url.startswith("tcps://"):
-        url = url.replace("tcps://", "wss://")
-        # Change port to 443
-        if len(url.split(":")) > 1:
-            url = url.split(":")
-            url[-1] = "443"
-            url = ":".join(url)
-    return url
-
-
-def visualizer_command(port, find_unused_port=False, host=False, use_env=False):
-    """Runs a GUI web-based visualizer for inspecting events inside the solace agent mesh."""
-    config = click.get_current_context().obj["solace_agent_mesh"]
-    if use_env:
-        try:
-            from dotenv import load_dotenv
-
-            env_file = config["env_file"]
-            load_dotenv(env_file, override=True)
-        except ImportError:
-            log_error(
-                "Failed to import dotenv. Please install it using 'pip install python-dotenv'"
-            )
-            return 1
-        except Exception as e:
-            log_error(f"Failed to load environment variables. {e}")
-            return 1
-
-    visualizer_directory = os.path.join(get_cli_root_dir(), "assets", "web-visualizer")
-    # Check if the visualizer directory exists
-    if not os.path.exists(visualizer_directory):
-        visualizer_directory = os.path.join(
-            get_cli_root_dir(), "web-visualizer", "dist"
-        )
-        if not os.path.exists(visualizer_directory):
-            log_error("Error: Built Web-Visualizer directory not found.")
-            return 1
-
-    # Find an unused port if the specified port is in use
-    while True:
-        # Check if port is available
-        try:
-            with socketserver.TCPServer(("localhost", port), None) as s:
-                pass
-        except OSError:
-            log_error(f"Error: Port {port} is already in use.")
-            if find_unused_port:
-                port += 1
-                click.echo(f"Trying port {port}...")
-                continue
-            else:
-                return 1
-        break
-
-    # Change the current working directory to the visualizer directory
-    os.chdir(visualizer_directory)
-
-    # Write the Solace broker configuration to a file for client pickup
-    config = {
-        "url": get_wss_url(os.getenv("SOLACE_BROKER_URL", "")),
-        "username": os.getenv("SOLACE_BROKER_USERNAME", ""),
-        "password": os.getenv("SOLACE_BROKER_PASSWORD", ""),
-        "vpn": os.getenv("SOLACE_BROKER_VPN", ""),
-        "namespace": os.getenv("SOLACE_AGENT_MESH_NAMESPACE", ""),
-    }
-    with open("config.json", "w") as f:
-        json.dump(config, f)
-
-    # Set up a handler to serve files from the specified directory
-    handler = http.server.SimpleHTTPRequestHandler
-
-    # Determine the host binding
-    if host:
-        # Bind to '0.0.0.0' to expose to the network
-        bind_address = "0.0.0.0"
-        local_ip = get_local_ip()  # Get local network IP address
-    else:
-        # Bind to 'localhost' to restrict access to the local machine
-        bind_address = "localhost"
-        local_ip = "localhost"
-
-    # Start the server
-    with socketserver.TCPServer((bind_address, port), handler) as httpd:
-        click.echo(f"Serving solace-agent-mesh web-visualizer.")
-        click.echo(
-            click.style(f"\tLocal: http://localhost:{port}", bold=True, fg="blue")
-        )
-        click.echo(
-            click.style(
-                "\tNetwork: "
-                + (f"http://{local_ip}:{port}" if host else "use --host to expose"),
-                bold=True,
-                fg="blue",
-            )
-        )
-        click.echo("Press Ctrl+C to stop the server.")
-        try:
-            httpd.serve_forever()
-        except KeyboardInterrupt:
-            click.echo("Shutting down server.")
-            httpd.shutdown()
-        finally:
-            os.remove("config.json")

solace_agent_mesh/cli/config.py

@@ -1,85 +0,0 @@
-import os
-from ruamel.yaml import YAML
-
-# Initialize a YAML object
-yaml = YAML()
-yaml.preserve_quotes = True  # To preserve quotes in the YAML
-
-from cli.utils import merge_dicts, load_template, remove_duplicate
-
-
-class Config:
-    default_config_file = "solace-agent-mesh-default.yaml"
-    user_config_file = "solace-agent-mesh.yaml"
-    user_plugin_config_file = "solace-agent-mesh-plugin.yaml"
-    default_plugin_config_file = "solace-agent-mesh-plugin-default.yaml"
-
-    @staticmethod
-    def get_default_config():
-        loaded_config = load_template(Config.default_config_file)
-        return yaml.load(loaded_config)
-
-    @staticmethod
-    def get_default_plugin_config():
-        loaded_config = load_template(Config.default_plugin_config_file)
-        return yaml.load(loaded_config)
-
-    @staticmethod
-    def get_user_config(config_file=None):
-        config_file_path = config_file or Config.user_config_file
-        if os.path.exists(config_file_path):
-            with open(config_file_path, "r", encoding="utf-8") as f:
-                return yaml.load(f) or {}
-        return {}
-
-    @staticmethod
-    def get_user_plugin_config(config_file=None):
-        config_file_path = config_file or Config.user_plugin_config_file
-        if os.path.exists(config_file_path):
-            with open(config_file_path, "r", encoding="utf-8") as f:
-                return yaml.load(f) or {}
-        return {}
-
-    @staticmethod
-    def get_config(config_file=None):
-        user_config = Config.get_user_config(config_file)
-        default_config = Config.get_default_config()
-        # Merge user config with default config
-        merged_config = merge_dicts(default_config, user_config)
-        merged_config["solace_agent_mesh"]["built_in"]["agents"] = remove_duplicate(
-            merged_config["solace_agent_mesh"]["built_in"]["agents"],
-            lambda agent: agent.get("name"),
-        )
-        return merged_config
-
-    @staticmethod
-    def get_plugin_config(config_file=None):
-        user_config = Config.get_user_plugin_config(config_file)
-        default_config = Config.get_default_plugin_config()
-        # Merge user config with default config
-        merged_config = merge_dicts(default_config, user_config)
-        return merged_config
-
-    @staticmethod
-    def is_plugin_project():
-        return os.path.exists(Config.user_plugin_config_file)
-
-    @staticmethod
-    @staticmethod
-    def write_config(config, path=None):
-        if not path:
-            path = Config.user_config_file
-        with open(path, "w", encoding="utf-8") as f:
-            yaml.dump(config, f)
-
-    @staticmethod
-    def load_config(path=None):
-        if not path:
-            path = Config.user_config_file
-        if os.path.exists(path):
-            with open(path, "r", encoding="utf-8") as f:
-                return yaml.load(f)
-            
-    @staticmethod
-    def get_yaml_parser():
-        return yaml.load

solace_agent_mesh/common/action.py

@@ -1,91 +0,0 @@
-from abc import ABC, abstractmethod
-
-from .action_response import ActionResponse
-
-
-class Action(ABC):
-
-    def __init__(self, attributes, agent=None, config_fn=None, **kwargs):
-        self.validate_attributes(attributes)
-        self.long_description = attributes.get(
-            "long_description", attributes.get("prompt_directive", "<unspecified>")
-        )
-        self._prompt_directive = attributes.get("prompt_directive")
-        self._name = attributes.get("name")
-        self._params = attributes.get("params")
-        self._disabled = attributes.get("disabled", False)
-        self._examples = attributes.get("examples", [])
-        self._required_scopes = attributes.get("required_scopes", [])
-        self._config_fn = config_fn
-        self.agent = agent
-        self.kwargs = kwargs
-
-    @property
-    def name(self):
-        return self._name
-
-    @property
-    def disabled(self):
-        return self._disabled
-
-    @property
-    def examples(self):
-        return self._examples
-
-    @property
-    def required_scopes(self):
-        return self._required_scopes
-
-    def set_agent(self, agent):
-        self.agent = agent
-
-    def fix_scopes(self, search_value, replace_value):
-        self._required_scopes = [
-            scope.replace(search_value, replace_value)
-            for scope in self._required_scopes
-        ]
-
-    def get_agent(self):
-        return self.agent
-
-    def set_config_fn(self, config_fn):
-        self._config_fn = config_fn
-
-    def get_config(self, key=None, default=None):
-        if self._config_fn:
-            return self._config_fn(key, default)
-        return default
-
-    def get_prompt_summary(self, prefix="") -> dict:
-        if self.disabled:
-            return None
-        summary = {}
-        action_name = self._name
-        summary[action_name] = {
-            "desc": self._prompt_directive,
-            "params": [f"{param['name']} ({param['desc']})" for param in self._params],
-            "examples": self._examples,
-            "required_scopes": self._required_scopes,
-        }
-        return summary
-
-    def validate_attributes(self, attributes):
-        if not attributes.get("name"):
-            raise ValueError("Actions must have a name")
-        if not attributes.get("prompt_directive"):
-            raise ValueError("Actions must have a prompt_directive")
-        if attributes.get("params"):
-            params = attributes.get("params")
-            for param in params:
-                if not param.get("name"):
-                    raise ValueError(
-                        "Action attributes params must have a descriptive name"
-                    )
-                if not param.get("desc"):
-                    raise ValueError("Action attributes params must have a description")
-                if not param.get("type"):
-                    raise ValueError("Action attributes params must have a type")
-
-    @abstractmethod
-    def invoke(self, params, meta={}) -> ActionResponse:
-        raise NotImplementedError("Invoke method must be implemented in subclass")

solace_agent_mesh/common/action_list.py

@@ -1,37 +0,0 @@
-from .action import Action
-
-
-class ActionList:
-
-    def __init__(self, actions_classes, **kwargs):
-        self.actions: Action = []
-        self.actions_map = {}
-        for action_class in actions_classes:
-            action = action_class(**kwargs)
-            self.actions.append(action)
-            self.actions_map[action.name] = action
-
-    def add_action(self, action):
-        self.actions.append(action)
-        self.actions_map[action.name] = action
-
-    def set_agent(self, agent):
-        for action in self.actions:
-            action.set_agent(agent)
-
-    def fix_scopes(self, search_value, replace_value):
-        for action in self.actions:
-            action.fix_scopes(search_value, replace_value)
-
-    def set_config_fn(self, config_fn):
-        for action in self.actions:
-            action.set_config_fn(config_fn)
-
-    def get_prompt_summary(self, prefix="") -> dict:
-        summary = []
-        for action in self.actions:
-            summary.append(action.get_prompt_summary(prefix))
-        return summary
-
-    def get_action(self, name):
-        return self.actions_map.get(name)

solace_agent_mesh/common/action_response.py

@@ -1,340 +0,0 @@
-"""This is the definition of responses for the actions of the system."""
-
-from typing import Optional
-
-
-class RagMatch:
-
-    def __init__(self, text: str, link: str = None, heading: str = None):
-        self._text: str = text
-        self._link: str = link
-        self._heading: str = heading
-
-    @property
-    def text(self) -> str:
-        return self._text
-
-    @property
-    def link(self) -> str:
-        return self._link
-
-    @property
-    def heading(self) -> str:
-        return self._headings
-
-    def to_dict(self) -> dict:
-        return {
-            "text": self._text,
-            "link": self._link,
-            "heading": self._heading,
-        }
-
-
-class InlineFile:
-
-    def __init__(self, content: str, name: str, **kwargs):
-        if type(content) != str:
-            raise ValueError("InlineFile content must be a string")
-        self._content: str = content
-        self._name: str = name
-        self._kwargs: dict = kwargs
-
-    @property
-    def content(self) -> str:
-        return self._content
-
-    @property
-    def name(self) -> str:
-        return self._name
-    
-    @property
-    def kwargs(self) -> dict:
-        return self._kwargs
-
-    def to_dict(self) -> dict:
-        return {
-            "data": self._content,
-            "name": self._name,
-            "file_size": len(self._content.encode()),
-            "mime_type": "text/plain",
-            **self._kwargs,
-        }
-
-
-class WithContextQuery:
-
-    def __init__(
-        self, query: str, context_type: str, context: str = None, since: str = None
-    ):
-        self._query: str = query
-        self._context_type: str = context_type
-        self._context: str = context
-        self._since: str = since
-
-    @property
-    def query(self) -> str:
-        return self._query
-
-    @property
-    def context(self) -> str:
-        return self._context
-
-    @property
-    def context_type(self) -> str:
-        return self._context_type
-
-    @property
-    def since(self) -> dict:
-        return self._since
-
-    def to_dict(self) -> dict:
-        return {
-            "query": self._query,
-            "context_type": self._context_type,
-            "context": self._context,
-            "since": self._since,
-        }
-
-
-class RagResponse:
-
-    def __init__(
-        self, data_source: str, matches: list[RagMatch], query: str, prompt: str = None
-    ):
-        self._data_source: str = data_source
-        self._matches: list[RagMatch] = matches
-        self._query: str = query
-        self._prompt: str = prompt
-
-    @property
-    def data_source(self) -> str:
-        return self._data_source
-
-    @property
-    def matches(self) -> list[RagMatch]:
-        return self._matches
-
-    @property
-    def query(self) -> str:
-        return self._query
-
-    @property
-    def prompt(self) -> str:
-        return self._prompt
-
-    def to_dict(self) -> dict:
-        return {
-            "data_source": self._data_source,
-            "matches": [match.to_dict() for match in self._matches],
-            "query": self._query,
-            "prompt": self._prompt,
-        }
-
-
-class AgentStateChange:
-
-    def __init__(self, agent_name: str, new_state: str):
-        self._agent_name: str = agent_name
-        self._new_state: str = new_state
-
-    @property
-    def agent_name(self) -> str:
-        return self._agent_name
-
-    @property
-    def new_state(self) -> str:
-        return self._new_state
-
-    def to_dict(self) -> dict:
-        return {"agent_name": self._agent_name, "new_state": self._new_state}
-
-
-class ErrorInfo:
-
-    def __init__(self, error_message: str):
-        self._error_message: str = error_message
-
-    @property
-    def error_message(self) -> str:
-        return self._error_message
-
-    def __str__(self) -> str:
-        return self._error_message
-
-    def to_dict(self) -> dict:
-        return {"error_message": self._error_message}
-
-
-class ActionResponse:
-
-    def __init__(
-        self,
-        message: any = None,
-        files: list[str] = None,
-        inline_files: list[InlineFile] = None,
-        clear_history: bool = False,
-        history_depth_to_keep: int = None,
-        error_info: ErrorInfo = None,
-        agent_state_change: AgentStateChange = None,
-        invoke_model_again: bool = False,
-        context_query: WithContextQuery = None,
-        is_async: bool = False,
-        async_response_id: str = None,
-    ):
-        # Message to return - this could be a string or a slack blocks message
-        self._message: str = message
-        # Files to return - this is a list of temporary files to return
-        self._files: list[str] = files
-        # Inline files to return - this is a list of inline files to return
-        self._inline_files: list[InlineFile] = inline_files
-        # Clear history - this is a flag to clear the chat history
-        self._clear_history: bool = clear_history
-        # Clear history but keep depth - this is a flag to clear the chat history but keep
-        # the last N messages
-        self._history_depth_to_keep: int = history_depth_to_keep
-        # Error info - this is a dictionary of error information (error_message)
-        self._error_info: ErrorInfo = error_info
-        # Agent state change - this is a dictionary of agent state change
-        # information (agent_name, new_state)
-        self._agent_state_change: AgentStateChange = agent_state_change
-        # Invoke model again - this is a flag to indicate if the model should be
-        # invoked again with the same input
-        self._invoke_model_again: bool = invoke_model_again
-        # Context query - this contains the query and context type to be used in the next action
-        self._context_query: WithContextQuery = context_query
-        # action_list_id - identifier of the action_list that this action response is associated with
-        self._action_list_id: str = None
-        # action_idx - index of the action in the action_list that this action response is associated with
-        self._action_idx: int = None
-        # action_name - name of the action that this action response is associated with
-        self._action_name: str = None
-        # action_params - parameters of the action that this action response is associated with
-        self._action_params: dict = None
-        # is_async - indicates if this is an async response that will be delivered later
-        self._is_async: bool = is_async
-        # async_response_id - unique identifier for correlating async responses
-        self._async_response_id: str = async_response_id
-        # originator - the component that originated the action request
-        self._originator: Optional[str] = None
-
-    @property
-    def message(self) -> any:
-        return self._message
-
-    @message.setter
-    def message(self, message: any):
-        self._message = message
-
-    @property
-    def files(self) -> list[str]:
-        return self._files
-
-    @property
-    def inline_files(self) -> list[InlineFile]:
-        return self._inline_files
-
-    @property
-    def clear_history(self) -> bool:
-        return self._clear_history
-
-    @property
-    def history_depth_to_keep(self) -> int:
-        return self._history_depth_to_keep
-
-    @property
-    def error_info(self) -> dict:
-        return self._error_info
-
-    @property
-    def agent_state_change(self) -> AgentStateChange:
-        return self._agent_state_change
-
-    @property
-    def invoke_model_again(self) -> bool:
-        return self._invoke_model_again
-
-    @property
-    def context_query(self) -> WithContextQuery:
-        return self._context_query
-
-    @property
-    def action_list_id(self) -> str:
-        return self._action_list_id
-
-    @property
-    def action_idx(self) -> int:
-        return self._action_idx
-
-    @property
-    def action_name(self) -> str:
-        return self._action_name
-
-    @property
-    def action_params(self) -> dict:
-        return self._action_params
-
-    @property
-    def originator(self) -> dict:
-        return self._originator
-
-    @action_list_id.setter
-    def action_list_id(self, action_list_id: str):
-        self._action_list_id = action_list_id
-
-    @action_idx.setter
-    def action_idx(self, action_idx: int):
-        self._action_idx = action_idx
-
-    @action_name.setter
-    def action_name(self, action_name: str):
-        self._action_name = action_name
-
-    @action_params.setter
-    def action_params(self, action_params: dict):
-        self._action_params = action_params
-
-    @originator.setter
-    def originator(self, originator: str):
-        self._originator = originator
-
-    @property
-    def is_async(self) -> bool:
-        return self._is_async
-
-    @property 
-    def async_response_id(self) -> str:
-        return self._async_response_id
-
-    def to_dict(self) -> dict:
-        response = {}
-        if self._message:
-            response["message"] = self._message
-        if self._is_async:
-            response["is_async"] = True
-            response["async_response_id"] = self._async_response_id
-        if self._files:
-            # Files are already dictionary
-            response["files"] = self._files
-        if self._inline_files:
-            # Add to the files list
-            response["files"] = response.get("files", []) + [
-                inline_file.to_dict() for inline_file in self._inline_files
-            ]
-        if self._clear_history:
-            response["clear_history"] = self._clear_history
-        if self._history_depth_to_keep:
-            response["history_depth_to_keep"] = self._history_depth_to_keep
-        if self._error_info:
-            response["error_info"] = self._error_info.to_dict()
-        if self._agent_state_change:
-            response["agent_state_change"] = self._agent_state_change.to_dict()
-        if self._invoke_model_again:
-            response["invoke_model_again"] = self._invoke_model_again
-        if self._context_query:
-            response["context_query"] = self._context_query.to_dict()
-        response["action_list_id"] = self._action_list_id
-        response["action_idx"] = self._action_idx
-        response["action_name"] = self._action_name
-        response["action_params"] = self._action_params
-        response["originator"] = self._originator
-        return response