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

solace_agent_mesh/gateway/http_sse/routers/routers_llm.txt

@@ -1,312 +0,0 @@
-# DEVELOPER GUIDE for the routers directory
-
-## Quick Summary
-The `routers` directory contains FastAPI router modules that define the REST API endpoints for the HTTP SSE Gateway. Each router groups endpoints by functional domain (agent discovery, artifact management, authentication, sessions, etc.) and provides the primary interface for frontend applications and other clients to interact with the gateway. The routers work together to provide a complete web API with real-time capabilities through Server-Sent Events (SSE), along with comprehensive session management, artifact handling, and A2A message visualization.
-
-## Files and Subdirectories Overview
-- **Direct files:**
-  - `__init__.py` - Package initialization for router modules
-  - `agent_cards.py` - Agent discovery endpoints
-  - `artifacts.py` - Artifact management (upload, download, versioning)
-  - `auth.py` - Authentication flow endpoints (login, callback, refresh)
-  - `config.py` - Frontend configuration endpoint
-  - `feedback.py` - User feedback collection endpoints
-  - `people.py` - User search for autocomplete features
-  - `sessions.py` - Session management (CRUD operations)
-  - `sse.py` - Server-Sent Events streaming endpoint
-  - `tasks.py` - Task submission and management endpoints
-  - `users.py` - Current user information endpoint
-  - `visualization.py` - A2A message visualization streaming
-- **Subdirectories:**
-  - `dto/` - Data Transfer Objects for request/response validation
-
-## Developer API Reference
-
-### Direct Files
-
-#### __init__.py
-**Purpose:** Package initialization for the routers module
-**Import:** `from solace_agent_mesh.gateway.http_sse.routers import *`
-
-#### agent_cards.py
-**Purpose:** Provides REST endpoints for agent discovery
-**Import:** `from solace_agent_mesh.gateway.http_sse.routers.agent_cards import router`
-
-**Functions:**
-- `get_discovered_agent_cards() -> List[AgentCard]` - Retrieves all currently discovered A2A agents
-
-#### artifacts.py
-**Purpose:** Manages session-specific artifacts via REST endpoints with versioning and metadata support
-**Import:** `from solace_agent_mesh.gateway.http_sse.routers.artifacts import router, ArtifactUploadResponse`
-
-**Classes:**
-- `ArtifactUploadResponse(BaseModel)` - Response model for artifact uploads with camelCase fields
-
-**Functions:**
-- `upload_artifact_with_session(upload_file: UploadFile, sessionId: str, filename: str, metadata_json: str) -> ArtifactUploadResponse` - Uploads artifact with session management
-- `list_artifact_versions(session_id: str, filename: str) -> List[int]` - Lists available versions for an artifact
-- `list_artifacts(session_id: str) -> List[ArtifactInfo]` - Lists all artifacts in a session with metadata
-- `get_latest_artifact(session_id: str, filename: str) -> StreamingResponse` - Downloads latest artifact version with embed resolution
-- `get_specific_artifact_version(session_id: str, filename: str, version: Union[int, str]) -> StreamingResponse` - Downloads specific version
-- `get_artifact_by_uri(uri: str) -> StreamingResponse` - Downloads artifact by formal artifact:// URI
-- `delete_artifact(session_id: str, filename: str) -> Response` - Deletes artifact and all versions
-
-#### auth.py
-**Purpose:** Handles OAuth-based user authentication flow with external authorization service
-**Import:** `from solace_agent_mesh.gateway.http_sse.routers.auth import router`
-
-**Functions:**
-- `initiate_login(request: FastAPIRequest) -> RedirectResponse` - Starts OAuth login flow with external service
-- `get_csrf_token(response: Response) -> Dict[str, str]` - Generates and sets CSRF token
-- `auth_callback(request: FastAPIRequest) -> RedirectResponse` - Handles OAuth callback and token exchange
-- `refresh_token(request: FastAPIRequest) -> Dict[str, str]` - Refreshes access token using refresh token
-
-#### config.py
-**Purpose:** Provides frontend configuration settings including feature flags
-**Import:** `from solace_agent_mesh.gateway.http_sse.routers.config import router`
-
-**Functions:**
-- `get_app_config() -> Dict[str, Any]` - Returns frontend configuration including auth URLs, feature flags, and persistence settings
-
-#### feedback.py
-**Purpose:** Receives and processes user feedback on chat messages
-**Import:** `from solace_agent_mesh.gateway.http_sse.routers.feedback import router, FeedbackPayload`
-
-**Classes:**
-- `FeedbackPayload(BaseModel)` - Data model for feedback submission
-  - `task_id: str` - ID of the task being rated
-  - `session_id: str` - Session containing the task
-  - `feedback_type: Literal["up", "down"]` - Type of feedback
-  - `feedback_text: Optional[str]` - Optional text feedback
-
-**Functions:**
-- `submit_feedback(payload: FeedbackPayload, user_id: str) -> Dict[str, str]` - Processes user feedback asynchronously
-
-#### people.py
-**Purpose:** Provides user search functionality for autocomplete features
-**Import:** `from solace_agent_mesh.gateway.http_sse.routers.people import router`
-
-**Functions:**
-- `search_people(q: str, limit: int = 10) -> List[Dict[str, Any]]` - Searches for users for @mention autocomplete
-
-#### sessions.py
-**Purpose:** Manages user sessions including CRUD operations with persistence
-**Import:** `from solace_agent_mesh.gateway.http_sse.routers.sessions import router`
-
-**Functions:**
-- `get_all_sessions(page_number: int, page_size: int, user: dict) -> PaginatedResponse[SessionResponse]` - Lists user's sessions with pagination
-- `get_session(session_id: str, user: dict) -> DataResponse[SessionResponse]` - Gets session details with authorization
-- `get_session_history(session_id: str, user: dict) -> List[MessageResponse]` - Gets session message history
-- `update_session_name(session_id: str, name: str, user: dict) -> SessionResponse` - Updates session name with validation
-- `delete_session(session_id: str, user: dict) -> None` - Deletes session with cascade notifications
-- `save_task(session_id: str, request: SaveTaskRequest, user: dict) -> TaskResponse` - Saves complete task interaction (upsert)
-- `get_session_tasks(session_id: str, user: dict) -> TaskListResponse` - Gets all tasks for a session
-
-#### sse.py
-**Purpose:** Provides Server-Sent Events endpoint for real-time streaming
-**Import:** `from solace_agent_mesh.gateway.http_sse.routers.sse import router`
-
-**Functions:**
-- `subscribe_to_task_events(task_id: str, request: FastAPIRequest) -> EventSourceResponse` - Establishes SSE connection for task updates with automatic cleanup
-
-#### tasks.py
-**Purpose:** Handles task submission, management, and historical search
-**Import:** `from solace_agent_mesh.gateway.http_sse.routers.tasks import router`
-
-**Functions:**
-- `search_tasks(start_date: Optional[str], end_date: Optional[str], search: Optional[str], page: int, page_size: int, query_user_id: Optional[str]) -> List[Task]` - Searches historical tasks with admin capabilities
-- `get_task_as_stim_file(task_id: str) -> Response` - Downloads complete task history as .stim file
-- `send_task_to_agent(request: FastAPIRequest, payload: SendMessageRequest) -> SendMessageSuccessResponse` - Submits non-streaming task
-- `subscribe_task_from_agent(request: FastAPIRequest, payload: SendStreamingMessageRequest) -> SendStreamingMessageSuccessResponse` - Submits streaming task
-- `cancel_agent_task(request: FastAPIRequest, taskId: str, payload: CancelTaskRequest) -> Dict[str, str]` - Cancels active task
-
-#### users.py
-**Purpose:** Provides current user information with authentication status
-**Import:** `from solace_agent_mesh.gateway.http_sse.routers.users import router`
-
-**Functions:**
-- `get_current_user_endpoint(user: dict) -> Dict[str, Any]` - Returns current user information with auth status
-
-#### visualization.py
-**Purpose:** Manages A2A message visualization streams for real-time monitoring
-**Import:** `from solace_agent_mesh.gateway.http_sse.routers.visualization import router, SubscriptionTarget, VisualizationSubscribeRequest`
-
-**Classes:**
-- `SubscriptionTarget(BaseModel)` - Defines visualization target
-  - `type: str` - Target type (e.g., "current_namespace_a2a_messages", "agent_a2a_messages")
-  - `identifier: Optional[str]` - Target identifier (namespace or agent name)
-- `VisualizationSubscribeRequest(BaseModel)` - Subscription request
-  - `subscription_targets: Optional[List[SubscriptionTarget]]` - Targets to monitor
-  - `client_stream_id: Optional[str]` - Client-generated stream ID for idempotency
-- `VisualizationSubscribeResponse(BaseModel)` - Subscription response with SSE URL
-- `VisualizationConfigUpdateRequest(BaseModel)` - Configuration update request
-- `VisualizationConfigUpdateResponse(BaseModel)` - Configuration update response
-
-**Functions:**
-- `subscribe_to_visualization_stream(request_data: VisualizationSubscribeRequest) -> VisualizationSubscribeResponse` - Starts visualization stream with authorization
-- `get_visualization_stream_events(stream_id: str) -> EventSourceResponse` - SSE endpoint for visualization events
-- `update_visualization_stream_config(stream_id: str, update_request: VisualizationConfigUpdateRequest) -> VisualizationConfigUpdateResponse` - Updates stream configuration
-- `unsubscribe_from_visualization_stream(stream_id: str) -> Response` - Terminates visualization stream
-
-### Subdirectory APIs
-
-#### dto/
-**Purpose:** Provides Data Transfer Objects for request/response validation and serialization with automatic timestamp conversion
-**Key Exports:** Request and response DTOs for session management with field validation and camelCase aliasing
-**Import Examples:**
-```python
-from solace_agent_mesh.gateway.http_sse.routers.dto.requests import GetSessionsRequest, UpdateSessionRequest
-from solace_agent_mesh.gateway.http_sse.routers.dto.responses import SessionResponse, MessageResponse
-```
-
-## Complete Usage Guide
-
-### 1. Setting Up Routers in FastAPI Application
-
-```python
-from fastapi import FastAPI
-from solace_agent_mesh.gateway.http_sse.routers import (
-    agent_cards,
-    artifacts,
-    auth,
-    config,
-    feedback,
-    people,
-    sessions,
-    sse,
-    tasks,
-    users,
-    visualization
-)
-
-app = FastAPI()
-
-# Include all routers with appropriate prefixes
-app.include_router(agent_cards.router, prefix="/api/v1", tags=["agents"])
-app.include_router(artifacts.router, prefix="/api/v1/artifacts", tags=["artifacts"])
-app.include_router(auth.router, prefix="/api/v1", tags=["auth"])
-app.include_router(config.router, prefix="/api/v1", tags=["config"])
-app.include_router(feedback.router, prefix="/api/v1", tags=["feedback"])
-app.include_router(people.router, prefix="/api/v1", tags=["people"])
-app.include_router(sessions.router, prefix="/api/v1", tags=["sessions"])
-app.include_router(sse.router, prefix="/api/v1/sse", tags=["sse"])
-app.include_router(tasks.router, prefix="/api/v1/tasks", tags=["tasks"])
-app.include_router(users.router, prefix="/api/v1/users", tags=["users"])
-app.include_router(visualization.router, prefix="/api/v1/visualization", tags=["visualization"])
-```
-
-### 2. Agent Discovery and Task Submission
-
-```python
-import httpx
-from a2a.types import SendStreamingMessageRequest, Message, MessagePart
-
-# Discover available agents
-async def get_available_agents():
-    async with httpx.AsyncClient() as client:
-        response = await client.get("http://localhost:8000/api/v1/agentCards")
-        return response.json()
-
-# Submit a streaming task to an agent
-async def submit_streaming_task(agent_name: str, message_text: str, session_id: str):
-    # Create message parts
-    parts = [MessagePart(text=message_text)]
-    
-    # Create message with metadata
-    message = Message(
-        parts=parts,
-        context_id=session_id,
-        metadata={"agent_name": agent_name}
-    )
-    
-    # Create request payload
-    payload = SendStreamingMessageRequest(
-        method="message:stream",
-        params={"message": message},
-        id="req_123"
-    )
-    
-    async with httpx.AsyncClient() as client:
-        response = await client.post(
-            "http://localhost:8000/api/v1/tasks/message:stream",
-            json=payload.model_dump()
-        )
-        return response.json()
-
-# Search historical tasks (admin users can query all users)
-async def search_historical_tasks(start_date: str = None, query_user_id: str = None):
-    params = {}
-    if start_date:
-        params["start_date"] = start_date
-    if query_user_id:
-        params["query_user_id"] = query_user_id
-    
-    async with httpx.AsyncClient() as client:
-        response = await client.get(
-            "http://localhost:8000/api/v1/tasks",
-            params=params
-        )
-        return response.json()
-```
-
-### 3. Real-time Event Streaming with SSE
-
-```python
-import asyncio
-import httpx
-import json
-
-# Client-side SSE connection for task events
-async def listen_to_task_events(task_id: str):
-    async with httpx.AsyncClient() as client:
-        async with client.stream(
-            "GET", 
-            f"http://localhost:8000/api/v1/sse/subscribe/{task_id}",
-            headers={"Accept": "text/event-stream"}
-        ) as response:
-            async for line in response.aiter_lines():
-                if line.startswith("data: "):
-                    event_data = line[6:]  # Remove "data: " prefix
-                    try:
-                        parsed_data = json.loads(event_data)
-                        print(f"Received event: {parsed_data}")
-                    except json.JSONDecodeError:
-                        print(f"Received raw data: {event_data}")
-
-# Client-side SSE connection for visualization
-async def listen_to_visualization_events(stream_id: str):
-    async with httpx.AsyncClient() as client:
-        async with client.stream(
-            "GET",
-            f"http://localhost:8000/api/v1/visualization/{stream_id}/events",
-            headers={"Accept": "text/event-stream"}
-        ) as response:
-            async for line in response.aiter_lines():
-                if line.startswith("data: "):
-                    event_data = line[6:]
-                    print(f"Visualization event: {event_data}")
-```
-
-### 4. Comprehensive Artifact Management
-
-```python
-import httpx
-import json
-from pathlib import Path
-
-# Upload an artifact with metadata and automatic session creation
-async def upload_artifact_with_metadata(session_id: str, filename: str, file_path: Path, metadata: dict = None):
-    files = {"upload_file": (filename, file_path.open("rb"))}
-    data = {
-        "sessionId": session_id,  # Can be null/empty to create new session
-        "filename": filename
-    }
-    
-    if metadata:
-        data["metadata_json"] = json.dumps(metadata)
-    
-    async with httpx.AsyncClient() as client:
-        response = await client.post(
-            "http://localhost:
-
-# content_hash: 8e5e35d1d55cb448656d32d58b4600db192110e8de163a93765eef3e04086329

solace_agent_mesh/gateway/http_sse/services/services_llm.txt

@@ -1,303 +0,0 @@
-# DEVELOPER GUIDE: services
-
-## Quick Summary
-The `services` directory contains the business logic layer for the HTTP SSE Gateway. It provides high-level services for agent management (discovering and retrieving A2A agents), user feedback processing with database persistence and event publishing, user search via identity services, session management with database persistence, task logging to database, data retention/cleanup, and A2A task operations like cancellation.
-
-## Files Overview
-- `__init__.py` - Package initialization file marking the directory as a Python package
-- `agent_card_service.py` - Service for retrieving information about discovered A2A agents from the registry
-- `data_retention_service.py` - Service for automatic cleanup of old tasks and feedback based on retention policies
-- `feedback_service.py` - Service for processing and storing user feedback on chat messages with database and event publishing
-- `people_service.py` - Service for searching users via configured identity services
-- `session_service.py` - Service for managing chat sessions and messages with database persistence
-- `task_logger_service.py` - Service for logging A2A tasks and events to the database
-- `task_service.py` - Service for handling A2A task operations like cancellation
-
-## Developer API Reference
-
-### __init__.py
-**Purpose:** Marks the services directory as a Python package
-**Import:** N/A - No public interfaces
-
-### agent_card_service.py
-**Purpose:** Provides methods for accessing information about discovered A2A agents from the shared AgentRegistry
-**Import:** `from solace_agent_mesh.gateway.http_sse.services.agent_card_service import AgentCardService`
-
-**Classes:**
-- `AgentCardService(agent_registry: AgentRegistry)` - Service for accessing discovered A2A agent information
-  - `get_all_agent_cards() -> List[AgentCard]` - Retrieves all currently discovered and registered agent cards
-  - `get_agent_card_by_name(agent_name: str) -> Optional[AgentCard]` - Retrieves a specific agent card by name, returns None if not found
-
-**Usage Examples:**
-```python
-from solace_agent_mesh.gateway.http_sse.services.agent_card_service import AgentCardService
-from solace_agent_mesh.common.agent_registry import AgentRegistry
-
-# Initialize with shared agent registry
-agent_registry = AgentRegistry()  # Usually injected as shared instance
-agent_service = AgentCardService(agent_registry=agent_registry)
-
-# Get all available agents
-all_agents = agent_service.get_all_agent_cards()
-print(f"Found {len(all_agents)} agents")
-
-# Get specific agent by name
-agent = agent_service.get_agent_card_by_name("data-processor")
-if agent:
-    print(f"Found agent: {agent.name}")
-else:
-    print("Agent not found")
-```
-
-### data_retention_service.py
-**Purpose:** Service for automatically cleaning up old tasks, task events, and feedback based on configurable retention policies
-**Import:** `from solace_agent_mesh.gateway.http_sse.services.data_retention_service import DataRetentionService`
-
-**Classes:**
-- `DataRetentionService(session_factory: Callable[[], DBSession] | None, config: Dict[str, Any])` - Service for automatic data cleanup based on retention policies
-  - `cleanup_old_data() -> None` - Main orchestration method for cleaning up old data, calls cleanup methods for tasks and feedback
-
-**Constants/Variables:**
-- `MIN_RETENTION_DAYS: int` - Minimum retention period (1 day)
-- `MIN_CLEANUP_INTERVAL_HOURS: int` - Minimum cleanup interval (1 hour)
-- `MIN_BATCH_SIZE: int` - Minimum batch size for deletion (1)
-- `MAX_BATCH_SIZE: int` - Maximum batch size for deletion (10000)
-
-**Usage Examples:**
-```python
-from solace_agent_mesh.gateway.http_sse.services.data_retention_service import DataRetentionService
-from sqlalchemy.orm import sessionmaker
-
-# Initialize with database session factory and config
-session_factory = sessionmaker(bind=your_engine)
-config = {
-    "enabled": True,
-    "task_retention_days": 90,
-    "feedback_retention_days": 90,
-    "cleanup_interval_hours": 24,
-    "batch_size": 1000
-}
-
-retention_service = DataRetentionService(
-    session_factory=session_factory,
-    config=config
-)
-
-# Run cleanup (typically called by scheduler)
-retention_service.cleanup_old_data()
-```
-
-### feedback_service.py
-**Purpose:** Handles the business logic for processing and storing user feedback with database persistence and event publishing
-**Import:** `from solace_agent_mesh.gateway.http_sse.services.feedback_service import FeedbackService`
-
-**Classes:**
-- `FeedbackService(session_factory: Callable[[], DBSession] | None, component: WebUIBackendComponent, task_repo: ITaskRepository)` - Service for processing user feedback with database persistence and event publishing
-  - `process_feedback(payload: FeedbackPayload, user_id: str) -> None` - Asynchronously processes and stores feedback, publishes events if configured
-
-**Usage Examples:**
-```python
-import asyncio
-from solace_agent_mesh.gateway.http_sse.services.feedback_service import FeedbackService
-from sqlalchemy.orm import sessionmaker
-
-# Initialize with database session factory
-session_factory = sessionmaker(bind=your_engine)
-component = YourWebUIBackendComponent()  # Your component instance
-task_repo = YourTaskRepository()  # Your task repository
-
-feedback_service = FeedbackService(
-    session_factory=session_factory,
-    component=component,
-    task_repo=task_repo
-)
-
-# Process feedback (requires FeedbackPayload from router)
-async def process_user_feedback():
-    # payload would be a FeedbackPayload instance from the router
-    await feedback_service.process_feedback(payload, user_id="user123")
-
-asyncio.run(process_user_feedback())
-```
-
-### people_service.py
-**Purpose:** Provides user search functionality via configured identity services
-**Import:** `from solace_agent_mesh.gateway.http_sse.services.people_service import PeopleService`
-
-**Classes:**
-- `PeopleService(identity_service: Optional[BaseIdentityService])` - Service for searching and retrieving user information
-  - `search_for_users(query: str, limit: int = 10) -> List[Dict[str, Any]]` - Asynchronously searches for users, returns empty list if no identity service configured or query too short
-
-**Usage Examples:**
-```python
-import asyncio
-from solace_agent_mesh.gateway.http_sse.services.people_service import PeopleService
-from solace_agent_mesh.common.services.identity_service import BaseIdentityService
-
-# Initialize with identity service
-identity_service = SomeIdentityService()  # Your identity service implementation
-people_service = PeopleService(identity_service=identity_service)
-
-async def search_users():
-    # Search for users
-    users = await people_service.search_for_users("john", limit=5)
-    for user in users:
-        print(f"User: {user.get('name')} - {user.get('email')}")
-
-# Initialize without identity service (graceful degradation)
-people_service_no_id = PeopleService(identity_service=None)
-# search_for_users will return empty list
-
-asyncio.run(search_users())
-```
-
-### session_service.py
-**Purpose:** Manages chat sessions and messages with database persistence support
-**Import:** `from solace_agent_mesh.gateway.http_sse.services.session_service import SessionService`
-
-**Classes:**
-- `SessionService(component: WebUIBackendComponent = None)` - Service for managing chat sessions and messages
-  - `is_persistence_enabled() -> bool` - Checks if the service is configured with a persistent backend
-  - `get_user_sessions(db: DbSession, user_id: UserId, pagination: PaginationParams | None = None) -> PaginatedResponse[Session]` - Retrieves paginated sessions for a user
-  - `get_session_details(db: DbSession, session_id: SessionId, user_id: UserId) -> Session | None` - Gets session details for a specific session
-  - `create_session(db: DbSession, user_id: UserId, name: str | None = None, agent_id: str | None = None, session_id: str | None = None) -> Optional[Session]` - Creates a new session
-  - `update_session_name(db: DbSession, session_id: SessionId, user_id: UserId, name: str) -> Session | None` - Updates session name
-  - `delete_session_with_notifications(db: DbSession, session_id: SessionId, user_id: UserId) -> bool` - Deletes session and notifies agents
-  - `save_task(db: DbSession, task_id: str, session_id: str, user_id: str, user_message: Optional[str], message_bubbles: str, task_metadata: Optional[str] = None) -> ChatTask` - Saves a complete task interaction
-  - `get_session_tasks(db: DbSession, session_id: str, user_id: str) -> List[ChatTask]` - Gets all tasks for a session
-  - `get_session_messages_from_tasks(db: DbSession, session_id: str, user_id: str) -> List[Dict[str, Any]]` - Gets session messages by flattening task message_bubbles for backward compatibility
-
-**Usage Examples:**
-```python
-from solace_agent_mesh.gateway.http_sse.services.session_service import SessionService
-from sqlalchemy.orm import Session as DbSession
-
-# Initialize with component
-component = YourWebUIBackendComponent()  # Your component
-session_service = SessionService(component=component)
-
-# Use with database session
-with your_session_factory() as db:
-    # Create a new session
-    session = session_service.create_session(
-        db=db,
-        user_id="user123",
-        name="My Chat Session",
-        agent_id="assistant-agent"
-    )
-
-    # Save a task with message bubbles
-    import json
-    message_bubbles = json.dumps([
-        {"type": "user", "text": "Hello", "id": "msg1"},
-        {"type": "agent", "text": "Hi there!", "id": "msg2"}
-    ])
-    
-    task = session_service.save_task(
-        db=db,
-        task_id="task-123",
-        session_id=session.id,
-        user_id="user123",
-        user_message="Hello",
-        message_bubbles=message_bubbles
-    )
-
-    # Get user's sessions with pagination
-    paginated_sessions = session_service.get_user_sessions(db, "user123")
-    
-    db.commit()
-```
-
-### task_logger_service.py
-**Purpose:** Service for logging A2A tasks and events to the database with configurable filtering and sanitization
-**Import:** `from solace_agent_mesh.gateway.http_sse.services.task_logger_service import TaskLoggerService`
-
-**Classes:**
-- `TaskLoggerService(session_factory: Callable[[], DBSession] | None, config: Dict[str, Any])` - Service for logging A2A tasks and events to database
-  - `log_event(event_data: Dict[str, Any]) -> None` - Parses a raw A2A message and logs it as a task event, creates or updates master task record
-
-**Usage Examples:**
-```python
-from solace_agent_mesh.gateway.http_sse.services.task_logger_service import TaskLoggerService
-from sqlalchemy.orm import sessionmaker
-
-# Initialize with database session factory and config
-session_factory = sessionmaker(bind=your_engine)
-config = {
-    "enabled": True,
-    "log_status_updates": True,
-    "log_artifact_events": False,
-    "log_file_parts": True,
-    "max_file_part_size_bytes": 102400
-}
-
-task_logger = TaskLoggerService(
-    session_factory=session_factory,
-    config=config
-)
-
-# Log an A2A event
-event_data = {
-    "topic": "sam/agents/my-agent/request",
-    "payload": {"id": "task-123", "method": "sendMessage"},
-    "user_properties": {"userId": "user@example.com"}
-}
-
-task_logger.log_event(event_data)
-```
-
-### task_service.py
-**Purpose:** Handles A2A task operations, specifically task cancellation using CoreA2AService and message publishing
-**Import:** `from solace_agent_mesh.gateway.http_sse.services.task_service import TaskService, PublishFunc`
-
-**Type Aliases:**
-- `PublishFunc: Callable[[str, Dict, Optional[Dict]], None]` - Function type for publishing messages (topic, payload, user_properties)
-
-**Classes:**
-- `TaskService(core_a2a_service: CoreA2AService, publish_func: PublishFunc, namespace: str, gateway_id: str, sse_manager: SSEManager, task_context_map: Dict[str, Dict], task_context_lock: threading.Lock, app_name: str)` - Service for managing A2A task operations
-  - `cancel_task(agent_name: str, task_id: str, client_id: str, user_id: str = "web_user") -> None` - Asynchronously cancels a task by publishing A2A CancelTaskRequest message
-
-**Usage Examples:**
-```python
-import asyncio
-import threading
-from solace_agent_mesh.gateway.http_sse.services.task_service import TaskService, PublishFunc
-from solace_agent_mesh.core_a2a.service import CoreA2AService
-from solace_agent_mesh.gateway.http_sse.sse_manager import SSEManager
-
-# Define publish function
-def my_publish_func(topic: str, payload: dict, user_properties: dict = None):
-    print(f"Publishing to {topic}: {payload}")
-    # Your actual message publishing logic here
-
-# Initialize dependencies
-core_a2a_service = CoreA2AService()  # Your core A2A service
-sse_manager = SSEManager()
-task_context_map = {}
-task_context_lock = threading.Lock()
-
-# Create task service
-task_service = TaskService(
-    core_a2a_service=core_a2a_service,
-    publish_func=my_publish_func,
-    namespace="my-namespace",
-    gateway_id="gateway-01",
-    sse_manager=sse_manager,
-    task_context_map=task_context_map,
-    task_context_lock=task_context_lock,
-    app_name="my-app"
-)
-
-async def cancel_task_example():
-    # Cancel a task
-    await task_service.cancel_task(
-        agent_name="data-processor",
-        task_id="task-123",
-        client_id="client-456",
-        user_id="user@example.com"
-    )
-
-asyncio.run(cancel_task_example())
-```
-
-# content_hash: 09bc3008d9a6c148b0b9d7477d20b26514f7fc4ee72f36eda5348f8f7d51f2ea