solace-agent-mesh 1.11.2__py3-none-any.whl

solace_agent_mesh/templates/plugin_tools_template.py

@@ -0,0 +1,224 @@
+import logging
+import asyncio
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional
+
+from google.adk.tools import ToolContext
+from solace_agent_mesh.agent.utils.artifact_helpers import (
+    save_artifact_with_metadata,
+    DEFAULT_SCHEMA_MAX_KEYS,
+)
+from solace_agent_mesh.agent.utils.context_helpers import get_original_session_id
+
+log = logging.getLogger(__name__)
+
+async def example_text_processor_tool(
+    text_input: str,
+    uppercase: bool = False,  # Example of a boolean parameter
+    tool_context: Optional[ToolContext] = None,
+    tool_config: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+    """
+    An example tool that processes input text, optionally converts it to uppercase,
+    and adds a prefix from tool_config.
+    """
+    plugin_name = "__PLUGIN_SPACED_NAME__"
+    log_identifier = f"[{plugin_name}:example_text_processor_tool]"
+    log.info(f"{log_identifier} Received text: '{text_input}', uppercase: {uppercase}")
+
+    current_tool_config = tool_config if tool_config is not None else {}
+    prefix = current_tool_config.get("prefix", "Processed: ")
+
+    processed_text = text_input
+    if uppercase:
+        processed_text = processed_text.upper()
+
+    final_text = f"{prefix}{processed_text}"
+
+    log.info(f"{log_identifier} Processed text: '{final_text}'")
+    return {
+        "status": "success",
+        "message": "Text processed successfully by example_text_processor_tool.",
+        "original_input": text_input,
+        "processed_text": final_text,
+        "was_uppercased": uppercase,
+    }
+
+
+async def example_text_file_creator_tool(
+    filename: str,
+    content: str,
+    tool_context: Optional[ToolContext] = None,
+    tool_config: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+    """
+    An example tool that creates a text file and saves it as an artifact
+    using the Solace Agent Mesh artifact service.
+    """
+    plugin_name = "__PLUGIN_SPACED_NAME__"
+    log_identifier = f"[{plugin_name}:example_text_file_creator_tool]"
+    log.info(
+        f"{log_identifier} Received request to create file: '{filename}' with content starting: '{content[:50]}...'"
+    )
+
+    if not tool_context or not tool_context._invocation_context:
+        log.error(
+            f"{log_identifier} ToolContext or InvocationContext is missing. Cannot save artifact."
+        )
+        return {
+            "status": "error",
+            "message": "ToolContext or InvocationContext is missing.",
+        }
+
+    inv_context = tool_context._invocation_context
+    app_name = getattr(inv_context, "app_name", None)
+    user_id = getattr(inv_context, "user_id", None)
+    session_id = get_original_session_id(inv_context)
+    artifact_service = getattr(inv_context, "artifact_service", None)
+
+    if not all([app_name, user_id, session_id, artifact_service]):
+        missing_parts = [
+            part
+            for part, val in [
+                ("app_name", app_name),
+                ("user_id", user_id),
+                ("session_id", session_id),
+                ("artifact_service", artifact_service),
+            ]
+            if not val
+        ]
+        log.error(
+            f"{log_identifier} Missing required context parts for artifact saving: {', '.join(missing_parts)}"
+        )
+        return {
+            "status": "error",
+            "message": f"Missing required context parts for artifact saving: {', '.join(missing_parts)}",
+        }
+
+    output_filename = filename
+    if not output_filename.lower().endswith(".txt"):
+        output_filename += ".txt"
+
+    content_bytes = content.encode("utf-8")
+    mime_type = "text/plain"
+    timestamp = datetime.now(timezone.utc)
+
+    metadata_dict = {
+        "description": f"Text file created by {plugin_name}'s example_text_file_creator_tool.",
+        "source_tool": "example_text_file_creator_tool",
+        "original_requested_filename": filename,
+        "creation_timestamp_iso": timestamp.isoformat(),
+        "content_character_count": len(content),
+    }
+
+    log.info(
+        f"{log_identifier} Attempting to save artifact '{output_filename}' via artifact_service."
+    )
+    try:
+        save_result = await save_artifact_with_metadata(
+            artifact_service=artifact_service,
+            app_name=app_name,
+            user_id=user_id,
+            session_id=session_id,
+            filename=output_filename,
+            content_bytes=content_bytes,
+            mime_type=mime_type,
+            metadata_dict=metadata_dict,
+            timestamp=timestamp,
+            schema_max_keys=DEFAULT_SCHEMA_MAX_KEYS,
+            tool_context=tool_context,
+        )
+        if save_result.get("status") == "error":
+            log.error(
+                f"{log_identifier} Failed to save artifact: {save_result.get('message')}"
+            )
+            return {
+                "status": "error",
+                "message": f"Failed to save artifact: {save_result.get('message')}",
+            }
+
+        log.info(
+            f"{log_identifier} Artifact '{output_filename}' v{save_result['data_version']} saved successfully."
+        )
+        return {
+            "status": "success",
+            "message": f"File '{output_filename}' created and saved as artifact v{save_result['data_version']}.",
+            "output_filename": output_filename,
+            "output_version": save_result["data_version"],
+        }
+    except Exception as e:
+        log.exception(f"{log_identifier} Unexpected error during artifact saving: {e}")
+        return {
+            "status": "error",
+            "message": f"An unexpected error occurred during artifact saving: {e}",
+        }
+
+
+# Example of how these might be tested or run if this file was executed directly.
+# This assumes the script is run in an environment where solace_agent_mesh is importable,
+# or the imports at the top will fail.
+if __name__ == "__main__":
+
+    async def run_tests():
+        print("--- Testing example_text_processor_tool ---")
+        # For standalone testing, ToolContext might be minimal or None if ADK is not fully available.
+        # The tool should handle tool_context=None gracefully if it's designed to be testable standalone.
+
+        # A more complete mock for standalone testing if needed:
+        class MockArtifactService:
+            async def save_artifact(
+                self, **kwargs
+            ):  # Match expected signature elements
+                log.info(
+                    f"MockArtifactService.save_artifact called with filename: {kwargs.get('filename')}"
+                )
+                return {
+                    "uri": f"mock://{kwargs.get('filename')}",
+                    "version": 1,
+                }  # Simulate ADK response
+
+            async def save_artifact_metadata(self, **kwargs):
+                log.info(
+                    f"MockArtifactService.save_artifact_metadata called for: {kwargs.get('filename')}"
+                )
+                return {
+                    "uri": f"mock://{kwargs.get('filename')}.metadata",
+                    "version": 1,
+                }
+
+        class MockInvocationContext:
+            def __init__(self):
+                self.app_name = "test_app"
+                self.user_id = "test_user"
+                self.session_id = "test_session_123"
+                self.artifact_service = MockArtifactService()
+                # Add other attributes if your tool or helpers expect them
+
+        class MockToolContext:
+            def __init__(self):
+                self._invocation_context = MockInvocationContext()
+
+        mock_context = MockToolContext()
+
+        text_result1 = await example_text_processor_tool(
+            "hello world",
+            uppercase=True,
+            tool_context=mock_context,
+            tool_config={"prefix": "TestPrefix: "},
+        )
+        print(f"Text tool result 1: {text_result1}")
+
+        text_result2 = await example_text_processor_tool(
+            "another test", tool_context=mock_context
+        )
+        print(f"Text tool result 2: {text_result2}")
+
+        print("\n--- Testing example_text_file_creator_tool ---")
+        file_result = await example_text_file_creator_tool(
+            "my_example_file.txt",
+            "This is the content of the example file created by the plugin template.",
+            tool_context=mock_context,  # Using the mock context with a mock artifact service
+        )
+        print(f"File tool result: {file_result}")
+
+    asyncio.run(run_tests())

solace_agent_mesh/templates/shared_config.yaml

@@ -0,0 +1,112 @@
+shared_config:
+  - broker_connection: &broker_connection
+      dev_mode: ${SOLACE_DEV_MODE, false}
+      broker_url: ${SOLACE_BROKER_URL, ws://localhost:8008}
+      broker_username: ${SOLACE_BROKER_USERNAME, default}
+      broker_password: ${SOLACE_BROKER_PASSWORD, default}
+      broker_vpn: ${SOLACE_BROKER_VPN, default}
+      temporary_queue: ${USE_TEMPORARY_QUEUES, true}
+      
+
+  - models:
+    planning: &planning_model
+      # This dictionary structure tells ADK to use the LiteLlm wrapper.
+      # 'model' uses the specific model identifier your endpoint expects.
+      model: ${LLM_SERVICE_PLANNING_MODEL_NAME} # Use env var for model name
+      # 'api_base' tells LiteLLM where to send the request.
+      api_base: ${LLM_SERVICE_ENDPOINT} # Use env var for endpoint URL
+      # 'api_key' provides authentication.
+      api_key: ${LLM_SERVICE_API_KEY} # Use env var for API key
+      # Enable parallel tool calls for planning model
+      parallel_tool_calls: true 
+      # Prompt Caching Strategy
+      cache_strategy: "5m" # none, 5m, 1h
+
+      # max_tokens: ${MAX_TOKENS, 16000} # Set a reasonable max token limit for planning
+      # temperature: 0.1 # Lower temperature for more deterministic planning
+      
+
+    general: &general_model
+      # This dictionary structure tells ADK to use the LiteLlm wrapper.
+      # 'model' uses the specific model identifier your endpoint expects.
+      model: ${LLM_SERVICE_GENERAL_MODEL_NAME} # Use env var for model name
+      # 'api_base' tells LiteLLM where to send the request.
+      api_base: ${LLM_SERVICE_ENDPOINT} # Use env var for endpoint URL
+      # 'api_key' provides authentication.
+      api_key: ${LLM_SERVICE_API_KEY} # Use env var for API key
+      # Prompt Caching Strategy
+      cache_strategy: "5m" # none, 5m, 1h
+
+    image_gen: &image_generation_model
+      # This dictionary structure tells ADK to use the LiteLlm wrapper.
+      # 'model' uses the specific model identifier your endpoint expects.
+      model: ${IMAGE_MODEL_NAME} # Use env var for model name
+      # 'api_base' tells LiteLLM where to send the request.
+      api_base: ${IMAGE_SERVICE_ENDPOINT} # Use env var for endpoint URL
+      # 'api_key' provides authentication.
+      api_key: ${IMAGE_SERVICE_API_KEY} # Use env var for API key
+
+    report_gen: &report_generation_model
+      # This dictionary structure tells ADK to use the LiteLlm wrapper.
+      # 'model' uses the specific model identifier your endpoint expects.
+      model: ${LLM_REPORT_MODEL_NAME} # Use env var for model name
+      # 'api_base' tells LiteLLM where to send the request.
+      api_base: ${LLM_SERVICE_ENDPOINT} # Use env var for endpoint URL
+      # 'api_key' provides authentication.
+      api_key: ${LLM_SERVICE_API_KEY} # Use env var for API key
+
+    multimodal: &multimodal_model  "gemini-2.5-flash-preview-04-17"
+
+    # OAuth 2.0 Client Credentials authentication example
+    oauth_planning: &oauth_planning_model
+      # This dictionary structure tells ADK to use the LiteLlm wrapper with OAuth authentication.
+      # 'model' uses the specific model identifier your endpoint expects.
+      model: ${LLM_SERVICE_OAUTH_PLANNING_MODEL_NAME} # Use env var for model name
+      # 'api_base' tells LiteLLM where to send the request.
+      api_base: ${LLM_SERVICE_OAUTH_ENDPOINT} # Use env var for endpoint URL
+
+      # OAuth 2.0 Client Credentials configuration
+      oauth_token_url: ${LLM_SERVICE_OAUTH_TOKEN_URL} # OAuth token endpoint URL
+      oauth_client_id: ${LLM_SERVICE_OAUTH_CLIENT_ID} # OAuth client identifier
+      oauth_client_secret: ${LLM_SERVICE_OAUTH_CLIENT_SECRET} # OAuth client secret
+      oauth_scope: ${LLM_SERVICE_OAUTH_SCOPE} # Optional: OAuth scope (space-separated)
+      # oauth_ca_cert: ${LLM_SERVICE_OAUTH_CA_CERT_PATH} # Optional: Custom CA certificate path
+      oauth_token_refresh_buffer_seconds: ${LLM_SERVICE_OAUTH_TOKEN_REFRESH_BUFFER_SECONDS, 300} # Refresh buffer
+
+      # Enable parallel tool calls for planning model
+      parallel_tool_calls: true
+      # max_tokens: ${MAX_TOKENS, 16000} # Set a reasonable max token limit for planning
+      # temperature: 0.1 # Lower temperature for more deterministic planning
+
+    oauth_general: &oauth_general_model
+      # This dictionary structure tells ADK to use the LiteLlm wrapper with OAuth authentication.
+      # 'model' uses the specific model identifier your endpoint expects.
+      model: ${LLM_SERVICE_OAUTH_GENERAL_MODEL_NAME} # Use env var for model name
+      # 'api_base' tells LiteLLM where to send the request.
+      api_base: ${LLM_SERVICE_OAUTH_ENDPOINT} # Use env var for endpoint URL
+
+      # OAuth 2.0 Client Credentials configuration
+      oauth_token_url: ${LLM_SERVICE_OAUTH_TOKEN_URL} # OAuth token endpoint URL
+      oauth_client_id: ${LLM_SERVICE_OAUTH_CLIENT_ID} # OAuth client identifier
+      oauth_client_secret: ${LLM_SERVICE_OAUTH_CLIENT_SECRET} # OAuth client secret
+      oauth_scope: ${LLM_SERVICE_OAUTH_SCOPE} # Optional: OAuth scope (space-separated)
+      # oauth_ca_cert: ${LLM_SERVICE_OAUTH_CA_CERT_PATH} # Optional: Custom CA certificate path
+      oauth_token_refresh_buffer_seconds: ${LLM_SERVICE_OAUTH_TOKEN_REFRESH_BUFFER_SECONDS, 300} # Refresh buffer
+
+  - services:
+    # Default session service configuration
+    session_service: &default_session_service
+      type: "memory"
+      default_behavior: "PERSISTENT"
+    
+    # Default artifact service configuration
+    artifact_service: &default_artifact_service
+      type: "__DEFAULT_ARTIFACT_SERVICE_TYPE__"
+      # __DEFAULT_ARTIFACT_SERVICE_BASE_PATH_LINE__
+      artifact_scope: __DEFAULT_ARTIFACT_SERVICE_SCOPE__
+    
+    # Default data tools configuration
+    data_tools_config: &default_data_tools_config
+      sqlite_memory_threshold_mb: 100
+      max_result_preview_rows: 50
+      max_result_preview_bytes: 4096

solace_agent_mesh/templates/templates_llm.txt

@@ -0,0 +1,147 @@
+Here is the DEVELOPER GUIDE for the `templates` directory.
+
+## Quick Summary
+
+The `templates` directory contains boilerplate files for creating various components within the Solace Agent Mesh (SAM) ecosystem. These templates are used by the `sam` command-line interface (CLI) and developers to bootstrap new agents, gateways, and plugins. They provide a standardized starting point, ensuring new components adhere to the required structure and include necessary configurations.
+
+## Files Overview
+
+*   `agent_template.yaml`: A template for a standard agent configuration file.
+*   `eval_backend_template.yaml`: Configuration template for the A2A Evaluation Backend service.
+*   `gateway_app_template.py`: Python template for a custom gateway's main `App` class, which handles configuration.
+*   `gateway_component_template.py`: Python template for a custom gateway's `Component` class, which implements the core logic.
+*   `gateway_config_template.yaml`: YAML configuration template for a custom gateway.
+*   `main_orchestrator.yaml`: Configuration template for the primary Orchestrator agent.
+*   `plugin_agent_config_template.yaml`: Template for an agent configuration generated from a plugin.
+*   `plugin_custom_config_template.yaml`: Template for a custom configuration file generated from a plugin.
+*   `plugin_custom_template.py`: Python template for a custom class within a plugin.
+*   `plugin_gateway_config_template.yaml`: Template for a gateway configuration generated from a plugin.
+*   `plugin_pyproject_template.toml`: Template for a plugin's `pyproject.toml` file, defining its packaging and dependencies.
+*   `plugin_readme_template.md`: Template for a plugin's `README.md` file.
+*   `plugin_tools_template.py`: Python template demonstrating how to create custom tools for a plugin.
+*   `shared_config.yaml`: A template for shared configuration settings (e.g., broker, models, services) used across multiple components.
+*   `webui.yaml`: Configuration template for the WebUI Gateway.
+
+## Developer API Reference
+
+### agent_template.yaml
+
+**Purpose:** A generic template for creating a new agent configuration. It includes placeholders that are typically filled in by a developer or a script to define a new agent's behavior, model, tools, and communication settings.
+
+**Key Placeholders:**
+*   `__AGENT_NAME__`: The unique name of the agent.
+*   `__NAMESPACE__`: The namespace the agent operates in.
+*   `__SUPPORTS_STREAMING__`: `true` or `false` to indicate if the agent supports streaming responses.
+*   `__MODEL_ALIAS__`: The alias of the language model to use (e.g., `*planning_model`).
+*   `__INSTRUCTION__`: The system prompt or instruction for the agent.
+*   `__TOOLS_CONFIG__`: A YAML list defining the tools available to the agent.
+*   `__SESSION_SERVICE__`, `__ARTIFACT_SERVICE__`: Configuration for session and artifact services.
+*   `__AGENT_CARD_...__`: Fields defining the agent's metadata for discovery.
+*   `__INTER_AGENT_COMMUNICATION_...__`: Rules for how this agent can communicate with other agents.
+
+---
+### eval_backend_template.yaml
+
+**Purpose:** A configuration template for the evaluation backend, a specialized REST gateway used for testing and evaluation purposes. It defines the broker connection, API settings, and system prompts.
+
+**Key Configuration:**
+*   `app_module`: Set to `solace_agent_mesh.gateway.rest.app` to use the standard REST gateway implementation.
+*   `namespace`: The operational namespace, often set via an environment variable `${NAMESPACE}`.
+*   `fastapi_host`, `fastapi_port`: The host and port for the backend's REST API.
+*   `cors_allowed_origins`: A list of origins allowed to make cross-origin requests to the API.
+*   `system_purpose`, `response_format`: Default prompts for the gateway.
+
+---
+### gateway_app_template.py
+
+**Purpose:** This template defines the main application class for a custom gateway. Its primary role is to extend `BaseGatewayApp` and define the gateway-specific configuration schema.
+
+**Import:** `from my_gateway.app import MyGatewayApp` (where `__GATEWAY_NAME_PASCAL_CASE__` is replaced, e.g., `MyGatewayApp`)
+
+**Classes:**
+- `__GATEWAY_NAME_PASCAL_CASE__GatewayApp(BaseGatewayApp)` - The main app class for the custom gateway.
+  - `SPECIFIC_APP_SCHEMA_PARAMS: List[Dict[str, Any]]` - A class attribute where you define the custom configuration parameters for your gateway. Each dictionary in the list defines a parameter's name, type, requirement, and description.
+  - `_get_gateway_component_class() -> Type[BaseGatewayComponent]` - An abstract method that must be implemented to return the type of your custom gateway component class.
+
+**Usage Examples:**
+```python
+# In your gateway's app.py (e.g., src/my_slack_gateway/app.py)
+
+from typing import Any, Dict, List, Type
+
+from solace_agent_mesh.gateway.base.app import BaseGatewayApp
+from solace_agent_mesh.gateway.base.component import BaseGatewayComponent
+
+# Import your component class
+from .component import MySlackGatewayComponent
+
+class MySlackGatewayApp(BaseGatewayApp):
+    """
+    App class for the My Slack Gateway.
+    """
+
+    # Define custom configuration parameters that will be available
+    # in the gateway's YAML config file.
+    SPECIFIC_APP_SCHEMA_PARAMS: List[Dict[str, Any]] = [
+        {
+            "name": "slack_bot_token",
+            "required": True,
+            "type": "string",
+            "description": "The Slack Bot User OAuth Token (starts with xoxb-).",
+        },
+        {
+            "name": "slack_app_token",
+            "required": True,
+            "type": "string",
+            "description": "The Slack App-Level Token for Socket Mode (starts with xapp-).",
+        },
+        {
+            "name": "default_target_agent",
+            "required": False,
+            "type": "string",
+            "default": "OrchestratorAgent",
+            "description": "The default agent to send messages to.",
+        },
+    ]
+
+    def _get_gateway_component_class(self) -> Type[BaseGatewayComponent]:
+        """
+        Returns the specific gateway component class for this app.
+        """
+        return MySlackGatewayComponent
+```
+
+---
+### gateway_component_template.py
+
+**Purpose:** This template implements the core logic of a custom gateway. It handles the lifecycle of the gateway, communication with the external system, and translation between the external system's data format and the A2A (Agent-to-Agent) protocol.
+
+**Import:** `from my_gateway.component import MyGatewayComponent` (where `__GATEWAY_NAME_PASCAL_CASE__` is replaced)
+
+**Classes:**
+- `__GATEWAY_NAME_PASCAL_CASE__GatewayComponent(BaseGatewayComponent)` - The main component class implementing the gateway's logic.
+  - `_start_listener() -> None` - **GDK Hook:** Implement this to start listening for events from the external system (e.g., start a polling loop, connect a client). Called by the framework.
+  - `_stop_listener() -> None` - **GDK Hook:** Implement this to stop listening and clean up connections to the external system. Called by the framework.
+  - `_authenticate_external_user(external_event_data: Any) -> Optional[str]` - **GDK Hook:** Implement this to authenticate an incoming request from the external system. Return a unique user ID string on success, `None` on failure.
+  - `_translate_external_input(external_event_data: Any, authenticated_user_identity: str) -> Tuple[Optional[str], List[A2APart], Dict[str, Any]]` - **GDK Hook:** Implement this to convert an event from the external system into an A2A task. Returns the target agent name, a list of A2A parts (Text, File, etc.), and a context dictionary to be used for sending the response back.
+  - `_send_final_response_to_external(external_request_context: Dict[str, Any], task_data: Task) -> None` - **GDK Hook:** Implement this to send the final result of an A2A task back to the external system.
+  - `_send_error_to_external(external_request_context: Dict[str, Any], error_data: JSONRPCError) -> None` - **GDK Hook:** Implement this to send an error notification back to the external system.
+  - `_send_update_to_external(external_request_context: Dict[str, Any], event_data: Union[TaskStatusUpdateEvent, TaskArtifactUpdateEvent], is_final_chunk_of_update: bool) -> None` - **GDK Hook:** (Optional) Implement this to handle streaming intermediate updates (e.g., "Agent is thinking...") back to the external system.
+  - `cleanup() -> None` - **GDK Hook:** Perform any final cleanup before the component is destroyed. Always call `super().cleanup()`.
+
+**Usage Examples:**
+```python
+# In your gateway's component.py (e.g., src/my_slack_gateway/component.py)
+# This is a conceptual example of the implementation flow.
+
+from typing import Any, Dict, List, Optional, Tuple
+from solace_agent_mesh.gateway.base.component import BaseGatewayComponent
+from solace_agent_mesh.common.types import Part as A2APart, TextPart, Task
+
+class MySlackGatewayComponent(BaseGatewayComponent):
+    def __init__(self, **kwargs: Any):
+        super().__init__(**kwargs)
+        # Retrieve config defined in the App class
+        self.slack_token = self.get_config("slack_bot_token")
+        self.default_agent = self.get_config("default_target_agent")
+        # self.slack_client = SlackClient(token=self.slack_token)

solace_agent_mesh/templates/webui.yaml

@@ -0,0 +1,177 @@
+
+
+log:
+  stdout_log_level: INFO
+  log_file_level: DEBUG
+  log_file: webui_app.log
+
+
+!include ../shared_config.yaml
+
+apps:
+  - name: a2a_webui_app
+    app_base_path: .
+    app_module: solace_agent_mesh.gateway.http_sse.app
+
+    broker:
+      <<: *broker_connection
+
+    app_config:
+      namespace: ${NAMESPACE}
+      session_secret_key: "${SESSION_SECRET_KEY}"
+
+      model: *general_model
+      artifact_service: *default_artifact_service
+      session_service: __SESSION_SERVICE__
+      gateway_id: ${WEBUI_GATEWAY_ID}
+      fastapi_host: ${FASTAPI_HOST}
+      fastapi_port: ${FASTAPI_PORT}
+      cors_allowed_origins: 
+        - "http://localhost:3000" 
+        - "http://127.0.0.1:3000"
+
+      enable_embed_resolution: ${ENABLE_EMBED_RESOLUTION} # Enable late-stage resolution
+      gateway_artifact_content_limit_bytes: ${GATEWAY_ARTIFACT_LIMIT_BYTES, 10000000} # Max size for late-stage embeds
+      sse_max_queue_size: ${SSE_MAX_QUEUE_SIZE, 200} # Max size of SSE connection queues
+
+      system_purpose: >
+            The system is an AI Chatbot with agentic capabilities.
+            It will use the agents available to provide information,
+            reasoning and general assistance for the users in this system.
+            **Always return useful artifacts and files that you create to the user.**
+            Provide a status update before each tool call.
+            Your external name is Agent Mesh.
+
+      response_format: >
+            Responses should be clear, concise, and professionally toned.
+            Format responses to the user in Markdown using appropriate formatting.
+
+      # --- Frontend Config Passthrough ---
+      frontend_welcome_message: __FRONTEND_WELCOME_MESSAGE__
+      frontend_bot_name: __FRONTEND_BOT_NAME__
+      frontend_collect_feedback: __FRONTEND_COLLECT_FEEDBACK__
+      frontend_logo_url: __FRONTEND_LOGO_URL__
+      
+      # --- Frontend Feature Flags ---
+      # Uncomment to control speech features in the UI
+      frontend_feature_enablement:
+      #   speechToText: true   # Set to false to hide Speech-to-Text settings & microphone
+      #   textToSpeech: true   # Set to false to hide Text-to-Speech settings & speaker button
+      #   projects: true
+      #   promptLibrary: true
+        background_tasks: true  # Enable background task execution
+
+      # --- Background Tasks Configuration ---
+      background_tasks:
+        default_timeout_ms: 3600000  # Default: 1 hour (3600000ms)
+
+      # --- Speech Configuration (STT/TTS) ---
+      speech:
+        # stt:
+        #   provider: openai
+        #   url: "https://api.openai.com/v1/audio/transcriptions"
+        #   api_key: "${OPENAI_API_KEY}"
+        #   model: "whisper-1"
+        stt:
+          provider: azure
+          azure:
+            api_key: "${AZURE_SPEECH_KEY}"
+            region: "${AZURE_SPEECH_REGION}"
+            language: en-US
+        
+        # Text-to-Speech Configuration
+        tts:
+          provider: ${TTS_PROVIDER, gemini}  # "gemini", "azure", or "polly" (can be overridden by UI)
+          
+          # Azure Neural Voices Configuration
+          azure:
+            api_key: "${AZURE_SPEECH_KEY}"
+            region: "${AZURE_SPEECH_REGION}"
+            default_voice: "en-US-Andrew:DragonHDLatestNeural"
+            voices:
+              # DragonHD Latest Neural Voices (Highest Quality)
+              - "en-US-Ava:DragonHDLatestNeural"
+              - "en-US-Ava3:DragonHDLatestNeural"
+              - "en-US-Adam:DragonHDLatestNeural"
+              - "en-US-Alloy:DragonHDLatestNeural"
+              - "en-US-Andrew:DragonHDLatestNeural"
+              - "en-US-Andrew2:DragonHDLatestNeural"
+              - "en-US-Andrew3:DragonHDLatestNeural"
+              - "en-US-Aria:DragonHDLatestNeural"
+              - "en-US-Brian:DragonHDLatestNeural"
+              - "en-US-Davis:DragonHDLatestNeural"
+              - "en-US-Emma:DragonHDLatestNeural"
+              - "en-US-Emma2:DragonHDLatestNeural"
+              - "en-US-Jenny:DragonHDLatestNeural"
+              - "en-US-MultiTalker-Ava-Andrew:DragonHDLatestNeural"
+              - "en-US-Nova:DragonHDLatestNeural"
+              - "en-US-Phoebe:DragonHDLatestNeural"
+              - "en-US-Serena:DragonHDLatestNeural"
+              - "en-US-Steffan:DragonHDLatestNeural"
+              # Standard Neural Voices
+              - "en-US-JennyNeural"
+              - "en-US-GuyNeural"
+              - "en-US-AriaNeural"
+              - "en-US-DavisNeural"
+              - "en-US-JaneNeural"
+              - "en-US-JasonNeural"
+              - "en-US-NancyNeural"
+              - "en-US-TonyNeural"
+              - "en-GB-LibbyNeural"
+              - "en-GB-RyanNeural"
+              - "en-GB-SoniaNeural"
+              - "en-AU-NatashaNeural"
+              - "en-AU-WilliamNeural"
+          
+          # Google Gemini Configuration
+          gemini:
+            api_key: "${GEMINI_API_KEY}"
+            model: "gemini-2.5-flash-preview-tts"
+            default_voice: "Kore"
+            language: "en-US"
+            voices:
+            - "Kore"
+            - "Puck"
+            - "Zephyr"
+            - "Charon"
+            - "Fenrir"
+            - "Leda"
+            - "Aoede"
+            - "Callirhoe"
+            - "Umbriel"
+            - "Enceladus"
+            - "Iapetus"
+            - "Erinome"
+            - "Algieba"
+            - "Despina"
+            - "Algenib"
+            - "Achernar"
+            - "Schedar"
+            - "Gacrux"
+            - "Pulcherrima"
+            - "Achird"
+            - "Zubenelgenubi"
+            - "Vindemiatrix"
+            - "Sadachbia"
+            - "Sadaltager"
+            - "Sulafat"
+            - "Autonoe"
+            - "Laomedeia"
+            - "Orus"
+            - "Rasalgethi"
+            - "Alnilam"
+        
+        # Frontend Speech Tab Default Settings (optional)
+        speechTab:
+          advancedMode: false
+          speechToText:
+            speechToText: true
+            engineSTT: "external"  # Use external for better quality
+            languageSTT: "en-US"
+          textToSpeech:
+            textToSpeech: true
+            engineTTS: "external"  # Use external for better quality
+            voice: "Kore"
+            playbackRate: 1.0
+            cacheTTS: true
+