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

solace_agent_mesh/agents/global/actions/plantuml_diagram.py

@@ -3,6 +3,8 @@
 import platform
 import os
 import tempfile
+import uuid
+import shutil
 import subprocess
 
 from solace_ai_connector.common.log import log
@@ -11,11 +13,51 @@ from ....common.action_response import ActionResponse
 from ....services.file_service import FileService
 
 PLANTUML_PROMPT = """Generate a PlantUML markup language for the given description by the user. Supports sequence diagrams, class diagrams, use case diagrams, activity diagrams, component diagrams, state diagrams, and timing diagrams. Newlines must be escaped with a backslash and put quotes around participants names. Respond only with PlantUML markup, do not include any other text, symbols or quotes.
-Rules to follow for sequence diagrams:
-    - Do not use variables if they are not declared as participants.
-    - Only use notes to cover one or two participants per line.
-    - Do not use the `activate` or `deactivate` commands directly after a delay notation (`...`), whether directly or with a note in between.
-    - Do not use the `activate` or `deactivate` commands twice in a row, whether directly or with a note in between.
+
+Rules to follow for all diagrams:
+- Always include @startuml at the beginning and @enduml at the end
+- Use simple quotes for names, not double quotes
+- Avoid using <<stereotype>> syntax in state diagrams unless absolutely necessary
+- For state diagrams, use simple state names without spaces (like LoginScreen instead of "Login Screen")
+- If you need descriptive names, use the 'as' keyword (e.g., [*] --> LoginScreen as "Login Screen")
+- Don't use variables if they are not declared
+- Never skip lines
+- For notes in all diagrams:
+    - Use the simple syntax: `note over Participant: Text` without any positioning numbers
+    - Do not use positioning numbers (like `at 25`) in note commands
+    - Never combine multiple participants in a single note
+
+Rules for sequence diagrams:
+- Only use notes to cover one or two participants per line
+- Do not use the `activate` or `deactivate` commands directly after a delay notation (`...`), whether directly or with a note in between
+- Do not use the `activate` or `deactivate` commands twice in a row, whether directly or with a note in between
+
+Rules for activity diagrams:
+- Do not use the `backward:` keyword for loops or returning to previous steps
+- Instead, use the label and goto pattern:
+  1. Add a label to the target activity: `label label_name`
+  2. Use goto to reference that label: `goto label_name`
+- Always place labels immediately after the activity they refer to
+- Labels should use lowercase with underscores for readability (e.g., `label browse_products`)
+
+Rules for state diagrams:
+- Use simple state names without spaces and without quotes
+- When stereotypes are absolutely necessary, use the correct syntax:
+  - For existing states: `state StateName <<stereotype>>`
+  - For new states with descriptions: `state "Description" as StateName <<stereotype>>`
+- Always place stereotypes after the state name, not before
+- If using skinparam for stereotype styling, ensure it's properly defined: `skinparam state \{ BackgroundColor<<stereotype>> Color\}
+- For notes in state diagrams:
+  - Do NOT use `note over StateName` syntax (this is for sequence diagrams)
+  - Instead use directional positioning: `note left of StateName`, `note right of StateName`, `note top of StateName`, or `note bottom of StateName`
+  - Example: `note left of OrderCreated : Initial customer order`
+
+Rules for timing diagrams:
+- Never include notes
+- For 'robust' participants, use named states instead of symbolic states
+   - CORRECT: `PS is "ON"` or `PS is ON`
+   - INCORRECT: `PS is {+}` or `PS is {-}`
+- For 'concise' participants, use numeric values (e.g., `BP is 10`)
 """
 
 
@@ -42,10 +84,6 @@ 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()
@@ -70,34 +108,54 @@ class PlantUmlDiagram(Action):
         if not expression.endswith("@enduml"):
             expression = f"{expression}\n@enduml"
         log.debug("PlantUML expression: %s", expression)
-        img_path = None
         files = []
-        with tempfile.NamedTemporaryFile(delete=True) as temp:
-            temp.write(expression.encode())
-            temp.flush()
-            dir_path = os.path.dirname(temp.name)
-            img_path = f"{dir_path}/{os.path.basename(temp.name)}.png"
-
-            try:
-                subprocess.run(
-                    ["plantuml", "-tpng", temp.name, "-o", dir_path],
-                    check=True,
-                    capture_output=True,
-                    text=True,
-                )
-                file_service = FileService()
-                file_meta = file_service.upload_from_file(
-                    img_path,
-                    meta.get("session_id"),
-                    data_source="Global Agent - PlantUML Action",
-                )
-                files.append(file_meta)
-
-            except subprocess.CalledProcessError as e:
-                log.error("Subprocess failed with stderr: %s", e.stderr)
-                return ActionResponse(
-                    message=f"Failed to create diagram: {e.stderr}",
-                )
+
+        try:
+            temp_dir = tempfile.mkdtemp()
+            # Create a unique filename with .puml extension
+            diagram_id = str(uuid.uuid4())
+            puml_filename = f"diagram_{diagram_id}.puml"
+            puml_path = os.path.join(temp_dir, puml_filename)
+            png_path = os.path.join(temp_dir, f"diagram_{diagram_id}.png")
+
+            # Write PlantUML content to input file
+            with open(puml_path, 'w', encoding='utf-8') as f:
+                f.write(expression)
+
+            # Run PlantUML
+            subprocess.run(
+                ["plantuml", "-tpng", puml_path, "-o", temp_dir],
+                shell=platform.system() == "Windows",
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+
+            # Upload the generated image
+            file_service = FileService()
+            file_meta = file_service.upload_from_file(
+                png_path,
+                meta.get("session_id"),
+                data_source="Global Agent - PlantUML Action",
+            )
+            files.append(file_meta)
+
+        except FileNotFoundError as e:
+            log.error("PlantUML executable not found: %s", str(e))
+            return ActionResponse(
+                message="PlantUML executable not found. Please ensure PlantUML is installed and available in PATH.",
+            )
+        except subprocess.CalledProcessError as e:
+            log.error("Subprocess failed with stderr: %s", str(e))
+            return ActionResponse(
+                message=f"Failed to create diagram: {str(e)}",
+            )
+        finally:
+            if 'temp_dir' in locals() and os.path.exists(temp_dir):
+                try:
+                    shutil.rmtree(temp_dir)  # Remove directory and all contents
+                except:
+                    pass
 
         return ActionResponse(
             message=f"diagram created with the plantUML: \n```\n{expression}\n```",

solace_agent_mesh/agents/global/actions/plotly_graph.py

@@ -47,7 +47,7 @@ class PlotlyGraph(Action):
                         ],
                         "reasoning": [
                             "- user has requested a random bar graph",
-                            "- invoke the plotly action from the global agent to generate a bar graph with random data"
+                            "- 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.",
@@ -57,23 +57,23 @@ class PlotlyGraph(Action):
                             "parameter_name": "plotly_figure_config",
                             "parameters": {
                                 "plotly_figure_config": [
-                                    "{{",
-                                    "    \"data\": [",
-                                    "    {{",
-                                    "        \"x\": [\"A\", \"B\", \"C\", \"D\", \"E\"],",
-                                    "        \"y\": [23, 45, 56, 78, 90],",
-                                    "        \"type\": \"bar\"",
-                                    "    }}",
+                                    "{",
+                                    '    "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\"}}",
-                                    "    }}",
-                                    "}}"
+                                    '    "layout": {',
+                                    '    "title": "Random Bar Graph",',
+                                    '    "xaxis": {"title": "Categories"},',
+                                    '    "yaxis": {"title": "Values"}',
+                                    "    }",
+                                    "}",
                                 ]
-                            }
-                        }
+                            },
+                        },
                     }
                 ],
             },
@@ -82,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:
@@ -110,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,
@@ -120,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/cli/__init__.py

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

solace_agent_mesh/cli/commands/add/agent.py

@@ -101,7 +101,7 @@ def add_agent_command(name):
 
         click.echo(f"Created sample action at: {get_display_path(action_path)}")
 
-        temp_file = os.path.join(config_directory, "__TEMPLATES_WILL_BE_HERE__")
+        temp_file = os.path.join(config_directory, ".gitkeep")
         if os.path.exists(temp_file):
             os.remove(temp_file)
     except IOError as e:

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__")
+
+    temp_file = os.path.join(config_directory, ".gitkeep")
     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

@@ -289,7 +289,7 @@ def add_gateway_command(name, interfaces):
 
         created_file_names.append(gateway_config_path)
             
-        temp_file = os.path.join(config_directory, "__TEMPLATES_WILL_BE_HERE__")
+        temp_file = os.path.join(config_directory, ".gitkeep")
         if os.path.exists(temp_file):
             os.remove(temp_file)
 
@@ -328,7 +328,7 @@ def add_interface_command(name):
     try:
         os.makedirs(interfaces_directory, exist_ok=True)
 
-        temp_file = os.path.join(interfaces_directory, "__INTERFACES_WILL_BE_HERE__")
+        temp_file = os.path.join(interfaces_directory, ".gitkeep")
         if os.path.exists(temp_file):
             os.remove(temp_file)
 

solace_agent_mesh/cli/commands/build.py

@@ -378,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):
     """

solace_agent_mesh/cli/commands/init/check_if_already_done.py

@@ -9,5 +9,5 @@ def check_if_already_done(options, default_options, none_interactive, abort):
     config_path = Config.user_config_file
     if os.path.exists(config_path):
         abort(
-            "The project has already been initialized. If you want to reinitialize the project, please delete the solace-agent-mesh.yaml file."
+            "The project has already been initialized. If you want to reinitialize the project, please delete the solace-agent-mesh.yaml file"
         )

solace_agent_mesh/cli/commands/init/create_config_file_step.py

@@ -21,6 +21,14 @@ def create_config_file_step(options, default_options, none_interactive, abort):
     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")

solace_agent_mesh/cli/commands/init/init.py

@@ -9,45 +9,13 @@ 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,
 )
-
-default_options = {
-    "namespace": "",
-    "config_dir": "configs",
-    "module_dir": "modules",
-    "env_file": ".env",
-    "build_dir": "build",
-    "broker_type": "container",
-    "broker_url": "ws://localhost:8008",
-    "broker_vpn": "default",
-    "broker_username": "default",
-    "broker_password": "default",
-    "container_engine": "docker",
-    "llm_model_name": "openai/gpt-4o",
-    "llm_endpoint_url": "https://api.openai.com/v1",
-    "llm_api_key": "",
-    "embedding_model_name": "openai/text-embedding-ada-002",
-    "embedding_endpoint_url": "https://api.openai.com/v1",
-    "embedding_api_key": "",
-    "built_in_agent": [],
-    "file_service_provider": "volume",
-    "file_service_config": ["volume=/tmp/solace-agent-mesh"],
-    "env_var": [],
-    "rest_api_enabled": True,
-    "rest_api_server_input_port": "5050",
-    "rest_api_server_host": "127.0.0.1",
-    "rest_api_server_input_endpoint": "/api/v1/request",
-    "rest_api_gateway_name": "rest-api",
-    "webui_enabled": True,
-    "webui_listen_port": "5001",
-    "webui_host": "127.0.0.1"
-}
-"""
-Default options for the init command.
-"""
+from solace_agent_mesh.config_portal.backend.common import default_options
 
 
 def abort(message: str):
@@ -61,14 +29,19 @@ def init_command(options={}):
     """
     Initialize the Solace Agent Mesh application.
     """
-    click.echo(click.style("Initializing Solace Agent Mesh", bold=True, fg="blue"))
     skip = False
     if "skip" in options and options["skip"]:
         skip = True
 
+    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
-    steps = [
-        ("", check_if_already_done),
+    cli_steps = [
         ("Project structure setup", project_structure_step),
         ("Broker setup", broker_step),
         ("AI provider setup", ai_provider_step),
@@ -77,6 +50,15 @@ def init_command(options={}):
         ("", 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

solace_agent_mesh/cli/commands/init/web_init_step.py

@@ -0,0 +1,32 @@
+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.")