solace-agent-mesh 0.2.4__py3-none-any.whl → 1.0.1__py3-none-any.whl

solace_agent_mesh/cli/commands/init/create_config_file_step.py

@@ -1,65 +0,0 @@
-import click
-
-from cli.config import Config
-
-
-def create_config_file_step(options, default_options, none_interactive, abort):
-    """
-    Creates the configuration files.
-    """
-    # Populate options dictionary with default values, for non specified options
-    for key, value in default_options.items():
-        if key not in options or options[key] is None:
-            options[key] = value
-    
-    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 built-in services
-    builtin_services_ref = (
-        sam_config.get("solace_agent_mesh", {}).get("built_in", {}).get("services", [])
-    )
-    for service in builtin_services_ref:
-        if service["name"] == "embedding":
-            service["enabled"] = options.get("embedding_service_enabled", False)
-
-    # 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

@@ -1,147 +0,0 @@
-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 update_or_add_pairs_to_file(file_path, pairs):
-    """
-    Updates existing key-value pairs in a file or adds them if they don't exist.
-    
-    Args:
-        file_path (str): The path to the file to update
-        pairs (list): A list of (key, value) tuples to update or add
-    """
-    # Check if file exists
-    if os.path.exists(file_path):
-        with open(file_path, "r", encoding="utf-8") as f:
-            lines = f.readlines()
-    else:
-        lines = []
-    
-    # Create a dictionary of key-value pairs for quick lookup
-    pair_dict = {key: value for key, value in pairs}
-    updated_keys = set()
-    
-    # Process each line
-    new_lines = []
-    for line in lines:
-        line = line.rstrip()
-        if not line or line.startswith("#"):
-            # Keep comments and empty lines
-            new_lines.append(line)
-            continue
-            
-        # Check if line contains any of our keys
-        found_key = None
-        for key in pair_dict:
-            if line.startswith(key + "=") or line.startswith(key + " ="):
-                found_key = key
-                updated_keys.add(key)
-                new_lines.append(f"{key}{pair_dict[key]}")
-                break
-                
-        if not found_key:
-            # Keep lines that don't match our keys
-            new_lines.append(line)
-    
-    # Add any new variables that weren't found
-    for key, value in pairs:
-        if key not in updated_keys:
-            new_lines.append(f"{key}{value}")
-    
-    # Write the updated content back to the file
-    with open(file_path, "w", encoding="utf-8") as f:
-        f.write("\n".join(new_lines) + "\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"], "")
-    update_or_add_pairs_to_file(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

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

@@ -1,92 +0,0 @@
-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 .web_init_step import web_init_step
-
-from cli.utils import (
-    log_error,
-    ask_yes_no_question,
-)
-from solace_agent_mesh.config_portal.backend.common import default_options
-
-
-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.
-    """
-    skip = False
-    if "skip" in options and options["skip"]:
-        skip = True
-
-    click.echo(click.style("Initializing Solace Agent Mesh", bold=True, fg="blue"))
-    check_if_already_done(options, default_options, skip, abort)
-
-    use_web_based_init = options.get("use_web_based_init", False)
-    if not use_web_based_init and not skip:
-        use_web_based_init = ask_yes_no_question("Would you like to configure your project through a web interface in your browser?", True)
-
-    # no description for hidden steps
-    cli_steps = [
-        ("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),
-        ("", create_config_file_step),
-        ("Setting up project", create_other_project_files_step),
-    ]
-
-    web_steps = [
-        ("Initilize in web", web_init_step),
-        ("", create_config_file_step),
-        ("", create_other_project_files_step),
-    ]
-
-    steps = web_steps if use_web_based_init else cli_steps
-         
-    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

@@ -1,16 +0,0 @@
-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}/"

solace_agent_mesh/cli/commands/init/web_init_step.py

@@ -1,32 +0,0 @@
-import click
-import multiprocessing
-from solace_agent_mesh.config_portal.backend.server import run_flask
-
-def web_init_step(options, default_options, none_interactive, abort):
-    if not none_interactive:
-        with multiprocessing.Manager() as manager:
-            # Create a shared configuration dictionary
-            shared_config = manager.dict()
-            
-            # Start the Flask server with the shared config
-            init_gui_process = multiprocessing.Process(
-                target=run_flask,
-                args=("127.0.0.1", 5002, shared_config)
-            )
-            init_gui_process.start()
-
-            click.echo(click.style("Web configuration portal is running at http://127.0.0.1:5002", fg="green"))
-            click.echo("Complete the configuration in your browser to continue...")
-
-            # Wait for the Flask server to finish
-            init_gui_process.join()
-            
-            # Get the configuration from the shared dictionary
-            if shared_config:
-                # Convert from manager.dict to regular dict
-                config_from_portal = dict(shared_config)
-                options.update(config_from_portal)
-                click.echo(click.style("Configuration received from portal", fg="green"))
-
-            else:
-                abort("Web configuration failed, please try again.")

solace_agent_mesh/cli/commands/plugin/__init__.py

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

solace_agent_mesh/cli/commands/plugin/add.py

@@ -1,100 +0,0 @@
-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(["pip3", "install", install_name])
-            elif installer == "uv":
-                subprocess.check_call(["uv", "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}'.")