solace-agent-mesh 0.1.3__py3-none-any.whl → 0.2.0__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,

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.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/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/plugin/build.py

@@ -11,7 +11,7 @@ def build_command():
     subprocess.check_call(["python", "-m", "build"])
 
 
-def get_all_plugin_gateway_interfaces(config, abort): 
+def get_all_plugin_gateway_interfaces(config, abort, return_plugin_config=False):
     plugins = config.get("plugins", [])
     gateway_interfaces = {}
 
@@ -27,6 +27,8 @@ def get_all_plugin_gateway_interfaces(config, abort):
             if not os.path.exists(interface_path):
                 continue
 
+            interface_gateway_configs = (Config.load_config(os.path.join(plugin_path, Config.user_plugin_config_file)) or {}).get("solace_agent_mesh_plugin", {}).get("interface_gateway_configs", {})
+            interface_gateway_config = None
             # Ensuring flow and default pair exist
             interface_pairs = {}
             for file in os.listdir(interface_path):
@@ -44,7 +46,14 @@ def get_all_plugin_gateway_interfaces(config, abort):
             
             for name, files in interface_pairs.items():
                 if len(files) == 2:
-                    gateway_interfaces[name] = interface_path
+                    if return_plugin_config:
+                        for interface_name, interface_config in interface_gateway_configs.items():
+                            if interface_name == name.replace("-", "_"):
+                                interface_gateway_config = interface_config
+                                break
+                        gateway_interfaces[name] = (interface_path, interface_gateway_config)
+                    else:
+                        gateway_interfaces[name] = interface_path
         
     return gateway_interfaces
 

solace_agent_mesh/cli/config.py

@@ -79,3 +79,7 @@ class Config:
         if os.path.exists(path):
             with open(path, "r", encoding="utf-8") as f:
                 return yaml.load(f)
+            
+    @staticmethod
+    def get_yaml_parser():
+        return yaml.load

solace_agent_mesh/cli/utils.py

@@ -42,7 +42,7 @@ def literal_format_template(template, literals):
     return template
 
 
-def load_template(name, format_pair={}):
+def load_template(name, format_pair={}, parser=None):
     """Load a template file and format it with the given key-value pairs."""
     # Construct the path to the template file using a relative path
     template_file = os.path.normpath(
@@ -53,7 +53,10 @@ def load_template(name, format_pair={}):
         return None
 
     with open(template_file, "r", encoding="utf-8") as f:
-        file = f.read()
+        if parser:
+            file = parser(f)
+        else:
+            file = f.read()
 
     file = literal_format_template(file, format_pair)
 
@@ -75,6 +78,8 @@ def get_display_path(path):
 def log_error(message):
     click.echo(click.style(message, fg="red"), err=True)
 
+def log_warning(message):
+    click.echo(click.style(message, fg="yellow"), err=False)
 
 def log_link(message):
     click.echo(click.style(message, fg="blue"), err=False)

solace_agent_mesh/common/constants.py

@@ -3,3 +3,13 @@ SOLACE_AGENT_MESH_SYSTEM_SESSION_ID = "solace_agent_mesh_system_session_id"
 DEFAULT_IDENTITY_KEY_FIELD = "identity"
 
 ORCHESTRATOR_COMPONENT_NAME = "orchestrator"
+
+HISTORY_MEMORY_ROLE = "history"
+
+HISTORY_ACTION_ROLE = "tool_call"
+
+HISTORY_USER_ROLE = "user"
+
+HISTORY_SYSTEM_ROLE = "system"
+
+HISTORY_ASSISTANT_ROLE = "assistant"

solace_agent_mesh/common/utils.py

@@ -139,17 +139,22 @@ def parse_file_content(file_xml: str) -> dict:
     """
     Parse the xml tags in the content and return a dictionary of the content.
     """
-    ignore_content_tags = ["data"]
-    file_dict = xml_to_dict(file_xml, ignore_content_tags)
-    dict_keys = list(file_dict.keys())
-    top_key = [key for key in dict_keys if key not in ignore_content_tags][0]
-
-    return {
-        "data": file_dict.get("data", {}).get("data", ""),
-        "url": file_dict.get(top_key, {}).get("url", {}).get("url", ""),
-        "mime_type": file_dict.get(top_key, {}).get("mime_type", ""),
-        "name": file_dict.get(top_key, {}).get("name", ""),
-    }
+    try:
+        ignore_content_tags = ["data"]
+        file_dict = xml_to_dict(file_xml, ignore_content_tags)
+        dict_keys = list(file_dict.keys())
+        top_key = [key for key in dict_keys if key not in ignore_content_tags][0]
+
+        return {
+            "data": file_dict.get("data", {}).get("data", ""),
+            "url": file_dict.get(top_key, {}).get("url", {}).get("url", ""),
+            "mime_type": file_dict.get(top_key, {}).get("mime_type", ""),
+            "name": file_dict.get(top_key, {}).get("name", ""),
+        }
+    except Exception as e:
+        result = {"data": "", "url": "", "mime_type": "", "name": ""}
+        log.error("Error parsing file content: %s", e)
+        return result
 
 
 def parse_llm_output(llm_output: str) -> dict:

solace_agent_mesh/configs/service_embedding.yaml

@@ -53,7 +53,7 @@ flows:
           source_expression: input.payload
 
       - component_name: embedding_service_model
-        num_instances: 1
+        num_instances: ${EMBEDDING_SERVICE_MODEL_NUM_INSTANCES, 1}
         component_module: litellm_embeddings
         component_config:
           load_balancer:

solace_agent_mesh/configs/service_llm.yaml

@@ -81,7 +81,7 @@ flows:
           source_expression: input.payload
 
       - component_name: llm_service_planning
-        num_instances: 1
+        num_instances: ${LLM_SERVICE_PLANNING_MODEL_NUM_INSTANCES, 1}
         component_module: litellm_chat_model
         component_config:
           <<: *llm_config