solace-agent-mesh 1.6.1__py3-none-any.whl → 1.13.2__py3-none-any.whl

solace_agent_mesh/gateway/http_sse/shared/shared_llm.txt

@@ -1,285 +0,0 @@
-# DEVELOPER GUIDE: shared
-
-## Quick Summary
-The `shared` directory contains common utilities, constants, enums, types, and exception handling used across all layers of the HTTP SSE gateway. It provides authentication helpers, timestamp utilities, standardized exception handling, database utilities, pagination support, and response formatting for consistent API behavior.
-
-## Files Overview
-- `__init__.py` - Central exports for all shared utilities and components
-- `auth_utils.py` - Authentication utilities for FastAPI applications
-- `timestamp_utils.py` - Epoch timestamp utilities matching Java backend patterns
-- `exceptions.py` - Generic web exceptions for HTTP/REST APIs
-- `error_dto.py` - Standardized error response DTOs
-- `exception_handlers.py` - FastAPI exception handlers for consistent HTTP error responses
-- `base_repository.py` - Base repository classes with proper transaction management
-- `pagination.py` - Pagination utilities for API responses
-- `database_exceptions.py` - Database exception handling and conversion
-- `database_helpers.py` - Database utility functions and custom types
-- `response_utils.py` - Standardized response formatting utilities
-- `enums.py` - Enumerations for message types, task status, and validation errors
-- `types.py` - Custom types and type aliases for better type safety
-- `utils.py` - Generic utility functions
-
-## Developer API Reference
-
-### auth_utils.py
-**Purpose:** Provides authentication utilities for FastAPI controllers
-**Import:** `from solace_agent_mesh.gateway.http_sse.shared import get_current_user`
-
-**Functions:**
-- `get_current_user(request: FastAPIRequest) -> dict` - Extracts authenticated user from request state, returns user info or anonymous default
-
-**Usage Examples:**
-```python
-from fastapi import Depends
-from solace_agent_mesh.gateway.http_sse.shared import get_current_user
-
-@app.get("/protected")
-async def protected_endpoint(user: dict = Depends(get_current_user)):
-    return {"user_id": user["id"], "name": user["name"]}
-```
-
-### timestamp_utils.py
-**Purpose:** Provides epoch timestamp utilities for database portability and timezone handling
-**Import:** `from solace_agent_mesh.gateway.http_sse.shared import now_epoch_ms, epoch_ms_to_iso8601, iso8601_to_epoch_ms`
-
-**Functions:**
-- `now_epoch_ms() -> int` - Get current time as milliseconds since epoch
-- `epoch_ms_to_iso8601(epoch_ms: int) -> str` - Convert epoch milliseconds to ISO 8601 string
-- `iso8601_to_epoch_ms(iso8601_string: str) -> int` - Convert ISO 8601 string to epoch milliseconds
-- `datetime_to_epoch_ms(dt: datetime) -> int` - Convert datetime object to epoch milliseconds
-- `epoch_ms_to_datetime(epoch_ms: int) -> datetime` - Convert epoch milliseconds to datetime object
-- `validate_epoch_ms(epoch_ms: int | None) -> bool` - Validate that an epoch milliseconds value is reasonable
-
-**Usage Examples:**
-```python
-from solace_agent_mesh.gateway.http_sse.shared import (
-    now_epoch_ms, epoch_ms_to_iso8601, iso8601_to_epoch_ms
-)
-
-# Get current timestamp for database storage
-created_time = now_epoch_ms()
-
-# Convert for API response
-iso_string = epoch_ms_to_iso8601(created_time)
-
-# Parse from API request
-timestamp = iso8601_to_epoch_ms("2024-01-01T00:00:00Z")
-```
-
-### exceptions.py
-**Purpose:** Generic web exceptions for HTTP/REST APIs
-**Import:** `from solace_agent_mesh.gateway.http_sse.shared import ValidationError, EntityNotFoundError, EntityAlreadyExistsError`
-
-**Classes:**
-- `WebUIBackendException(message: str, details: Optional[Dict[str, Any]] = None)` - Base exception for all web UI backend errors
-- `ValidationError(message: str, validation_details: Optional[Dict[str, List[str]]] = None, entity_type: Optional[str] = None, entity_identifier: Optional[str] = None)` - Exception for validation errors with field-level details
-- `EntityNotFoundError(entity_type: str, entity_id: str)` - Generic exception for when an entity is not found
-- `EntityAlreadyExistsError(entity_type: str, identifier: str, value: Any = None)` - Exception for when an entity already exists
-- `BusinessRuleViolationError(rule: str, message: str)` - Exception for business rule violations
-- `ConfigurationError(component: str, message: str)` - Exception for configuration-related errors
-- `DataIntegrityError(constraint: str, message: str)` - Exception for data integrity violations
-- `ExternalServiceError(service: str, message: str, status_code: Optional[int] = None)` - Exception for external service communication errors
-- `ValidationErrorBuilder()` - Builder for constructing ValidationError instances with fluent API
-
-**Usage Examples:**
-```python
-from solace_agent_mesh.gateway.http_sse.shared import (
-    ValidationError, EntityNotFoundError, ValidationErrorBuilder
-)
-
-# Simple validation error
-raise ValidationError("Invalid input data")
-
-# Entity not found
-raise EntityNotFoundError("User", "123")
-
-# Complex validation with builder
-error = ValidationError.builder() \
-    .message("Invalid user data") \
-    .validation_detail("email", ["Invalid email format"]) \
-    .entity_type("User") \
-    .build()
-```
-
-### error_dto.py
-**Purpose:** Standardized error response DTOs for HTTP APIs
-**Import:** `from solace_agent_mesh.gateway.http_sse.shared import EventErrorDTO`
-
-**Classes:**
-- `EventErrorDTO(message: str, validationDetails: Optional[Dict[str, List[str]]] = None)` - Simplified and standardized error response format
-  - `create(message: str, validation_details: Optional[Dict[str, List[str]]] = None) -> EventErrorDTO` - Create a new EventErrorDTO
-  - `not_found(entity_type: str, entity_id: str) -> EventErrorDTO` - Create a 404 Not Found error
-  - `validation_error(message: str, validation_details: Dict[str, List[str]]) -> EventErrorDTO` - Create a validation error
-
-**Usage Examples:**
-```python
-from solace_agent_mesh.gateway.http_sse.shared import EventErrorDTO
-
-# Simple error
-error = EventErrorDTO.create("Something went wrong")
-
-# Not found error
-error = EventErrorDTO.not_found("User", "123")
-
-# Validation error
-error = EventErrorDTO.validation_error(
-    "Invalid data",
-    {"email": ["Invalid format"], "age": ["Must be positive"]}
-)
-```
-
-### exception_handlers.py
-**Purpose:** FastAPI exception handlers for consistent HTTP error responses
-**Import:** `from solace_agent_mesh.gateway.http_sse.shared import register_exception_handlers`
-
-**Functions:**
-- `register_exception_handlers(app)` - Register all exception handlers with a FastAPI app
-- `create_error_response(status_code: int, message: str, validation_details: dict = None) -> JSONResponse` - Create standardized error response
-
-**Usage Examples:**
-```python
-from fastapi import FastAPI
-from solace_agent_mesh.gateway.http_sse.shared import register_exception_handlers
-
-app = FastAPI()
-register_exception_handlers(app)
-```
-
-### base_repository.py
-**Purpose:** Base repository classes with proper transaction management
-**Import:** `from solace_agent_mesh.gateway.http_sse.shared import BaseRepository, PaginatedRepository, ValidationMixin`
-
-**Classes:**
-- `BaseRepository(model_class: Type[ModelType], entity_class: Type[EntityType])` - Abstract base class for repositories
-  - `create(session: Session, create_data: Dict[str, Any]) -> EntityType` - Create a new entity
-  - `get_by_id(session: Session, entity_id: Any) -> EntityType` - Get entity by ID
-  - `get_all(session: Session, limit: Optional[int] = None, offset: Optional[int] = None) -> List[EntityType]` - Get all entities
-  - `update(session: Session, entity_id: Any, update_data: Dict[str, Any]) -> EntityType` - Update an entity
-  - `delete(session: Session, entity_id: Any) -> None` - Delete an entity
-- `PaginatedRepository(model_class: Type[ModelType], entity_class: Type[EntityType])` - Base repository with enhanced pagination support
-  - `get_paginated(session: Session, page_number: int, page_size: int) -> tuple[List[EntityType], int]` - Get paginated results
-- `ValidationMixin` - Mixin for repositories that need validation logic
-
-**Usage Examples:**
-```python
-from solace_agent_mesh.gateway.http_sse.shared import BaseRepository
-from sqlalchemy.orm import Session
-
-class UserRepository(BaseRepository[UserModel, UserEntity]):
-    @property
-    def entity_name(self) -> str:
-        return "User"
-
-# Usage
-repo = UserRepository(UserModel, UserEntity)
-user = repo.create(session, {"name": "John", "email": "john@example.com"})
-```
-
-### pagination.py
-**Purpose:** Pagination utilities for API responses
-**Import:** `from solace_agent_mesh.gateway.http_sse.shared import PaginationParams, PaginatedResponse, DataResponse`
-
-**Classes:**
-- `PaginationParams(page_number: int = 1, page_size: int = 20)` - Request parameters for pagination
-  - `offset: int` - Calculate the offset for database queries
-- `PaginatedResponse[T](data: list[T], meta: Meta)` - Generic paginated response with data and metadata
-  - `create(data: list[T], total_count: int, pagination: PaginationParams) -> PaginatedResponse[T]` - Create paginated response
-- `DataResponse[T](data: T)` - Simple data response wrapper
-  - `create(data: T) -> DataResponse[T]` - Create data response
-
-**Usage Examples:**
-```python
-from solace_agent_mesh.gateway.http_sse.shared import PaginationParams, PaginatedResponse
-
-# Create pagination params
-pagination = PaginationParams(page_number=1, page_size=20)
-
-# Create paginated response
-response = PaginatedResponse.create(users, total_count=100, pagination=pagination)
-```
-
-### response_utils.py
-**Purpose:** Standardized response formatting utilities
-**Import:** `from solace_agent_mesh.gateway.http_sse.shared import create_data_response, create_paginated_response, StandardResponseMixin`
-
-**Functions:**
-- `create_data_response(data: T) -> DataResponse[T]` - Create a standardized data response
-- `create_paginated_response(data: List[T], total_count: int, pagination_params: PaginationParams) -> PaginatedResponse[T]` - Create a standardized paginated response
-- `create_success_response(message: str = "Success") -> DataResponse[Dict[str, str]]` - Create a standardized success response
-- `create_list_response(items: List[T]) -> DataResponse[List[T]]` - Create a standardized list response
-
-**Classes:**
-- `StandardResponseMixin` - Mixin class to add standard response methods to services or controllers
-
-**Usage Examples:**
-```python
-from solace_agent_mesh.gateway.http_sse.shared import create_data_response, create_paginated_response
-
-# Simple data response
-response = create_data_response({"id": 1, "name": "test"})
-
-# Paginated response
-response = create_paginated_response(users, 100, pagination_params)
-```
-
-### database_exceptions.py
-**Purpose:** Database exception handling and conversion
-**Import:** `from solace_agent_mesh.gateway.http_sse.shared import DatabaseExceptionHandler, handle_database_errors`
-
-**Classes:**
-- `DatabaseExceptionHandler` - Centralized handler for converting SQLAlchemy exceptions to domain exceptions
-  - `handle_integrity_error(e: IntegrityError, entity_type: str = "Resource") -> ValidationError` - Convert integrity constraint violations
-  - `handle_operational_error(e: OperationalError, entity_type: str = "Resource") -> DataIntegrityError` - Handle operational errors
-
-**Functions:**
-- `handle_database_errors(entity_type: str = "Resource")` - Convenience decorator for database exception handling
-
-**Usage Examples:**
-```python
-from solace_agent_mesh.gateway.http_sse.shared import handle_database_errors
-
-class UserRepository:
-    @handle_database_errors("User")
-    def create_user(self, session, data):
-        # Repository method implementation
-        pass
-```
-
-### database_helpers.py
-**Purpose:** Database utility functions and custom types
-**Import:** `from solace_agent_mesh.gateway.http_sse.shared import SimpleJSON`
-
-**Classes:**
-- `SimpleJSON(TypeDecorator)` - Simple JSON type using Text storage for all databases
-
-**Usage Examples:**
-```python
-from sqlalchemy import Column, String
-from solace_agent_mesh.gateway.http_sse.shared import SimpleJSON
-
-class MyModel(Base):
-    id = Column(String, primary_key=True)
-    metadata = Column(SimpleJSON)  # Stores JSON as text
-```
-
-### utils.py
-**Purpose:** Generic utility functions
-**Import:** `from solace_agent_mesh.gateway.http_sse.shared import generate_uuid, to_snake_case, to_pascal_case`
-
-**Functions:**
-- `generate_uuid() -> str` - Generate a UUID string for database storage
-- `to_snake_case(name: str) -> str` - Convert a string to snake_case
-- `to_pascal_case(name: str) -> str` - Convert a string to PascalCase
-
-**Usage Examples:**
-```python
-from solace_agent_mesh.gateway.http_sse.shared import generate_uuid, to_snake_case
-
-# Generate unique ID
-user_id = generate_uuid()
-
-# Convert naming
-snake_name = to_snake_case("User Name")  # "user_name"
-```
-
-# content_hash: 0e33735691fb4637243f4fe61acbba78a388e654834903e34be22e3ce6f3c3bc

solace_agent_mesh/gateway/http_sse/utils/utils_llm.txt

@@ -1,47 +0,0 @@
-## Quick Summary
-The `utils` directory provides utility functions for the HTTP SSE Gateway, specifically for creating .stim file structures from task and event data.
-
-## Files Overview
-- `__init__.py` - Package initialization file for HTTP SSE Gateway utilities
-- `stim_utils.py` - Utility functions for formatting task data into .stim file structures
-
-## Developer API Reference
-
-### __init__.py
-**Purpose:** Package initialization for HTTP SSE Gateway utilities
-**Import:** `from solace_agent_mesh.gateway.http_sse.utils import *`
-
-This file serves as the package entry point and contains no public interfaces.
-
-### stim_utils.py
-**Purpose:** Provides utility functions for creating .stim file structures from task and event data
-**Import:** `from solace_agent_mesh.gateway.http_sse.utils.stim_utils import create_stim_from_task_data`
-
-**Functions:**
-- `create_stim_from_task_data(task: Task, events: List[TaskEvent]) -> dict` - Formats a task and its events into the .stim file structure with version 2.0 format for gateway-generated logs
-
-**Usage Examples:**
-```python
-from solace_agent_mesh.gateway.http_sse.utils.stim_utils import create_stim_from_task_data
-from solace_agent_mesh.gateway.http_sse.repository.entities import Task, TaskEvent
-
-# Create a .stim file structure from task and events
-task = Task(
-    id="task_123",
-    user_id="user_456", 
-    start_time="2024-01-01T10:00:00Z",
-    end_time="2024-01-01T10:05:00Z",
-    status="completed",
-    initial_request_text="Process this data"
-)
-
-events = [
-    TaskEvent(event_type="start", timestamp="2024-01-01T10:00:00Z"),
-    TaskEvent(event_type="complete", timestamp="2024-01-01T10:05:00Z")
-]
-
-stim_data = create_stim_from_task_data(task, events)
-# Returns a dictionary with 'invocation_details' and 'invocation_flow' keys
-```
-
-# content_hash: 7fdc4ad8bbcefb07ee40f84c438f988cda4fdfb812dab55c6a064d1b38b0c83f

solace_agent_mesh/llm.txt

@@ -1,228 +0,0 @@
-Here is the comprehensive developer guide for the `src` directory.
-
-## Quick Summary
-The `src` directory serves as the main source code root for the Solace AI Connector, containing four primary subsystems that work together to enable comprehensive AI agent communication and hosting. The `agent` directory provides a complete framework for hosting Google ADK agents with A2A protocol support, the `common` directory offers foundational A2A protocol infrastructure and utilities, the `core_a2a` directory provides a reusable service layer for core A2A operations, and the `gateway` directory implements various gateway patterns for external platform integration. These components work together to create a distributed AI agent ecosystem with real-time communication, task delegation, and multi-platform integration capabilities.
-
-## Files and Subdirectories Overview
-- **Direct files:**
-  - `__init__.py`: Empty package initialization file.
-- **Subdirectories:**
-  - `agent/`: Complete ADK agent hosting framework with A2A protocol integration and comprehensive tool library.
-  - `common/`: Foundational A2A protocol infrastructure, type systems, and client/server implementations.
-  - `core_a2a/`: Reusable service layer for core A2A interactions and agent registry operations.
-  - `gateway/`: Gateway framework with HTTP/SSE, Slack, and Webhook implementations for external platform integration.
-
-## Developer API Reference
-
-### Direct Files
-
-#### __init__.py
-**Purpose:** Standard Python package initializer. It allows the `src` directory and its subdirectories to be treated as a package.
-**Import:** `from src import agent, common, gateway`
-
-**Classes/Functions/Constants:**
-This file is empty and has no public interfaces.
-
-### Subdirectory APIs
-
-#### agent/
-**Purpose:** Provides a complete framework for hosting Google ADK agents with A2A protocol support and a comprehensive, extensible tool library.
-**Key Exports:** `SamAgentApp`, `SamAgentComponent`, `AppLlmAgent`, and a wide array of built-in tools for data analysis, web requests, multimedia processing, and inter-agent communication.
-**Import Examples:**
-```python
-from src.solace_agent_mesh.agent.sac.app import SamAgentApp
-from src.solace_agent_mesh.agent.sac.component import SamAgentComponent
-from src.solace_agent_mesh.agent.adk.app_llm_agent import AppLlmAgent
-from src.solace_agent_mesh.agent.tools.builtin_data_analysis_tools import query_data_with_sql
-from src.solace_agent_mesh.agent.tools.peer_agent_tool import PeerAgentTool
-from src.solace_agent_mesh.agent.tools.web_tools import web_request
-from src.solace_agent_mesh.agent.tools.image_tools import create_image_from_description
-```
-
-#### common/
-**Purpose:** Provides the foundational infrastructure for Agent-to-Agent (A2A) communication, including the core protocol, data types, message translation, and client/server implementations.
-**Key Exports:** A2A protocol functions, Pydantic type definitions (`Message`, `Task`, `AgentCard`), `A2AClient` for interacting with agents, `A2AServer` for building agents, and various utilities.
-**Import Examples:**
-```python
-from src.solace_agent_mesh.common.a2a_protocol import get_agent_request_topic
-from src.solace_agent_mesh.common.types import Message, Task, AgentCard, TextPart
-from src.solace_agent_mesh.common.client import A2AClient, A2ACardResolver
-from src.solace_agent_mesh.common.server import A2AServer, InMemoryTaskManager
-from src.solace_agent_mesh.common.agent_registry import AgentRegistry
-from src.solace_agent_mesh.common.utils.embeds import resolve_embeds_in_string
-```
-
-#### core_a2a/
-**Purpose:** Provides a reusable, decoupled service layer for core A2A interactions, handling task submission, cancellation, and agent discovery.
-**Key Exports:** `CoreA2AService` for managing A2A protocol logic without being tied to a specific gateway or messaging implementation.
-**Import Examples:**
-```python
-from src.solace_agent_mesh.core_a2a.service import CoreA2AService
-```
-
-#### gateway/
-**Purpose:** Provides a framework and multiple implementations for building gateways that bridge external platforms (like web UIs, Slack, or webhooks) with the A2A messaging system.
-**Key Exports:** `BaseGatewayApp` and `BaseGatewayComponent` for creating custom gateways, and concrete implementations like `WebUIBackendApp`, `SlackGatewayApp`, and `WebhookGatewayApp`.
-**Import Examples:**
-```python
-from src.solace_agent_mesh.gateway.base.app import BaseGatewayApp
-from src.solace_agent_mesh.gateway.http_sse.app import WebUIBackendApp
-from src.solace_agent_mesh.gateway.slack.app import SlackGatewayApp
-from src.solace_agent_mesh.gateway.webhook.app import WebhookGatewayApp
-from src.solace_agent_mesh.gateway.base.authorization_service import ConfigurableRbacAuthorizationService
-```
-
-## Complete Usage Guide
-This guide demonstrates how the different subdirectories within `src` work together to build a complete, distributed AI agent system.
-
-### 1. How to import and use functionality from subdirectories
-The following examples show how to import and instantiate components from each major subdirectory.
-
-```python
-# 1. Import from the 'agent' directory to create an AI agent
-from src.solace_agent_mesh.agent.sac.app import SamAgentApp
-
-# 2. Import from the 'common' and 'core_a2a' directories for protocol infrastructure
-from src.solace_agent_mesh.common.agent_registry import AgentRegistry
-from src.solace_agent_mesh.common.types import AgentCard, AgentCapabilities, AgentSkill
-from src.solace_agent_mesh.core_a2a.service import CoreA2AService
-
-# 3. Import from the 'gateway' directory to create interfaces
-from src.solace_agent_mesh.gateway.http_sse.app import WebUIBackendApp
-from src.solace_agent_mesh.gateway.slack.app import SlackGatewayApp
-from src.solace_agent_mesh.gateway.webhook.app import WebhookGatewayApp
-
-# 4. Import tools from the 'agent/tools' subdirectory
-from src.solace_agent_mesh.agent.tools.peer_agent_tool import PeerAgentTool
-from src.solace_agent_mesh.agent.tools.builtin_data_analysis_tools import query_data_with_sql
-```
-
-### 2. How different parts work together
-This section shows a step-by-step process for building a system, illustrating the synergy between the components.
-
-#### Step 1: Create an ADK-powered agent (`agent/`)
-First, define and configure an agent. This agent will automatically be equipped with a rich set of tools and A2A communication capabilities.
-
-```python
-# File: my_system.py
-from src.solace_agent_mesh.agent.sac.app import SamAgentApp
-
-# Configure the agent with all capabilities
-agent_config = {
-    "name": "data-analyst-agent",
-    "app_config": {
-        "namespace": "myorg/ai-agents",
-        "agent_name": "data_analyst",
-        "model": "gemini-1.5-pro",
-        "instruction": "You are a data analysis expert with access to SQL, charting, web tools, and peer collaboration.",
-        "agent_card": {
-            "description": "AI agent for comprehensive data analysis and reporting",
-            "capabilities": ["data_analysis", "web_research", "chart_generation", "peer_collaboration"]
-        },
-        "agent_card_publishing": {"interval_seconds": 30},
-        "agent_discovery": {"enabled": True},
-        "inter_agent_communication": {"allow_list": ["*"]}
-    }
-}
-
-# Create the agent app (in a real scenario, this is run by the SAC framework)
-agent_app = SamAgentApp(agent_config)
-```
-
-#### Step 2: Set Up A2A Protocol Infrastructure (`common/` and `core_a2a/`)
-Next, set up the core services that manage agent discovery and task routing. This is often handled by the gateway components but can be used directly.
-
-```python
-# File: my_system.py (continued)
-from src.solace_agent_mesh.common.agent_registry import AgentRegistry
-from src.solace_agent_mesh.common.types import AgentCard, AgentCapabilities, AgentSkill
-from src.solace_agent_mesh.core_a2a.service import CoreA2AService
-
-# Initialize a shared agent registry
-agent_registry = AgentRegistry()
-
-# Create the core A2A service, which uses the registry
-namespace = "myorg/ai-agents"
-a2a_service = CoreA2AService(agent_registry, namespace)
-
-# Manually register an agent's capabilities (this is usually done automatically by the agent itself)
-data_analyst_card = AgentCard(
-    name="data_analyst",
-    display_name="Data Analyst",
-    description="AI agent for data analysis",
-    url=f"a2a://{namespace}/data_analyst",
-    version="1.0.0",
-    capabilities=AgentCapabilities(streaming=True, pushNotifications=True),
-    skills=[AgentSkill(id="sql_analysis", name="SQL Data Analysis")]
-)
-a2a_service.process_discovery_message(data_analyst_card)
-```
-
-#### Step 3: Create Gateway Integrations (`gateway/`)
-Create one or more gateways to expose the agent(s) to external platforms.
-
-```python
-# File: my_system.py (continued)
-from src.solace_agent_mesh.gateway.http_sse.app import WebUIBackendApp
-from src.solace_agent_mesh.gateway.slack.app import SlackGatewayApp
-
-# Web UI Gateway for browser-based interactions
-webui_config = {
-    "name": "web-gateway",
-    "app_config": {
-        "namespace": "myorg/ai-agents",
-        "gateway_id": "web-ui-gateway",
-        "session_secret_key": "a-very-secret-key",
-        "fastapi_host": "0.0.0.0",
-        "fastapi_port": 8080,
-        "artifact_service": {"type": "local_file", "base_path": "./artifacts"}
-    }
-}
-webui_app = WebUIBackendApp(webui_config)
-
-# Slack Gateway for team collaboration
-slack_config = {
-    "name": "slack-gateway",
-    "app_config": {
-        "namespace": "myorg/ai-agents",
-        "gateway_id": "slack-gateway",
-        "slack_bot_token": "${SLACK_BOT_TOKEN}",
-        "slack_app_token": "${SLACK_APP_TOKEN}",
-        "default_agent_name": "data_analyst"
-    }
-}
-slack_app = SlackGatewayApp(slack_config)
-```
-
-### 3. Common usage patterns
-
-#### Pattern 1: Inter-Agent Communication
-An agent can use the `PeerAgentTool` (from `agent/tools/`) to delegate tasks to other agents, leveraging the `common/` protocol infrastructure.
-
-```python
-# This code would run within an agent's tool execution context.
-from src.solace_agent_mesh.agent.tools.peer_agent_tool import PeerAgentTool
-
-async def analyze_and_delegate_report(component, tool_context):
-    # Assume 'component' is the SamAgentComponent instance hosting the current agent.
-    
-    # Step 1: Perform local analysis (using another tool)
-    # ... analysis_result = await query_data_with_sql(...) ...
-
-    # Step 2: Delegate report generation to a specialist agent
-    peer_tool = PeerAgentTool(
-        target_agent_name="report_generator",
-        host_component=component
-    )
-    
-    report_result = await peer_tool.run_async(
-        args={
-            "task_description": "Generate a professional PDF report from this analysis",
-            "analysis_data": "artifact://analysis_result.json",
-            "report_format": "PDF"
-        },
-        tool_context=tool_context
-    )
-    
-    return report_result
-```