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

solace_agent_mesh/cli/commands/init_cmd/env_step.py

@@ -18,6 +18,8 @@ ENV_DEFAULTS = {
     "FASTAPI_PORT": "8000",
     "FASTAPI_HTTPS_PORT": "8443",
     "ENABLE_EMBED_RESOLUTION": "true",
+    "WEB_UI_GATEWAY_DATABASE_URL": "sqlite:///data/webui_gateway.db",
+    "ORCHESTRATOR_DATABASE_URL": "sqlite:///data/orchestrator.db",
     "SSL_KEYFILE": "",
     "SSL_CERTFILE": "",
     "SSL_KEYFILE_PASSWORD": "",
@@ -39,28 +41,28 @@ def create_env_file(project_root: Path, options: dict, skip_interactive: bool) -
 
     env_params_config = [
         (
-            "llm_endpoint_url",
+            "llm_service_endpoint",
             "LLM_SERVICE_ENDPOINT",
             "Enter LLM Service Endpoint URL",
             False,
             "LLM_SERVICE_ENDPOINT",
         ),
         (
-            "llm_api_key",
+            "llm_service_api_key",
             "LLM_SERVICE_API_KEY",
             "Enter LLM Service API Key",
             True,
             "LLM_SERVICE_API_KEY",
         ),
         (
-            "llm_planning_model_name",
+            "llm_service_planning_model_name",
             "LLM_SERVICE_PLANNING_MODEL_NAME",
             "Enter LLM Planning Model Name (e.g., openai/gpt-4o)",
             False,
             "LLM_SERVICE_PLANNING_MODEL_NAME",
         ),
         (
-            "llm_general_model_name",
+            "llm_service_general_model_name",
             "LLM_SERVICE_GENERAL_MODEL_NAME",
             "Enter LLM General Model Name (e.g., openai/gpt-3.5-turbo)",
             False,
@@ -134,28 +136,28 @@ def create_env_file(project_root: Path, options: dict, skip_interactive: bool) -
             "FASTAPI_HTTPS_PORT",
             "Enter Web UI FastAPI HTTPS Port",
             False,
-            "FASTAPI_HTTPS_PORT"
+            "FASTAPI_HTTPS_PORT",
         ),
         (
             "webui_ssl_keyfile",
             "SSL_KEYFILE",
             "Enter SSL Key File Path",
             False,
-            "SSL_KEYFILE"
+            "SSL_KEYFILE",
         ),
         (
             "webui_ssl_certfile",
             "SSL_CERTFILE",
             "Enter SSL Certificate File Path",
             False,
-            "SSL_CERTFILE"
+            "SSL_CERTFILE",
         ),
         (
             "webui_ssl_keyfile_password",
             "SSL_KEYFILE_PASSWORD",
             "Enter SSL Key File Passphrase",
             True,
-            "SSL_KEYFILE_PASSWORD"
+            "SSL_KEYFILE_PASSWORD",
         ),
         (
             "webui_enable_embed_resolution",
@@ -207,6 +209,15 @@ def create_env_file(project_root: Path, options: dict, skip_interactive: bool) -
         )
         env_vars_to_write[env_name] = options.get(opt_key)
 
+    if options.get("web_ui_gateway_database_url"):
+        env_vars_to_write["WEB_UI_GATEWAY_DATABASE_URL"] = options[
+            "web_ui_gateway_database_url"
+        ]
+    if options.get("orchestrator_database_url"):
+        env_vars_to_write["ORCHESTRATOR_DATABASE_URL"] = options[
+            "orchestrator_database_url"
+        ]
+
     if (
         env_vars_to_write.get("NAMESPACE")
         and env_vars_to_write["NAMESPACE"] != ENV_DEFAULTS.get("NAMESPACE")

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(