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

solace_agent_mesh/cli/commands/init_cmd/orchestrator_step.py

@@ -0,0 +1,387 @@
+import click
+from pathlib import Path
+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
+
+ORCHESTRATOR_DEFAULTS = {
+    "agent_name": "OrchestratorAgent",
+    "supports_streaming": True,
+    "artifact_handling_mode": "embed",
+    "enable_embed_resolution": True,
+    "enable_artifact_content_instruction": True,
+    "session_service": {"type": "memory", "default_behavior": "PERSISTENT"},
+    "artifact_service": {
+        "type": "filesystem",
+        "base_path": "/tmp/samv2",
+        "artifact_scope": "namespace",
+    },
+    "agent_card": {
+        "description": "The Orchestrator component. It manages tasks and coordinates multi-agent workflows.",
+        "defaultInputModes": ["text"],
+        "defaultOutputModes": ["text", "file"],
+        "skills": [],
+    },
+    "agent_card_publishing": {"interval_seconds": 10},
+    "agent_discovery": {"enabled": True},
+    "inter_agent_communication": {
+        "allow_list": ["*"],
+        "request_timeout_seconds": DEFAULT_COMMUNICATION_TIMEOUT,
+    },
+}
+
+
+def create_orchestrator_config(
+    project_root: Path, options: dict, skip_interactive: bool
+) -> bool:
+    """
+    Creates the main_orchestrator.yaml file with configured values.
+    Returns True on success, False on failure.
+    """
+    click.echo("Configuring main orchestrator...")
+
+    raise_if_not_valid_agent_name = options.get("agent_name") or skip_interactive
+    ask_if_not_provided(
+        options,
+        "agent_name",
+        "Enter agent name",
+        ORCHESTRATOR_DEFAULTS["agent_name"],
+        skip_interactive,
+    )
+
+    agent_name = options.get("agent_name")
+    while not re.match(r"^[a-zA-Z0-9_]+$", agent_name):
+        if raise_if_not_valid_agent_name:
+            raise click.UsageError(
+                "Invalid agent name. Only letters, numbers, and underscores are allowed."
+            )
+        else:
+            click.echo(
+                click.style(
+                    "Invalid agent name. Only letters, numbers, and underscores are allowed.",
+                    fg="red",
+                ),
+                err=True,
+            )
+            agent_name = click.prompt("Please enter a valid agent name")
+    options["agent_name"] = agent_name
+
+    ask_if_not_provided(
+        options,
+        "supports_streaming",
+        "Enable streaming support? (true/false)",
+        ORCHESTRATOR_DEFAULTS["supports_streaming"],
+        skip_interactive,
+        is_bool=True,
+    )
+
+    session_type = ask_if_not_provided(
+        options,
+        "session_service_type",
+        "Enter session service type",
+        ORCHESTRATOR_DEFAULTS["session_service"]["type"],
+        skip_interactive,
+        choices=["memory", "vertex_rag"],
+    )
+
+    session_behavior = ask_if_not_provided(
+        options,
+        "session_service_behavior",
+        "Enter session service behavior",
+        ORCHESTRATOR_DEFAULTS["session_service"]["default_behavior"],
+        skip_interactive,
+        choices=["PERSISTENT", "RUN_BASED"],
+    )
+
+    artifact_type = ask_if_not_provided(
+        options,
+        "artifact_service_type",
+        "Enter artifact service type",
+        ORCHESTRATOR_DEFAULTS["artifact_service"]["type"],
+        skip_interactive,
+        choices=["memory", "filesystem", "gcs"],
+    )
+
+    artifact_base_path = None
+    if artifact_type == "filesystem":
+        artifact_base_path = ask_if_not_provided(
+            options,
+            "artifact_service_base_path",
+            "Enter artifact service base path",
+            ORCHESTRATOR_DEFAULTS["artifact_service"]["base_path"],
+            skip_interactive,
+        )
+
+    artifact_scope = ask_if_not_provided(
+        options,
+        "artifact_service_scope",
+        "Enter artifact service scope",
+        ORCHESTRATOR_DEFAULTS["artifact_service"]["artifact_scope"],
+        skip_interactive,
+        choices=["namespace", "app", "custom"],
+    )
+
+    artifact_handling_mode = ask_if_not_provided(
+        options,
+        "artifact_handling_mode",
+        "Enter artifact handling mode",
+        ORCHESTRATOR_DEFAULTS["artifact_handling_mode"],
+        skip_interactive,
+        choices=["ignore", "embed", "reference"],
+    )
+
+    enable_embed_resolution = ask_if_not_provided(
+        options,
+        "enable_embed_resolution",
+        "Enable embed resolution? (true/false)",
+        ORCHESTRATOR_DEFAULTS["enable_embed_resolution"],
+        skip_interactive,
+        is_bool=True,
+    )
+
+    enable_artifact_content_instruction = ask_if_not_provided(
+        options,
+        "enable_artifact_content_instruction",
+        "Enable artifact content instruction? (true/false)",
+        ORCHESTRATOR_DEFAULTS["enable_artifact_content_instruction"],
+        skip_interactive,
+        is_bool=True,
+    )
+
+    agent_card_description = ask_if_not_provided(
+        options,
+        "agent_card_description",
+        "Enter agent card description",
+        ORCHESTRATOR_DEFAULTS["agent_card"]["description"],
+        skip_interactive,
+    )
+
+    if "agent_card_default_input_modes" in options and isinstance(
+        options["agent_card_default_input_modes"], list
+    ):
+        default_input_modes = options["agent_card_default_input_modes"]
+    else:
+        default_input_modes_str = ask_if_not_provided(
+            options,
+            "agent_card_default_input_modes",
+            "Enter agent card default input modes (comma-separated)",
+            ",".join(ORCHESTRATOR_DEFAULTS["agent_card"]["defaultInputModes"]),
+            skip_interactive,
+        )
+        if isinstance(default_input_modes_str, list):
+            default_input_modes = default_input_modes_str
+        else:
+            default_input_modes = [
+                mode.strip() for mode in default_input_modes_str.split(",")
+            ]
+
+    if "agent_card_default_output_modes" in options and isinstance(
+        options["agent_card_default_output_modes"], list
+    ):
+        default_output_modes = options["agent_card_default_output_modes"]
+    else:
+        default_output_modes_str = ask_if_not_provided(
+            options,
+            "agent_card_default_output_modes",
+            "Enter agent card default output modes (comma-separated)",
+            ",".join(ORCHESTRATOR_DEFAULTS["agent_card"]["defaultOutputModes"]),
+            skip_interactive,
+        )
+        if isinstance(default_output_modes_str, list):
+            default_output_modes = default_output_modes_str
+        else:
+            default_output_modes = [
+                mode.strip() for mode in default_output_modes_str.split(",")
+            ]
+
+    agent_discovery_enabled = ask_if_not_provided(
+        options,
+        "agent_discovery_enabled",
+        "Enable agent discovery? (true/false)",
+        ORCHESTRATOR_DEFAULTS["agent_discovery"]["enabled"],
+        skip_interactive,
+        is_bool=True,
+    )
+
+    agent_card_publishing_interval = ask_if_not_provided(
+        options,
+        "agent_card_publishing_interval",
+        "Enter agent card publishing interval (seconds)",
+        ORCHESTRATOR_DEFAULTS["agent_card_publishing"]["interval_seconds"],
+        skip_interactive,
+    )
+
+    if "inter_agent_communication_allow_list" in options and isinstance(
+        options["inter_agent_communication_allow_list"], list
+    ):
+        allow_list = options["inter_agent_communication_allow_list"]
+    else:
+        allow_list_str = ask_if_not_provided(
+            options,
+            "inter_agent_communication_allow_list",
+            "Enter inter-agent communication allow list (comma-separated, use * for all)",
+            ",".join(ORCHESTRATOR_DEFAULTS["inter_agent_communication"]["allow_list"]),
+            skip_interactive,
+        )
+        if isinstance(allow_list_str, list):
+            allow_list = allow_list_str
+        else:
+            allow_list = [item.strip() for item in allow_list_str.split(",")]
+
+    if "inter_agent_communication_deny_list" in options and isinstance(
+        options["inter_agent_communication_deny_list"], list
+    ):
+        deny_list = options["inter_agent_communication_deny_list"]
+    else:
+        deny_list_str = ask_if_not_provided(
+            options,
+            "inter_agent_communication_deny_list",
+            "Enter inter-agent communication deny list (comma-separated, leave empty for none)",
+            "",
+            skip_interactive,
+        )
+        if isinstance(deny_list_str, list):
+            deny_list = deny_list_str
+        else:
+            deny_list = (
+                [item.strip() for item in deny_list_str.split(",")]
+                if deny_list_str.strip()
+                else []
+            )
+
+    inter_agent_communication_timeout = ask_if_not_provided(
+        options,
+        "inter_agent_communication_timeout",
+        "Enter inter-agent communication timeout (seconds)",
+        ORCHESTRATOR_DEFAULTS["inter_agent_communication"]["request_timeout_seconds"],
+        skip_interactive,
+    )
+
+    shared_config_dest_path = project_root / "configs" / "shared_config.yaml"
+
+    try:
+        shared_template_content = load_template("shared_config.yaml")
+
+        artifact_base_path_line = ""
+        if artifact_type == "filesystem":
+            artifact_base_path_line = f'base_path: "{artifact_base_path}"'
+
+        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,
+        }
+
+        modified_shared_content = shared_template_content
+        for placeholder, value in shared_replacements.items():
+            modified_shared_content = modified_shared_content.replace(
+                placeholder, str(value)
+            )
+
+        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)
+        click.echo(f"  Configured: {shared_config_dest_path.relative_to(project_root)}")
+
+    except Exception as e:
+        click.echo(
+            click.style(
+                f"Error configuring file {shared_config_dest_path}: {e}", fg="red"
+            ),
+            err=True,
+        )
+        return False
+
+    main_orchestrator_path = (
+        project_root / "configs" / "agents" / "main_orchestrator.yaml"
+    )
+
+    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"
+
+        deny_list_line = ""
+        if deny_list:
+            deny_list_yaml = (
+                yaml.dump(deny_list, Dumper=yaml.SafeDumper, default_flow_style=True)
+                .strip()
+                .replace("'", '"')
+            )
+            deny_list_line = f"deny_list: {deny_list_yaml}\n        "
+
+        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.
+        2. Analyze each task to determine the optimal execution strategy:
+           a. Single Agent Delegation: If the task can be fully addressed by a single peer agent (based on their declared capabilities/description), delegate the task to that agent.
+           b. Multi-Agent Coordination: If task completion requires a coordinated effort from multiple peer agents: first, devise a logical execution plan (detailing the sequence of agent invocations and any necessary data handoffs). Then, manage the execution of this plan, invoking each agent in the defined order.
+           c. Direct Execution: If the task is not suitable for delegation (neither to a single agent nor a multi-agent sequence) and falls within your own capabilities, execute the task yourself.
+
+        Artifact Management Guidelines:
+        - If an artifact was created during the task (either by yourself or a delegated agent), you must use the `list_artifacts` tool to get the details of the created artifacts.
+        - 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")
+
+        orchestrator_replacements = {
+            "__NAMESPACE__": "${NAMESPACE}",
+            "__APP_NAME__": f"{kebab_case_name}_app",
+            "__SUPPORTS_STREAMING__": str(options["supports_streaming"]).lower(),
+            "__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,
+            "__ARTIFACT_HANDLING_MODE__": artifact_handling_mode,
+            "__ENABLE_EMBED_RESOLUTION__": str(enable_embed_resolution).lower(),
+            "__ENABLE_ARTIFACT_CONTENT_INSTRUCTION__": str(
+                enable_artifact_content_instruction
+            ).lower(),
+            "__AGENT_CARD_DESCRIPTION__": agent_card_description,
+            "__DEFAULT_INPUT_MODES__": yaml.dump(
+                default_input_modes, Dumper=yaml.SafeDumper, default_flow_style=True
+            )
+            .strip()
+            .replace("'", '"'),
+            "__DEFAULT_OUTPUT_MODES__": yaml.dump(
+                default_output_modes, Dumper=yaml.SafeDumper, default_flow_style=True
+            )
+            .strip()
+            .replace("'", '"'),
+            "__AGENT_CARD_PUBLISHING_INTERVAL__": str(agent_card_publishing_interval),
+            "__AGENT_DISCOVERY_ENABLED__": str(agent_discovery_enabled).lower(),
+            "__INTER_AGENT_COMMUNICATION_ALLOW_LIST__": yaml.dump(
+                allow_list, Dumper=yaml.SafeDumper, default_flow_style=True
+            )
+            .strip()
+            .replace("'", '"'),
+            "__INTER_AGENT_COMMUNICATION_DENY_LIST_LINE__": deny_list_line,
+            "__INTER_AGENT_COMMUNICATION_TIMEOUT__": str(
+                inter_agent_communication_timeout
+            ),
+        }
+
+        modified_orchestrator_content = orchestrator_template_content
+        for placeholder, value in orchestrator_replacements.items():
+            modified_orchestrator_content = modified_orchestrator_content.replace(
+                placeholder, str(value)
+            )
+
+        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)
+
+        click.echo(f"  Created: {main_orchestrator_path.relative_to(project_root)}")
+        return True
+    except Exception as e:
+        click.echo(
+            click.style(f"Error creating file {main_orchestrator_path}: {e}", fg="red"),
+            err=True,
+        )
+        return False

solace_agent_mesh/cli/commands/init_cmd/project_files_step.py

@@ -0,0 +1,38 @@
+import click
+from pathlib import Path
+from cli import __version__ as cli_version
+
+
+def create_project_files(project_root: Path) -> bool:
+    """
+    Creates standard project files like configurations, __init__.py, and requirements.txt.
+    Returns True if all essential files are created, False otherwise.
+    """
+    click.echo("Creating project files...")
+    all_successful = True
+
+    src_init_path = project_root / "src" / "__init__.py"
+    try:
+        with open(src_init_path, "w", encoding="utf-8") as f:
+            f.write("# Source directory\n")
+        click.echo(f"  Created: {src_init_path.relative_to(project_root)}")
+    except IOError as e:
+        click.echo(
+            click.style(f"Error creating file {src_init_path}: {e}", fg="red"), err=True
+        )
+        all_successful = False
+
+    requirements_path = project_root / "requirements.txt"
+    requirements_content = f"""solace-agent-mesh~={cli_version}\n"""
+    try:
+        with open(requirements_path, "w", encoding="utf-8") as f:
+            f.write(requirements_content)
+        click.echo(f"  Created: {requirements_path.relative_to(project_root)}")
+    except IOError as e:
+        click.echo(
+            click.style(f"Error creating file {requirements_path}: {e}", fg="red"),
+            err=True,
+        )
+        all_successful = False
+
+    return all_successful

solace_agent_mesh/cli/commands/init_cmd/web_init_step.py

@@ -0,0 +1,110 @@
+import click
+import multiprocessing
+from time import sleep
+import sys
+import webbrowser
+import requests
+
+try:
+    from config_portal.backend.server import run_flask
+except ImportError as e:
+    click.echo(
+        click.style(
+            f"Critical Error: Could not import run_flask from config_portal.backend.server. Error: {e}\n",
+            fg="red",
+        ),
+        err=True,
+    )
+    click.echo(click.style("Aborting web-based initialization.", fg="red"), err=True)
+    sys.exit(1)
+
+
+def wait_for_server(url, timeout=30):
+    start = 0
+    while start < timeout:
+        try:
+            r = requests.get(url)
+            if r.status_code == 200:
+                return True
+        except Exception:
+            pass
+        sleep(0.5)
+        start += 0.5
+    return False
+
+
+def perform_web_init(current_cli_params: dict) -> dict:
+    """
+    Launches the web-based configuration portal and updates params.
+    """
+
+    click.echo(
+        click.style("Attempting to start web-based configuration portal...", fg="blue")
+    )
+
+    with multiprocessing.Manager() as manager:
+        shared_config_from_web = manager.dict()
+        init_gui_process = multiprocessing.Process(
+            target=run_flask, args=("127.0.0.1", 5002, shared_config_from_web)
+        )
+        init_gui_process.start()
+        portal_url = "http://127.0.0.1:5002"
+        click.echo(
+            click.style(
+                f"Web configuration portal is running at {portal_url}",
+                fg="green",
+            )
+        )
+        if wait_for_server(portal_url):
+            try:
+                webbrowser.open(portal_url)
+            except Exception:
+                click.echo(
+                    click.style(
+                        f"Could not automatically open browser, Please open {portal_url} manually.",
+                        fg="yellow",
+                    )
+                )
+        else:
+            click.echo(
+                click.style(
+                    f"Server did not start in time. Please check for errors and try again.",
+                    fg="red",
+                )
+            )
+
+        click.echo(
+            "Complete the configuration in your browser. The CLI will resume once the portal is closed or submits data."
+        )
+
+        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")
+
+            click.echo(
+                click.style("Configuration received from web portal.", fg="green")
+            )
+
+            for key, value in config_from_portal.items():
+                current_cli_params[key] = value
+        else:
+            click.echo(
+                click.style(
+                    "No configuration data received from web portal, or portal was closed without saving.",
+                    fg="yellow",
+                )
+            )
+            click.echo(
+                click.style(
+                    "Proceeding with values from CLI options or defaults if available.",
+                    fg="yellow",
+                )
+            )
+
+    return current_cli_params