solace-agent-mesh 1.5.0__py3-none-any.whl → 1.6.0__py3-none-any.whl

solace_agent_mesh/gateway/http_sse/routers/tasks.py

@@ -2,61 +2,53 @@
 API Router for submitting and managing tasks to agents.
 """
 
-import yaml
+import logging
 from datetime import datetime
-from fastapi import (
-    APIRouter,
-    Depends,
-    HTTPException,
-    Request as FastAPIRequest,
-    Response,
-    status,
-)
-from fastapi.exceptions import RequestValidationError
-from typing import List, Optional, Union
-
-from solace_ai_connector.common.log import log
-
-from ....gateway.http_sse.session_manager import SessionManager
-from ....gateway.http_sse.services.task_service import TaskService
-from ....gateway.http_sse.services.session_service import SessionService
-from ....gateway.http_sse.repository.interfaces import ITaskRepository
-from ....gateway.http_sse.repository.entities import Task
-from ....gateway.http_sse.shared.types import PaginationParams, UserId
-from ..utils.stim_utils import create_stim_from_task_data
+from typing import TYPE_CHECKING
 
+import yaml
 from a2a.types import (
     CancelTaskRequest,
     SendMessageRequest,
-    SendStreamingMessageRequest,
     SendMessageSuccessResponse,
+    SendStreamingMessageRequest,
     SendStreamingMessageSuccessResponse,
 )
-from ....common import a2a
+from fastapi import APIRouter, Depends, HTTPException, Response, status
+from fastapi import Request as FastAPIRequest
+from sqlalchemy.orm import Session as DBSession
 
+from ....common import a2a
 from ....gateway.http_sse.dependencies import (
-    get_session_manager,
+    get_db,
     get_sac_component,
-    get_task_service,
     get_session_business_service,
+    get_session_manager,
     get_task_repository,
-    get_user_id,
+    get_task_service,
     get_user_config,
-    get_session_business_service,
+    get_user_id,
 )
+from ....gateway.http_sse.repository.entities import Task
+from ....gateway.http_sse.repository.interfaces import ITaskRepository
 from ....gateway.http_sse.services.session_service import SessionService
-
-from typing import TYPE_CHECKING
+from ....gateway.http_sse.services.task_service import TaskService
+from ....gateway.http_sse.session_manager import SessionManager
+from ....gateway.http_sse.shared.pagination import PaginationParams
+from ....gateway.http_sse.shared.types import UserId
+from ..utils.stim_utils import create_stim_from_task_data
 
 if TYPE_CHECKING:
     from ....gateway.http_sse.component import WebUIBackendComponent
 
 router = APIRouter()
 
+log = logging.getLogger(__name__)
+
 
 async def _submit_task(
     request: FastAPIRequest,
-    payload: Union[SendMessageRequest, SendStreamingMessageRequest],
+    payload: SendMessageRequest | SendStreamingMessageRequest,
     session_manager: SessionManager,
     component: "WebUIBackendComponent",
     is_streaming: bool,
@@ -202,25 +194,25 @@ async def _submit_task(
         )
 
 
-@router.get("/tasks", response_model=List[Task], tags=["Tasks"])
+@router.get("/tasks", response_model=list[Task], tags=["Tasks"])
 async def search_tasks(
     request: FastAPIRequest,
-    start_date: Optional[str] = None,
-    end_date: Optional[str] = None,
-    search: Optional[str] = None,
+    start_date: str | None = None,
+    end_date: str | None = None,
     page: int = 1,
     page_size: int = 20,
-    query_user_id: Optional[str] = None,
+    query_user_id: str | None = None,
+    db: DBSession = Depends(get_db),
     user_id: UserId = Depends(get_user_id),
     user_config: dict = Depends(get_user_config),
     repo: ITaskRepository = Depends(get_task_repository),
 ):
     """
-    Lists and searches for historical tasks.
-    - Regular users can only search their own tasks.
-    - Users with the 'tasks:read:all' scope can search for any user's tasks by providing `query_user_id`.
+    Lists and filters historical tasks by date.
+    - Regular users can only view their own tasks.
+    - Users with the 'tasks:read:all' scope can view any user's tasks by providing `query_user_id`.
     """
-    log_prefix = f"[GET /api/v1/tasks] "
+    log_prefix = "[GET /api/v1/tasks] "
     log.info("%sRequest from user %s", log_prefix, user_id)
 
     target_user_id = user_id
@@ -264,14 +256,14 @@ async def search_tasks(
                 detail="Invalid end_date format. Use ISO 8601 format.",
             )
 
-    pagination = PaginationParams(page=page, page_size=page_size)
+    pagination = PaginationParams(page_number=page, page_size=page_size)
 
     try:
         tasks = repo.search(
+            db,
             user_id=target_user_id,
             start_date=start_time_ms,
             end_date=end_time_ms,
-            search_query=search,
             pagination=pagination,
         )
         return tasks
@@ -287,6 +279,7 @@ async def search_tasks(
 async def get_task_as_stim_file(
     task_id: str,
     request: FastAPIRequest,
+    db: DBSession = Depends(get_db),
     user_id: UserId = Depends(get_user_id),
     user_config: dict = Depends(get_user_config),
     repo: ITaskRepository = Depends(get_task_repository),
@@ -298,7 +291,7 @@ async def get_task_as_stim_file(
     log.info("%sRequest from user %s", log_prefix, user_id)
 
     try:
-        result = repo.find_by_id_with_events(task_id)
+        result = repo.find_by_id_with_events(db, task_id)
         if not result:
             raise HTTPException(
                 status_code=status.HTTP_404_NOT_FOUND,

solace_agent_mesh/gateway/http_sse/routers/users.py

@@ -3,13 +3,15 @@ Router for user-related endpoints.
 Maintains backward compatibility with original API format.
 """
 
+import logging
 from typing import Any
 
 from fastapi import APIRouter, Depends
-from solace_ai_connector.common.log import log
 
 from ..shared.auth_utils import get_current_user
 
+log = logging.getLogger(__name__)
+
 router = APIRouter()
 
 

solace_agent_mesh/gateway/http_sse/routers/visualization.py

@@ -2,6 +2,7 @@
 API Router for managing A2A message visualization streams.
 """
 
+import logging
 import asyncio
 import uuid
 from fastapi import (
@@ -15,7 +16,6 @@ from fastapi import (
 from pydantic import BaseModel, Field
 from typing import List, Optional, Dict, Any, Set
 
-from solace_ai_connector.common.log import log
 
 from ....gateway.http_sse.dependencies import (
     get_sac_component,
@@ -30,6 +30,7 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from ....gateway.http_sse.component import WebUIBackendComponent
 
+log = logging.getLogger(__name__)
 
 router = APIRouter()
 
@@ -133,26 +134,32 @@ from sse_starlette.sse import EventSourceResponse
 
 def _generate_sse_url(fastapi_request: FastAPIRequest, stream_id: str) -> str:
     """
-    Generate SSE endpoint URL with proper scheme detection for reverse proxy scenarios.
+    Generate SSE endpoint URL with proper scheme and host detection for reverse proxy scenarios.
 
     Args:
         fastapi_request: The FastAPI request object
         stream_id: The stream ID for the SSE endpoint
 
     Returns:
-        Complete SSE URL with correct scheme (http/https)
+        Complete SSE URL with correct scheme (http/https) and host.
     """
+    base_url = fastapi_request.url_for(
+        "get_visualization_stream_events", stream_id=stream_id
+    )
+
     forwarded_proto = fastapi_request.headers.get("x-forwarded-proto")
-    if forwarded_proto and forwarded_proto.lower() == "https":
-        scheme = "https"
+    forwarded_host = fastapi_request.headers.get("x-forwarded-host")
+
+    if forwarded_proto and forwarded_host:
+        # In a reverse proxy environment like GitHub Codespaces, reconstruct the URL
+        # using the forwarded headers to ensure it's publicly accessible.
+        return str(base_url.replace(scheme=forwarded_proto, netloc=forwarded_host))
+    elif forwarded_proto:
+        # Handle cases with only a forwarded protocol (standard reverse proxy)
+        return str(base_url.replace(scheme=forwarded_proto))
     else:
-        scheme = fastapi_request.url.scheme
-
-    return str(
-        fastapi_request.url_for(
-            "get_visualization_stream_events", stream_id=stream_id
-        ).replace(scheme=scheme)
-    )
+        # Default behavior when not behind a reverse proxy
+        return str(base_url)
 
 
 def _translate_target_to_solace_topics(

solace_agent_mesh/gateway/http_sse/services/agent_card_service.py

@@ -5,7 +5,9 @@ with the AgentRegistry.
 
 from typing import List, Optional
 
-from solace_ai_connector.common.log import log
+import logging
+
+log = logging.getLogger(__name__)
 
 from ....common.agent_registry import AgentRegistry
 from a2a.types import AgentCard

solace_agent_mesh/gateway/http_sse/services/data_retention_service.py

@@ -2,16 +2,17 @@
 Service for managing automatic cleanup of old data based on retention policies.
 """
 
+import logging
 import time
 from typing import Any, Callable, Dict
 
-from solace_ai_connector.common.log import log
 from sqlalchemy.orm import Session as DBSession
 
 from ..repository.feedback_repository import FeedbackRepository
 from ..repository.task_repository import TaskRepository
 from ..shared import now_epoch_ms
 
+log = logging.getLogger(__name__)
 
 class DataRetentionService:
     """
@@ -187,8 +188,8 @@ class DataRetentionService:
 
         db = self.session_factory()
         try:
-            repo = TaskRepository(db)
-            total_deleted = repo.delete_tasks_older_than(cutoff_time_ms, batch_size)
+            repo = TaskRepository()
+            total_deleted = repo.delete_tasks_older_than(db, cutoff_time_ms, batch_size)
 
             if total_deleted == 0:
                 log.info(
@@ -240,8 +241,8 @@ class DataRetentionService:
 
         db = self.session_factory()
         try:
-            repo = FeedbackRepository(db)
-            total_deleted = repo.delete_feedback_older_than(cutoff_time_ms, batch_size)
+            repo = FeedbackRepository()
+            total_deleted = repo.delete_feedback_older_than(db, cutoff_time_ms, batch_size)
 
             if total_deleted == 0:
                 log.info(

solace_agent_mesh/gateway/http_sse/services/feedback_service.py

@@ -3,10 +3,10 @@ Service layer for handling user feedback on chat messages.
 """
 
 import json
+import logging
 import uuid
 from typing import TYPE_CHECKING, Callable
 
-from solace_ai_connector.common.log import log
 from sqlalchemy.orm import Session as DBSession
 
 from ..repository.entities import Feedback
@@ -21,6 +21,7 @@ if TYPE_CHECKING:
     from ..component import WebUIBackendComponent
     from ..repository.interfaces import ITaskRepository
 
+log = logging.getLogger(__name__)
 
 class FeedbackService:
     """Handles the business logic for processing user feedback."""
@@ -70,8 +71,8 @@ class FeedbackService:
 
                 db = self.session_factory()
                 try:
-                    repo = FeedbackRepository(db)
-                    repo.save(feedback_entity)
+                    repo = FeedbackRepository()
+                    repo.save(db, feedback_entity)
                     db.commit()
                     log.info(
                         "Feedback from user '%s' for task '%s' saved to database.",
@@ -130,14 +131,14 @@ class FeedbackService:
         db = self.session_factory()
         try:
             from ..repository.chat_task_repository import ChatTaskRepository
-            
-            task_repo = ChatTaskRepository(db)
-            task = task_repo.find_by_id(task_id, user_id)
-            
+
+            task_repo = ChatTaskRepository()
+            task = task_repo.find_by_id(db, task_id, user_id)
+
             if task:
                 # Update feedback in task metadata
                 task.add_feedback(feedback_type, feedback_text)
-                task_repo.save(task)
+                task_repo.save(db, task)
                 db.commit()
                 log.info(
                     "Updated task metadata with feedback for task '%s' by user '%s'",
@@ -186,45 +187,53 @@ class FeedbackService:
 
         if include_task_info == "summary":
             log.debug("%s Including task summary.", log_id)
-            task_summary_data = self.task_repo.find_by_id(payload.task_id)
-            if task_summary_data:
-                event_payload["task_summary"] = task_summary_data.model_dump()
+            db = self.session_factory()
+            try:
+                task_summary_data = self.task_repo.find_by_id(db, payload.task_id)
+                if task_summary_data:
+                    event_payload["task_summary"] = task_summary_data.model_dump()
+            finally:
+                db.close()
 
         elif include_task_info == "stim":
             log.debug("%s Including task stim data.", log_id)
-            task_with_events = self.task_repo.find_by_id_with_events(payload.task_id)
-            if task_with_events:
-                task, events = task_with_events
-                stim_data = create_stim_from_task_data(task, events)
-                event_payload["task_stim_data"] = stim_data
-
-                # Check payload size
-                max_size = config.get("max_payload_size_bytes", 9000000)
-                try:
-                    payload_bytes = json.dumps(event_payload).encode("utf-8")
-                    if len(payload_bytes) > max_size:
-                        log.warning(
-                            "%s Stim payload size (%d bytes) exceeds limit (%d bytes). Falling back to summary.",
-                            log_id,
-                            len(payload_bytes),
-                            max_size,
-                        )
-                        # Fallback to summary
-                        del event_payload["task_stim_data"]
-                        task_summary_data = self.task_repo.find_by_id(payload.task_id)
-                        if task_summary_data:
-                            event_payload[
-                                "task_summary"
-                            ] = task_summary_data.model_dump()
-                        event_payload["truncation_details"] = {
-                            "strategy": "fallback_to_summary",
-                            "reason": "payload_too_large",
-                        }
-                except Exception as e:
-                    log.error("%s Error checking payload size: %s", log_id, e)
-                    # If we can't check size, better to not send a potentially huge message
-                    if "task_stim_data" in event_payload:
-                        del event_payload["task_stim_data"]
+            db = self.session_factory()
+            try:
+                task_with_events = self.task_repo.find_by_id_with_events(db, payload.task_id)
+                if task_with_events:
+                    task, events = task_with_events
+                    stim_data = create_stim_from_task_data(task, events)
+                    event_payload["task_stim_data"] = stim_data
+
+                    # Check payload size
+                    max_size = config.get("max_payload_size_bytes", 9000000)
+                    try:
+                        payload_bytes = json.dumps(event_payload).encode("utf-8")
+                        if len(payload_bytes) > max_size:
+                            log.warning(
+                                "%s Stim payload size (%d bytes) exceeds limit (%d bytes). Falling back to summary.",
+                                log_id,
+                                len(payload_bytes),
+                                max_size,
+                            )
+                            # Fallback to summary
+                            del event_payload["task_stim_data"]
+                            task_summary_data = self.task_repo.find_by_id(db, payload.task_id)
+                            if task_summary_data:
+                                event_payload[
+                                    "task_summary"
+                                ] = task_summary_data.model_dump()
+                            event_payload["truncation_details"] = {
+                                "strategy": "fallback_to_summary",
+                                "reason": "payload_too_large",
+                            }
+                    except Exception as e:
+                        log.error("%s Error checking payload size: %s", log_id, e)
+                        # If we can't check size, better to not send a potentially huge message
+                        if "task_stim_data" in event_payload:
+                            del event_payload["task_stim_data"]
+            finally:
+                db.close()
 
         # Publish the event
         topic = config.get("topic", "sam/feedback/v1")

solace_agent_mesh/gateway/http_sse/services/people_service.py

@@ -2,12 +2,12 @@
 Service layer for handling people-related operations, such as searching for users.
 """
 
+import logging
 from typing import Any, Dict, List, Optional
 
-from solace_ai_connector.common.log import log
-
 from ....common.services.identity_service import BaseIdentityService
 
+log = logging.getLogger(__name__)
 
 class PeopleService:
     """

solace_agent_mesh/gateway/http_sse/services/session_service.py

@@ -1,7 +1,7 @@
+import logging
 import uuid
 from typing import TYPE_CHECKING, Optional, List, Dict, Any
 
-from solace_ai_connector.common.log import log
 from sqlalchemy.orm import Session as DbSession
 
 from ..repository import (
@@ -15,6 +15,8 @@ from ..shared.types import SessionId, UserId
 from ..shared import now_epoch_ms
 from ..shared.pagination import PaginationParams, PaginatedResponse, get_pagination_or_default
 
+log = logging.getLogger(__name__)
+
 if TYPE_CHECKING:
     from ..component import WebUIBackendComponent
 
@@ -29,7 +31,7 @@ class SessionService:
     def _get_repositories(self, db: DbSession):
         """Create session repository for the given database session."""
         from ..repository import SessionRepository
-        session_repository = SessionRepository(db)
+        session_repository = SessionRepository()
         return session_repository
 
     def is_persistence_enabled(self) -> bool:
@@ -55,8 +57,8 @@ class SessionService:
         session_repository = self._get_repositories(db)
 
         # Pass pagination params directly - repository will handle offset calculation
-        sessions = session_repository.find_by_user(user_id, pagination)
-        total_count = session_repository.count_by_user(user_id)
+        sessions = session_repository.find_by_user(db, user_id, pagination)
+        total_count = session_repository.count_by_user(db, user_id)
 
         return PaginatedResponse.create(sessions, total_count, pagination)
 
@@ -67,7 +69,7 @@ class SessionService:
             return None
 
         session_repository = self._get_repositories(db)
-        return session_repository.find_user_session(session_id, user_id)
+        return session_repository.find_user_session(db, session_id, user_id)
 
     def create_session(
         self,
@@ -98,7 +100,7 @@ class SessionService:
         )
 
         session_repository = self._get_repositories(db)
-        created_session = session_repository.save(session)
+        created_session = session_repository.save(db, session)
         log.info("Created new session %s for user %s", created_session.id, user_id)
 
         if not created_session:
@@ -119,12 +121,12 @@ class SessionService:
             raise ValueError("Session name cannot exceed 255 characters")
 
         session_repository = self._get_repositories(db)
-        session = session_repository.find_user_session(session_id, user_id)
+        session = session_repository.find_user_session(db, session_id, user_id)
         if not session:
             return None
 
         session.update_name(name)
-        updated_session = session_repository.save(session)
+        updated_session = session_repository.save(db, session)
 
         log.info("Updated session %s name to '%s'", session_id, name)
         return updated_session
@@ -136,7 +138,7 @@ class SessionService:
             raise ValueError("Invalid session ID")
 
         session_repository = self._get_repositories(db)
-        session = session_repository.find_user_session(session_id, user_id)
+        session = session_repository.find_user_session(db, session_id, user_id)
         if not session:
             log.warning(
                 "Attempted to delete non-existent session %s by user %s",
@@ -153,7 +155,7 @@ class SessionService:
             )
             return False
 
-        deleted = session_repository.delete(session_id, user_id)
+        deleted = session_repository.delete(db, session_id, user_id)
         if not deleted:
             return False
 
@@ -194,10 +196,10 @@ class SessionService:
         """
         # Validate session exists and belongs to user
         session_repository = self._get_repositories(db)
-        session = session_repository.find_user_session(session_id, user_id)
+        session = session_repository.find_user_session(db, session_id, user_id)
         if not session:
             raise ValueError(f"Session {session_id} not found for user {user_id}")
-        
+
         # Create task entity - pass strings directly
         task = ChatTask(
             id=task_id,
@@ -209,14 +211,14 @@ class SessionService:
             created_time=now_epoch_ms(),
             updated_time=None
         )
-        
+
         # Save via repository
-        task_repo = ChatTaskRepository(db)
-        saved_task = task_repo.save(task)
-        
+        task_repo = ChatTaskRepository()
+        saved_task = task_repo.save(db, task)
+
         # Update session activity
         session.mark_activity()
-        session_repository.save(session)
+        session_repository.save(db, session)
         
         log.info(f"Saved task {task_id} for session {session_id}")
         return saved_task
@@ -243,13 +245,13 @@ class SessionService:
         """
         # Validate session exists and belongs to user
         session_repository = self._get_repositories(db)
-        session = session_repository.find_user_session(session_id, user_id)
+        session = session_repository.find_user_session(db, session_id, user_id)
         if not session:
             raise ValueError(f"Session {session_id} not found for user {user_id}")
-        
+
         # Load tasks
-        task_repo = ChatTaskRepository(db)
-        return task_repo.find_by_session(session_id, user_id)
+        task_repo = ChatTaskRepository()
+        return task_repo.find_by_session(db, session_id, user_id)
 
     def get_session_messages_from_tasks(
         self,

solace_agent_mesh/gateway/http_sse/services/task_logger_service.py

@@ -3,6 +3,7 @@ Service for logging A2A tasks and events to the database.
 """
 
 import copy
+import logging
 import uuid
 from typing import Any, Callable, Dict, Union
 
@@ -14,7 +15,6 @@ from a2a.types import (
     TaskArtifactUpdateEvent,
     TaskStatusUpdateEvent,
 )
-from solace_ai_connector.common.log import log
 from sqlalchemy.orm import Session as DBSession
 
 from ....common import a2a
@@ -22,6 +22,7 @@ from ..repository.entities import Task, TaskEvent
 from ..repository.task_repository import TaskRepository
 from ..shared import now_epoch_ms
 
+log = logging.getLogger(__name__)
 
 class TaskLoggerService:
     """Service for logging A2A tasks and events to the database."""
@@ -70,7 +71,7 @@ class TaskLoggerService:
 
         db = self.session_factory()
         try:
-            repo = TaskRepository(db)
+            repo = TaskRepository()
 
             # Infer details from the parsed event
             direction, task_id, user_id = self._infer_event_details(
@@ -94,7 +95,7 @@ class TaskLoggerService:
             sanitized_payload = self._sanitize_payload(payload)
 
             # Check for existing task or create a new one
-            task = repo.find_by_id(task_id)
+            task = repo.find_by_id(db, task_id)
             if not task:
                 if direction == "request":
                     initial_text = self._extract_initial_text(parsed_event)
@@ -106,7 +107,7 @@ class TaskLoggerService:
                             initial_text[:1024] if initial_text else None
                         ),  # Truncate
                     )
-                    repo.save_task(new_task)
+                    repo.save_task(db, new_task)
                     log.info(
                         f"{self.log_identifier} Created new task record for ID: {task_id}"
                     )
@@ -119,7 +120,7 @@ class TaskLoggerService:
                         start_time=now_epoch_ms(),
                         initial_request_text="[Task started before logger was active]",
                     )
-                    repo.save_task(placeholder_task)
+                    repo.save_task(db, placeholder_task)
                     log.info(
                         f"{self.log_identifier} Created placeholder task record for ID: {task_id}"
                     )
@@ -134,12 +135,12 @@ class TaskLoggerService:
                 direction=direction,
                 payload=sanitized_payload,
             )
-            repo.save_event(task_event)
+            repo.save_event(db, task_event)
 
             # If it's a final event, update the master task record
             final_status = self._get_final_status(parsed_event)
             if final_status:
-                task_to_update = repo.find_by_id(task_id)
+                task_to_update = repo.find_by_id(db, task_id)
                 if task_to_update:
                     task_to_update.end_time = now_epoch_ms()
                     task_to_update.status = final_status
@@ -158,8 +159,8 @@ class TaskLoggerService:
                                 f"output={token_usage.get('total_output_tokens')}, "
                                 f"cached={token_usage.get('total_cached_input_tokens')}"
                             )
-                    
-                    repo.save_task(task_to_update)
+
+                    repo.save_task(db, task_to_update)
                     log.info(
                         f"{self.log_identifier} Finalized task record for ID: {task_id} with status: {final_status}"
                     )