solace-agent-mesh 0.1.3__py3-none-any.whl → 0.2.1__py3-none-any.whl

solace_agent_mesh/agents/global/actions/plantuml_diagram.py

@@ -54,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

@@ -37,46 +37,44 @@ 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,
@@ -84,15 +82,38 @@ class PlotlyGraph(Action):
 
     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:
+            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):
+            # First remove any leading/trailing whitespace
+            obj = obj.strip()
+
+            # Next remove ```yaml or ```json
+            if obj.startswith("```yaml") or obj.startswith("```json"):
+                obj = obj[7:]
+            elif obj.startswith("```"):
+                obj = obj[3:]
+            # Remove any trailing ``` characters
+            if obj.endswith("```"):
+                obj = obj[:-3]
+            # Remove any leading/trailing whitespace again
+            obj = obj.strip()
+
+            # If the string starts with a quote and ends with that same quote, remove them
+            if obj.startswith("'") and obj.endswith("'"):
+                obj = obj[1:-1]
+            elif obj.startswith('"') and obj.endswith('"'):
+                obj = obj[1:-1]
+
             # Remove any leading/trailing quote characters
             obj = obj.strip("'\" ")
             try:
@@ -112,7 +133,9 @@ class PlotlyGraph(Action):
             pio.write_image(fig, byte_io)
             byte_io.seek(0)
             file_service = FileService()
-            image_name = "generated_graph_" + str(random.randint(100000, 999999)) + ".png"
+            image_name = (
+                "generated_graph_" + str(random.randint(100000, 999999)) + ".png"
+            )
             image_meta = file_service.upload_from_buffer(
                 byte_io.read(),
                 image_name,
@@ -122,7 +145,8 @@ class PlotlyGraph(Action):
             files.append(image_meta)
         except Exception as e:
             return ActionResponse(
-                message="Could not create plotly graph. Please check the plotly figure configuration. plotly error: " + str(e),
+                message="Could not create plotly graph. Please check the plotly figure configuration. plotly error: "
+                + str(e),
             )
 
         return ActionResponse(files=files)

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.3"
+__version__ = "0.2.1"

solace_agent_mesh/cli/commands/add/copy_from_plugin.py

@@ -16,7 +16,7 @@ def copy_from_plugin(name, plugin_name, entity_type):
     if entity_type not in ["agents", "gateways"]:
         log_error("Invalid entity type.")
         return 1
-    
+
     src_entity_name = name
     if ":" in plugin_name:
         plugin_name, src_entity_name = plugin_name.split(":")
@@ -33,11 +33,13 @@ def copy_from_plugin(name, plugin_name, entity_type):
     item_name = f"{item_name}.yaml" if entity_type == "agents" else item_name
 
     src_entity_name = src_entity_name.replace("-", "_")
-    src_entity_name = f"{src_entity_name}.yaml" if entity_type == "agents" else src_entity_name
+    src_entity_name = (
+        f"{src_entity_name}.yaml" if entity_type == "agents" else src_entity_name
+    )
     template_path = os.path.join(plugin_path, "configs", entity_type, src_entity_name)
 
     if not os.path.exists(template_path):
-        log_error(f"Could not find '{item_name}' in '{plugin_name}' plugin.")
+        log_error(f"Could not find '{src_entity_name}' in '{plugin_name}' plugin.")
         return 1
 
     config = click.get_current_context().obj
@@ -80,11 +82,11 @@ def copy_from_plugin(name, plugin_name, entity_type):
     else:
         log_error("Invalid entity type.")
         return 1
-    
+
     temp_file = os.path.join(config_directory, "__TEMPLATES_WILL_BE_HERE__")
     if os.path.exists(temp_file):
         os.remove(temp_file)
-        
+
     click.echo(
         f"Copied {entity_type[:-1]} '{name}' from plugin '{plugin_name}' at: {get_display_path(target_directory)}"
-    )
+    )

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
 )
 
@@ -379,7 +378,22 @@ def build_solace_agent_mesh(config, build_config_dir, abort, parsers):
         if f.endswith(".yaml")
         and not any(f.startswith(prefix) for prefix in skip_prefixes)
     ]
+    
+    # Check if embedding service is enabled
+    embedding_enabled = True  # Default to True for backward compatibility
+    built_in_services = config.get("built_in", {}).get("services", [])
+    if built_in_services:  # Only check if services section exists
+        embedding_enabled = False
+        for service in built_in_services:
+            if service.get("name") == "embedding" and service.get("enabled"):
+                embedding_enabled = True
+                break
+    
     for config_file in config_files:
+        # Skip embedding service if not enabled
+        if config_file == "service_embedding.yaml" and not embedding_enabled:
+            click.echo(f"Skipping embedding service as it is disabled.")
+            continue
         try:
             # Read config file
             config_file_path = os.path.join(configs_source_path, config_file)

solace_agent_mesh/cli/commands/init/ai_provider_step.py

@@ -39,38 +39,55 @@ def ai_provider_step(options, default_options, none_interactive, abort):
         default_options["llm_model_name"],
         none_interactive,
     )
-
-    ask_if_not_provided(
+    # Ask if the user wants to enable the embedding service
+    embedding_enabled = ask_if_not_provided(
         options,
-        "embedding_endpoint_url",
-        "Provide Embedding endpoint URL",
-        default_options["embedding_endpoint_url"],
+        "embedding_service_enabled",
+        "Enable embedding service for vector embeddings?",
+        default_options["embedding_service_enabled"],
         none_interactive,
     )
 
-    ask_if_not_provided(
-        options,
-        "embedding_api_key",
-        "Provide Embedding API Key",
-        default_options["embedding_api_key"],
-        none_interactive,
-        hide_input=True,
-    )
+    options["embedding_service_enabled"] = embedding_enabled
 
-    click.echo(
-        click.style(
-            (
-                "The model name should follow the format `provider/model-name`."
-                "\n\t For example: openai/text-embedding-ada-002 or openai/my-model-that-follows-openai-api"
-            ),
-            fg="yellow",
+    # Only ask for embedding configuration if the service is enabled
+    if embedding_enabled:
+        ask_if_not_provided(
+            options,
+            "embedding_endpoint_url",
+            "Provide Embedding endpoint URL",
+            default_options["embedding_endpoint_url"],
+            none_interactive,
         )
-    )
 
-    ask_if_not_provided(
-        options,
-        "embedding_model_name",
-        "Provide Embedding model name to use",
-        default_options["embedding_model_name"],
-        none_interactive,
-    )
+        ask_if_not_provided(
+            options,
+            "embedding_api_key",
+            "Provide Embedding API Key",
+            default_options["embedding_api_key"],
+            none_interactive,
+            hide_input=True,
+        )
+
+        click.echo(
+            click.style(
+                (
+                    "The model name should follow the format `provider/model-name`."
+                    "\n\t For example: openai/text-embedding-ada-002 or openai/my-model-that-follows-openai-api"
+                ),
+                fg="yellow",
+            )
+        )
+
+        ask_if_not_provided(
+            options,
+            "embedding_model_name",
+            "Provide Embedding model name to use",
+            default_options["embedding_model_name"],
+            none_interactive,
+        )
+    else:
+        # Set empty values for embedding configuration if the service is disabled
+        options["embedding_endpoint_url"] = ""
+        options["embedding_api_key"] = ""
+        options["embedding_model_name"] = ""

solace_agent_mesh/cli/commands/init/broker_step.py

@@ -3,10 +3,7 @@ import click
 import os
 
 from cli.utils import ask_if_not_provided
-
-
-CONTAINER_RUN_COMMAND = " run -d -p 8080:8080 -p 55554:55555 -p 8008:8008 -p 1883:1883 -p 8000:8000 -p 5672:5672 -p 9000:9000 -p 2222:2222 --shm-size=2g --env username_admin_globalaccesslevel=admin --env username_admin_password=admin --name=solace solace/solace-pubsub-standard"
-
+from solace_agent_mesh.config_portal.backend.common import CONTAINER_RUN_COMMAND
 
 def broker_step(options, default_options, none_interactive, abort):
     """