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

solace_agent_mesh/cli/utils.py

@@ -0,0 +1,246 @@
+import os
+import re
+import click
+import importlib
+
+
+def get_cli_root_dir():
+    """Get the path to the CLI root directory."""
+    # Get the directory of the current script
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    # Construct the root directory
+    return os.path.normpath(os.path.join(current_dir, ".."))
+
+
+def merge_dicts(dict1, dict2):
+    """Merge two dictionaries recursively."""
+    for key, value in dict2.items():
+        if key in dict1 and isinstance(dict1[key], dict) and isinstance(value, dict):
+            merge_dicts(dict1[key], value)
+        elif key in dict1 and isinstance(dict1[key], list) and isinstance(value, list):
+            # set concat arrays
+            dict1[key] = list(dict1[key] + value)
+        else:
+            # dict2 takes precedence
+            dict1[key] = value
+    return dict1
+
+
+def remove_duplicate(array, id_fn):
+    """Remove duplicates from an array based on a key function. Keeps the last occurrence."""
+    seen = set()
+    reversed_array = array[::-1]
+    deduplicated_array = [
+        x for x in reversed_array if not (id_fn(x) in seen or seen.add(id_fn(x)))
+    ]
+    return deduplicated_array[::-1]
+
+
+def literal_format_template(template, literals):
+    for key, value in literals.items():
+        template = template.replace("{{" + key + "}}", value)
+    return template
+
+
+def load_template(name, format_pair={}):
+    """Load a template file and format it with the given key-value pairs."""
+    # Construct the path to the template file using a relative path
+    template_file = os.path.normpath(
+        os.path.join(get_cli_root_dir(), "templates", name)
+    )
+
+    if not os.path.exists(template_file):
+        return None
+
+    with open(template_file, "r", encoding="utf-8") as f:
+        file = f.read()
+
+    file = literal_format_template(file, format_pair)
+
+    return file
+
+
+def extract_yaml_env_variables(yaml_content):
+    """Get environment variables from a yaml file.
+    Env variables are annotated with the ${VAR}
+    """
+    return re.findall(r"\${(\w+)}", yaml_content)
+
+
+def get_display_path(path):
+    """Get the display path of a file path."""
+    return path if os.path.isabs(path) else f"./{path}"
+
+
+def log_error(message):
+    click.echo(click.style(message, fg="red"), err=True)
+
+
+def log_link(message):
+    click.echo(click.style(message, fg="blue"), err=False)
+
+
+def log_success(message):
+    click.echo(click.style(message, fg="green"), err=False)
+
+
+def ask_yes_no_question(question: str, default=False) -> bool:
+    """Ask a yes/no question and return the answer."""
+    return click.confirm(question, default=default)
+
+
+def ask_question(question: str, default=None) -> str:
+    """Ask a question and return the answer."""
+    return click.prompt(question, default=default)
+
+
+def ask_choice_question(question: str, choices: list, default=None) -> str:
+    """Ask a choice question and return the answer."""
+    return click.prompt(question, type=click.Choice(choices), default=default)
+
+
+def ask_password(question: str, default=None) -> str:
+    """Ask a password question and return the answer."""
+    return click.prompt(question, default=default, hide_input=True)
+
+
+def ask_if_not_provided(
+    options,
+    key,
+    question,
+    default=None,
+    none_interactive=False,
+    choices=None,
+    hide_input=False,
+):
+    """
+    Ask a question if the key is not in the options.
+    Updates the options dictionary with the answer.
+    Returns the answer.
+    """
+    if key not in options or options[key] is None:
+        if none_interactive:
+            options[key] = default
+        elif choices:
+            options[key] = ask_choice_question(question, choices, default=default)
+        elif hide_input:
+            options[key] = ask_password(question, default=default)
+        elif isinstance(default, bool):
+            options[key] = ask_yes_no_question(question, default=default)
+        else:
+            options[key] = ask_question(question, default=default)
+    return options[key]
+
+
+def apply_document_parsers(file_content, parsers, meta={}):
+    for parser in parsers:
+        file_content = parser(file_content, meta)
+    return file_content
+
+
+def load_plugin(name, return_path_only=False):
+    """Load a plugin by name.
+
+    Args:
+        name (str): The name of the plugin to load.
+        return_path_only (bool, optional): Whether to return only the path to the module.
+
+    Returns:
+        module: The loaded module.
+        module_path: The path to the module. (Or only the path if return_path_only is True)
+    """
+    # Construct the path to the plugin directory using a relative path
+    try:
+        # Attempt to import the module
+        module = importlib.import_module(name)
+        module_path = module.__path__[0]
+    except ImportError:
+        if return_path_only:
+            return None
+        return None, None
+
+    if return_path_only:
+        return module_path
+
+    return module, module_path
+
+
+def get_formatted_names(name: str):
+    name = name.strip()
+    parts = re.split(r"[\s_-]", name)
+    return {
+        "KEBAB_CASE_NAME": "-".join([word.lower() for word in parts]),
+        "HYPHENED_NAME": name,
+        "CAMEL_CASE_NAME": "".join([word.capitalize() for word in parts]),
+        "SNAKE_CASE_NAME": "_".join([word.lower() for word in parts]),
+        "SPACED_NAME": " ".join(parts),
+        "SNAKE_UPPER_CASE_NAME": "_".join([word.upper() for word in parts]),
+    }
+
+
+def find_last_list_item_indent(yaml_content):
+    """
+    Finds the indentation of the last list item
+    Returns the number of spaces before the dash (-)
+    """
+    lines = yaml_content.splitlines()
+    
+    # Look for the last line starting with '-' by iterating in reverse
+    for line in reversed(lines):
+        stripped_line = line.lstrip()
+        if stripped_line.startswith('-'):
+            return len(line) - len(stripped_line)
+    
+    #default to 0
+    return 0
+
+
+def normalize_and_reindent_yaml(reference_yaml, yaml_content):
+    """Given YAML content, adjust the indentation to the given target_dash_indent,
+    while preserving the relative indentation of the content.
+    """
+    target_dash_indent = find_last_list_item_indent(reference_yaml)
+
+    lines = yaml_content.splitlines()
+    if not lines:
+        return ""
+
+    # Find the current dash indentation in the content
+    current_dash_indent = None
+    for line in lines:
+        if line.lstrip().startswith('-'):
+            current_dash_indent = len(line) - len(line.lstrip())
+            break
+    
+    if current_dash_indent is None:
+        current_dash_indent = 0
+
+    # Calculate the indentation difference
+    indent_difference = target_dash_indent - current_dash_indent
+
+    # Apply the indentation difference to all lines
+    reindented_lines = []
+    for line in lines:
+        if not line.strip():
+            # Preserve empty lines
+            reindented_lines.append(line)
+        else:
+            current_indent = len(line) - len(line.lstrip())
+            #prevent negative indent
+            new_indent = max(0, current_indent + indent_difference)
+            reindented_lines.append(' ' * new_indent + line.lstrip())
+
+    reindented_lines.append('\n')
+
+    return '\n'.join(reindented_lines)
+
+def get_all_cases(name: str):
+    name = name.strip()
+    parts = re.split(r"[\s_-]", name)
+    return {
+        "KEBAB_CASE": "-".join([word.lower() for word in parts]),
+        "CAMEL_CASE": "".join([word.capitalize() for word in parts]),
+        "SNAKE_CASE": "_".join([word.lower() for word in parts]),
+        "SPACED": " ".join(parts),
+        "SNAKE_UPPER_CASE": "_".join([word.upper() for word in parts]),
+    }

solace_agent_mesh/common/action.py

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

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

@@ -0,0 +1,327 @@
+"""This is the definition of responses for the actions of the system."""
+
+
+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
+
+    @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
+
+    @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
+
+    @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
+        return response

solace_agent_mesh/common/constants.py

@@ -0,0 +1,3 @@
+SOLACE_AGENT_MESH_SYSTEM_SESSION_ID = "solace_agent_mesh_system_session_id"
+
+DEFAULT_IDENTITY_KEY_FIELD = "identity"