solace-agent-mesh 0.2.4__py3-none-any.whl → 1.0.1__py3-none-any.whl

solace_agent_mesh/services/llm_service/components/llm_request_component.py

@@ -1,340 +0,0 @@
-"""LLM Request Component for performing LLM service requests."""
-
-import uuid
-from typing import Dict, Any
-
-from solace_ai_connector.components.component_base import ComponentBase
-from solace_ai_connector.common.log import log
-from solace_ai_connector.common.message import Message
-from solace_ai_connector.common.utils import ensure_slash_on_end
-
-info = {
-    "class_name": "LLMRequestComponent",
-    "description": "Component that performs LLM service requests",
-    "config_parameters": [
-        {
-            "name": "llm_service_topic",
-            "required": True,
-            "description": "The topic for the LLM service",
-        },
-        {
-            "name": "stream_to_flow",
-            "required": False,
-            "description": (
-                "Name the flow to stream the output to - this must be configured for "
-                "llm_mode='stream'. This is mutually exclusive with stream_to_next_component."
-            ),
-            "default": "",
-        },
-        {
-            "name": "stream_to_next_component",
-            "required": False,
-            "description": (
-                "Whether to stream the output to the next component in the flow. "
-                "This is mutually exclusive with stream_to_flow."
-            ),
-            "default": False,
-        },
-        {
-            "name": "llm_mode",
-            "required": False,
-            "description": (
-                "The mode for streaming results: 'sync' or 'stream'. 'stream' "
-                "will just stream the results to the named flow. 'none' will "
-                "wait for the full response."
-            ),
-            "default": "none",
-        },
-        {
-            "name": "stream_batch_size",
-            "required": False,
-            "description": "The minimum number of words in a single streaming result.",
-            "default": 15,
-        },
-    ],
-    "input_schema": {
-        "type": "object",
-        "properties": {
-            "messages": {
-                "type": "array",
-                "items": {
-                    "type": "object",
-                    "properties": {
-                        "role": {
-                            "type": "string",
-                            "enum": ["system", "user", "assistant"],
-                        },
-                        "content": {"type": "string"},
-                    },
-                    "required": ["role", "content"],
-                },
-            },
-            "source_info": {
-                "type": "object",
-                "properties": {
-                    "type": {"type": "string"},
-                },
-                "required": ["type"],
-            },
-        },
-        "required": ["messages"],
-    },
-    "output_schema": {
-        "type": "object",
-        "properties": {
-            "content": {
-                "type": "string",
-                "description": "The generated response from the model",
-            },
-            "chunk": {
-                "type": "string",
-                "description": "The current chunk of the response",
-            },
-            "response_uuid": {
-                "type": "string",
-                "description": "The UUID of the response",
-            },
-            "first_chunk": {
-                "type": "boolean",
-                "description": "Whether this is the first chunk of the response",
-            },
-            "last_chunk": {
-                "type": "boolean",
-                "description": "Whether this is the last chunk of the response",
-            },
-            "streaming": {
-                "type": "boolean",
-                "description": "Whether this is a streaming response",
-            },
-        },
-        "required": ["content"],
-    },
-}
-
-
-class LLMRequestComponent(ComponentBase):
-    """Component that performs LLM service requests."""
-
-    def __init__(self, child_info=None, **kwargs):
-        super().__init__(child_info or info, **kwargs)
-        self.init()
-
-    def init(self):
-        """Initialize the component with configuration parameters."""
-        self.llm_service_topic = ensure_slash_on_end(
-            self.get_config("llm_service_topic")
-        )
-        self.stream_to_flow = self.get_config("stream_to_flow")
-        self.stream_to_next_component = self.get_config("stream_to_next_component")
-        self.llm_mode = self.get_config("llm_mode")
-        self.stream_batch_size = self.get_config("stream_batch_size")
-
-        if self.stream_to_flow and self.stream_to_next_component:
-            raise ValueError(
-                "stream_to_flow and stream_to_next_component are mutually exclusive"
-            )
-
-        if not self.is_broker_request_response_enabled():
-            raise ValueError(
-                "LLM service topic is set, but the component does not "
-                f"have its broker request/response enabled, {self.__class__.__name__}"
-            )
-
-    def invoke(self, message: Message, data: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Invoke the LLM service request.
-
-        Args:
-            message (Message): The input message.
-            data (Dict[str, Any]): The input data containing the messages.
-
-        Returns:
-            Dict[str, Any]: The response from the LLM service.
-        """
-        messages = data.get("messages", [])
-        source_info = data.get("source_info", {})
-        llm_message = self._create_llm_message(message, messages, source_info)
-        response_uuid = str(uuid.uuid4())
-
-        try:
-            if self.llm_mode == "stream":
-                return self._handle_streaming(message, llm_message, response_uuid)
-            else:
-                return self._handle_sync(llm_message)
-        except Exception as e:
-            log.error("Error invoking LLM service: %s", e, exc_info=True)
-            raise
-
-    def _handle_sync(self, llm_message: Message) -> Dict[str, Any]:
-        """
-        Handle synchronous LLM service request.
-
-        Args:
-            llm_message (Message): The message to send to the LLM service.
-
-        Returns:
-            Dict[str, Any]: The response from the LLM service.
-        """
-        response = self.do_broker_request_response(llm_message)
-        return response.get_payload()
-
-    def _handle_streaming(
-        self, input_message: Message, llm_message: Message, response_uuid: str
-    ) -> Dict[str, Any]:
-        """
-        Handle streaming LLM service request.
-
-        Args:
-            input_message (Message): The original input message.
-            llm_message (Message): The message to send to the LLM service.
-            response_uuid (str): The UUID for the response.
-
-        Returns:
-            Dict[str, Any]: The final response from the LLM service.
-        """
-        aggregate_result = ""
-        current_batch = ""
-        first_chunk = True
-        error = False
-
-        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,
-                    aggregate_result,
-                    aggregate_result,
-                    response_uuid,
-                    first_chunk,
-                    True,
-                )
-        # 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:
-        """
-        Create a message for the LLM service request.
-
-        Args:
-            message (Message): The original input message.
-            messages (list): The list of messages to send to the LLM service.
-            source_info (dict): Information about the caller to help montoring LLM requests.
-
-        Returns:
-            Message: The created message for the LLM service.
-        """
-        user_properties = message.get_user_properties().copy()
-        stimulus_uuid = user_properties.get("stimulus_uuid", str(uuid.uuid4()))
-        session_id = user_properties.get("session_id", "x")
-        originator_id = user_properties.get("originator_id", "x")
-        user_properties["llm_request_source_info"] = source_info
-
-        topic = f"{self.llm_service_topic}{stimulus_uuid}/{session_id}/{originator_id}"
-
-        return Message(
-            topic=topic,
-            payload={"messages": messages, "stream": True},
-            user_properties=user_properties,
-        )
-
-    def _send_streaming_chunk(
-        self,
-        input_message: Message,
-        chunk: str,
-        aggregate_result: str,
-        response_uuid: str,
-        first_chunk: bool,
-        last_chunk: bool,
-    ):
-        """
-        Send a streaming chunk to the specified flow or next component.
-
-        Args:
-            input_message (Message): The original input message.
-            chunk (str): The current chunk of the response.
-            aggregate_result (str): The aggregated result so far.
-            response_uuid (str): The UUID of the response.
-            first_chunk (bool): Whether this is the first chunk.
-            last_chunk (bool): Whether this is the last chunk.
-        """
-        payload = {
-            "chunk": chunk,
-            "content": aggregate_result,
-            "response_uuid": response_uuid,
-            "first_chunk": first_chunk,
-            "last_chunk": last_chunk,
-            "streaming": True,
-        }
-        message = Message(
-            payload=payload,
-            user_properties=input_message.get_user_properties(),
-        )
-
-        if self.stream_to_flow:
-            self.send_to_flow(self.stream_to_flow, message)
-        elif self.stream_to_next_component:
-            self.send_message(message)
-
-    @staticmethod
-    def _get_user_propery(message, user_property_key):
-        message_props = message.get_user_properties()
-        return message_props.get(user_property_key, "unknown")
-
-    # Define a helper function to check if response matches request
-    @staticmethod
-    def _correlate_request_and_response(request_msg, response_msg, correlation_key="stimulus_uuid"):
-        return (LLMRequestComponent._get_user_propery(request_msg, correlation_key) == 
-            LLMRequestComponent._get_user_propery(response_msg, correlation_key))
-

solace_agent_mesh/services/llm_service/components/llm_service_component_base.py

@@ -1,152 +0,0 @@
-"""This is the base class that provides LLM and Embedding service access"""
-
-from abc import ABC , abstractmethod
-from solace_ai_connector.components.component_base import ComponentBase
-from solace_ai_connector.common.message import Message
-from solace_ai_connector.common.utils import ensure_slash_on_end
-
-
-
-agent_info = {
-    "class_name": "LLMServiceComponentBase",
-    "description": "This is the base class that provides LLM and Embedding service access",
-    "config_parameters": [
-        {
-            "name": "llm_service_topic",
-            "required": False,
-            "description": "The topic to use for the LLM service",
-        },
-        {
-            "name": "embedding_service_topic",
-            "required": False,
-            "description": "The topic to use for the Embedding service",
-        },
-    ]
-}
-
-
-class LLMServiceComponentBase(ComponentBase, ABC):
-
-    def __init__(self, module_info={}, **kwargs):
-        super().__init__(module_info, **kwargs)
-        self.current_message = None
-        self.current_request_data = None
-
-        self.llm_service_topic = self.get_config("llm_service_topic")
-        if self.llm_service_topic:
-            self.llm_service_topic = ensure_slash_on_end(self.llm_service_topic)
-            # Check that the component's broker request/response is enabled
-            if not self.is_broker_request_response_enabled():
-                raise ValueError(
-                    "LLM service topic is set, but the component does not "
-                    f"have its broker request/response enabled, {self.__class__.__name__}"
-                )
-
-        self.embedding_service_topic = self.get_config("embedding_service_topic")
-        if self.embedding_service_topic:
-            self.embedding_service_topic = ensure_slash_on_end(
-                self.embedding_service_topic
-            )
-            # Check that the component's broker request/response is enabled
-            if not self.is_broker_request_response_enabled():
-                raise ValueError(
-                    "Embedding service topic is set, but the component does not "
-                    f"have its broker request/response enabled, {self.__class__.__name__}"
-                )
-            
-    def process_pre_invoke(self, message):
-        self.current_request_data = super().process_pre_invoke(message)
-        return self.current_request_data
-
-    def process_post_invoke(self, result, message):
-        super().process_post_invoke(result, message)
-        self.current_request_data = None
-
-    @abstractmethod
-    def invoke(self, message, data):
-        pass
-
-    def do_llm_service_request_stream(self, message):
-        for response_message, last_message in self.do_broker_request_response(
-            message,
-            stream=True,
-            streaming_complete_expression="input.payload:last_chunk",
-        ):
-            yield response_message.get_payload(), last_message
-        return
-
-    def do_llm_service_request(self, messages, stream=False, resolve_files=False):
-        """Send a message to the LLM service"""
-        if not self.llm_service_topic:
-            raise ValueError(f"LLM service topic not set on {self.__class__.__name__}")
-
-        user_properties = self.current_message.get_user_properties().copy()
-
-        # Add the topic suffix
-        stimulus_uuid = user_properties.get("stimulus_uuid", "x")
-        session_id = user_properties.get("session_id", "x")
-        originator_id = user_properties.get("originator_id", "x")
-
-        topic = f"{self.llm_service_topic}{stimulus_uuid}/{session_id}/{originator_id}"
-        user_properties["resolve_files"] = resolve_files
-
-        if self.current_request_data:
-            action_list_id = self.current_request_data.get("action_list_id")
-            action_idx = self.current_request_data.get("action_idx")
-            action_name = self.current_request_data.get("action_name")
-
-            source_info = {
-                "type": "agent",
-                "agent_name": self.info.get("agent_name"),
-                "action_list_id": action_list_id,
-                "action_idx": action_idx,
-                "action_name": action_name,
-            }
-        else:
-            source_info = {
-                "type": "agent",
-                "agent_name": self.info.get("agent_name"),
-            }
-
-        user_properties["llm_request_source_info"] = source_info
-
-        message = Message(
-            topic=topic,
-            payload={"messages": messages, "stream": stream},
-            user_properties=user_properties,
-        )
-
-        if stream:
-            return self.do_llm_service_request_stream(message)
-        else:
-            return self.do_broker_request_response(message).get_payload()
-
-    def do_embedding_service_request(self, items, resolve_files=False):
-        """Send a message to the Embedding service"""
-        if not self.embedding_service_topic:
-            raise ValueError(
-                f"Embedding service topic not set on {self.__class__.__name__}"
-            )
-
-        user_properties = self.current_message.get_user_properties().copy()
-
-        # Add the topic suffix
-        stimulus_uuid = user_properties.get("stimulus_uuid", "x")
-        session_id = user_properties.get("session_id", "x")
-        originator_id = user_properties.get("originator_id", "x")
-
-        topic = f"{self.embedding_service_topic}{stimulus_uuid}/{session_id}/{originator_id}"
-        user_properties["resolve_files"] = resolve_files
-
-        message = Message(
-            topic=topic,
-            payload={
-                "items": items,
-            },
-            user_properties=user_properties,
-        )
-
-        return (
-            self.do_broker_request_response(message).get_payload().get("embeddings", [])
-        )
-

solace_agent_mesh/services/middleware_service/middleware_service.py

@@ -1,20 +0,0 @@
-from ..common.singleton import SingletonMeta
-
-class MiddlewareService(metaclass=SingletonMeta):
-    def __init__(self):
-        self._middleware = {}
-        self._register_defaults()
-    
-    def _register_defaults(self):
-        # Default middleware that just returns actions unchanged
-        self.register("filter_action", lambda user_properties, actions: actions)
-        # Default middleware that allows all actions
-        self.register("base_agent_filter", lambda user_properties, action: True)
-        # Default middleware that allows all action requests
-        self.register("validate_action_request", lambda user_properties, action_details: True)
-    
-    def register(self, name: str, middleware_fn):
-        self._middleware[name] = middleware_fn
-    
-    def get(self, name: str):
-        return self._middleware.get(name, lambda *args, **kwargs: args[0] if len(args) == 1 else args)

solace_agent_mesh/templates/action.py

@@ -1,38 +0,0 @@
-"""Action description"""
-
-from solace_ai_connector.common.log import log
-
-
-from solace_agent_mesh.common.action import Action
-from solace_agent_mesh.common.action_response import ActionResponse
-
-# To import from a local file, like this file, use a relative path from the {{SNAKE_CASE_NAME}}
-# For example, to load this class, use:
-#   from {{SNAKE_CASE_NAME}}.actions.sample_action import SampleAction
-
-
-class SampleAction(Action):
-    def __init__(self, **kwargs):
-        super().__init__(
-            {
-                "name": "sample_action",
-                "prompt_directive": ("detailed description of the action. " "examples, chain of thought, etc." "details for parameters"),
-                "params": [
-                    {
-                        "name": "sampleParam",
-                        "desc": "Description of the parameter",
-                        "type": "type of parameter (string, int, etc.)",
-                    }
-                ],
-                "required_scopes": ["{{SNAKE_CASE_NAME}}:sample_action:read"],
-            },
-            **kwargs,
-        )
-
-    def invoke(self, params, meta={}) -> ActionResponse:
-        log.debug("Doing sample action: %s", params["sampleParam"])
-        return self.do_action(params["sampleParam"])
-
-    def do_action(self, sample) -> ActionResponse:
-        sample += " Action performed"
-        return ActionResponse(message=sample)

solace_agent_mesh/templates/agent.py

@@ -1,29 +0,0 @@
-"""The agent component for the {{SPACED_NAME}}"""
-
-import os
-import copy
-import sys
-
-SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
-sys.path.append(os.path.dirname(SCRIPT_DIR))
-
-from solace_agent_mesh.agents.base_agent_component import (
-    agent_info,
-    BaseAgentComponent,
-)
-
-# Sample action import
-from {{SNAKE_CASE_NAME}}.actions.sample_action import SampleAction
-
-info = copy.deepcopy(agent_info)
-info["agent_name"] = "{{SNAKE_CASE_NAME}}"
-info["class_name"] = "{{CAMEL_CASE_NAME}}AgentComponent"
-info["description"] = (
-    "This agent handles ... It should be used "
-    "when an user explicitly requests information ... "
-)
-
-class {{CAMEL_CASE_NAME}}AgentComponent(BaseAgentComponent):
-    info = info
-    # sample action
-    actions = [SampleAction]

solace_agent_mesh/templates/agent.yaml

@@ -1,70 +0,0 @@
-# This is the configuration file for the {{SPACED_NAME}} agent
-#
-# It fulfills a few functions:
-# 1. A flow to do periodic registration of this agent with the orchestrator
-# 2. A flow to process action requests and produce action responses
-#    This requires a custom component to process the action requests
-
----
-log:
-  stdout_log_level: INFO
-  log_file_level: INFO
-  log_file: solace_ai_connector.log
-
-shared_config:
-  - broker_config: &broker_connection
-      dev_mode: ${SOLACE_DEV_MODE, false}
-      broker_url: ${SOLACE_BROKER_URL}
-      broker_username: ${SOLACE_BROKER_USERNAME}
-      broker_password: ${SOLACE_BROKER_PASSWORD}
-      broker_vpn: ${SOLACE_BROKER_VPN}
-      temporary_queue: ${USE_TEMPORARY_QUEUES, false}
-
-flows:
-
-  # Flow to handle action requests
-  - name: {{SNAKE_CASE_NAME}}_action_request_processor
-    components:
-      # Input from a Solace broker
-      - component_name: broker_input
-        component_module: broker_input
-        component_config:
-          <<: *broker_connection
-          payload_encoding: utf-8
-          payload_format: json
-          broker_queue_name: ${SOLACE_AGENT_MESH_NAMESPACE}agent_{{SNAKE_CASE_NAME}}_action_request
-          broker_subscriptions:
-            # Subscribe to all {{SNAKE_CASE_NAME}} actions - note that if we
-            # wanted to handle some {{SNAKE_CASE_NAME}} actions elsewhere, we would
-            # need to be more specific here
-            - topic: ${SOLACE_AGENT_MESH_NAMESPACE}solace-agent-mesh/v1/actionRequest/*/*/{{SNAKE_CASE_NAME}}/>
-              qos: 1
-
-      # Custom component to process the action request
-      - component_name: action_request_processor
-        component_base_path: .
-         # path is completed at build time
-        component_module: {{MODULE_DIRECTORY}}.agents.{{SNAKE_CASE_NAME}}.{{SNAKE_CASE_NAME}}_agent_component
-        component_config:
-          llm_service_topic: ${SOLACE_AGENT_MESH_NAMESPACE}solace-agent-mesh/v1/llm-service/request/general-good/
-          embedding_service_topic: ${SOLACE_AGENT_MESH_NAMESPACE}solace-agent-mesh/v1/embedding-service/request/text/
-          # Pass required configuration to the component
-        broker_request_response:
-          enabled: true
-          broker_config: *broker_connection
-          request_expiry_ms: 120000
-          payload_encoding: utf-8
-          payload_format: json
-          response_topic_prefix: ${SOLACE_AGENT_MESH_NAMESPACE}solace-agent-mesh/v1
-          response_queue_prefix: ${SOLACE_AGENT_MESH_NAMESPACE}solace-agent-mesh/v1
-        component_input:
-          source_expression: input.payload
-
-      # Output to a Solace broker
-      - component_name: broker_output
-        component_module: broker_output
-        component_config:
-          <<: *broker_connection
-          payload_encoding: utf-8
-          payload_format: json
-          copy_user_properties: true

solace_agent_mesh/templates/gateway-config-template.yaml

@@ -1,6 +0,0 @@
-- {{SNAKE_CASE_NAME}}_config: &gateway_interface_config
-    key: "value" # Add your configuration here
-
-- 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.