solace-agent-mesh 0.1.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

solace_agent_mesh/agents/base_agent_component.py

@@ -12,6 +12,7 @@ from solace_ai_connector.common.utils import ensure_slash_on_end
 from ..services.llm_service.components.llm_service_component_base import LLMServiceComponentBase
 from ..common.action_list import ActionList
 from ..common.action_response import ActionResponse, ErrorInfo
+from ..common.constants import ORCHESTRATOR_COMPONENT_NAME
 from ..services.file_service import FileService
 from ..services.file_service.file_utils import recursive_file_resolver
 from ..services.middleware_service.middleware_service import MiddlewareService
@@ -185,6 +186,7 @@ class BaseAgentComponent(LLMServiceComponentBase, ABC):
         action_response.action_idx = data.get("action_idx")
         action_response.action_name = action_name
         action_response.action_params = data.get("action_params", {})
+        action_response.originator = data.get("originator", ORCHESTRATOR_COMPONENT_NAME)
         try:
             action_response_dict = action_response.to_dict()
         except Exception as e:

solace_agent_mesh/agents/global/actions/plantuml_diagram.py

@@ -1,5 +1,6 @@
 """PlantUML diagram"""
 
+import platform
 import os
 import tempfile
 import subprocess
@@ -41,6 +42,10 @@ class PlantUmlDiagram(Action):
         )
 
     def invoke(self, params, meta={}) -> ActionResponse:
+        if platform.system() == "Windows":
+            return ActionResponse(
+                message=f"Unfortunately, the PlantUML is not available on {platform.system()}"
+            )
         # Do a local command to run plantuml -tpng
         description = params.get("diagram_description")
         agent = self.get_agent()
@@ -49,8 +54,15 @@ class PlantUmlDiagram(Action):
             {"role": "user", "content": description},
         ]
         agent = self.get_agent()
-        response = agent.do_llm_service_request(messages=messages)
-        expression = response.get("content")
+        try:
+            response = agent.do_llm_service_request(messages=messages)
+            expression = response.get("content")
+        except TimeoutError as e:
+            log.error("LLM request timed out: %s", str(e))
+            return ActionResponse(message="LLM request timed out")
+        except Exception as e:
+            log.error("Failed to process content with LLM: %s", str(e))
+            return ActionResponse(message="Failed to process content with LLM")
 
         # Surround expression with @startuml and @enduml if missing
         if not expression.startswith("@startuml"):

solace_agent_mesh/agents/global/actions/plotly_graph.py

@@ -1,11 +1,14 @@
 """Plotly graph generation"""
 
+import platform
 import os
 import random
 import tempfile
 import json
 import yaml
+from importlib.metadata import version
 from io import BytesIO
+from packaging.version import parse
 from solace_ai_connector.common.log import log
 
 import plotly.graph_objects as go
@@ -34,52 +37,58 @@ class PlotlyGraph(Action):
                 ],
                 "required_scopes": ["global:plotly:read"],
                 "examples": [
-                    """    <example>
-        <example_docstring>
-            This is an example of a user asking for a bar graph. The plotly action from the global agent is invoked to generate the graph.
-        </example_docstring>
-        <example_stimulus>
-            <{tp}stimulus starting_id="12">
-            Please generate a random bar graph for me
-            </{tp}stimulus>
-            <{tp}stimulus_metadata>
-            local_time: 2024-09-04 15:59:02 EDT-0400 (Wednesday)
-            </{tp}stimulus_metadata>
-        </example_stimulus>
-        <example_response>
-            <{tp}reasoning>
-            - user has requested a random bar graph
-            - invoke the plotly action from the global agent to generate a bar graph with random data
-            </{tp}reasoning>
-            Certainly! I'd be happy to generate a random bar graph for you.
-            <{tp}status_update>I'll use our plotting tool to create this for you right away.</{tp}status_update>
-            <{tp}invoke_action agent="global" action="plotly">
-            <{tp}parameter name="plotly_figure_config">
-            {{
-                "data": [
-                {{
-                    "x": ["A", "B", "C", "D", "E"],
-                    "y": [23, 45, 56, 78, 90],
-                    "type": "bar"
-                }}
-                ],
-                "layout": {{
-                "title": "Random Bar Graph",
-                "xaxis": {{"title": "Categories"}},
-                "yaxis": {{"title": "Values"}}
-                }}
-            }}
-            </{tp}parameter>
-            </{tp}invoke_action>
-        </example_response>
-    </example>
-"""
+                    {
+                        "docstring": "This is an example of a user asking for a bar graph. The plotly action from the global agent is invoked to generate the graph.",
+                        "tag_prefix_placeholder": "{tp}",
+                        "starting_id": "12",
+                        "user_input": "Please generate a random bar graph for me",
+                        "metadata": [
+                            "local_time: 2024-09-04 15:59:02 EDT-0400 (Wednesday)"
+                        ],
+                        "reasoning": [
+                            "- user has requested a random bar graph",
+                            "- invoke the plotly action from the global agent to generate a bar graph with random data"
+                        ],
+                        "response_text": "Certainly! I'd be happy to generate a random bar graph for you.",
+                        "status_update": "I'll use our plotting tool to create this for you right away.",
+                        "action": {
+                            "agent": "global",
+                            "name": "plotly",
+                            "parameter_name": "plotly_figure_config",
+                            "parameters": {
+                                "plotly_figure_config": [
+                                    "{{",
+                                    "    \"data\": [",
+                                    "    {{",
+                                    "        \"x\": [\"A\", \"B\", \"C\", \"D\", \"E\"],",
+                                    "        \"y\": [23, 45, 56, 78, 90],",
+                                    "        \"type\": \"bar\"",
+                                    "    }}",
+                                    "    ],",
+                                    "    \"layout\": {{",
+                                    "    \"title\": \"Random Bar Graph\",",
+                                    "    \"xaxis\": {{\"title\": \"Categories\"}},",
+                                    "    \"yaxis\": {{\"title\": \"Values\"}}",
+                                    "    }}",
+                                    "}}"
+                                ]
+                            }
+                        }
+                    }
                 ],
             },
             **kwargs,
         )
 
     def invoke(self, params, meta={}) -> ActionResponse:
+        if platform.system() == "Windows":
+            kaleido_version = version('kaleido')
+            min_version = parse('0.1.0.post1')
+            max_version = parse('0.2.0')
+            if parse(kaleido_version) < min_version or parse(kaleido_version) >= max_version:
+                return ActionResponse(
+                    message="For Windows users, the plotting functionality requires a specific version of Kaleido. Please refer to the documentation."
+                )
         obj = params["plotly_figure_config"]
         if isinstance(obj, str):
             # Remove any leading/trailing quote characters

solace_agent_mesh/agents/web_request/actions/do_web_request.py

@@ -31,37 +31,31 @@ class DoWebRequest(Action):
                 ],
                 "required_scopes": ["web_request:do_web_request:read"],
                 "examples": [
-                    """    <example>
-        <example_docstring>
-            This is an example of a user requesting to fetch information from the web. The web_request agent is open so invoke the do_web_request action to fetch the content from the url and process the information according to the llm_prompt.
-        </example_docstring>
-        <example_stimulus>
-            <{tp}stimulus starting_id="10"/>
-            What is the weather in Ottawa?
-            </{tp}stimulus>
-            <{tp}stimulus_metadata>
-            local_time: 2024-11-06 12:33:12 EST-0500 (Wednesday)
-            </{tp}stimulus_metadata>
-        </example_stimulus>
-        <example_response>
-            <{tp}reasoning>
-            - User is asking for current weather information in Ottawa
-            - We need to fetch up-to-date weather data
-            - Use the web_request agent to get the latest weather information
-            - Plan to use the Environment Canada website for accurate local weather data
-            </{tp}reasoning>
-
-            Certainly! I\'ll fetch the current weather information for Ottawa for you right away.
-
-            <{tp}invoke_action agent="web_request" action="do_web_request">
-            <{tp}parameter name="url">https://weather.gc.ca/city/pages/on-118_metric_e.html</{tp}parameter>
-            <{tp}parameter name="llm_prompt">Extract the current temperature, weather conditions, and any important weather alerts or warnings for Ottawa from the webpage. Format the response as a bulleted list with emoji where appropriate.</{tp}parameter>
-            </{tp}invoke_action>
-
-            <{tp}status_update>Retrieving the latest weather data for Ottawa...</{tp}status_update>'
-        </example_response>
-    </example>
-"""
+                    {
+                        "docstring": "This is an example of a user requesting to fetch information from the web. The web_request agent is open so invoke the do_web_request action to fetch the content from the url and process the information according to the llm_prompt.",
+                        "tag_prefix_placeholder": "{tp}",
+                        "starting_id": "10",
+                        "user_input": "What is the weather in Ottawa?",
+                        "metadata": [
+                            "local_time: 2024-11-06 12:33:12 EST-0500 (Wednesday)"
+                        ],
+                        "reasoning": [
+                            "- User is asking for current weather information in Ottawa",
+                            "- We need to fetch up-to-date weather data",
+                            "- Use the web_request agent to get the latest weather information",
+                            "- Plan to use the Environment Canada website for accurate local weather data"
+                        ],
+                        "response_text": "Certainly! I'll fetch the current weather information for Ottawa for you right away.",
+                        "status_update": "Retrieving the latest weather data for Ottawa...",
+                        "action": {
+                            "agent": "web_request",
+                            "name": "do_web_request",
+                            "parameters": {
+                                "url": "https://weather.gc.ca/city/pages/on-118_metric_e.html",
+                                "llm_prompt": "Extract the current temperature, weather conditions, and any important weather alerts or warnings for Ottawa from the webpage. Format the response as a bulleted list with emoji where appropriate."
+                            }
+                        }
+                    }
                 ],
             },
             **kwargs,
@@ -127,8 +121,15 @@ class DoWebRequest(Action):
             ]
 
             agent = self.get_agent()
-            response = agent.do_llm_service_request(messages=messages)
-            content = response.get("content")
+            try:
+                response = agent.do_llm_service_request(messages=messages)
+                content = response.get("content")
+            except TimeoutError as e:
+                log.error("LLM request timed out: %s", str(e))
+                return ActionResponse(message="LLM request timed out")
+            except Exception as e:
+                log.error("Failed to process content with LLM: %s", str(e))
+                return ActionResponse(message="Failed to process content with LLM")
 
         # Code to create the image using the provided content
         return ActionResponse(message=content)

solace_agent_mesh/cli/__init__.py

@@ -1 +1 @@
-__version__ = "0.1.2"
+__version__ = "0.2.0"

solace_agent_mesh/cli/commands/add/gateway.py

@@ -1,8 +1,9 @@
 import os
 import sys
 import click
+import re
 
-from cli.utils import get_display_path, load_template, log_error, get_formatted_names
+from cli.utils import get_display_path, load_template, log_error, get_formatted_names, log_warning
 from cli.commands.plugin.build import get_all_plugin_gateway_interfaces
 from cli.config import Config
 
@@ -34,6 +35,126 @@ def _add_python_files(modules_directory, template_args, created_file_names):
                 f.write(gateway_template)
         created_file_names.append(gateway_path)
 
+def _update_gateway_yaml(yaml_string, interface_gateway_config):
+    # Update system_purpose
+    if "system_purpose" in interface_gateway_config:
+        yaml_string = re.sub(
+            r'(system_purpose: >\n\s+)(.*?)(?=\n\s{4}\S)',
+            lambda m: f'{m.group(1)}{interface_gateway_config["system_purpose"]}',
+            yaml_string,
+            flags=re.DOTALL
+        )
+    
+    # Update interaction_type
+    if "interaction_type" in interface_gateway_config:
+        yaml_string = re.sub(
+            r'(interaction_type: )".*?"',
+            lambda m: f'{m.group(1)}"{interface_gateway_config["interaction_type"]}"',
+            yaml_string
+        )
+    
+    # Update history settings
+    history_config = interface_gateway_config.get("history", {})
+    if not history_config.get("enabled", False):
+        yaml_string = re.sub(r'\n\s+history_config: \n\s+<<: \*default_history_policy', '', yaml_string)
+        yaml_string = re.sub(r'(retain_history: )true', r'\1false', yaml_string)
+        yaml_string = re.sub(
+            r'\n- history_policy:.*?(?=\n\n)',
+            '',
+            yaml_string,
+            flags=re.DOTALL
+        )
+
+    else:
+        if history_config.get("type") is not None:
+            yaml_string = re.sub(
+                r'(type: )".*?"',
+                lambda m: f'{m.group(1)}"{history_config.get("type")}"',
+                yaml_string,
+                count=1  # Update only the first occurrence
+            )
+        if history_config.get("time_to_live") is not None:
+            yaml_string = re.sub(
+                r'(time_to_live: )\d+',
+                lambda m: f'{m.group(1)}{history_config.get("time_to_live")}',
+                yaml_string
+            )
+        if history_config.get("expiration_check_interval") is not None:
+            yaml_string = re.sub(
+                r'(expiration_check_interval: )\d+',
+                lambda m: f'{m.group(1)}{history_config.get("expiration_check_interval")}',
+                yaml_string
+            )
+
+        if history_config.get("max_turns") is not None:
+            yaml_string = re.sub(
+                r'(max_turns: )\d+',
+                lambda m: f'{m.group(1)}{history_config.get("max_turns")}',
+                yaml_string
+            )
+        if history_config.get("max_characters") is not None:
+            yaml_string = re.sub(
+                r'(max_characters: )\d+',
+                lambda m: f'{m.group(1)}{history_config.get("max_characters")}',
+                yaml_string
+            )
+        if history_config.get("enforce_alternate_message_roles") is not None:
+            yaml_string = re.sub(
+                r'(enforce_alternate_message_roles: )\w+',
+                lambda m: f'{m.group(1)}{str(history_config.get("enforce_alternate_message_roles", True)).lower()}',
+                yaml_string
+            )
+
+        # Inject long-term memory before history_policy
+        if history_config.get("long_term_memory", {}).get("enabled", False):
+            # Build llm_config string
+            llm_config_items = history_config['long_term_memory'].get('llm_config', {})
+            if llm_config_items:
+                llm_config_parts = []
+                for key, value in llm_config_items.items():
+                    llm_config_parts.append(f"{key}: {value}")
+                llm_config = "\n        " + "\n        ".join(llm_config_parts) + "\n"
+            else:
+                llm_config = " {} \n"
+            
+            # Build store_config string
+            store_config_items = history_config['long_term_memory'].get('store_config', {})
+            if store_config_items:
+                store_config_parts = []
+                for key, value in store_config_items.items():
+                    store_config_parts.append(f"{key}: {value}")
+                store_config = "\n        " + "\n        ".join(store_config_parts) + "\n"
+            else:
+                store_config = " {} \n"
+            long_term_yaml = (
+                'long_term_memory: true\n'
+                '    long_term_memory_config:\n'
+                f'      llm_config:{llm_config}'
+                f'      store_config:{store_config}'
+                '    '
+            )
+
+            if "long_term_memory:" not in yaml_string:
+                yaml_string = re.sub(
+                    r'(history_policy: # History provider configs.*?\n(\s+max_turns: \d+))',
+                    lambda m: f'{long_term_yaml}{m.group(1)}',
+                    yaml_string,
+                    flags=re.DOTALL
+                )
+
+        # Inject type_config under history_policy
+        type_config = history_config.get("type_config", {})
+        if type_config:
+            type_config_yaml = '\n'.join([f'      {key}: {value}' for key, value in type_config.items()])
+            yaml_string = re.sub(
+                r'(history_policy: # History provider configs.*?)\n',
+                lambda m: f'{m.group(1)}\n{type_config_yaml}\n',
+                yaml_string,
+                flags=re.DOTALL
+            )
+        
+    return yaml_string
+
 def add_gateway_command(name, interfaces):
     """
     Creates a gateway configuration directory and files based on provided templates.
@@ -76,7 +197,7 @@ def add_gateway_command(name, interfaces):
         def abort():
             sys.exit(1)
 
-        plugin_gateway_interfaces = get_all_plugin_gateway_interfaces(config, abort)
+        plugin_gateway_interfaces = get_all_plugin_gateway_interfaces(config, abort, return_plugin_config=True)
 
         # Check if the gateway directory already exists
         if os.path.exists(gateway_directory):
@@ -91,12 +212,11 @@ def add_gateway_command(name, interfaces):
 
         # Create the gateway config file from the template directory
         # The file name is gateway-default-config.yaml but write it as gateway.yaml in the gateway_directory
-        gateway_config_template = load_template("gateway-default-config.yaml")
         gateway_config_path = os.path.join(gateway_directory, "gateway.yaml")
-        with open(gateway_config_path, "w", encoding="utf-8") as f:
-            f.write(gateway_config_template)
-
-        created_file_names.append(gateway_config_path)
+        gateway_config_default = load_template("gateway-default-config.yaml")
+        gateway_config = gateway_config_default
+        gateway_config_interface_default_name = None # the interface name that is used for the default gateway config
+        gateway_config_overwritten = False
 
         # If the interface list is not empty, create the interface config files
         if interfaces:
@@ -105,8 +225,17 @@ def add_gateway_command(name, interfaces):
                 # The name will be {interface}-default-config.yaml
                 # Write the file as {interface}.yaml in the gateway_directory
                 if interface in plugin_gateway_interfaces:
+                    interface_gateway_config = plugin_gateway_interfaces[interface][1]
+                    # Checking if the interface has default values for the gateway.yaml
+                    if interface_gateway_config:
+                        # Checking if another interface has already been used to create the gateway.yaml
+                        if gateway_config_interface_default_name:
+                            # Overwrite the default gateway config with the current interface config
+                            gateway_config_overwritten = True
+                        gateway_config_interface_default_name = interface
+                        gateway_config = _update_gateway_yaml(gateway_config_default, interface_gateway_config)
                     interface_default_path = os.path.join(
-                        plugin_gateway_interfaces[interface],
+                        plugin_gateway_interfaces[interface][0],
                         f"{interface}-default-config.yaml",
                     )
                     if not os.path.exists(interface_default_path):
@@ -149,6 +278,17 @@ def add_gateway_command(name, interfaces):
                 log_error(f"Error creating gateway, gateway config was created: {e}")
                 return 1
             
+        with open(gateway_config_path, "w", encoding="utf-8") as f:
+            f.write(gateway_config)
+
+        if gateway_config_overwritten:
+            log_warning(("Multiple interface configurations found. "
+                         "Overwriting default gateway configuration with "
+                         f"{gateway_config_interface_default_name} interface configuration."
+            ))
+
+        created_file_names.append(gateway_config_path)
+            
         temp_file = os.path.join(config_directory, "__TEMPLATES_WILL_BE_HERE__")
         if os.path.exists(temp_file):
             os.remove(temp_file)
@@ -169,7 +309,8 @@ def add_interface_command(name):
     Creates a new gateway interface with the provided name.
     """
     config = Config.get_plugin_config()
-    plugin_name = config.get("solace_agent_mesh_plugin", {}).get("name")
+    plugin_config = config.get("solace_agent_mesh_plugin", {})
+    plugin_name = plugin_config.get("name")
     if not plugin_name or plugin_name == "solace-agent-mesh-plugin":
         log_error("Could not find a valid plugin project")
         return 1
@@ -210,6 +351,18 @@ def add_interface_command(name):
 
         _add_python_files(modules_directory, template_args, created_file_names)
 
+        # Update the 'solace-agent-mesh-plugin' configuration file
+        plugin_config["includes_gateway_interface"] = True
+        plugin_gateway_config_template = load_template("plugin-gateway-default-config.yaml", parser=Config.get_yaml_parser())
+        if not plugin_gateway_config_template:
+            log_error("Error: Plugin gateway config template not found.")
+        else:
+            if "interface_gateway_configs" not in plugin_config:
+                plugin_config["interface_gateway_configs"] = {}
+            plugin_config["interface_gateway_configs"][template_args["HYPHENED_NAME"]] = plugin_gateway_config_template.get("plugin_gateway_default_config", {})
+            Config.write_config(config, Config.user_plugin_config_file)
+            click.echo(f"Updated {Config.user_plugin_config_file} with default gateway interface configuration for {template_args['HYPHENED_NAME']}")
+
     except IOError as e:
         log_error(f"Error creating gateway interface, {e}")
         return 1

solace_agent_mesh/cli/commands/build.py

@@ -16,7 +16,6 @@ from cli.utils import (
     get_display_path,
     log_error,
     apply_document_parsers,
-    find_last_list_item_indent,
     normalize_and_reindent_yaml
 )
 

solace_agent_mesh/cli/commands/init/builtin_agent_step.py

@@ -10,12 +10,7 @@ def builtin_agent_step(options, default_options, none_interactive, abort):
         "image_processing": (
             True,
             "generate images from text or convert images to text (The model name should be formatted like provider/model-name)",
-            ["IMAGE_GEN_MODEL=", "IMAGE_GEN_ENDPOINT=", "IMAGE_GEN_API_KEY="],
-        ),
-        "slack": (
-            False,
-            "Slack agent, send messages to Slack channels",
-            ["MONITOR_SLACK_BOT_TOKEN="],
+            ["IMAGE_GEN_ENDPOINT=", "IMAGE_GEN_API_KEY=", "IMAGE_GEN_MODEL=",],
         ),
     }
 

solace_agent_mesh/cli/commands/init/create_config_file_step.py

@@ -7,6 +7,11 @@ 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

solace_agent_mesh/cli/commands/init/create_other_project_files_step.py

@@ -17,6 +17,57 @@ def add_pair_to_file_if_not_exists(file_path, pairs):
                 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.
@@ -92,5 +143,5 @@ def create_other_project_files_step(options, default_options, none_interactive,
             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)
+    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/init.py

@@ -9,8 +9,6 @@ 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,
@@ -45,7 +43,7 @@ default_options = {
     "rest_api_gateway_name": "rest-api",
     "webui_enabled": True,
     "webui_listen_port": "5001",
-    "webui_host": "localhost"
+    "webui_host": "127.0.0.1"
 }
 """
 Default options for the init command.
@@ -76,8 +74,6 @@ def init_command(options={}):
         ("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),
     ]

solace_agent_mesh/cli/commands/init/project_structure_step.py

@@ -14,32 +14,3 @@ def project_structure_step(options, default_options, none_interactive, abort):
     )
     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,
-    )