solace-agent-mesh 1.1.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

solace_agent_mesh/cli/commands/init_cmd/orchestrator_step.py

@@ -1,17 +1,21 @@
-import click
+import re
 from pathlib import Path
+
+import click
 import yaml
-import re
-from ...utils import ask_if_not_provided, load_template, get_formatted_names
+
 from config_portal.backend.common import DEFAULT_COMMUNICATION_TIMEOUT
 
+from ...utils import ask_if_not_provided, get_formatted_names, load_template
+
 ORCHESTRATOR_DEFAULTS = {
     "agent_name": "OrchestratorAgent",
     "supports_streaming": True,
     "artifact_handling_mode": "reference",
     "enable_embed_resolution": True,
     "enable_artifact_content_instruction": True,
-    "session_service": {"type": "memory", "default_behavior": "PERSISTENT"},
+    "enable_builtin_artifact_tools": {"enabled": True},
+    "enable_builtin_data_tools": {"enabled": True},
     "artifact_service": {
         "type": "filesystem",
         "base_path": "/tmp/samv2",
@@ -83,16 +87,16 @@ def create_orchestrator_config(
         options,
         "session_service_type",
         "Enter session service type",
-        ORCHESTRATOR_DEFAULTS["session_service"]["type"],
+        "memory",
         skip_interactive,
-        choices=["memory", "vertex_rag"],
+        choices=["sql", "memory", "vertex_rag"],
     )
 
     session_behavior = ask_if_not_provided(
         options,
         "session_service_behavior",
         "Enter session service behavior",
-        ORCHESTRATOR_DEFAULTS["session_service"]["default_behavior"],
+        "PERSISTENT",
         skip_interactive,
         choices=["PERSISTENT", "RUN_BASED"],
     )
@@ -110,7 +114,7 @@ def create_orchestrator_config(
     s3_bucket_name = None
     s3_endpoint_url = None
     s3_region = None
-    
+
     if artifact_type == "filesystem":
         artifact_base_path = ask_if_not_provided(
             options,
@@ -127,7 +131,7 @@ def create_orchestrator_config(
             options["s3_endpoint_url"] = options["artifact_service_endpoint_url"]
         if options.get("artifact_service_region"):
             options["s3_region"] = options["artifact_service_region"]
-            
+
         s3_bucket_name = ask_if_not_provided(
             options,
             "s3_bucket_name",
@@ -304,18 +308,13 @@ def create_orchestrator_config(
         if artifact_type == "filesystem":
             artifact_base_path_line = f'base_path: "{artifact_base_path}"'
         elif artifact_type == "s3":
-            s3_config_lines = [f'bucket_name: "{s3_bucket_name}"']
-            if s3_endpoint_url:
-                s3_config_lines.append(f'endpoint_url: "{s3_endpoint_url}"')
-            if s3_region:
-                s3_config_lines.append(f'region: "{s3_region}"')
+            s3_config_lines = ["bucket_name: ${S3_BUCKET_NAME}"]
+            s3_config_lines.append("endpoint_url: ${S3_ENDPOINT_URL:-}")
+            s3_config_lines.append("region: ${S3_REGION}")
             artifact_base_path_line = "\n      ".join(s3_config_lines)
 
         shared_replacements = {
-            "__DEFAULT_SESSION_SERVICE_TYPE__": session_type,
-            "__DEFAULT_SESSION_SERVICE_BEHAVIOR__": session_behavior,
             "__DEFAULT_ARTIFACT_SERVICE_TYPE__": artifact_type,
-            "__DEFAULT_ARTIFACT_SERVICE_BASE_PATH_LINE__": artifact_base_path_line,
             "__DEFAULT_ARTIFACT_SERVICE_SCOPE__": artifact_scope,
         }
 
@@ -325,6 +324,18 @@ def create_orchestrator_config(
                 placeholder, str(value)
             )
 
+        if not artifact_base_path_line:
+            modified_shared_content = re.sub(
+                r"\s*# __DEFAULT_ARTIFACT_SERVICE_BASE_PATH_LINE__.*",
+                "",
+                modified_shared_content,
+            )
+        else:
+            modified_shared_content = modified_shared_content.replace(
+                "      # __DEFAULT_ARTIFACT_SERVICE_BASE_PATH_LINE__",
+                f"      {artifact_base_path_line}",
+            )
+
         shared_config_dest_path.parent.mkdir(parents=True, exist_ok=True)
         with open(shared_config_dest_path, "w", encoding="utf-8") as f:
             f.write(modified_shared_content)
@@ -366,8 +377,8 @@ def create_orchestrator_config(
     try:
         orchestrator_template_content = load_template("main_orchestrator.yaml")
 
-        session_service_block_for_orchestrator = "*default_session_service"
-        artifact_service_block_for_orchestrator = "*default_artifact_service"
+        formatted_name = get_formatted_names(options["agent_name"])
+        kebab_case_name = formatted_name.get("KEBAB_CASE_NAME")
 
         deny_list_line = ""
         if deny_list:
@@ -376,7 +387,7 @@ def create_orchestrator_config(
                 .strip()
                 .replace("'", '"')
             )
-            deny_list_line = f"deny_list: {deny_list_yaml}\n        "
+            deny_list_line = f"deny_list: {deny_list_yaml}"
 
         default_instruction = """You are the Orchestrator Agent within an AI agentic system. Your primary responsibilities are to:
         1. Process tasks received from external sources via the system Gateway.
@@ -390,8 +401,40 @@ def create_orchestrator_config(
         - You must then review the list of artifacts and return the ones that are important for the user by using the `signal_artifact_for_return` tool.
         - Provide regular progress updates using `status_update` embed directives, especially before initiating any tool call."""
 
-        formatted_name = get_formatted_names(options["agent_name"])
-        kebab_case_name = formatted_name.get("KEBAB_CASE_NAME")
+        if session_type == "sql":
+            session_service_lines = [
+                f'type: "{session_type}"',
+                'database_url: "${ORCHESTRATOR_DATABASE_URL}"',
+                f'default_behavior: "{session_behavior}"',
+            ]
+            session_service_block = "\n" + "\n".join(
+                [f"        {line}" for line in session_service_lines]
+            )
+
+            data_dir = project_root / "data"
+            data_dir.mkdir(exist_ok=True)
+            orchestrator_db_file = data_dir / "orchestrator.db"
+            orchestrator_database_url = f"sqlite:///{orchestrator_db_file.resolve()}"
+
+            try:
+                env_path = project_root / ".env"
+                with open(env_path, "a", encoding="utf-8") as f:
+                    f.write(
+                        f'\nORCHESTRATOR_DATABASE_URL="{orchestrator_database_url}"\n'
+                    )
+                click.echo(
+                    f"  Added ORCHESTRATOR_DATABASE_URL to .env: {orchestrator_database_url}"
+                )
+            except Exception as e:
+                click.echo(
+                    click.style(
+                        f"Warning: Could not add ORCHESTRATOR_DATABASE_URL to .env: {e}",
+                        fg="yellow",
+                    ),
+                    err=True,
+                )
+        else:
+            session_service_block = "*default_session_service"
 
         orchestrator_replacements = {
             "__NAMESPACE__": "${NAMESPACE}",
@@ -400,8 +443,8 @@ def create_orchestrator_config(
             "__AGENT_NAME__": options["agent_name"],
             "__LOG_FILE_NAME__": f"{kebab_case_name}.log",
             "__INSTRUCTION__": default_instruction,
-            "__SESSION_SERVICE__": session_service_block_for_orchestrator,
-            "__ARTIFACT_SERVICE__": artifact_service_block_for_orchestrator,
+            "__SESSION_SERVICE__": session_service_block,
+            "__ARTIFACT_SERVICE__": "*default_artifact_service",
             "__ARTIFACT_HANDLING_MODE__": artifact_handling_mode,
             "__ENABLE_EMBED_RESOLUTION__": str(enable_embed_resolution).lower(),
             "__ENABLE_ARTIFACT_CONTENT_INSTRUCTION__": str(
@@ -425,7 +468,6 @@ def create_orchestrator_config(
             )
             .strip()
             .replace("'", '"'),
-            "__INTER_AGENT_COMMUNICATION_DENY_LIST_LINE__": deny_list_line,
             "__INTER_AGENT_COMMUNICATION_TIMEOUT__": str(
                 inter_agent_communication_timeout
             ),
@@ -437,6 +479,19 @@ def create_orchestrator_config(
                 placeholder, str(value)
             )
 
+        if deny_list:
+            modified_orchestrator_content = modified_orchestrator_content.replace(
+                "__INTER_AGENT_COMMUNICATION_DENY_LIST_LINE__",
+                deny_list_line,
+            )
+        else:
+            modified_orchestrator_content = re.sub(
+                r"^\s*__INTER_AGENT_COMMUNICATION_DENY_LIST_LINE__\n?$",
+                "",
+                modified_orchestrator_content,
+                flags=re.MULTILINE,
+            )
+
         main_orchestrator_path.parent.mkdir(parents=True, exist_ok=True)
         with open(main_orchestrator_path, "w", encoding="utf-8") as f:
             f.write(modified_orchestrator_content)

solace_agent_mesh/cli/commands/init_cmd/web_init_step.py

@@ -1,9 +1,10 @@
-import click
 import multiprocessing
 import sys
 import webbrowser
-from ...utils import wait_for_server
 
+import click
+
+from ...utils import wait_for_server
 
 try:
     from config_portal.backend.server import run_flask
@@ -19,7 +20,6 @@ except ImportError as e:
     sys.exit(1)
 
 
-
 def perform_web_init(current_cli_params: dict) -> dict:
     """
     Launches the web-based configuration portal and updates params.
@@ -55,7 +55,7 @@ def perform_web_init(current_cli_params: dict) -> dict:
         else:
             click.echo(
                 click.style(
-                    f"Server did not start in time. Please check for errors and try again.",
+                    "Server did not start in time. Please check for errors and try again.",
                     fg="red",
                 )
             )
@@ -67,12 +67,34 @@ def perform_web_init(current_cli_params: dict) -> dict:
         init_gui_process.join()
         if shared_config_from_web:
             config_from_portal = dict(shared_config_from_web)
-            config_from_portal["llm_planning_model_name"] = config_from_portal.get(
-                "llm_planning_model_name"
-            ) or config_from_portal.get("llm_model_name")
-            config_from_portal["llm_general_model_name"] = config_from_portal.get(
-                "llm_general_model_name"
-            ) or config_from_portal.get("llm_model_name")
+
+            # Map web portal keys to CLI expected keys for backwards compatibility
+            key_mappings = {
+                "llm_api_key": "llm_service_api_key",
+                "llm_endpoint_url": "llm_service_endpoint",
+                "llm_model_name": "llm_service_model_name",
+            }
+
+            for old_key, new_key in key_mappings.items():
+                if old_key in config_from_portal and new_key not in config_from_portal:
+                    config_from_portal[new_key] = config_from_portal[old_key]
+
+            # Handle planning and general model names with fallback to single model name
+            config_from_portal["llm_service_planning_model_name"] = (
+                config_from_portal.get("llm_service_planning_model_name")
+                or config_from_portal.get("llm_planning_model_name")
+                or config_from_portal.get("llm_model_name")
+            )
+
+            config_from_portal["llm_service_general_model_name"] = (
+                config_from_portal.get("llm_service_general_model_name")
+                or config_from_portal.get("llm_general_model_name")
+                or config_from_portal.get("llm_model_name")
+            )
+
+            # Clean up deprecated keys if new keys are present
+            config_from_portal.pop("llm_planning_model_name", None)
+            config_from_portal.pop("llm_general_model_name", None)
 
             click.echo(
                 click.style("Configuration received from web portal.", fg="green")

solace_agent_mesh/cli/commands/init_cmd/webui_gateway_step.py

@@ -3,14 +3,15 @@ from pathlib import Path
 
 from ...utils import ask_if_not_provided, ask_yes_no_question, load_template
 
+
 WEBUI_GATEWAY_DEFAULTS = {
     "webui_frontend_welcome_message": "",
     "webui_frontend_bot_name": "Solace Agent Mesh",
     "webui_frontend_collect_feedback": False,
     "webui_session_secret_key": "please_change_me_in",
     "webui_fastapi_host": "127.0.0.1",
-    "webui_fastapi_port": 8000, # Store as int if CLI option is int
-    "webui_fastapi_https_port": 8443, # Store as int if CLI option is int
+    "webui_fastapi_port": 8000,
+    "webui_fastapi_https_port": 8443,
     "webui_ssl_keyfile": "",
     "webui_ssl_certfile": "",
     "webui_ssl_keyfile_password": "",
@@ -39,6 +40,10 @@ def create_webui_gateway_config(
 
     options["add_webui_gateway"] = add_gateway
 
+    if not add_gateway:
+        click.echo(click.style("  Skipping Web UI Gateway file creation.", fg="yellow"))
+        return True
+
     options["webui_session_secret_key"] = ask_if_not_provided(
         options,
         "webui_session_secret_key",
@@ -69,9 +74,11 @@ def create_webui_gateway_config(
         none_interactive=skip_interactive,
     )
     options["webui_fastapi_https_port"] = ask_if_not_provided(
-        options, "webui_fastapi_https_port", "Enter Web UI FastAPI HTTPS Port",
+        options,
+        "webui_fastapi_https_port",
+        "Enter Web UI FastAPI HTTPS Port",
         default=default_values.get("webui_fastapi_https_port", 8443),
-        none_interactive=skip_interactive
+        none_interactive=skip_interactive,
     )
     options["webui_enable_embed_resolution"] = ask_if_not_provided(
         options,
@@ -85,19 +92,26 @@ def create_webui_gateway_config(
         is_bool=True,
     )
     options["webui_ssl_keyfile"] = ask_if_not_provided(
-        options, "webui_ssl_keyfile", "Enter SSL Key File Path",
+        options,
+        "webui_ssl_keyfile",
+        "Enter SSL Key File Path",
         default=default_values.get("webui_ssl_keyfile", ""),
-        none_interactive=skip_interactive
+        none_interactive=skip_interactive,
     )
     options["webui_ssl_certfile"] = ask_if_not_provided(
-        options, "webui_ssl_certfile", "Enter SSL Certificate File Path",
+        options,
+        "webui_ssl_certfile",
+        "Enter SSL Certificate File Path",
         default=default_values.get("webui_ssl_certfile", ""),
-        none_interactive=skip_interactive
+        none_interactive=skip_interactive,
     )
     options["webui_ssl_keyfile_password"] = ask_if_not_provided(
-        options, "webui_ssl_keyfile_password", "Enter SSL Key File Passphrase",
+        options,
+        "webui_ssl_keyfile_password",
+        "Enter SSL Key File Passphrase",
         default=default_values.get("webui_ssl_keyfile_password", ""),
-        none_interactive=skip_interactive, hide_input=True
+        none_interactive=skip_interactive,
+        hide_input=True,
     )
 
     options["webui_frontend_welcome_message"] = ask_if_not_provided(
@@ -131,15 +145,58 @@ def create_webui_gateway_config(
         is_bool=True,
     )
 
-    if not add_gateway:
-        click.echo(click.style("  Skipping Web UI Gateway file creation.", fg="yellow"))
-        return True
+    session_type = ask_if_not_provided(
+        options,
+        "webui_session_service_type",
+        "Enter WebUI session service type",
+        "sql",
+        skip_interactive,
+        choices=["sql", "memory"],
+    )
+
+    session_behavior = ask_if_not_provided(
+        options,
+        "webui_session_service_behavior",
+        "Enter WebUI session service behavior",
+        "PERSISTENT",
+        skip_interactive,
+        choices=["PERSISTENT", "RUN_BASED"],
+    )
 
     click.echo("Creating Web UI Gateway configuration file...")
     destination_path = project_root / "configs" / "gateways" / "webui.yaml"
 
     try:
         template_content = load_template("webui.yaml")
+        
+        if session_type == "sql":
+            session_service_lines = [
+                f'type: "{session_type}"',
+                f'database_url: "${{WEB_UI_GATEWAY_DATABASE_URL}}"',
+                f'default_behavior: "{session_behavior}"',
+            ]
+            session_service_block = "\n" + "\n".join(
+                [f"        {line}" for line in session_service_lines]
+            )
+            
+            data_dir = project_root / "data"
+            data_dir.mkdir(exist_ok=True)
+            webui_db_file = data_dir / "webui_gateway.db"
+            webui_database_url = f"sqlite:///{webui_db_file.resolve()}"
+            
+            try:
+                env_path = project_root / ".env"
+                with open(env_path, "a", encoding="utf-8") as f:
+                    f.write(f'\nWEB_UI_GATEWAY_DATABASE_URL="{webui_database_url}"\n')
+                click.echo(f"  Added WEB_UI_GATEWAY_DATABASE_URL to .env: {webui_database_url}")
+            except Exception as e:
+                click.echo(
+                    click.style(f"Warning: Could not add WEB_UI_GATEWAY_DATABASE_URL to .env: {e}", fg="yellow"),
+                    err=True,
+                )
+        else:
+            session_service_block = "*default_session_service"
+        
         replacements = {
             "__FRONTEND_WELCOME_MESSAGE__": str(
                 options.get("webui_frontend_welcome_message", "")
@@ -150,11 +207,13 @@ def create_webui_gateway_config(
             "__FRONTEND_COLLECT_FEEDBACK__": str(
                 options.get("webui_frontend_collect_feedback", False)
             ).lower(),
+            "__SESSION_SERVICE__": session_service_block,
         }
 
         modified_content = template_content
         for placeholder, value in replacements.items():
-            modified_content = modified_content.replace(placeholder, value)
+            if value is not None:
+                modified_content = modified_content.replace(placeholder, str(value))
 
         destination_path.parent.mkdir(parents=True, exist_ok=True)
         with open(destination_path, "w", encoding="utf-8") as f:
@@ -164,7 +223,7 @@ def create_webui_gateway_config(
         return True
 
     except FileNotFoundError:
-        click.echo(click.style(f"Error: Template file not found.", fg="red"), err=True)
+        click.echo(click.style("Error: Template file not found.", fg="red"), err=True)
         return False
     except IOError as e:
         click.echo(

solace_agent_mesh/cli/commands/plugin_cmd/create_cmd.py

@@ -18,12 +18,10 @@ DEFAULT_PLUGIN_VERSION = "0.1.0"
 
 
 def ensure_directory_exists(path: pathlib.Path):
-    """Creates a directory if it doesn't exist."""
     path.mkdir(parents=True, exist_ok=True)
 
 
 def replace_placeholders(content: str, replacements: dict) -> str:
-    """Replaces placeholders in a string."""
     for placeholder, value in replacements.items():
         content = content.replace(placeholder, str(value))
     return content

solace_agent_mesh/cli/commands/run_cmd.py

@@ -1,8 +1,10 @@
-import click
 import os
 import sys
 from pathlib import Path
-from dotenv import load_dotenv, find_dotenv
+
+import click
+from dotenv import find_dotenv, load_dotenv
+
 from cli.utils import error_exit
 from solace_agent_mesh.common.utils.initializer import initialize
 
@@ -110,7 +112,7 @@ def run(files: tuple[str, ...], skip_files: tuple[str, ...], system_env: bool):
                 ),
                 err=True,
             )
-            return 1
+            sys.exit(1)
 
         for filepath in configs_dir.rglob("*.yaml"):
             if filepath.name.startswith("_") or filepath.name.startswith(

solace_agent_mesh/cli/utils.py

@@ -1,10 +1,12 @@
+import importlib
 import os
+import re
 from pathlib import Path
-import importlib
+from time import sleep
+
 import click
-import re
 import requests
-from time import sleep
+from sqlalchemy import create_engine, event
 
 
 def ask_yes_no_question(question: str, default=False) -> bool:
@@ -83,7 +85,7 @@ def load_template(name, parser=None, *args):
     if not os.path.exists(template_file):
         raise FileNotFoundError(f"Template file '{template_file}' does not exist.")
 
-    with open(template_file, "r", encoding="utf-8") as f:
+    with open(template_file, encoding="utf-8") as f:
         if parser:
             file = parser(f.read(), *args)
         else:
@@ -94,21 +96,23 @@ def load_template(name, parser=None, *args):
 
 def get_formatted_names(name: str):
     # Normalize separators
-    normalized = re.sub(r'[\s\-_]+', '_', name.strip())
+    normalized = re.sub(r"[\s\-_]+", "_", name.strip())
 
-    camel_case_split = re.sub(r'([a-z0-9])([A-Z])', r'\1_\2', normalized)      # fooBar -> foo_Bar
-    acronym_split = re.sub(r'([A-Z]+)([A-Z][a-z])', r'\1_\2', camel_case_split)        # APIKey -> API_Key
+    camel_case_split = re.sub(
+        r"([a-z0-9])([A-Z])", r"\1_\2", normalized
+    )  # fooBar -> foo_Bar
+    acronym_split = re.sub(
+        r"([A-Z]+)([A-Z][a-z])", r"\1_\2", camel_case_split
+    )  # APIKey -> API_Key
 
-    raw_parts = [p for p in acronym_split.split('_') if p]
+    raw_parts = [p for p in acronym_split.split("_") if p]
 
     parts = [p.lower() for p in raw_parts]
 
     # Spaced capitalized name:
     #   - If original was all caps, keep it all caps (API -> API)
     #   - Else capitalize normally
-    spaced_capitalized_parts = [
-        p if p.isupper() else p.capitalize() for p in raw_parts
-    ]
+    spaced_capitalized_parts = [p if p.isupper() else p.capitalize() for p in raw_parts]
 
     return {
         "KEBAB_CASE_NAME": "-".join(parts),
@@ -192,6 +196,7 @@ def indent_multiline_string(
     else:
         return "\n".join(indentation + line for line in text.splitlines()).lstrip()
 
+
 def wait_for_server(url, timeout=30):
     start = 0
     while start < timeout:
@@ -203,4 +208,55 @@ def wait_for_server(url, timeout=30):
             pass
         sleep(0.5)
         start += 0.5
-    return False
+    return False
+
+
+def create_and_validate_database(database_url: str, db_name: str = "database") -> bool:
+    """
+    Create and validate a database connection.
+
+    Args:
+        database_url (str): Database URL to validate
+        db_name (str): Descriptive name for logging purposes
+
+    Returns:
+        bool: True if successful, raises exception if failed
+    """
+    try:
+        # Handle SQLite file creation
+        if database_url.startswith("sqlite:///"):
+            db_file_path_str = database_url.replace("sqlite:///", "")
+            db_file_path = Path(db_file_path_str)
+            db_file_path.parent.mkdir(parents=True, exist_ok=True)
+
+            engine = create_engine(database_url)
+
+            @event.listens_for(engine, "connect")
+            def set_sqlite_pragma(dbapi_connection, connection_record):
+                cursor = dbapi_connection.cursor()
+                cursor.execute("PRAGMA foreign_keys=ON")
+                cursor.close()
+        elif database_url.startswith("postgresql"):
+            # Check if PostgreSQL driver is available
+            try:
+                import psycopg2
+            except ImportError:
+                raise ImportError(
+                    "PostgreSQL support requires psycopg2. Install with: "
+                    "pip install 'solace-agent-mesh[postgresql]'"
+                )
+            engine = create_engine(database_url)
+        else:
+            engine = create_engine(database_url)
+
+        with engine.connect() as connection:
+            pass
+
+        engine.dispose()
+        click.echo(click.style(f"  {db_name} validation successful.", fg="green"))
+        return True
+
+    except Exception as e:
+        error_msg = f"Database connection failed for {db_name}: {e}"
+        click.echo(click.style(f"  Error: {error_msg}", fg="red"), err=True)
+        raise ValueError(error_msg)

solace_agent_mesh/client/webui/frontend/static/assets/authCallback-vY5eu2lI.js

@@ -0,0 +1 @@
+import{c as n}from"./client-BeBkzgWW.js";import{r as a,j as s}from"./vendor-CE0AeXyK.js";function c(){return a.useEffect(()=>{const r=window.location.hash.substring(1),e=new URLSearchParams(r),o=e.get("access_token"),t=e.get("refresh_token");o?(localStorage.setItem("access_token",o),t&&localStorage.setItem("refresh_token",t),window.location.href="/"):console.error("AuthCallback: No access token found in URL hash.")},[]),s.jsx("div",{children:"Loading..."})}n.createRoot(document.getElementById("root")).render(s.jsx(c,{}));