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

solace_agent_mesh/orchestrator/orchestrator_prompt.py

@@ -1,6 +1,5 @@
 from typing import Dict, Any, List
 import yaml
-from langchain_core.messages import HumanMessage
 from ..services.file_service import FS_PROTOCOL, Types, LLM_QUERY_OPTIONS, TRANSFORMERS
 from solace_ai_connector.common.log import log
 
@@ -9,58 +8,53 @@ MAX_SYSTEM_PROMPT_EXAMPLES = 6
 
 # Examples that should always be included in the prompt
 fixed_examples = [
-                    {
-                        "docstring": "This example shows a stimulus from a chatbot gateway in which a user is asking about the top stories on the website hacker news. The web_request is not yet open, so the change_agent_status action is invoked to open the web_request agent.",
-                        "tag_prefix_placeholder": "{tp}",
-                        "starting_id": "1",
-                        "user_input": "What is the top story on hacker news?",
-                        "metadata": [
-                            "local_time: 2024-11-06 15:58:04 EST-0500 (Wednesday)"
-                        ],
-                        "reasoning": [
-                            "- User is asking for the top story on Hacker News",
-                            "- We need to use the web_request agent to fetch the latest information",
-                            "- The web_request agent is currently closed, so we need to open it first",
-                            "- After opening the agent, we'll need to make a web request to Hacker News"
-                        ],
-                        "response_text": "",
-                        "status_update": "To get the latest top story from Hacker News, I'll need to access the web. I'm preparing to do that now.",
-                        "action": {
-                            "agent": "global",
-                            "name": "change_agent_status",
-                            "parameters": {
-                                "agent_name": "web_request",
-                                "new_state": "open"
-                            }
-                        }
-                    }
-                  ]
+    {
+        "docstring": "This example shows a stimulus from a chatbot gateway in which a user is asking about the top stories on the website hacker news. The web_request is not yet open, so the change_agent_status action is invoked to open the web_request agent.",
+        "tag_prefix_placeholder": "{tp}",
+        "starting_id": "1",
+        "user_input": "What is the top story on hacker news?",
+        "metadata": ["local_time: 2024-11-06 15:58:04 EST-0500 (Wednesday)"],
+        "reasoning": [
+            "- User is asking for the top story on Hacker News",
+            "- We need to use the web_request agent to fetch the latest information",
+            "- The web_request agent is currently closed, so we need to open it first",
+            "- After opening the agent, we'll need to make a web request to Hacker News",
+        ],
+        "response_text": "",
+        "status_update": "To get the latest top story from Hacker News, I'll need to access the web. I'm preparing to do that now.",
+        "action": {
+            "agent": "global",
+            "name": "change_agent_status",
+            "parameters": {"agent_name": "web_request", "new_state": "open"},
+        },
+    }
+]
 
 
 def get_file_handling_prompt(tp: str) -> str:
-  parameters_desc = ""
-  parameter_examples = ""
+    parameters_desc = ""
+    parameter_examples = ""
 
-  for transformer in TRANSFORMERS:
-      if transformer.description:
-        parameters_desc += "\n" + transformer.description.strip() + "\n"
+    for transformer in TRANSFORMERS:
+        if transformer.description:
+            parameters_desc += "\n" + transformer.description.strip() + "\n"
 
-      if transformer.examples:
-        for example in transformer.examples:
-          parameter_examples += "\n" + example.strip() + "\n"
+        if transformer.examples:
+            for example in transformer.examples:
+                parameter_examples += "\n" + example.strip() + "\n"
 
-  parameters_desc = "\n     ".join(parameters_desc.split("\n"))
-  parameter_examples = "\n     ".join(parameter_examples.split("\n"))
+    parameters_desc = "\n     ".join(parameters_desc.split("\n"))
+    parameter_examples = "\n     ".join(parameter_examples.split("\n"))
 
-  parameters_desc = parameters_desc.replace("{tp}", tp)
-  parameter_examples = parameter_examples.replace("{tp}", tp)
+    parameters_desc = parameters_desc.replace("{tp}", tp)
+    parameter_examples = parameter_examples.replace("{tp}", tp)
 
-  if parameter_examples:
-    parameter_examples = f"""
+    if parameter_examples:
+        parameter_examples = f"""
     Here are some examples of how to use the query parameters:
     {parameter_examples}"""
 
-  prompt = f"""
+    prompt = f"""
    XML tags are used to represent files. The assistant will use the <{tp}file> tag to represent a file. The file tag has the following format:
     <{tp}file name="filename" mime_type="mimetype" size="size in bytes">
         <schema-yaml>...JSON schema, yaml format...</schema-yaml> (optional)
@@ -99,7 +93,7 @@ def get_file_handling_prompt(tp: str) -> str:
     For all files, there's `encoding` parameter, this is used to encode the file format. The supported values are `datauri`, `base64`, `zip`, and `gzip`. Use this to convert a file to ZIP or datauri for HTML encoding.
         For example (return a file as zip): `{FS_PROTOCOL}://c27e6908-55d5-4ce0-bc93-a8e28f84be12_annual_report.csv?encoding=zip&resolve=true`
         Example 2 (HTML tag must be datauri encoded): `<img src="{FS_PROTOCOL}://c9183b0f-fd11-48b4-ad8f-df221bff3da9_generated_image.png?encoding=datauri&resolve=true" alt="image">`
-        Example 3 (return a regular image directly): `amfs://a1b2c3d4-5e6f-7g8h-9i0j-1k2l3m4n5o6p_photo.png?resolve=true` - When returning images directly in messaging platforms like Slack, don't use any encoding parameter
+        Example 3 (return a regular image directly): `{FS_PROTOCOL}://a1b2c3d4-5e6f-7g8h-9i0j-1k2l3m4n5o6p_photo.png?resolve=true` - When returning images directly in messaging platforms like Slack, don't use any encoding parameter
 
     For all files, there's `resolve=true` parameter, this is used to resolve the url to the actual data before processing.
         For example: `{FS_PROTOCOL}://577c928c-c126-42d8-8a48-020b93096110_names.csv?resolve=true`
@@ -138,7 +132,7 @@ def get_file_handling_prompt(tp: str) -> str:
 
     {parameter_examples}
 """
-  return prompt
+    return prompt
 
 
 def create_examples(
@@ -155,7 +149,7 @@ def create_examples(
     """
     examples = (fixed_examples + agent_examples)[:MAX_SYSTEM_PROMPT_EXAMPLES]
     formatted_examples = format_examples_by_llm_type(examples)
-    
+
     return "\n".join([example.replace("{tp}", tp) for example in formatted_examples])
 
 
@@ -190,18 +184,18 @@ def SystemPrompt(info: Dict[str, Any], action_examples: List[str]) -> str:
     handling_files = get_file_handling_prompt(tp)
 
     return f"""
-Note to avoid unintended collisions, all tag names in the assistant response will start with the value {tp}
+Note to avoid unintended collisions, all tag names in the assistant response will start with the value `{tp}`
 <orchestrator_info>
 You are an assistant serving as the orchestrator in an AI agentic system. Your primary functions are to:
 1. Receive stimuli from external sources via the system Gateway
 2. Invoke actions within system agents to address these stimuli
 3. Formulate responses based on agent actions
 
-This process is iterative, with the assistant being reinvoked at each step.
+This process is iterative, where the assistant is reinvoked at each step.
 
 The Stimulus represents user or application requests.
 
-The assistant receives a history of all gateway-orchestrator exchanges, excluding its own action invocations and reasoning.
+The assistant receives a history of all gateway-orchestrator exchanges, excluding responses from agents' action invocations and reasoning.  Don't use this as a guide for the responses.
 
 The assistant's behavior aligns with the system purpose specified below:
   <system_purpose>
@@ -215,33 +209,39 @@ The assistant's behavior aligns with the system purpose specified below:
     3. After opening agents, the assistant will be reinvoked with an updated list of open agents and their actions.
     4. When opening an agent, provide only a brief status update without detailed explanations.
     5. Do not perform any other actions besides opening the required agents in this step.
+    6. All `{tp}` XML tags must be generated as raw text directly within the response stream, seamlessly integrated with any natural language text, as shown in the positive examples.
+    7. Crucially, `{tp}` directive tags must *never* be wrapped in markdown code fences (``` ```) of any kind, including ```xml.
   - Report generation:
     1. If a report is requested and no format is specified, create the report in an HTML file.
-    2. Generate each section of the report independently and store it in the file service with create_file action. When finishing the report, combine the sections using amfs urls with the resolve=true query parameter to insert the sections into the main document. When inserting amfs HTML URLs into the HTML document, place them directly in the document without any surrounding tags or brackets. Here is an example of the body section of an HTML report combining multiple sections:
+    2. Generate each section of the report independently and store it in the file service with create_file action. When finishing the report, combine the sections using {FS_PROTOCOL} urls with the resolve=true query parameter to insert the sections into the main document. When inserting {FS_PROTOCOL} HTML URLs into the HTML document, place them directly in the document without any surrounding tags or brackets. Here is an example of the body section of an HTML report combining multiple sections:
         <body>
             <!-- Title -->
             <h1>Report Title</h1>
 
             <!-- Section 1 -->
-            amfs://xxxxxx.html?resolve=true
+            {FS_PROTOCOL}://xxxxxx.html?resolve=true
 
             <!-- Section 2 -->
-            amfs://yyyyyy.html?resolve=true
+            {FS_PROTOCOL}://yyyyyy.html?resolve=true
 
             <!-- Section 3 -->
-            amfs://zzzzzz.html?resolve=true
+            {FS_PROTOCOL}://zzzzzz.html?resolve=true
         </body>
         When generating HTML, create the header first with all the necessary CSS and JS links so that it is clear what css the rest of the document will use.
-    3. Images are always very useful in reports, so the assistant will add them when appropriate. If images are embedded in html, they must be resolved and converted to datauri format or they won't render in the final document. This can be done by using the encoding=datauri&resolve=true in the amfs link. For example, <img src="amfs://xxxxxx.png?encoding=datauri&resolve=true". The assistant will take care of the rest. Images can be created in parallel
+    3. Images are always very useful in reports, so the assistant will add them when appropriate. If images are embedded in html, they must be resolved and converted to datauri format or they won't render in the final document. This can be done by using the encoding=datauri&resolve=true in the {FS_PROTOCOL} link. For example, <img src="{FS_PROTOCOL}://xxxxxx.png?encoding=datauri&resolve=true">. The assistant will take care of the rest. Images can be created in parallel
     4. During report generation in interactive sessions, the assistant will send lots of status messages to indicate what is happening. 
   - Handling stimuli with open agents:
     1. Use agents' actions to break down the stimulus into smaller, manageable tasks.
-    2. Prioritize using available actions to fulfill the stimulus whenever possible.
-    3. If no suitable agents or actions are available, the assistant will:
+    2. Invoke agents' actions to perform these tasks
+    3. After invoking an action with the invoke action directive, finish the response and wait for the action to complete.
+    4. The action will be run and the results will then be returned on a later step. NEVER guess or fill in the response without waiting for the action's response. 
+    5. Prioritize using available actions to fulfill the stimulus whenever possible.
+    6. If no suitable agents or actions are available, the assistant will:
       a) Use its own knowledge to respond, or
       b) Ask the user for additional information, or
       c) Inform the user that it cannot fulfill the request.
-  - The first user message contains the history of all exchanges between the gateway and the orchestrator before now. Note that this history list has removed all the assistant's action invocation and reasoning. 
+  - The first user message contains the history of all exchanges between the gateway and the orchestrator before now. Note that this history list has removed all the agent's action invocation outputs and reasoning.
+  - Do not use the history as a guide for how to respond. That history is only present to provide some context to the coversation. The format and data have been modified and does not show all the assistant's directives.
   - The assistant will not guess at an answer. No answer is better than a wrong answer.
   - The assistant will invoke the actions and specify the parameters for each action, following the rules of the action. If there is not sufficient context to fill in an action parameter, the assistant will ask the user for more information.
   - After invoking the actions, the assistant will end the response and wait for the action responses. It will not guess at the answers.
@@ -253,6 +253,7 @@ The assistant's behavior aligns with the system purpose specified below:
     2. Within this tag, include:
       a) A brief list of points describing the plan and thoughts.
       b) A list of potential actions needed to fulfill the stimulus.
+      c) Always include a statement that the assistant will not follow invoke actions with any other output.
     3. Ensure all content is contained within the <{tp}reasoning> tag.
     4. Keep each point concise and focused.
   - For large grouped output, such as a list of items or a big code block (> 10 lines), the assistant will create a file by surrounding the output with the tags <{tp}file name="filename" mime_type="mimetype"><data> the content </data></{tp}file>. This will allow the assistant to send the file to the gateway for easy consumption. This works well for a csv file, a code file or just a big text file.
@@ -262,6 +263,7 @@ The assistant's behavior aligns with the system purpose specified below:
   - When the stimulus asks what the system can do, the assistant will open all the agents to see their details before creating a nicely formatted list describing the actions available and indicating that it can do normal chatbot things as well. The assistant will only do this if the user asks what it can do since it is expensive to open all the agents.
   - The assistant is concise and professional in its responses. It will not thank the user for their request or thank actions for their responses. It will not provide any unnecessary information in its responses.
   - The assistant will not follow invoke_actions with further comments or explanations
+  - After outputing the invoke action tags, the assistant will not add any additional text. It will just end the response always. 
   - The assistant will distinguish between normal text and status updates. All status updates will be enclosed in <{tp}status_update/> tags.
   - Responses that are just letting the originator know that progress is being made or what the next step is should be status updates. They should be brief and to the point. 
     <action_rules>
@@ -350,7 +352,7 @@ def UserStimulusPrompt(
     )
 
     prompt = (
-        "NOTE - this history represents the conversation as seen by the user on the other side of the gateway. It does not include the assistant's invoke actions or reasoning. All of that has been removed, so don't use this history as an example for how the assistant should behave\n"
+        "NOTE - this history represents the conversation as seen by the user on the other side of the gateway. It does not include the responses from invoked actions or reasoning. All of that has been removed, so don't use this history as an example for how the assistant should behave\n"
         f"{gateway_history_str}\n"
         f"<{info['tag_prefix']}stimulus>\n"
         f"{stimulus}\n"
@@ -408,7 +410,7 @@ reputation is on the line.
 """
 
 
-def ContextQueryPrompt(query: str, context: str) -> HumanMessage:
+def ContextQueryPrompt(query: str, context: str) -> str:
     return f"""
 You (orchestrator) are being asked to query, comment on or edit the following text following the originator's request.
 Do your best to give a complete and accurate answer using only the context given below. Ensure that you
@@ -433,11 +435,11 @@ you should ask the originator for more information. Include links to the source
 def format_examples_by_llm_type(examples: list, llm_type: str = "anthropic") -> list:
     """
     Render examples based on llm type
-    
+
     Args:
         llm_type (str): The type of LLM to render examples for (default: "anthropic")
         examples (list): List of examples in model-agnostic format
-        
+
     Returns:
         list: List of examples formatted for the specified LLM
     """
@@ -452,11 +454,12 @@ def format_examples_by_llm_type(examples: list, llm_type: str = "anthropic") ->
 
     return formatted_examples
 
+
 def format_example_for_anthropic(example: dict) -> str:
     """
     Format an example for the Anthropic's LLMs
     """
-    
+
     tag_prefix = example.get("tag_prefix_placeholder", "t123")
     starting_id = example.get("starting_id", "1")
     docstring = example.get("docstring", "")
@@ -464,7 +467,7 @@ def format_example_for_anthropic(example: dict) -> str:
     metadata_lines = example.get("metadata", [])
     reasoning_lines = example.get("reasoning", [])
     response_text = example.get("response_text", "")
-    
+
     # Start building the XML structure, add the description and user input
     xml_content = f"""<example>
         <example_docstring>
@@ -476,41 +479,41 @@ def format_example_for_anthropic(example: dict) -> str:
             </{tag_prefix}stimulus>
             <{tag_prefix}stimulus_metadata>
             """
-    
+
     # Add metadata lines
     for metadata_line in metadata_lines:
         xml_content += f"{metadata_line}\n"
-    
+
     xml_content += f"""</{tag_prefix}stimulus_metadata>
         </example_stimulus>
         <example_response>
             <{tag_prefix}reasoning>
             """
-    
+
     # Add reasoning lines
     for reasoning_line in reasoning_lines:
         xml_content += f"{reasoning_line}\n"
-    
+
     xml_content += f"""</{tag_prefix}reasoning>
             {response_text}"""
-    
+
     # Add action invocation section
     if "action" in example:
         action_data = example.get("action", {})
         status_update = example.get("status_update", "")
         agent_name = action_data.get("agent", "")
         action_name = action_data.get("name", "")
-        
+
         xml_content += f"""
             <{tag_prefix}status_update>{status_update}</{tag_prefix}status_update>
             <{tag_prefix}invoke_action agent="{agent_name}" action="{action_name}">"""
-        
+
         # Handle parameters as dictionary
         parameter_dict = action_data.get("parameters", {})
         for param_name, param_value in parameter_dict.items():
             xml_content += f"""
             <{tag_prefix}parameter name="{param_name}">"""
-            
+
             # Handle parameter names and values (as lists)
             if isinstance(param_value, list):
                 for line in param_value:
@@ -519,11 +522,11 @@ def format_example_for_anthropic(example: dict) -> str:
             else:
                 # For simple string values
                 xml_content += f"{param_value}"
-                
+
             xml_content += f"</{tag_prefix}parameter>\n"
-    
+
         xml_content += f"</{tag_prefix}invoke_action>"
-    
+
     # Close the XML structure
     xml_content += """
         </example_response>
@@ -532,4 +535,5 @@ def format_example_for_anthropic(example: dict) -> str:
 
     return xml_content
 
-LONG_TERM_MEMORY_PROMPT = " - You are capable of remembering things and have long-term memory, this happens automatically."
+
+LONG_TERM_MEMORY_PROMPT = " - You are capable of remembering things and have long-term memory, this happens automatically."

solace_agent_mesh/services/history_service/history_providers/sql_history_provider.py

@@ -72,7 +72,7 @@ class SQLHistoryProvider(BaseHistoryProvider):
         query = f"SELECT data FROM {self.table_name} WHERE session_id = %s"
         cursor = self.db.execute(query, (session_id,))
         row = cursor.fetchone()
-        if not row.get("data"):
+        if not row or not row.get("data"):
             return {}
         data = row["data"] if isinstance(row["data"], dict) else json.loads(row["data"])
         return data

solace_agent_mesh/services/llm_service/components/llm_request_component.py

@@ -195,49 +195,72 @@ class LLMRequestComponent(ComponentBase):
         aggregate_result = ""
         current_batch = ""
         first_chunk = True
+        error = False
 
-        for response_message, last_message in self.do_broker_request_response(
-            llm_message,
-            stream=True,
-            streaming_complete_expression="input.payload:last_chunk",
-        ):
-            # Only process if the stimulus UUIDs correlate
-            if not self._correlate_request_and_response(input_message, response_message):
-                log.error("Mismatched request and response stimulus UUIDs: %s %s",
-                        self._get_user_propery(input_message, "stimulus_uuid"),
-                        self._get_user_propery(response_message, "stimulus_uuid"))                
-                raise ValueError("Mismatched request and response stimulus UUIDs")
-
-            payload = response_message.get_payload()
-            content = payload.get("chunk", "")
-            aggregate_result += content
-            current_batch += content
-
-            if payload.get("handle_error", False):
-                log.error("Error invoking LLM service: %s", payload.get("content", ""), exc_info=True)
-                aggregate_result = payload.get("content", None)
-                last_message = True
-
-            if len(current_batch.split()) >= self.stream_batch_size or last_message:
+        try:
+            for response_message, last_message in self.do_broker_request_response(
+                llm_message,
+                stream=True,
+                streaming_complete_expression="input.payload:last_chunk",
+            ):
+                # Only process if the stimulus UUIDs correlate
+                if not self._correlate_request_and_response(input_message, response_message):
+                    log.error("Mismatched request and response stimulus UUIDs: %s %s",
+                            self._get_user_propery(input_message, "stimulus_uuid"),
+                            self._get_user_propery(response_message, "stimulus_uuid"))
+                    raise ValueError("Mismatched request and response stimulus UUIDs")
+
+                payload = response_message.get_payload()
+                content = payload.get("chunk", "")
+                aggregate_result += content
+                current_batch += content
+
+                if payload.get("handle_error", False):
+                    log.error("Error invoking LLM service: %s", payload.get("content", ""), exc_info=True)
+                    aggregate_result = payload.get("content", None)
+                    last_message = True
+                    error = True
+
+                if len(current_batch.split()) >= self.stream_batch_size or last_message:
+                    self._send_streaming_chunk(
+                        input_message,
+                        current_batch,
+                        aggregate_result,
+                        response_uuid,
+                        first_chunk,
+                        last_message,
+                    )
+                    current_batch = ""
+                    first_chunk = False
+
+                if last_message:
+                    break
+        except TimeoutError as e:
+            log.error("Timeout error during streaming: %s", e, exc_info=True)
+            aggregate_result = "That request took too long to process. Try again with a more focused request or by breaking it in smaller parts."
+            error = True
+        except Exception as e:
+            log.error("Error during streaming: %s", e, exc_info=True)
+            aggregate_result = f"I apologize, but I encountered an error while processing your request: {str(e)}"
+            error = True
+        finally:
+            # Send a final error chunk if there was an error
+            if error:
                 self._send_streaming_chunk(
                     input_message,
-                    current_batch,
+                    aggregate_result,
                     aggregate_result,
                     response_uuid,
                     first_chunk,
-                    last_message,
+                    True,
                 )
-                current_batch = ""
-                first_chunk = False
-
-            if last_message:
-                break
-
+        # Return the final result
         return {
             "content": aggregate_result,
             "response_uuid": response_uuid,
             "streaming": True,
             "last_chunk": True,
+            "error": error
         }
 
     def _create_llm_message(self, message: Message, messages: list, source_info: dict) -> Message:

solace_agent_mesh/templates/rest-api-default-config.yaml

@@ -24,6 +24,8 @@
     local_dev : ${WEBUI_LOCAL_DEV}
 
 - response_format_prompt: &response_format_prompt >
-    Return all responses in markdown format. When returning files or images, use the <{{tag_prefix}}file> tags.
-    Do not return files as links or with generic <file> tags.
+    Use markdown formatting for text responses.
+    FILE HANDLING REQUIREMENTS:
+    - ALWAYS use <{{tag_prefix}}file> tags for files/images
+    - NEVER use markdown image/link syntax or generic HTML tags for files
     

solace_agent_mesh/templates/solace-agent-mesh-default.yaml

@@ -16,6 +16,15 @@ solace_agent_mesh:
         # Slack agent, send messages to Slack channels
       - name: slack
         enabled: true
+    # Configuring the built-in services
+    services:
+      # Embedding service for vector embeddings
+      # If enabled, the following environment variables are required:
+      # - EMBEDDING_SERVICE_MODEL_NAME
+      # - EMBEDDING_SERVICE_API_KEY
+      # - EMBEDDING_SERVICE_ENDPOINT
+      - name: embedding
+        enabled: false
 
   # Directory to component yaml config files, this directory would have a sub directory for each component type
   config_directory: configs

solace_agent_mesh/templates/web-default-config.yaml

@@ -4,5 +4,7 @@
     max_file_size: 2000 # 2GB
 
 - response_format_prompt: &response_format_prompt >
-    Return all responses in markdown format. When returning files or images, use the <{{tag_prefix}}file> tags.
-    Do not return files as links or with generic <file> tags.
+    Use markdown formatting for text responses.
+    FILE HANDLING REQUIREMENTS:
+    - ALWAYS use <{{tag_prefix}}file> tags for files/images
+    - NEVER use markdown image/link syntax or generic HTML tags for files