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

solace_agent_mesh/gateway/http_sse/repository/models/models_llm.txt

@@ -0,0 +1,266 @@
+## Quick Summary
+This directory contains SQLAlchemy ORM models and Pydantic schemas for database persistence in the HTTP SSE gateway. It provides models for managing chat sessions, messages, tasks, task events, and user feedback with proper relationships and database schema definitions.
+
+## Files Overview
+- `__init__.py` - Package initialization exposing all SQLAlchemy and Pydantic models
+- `base.py` - SQLAlchemy declarative base configuration
+- `feedback_model.py` - FeedbackModel for storing user feedback on tasks
+- `message_model.py` - MessageModel and Pydantic schemas for chat messages with session relationships
+- `session_model.py` - SessionModel and Pydantic schemas for managing chat sessions
+- `task_event_model.py` - TaskEventModel for storing A2A task events with task relationships
+- `task_model.py` - TaskModel for managing tasks with event relationships and token usage tracking
+
+## Developer API Reference
+
+### __init__.py
+**Purpose:** Package entry point that exposes all SQLAlchemy models and Pydantic schemas
+**Import:** `from solace_agent_mesh.gateway.http_sse.repository.models import Base, MessageModel, SessionModel, CreateMessageModel, UpdateMessageModel, CreateSessionModel, UpdateSessionModel, TaskEventModel, TaskModel, FeedbackModel`
+
+**Constants/Variables:**
+- `__all__: List[str]` - Public API exports including all models and schemas
+
+### base.py
+**Purpose:** Provides the SQLAlchemy declarative base for all models
+**Import:** `from solace_agent_mesh.gateway.http_sse.repository.models.base import Base`
+
+**Constants/Variables:**
+- `Base: DeclarativeMeta` - SQLAlchemy declarative base class for all models
+
+**Usage Examples:**
+```python
+from solace_agent_mesh.gateway.http_sse.repository.models.base import Base
+from sqlalchemy import create_engine
+
+# Create all tables
+engine = create_engine("sqlite:///example.db")
+Base.metadata.create_all(engine)
+```
+
+### feedback_model.py
+**Purpose:** SQLAlchemy model for storing user feedback on tasks
+**Import:** `from solace_agent_mesh.gateway.http_sse.repository.models.feedback_model import FeedbackModel`
+
+**Classes:**
+- `FeedbackModel(Base)` - SQLAlchemy model for user feedback
+  - `id: Column[String]` - Primary key feedback identifier
+  - `session_id: Column[String]` - Session identifier
+  - `task_id: Column[String]` - Task identifier (indexed)
+  - `user_id: Column[String]` - User identifier (indexed)
+  - `rating: Column[String]` - Feedback rating (e.g., 'up', 'down')
+  - `comment: Column[Text]` - Optional feedback comment
+  - `created_time: Column[BigInteger]` - Creation timestamp in epoch milliseconds
+
+**Usage Examples:**
+```python
+from solace_agent_mesh.gateway.http_sse.repository.models.feedback_model import FeedbackModel
+from sqlalchemy.orm import sessionmaker
+
+# Create feedback
+feedback = FeedbackModel(
+    id="feedback_123",
+    session_id="session_456",
+    task_id="task_789",
+    user_id="user_123",
+    rating="up",
+    comment="Great response!",
+    created_time=1640995200000
+)
+
+# Add to database
+Session = sessionmaker(bind=engine)
+db_session = Session()
+db_session.add(feedback)
+db_session.commit()
+```
+
+### message_model.py
+**Purpose:** SQLAlchemy model and Pydantic schemas for storing chat messages with session relationships
+**Import:** `from solace_agent_mesh.gateway.http_sse.repository.models.message_model import MessageModel, CreateMessageModel, UpdateMessageModel`
+
+**Classes:**
+- `MessageModel(Base)` - SQLAlchemy model for chat messages
+  - `id: Column[String]` - Primary key message identifier
+  - `session_id: Column[String]` - Foreign key to sessions table with CASCADE delete
+  - `message: Column[Text]` - Message content
+  - `created_time: Column[BigInteger]` - Creation timestamp (auto-generated)
+  - `sender_type: Column[String]` - Type of message sender (max 50 chars)
+  - `sender_name: Column[String]` - Name of message sender (max 255 chars)
+  - `session: relationship` - SQLAlchemy relationship to SessionModel
+
+- `CreateMessageModel(BaseModel)` - Pydantic model for creating messages
+  - `id: str` - Message identifier
+  - `session_id: str` - Session identifier
+  - `message: str` - Message content
+  - `sender_type: str` - Sender type
+  - `sender_name: str` - Sender name
+  - `created_time: int` - Creation timestamp
+
+- `UpdateMessageModel(BaseModel)` - Pydantic model for updating messages
+  - `message: str` - Updated message content
+  - `sender_type: str` - Updated sender type
+  - `sender_name: str` - Updated sender name
+
+**Usage Examples:**
+```python
+from solace_agent_mesh.gateway.http_sse.repository.models.message_model import MessageModel, CreateMessageModel
+from sqlalchemy.orm import sessionmaker
+
+# Create using SQLAlchemy model
+message = MessageModel(
+    id="msg_123",
+    session_id="session_456",
+    message="Hello, world!",
+    sender_type="user",
+    sender_name="John Doe"
+)
+
+# Create using Pydantic model
+create_data = CreateMessageModel(
+    id="msg_124",
+    session_id="session_456",
+    message="How are you?",
+    sender_type="user",
+    sender_name="John Doe",
+    created_time=1640995200000
+)
+```
+
+### session_model.py
+**Purpose:** SQLAlchemy model and Pydantic schemas for managing chat sessions with message relationships
+**Import:** `from solace_agent_mesh.gateway.http_sse.repository.models.session_model import SessionModel, CreateSessionModel, UpdateSessionModel`
+
+**Classes:**
+- `SessionModel(Base)` - SQLAlchemy model for chat sessions
+  - `id: Column[String]` - Primary key session identifier
+  - `name: Column[String]` - Optional session name
+  - `user_id: Column[String]` - Required user identifier
+  - `agent_id: Column[String]` - Optional agent identifier
+  - `created_time: Column[BigInteger]` - Creation timestamp (auto-generated)
+  - `updated_time: Column[BigInteger]` - Last update timestamp (auto-updated)
+  - `messages: relationship` - SQLAlchemy relationship to MessageModel with cascade delete
+
+- `CreateSessionModel(BaseModel)` - Pydantic model for creating sessions
+  - `id: str` - Session identifier
+  - `name: str | None` - Optional session name
+  - `user_id: str` - User identifier
+  - `agent_id: str | None` - Optional agent identifier
+  - `created_time: int` - Creation timestamp
+  - `updated_time: int` - Update timestamp
+
+- `UpdateSessionModel(BaseModel)` - Pydantic model for updating sessions
+  - `name: str | None` - Optional updated session name
+  - `agent_id: str | None` - Optional updated agent identifier
+  - `updated_time: int` - Update timestamp
+
+**Usage Examples:**
+```python
+from solace_agent_mesh.gateway.http_sse.repository.models.session_model import SessionModel, CreateSessionModel
+from sqlalchemy.orm import sessionmaker
+
+# Create using SQLAlchemy model
+session = SessionModel(
+    id="session_123",
+    name="My Chat Session",
+    user_id="user_456",
+    agent_id="agent_789"
+)
+
+# Create using Pydantic model
+create_data = CreateSessionModel(
+    id="session_124",
+    name="Another Session",
+    user_id="user_456",
+    agent_id="agent_789",
+    created_time=1640995200000,
+    updated_time=1640995200000
+)
+
+# Access related messages
+messages = session.messages  # Returns list of MessageModel instances
+```
+
+### task_event_model.py
+**Purpose:** SQLAlchemy model for storing A2A task events with task relationships
+**Import:** `from solace_agent_mesh.gateway.http_sse.repository.models.task_event_model import TaskEventModel`
+
+**Classes:**
+- `TaskEventModel(Base)` - SQLAlchemy model for A2A task events
+  - `id: Column[String]` - Primary key event identifier
+  - `task_id: Column[String]` - Foreign key to tasks table with CASCADE delete (indexed)
+  - `user_id: Column[String]` - Optional user identifier (indexed)
+  - `created_time: Column[BigInteger]` - Creation timestamp in epoch milliseconds
+  - `topic: Column[Text]` - Event topic
+  - `direction: Column[String]` - Event direction (max 50 chars)
+  - `payload: Column[JSON]` - Event payload as JSON
+  - `task: relationship` - SQLAlchemy relationship to TaskModel
+
+**Usage Examples:**
+```python
+from solace_agent_mesh.gateway.http_sse.repository.models.task_event_model import TaskEventModel
+from sqlalchemy.orm import sessionmaker
+
+# Create a task event
+event = TaskEventModel(
+    id="event_123",
+    task_id="task_456",
+    user_id="user_789",
+    created_time=1640995200000,
+    topic="agent/response",
+    direction="inbound",
+    payload={"message": "Task completed", "status": "success"}
+)
+
+# Add to database
+Session = sessionmaker(bind=engine)
+db_session = Session()
+db_session.add(event)
+db_session.commit()
+```
+
+### task_model.py
+**Purpose:** SQLAlchemy model for managing tasks with event relationships and token usage tracking
+**Import:** `from solace_agent_mesh.gateway.http_sse.repository.models.task_model import TaskModel`
+
+**Classes:**
+- `TaskModel(Base)` - SQLAlchemy model for tasks
+  - `id: Column[String]` - Primary key task identifier
+  - `user_id: Column[String]` - User identifier (indexed)
+  - `start_time: Column[BigInteger]` - Task start timestamp in epoch milliseconds
+  - `end_time: Column[BigInteger]` - Optional task end timestamp
+  - `status: Column[String]` - Optional task status
+  - `initial_request_text: Column[Text]` - Optional initial request text (indexed)
+  - `total_input_tokens: Column[Integer]` - Optional total input tokens used
+  - `total_output_tokens: Column[Integer]` - Optional total output tokens used
+  - `total_cached_input_tokens: Column[Integer]` - Optional total cached input tokens
+  - `token_usage_details: Column[JSON]` - Optional detailed token usage information
+  - `events: relationship` - SQLAlchemy relationship to TaskEventModel with cascade delete
+
+**Usage Examples:**
+```python
+from solace_agent_mesh.gateway.http_sse.repository.models.task_model import TaskModel
+from sqlalchemy.orm import sessionmaker
+
+# Create a new task with token tracking
+task = TaskModel(
+    id="task_123",
+    user_id="user_456",
+    start_time=1640995200000,
+    status="in_progress",
+    initial_request_text="Please help me with this task",
+    total_input_tokens=150,
+    total_output_tokens=300,
+    total_cached_input_tokens=50,
+    token_usage_details={"model": "gpt-4", "breakdown": {"reasoning": 200, "response": 100}}
+)
+
+# Add to database
+Session = sessionmaker(bind=engine)
+db_session = Session()
+db_session.add(task)
+db_session.commit()
+
+# Access related events
+events = task.events  # Returns list of TaskEventModel instances
+```
+
+# content_hash: 0583795702abeb023659a686bf3cfa551016bdd0284b01f2448dd9d4d2050f3b

solace_agent_mesh/gateway/http_sse/repository/models/session_model.py

@@ -24,9 +24,9 @@ class SessionModel(Base):
         BigInteger, nullable=False, default=now_epoch_ms, onupdate=now_epoch_ms
     )
 
-    # Relationship to messages
-    messages = relationship(
-        "MessageModel", back_populates="session", cascade="all, delete-orphan"
+    # Relationship to chat tasks
+    chat_tasks = relationship(
+        "ChatTaskModel", back_populates="session", cascade="all, delete-orphan"
     )
 
 

solace_agent_mesh/gateway/http_sse/repository/models/task_event_model.py

@@ -0,0 +1,25 @@
+"""
+Task Event SQLAlchemy model.
+"""
+
+from sqlalchemy import JSON, BigInteger, Column, ForeignKey, String, Text
+from sqlalchemy.orm import relationship
+
+from .base import Base
+
+
+class TaskEventModel(Base):
+    """SQLAlchemy model for A2A task events."""
+
+    __tablename__ = "task_events"
+
+    id = Column(String, primary_key=True)
+    task_id = Column(String, ForeignKey("tasks.id", ondelete="CASCADE"), index=True)
+    user_id = Column(String, nullable=True, index=True)
+    created_time = Column(BigInteger, nullable=False)
+    topic = Column(Text, nullable=False)
+    direction = Column(String(50), nullable=False)
+    payload = Column(JSON, nullable=False)
+
+    # Relationship to task
+    task = relationship("TaskModel", back_populates="events")

solace_agent_mesh/gateway/http_sse/repository/models/task_model.py

@@ -0,0 +1,32 @@
+"""
+Task SQLAlchemy model.
+"""
+
+from sqlalchemy import BigInteger, Column, Integer, JSON, String, Text
+from sqlalchemy.orm import relationship
+
+from .base import Base
+
+
+class TaskModel(Base):
+    """SQLAlchemy model for tasks."""
+
+    __tablename__ = "tasks"
+
+    id = Column(String, primary_key=True)
+    user_id = Column(String, nullable=False, index=True)
+    start_time = Column(BigInteger, nullable=False)
+    end_time = Column(BigInteger, nullable=True)
+    status = Column(String, nullable=True)
+    initial_request_text = Column(Text, nullable=True, index=True)
+    
+    # Token usage columns
+    total_input_tokens = Column(Integer, nullable=True)
+    total_output_tokens = Column(Integer, nullable=True)
+    total_cached_input_tokens = Column(Integer, nullable=True)
+    token_usage_details = Column(JSON, nullable=True)
+
+    # Relationship to events
+    events = relationship(
+        "TaskEventModel", back_populates="task", cascade="all, delete-orphan"
+    )

solace_agent_mesh/gateway/http_sse/repository/repository_llm.txt

@@ -0,0 +1,340 @@
+## Quick Summary
+
+The repository directory implements the data access layer for the HTTP SSE gateway using the Repository pattern. It provides a clean separation between domain entities and database persistence through SQLAlchemy ORM models. The architecture consists of abstract interfaces, concrete implementations, domain entities with business logic, and SQLAlchemy models for database operations. The two main subdirectories (entities and models) work together to provide a complete data persistence solution for chat sessions, messages, tasks, feedback, and events.
+
+## Files and Subdirectories Overview
+
+**Direct files:**
+- `__init__.py` - Main package exports for repository interfaces, implementations, entities, and models
+- `interfaces.py` - Abstract repository interfaces defining data access contracts for sessions, messages, tasks, and feedback
+- `message_repository.py` - SQLAlchemy implementation of message data access operations
+- `session_repository.py` - SQLAlchemy implementation of session data access operations
+- `feedback_repository.py` - SQLAlchemy implementation of feedback data access operations
+- `task_repository.py` - SQLAlchemy implementation of task data access operations
+
+**Subdirectories:**
+- `entities/` - Domain entities with business logic for sessions, messages, tasks, feedback, and events
+- `models/` - SQLAlchemy ORM models for database persistence and schema definition
+
+## Developer API Reference
+
+### Direct Files
+
+#### __init__.py
+**Purpose:** Central package exports for all repository components
+**Import:** `from solace_agent_mesh.gateway.http_sse.repository import IMessageRepository, ISessionRepository, MessageRepository, SessionRepository, Session, Message, SessionHistory, Base, MessageModel, SessionModel`
+
+**Exports:**
+- `IMessageRepository` - Message repository interface
+- `ISessionRepository` - Session repository interface  
+- `MessageRepository` - Message repository implementation
+- `SessionRepository` - Session repository implementation
+- `Message` - Message domain entity
+- `Session` - Session domain entity
+- `SessionHistory` - Session with messages composite entity
+- `Base` - SQLAlchemy declarative base
+- `MessageModel` - SQLAlchemy message model
+- `SessionModel` - SQLAlchemy session model
+
+#### interfaces.py
+**Purpose:** Defines abstract repository interfaces for data access contracts
+**Import:** `from solace_agent_mesh.gateway.http_sse.repository.interfaces import ISessionRepository, IMessageRepository, ITaskRepository, IFeedbackRepository`
+
+**Classes:**
+- `ISessionRepository(ABC)` - Abstract interface for session data operations
+  - `find_by_user(user_id: UserId, pagination: PaginationInfo | None = None) -> list[Session]` - Find all sessions for a user
+  - `count_by_user(user_id: UserId) -> int` - Count total sessions for a user
+  - `find_user_session(session_id: SessionId, user_id: UserId) -> Session | None` - Find specific user session
+  - `save(session: Session) -> Session` - Save or update a session
+  - `delete(session_id: SessionId, user_id: UserId) -> bool` - Delete user session
+  - `find_user_session_with_messages(session_id: SessionId, user_id: UserId, pagination: PaginationInfo | None = None) -> tuple[Session, list[Message]] | None` - Find session with messages
+
+- `IMessageRepository(ABC)` - Abstract interface for message data operations
+  - `find_by_session(session_id: SessionId, pagination: PaginationInfo | None = None) -> list[Message]` - Find messages in session
+  - `save(message: Message) -> Message` - Save or update a message
+  - `delete_by_session(session_id: SessionId) -> bool` - Delete all session messages
+
+- `ITaskRepository(ABC)` - Abstract interface for task data operations
+  - `save_task(task: Task) -> Task` - Create or update a task
+  - `save_event(event: TaskEvent) -> TaskEvent` - Save a task event
+  - `find_by_id(task_id: str) -> Task | None` - Find a task by its ID
+  - `find_by_id_with_events(task_id: str) -> tuple[Task, list[TaskEvent]] | None` - Find a task with all its events
+  - `search(user_id: UserId, start_date: int | None = None, end_date: int | None = None, search_query: str | None = None, pagination: PaginationParams | None = None) -> list[Task]` - Search for tasks with filters
+  - `delete_tasks_older_than(cutoff_time_ms: int, batch_size: int) -> int` - Delete tasks older than cutoff time
+
+- `IFeedbackRepository(ABC)` - Abstract interface for feedback data operations
+  - `save(feedback: Feedback) -> Feedback` - Save feedback
+  - `delete_feedback_older_than(cutoff_time_ms: int, batch_size: int) -> int` - Delete feedback older than cutoff time
+
+#### message_repository.py
+**Purpose:** SQLAlchemy implementation of message repository interface
+**Import:** `from solace_agent_mesh.gateway.http_sse.repository.message_repository import MessageRepository`
+
+**Classes:**
+- `MessageRepository(IMessageRepository)` - SQLAlchemy message repository implementation
+  - `__init__(db: DBSession)` - Initialize with database session
+  - `find_by_session(session_id: SessionId, pagination: PaginationInfo | None = None) -> list[Message]` - Find messages in session with pagination
+  - `save(message: Message) -> Message` - Save or update message in database
+  - `delete_by_session(session_id: SessionId) -> bool` - Delete all messages in session
+  - `_convert_model_to_entity(model: MessageModel) -> Message` - Convert SQLAlchemy model to domain entity
+
+#### session_repository.py
+**Purpose:** SQLAlchemy implementation of session repository interface
+**Import:** `from solace_agent_mesh.gateway.http_sse.repository.session_repository import SessionRepository`
+
+**Classes:**
+- `SessionRepository(ISessionRepository)` - SQLAlchemy session repository implementation
+  - `__init__(db: DBSession)` - Initialize with database session
+  - `find_by_user(user_id: UserId, pagination: PaginationInfo | None = None) -> list[Session]` - Find user sessions with pagination
+  - `count_by_user(user_id: UserId) -> int` - Count total sessions for a user
+  - `find_user_session(session_id: SessionId, user_id: UserId) -> Session | None` - Find specific user session
+  - `save(session: Session) -> Session` - Save or update session in database
+  - `delete(session_id: SessionId, user_id: UserId) -> bool` - Delete user session
+  - `find_user_session_with_messages(session_id: SessionId, user_id: UserId, pagination: PaginationInfo | None = None) -> tuple[Session, list[Message]] | None` - Find session with messages
+  - `_message_model_to_entity(model: MessageModel) -> Message` - Convert message model to entity
+
+#### feedback_repository.py
+**Purpose:** SQLAlchemy implementation of feedback repository interface
+**Import:** `from solace_agent_mesh.gateway.http_sse.repository.feedback_repository import FeedbackRepository`
+
+**Classes:**
+- `FeedbackRepository(IFeedbackRepository)` - SQLAlchemy feedback repository implementation
+  - `__init__(db: DBSession)` - Initialize with database session
+  - `save(feedback: Feedback) -> Feedback` - Save feedback to database
+  - `delete_feedback_older_than(cutoff_time_ms: int, batch_size: int) -> int` - Delete feedback older than cutoff time using batch deletion
+  - `_model_to_entity(model: FeedbackModel) -> Feedback` - Convert SQLAlchemy model to domain entity
+
+#### task_repository.py
+**Purpose:** SQLAlchemy implementation of task repository interface
+**Import:** `from solace_agent_mesh.gateway.http_sse.repository.task_repository import TaskRepository`
+
+**Classes:**
+- `TaskRepository(ITaskRepository)` - SQLAlchemy task repository implementation
+  - `__init__(db: DBSession)` - Initialize with database session
+  - `save_task(task: Task) -> Task` - Create or update a task
+  - `save_event(event: TaskEvent) -> TaskEvent` - Save a task event
+  - `find_by_id(task_id: str) -> Task | None` - Find a task by its ID
+  - `find_by_id_with_events(task_id: str) -> tuple[Task, list[TaskEvent]] | None` - Find a task with all its events
+  - `search(user_id: UserId, start_date: int | None = None, end_date: int | None = None, search_query: str | None = None, pagination: PaginationParams | None = None) -> list[Task]` - Search for tasks with filters
+  - `delete_tasks_older_than(cutoff_time_ms: int, batch_size: int) -> int` - Delete tasks older than cutoff time using batch deletion
+  - `_task_model_to_entity(model: TaskModel) -> Task` - Convert SQLAlchemy task model to domain entity
+  - `_event_model_to_entity(model: TaskEventModel) -> TaskEvent` - Convert SQLAlchemy event model to domain entity
+
+### Subdirectory APIs
+
+#### entities/
+**Purpose:** Provides domain entities with business logic for sessions, messages, tasks, feedback, and events
+**Key Exports:** Message, Session, SessionHistory, Task, TaskEvent, Feedback
+**Import Examples:**
+```python
+from solace_agent_mesh.gateway.http_sse.repository.entities import Message, Session, SessionHistory, Task, TaskEvent, Feedback
+```
+
+#### models/
+**Purpose:** Provides SQLAlchemy ORM models for database persistence and schema definition
+**Key Exports:** Base, MessageModel, SessionModel, TaskModel, TaskEventModel, FeedbackModel
+**Import Examples:**
+```python
+from solace_agent_mesh.gateway.http_sse.repository.models import Base, MessageModel, SessionModel, TaskModel, TaskEventModel, FeedbackModel
+```
+
+## Complete Usage Guide
+
+### 1. Setting Up the Repository Layer
+
+```python
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+from solace_agent_mesh.gateway.http_sse.repository import (
+    Base, MessageRepository, SessionRepository, TaskRepository, FeedbackRepository
+)
+
+# Create database engine and session
+engine = create_engine("sqlite:///chat.db")
+Base.metadata.create_all(engine)
+Session = sessionmaker(bind=engine)
+db_session = Session()
+
+# Initialize repositories
+message_repo = MessageRepository(db_session)
+session_repo = SessionRepository(db_session)
+task_repo = TaskRepository(db_session)
+feedback_repo = FeedbackRepository(db_session)
+```
+
+### 2. Working with Sessions
+
+```python
+from solace_agent_mesh.gateway.http_sse.repository.entities import Session
+from solace_agent_mesh.gateway.http_sse.shared.types import PaginationInfo
+import time
+
+# Create a new session
+session = Session(
+    id="session_123",
+    user_id="user_456",
+    name="Customer Support Chat",
+    agent_id="agent_789",
+    created_time=int(time.time() * 1000)
+)
+
+# Save session
+saved_session = session_repo.save(session)
+
+# Find user sessions with pagination
+pagination = PaginationInfo(page=1, page_size=10)
+user_sessions = session_repo.find_by_user("user_456", pagination)
+
+# Count total sessions for user
+total_sessions = session_repo.count_by_user("user_456")
+
+# Find specific session
+found_session = session_repo.find_user_session("session_123", "user_456")
+
+# Update session
+if found_session:
+    found_session.update_name("Updated Chat Name")
+    session_repo.save(found_session)
+```
+
+### 3. Working with Messages
+
+```python
+from solace_agent_mesh.gateway.http_sse.repository.entities import Message
+from solace_agent_mesh.gateway.http_sse.shared.enums import SenderType, MessageType
+
+# Create a new message
+message = Message(
+    id="msg_123",
+    session_id="session_123",
+    message="Hello, how can I help you today?",
+    sender_type=SenderType.AGENT,
+    sender_name="Support Agent",
+    message_type=MessageType.TEXT,
+    created_time=int(time.time() * 1000)
+)
+
+# Validate and save message
+message.validate_message_content()
+saved_message = message_repo.save(message)
+
+# Find messages in session
+session_messages = message_repo.find_by_session("session_123", pagination)
+
+# Check message properties
+if message.is_from_agent():
+    print("Message from agent")
+```
+
+### 4. Working with Tasks and Events
+
+```python
+from solace_agent_mesh.gateway.http_sse.repository.entities import Task, TaskEvent
+
+# Create a new task
+task = Task(
+    id="task_123",
+    user_id="user_456",
+    start_time=int(time.time() * 1000),
+    status="in_progress",
+    initial_request_text="Help me with my order"
+)
+
+# Save task
+saved_task = task_repo.save_task(task)
+
+# Create task event
+event = TaskEvent(
+    id="event_123",
+    task_id="task_123",
+    user_id="user_456",
+    created_time=int(time.time() * 1000),
+    topic="task.status.changed",
+    direction="outbound",
+    payload={"status": "completed", "result": "success"}
+)
+
+# Save event
+saved_event = task_repo.save_event(event)
+
+# Find task with events
+result = task_repo.find_by_id_with_events("task_123")
+if result:
+    task, events = result
+    print(f"Task {task.id} has {len(events)} events")
+
+# Search tasks
+from solace_agent_mesh.gateway.http_sse.shared.types import PaginationParams
+pagination_params = PaginationParams(page=1, page_size=10)
+tasks = task_repo.search(
+    user_id="user_456",
+    search_query="order",
+    pagination=pagination_params
+)
+```
+
+### 5. Working with Feedback
+
+```python
+from solace_agent_mesh.gateway.http_sse.repository.entities import Feedback
+
+# Create feedback
+feedback = Feedback(
+    id="feedback_123",
+    session_id="session_123",
+    task_id="task_123",
+    user_id="user_456",
+    rating="up",
+    comment="Great service!",
+    created_time=int(time.time() * 1000)
+)
+
+# Save feedback
+saved_feedback = feedback_repo.save(feedback)
+```
+
+### 6. Working with Session History (Combined Operations)
+
+```python
+from solace_agent_mesh.gateway.http_sse.repository.entities import SessionHistory
+
+# Get session with messages in one operation
+result = session_repo.find_user_session_with_messages(
+    "session_123", "user_456", pagination
+)
+
+if result:
+    session, messages = result
+    
+    # Create session history object
+    history = SessionHistory(
+        session=session,
+        messages=messages,
+        total_message_count=len(messages)
+    )
+    
+    print(f"Session: {history.session.name}")
+    print(f"Messages: {len(history.messages)}")
+```
+
+### 7. Using Repository Interfaces for Dependency Injection
+
+```python
+from solace_agent_mesh.gateway.http_sse.repository.interfaces import (
+    ISessionRepository, IMessageRepository, ITaskRepository, IFeedbackRepository
+)
+
+class ChatService:
+    def __init__(
+        self, 
+        session_repo: ISessionRepository,
+        message_repo: IMessageRepository,
+        task_repo: ITaskRepository,
+        feedback_repo: IFeedbackRepository
+    ):
+        self.session_repo = session_repo
+        self.message_repo = message_repo
+        self.task_repo = task_repo
+        self.feedback_
+
+# content_hash: e4e822acd625d1acce1f4ea0721844e7428a9b110c9e73b6657b8d3adc8ed038