solace-agent-mesh 0.1.3__py3-none-any.whl → 0.2.1__py3-none-any.whl

solace_agent_mesh/common/utils.py

@@ -139,17 +139,28 @@ def parse_file_content(file_xml: str) -> dict:
     """
     Parse the xml tags in the content and return a dictionary of the content.
     """
-    ignore_content_tags = ["data"]
-    file_dict = xml_to_dict(file_xml, ignore_content_tags)
-    dict_keys = list(file_dict.keys())
-    top_key = [key for key in dict_keys if key not in ignore_content_tags][0]
-
-    return {
-        "data": file_dict.get("data", {}).get("data", ""),
-        "url": file_dict.get(top_key, {}).get("url", {}).get("url", ""),
-        "mime_type": file_dict.get(top_key, {}).get("mime_type", ""),
-        "name": file_dict.get(top_key, {}).get("name", ""),
-    }
+    try:
+        # It is possible that the content of the file mistakenly has t###_ prefixes on the
+        # tags, so we need to strip them off. This is a bit of a hack to work around LLM errors
+
+        file_xml = re.sub(r"<t\d+_", "<", file_xml)
+        file_xml = re.sub(r"</t\d+_", "</", file_xml)
+
+        ignore_content_tags = ["data"]
+        file_dict = xml_to_dict(file_xml, ignore_content_tags)
+        dict_keys = list(file_dict.keys())
+        top_key = [key for key in dict_keys if key not in ignore_content_tags][0]
+
+        return {
+            "data": file_dict.get("data", {}).get("data", ""),
+            "url": file_dict.get(top_key, {}).get("url", {}).get("url", ""),
+            "mime_type": file_dict.get(top_key, {}).get("mime_type", ""),
+            "name": file_dict.get(top_key, {}).get("name", ""),
+        }
+    except Exception as e:
+        result = {"data": "", "url": "", "mime_type": "", "name": ""}
+        log.error("Error parsing file content: %s", e)
+        return result
 
 
 def parse_llm_output(llm_output: str) -> dict:
@@ -160,6 +171,7 @@ def parse_llm_output(llm_output: str) -> dict:
     # We need to save all the strings that we replace so that we can put them back
     # after we parse the yaml. Use a sequence number to create a unique placeholder
     # for each string.
+
     string_placeholders = {}
     string_count = 0
     sanity = 100
@@ -241,7 +253,9 @@ def parse_llm_output(llm_output: str) -> dict:
     return obj
 
 
-def parse_orchestrator_response(response, last_chunk=False, tag_prefix=""):
+def parse_orchestrator_response(
+    response, last_chunk=False, tag_prefix="", check_reasoning=True
+):
     tp = tag_prefix
     parsed_data = {
         "actions": [],
@@ -319,6 +333,7 @@ def parse_orchestrator_response(response, last_chunk=False, tag_prefix=""):
     current_param_value = []
     open_tags = []
     current_text = []
+    seen_invoke_action = False
 
     for line in response.split("\n"):
 
@@ -345,7 +360,8 @@ def parse_orchestrator_response(response, last_chunk=False, tag_prefix=""):
                 file_line = line[: file_end_index + len(f"</{tp}file>")]
                 file_content = [file_line]
                 current_file = parse_file_content("\n".join(file_content))
-                add_content_entry(parsed_data["content"], "file", current_file)
+                if not seen_invoke_action:
+                    add_content_entry(parsed_data["content"], "file", current_file)
                 in_file = False
                 current_file = {}
                 file_content = []
@@ -363,7 +379,8 @@ def parse_orchestrator_response(response, last_chunk=False, tag_prefix=""):
                 file_line = line[: file_end_index + len(f"</{tp}file>")]
                 file_content.append(file_line)
                 current_file = parse_file_content("\n".join(file_content))
-                add_content_entry(parsed_data["content"], "file", current_file)
+                if not seen_invoke_action:
+                    add_content_entry(parsed_data["content"], "file", current_file)
                 in_file = False
                 current_file = {}
                 file_content = []
@@ -376,6 +393,7 @@ def parse_orchestrator_response(response, last_chunk=False, tag_prefix=""):
             if in_invoke_action:
                 parsed_data["errors"].append("Nested <invoke_action> tags")
             in_invoke_action = True
+            seen_invoke_action = True
             open_tags.append("invoke_action")
             current_action = {
                 "agent": None,
@@ -398,7 +416,7 @@ def parse_orchestrator_response(response, last_chunk=False, tag_prefix=""):
                 if current_param_name:
                     current_action["parameters"][current_param_name] = "\n".join(
                         current_param_value
-                    ).strip()
+                    )
                 parsed_data["actions"].append(current_action)
                 current_action = {}
                 current_param_name = None
@@ -406,9 +424,10 @@ def parse_orchestrator_response(response, last_chunk=False, tag_prefix=""):
 
         elif in_invoke_action and f"<{tp}parameter" in line:
             if current_param_name:
-                current_action["parameters"][current_param_name] = "\n".join(
-                    current_param_value
-                ).strip()
+                param_value = "\n".join(current_param_value)
+                current_action["parameters"][current_param_name] = (
+                    clean_parameter_value(param_value)
+                )
                 current_param_value = []
 
             param_name_match = re.search(r'name\s*=\s*[\'"](\w+)[\'"]', line)
@@ -421,17 +440,19 @@ def parse_orchestrator_response(response, last_chunk=False, tag_prefix=""):
                     r">(.*?)(?:</" + tp + "parameter>|$)", line
                 )
                 if content_after_open:
-                    initial_content = content_after_open.group(1).strip()
+                    initial_content = content_after_open.group(1)
                     if initial_content:
                         current_param_value.append(initial_content)
 
                 # Check if parameter closes on same line
                 if f"</{tp}parameter>" in line:
-                    current_action["parameters"][current_param_name] = "\n".join(
-                        current_param_value
-                    ).strip()
+                    param_value = "\n".join(current_param_value)
+                    current_action["parameters"][current_param_name] = (
+                        clean_parameter_value(param_value)
+                    )
                     current_param_name = None
                     current_param_value = []
+
                     if "parameter" in open_tags:
                         open_tags.remove("parameter")
                 elif line.endswith("/>"):
@@ -446,25 +467,30 @@ def parse_orchestrator_response(response, last_chunk=False, tag_prefix=""):
             if f"</{tp}parameter>" in line:
                 # Handle content before closing tag on final line
                 content_before_close = re.sub(f"</{tp}parameter>.*", "", line)
-                if content_before_close.strip():
-                    current_param_value.append(content_before_close.strip())
-                current_action["parameters"][current_param_name] = "\n".join(
-                    current_param_value
-                ).strip()
+                if content_before_close:
+                    current_param_value.append(content_before_close)
+                param_value = "\n".join(current_param_value)
+                current_action["parameters"][current_param_name] = (
+                    clean_parameter_value(param_value)
+                )
                 current_param_name = None
                 current_param_value = []
                 if "parameter" in open_tags:
                     open_tags.remove("parameter")
             else:
-                current_param_value.append(line.strip())
+                current_param_value.append(line)
 
         else:
-            current_text.append(line)
+            # NOTE that we are intentionally ignoring all output text that occurs
+            # after any <invoke_action> tag. It has been told to never do this and
+            # if it does, then there is a good chance it is hallucinating responses
+            if not seen_invoke_action:
+                current_text.append(line)
 
     if open_tags:
         parsed_data["errors"].append(f"Unclosed tags: {', '.join(open_tags)}")
 
-    if in_file:
+    if in_file and not seen_invoke_action:
         content = "\n".join(file_content)
         # Add a status update for this
         parsed_data["status_updates"].append(
@@ -476,9 +502,28 @@ def parse_orchestrator_response(response, last_chunk=False, tag_prefix=""):
     if len(current_text) > 0:
         add_content_entry(parsed_data["content"], "text", current_text)
 
+    # Final check - if there is no reasoning, then the LLM is not complying with the
+    # request and we should return an error
+    if check_reasoning and not parsed_data["reasoning"]:
+        parsed_data["errors"].append("No <t###_reasoning> tag found")
+        parsed_data["content"] = []
+
     return parsed_data
 
 
+def strip_text_after_invoke_action(text):
+    """
+    Remove any text after the last </invoke_action> tag.
+    This is to prevent hallucinations from the LLM.
+    """
+    # Find the last instance of </t\d+_invoke_action> regexp and remove everything after it.
+    matches = list(re.finditer(r"</t\d+_invoke_action>", text))
+    if matches:
+        last_match_end = matches[-1].end()
+        return text[:last_match_end]
+    return text
+
+
 def remove_incomplete_tags_at_end(text):
     """If the end of the text is in the middle of a <tag> or </tag> then remove it."""
     # remove any open tags at the end
@@ -550,6 +595,35 @@ def match_solace_topic(subscription: str, topic: str) -> bool:
     )
 
 
+def clean_parameter_value(param_value):
+    """
+    Cleans a parameter value by:
+    1. Removing CDATA wrapper if present
+    2. Resolving XML entities like &gt;, &lt;, etc.
+
+    Parameters:
+    - param_value (str): The parameter value that might contain a CDATA wrapper
+                         and/or XML entities
+
+    Returns:
+    - str: The cleaned parameter value
+    """
+    if isinstance(param_value, str):
+        # Remove CDATA wrapper if present
+        cdata_match = re.match(r"\s*<!\[CDATA\[(.*?)\]\]>\s*$", param_value, re.DOTALL)
+        if cdata_match:
+            param_value = cdata_match.group(1)
+
+        # Resolve XML entities
+        param_value = param_value.replace("&lt;", "<")
+        param_value = param_value.replace("&gt;", ">")
+        param_value = param_value.replace("&amp;", "&")
+        param_value = param_value.replace("&quot;", '"')
+        param_value = param_value.replace("&apos;", "'")
+
+    return param_value
+
+
 def clean_text(text_array):
     # Any leading blank lines are removed
     while text_array and not text_array[0]:

solace_agent_mesh/config_portal/backend/common.py

@@ -0,0 +1,35 @@
+default_options = {
+    "namespace": "",
+    "config_dir": "configs",
+    "module_dir": "modules",
+    "env_file": ".env",
+    "build_dir": "build",
+    "broker_type": "solace",
+    "broker_url": "ws://localhost:8008",
+    "broker_vpn": "default",
+    "broker_username": "default",
+    "broker_password": "default",
+    "container_engine": "docker",
+    "llm_model_name": "openai/gpt-4o",
+    "llm_endpoint_url": "https://api.openai.com/v1",
+    "llm_api_key": "",
+    "embedding_model_name": "openai/text-embedding-ada-002",
+    "embedding_endpoint_url": "https://api.openai.com/v1",
+    "embedding_api_key": "",
+    "embedding_service_enabled": False,
+    "built_in_agent": ["web_request"],
+    "file_service_provider": "volume",
+    "file_service_config": ["directory=/tmp/solace-agent-mesh"],
+    "env_var": [],
+    "rest_api_enabled": True,
+    "rest_api_server_input_port": "5050",
+    "rest_api_server_host": "127.0.0.1",
+    "rest_api_server_input_endpoint": "/api/v1/request",
+    "rest_api_gateway_name": "rest-api",
+    "webui_enabled": True,
+    "webui_listen_port": "5001",
+    "webui_host": "localhost",
+    "dev_mode": True,
+}
+
+CONTAINER_RUN_COMMAND = " run -d -p 8080:8080 -p 55554:55555 -p 8008:8008 -p 1883:1883 -p 8000:8000 -p 5672:5672 -p 9000:9000 -p 2222:2222 --shm-size=2g --env username_admin_globalaccesslevel=admin --env username_admin_password=admin --name=solace solace/solace-pubsub-standard"

solace_agent_mesh/config_portal/backend/server.py

@@ -0,0 +1,233 @@
+import sys
+from flask import Flask, jsonify, request, send_from_directory, send_file
+from flask_cors import CORS
+import os
+import sys
+from solace_agent_mesh.config_portal.backend.common import default_options, CONTAINER_RUN_COMMAND 
+from cli.utils import get_formatted_names
+import shutil
+import litellm
+
+litellm.suppress_debug_info = True
+
+#disable flask startup banner
+import logging
+log = logging.getLogger('werkzeug')
+log.disabled = True
+cli = sys.modules['flask.cli']
+cli.show_server_banner = lambda *x: None
+
+def create_app(shared_config=None):
+    """Factory function that creates the Flask application with configuration injected"""
+    app = Flask(__name__)
+    CORS(app, resources={r"/api/*": {"origins": ["http://localhost:5174", "http://127.0.0.1:5174"]}})
+
+    EXCLUDE_OPTIONS = ["config_dir", "module_dir", "env_file", "build_dir", "container_engine", "rest_api_enabled",
+                     "rest_api_server_input_port", "rest_api_server_host", "rest_api_server_input_endpoint", 
+                     "rest_api_gateway_name", "webui_enabled", "webui_listen_port", "webui_host"]
+
+    @app.route('/api/default_options', methods=['GET'])
+    def get_default_options():
+        """Endpoint that returns the default options for form initialization"""
+        path = request.args.get('path', 'advanced')
+        
+        modified_default_options = default_options.copy()
+        
+        # Base exclusions for all paths
+        base_exclude_options = EXCLUDE_OPTIONS.copy()
+        
+        # Additional exclusions for quick path
+        quick_path_exclude_options = [
+            "namespace", "broker_type", "broker_url", "broker_vpn",
+            "broker_username", "broker_password", "container_engine",
+            "built_in_agent", "file_service_provider", "file_service_config"
+        ]
+        
+        # Apply exclusions based on path
+        exclude_options = base_exclude_options.copy()
+        if path == 'quick':
+            exclude_options.extend(quick_path_exclude_options)
+        
+        # Remove excluded options
+        for option in exclude_options:
+            modified_default_options.pop(option, None)
+        
+        return jsonify({
+            "default_options": modified_default_options,
+            "status": "success"
+        })
+
+    @app.route('/api/save_config', methods=['POST'])
+    def save_config():
+        """
+        Endpoint that accepts configuration data from the frontend,
+        merges it with default options, and updates the shared configuration.
+        """
+        try:
+            received_data = request.json
+            force = received_data.pop('force', False)
+
+            if not received_data:
+                return jsonify({"status": "error", "message": "No data received"}), 400
+            
+            complete_config = default_options.copy()
+            
+            # Update with the received data
+            for key, value in received_data.items():
+                if key in complete_config or key:
+                    complete_config[key] = value
+            
+            config_directory = complete_config["config_dir"]
+            formatted_name = get_formatted_names(complete_config["rest_api_gateway_name"])
+            gateway_directory = os.path.join(
+            config_directory, "gateways", formatted_name["SNAKE_CASE_NAME"]
+            )
+
+            #Handle the case where the gateway directory for rest already exists
+            if os.path.exists(gateway_directory) and not force:
+                return jsonify({"status": "ask_confirmation", "message": f"Gateway directory {gateway_directory} already exists, it will be overwritten."}), 400
+            elif os.path.exists(gateway_directory) and force:
+                shutil.rmtree(gateway_directory)
+
+            # Update the shared configuration if it exists
+            if shared_config is not None:
+                for key, value in complete_config.items():
+                    shared_config[key] = value
+            
+            return jsonify({
+                "status": "success",
+            })
+            
+        except Exception as e:
+            return jsonify({"status": "error", "message": str(e)}), 500
+    
+    @app.route('/api/test_llm_config', methods=['POST'])
+    def test_llm_config():
+        """
+        Endpoint that tests the LLM configuration given by the users"""
+        llm_config = request.json
+
+        #check for all values
+        if not llm_config.get("model") or not llm_config.get("api_key") or not llm_config.get("base_url"):
+            return jsonify({"status": "error", "message": "Please provide all the required values"}), 400
+
+        try:
+            response = litellm.completion(
+                model=llm_config.get("model"),
+                api_key=llm_config.get("api_key"),
+                base_url=llm_config.get("base_url"),
+                messages=[{"role":"user","content": "Say OK"}]
+                )
+            message = response.get("choices")[0].get("message")
+
+            if message is not None:
+                return jsonify({"status": "success", "message": message.content}), 200
+            else:
+                raise ValueError("No response from LLM")
+        except Exception:  
+            return jsonify({"status": "error", "message": "No response from LLM."}), 400
+
+
+
+    @app.route('/api/runcontainer', methods=['POST'])
+    def runcontainer():
+        try:
+            data = request.json or {}
+            
+            # Check if the user has podman or docker installed
+            has_podman = shutil.which("podman") is not None
+            has_docker = shutil.which("docker") is not None
+            
+            if not has_podman and not has_docker:
+                return jsonify({
+                    "status": "error", 
+                    "message": "You need to have either podman or docker installed to use the container broker."
+                }), 400
+            
+            # Determine which container engine to use
+            container_engine = data.get('container_engine')
+            
+            # If both are available, default to podman
+            if not container_engine and has_podman and has_docker:
+                container_engine = "podman"
+            # If only one is available, use that one
+            elif not container_engine:
+                container_engine = "podman" if has_podman else "docker"
+            
+            # Validate the container engine selection
+            if container_engine not in ["podman", "docker"]:
+                return jsonify({
+                    "status": "error", 
+                    "message": f"Invalid container engine: {container_engine}. Must be 'podman' or 'docker'."
+                }), 400
+            
+            if container_engine == "podman" and not has_podman:
+                return jsonify({
+                    "status": "error", 
+                    "message": "Podman was selected but is not installed on this system."
+                }), 400
+            
+            if container_engine == "docker" and not has_docker:
+                return jsonify({
+                    "status": "error", 
+                    "message": "Docker was selected but is not installed on this system."
+                }), 400
+            
+            # Run command for the container start
+            command = container_engine + CONTAINER_RUN_COMMAND
+            
+            # Execute the command and capture exit code
+            response_status = os.system(command)
+            
+            if response_status != 0:
+                return jsonify({
+                    "status": "error", 
+                    "message": f"Failed to start container. Exit code: {response_status}"
+                }), 500
+            
+            return jsonify({
+                "status": "success",
+                "message": f"Successfully started Solace PubSub+ broker container using {container_engine}",
+                "container_engine": container_engine
+            })
+            
+        except Exception as e:
+            return jsonify({"status": "error", "message": str(e)}), 500
+
+
+    @app.route('/api/shutdown', methods=['POST'])
+    def shutdown():
+        """Kills this Flask process immediately"""
+        response = jsonify({"message": "Server shutting down...", "status": "success"})
+        os._exit(0) 
+        return response
+        
+
+
+    @app.route("/assets/<path:path>")
+    def serve_assets(path):
+        return send_from_directory("../frontend/static/client/assets", path)
+
+    @app.route("/static/client/<path:path>")
+    def serve_client_files(path):
+        return send_from_directory("../frontend/static/client", path)
+
+    @app.route("/", defaults={"path": ""})
+    def serve(path):
+        return send_file("../frontend/static/client/index.html")
+
+    @app.route("/<path:path>")
+    def serve_files(path):
+        if path.endswith(('.png', '.jpg', '.jpeg', '.gif', '.ico')):
+            return send_from_directory("../frontend/static/client", path)
+        return send_file("../frontend/static/client/index.html")
+    
+    return app
+
+def run_flask(host="127.0.0.1", port=5002, shared_config=None):
+    """
+    Run the Flask development server with dependency-injected shared configuration.
+    """
+    app = create_app(shared_config)
+    app.run(host=host, port=port, debug=False, use_reloader=False)
+