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

solace_agent_mesh/cli/commands/init/create_config_file_step.py

@@ -0,0 +1,52 @@
+import click
+
+from cli.config import Config
+
+
+def create_config_file_step(options, default_options, none_interactive, abort):
+    """
+    Creates the configuration files.
+    """
+    sam_config = Config.get_default_config()
+
+    # Set up the built-in agents
+    builtin_agents_ref = (
+        sam_config.get("solace_agent_mesh", {}).get("built_in", {}).get("agents", [])
+    )
+    builtin_agents = options.get("built_in_agent", [])
+    for agent in builtin_agents_ref:
+        agent["enabled"] = agent["name"] in builtin_agents or agent["name"] == "global"
+
+    # Set up the project structure
+    sam_config.get("solace_agent_mesh", {})["config_directory"] = options.get("config_dir")
+    sam_config.get("solace_agent_mesh", {})["modules_directory"] = options.get("module_dir")
+    sam_config.get("solace_agent_mesh", {})["env_file"] = options.get("env_file")
+    sam_config.get("solace_agent_mesh", {}).get("build", {})["build_directory"] = (
+        options.get("build_dir")
+    )
+
+    # Set up the file service
+    file_service_ref = (
+        sam_config.get("solace_agent_mesh", {})
+        .get("runtime", {})
+        .get("services", {})
+        .get("file_service", {})
+    )
+    provider = options.get("file_service_provider")
+    file_service_ref["type"] = provider
+    if "config" not in file_service_ref:
+        file_service_ref["config"] = {}
+    if provider not in file_service_ref["config"]:
+        file_service_ref["config"][provider] = {}
+    for pair in options.get("file_service_config", []):
+        if "=" not in pair:
+            continue
+        key, value = pair.split("=")
+        file_service_ref["config"][provider][key] = value
+
+    Config.write_config(sam_config)
+    click.echo("Project files have been created.")
+
+    #update context (this is needed for add_gateway_command to work properly in the next step)
+    ctx = click.get_current_context()
+    ctx.obj['solace_agent_mesh'] = sam_config['solace_agent_mesh']

solace_agent_mesh/cli/commands/init/create_other_project_files_step.py

@@ -0,0 +1,96 @@
+import os
+from cli.commands.add.gateway import add_gateway_command
+
+def create_if_not_exists(file_path, content):
+    if not os.path.exists(file_path):
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(content)
+
+
+def add_pair_to_file_if_not_exists(file_path, pairs):
+    with open(file_path, "r", encoding="utf-8") as f:
+        content = f.read()
+
+    for key, value in pairs:
+        if key not in content:
+            with open(file_path, "a", encoding="utf-8") as f:
+                f.write(f"{key}{value}\n")
+
+
+def create_other_project_files_step(options, default_options, none_interactive, abort):
+    """
+    Creates the other project files. i.e. .gitignore, .env, requirements.txt, etc.
+    """
+    # Create .gitignore file
+    ignore = (
+        "*.pyc\n"
+        "__pycache__\n"
+        ".env\n"
+        ".venv\n"
+        "env/\n"
+        "venv/\n"
+        "log\n"
+        f"{options['env_file']}\n"
+        f"{options['build_dir']}\n"
+    )
+    create_if_not_exists(".gitignore", ignore)
+
+    # Create requirements.txt file
+    required_dependencies = [
+        ("solace-agent-mesh", "~=0.1.0"),
+    ]
+    create_if_not_exists("requirements.txt", "")
+    add_pair_to_file_if_not_exists("requirements.txt", required_dependencies)
+
+    # Create .env file
+    required_env_variables = [
+        ("SOLACE_AGENT_MESH_NAMESPACE", f"={options['namespace']}"),
+        ("SOLACE_DEV_MODE", f"={options['dev_mode']}"),
+        ("SOLACE_BROKER_URL", f"={options['broker_url']}"),
+        ("SOLACE_BROKER_VPN", f"={options['broker_vpn']}"),
+        ("SOLACE_BROKER_USERNAME", f"={options['broker_username']}"),
+        ("SOLACE_BROKER_PASSWORD", f"={options['broker_password']}"),
+        ("LLM_SERVICE_API_KEY", f"={options['llm_api_key']}"),
+        ("LLM_SERVICE_ENDPOINT", f"={options['llm_endpoint_url']}"),
+        ("LLM_SERVICE_PLANNING_MODEL_NAME", f"={options['llm_model_name']}"),
+        ("EMBEDDING_SERVICE_MODEL_NAME", f"={options['embedding_model_name']}"),
+        ("EMBEDDING_SERVICE_API_KEY", f"={options['embedding_api_key']}"),
+        ("EMBEDDING_SERVICE_ENDPOINT", f"={options['embedding_endpoint_url']}"),
+        ("RUNTIME_CONFIG_PATH", f"={options['build_dir']}/config.yaml"),
+    ]
+
+    if options.get("rest_api_enabled"):
+        #REST API env variables
+        rest_api_env_variables = [
+            ("REST_API_SERVER_INPUT_PORT", f"={options.get('rest_api_server_input_port', '')}"),
+            ("REST_API_SERVER_HOST", f"={options.get('rest_api_server_host', '')}"),
+            ("REST_API_SERVER_INPUT_ENDPOINT", f"={options.get('rest_api_server_input_endpoint', '')}"),
+        ]
+
+        required_env_variables.extend(rest_api_env_variables)
+
+    if options.get("webui_enabled"):
+        webui_env_variables = [
+            #Web UI env variables
+            ("WEBUI_ENABLED", f"={options['webui_enabled']}"),
+            ("WEBUI_PORT", f"={options['webui_listen_port']}"),
+            ("WEBUI_HOST", f"={options['webui_host']}"),
+            ("WEBUI_RESPONSE_API_URL", f"=http://{options['rest_api_server_host']}:{options['rest_api_server_input_port']}{options['rest_api_server_input_endpoint']}"),
+            ("WEBUI_FRONTEND_SERVER_URL", f"=http://{options['webui_host']}:{options['webui_listen_port']}"),
+            ("WEBUI_FRONTEND_URL", f"=http://{options['webui_host']}:{options['webui_listen_port']}"),
+        ]
+
+        required_env_variables.extend(webui_env_variables)
+
+    env_var_list = [
+        *default_options.get("env_var", []),
+        *list(options.get("env_var", [])),
+    ]
+    for env_var in env_var_list:
+        if "=" in env_var:
+            key, value = env_var.split("=")
+            required_env_variables.append((key, f"={value}"))
+
+    create_if_not_exists(options["env_file"], "")
+    add_pair_to_file_if_not_exists(options["env_file"], required_env_variables)
+    add_gateway_command(options["rest_api_gateway_name"],["rest-api"])

solace_agent_mesh/cli/commands/init/file_service_step.py

@@ -0,0 +1,73 @@
+import click
+
+from cli.utils import ask_if_not_provided, get_display_path
+
+
+def file_service_step(options, default_options, none_interactive, abort):
+    """
+    Initialize the file service.
+    """
+    provider = ask_if_not_provided(
+        options,
+        "file_service_provider",
+        (
+            "Choose a file service provider\n"
+            "\t-  Volume: Use a local volume (directory) to store files\n"
+            "\t-  Bucket: Use a cloud bucket to store files (Must use AWS S3 API)\n"
+            "Enter the provider"
+        ),
+        default_options["file_service_provider"],
+        none_interactive,
+        ("volume", "bucket"),
+    )
+
+    configs = {}
+    if "file_service_config" in options and options["file_service_config"]:
+        config_list = list(options["file_service_config"])
+        for config in config_list:
+            if "=" in config:
+                key, value = config.split("=")
+                configs[key] = value
+
+    default_config = {
+        "directory": "/tmp/solace-agent-mesh"
+    }
+    for config in default_options["file_service_config"]:
+        if "=" in config:
+            key, value = config.split("=")
+            default_config[key] = value
+
+    if provider == "volume":
+        ask_if_not_provided(
+            configs,
+            "directory",
+            "Provide the path to the volume directory",
+            default_config.get("directory"),
+            none_interactive,
+        )
+    elif provider == "bucket":
+        ask_if_not_provided(
+            configs,
+            "bucket_name",
+            "Provide the name of the bucket",
+            default_config.get("bucket_name"),
+            none_interactive,
+        )
+        # endpoint_url
+        ask_if_not_provided(
+            configs,
+            "endpoint_url",
+            "Provide the endpoint URL",
+            default_config.get("endpoint_url", ""),
+            none_interactive,
+        )
+        click.echo(
+            click.style(
+                f"You can setup the Boto3 authentication configuration in the {get_display_path('solace-agent-mesh.yaml')} file",
+                fg="yellow",
+            )
+        )
+
+    options["file_service_config"] = [
+        f"{key}={value}" for key, value in configs.items()
+    ]

solace_agent_mesh/cli/commands/init/init.py

@@ -0,0 +1,114 @@
+import click
+import sys
+
+from .check_if_already_done import check_if_already_done
+from .ai_provider_step import ai_provider_step
+from .broker_step import broker_step
+from .builtin_agent_step import builtin_agent_step
+from .create_config_file_step import create_config_file_step
+from .file_service_step import file_service_step
+from .project_structure_step import project_structure_step
+from .create_other_project_files_step import create_other_project_files_step
+from .rest_api_step import rest_api_step
+from .web_ui_step import webui_step
+
+from cli.utils import (
+    log_error,
+)
+
+default_options = {
+    "namespace": "",
+    "config_dir": "configs",
+    "module_dir": "modules",
+    "env_file": ".env",
+    "build_dir": "build",
+    "broker_type": "container",
+    "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": "",
+    "built_in_agent": [],
+    "file_service_provider": "volume",
+    "file_service_config": ["volume=/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"
+}
+"""
+Default options for the init command.
+"""
+
+
+def abort(message: str):
+    """Abort the init and cleanup"""
+    log_error(f"Init failed: {message}.")
+    # os.system(f"rm -rf {build_dir}")
+    sys.exit(1)
+
+
+def init_command(options={}):
+    """
+    Initialize the Solace Agent Mesh application.
+    """
+    click.echo(click.style("Initializing Solace Agent Mesh", bold=True, fg="blue"))
+    skip = False
+    if "skip" in options and options["skip"]:
+        skip = True
+
+    # no description for hidden steps
+    steps = [
+        ("", check_if_already_done),
+        ("Project structure setup", project_structure_step),
+        ("Broker setup", broker_step),
+        ("AI provider setup", ai_provider_step),
+        ("Builtin agent setup", builtin_agent_step),
+        ("File service setup", file_service_step),
+        ("REST API setup", rest_api_step),
+        ("Web UI setup", webui_step),
+        ("", create_config_file_step),
+        ("Setting up project", create_other_project_files_step),
+    ]
+    non_hidden_steps_count = len([step for step in steps if step[0]])
+
+    step = 0
+    try:
+        for name, function in steps:
+            if name:
+                step += 1
+                click.echo(
+                    click.style(
+                        f"Step {step} of {non_hidden_steps_count}: {name}", fg="blue"
+                    )
+                )
+            function(options, default_options, skip, abort)
+    except KeyboardInterrupt:
+        abort("\n\nAborted by user")
+
+    click.echo(click.style("Solace Agent Mesh has been initialized", fg="green"))
+
+    if not skip:
+        click.echo(
+            click.style(
+                "Review the `solace-agent-mesh` config file and make any necessary changes.",
+                fg="yellow",
+            )
+        )
+        click.echo(
+            click.style(
+                "To get started, use the `solace-agent-mesh add` command to add agents and gateways",
+                fg="blue",
+            )
+        )

solace_agent_mesh/cli/commands/init/project_structure_step.py

@@ -0,0 +1,45 @@
+from cli.utils import ask_if_not_provided
+
+
+def project_structure_step(options, default_options, none_interactive, abort):
+    """
+    Initialize the project structure.
+    """
+    namespace = ask_if_not_provided(
+        options,
+        "namespace",
+        "Enter a namespace for the project (It will be used as the topic prefix for all events.)",
+        default_options["namespace"],
+        none_interactive,
+    )
+    if namespace and not namespace.endswith("/"):
+        options["namespace"] = f"{namespace}/"
+
+    ask_if_not_provided(
+        options,
+        "config_dir",
+        "Enter base directory for config files",
+        default_options["config_dir"],
+        none_interactive,
+    )
+    ask_if_not_provided(
+        options,
+        "module_dir",
+        "Enter base directory for python modules",
+        default_options["module_dir"],
+        none_interactive,
+    )
+    ask_if_not_provided(
+        options,
+        "build_dir",
+        "Enter base directory for the build output",
+        default_options["build_dir"],
+        none_interactive,
+    )
+    ask_if_not_provided(
+        options,
+        "env_file",
+        "Enter environment file path",
+        default_options["env_file"],
+        none_interactive,
+    )

solace_agent_mesh/cli/commands/init/rest_api_step.py

@@ -0,0 +1,50 @@
+from cli.utils import ask_if_not_provided
+import click
+
+def rest_api_step(options, default_options, none_interactive, abort):
+    """
+    Initialize the REST API.
+    """
+
+    enabled = ask_if_not_provided(
+        options,
+        "rest_api_enabled",
+        "Set up the REST API interface? (Required for Web UI setup in the next step.)",
+        default_options["rest_api_enabled"],
+        none_interactive,
+    )
+
+    if not enabled:
+       return
+    
+    ask_if_not_provided(
+        options,
+        "rest_api_server_input_port",
+        "REST API server port",
+        default_options["rest_api_server_input_port"],
+        none_interactive,
+    )
+    ask_if_not_provided(
+        options,
+        "rest_api_server_host",
+        "REST API server host", 
+        default_options["rest_api_server_host"],
+        none_interactive,
+    )
+    ask_if_not_provided(
+        options,
+        "rest_api_server_input_endpoint",
+        "REST API endpoint",
+        default_options["rest_api_server_input_endpoint"],
+        none_interactive,
+    )
+    ask_if_not_provided(
+        options,
+        "rest_api_gateway_name",
+        "What would you like to call the gateway",
+        default_options["rest_api_gateway_name"],
+        none_interactive,
+    )
+
+    click.echo("\nAdditional configuration options are availale for the REST API such as enabling authentication, rate limits etc.")
+    click.echo("Please refer to our documentation for detailed setup instructions.\n")

solace_agent_mesh/cli/commands/init/web_ui_step.py

@@ -0,0 +1,40 @@
+from cli.utils import ask_if_not_provided
+import click
+
+def webui_step(options, default_options, none_interactive, abort):
+    """
+    Initialize the Web UI configuration.
+    """
+    if not options.get("rest_api_enabled"):
+        click.echo(click.style("Skipping setup for Web UI because REST API was not enabled", bold=False, fg="yellow"))
+        return
+    
+    enabled = ask_if_not_provided(
+        options,
+        "webui_enabled",
+        "Enable Web UI?",
+        default_options["webui_enabled"],
+        none_interactive=none_interactive,
+    )
+
+    if not enabled:
+       return
+     
+    ask_if_not_provided(
+        options,
+        "webui_listen_port",
+        "Server listen port",
+        default_options["webui_listen_port"],
+        none_interactive,
+    )
+
+    ask_if_not_provided(
+        options,
+        "webui_host",
+        "Server host",
+        default_options["webui_host"],
+        none_interactive,
+    )
+
+    click.echo("\nAdditional configuration options are availale for the Web UI such as enabling authentication, collecting feedback etc.")
+    click.echo("Please refer to our documentation for detailed setup instructions.\n")

solace_agent_mesh/cli/commands/plugin/__init__.py

@@ -0,0 +1,3 @@
+from .plugin import plugin_command
+
+__all__ = ["plugin_command"]

solace_agent_mesh/cli/commands/plugin/add.py

@@ -0,0 +1,98 @@
+import os
+import subprocess
+import click
+
+from cli.utils import log_error, load_plugin
+from cli.config import Config
+
+
+def add_command(name: str, installer: str = None, from_url=None, add_all=False):
+    """
+    Add a new plugin to solace-agent-mesh config yaml
+    Optional install the module if not found
+
+    Args:
+        name (str): The name of the plugin module to import.
+        installer (str, optional): Installer to use if the module is not installed.
+                                   Should be one of 'pip', 'poetry', 'conda', or None.
+    """
+    name = name.replace("-", "_")
+    sam_config = Config.get_user_config()
+    if not sam_config:
+        sam_config = Config.get_default_config()
+
+    if "plugins" not in sam_config["solace_agent_mesh"] or not sam_config["solace_agent_mesh"]["plugins"]:
+        sam_config["solace_agent_mesh"]["plugins"] = []
+
+    if any(plugin["name"] == name for plugin in sam_config["solace_agent_mesh"]["plugins"]):
+        log_error(f"Plugin '{name}' already exists.")
+        return 1
+    
+    # Attempt to import the module
+    module, module_path = load_plugin(name)
+    if not module:
+        if installer:
+            install_name = from_url or name
+            click.echo(
+                f"Module '{name}' not found. Attempting to install '{install_name}' using {installer}..."
+            )
+            if installer == "pip":
+                subprocess.check_call(["pip", "install", install_name])
+            elif installer == "poetry":
+                subprocess.check_call(["poetry", "add", install_name])
+            elif installer == "conda":
+                subprocess.check_call(["conda", "install", install_name])
+            else:
+                log_error(f"Unsupported installer: {installer}")
+                return 1
+            # Retry importing after installation
+            module, module_path = load_plugin(name)
+            if not module:
+                log_error(f"Failed to import module '{name}' after installation.")
+                return 1
+
+            # Adding to requirements.txt if exists and not already added
+            if os.path.exists("requirements.txt"):
+                with open("requirements.txt", "r", encoding="utf-8") as f:
+                    requirements = f.read().splitlines()
+                if install_name not in requirements:
+                    with open("requirements.txt", "a", encoding="utf-8") as f:
+                        f.write(f"\n{install_name}")
+        else:
+            log_error(
+                f"Module '{name}' is not installed, and no installer was provided."
+            )
+            return 1
+
+    # Path to plugin config in the module
+    plugin_file_path = os.path.join(module_path, Config.user_plugin_config_file)
+
+    if not os.path.exists(plugin_file_path):
+        log_error("Invalid solace-agent-mesh plugin module.")
+        return 1
+
+    plugin_config = Config.load_config(plugin_file_path)
+
+    if not plugin_config or "solace_agent_mesh_plugin" not in plugin_config:
+        log_error("Invalid solace-agent-mesh plugin module.")
+        return 1
+    plugin_config = plugin_config["solace_agent_mesh_plugin"]
+
+    plugin_data = {
+        "name": name,
+        "load_unspecified_files": add_all,
+        "includes_gateway_interface": plugin_config.get("includes_gateway_interface", False),
+        "load": {
+            "agents": [],
+            "gateways": [],
+            "overwrites": [],
+        },
+    }
+
+    if from_url:
+        plugin_data["from_url"] = from_url
+
+    sam_config["solace_agent_mesh"]["plugins"].append(plugin_data)
+    Config.write_config(sam_config)
+
+    click.echo(f"Successfully added plugin '{name}'.")