solace-agent-mesh 0.0.1__py3-none-any.whl → 0.1.0__py3-none-any.whl

solace_agent_mesh/services/llm_service/components/llm_service_component_base.py

@@ -0,0 +1,152 @@
+"""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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,38 @@
+"""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

@@ -0,0 +1,29 @@
+"""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

@@ -0,0 +1,70 @@
+# 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

@@ -0,0 +1,6 @@
+- {{SNAKE_CASE_NAME}}_config: &gateway_interface_config
+    key: "value" # Add your configuration here
+
+- response_format_prompt: &response_format_prompt >
+    Format the response using Markdown text formatting such as
+    **bold**, _italic_, and `code` where necessary.

solace_agent_mesh/templates/gateway-default-config.yaml

@@ -0,0 +1,28 @@
+- history_policy: &default_history_policy
+    type: "memory" # "memory", "redis", or your custom module name
+    module_path: . # Path to module, Only needed if you are using a custom module
+    time_to_live: 3600 # 1 hour
+    expiration_check_interval: 300 # 5 minutes
+    history_policy: # History provider configs (Passed to the history type provider)
+      max_turns: 40
+      max_characters: 50000
+      enforce_alternate_message_roles: true
+
+- identity_config: &default_identity_config
+    type: "passthru" # "passthru", "bamboohr", or your custom module name
+    module_path: . # Path to module, Only needed if you are using a custom module
+    configuration: {}
+
+- gateway_config: &gateway_config
+    gateway_id: {{GATEWAY_ID}}
+    system_purpose: >
+      The system is an AI Chatbot, that is providing information reasoning and general assistance for writing 
+      and coding to the users in this system.
+    interaction_type: "interactive"
+
+    identity:
+      <<: *default_identity_config
+
+    retain_history: true
+    history_config: 
+      <<: *default_history_policy

solace_agent_mesh/templates/gateway-flows.yaml

@@ -0,0 +1,81 @@
+
+  # Gateway to Solace
+  - name: gateway_input_flow
+    components:
+      - component_name: input_gateway
+        component_module: {{MODULE_DIRECTORY}}.gateways.{{SNAKE_CASE_NAME}}.{{SNAKE_CASE_NAME}}_input
+        component_base_path: .
+        component_config:
+          <<: *gateway_interface_config
+      - component_name: gateway_input
+        component_base_path: .
+        component_module: src.gateway.components.gateway_input
+        component_config:
+          identity_key_field: identity
+          <<: *gateway_config
+        component_input:
+          source_expression: previous
+        input_transforms:
+          - type: copy
+            source_value: *response_format_prompt
+            dest_expression: input.user_properties:response_format_prompt
+      - component_name: broker_output
+        component_module: broker_output
+        component_config:
+          <<: *broker_connection
+          payload_encoding: utf-8
+          payload_format: json
+          copy_user_properties: true
+        input_transforms:
+          - type: copy
+            source_expression: previous
+            dest_expression: user_data.output:payload
+          - type: copy
+            source_expression: template:${SOLACE_AGENT_MESH_NAMESPACE}solace-agent-mesh/v1/stimulus/gateway/gateway_input/{{GATEWAY_ID}}
+            dest_expression: user_data.output:topic
+        component_input:
+          source_expression: user_data.output
+
+  # Solace output Gateway
+  - name: gateway_output_flow
+    trace_level: DEBUG
+    components:
+      - component_name: broker_input
+        component_module: broker_input
+        component_config:
+          <<: *broker_connection
+          broker_queue_name: ${SOLACE_AGENT_MESH_NAMESPACE}_{{GATEWAY_ID}}
+          broker_subscriptions:
+            - topic: ${SOLACE_AGENT_MESH_NAMESPACE}solace-agent-mesh/v1/response/orchestrator/{{GATEWAY_ID}}
+              qos: 1
+            - topic: ${SOLACE_AGENT_MESH_NAMESPACE}solace-agent-mesh/v1/streamingResponse/orchestrator/{{GATEWAY_ID}}
+              qos: 1
+            - topic: ${SOLACE_AGENT_MESH_NAMESPACE}solace-agent-mesh/v1/responseComplete/orchestrator/{{GATEWAY_ID}}
+              qos: 1
+          payload_encoding: utf-8
+          payload_format: json
+
+      - component_name: output_gateway
+        component_base_path: .
+        component_module: src.gateway.components.gateway_output
+        component_config:
+          <<: *gateway_config
+          copy_user_properties: true
+        component_input:
+          source_expression: input.payload
+
+      - component_name: output_gateway
+        component_module: {{MODULE_DIRECTORY}}.gateways.{{SNAKE_CASE_NAME}}.{{SNAKE_CASE_NAME}}_output
+        component_base_path: .
+        component_config:
+          <<: *gateway_interface_config
+        input_transforms:
+          - type: copy
+            source_expression: input.user_properties
+            dest_expression: user_data.component_input:message_info
+          - type: copy
+            source_expression: input.payload
+            dest_expression: user_data.component_input:content
+        component_input:
+          source_expression: user_data.component_input
+

solace_agent_mesh/templates/gateway-header.yaml

@@ -0,0 +1,16 @@
+---
+log:
+  stdout_log_level: INFO
+  log_file_level: INFO
+  log_file: solace_ai_connector.log
+
+shared_config:
+  - broker_config: &broker_connection
+      broker_connection_share: ${SOLACE_BROKER_URL}
+      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}
+

solace_agent_mesh/templates/gateway_base.py

@@ -0,0 +1,15 @@
+"""Base class for all {{CAMEL_CASE_NAME}} gateways"""
+
+from abc import ABC, abstractmethod
+from solace_ai_connector.components.component_base import ComponentBase
+
+
+# You can use a singleton pattern or a class variable to
+# share a state between the input and output gateways
+
+class {{CAMEL_CASE_NAME}}Base(ComponentBase, ABC):
+    """Base class for all {{CAMEL_CASE_NAME}} gateways"""
+
+    @abstractmethod
+    def invoke(self, message, data):
+        pass

solace_agent_mesh/templates/gateway_input.py

@@ -0,0 +1,98 @@
+import os
+import sys
+import queue
+import threading
+
+from solace_ai_connector.common.log import log
+from solace_ai_connector.common.message import Message
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+sys.path.append(os.path.dirname(SCRIPT_DIR))
+
+from {{SNAKE_CASE_NAME}}.{{SNAKE_CASE_NAME}}_base import {{CAMEL_CASE_NAME}}Base
+
+
+info = {
+    "class_name": "{{CAMEL_CASE_NAME}}Input",
+    "description": (
+        "Description of your gateway input."
+    ),
+    "config_parameters": [],
+    "output_schema": {
+        "type": "object",
+        "properties": {
+            "event": {
+                "type": "object",
+                "properties": {
+                    "text": {
+                        "type": "string",
+                    },
+                    "files": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "name": {
+                                    "type": "string",
+                                },
+                                "content": {
+                                    "type": "string",
+                                },
+                                "size": {
+                                    "type": "number",
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        "required": ["event"],
+    },
+}
+
+
+class {{CAMEL_CASE_NAME}}Input({{CAMEL_CASE_NAME}}Base):
+    def __init__(self, **kwargs):
+        super().__init__(info, **kwargs)
+        log.debug("{{CAMEL_CASE_NAME}}Input initialized")
+
+        self.message_queue = queue.Queue()
+
+        self.{{SNAKE_CASE_NAME}}_thread = threading.Thread(target=self.start_{{SNAKE_CASE_NAME}}, args=(self.message_queue))
+        self.{{SNAKE_CASE_NAME}}_thread.daemon = True
+        self.{{SNAKE_CASE_NAME}}_thread.start()
+
+    def stop_component(self):
+        log.debug("Stopping {{CAMEL_CASE_NAME}}Input component")
+        if self.{{SNAKE_CASE_NAME}}_thread:
+            self.{{SNAKE_CASE_NAME}}_thread.join()
+    
+    def start_{{SNAKE_CASE_NAME}}(self, message_queue):
+        # This is a placeholder for the actual implementation
+        payload = {
+            "text": "Hello, World!",
+            "files": [
+                {
+                    "name": "file.txt",
+                    "content": "base64 encoded content",
+                    "size": 10,
+                }
+            ]
+        }
+        user_properties = {
+            "session_id": "session_id",
+            "identity": "test@email.com"
+        }
+        message = Message(payload=payload, user_properties=user_properties)
+        message.set_previous(payload)
+        message_queue.put(message)
+
+    def get_next_message(self):
+        """Get the next message from the queue.
+        """
+        return self.message_queue.get()
+
+    def invoke(self, message:Message, data:dict):
+        log.debug("{{CAMEL_CASE_NAME}}Output invoked, %s", data)
+        return data

solace_agent_mesh/templates/gateway_output.py

@@ -0,0 +1,71 @@
+import os
+import sys
+
+from solace_ai_connector.common.log import log
+from solace_ai_connector.common.message import Message
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+sys.path.append(os.path.dirname(SCRIPT_DIR))
+
+from {{SNAKE_CASE_NAME}}.{{SNAKE_CASE_NAME}}_base import {{CAMEL_CASE_NAME}}Base
+
+info = {
+    "class_name": "{{CAMEL_CASE_NAME}}Output",
+    "description": (
+        "Description of your gateway output."
+    ),
+    "config_parameters": [],
+    "input_schema": {
+        "type": "object",
+        "properties": {
+            "message_info": {
+                "type": "object",
+                "properties": {
+                    "session_id": {
+                        "type": "string",
+                    },
+                },
+                "required": ["session_id"],
+            },
+            "content": {
+                "type": "object",
+                "properties": {
+                    "text": {
+                        "type": "string",
+                    },
+                    "files": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "name": {
+                                    "type": "string",
+                                },
+                                "content": {
+                                    "type": "string",
+                                },
+                                "mime_type": {
+                                    "type": "string",
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        "required": ["message_info", "content"],
+    },
+}
+
+
+class {{CAMEL_CASE_NAME}}Output({{CAMEL_CASE_NAME}}Base):
+    def __init__(self, **kwargs):
+        super().__init__(info, **kwargs)
+        log.debug("{{CAMEL_CASE_NAME}}Output initialized")
+
+    def stop_component(self):
+        log.debug("Stopping {{CAMEL_CASE_NAME}}Output Component")
+
+    def invoke(self, message:Message, data:dict):
+        log.debug("{{CAMEL_CASE_NAME}}Output invoked, %s", data)
+

solace_agent_mesh/templates/plugin-pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.metadata]
+allow-direct-references = true
+
+[project]
+name = "{{name}}"
+dynamic = ["version"]
+authors = [
+  { name="{{author}}", email="" },
+]
+description = "{{description}}"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = []
+
+[tool.hatch.build.targets.wheel.force-include]
+"src" = "{{snake_name}}/src"
+"interfaces" = "{{snake_name}}/interfaces"
+"configs" = "{{snake_name}}/configs"
+"solace-agent-mesh-plugin.yaml" = "{{snake_name}}/solace-agent-mesh-plugin.yaml"
+
+[tool.hatch.build.targets.wheel]
+packages = ["{{snake_name}}"]
+
+[tool.hatch.version]
+path = "src/__init__.py"
+